Java ObservableList.addListener方法代码示例

import javafx.collections.ObservableList; //导入方法依赖的package包/类
/**
 * Pridá kolekci do registru
 *
 * @param items Kolekce, která se má přidat
 */
public void addColection(ObservableList<? extends DatabaseItem> items) {
    items.addListener((ListChangeListener<DatabaseItem>) c -> {
        while (c.next()) {
            if (c.wasAdded()) {
                this.registry.addAll(c.getAddedSubList());
            }
            if (c.wasRemoved()) {
                this.registry.removeAll(c.getRemoved());
            }
        }
    });
    for (DatabaseItem item : items) {
        this.registry.add(item);
    }
}
 

import javafx.collections.ObservableList; //导入方法依赖的package包/类
/**
 *
 * @param args
 */
public static void main(String[] args) {
    Logger log = LoggerFactory.getLogger(AppDemo.class);
    Initializer.getToolBox()
            .getEventBus()
            .toObserverable()
            .subscribe(e -> log.debug(e.toString()));
    App.main(args);

    ObservableList<Annotation> annotations = Initializer.getToolBox()
            .getData()
            .getAnnotations();

    annotations.addListener((InvalidationListener) observable ->
            log.debug("Annotation count: " + annotations.size()));
}
 

import javafx.collections.ObservableList; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
public FXThreadedObservableListWrapper(ObservableList<T> sourceList) {
	this.sourceList = sourceList;
	this.delegatedList = FXCollections.synchronizedObservableList(FXCollections.observableArrayList());
	Platform.runLater(() -> delegatedList.addAll(sourceList.toArray((T[])new Object[sourceList.size()])));
	sourceListListener = i -> Platform.runLater(() ->
		delegatedList.setAll(sourceList.toArray((T[])new Object[sourceList.size()])));
	sourceList.addListener(sourceListListener);
}
 

import javafx.collections.ObservableList; //导入方法依赖的package包/类
@SafeVarargs
public static <T> void mergeList(ObservableList<T> into, ObservableList<T>... lists) {
    final ObservableList<T> list = into;
    for (ObservableList<T> l : lists) {
        list.addAll(l);
        l.addListener((ListChangeListener<T>) c -> {
            while (c.next()) {
                if (c.wasAdded()) {
                    list.addAll(c.getAddedSubList());
                }
                if (c.wasRemoved()) {
                    list.removeAll(c.getRemoved());
                }
            }
        });
    }
}
 

import javafx.collections.ObservableList; //导入方法依赖的package包/类
public static <T, U> void bind(List<T> boundList, ObservableList<U> sourceList, Function<U, T> mapper) {
    ListSynchronizer<T, U> listener = new ListSynchronizer<>(boundList, mapper);
    sourceList.removeListener(listener);
    sourceList.addListener(listener);
    boundList.clear();
    boundList.addAll(map(sourceList, mapper));
}
 

import javafx.collections.ObservableList; //导入方法依赖的package包/类
public static void premain(final String args, Instrumentation instrumentation) throws Exception {
    instrumentation.addTransformer(new MenuItemTransformer());
    instrumentation.addTransformer(new FileChooserTransformer());
    logger.info("JavaVersion: " + System.getProperty("java.version"));
    final int port;
    if (args != null && args.trim().length() > 0) {
        port = Integer.parseInt(args.trim());
    } else {
        throw new Exception("Port number not specified");
    }
    windowTitle = System.getProperty("start.window.title", "");
    ObservableList<Stage> stages = StageHelper.getStages();
    stages.addListener(new ListChangeListener<Stage>() {
        boolean done = false;

        @Override public void onChanged(javafx.collections.ListChangeListener.Change<? extends Stage> c) {
            if (done) {
                return;
            }
            if (!"".equals(windowTitle)) {
                logger.warning("WindowTitle is not supported yet... Ignoring it.");
            }
            c.next();
            if (c.wasAdded()) {
                AccessController.doPrivileged(new PrivilegedAction<Object>() {
                    @Override public Object run() {
                        return new JavaFxRecorderHook(port);
                    }
                });
                done = true;
            }
        }
    });
}
 

import javafx.collections.ObservableList; //导入方法依赖的package包/类
public static <F, T> ObservableList<T> map(ObservableList<F> list, Function<F, T> forward, Function<T, F> backward) {
  ObservableList<T> newList = FXCollections.observableArrayList();
  newList.setAll(Lists.transform(list, forward::apply));

  MapToTargetListener<F, T> forwardListener = new MapToTargetListener<>(list, newList, forward);
  MapToTargetListener<T, F> backwardListener = new MapToTargetListener<>(newList, list, backward);
  forwardListener.updating.bindBidirectional(backwardListener.updating);

  list.addListener(forwardListener);
  newList.addListener(backwardListener);
  return newList;
}
 

import javafx.collections.ObservableList; //导入方法依赖的package包/类
@Test
public void testNestedRows() {
  ObservableList<SpecificationRow<StringProperty>> rows =
      FXCollections.observableList(
          Collections.singletonList(specRow),
          identityExtractor()
      );
  rows.addListener((Observable obs) -> listenerCalls++);

  assertEquals("listener calls before change", 0, listenerCalls);
  toBeChanged.set("XXX");
  assertEquals("listener calls after change", 1, listenerCalls);

  StringProperty toBeAddedChangedRemoved = new SimpleStringProperty("");

  rows.get(0).getCells().put("toBeAddedChangedRemoved", toBeAddedChangedRemoved);
  assertEquals("listener calls after adding", 2, listenerCalls);

  toBeAddedChangedRemoved.set("ASDF");
  assertEquals("listener calls after changing added", 3, listenerCalls);

  rows.get(0).getCells().remove("toBeAddedChangedRemoved");
  assertEquals("listener calls after removing", 4, listenerCalls);

  toBeAddedChangedRemoved.set("SHOULD NOT FIRE EVENT");
  assertEquals("listener calls after changing cell that was removed", 4, listenerCalls);
}
 

import javafx.collections.ObservableList; //导入方法依赖的package包/类
@SuppressWarnings("unchecked") // Yes, I know the cast below is unchecked
protected void setHiddenFieldChildren(ObservableList<TreeItem<T>> list) {
    try {
        Field childrenField = TreeItem.class.getDeclaredField("children"); //$NON-NLS-1$
        childrenField.setAccessible(true);
        childrenField.set(this, list);

        Field declaredField = TreeItem.class.getDeclaredField("childrenListener"); //$NON-NLS-1$
        declaredField.setAccessible(true);
        list.addListener((ListChangeListener<? super TreeItem<T>>) declaredField.get(this));
    } catch (NoSuchFieldException | SecurityException | IllegalArgumentException | IllegalAccessException e) {
        throw new RuntimeException("Could not set TreeItem.children", e); //$NON-NLS-1$
    }
}
 

import javafx.collections.ObservableList; //导入方法依赖的package包/类
@Test
public void addElementsTest()
{
    final ObservableList<Model> collection1 = FXCollections.observableArrayList(new Model("value1"),
                                                                                new Model("value2"),
                                                                                new Model("value3"),
                                                                                new Model("value4"));
    final ObservableList<String> collection2 = FXCollections.observableArrayList();

    IFXContentBinding.bind(collection2, collection1, Model::getText);

    final AtomicReference<ListChangeListener.Change<? extends String>> change = new AtomicReference<>(null);
    collection2.addListener((ListChangeListener<String>) c -> {
        change.set(c);
    });

    collection1.addAll(2, Arrays.asList(new Model("value2bis"), new Model("value2ter")));

    assertNotNull("Change event", change.get());
    assertTrue("Has change", change.get().next());
    assertTrue("Was added", change.get().wasAdded());
    assertFalse("Was removed", change.get().wasRemoved());
    assertFalse("Was update", change.get().wasUpdated());
    assertFalse("Was permuted", change.get().wasPermutated());
    assertEquals("from", 2, change.get().getFrom());
    assertEquals("to", 4, change.get().getTo());
    assertEquals("Added sub-list", Arrays.asList("value2bis", "value2ter"), change.get().getAddedSubList());
    assertFalse("Has more change", change.get().next());

    assertEquals(Arrays.asList("value1", "value2", "value2bis", "value2ter", "value3", "value4"), collection2);
}
 

import javafx.collections.ObservableList; //导入方法依赖的package包/类
@Test
public void removeElementsTest()
{
    final ObservableList<Model> collection1 = FXCollections.observableArrayList(new Model("value1"),
                                                                                new Model("value2"),
                                                                                new Model("value3"),
                                                                                new Model("value4"));
    final ObservableList<String> collection2 = FXCollections.observableArrayList();

    IFXContentBinding.bind(collection2, collection1, Model::getText);

    final AtomicReference<ListChangeListener.Change<? extends String>> change = new AtomicReference<>(null);
    collection2.addListener((ListChangeListener<String>) c -> {
        change.set(c);
    });

    collection1.subList(1, 3).clear();

    assertNotNull("Change event", change.get());
    assertTrue("Has change", change.get().next());
    assertFalse("Was added", change.get().wasAdded());
    assertTrue("Was removed", change.get().wasRemoved());
    assertFalse("Was update", change.get().wasUpdated());
    assertFalse("Was permuted", change.get().wasPermutated());
    assertEquals("from", 1, change.get().getFrom());
    assertEquals("to", 1, change.get().getTo());
    assertEquals("Removed", Arrays.asList("value2", "value3"), change.get().getRemoved());
    assertFalse("Has more change", change.get().next());

    assertEquals(Arrays.asList("value1", "value4"), collection2);
}
 

import javafx.collections.ObservableList; //导入方法依赖的package包/类
@Test
public void replaceElementsTest()
{
    final ObservableList<Model> collection1 = FXCollections.observableArrayList(new Model("value1"),
                                                                                new Model("value2"),
                                                                                new Model("value3"),
                                                                                new Model("value4"));
    final ObservableList<String> collection2 = FXCollections.observableArrayList();

    IFXContentBinding.bind(collection2, collection1, Model::getText);

    final AtomicReference<ListChangeListener.Change<? extends String>> change = new AtomicReference<>(null);
    collection2.addListener((ListChangeListener<String>) c -> {
        change.set(c);
    });

    collection1.set(1, new Model("value2bis"));

    assertNotNull("Change event", change.get());
    assertTrue("Has change", change.get().next());
    assertTrue("Was added", change.get().wasAdded());
    assertTrue("Was removed", change.get().wasRemoved());
    assertFalse("Was update", change.get().wasUpdated());
    assertFalse("Was permuted", change.get().wasPermutated());
    assertEquals("from", 1, change.get().getFrom());
    assertEquals("to", 2, change.get().getTo());
    assertEquals("Added sub-list", Arrays.asList("value2bis"), change.get().getAddedSubList());
    assertEquals("Removed", Arrays.asList("value2"), change.get().getRemoved());
    assertFalse("Has more change", change.get().next());

    assertEquals(Arrays.asList("value1", "value2bis", "value3", "value4"), collection2);
}
 

import javafx.collections.ObservableList; //导入方法依赖的package包/类
/**
 * Instantiates a new Timing diagram view.
 *
 * @param xaxis the x axis
 * @param yaxis the y axis
 */
public TimingDiagramView(NumberAxis xaxis, Axis<A> yaxis) {
  super(xaxis, yaxis);
  this.xaxis = xaxis;
  this.yaxis = yaxis;

  setPrefHeight(80);

  getPlotChildren().addAll(cycleSelectionPane, durationLinesPane, dataPane);
  ViewUtils.setupView(this);

  ObservableList<Series<Number, A>> seriesObservableList = FXCollections.observableArrayList();
  setData(seriesObservableList);
  seriesObservableList.addListener((InvalidationListener) change -> {
    Platform.runLater(TimingDiagramView.this::requestRelayout);
  });
}
 

import javafx.collections.ObservableList; //导入方法依赖的package包/类
@Test
public void updateElementsTest()
{
    final ObservableList<Model> collection1 = FXCollections.observableArrayList(m -> new ObservableValue[] {
            m.textProperty() });
    collection1.setAll(new Model("value1"), new Model("value2"), new Model("value3"), new Model("value4"));
    final ObservableList<String> collection2 = FXCollections.observableArrayList();

    IFXContentBinding.bind(collection2, collection1, Model::getText);

    final AtomicReference<ListChangeListener.Change<? extends String>> change = new AtomicReference<>(null);
    collection2.addListener((ListChangeListener<String>) c -> {
        change.set(c);
    });

    collection1.get(1).setText("value2bis");

    assertNotNull("Change event", change.get());
    assertTrue("Has change", change.get().next());
    assertTrue("Was added", change.get().wasAdded());
    assertTrue("Was removed", change.get().wasRemoved());
    assertFalse("Was update", change.get().wasUpdated());
    assertFalse("Was permuted", change.get().wasPermutated());
    assertEquals("from", 1, change.get().getFrom());
    assertEquals("to", 2, change.get().getTo());
    assertEquals("Added sub-list", Arrays.asList("value2bis"), change.get().getAddedSubList());
    assertEquals("Removed", Arrays.asList("value2"), change.get().getRemoved());
    assertFalse("Has more change", change.get().next());

    assertEquals(Arrays.asList("value1", "value2bis", "value3", "value4"), collection2);
}
 

import javafx.collections.ObservableList; //导入方法依赖的package包/类
public <T> void bindModified(ObservableList<T> list) {
  list.addListener((ListChangeListener<T>) c -> modified());
}