Merge pull request #5289 from r0light/ensurejavafxthreadexecution

Wrapper classes for UI Lists etc that ensure updates on JavaFX thread

src/main/java/org/jabref/gui/fieldeditors/LinkedFilesEditor.java

@@ -34,6 +34,7 @@
 import org.jabref.gui.keyboard.KeyBinding;
 import org.jabref.gui.util.TaskExecutor;
 import org.jabref.gui.util.ViewModelListCellFactory;
+import org.jabref.gui.util.uithreadaware.UiThreadObservableList;
 import org.jabref.logic.integrity.FieldCheckers;
 import org.jabref.logic.l10n.Localization;
 import org.jabref.model.database.BibDatabaseContext;
@@ -51,6 +52,7 @@ public class LinkedFilesEditor extends HBox implements FieldEditorFX {
 
  private final DialogService dialogService;
  private final BibDatabaseContext databaseContext;
+ private final UiThreadObservableList<LinkedFileViewModel> decoratedModelList;
 
  public LinkedFilesEditor(Field field, DialogService dialogService, BibDatabaseContext databaseContext, TaskExecutor taskExecutor, AutoCompleteSuggestionProvider<?> suggestionProvider,
  FieldCheckers fieldCheckers,
@@ -74,7 +76,8 @@ public LinkedFilesEditor(Field field, DialogService dialogService, BibDatabaseCo
 
  listView.setCellFactory(cellFactory);
 
- Bindings.bindContentBidirectional(listView.itemsProperty().get(), viewModel.filesProperty());
+ decoratedModelList = new UiThreadObservableList<>(viewModel.filesProperty());
+ Bindings.bindContentBidirectional(listView.itemsProperty().get(), decoratedModelList);
  setUpKeyBindings();
  }
 

src/main/java/org/jabref/gui/fieldeditors/PersonsEditor.java

@@ -7,6 +7,7 @@
 import org.jabref.gui.autocompleter.AutoCompleteSuggestionProvider;
 import org.jabref.gui.autocompleter.AutoCompletionTextInputBinding;
 import org.jabref.gui.fieldeditors.contextmenu.EditorMenus;
+import org.jabref.gui.util.uithreadaware.UiThreadStringProperty;
 import org.jabref.logic.integrity.FieldCheckers;
 import org.jabref.model.entry.BibEntry;
 import org.jabref.model.entry.field.Field;
@@ -16,6 +17,7 @@ public class PersonsEditor extends HBox implements FieldEditorFX {
 
  private final PersonsEditorViewModel viewModel;
  private final TextInputControl textInput;
+ private final UiThreadStringProperty decoratedStringProperty;
 
  public PersonsEditor(final Field field,
  final AutoCompleteSuggestionProvider<?> suggestionProvider,
@@ -28,7 +30,8 @@ public PersonsEditor(final Field field,
  ? new EditorTextField()
  : new EditorTextArea();
 
- textInput.textProperty().bindBidirectional(viewModel.textProperty());
+ decoratedStringProperty = new UiThreadStringProperty(viewModel.textProperty());
+ textInput.textProperty().bindBidirectional(decoratedStringProperty);
  ((ContextMenuAddable) textInput).addToContextMenu(EditorMenus.getNameMenu(textInput));
  this.getChildren().add(textInput);
 

src/main/java/org/jabref/gui/util/uithreadaware/UiThreadChangeListener.java

@@ -0,0 +1,28 @@
+package org.jabref.gui.util.uithreadaware;
+
+import javafx.beans.value.ChangeListener;
+import javafx.beans.value.ObservableValue;
+
+class UiThreadChangeListener<T> implements ChangeListener<T> {
+
+ private ChangeListener<T> delegate;
+
+ public UiThreadChangeListener(ChangeListener<T> delegate) {
+ this.delegate = delegate;
+ }
+
+ @Override
+ public void changed(ObservableValue<? extends T> observable, T oldValue, T newValue) {
+ UiThreadHelper.ensureUiThreadExecution(() -> delegate.changed(observable, oldValue, newValue));
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ return delegate.equals(o);
+ }
+
+ @Override
+ public int hashCode() {
+ return delegate.hashCode();
+ }
+}

src/main/java/org/jabref/gui/util/uithreadaware/UiThreadHelper.java

@@ -0,0 +1,14 @@
+package org.jabref.gui.util.uithreadaware;
+
+import javafx.application.Platform;
+
+class UiThreadHelper {
+
+ static void ensureUiThreadExecution(Runnable task) {
+ if (Platform.isFxApplicationThread()) {
+ task.run();
+ } else {
+ Platform.runLater(task);
+ }
+ }
+}

src/main/java/org/jabref/gui/util/uithreadaware/UiThreadInvalidationListener.java

@@ -0,0 +1,28 @@
+package org.jabref.gui.util.uithreadaware;
+
+import javafx.beans.InvalidationListener;
+import javafx.beans.Observable;
+
+class UiThreadInvalidationListener implements InvalidationListener {
+
+ private final InvalidationListener delegate;
+
+ public UiThreadInvalidationListener(InvalidationListener delegate) {
+ this.delegate = delegate;
+ }
+
+ @Override
+ public void invalidated(Observable observable) {
+ UiThreadHelper.ensureUiThreadExecution(() -> delegate.invalidated(observable));
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ return delegate.equals(o);
+ }
+
+ @Override
+ public int hashCode() {
+ return delegate.hashCode();
+ }
+}

src/main/java/org/jabref/gui/util/uithreadaware/UiThreadListChangeListener.java

@@ -0,0 +1,27 @@
+package org.jabref.gui.util.uithreadaware;
+
+import javafx.collections.ListChangeListener;
+
+class UiThreadListChangeListener<E> implements ListChangeListener<E> {
+
+ private final ListChangeListener<E> delegate;
+
+ public UiThreadListChangeListener(ListChangeListener<E> delegate) {
+ this.delegate = delegate;
+ }
+
+ @Override
+ public void onChanged(Change<? extends E> c) {
+ UiThreadHelper.ensureUiThreadExecution(() -> delegate.onChanged(c));
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ return delegate.equals(o);
+ }
+
+ @Override
+ public int hashCode() {
+ return delegate.hashCode();
+ }
+}

src/main/java/org/jabref/gui/util/uithreadaware/UiThreadObservableList.java

@@ -0,0 +1,189 @@
+package org.jabref.gui.util.uithreadaware;
+
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+
+import javafx.beans.InvalidationListener;
+import javafx.collections.ListChangeListener;
+import javafx.collections.ObservableList;
+
+/**
+ * This class can be used to wrap an @see ObservableList inside it. When wrapped, any Listener listening for updates to the wrapped ObservableList (for example because of a binding to it) is ensured to be notified on the JavaFX Application Thread. It should be used to implement bindings where updates come in from a background thread but should be reflected in the UI where it is necessary that changes to the UI are performed on the JavaFX Application thread.
+ *
+ * @param <E> the type of the elements of the wrapped ObservableList.
+ */
+public class UiThreadObservableList<E> implements ObservableList<E> {
+
+ private final ObservableList<E> delegate;
+
+ public UiThreadObservableList(ObservableList<E> delegate) {
+ this.delegate = delegate;
+ }
+
+ @Override
+ public void addListener(ListChangeListener<? super E> listener) {
+ delegate.addListener(new UiThreadListChangeListener(listener));
+ }
+
+ @Override
+ public void removeListener(ListChangeListener<? super E> listener) {
+ delegate.removeListener(listener);
+ }
+
+ @Override
+ public boolean addAll(E... elements) {
+ return delegate.addAll(elements);
+ }
+
+ @Override
+ public boolean setAll(E... elements) {
+ return delegate.setAll(elements);
+ }
+
+ @Override
+ public boolean setAll(Collection<? extends E> col) {
+ return delegate.setAll(col);
+ }
+
+ @Override
+ public boolean removeAll(E... elements) {
+ return delegate.removeAll(elements);
+ }
+
+ @Override
+ public boolean retainAll(E... elements) {
+ return delegate.retainAll(elements);
+ }
+
+ @Override
+ public void remove(int from, int to) {
+ delegate.remove(from, to);
+ }
+
+ @Override
+ public int size() {
+ return delegate.size();
+ }
+
+ @Override
+ public boolean isEmpty() {
+ return delegate.isEmpty();
+ }
+
+ @Override
+ public boolean contains(Object o) {
+ return delegate.contains(o);
+ }
+
+ @Override
+ public Iterator<E> iterator() {
+ return delegate.iterator();
+ }
+
+ @Override
+ public Object[] toArray() {
+ return delegate.toArray();
+ }
+
+ @Override
+ public <T> T[] toArray(T[] a) {
+ return delegate.toArray(a);
+ }
+
+ @Override
+ public boolean add(E e) {
+ return delegate.add(e);
+ }
+
+ @Override
+ public boolean remove(Object o) {
+ return delegate.remove(o);
+ }
+
+ @Override
+ public boolean containsAll(Collection<?> c) {
+ return delegate.containsAll(c);
+ }
+
+ @Override
+ public boolean addAll(Collection<? extends E> c) {
+ return delegate.addAll(c);
+ }
+
+ @Override
+ public boolean addAll(int index, Collection<? extends E> c) {
+ return delegate.addAll(index, c);
+ }
+
+ @Override
+ public boolean removeAll(Collection<?> c) {
+ return delegate.removeAll(c);
+ }
+
+ @Override
+ public boolean retainAll(Collection<?> c) {
+ return delegate.retainAll(c);
+ }
+
+ @Override
+ public void clear() {
+ delegate.clear();
+ }
+
+ @Override
+ public E get(int index) {
+ return delegate.get(index);
+ }
+
+ @Override
+ public E set(int index, E element) {
+ return delegate.set(index, element);
+ }
+
+ @Override
+ public void add(int index, E element) {
+ delegate.add(index, element);
+ }
+
+ @Override
+ public E remove(int index) {
+ return delegate.remove(index);
+ }
+
+ @Override
+ public int indexOf(Object o) {
+ return delegate.indexOf(o);
+ }
+
+ @Override
+ public int lastIndexOf(Object o) {
+ return delegate.lastIndexOf(o);
+ }
+
+ @Override
+ public ListIterator<E> listIterator() {
+ return delegate.listIterator();
+ }
+
+ @Override
+ public ListIterator<E> listIterator(int index) {
+ return delegate.listIterator(index);
+ }
+
+ @Override
+ public List<E> subList(int fromIndex, int toIndex) {
+ return delegate.subList(fromIndex, toIndex);
+ }
+
+ @Override
+ public void addListener(InvalidationListener listener) {
+ delegate.addListener(new UiThreadInvalidationListener(listener));
+ }
+
+ @Override
+ public void removeListener(InvalidationListener listener) {
+ delegate.removeListener(listener);
+ }
+}