@Override public void initialize(URL location, ResourceBundle resources) { languageChoiceBox.getItems().addAll(DesignerUtil.getSupportedLanguageVersions() .stream() .map(LanguageVersion::getLanguage) .distinct() .collect(Collectors.toList())); languageChoiceBox.setConverter(new StringConverter<Language>() { @Override public String toString(Language object) { return object.getTerseName(); } @Override public Language fromString(String string) { return LanguageRegistry.findLanguageByTerseName(string); } }); languageChoiceBox.getSelectionModel().select(LanguageRegistry.getDefaultLanguage()); exportResultArea.setSyntaxHighlighter(new XmlSyntaxHighlighter()); registerListener(nameField.textProperty(), updateResultListener()); registerListener(messageField.textProperty(), updateResultListener()); registerListener(descriptionField.textProperty(), updateResultListener()); registerListener(prioritySlider.valueProperty(), updateResultListener()); registerListener(languageChoiceBox.getSelectionModel().selectedItemProperty(), updateResultListener()); registerListener(xpathExpression, updateResultListener()); updateResultListener().changed(null, null, null); }
@Test public void listeners() { ObservableAtomicReference<String> victim = new ObservableAtomicReference<>("Initial"); ChangeListener<String> listener = mock(ChangeListener.class); InvalidationListener invalidationListener = mock(InvalidationListener.class); victim.addListener(listener); victim.addListener(invalidationListener); victim.set("newVal"); assertEquals("newVal", victim.getValue()); verify(listener).changed(any(), eq("Initial"), eq("newVal")); verify(invalidationListener).invalidated(victim); } }
@Override public void changed(ObservableValue<? extends P> target, P oldTarget, P newTarget) { for (ChangeListener<? super P> listener : changeListeners) { listener.changed(target, oldTarget, newTarget); } } };
private void fireRangeChange(long oldValue, long newValue) { if (changeListener != null) { changeListener.changed(null, oldValue, newValue); } }
@Override public void changed(ObservableValue<? extends P> target, P oldTarget, P newTarget) { for (ChangeListener<? super P> listener : changeListeners) { listener.changed(target, oldTarget, newTarget); } } };
@Override public void changed(final ObservableValue<? extends T> observable, final T oldValue, final T newValue) { delegate.changed(observable, oldValue, newValue); }
@Override public void changed(ObservableValue<? extends T> observable, T oldValue, T newValue) { if (m_alreadyCalled) { return; } try { m_alreadyCalled = true; m_updateProperty.changed(observable, oldValue, newValue); } finally { m_alreadyCalled = false; } } }
@Override public void changed(ObservableValue obs, Object oldVal, Object newVal) { getValue(); if(!changeListeners.isEmpty()) { ChangeListener[] l = changeListeners.toArray(new ChangeListener[changeListeners.size()]); for(int i = 0; i < l.length; i++) { l[i].changed(this, oldValue, newValue); } } }
private void fireChanged() { valueDirty = true; update(); ChangeListener[] cListeners = changeListeners.toArray(new ChangeListener[changeListeners.size()]); for(int i = 0; i < cListeners.length; i++) { cListeners[i].changed(this, oldValue, newValue); } } private void fireInvalidated() {
@SuppressWarnings("unchecked") @Override public void handleValueChange(ValueChangeEvent event) { for (ChangeListener<? super E> l : WrappedValue.this.fxChangeListeners .toArray(new ChangeListener[0])) { l.changed(WrappedValue.this, (E) event.diff.getOldValue(), (E) event.diff.getNewValue()); } } };
/** * Registers the given change listeners to the corresponding property. * Avoids reoccurring events by wrapping the change listener. * <p> * <u>Beware that the order matters:</u><br> * this method copies the value from propertyA to propertyB initially by calling updateB! * * @param updateFromAtoB is called when A has changed and should update property B * @param updateFromBToA is called when B has changed and should update property A */ public static <A, B> void bindBidirectional(@Nonnull ObservableValue<A> propertyA, @Nonnull ObservableValue<B> propertyB, @Nonnull ChangeListener<A> updateFromAtoB, @Nonnull ChangeListener<B> updateFromBToA) { propertyA.addListener(new FlaggedChangeListener<>(updateFromAtoB)); propertyB.addListener(new FlaggedChangeListener<>(updateFromBToA)); //Initially update property B updateFromAtoB.changed(propertyA, null, propertyA.getValue()); }
/** * Adds a listener to the specified property so that changes to it are * reflected down to the source map. * * @param <T> the type of the property * @param key the key of the property * @param property the property to listen to * @param initialValue the initial value of this property * @return the same property but with listener attached */ private <T> Property<T> prepare(String key, Property<T> property, T initialValue) { final ChangeListener<T> change = (ob, oldValue, newValue) -> { if (newValue != null) { config.put(key, newValue); } else { config.remove(key); } invalidate(); }; property.setValue(initialValue); property.addListener(change); change.changed(property, null, initialValue); return property; }
private void notifyListeners(boolean value) { ListHelper.forEach(iListeners, l -> l.invalidated(this)); ListHelper.forEach(cListeners, l -> l.changed(this, !value, value)); }
public void afterChange(T newSource, P oldValue) { targetProperty = newSource != null ? targetPropertyGetter.getProperty(newSource) : null; P newValue = targetProperty != null ? targetProperty.getValue() : null; if (targetProperty != null) { targetProperty.addListener(targetChangeListener); targetProperty.addListener(targetInvalidationListener); if (newValue != oldValue) { targetInvalidationListener.invalidated(ChainedProperty.this); targetChangeListener.changed(ChainedProperty.this, oldValue, newValue); } } }
public void afterChange(T newSource, P oldValue) { if (newSource != null) targetObservableValue = targetObservableValueGetter.getObservableValue(newSource); P newValue = targetObservableValue != null ? targetObservableValue.getValue() : null; if (targetObservableValue != null) { targetObservableValue.addListener(targetChangeListener); targetObservableValue.addListener(targetInvalidationListener); } if (newValue != oldValue) { targetInvalidationListener.invalidated(ChainedObservableValue.this); targetChangeListener.changed(ChainedObservableValue.this, oldValue, newValue); } }
/******************************************************************************************************************* * ******************************************************************************************************************/ @Test public void treeItemChangeListener_must_callback_a_Selectable_on_selection_change() throws InterruptedException { // given final Selectable selectable = mock(Selectable.class); final Object datum = new Object(); final PresentationModel oldPm = new DefaultPresentationModel(datum, selectable); final PresentationModel pm = new DefaultPresentationModel(datum, selectable); // when fixture.treeItemChangeListener.changed(null, new TreeItem<>(oldPm), new TreeItem<>(pm)); // then executor.shutdown(); executor.awaitTermination(5, TimeUnit.SECONDS); verify(selectable, times(1)).select(); verifyNoMoreInteractions(selectable); }
/******************************************************************************************************************* * ******************************************************************************************************************/ @Test public void treeItemChangeListener_must_callback_a_Selectable_on_selection_change() throws InterruptedException { // given final Selectable selectable = mock(Selectable.class); final Object datum = new Object(); final PresentationModel oldPm = new DefaultPresentationModel(datum, selectable); final PresentationModel pm = new DefaultPresentationModel(datum, selectable); // when fixture.treeItemChangeListener.changed(null, new TreeItem<>(oldPm), new TreeItem<>(pm)); // then executor.shutdown(); executor.awaitTermination(5, TimeUnit.SECONDS); verify(selectable, times(1)).select(); verifyNoMoreInteractions(selectable); }
/******************************************************************************************************************* * ******************************************************************************************************************/ @Test public void treeItemChangeListener_must_do_nothing_when_there_is_no_Selectable_role() { // given final Object datum = new Object(); final PresentationModel oldPm = new DefaultPresentationModel(datum); final PresentationModel pm = new DefaultPresentationModel(datum); // when fixture.treeItemChangeListener.changed(null, new TreeItem<>(oldPm), new TreeItem<>(pm)); // then // no exceptions are thrown } }
/******************************************************************************************************************* * ******************************************************************************************************************/ @Test public void treeItemChangeListener_must_do_nothing_when_there_is_no_Selectable_role() { // given final Object datum = new Object(); final PresentationModel oldPm = new DefaultPresentationModel(datum); final PresentationModel pm = new DefaultPresentationModel(datum); // when fixture.treeItemChangeListener.changed(null, new TreeItem<>(oldPm), new TreeItem<>(pm)); // then // no exceptions are thrown } }