javafx.collections.MapChangeListener Java Examples

public static <K, V> Val<Map<K, V>> observableMapVal(ObservableMap<K, V> map) {
    return new ValBase<Map<K, V>>() {

        @Override
        protected Subscription connect() {
            MapChangeListener<K, V> listener = ch -> notifyObservers(new HashMap<>(map));
            map.addListener(listener);
            return () -> map.removeListener(listener);
        }

        @Override
        protected Map<K, V> computeValue() {
            return new HashMap<>(map);
        }
    };
}
 

/**
 * {@inheritDoc}
 */
@Override
public final void setupValueChangedListeners() {
  overlays.addListener((MapChangeListener<Region, WorkbenchOverlay>) c -> {
    LOGGER.trace("Listener overlays fired");
    if (c.wasAdded()) {
      LOGGER.trace("Overlay added");
      addOverlay(c.getValueAdded());
    } else if (c.wasRemoved()) {
      LOGGER.trace("Overlay removed");
      removeOverlay(c.getValueRemoved());
    }
  });

  WorkbenchUtils.addListListener(
      overlaysShown,
      change -> showOverlay(change, false),
      this::hideOverlay
  );

  WorkbenchUtils.addListListener(
      blockingOverlaysShown,
      change -> showOverlay(change, true),
      this::hideOverlay
  );
}
 

@Override
public void onChanged(final MapChangeListener.Change<? extends Object, ? extends Object> change) {
    final ObservableMap<?, ?> map = change.getMap();
    if (disabledFor.containsKey(map)) {
        return;
    }
    try {
        final UUID mapId = objectRegistry.getIdOrFail(map);
        final Object key = change.getKey();
        if (change.wasAdded()) {
            final Object value = change.getValueAdded();
            final List<Command> commands = creator.putToMap(mapId, key, value);
            registerListenersOnEverything(key);
            if (value != null) {
                registerListenersOnEverything(value);
            }
            distributeCommands(commands);
        } else {
            distributeCommands(creator.removeFromMap(mapId, key));
        }
    } catch (final SynchronizeFXException e) {
        topology.onError(e);
    }
}
 

public NewBadge(Node control, String key, Preferences preferences) {
    super(control);

    this.key = key;

    setText(Res.get("shared.new"));
    getStyleClass().add("new");

    setEnabled(!preferences.getDontShowAgainMap().containsKey(key));
    refreshBadge();

    preferences.getDontShowAgainMapAsObservable().addListener((MapChangeListener<? super String, ? super Boolean>) change -> {
        if (change.getKey().equals(key)) {
            setEnabled(!change.wasAdded());
            refreshBadge();
        }
    });
}
 

private void registerListeners() {
    widthProperty().addListener(o -> resize());
    heightProperty().addListener(o -> resize());
    sceneProperty().addListener(o -> {
        if (!locations.isEmpty()) { addShapesToScene(locations.values()); }
        if (isZoomEnabled()) { getScene().addEventFilter( ScrollEvent.ANY, new WeakEventHandler<>(_scrollEventHandler)); }

        locations.addListener((MapChangeListener<Location, Shape>) CHANGE -> {
            if (CHANGE.wasAdded()) {
                addShapesToScene(CHANGE.getValueAdded());
            } else if(CHANGE.wasRemoved()) {
                Platform.runLater(() -> pane.getChildren().remove(CHANGE.getValueRemoved()));
            }
        });
    });
}
 

private void registerListeners() {
    widthProperty().addListener(o -> resize());
    heightProperty().addListener(o -> resize());
    sceneProperty().addListener(o -> {
        if (!locations.isEmpty()) { addShapesToScene(locations.values()); }
        if (isZoomEnabled()) { getScene().addEventFilter( ScrollEvent.ANY, new WeakEventHandler<>(_scrollEventHandler)); }

        locations.addListener((MapChangeListener<Location, Shape>) CHANGE -> {
            if (CHANGE.wasAdded()) {
                addShapesToScene(CHANGE.getValueAdded());
            } else if(CHANGE.wasRemoved()) {
                Platform.runLater(() -> pane.getChildren().remove(CHANGE.getValueRemoved()));
            }
        });
    });
}
 

@Inject
public DaoPresentation(Preferences preferences,
                       BtcWalletService btcWalletService,
                       BsqWalletService bsqWalletService,
                       DaoStateService daoStateService,
                       DaoFacade daoFacade) {
    this.preferences = preferences;
    this.btcWalletService = btcWalletService;
    this.bsqWalletService = bsqWalletService;
    this.daoFacade = daoFacade;
    this.daoStateService = daoStateService;

    preferences.getDontShowAgainMapAsObservable().addListener((MapChangeListener<? super String, ? super Boolean>) change -> {
        if (change.getKey().equals(DAO_NEWS) && DevEnv.isDaoActivated()) {
            showNotification.set(!change.wasAdded());
        }
    });

    if (!DevEnv.isDaoActivated()) {
        bsqInfo.set("");
        bsqSyncProgress.set(0);
    }

    walletChainHeightListener = (observable, oldValue, newValue) -> onUpdateAnyChainHeight();
}
 

/**
 * Creates a position change listener (PCL) which {@link #refresh()
 * refreshes} this {@link Connection} upon anchor position changes
 * corresponding to the given {@link AnchorKey}.
 *
 * @param anchorKey
 *            The {@link AnchorKey} for which a position change will trigger
 *            a {@link #refresh()} with the returned PCL.
 * @return A position change listener to {@link #refresh() refresh} this
 *         {@link Connection} when the position for the given
 *         {@link AnchorKey} changes.
 */
protected MapChangeListener<? super AnchorKey, ? super Point> createPCL(
		final AnchorKey anchorKey) {
	return new MapChangeListener<AnchorKey, Point>() {
		@Override
		public void onChanged(
				MapChangeListener.Change<? extends AnchorKey, ? extends Point> change) {
			// if (inRefresh) {
			// return;
			// }
			if (change.getKey().equals(anchorKey)) {
				if (change.wasAdded() && change.wasRemoved()) {
					Point newPoint = FX2Geometry
							.toPoint(getCurve().localToParent(Geometry2FX
									.toFXPoint(change.getValueAdded())));
					if (!points.get(getAnchorIndex(anchorKey))
							.equals(newPoint)) {
						points.set(getAnchorIndex(anchorKey), newPoint);
						refresh();
					}
				}
			}
		}
	};
}
 

/**
 * Notifies the attached {@link MapChangeListener}s about the related
 * change.
 *
 * @param change
 *            The applied change.
 */
protected void notifyMapChangeListeners(
		Change<? extends K, ? extends V> change) {
	if (mapChangeListeners != null && !mapChangeListeners.isEmpty()) {
		// if (lockMapChangeListeners) {
		// throw new IllegalStateException("Re-entrant map change!");
		// }
		try {
			lockMapChangeListeners = true;
			for (MapChangeListener<? super K, ? super V> l : mapChangeListeners) {
				try {
					l.onChanged(change);
				} catch (Exception e) {
					// System.out.println("Exception in listener: " +
					// e.getMessage() + ", cause=" + e.getCause());
					Thread.currentThread().getUncaughtExceptionHandler()
							.uncaughtException(Thread.currentThread(), e);
				}
			}
		} finally {
			lockMapChangeListeners = false;
		}
	}
}
 

public ObservableMapValues(ObservableList<T> internalStore, ObservableMap<?, T> referencedMap) {
    this.internalStore = internalStore;
    this.referencedMap = referencedMap;

    referencedMap.addListener((MapChangeListener<Object, T>) change -> {
        if (change.wasAdded()) {
            internalStore.add(change.getValueAdded());
        }
        if (change.wasRemoved()) {
            internalStore.remove(change.getValueRemoved());
        }
    });
}
 

/**
 * Adds a new {@link MapChangeListener} to this {@link MapListenerHelperEx}.
 * If the same listener is added more than once, it will be registered more
 * than once and will receive multiple change events.
 *
 * @param listener
 *            The listener to add.
 */
public void addListener(MapChangeListener<? super K, ? super V> listener) {
	if (mapChangeListeners == null) {
		mapChangeListeners = new ArrayList<>();
	}
	// XXX: Prevent ConcurrentModificationExceptions (in case listeners are
	// added during notifications); as we only create a new multi-set in the
	// locked case, memory should not be waisted.
	if (lockMapChangeListeners) {
		mapChangeListeners = new ArrayList<>(mapChangeListeners);
	}
	mapChangeListeners.add(listener);
}
 

/**
 * Notifies all attached {@link InvalidationListener}s and
 * {@link MapChangeListener}s about the change.
 *
 * @param change
 *            The change to notify listeners about.
 */
public void fireValueChangedEvent(
		MapChangeListener.Change<? extends K, ? extends V> change) {
	notifyInvalidationListeners();
	if (change != null) {
		notifyMapChangeListeners(change);
	}
}
 

/**
 * Removes the given {@link MapChangeListener} from this
 * {@link MapListenerHelperEx}. If its was registered more than once,
 * removes one occurrence.
 *
 * @param listener
 *            The listener to remove.
 */
public void removeListener(
		MapChangeListener<? super K, ? super V> listener) {
	if (mapChangeListeners == null) {
		return;
	}

	// XXX: Prevent ConcurrentModificationExceptions (in case listeners are
	// added during notifications); as we only create a new multi-set in the
	// locked case, memory should not be waisted.
	if (lockMapChangeListeners) {
		mapChangeListeners = new ArrayList<>(mapChangeListeners);
	}
	// XXX: We have to ignore the hash code when removing listeners, as
	// otherwise unbinding will be broken (JavaFX bindings violate the
	// contract between equals() and hashCode(): JI-9028554); remove() may
	// thus not be used.
	for (Iterator<MapChangeListener<? super K, ? super V>> iterator = mapChangeListeners
			.iterator(); iterator.hasNext();) {
		if (iterator.next().equals(listener)) {
			iterator.remove();
			break;
		}
	}
	if (mapChangeListeners.isEmpty()) {
		mapChangeListeners = null;
	}
}
 

@Override
public void onChanged(MapChangeListener.Change<? extends String, ? extends Object> change) {
	if (ZestProperties.ROUTER__E.equals(change.getKey())) {
		// if the router changed, re-attach the visual (so we attach to
		// a different anchor)
		for (Entry<IVisualPart<? extends Node>, String> anchoragesByRole : getAnchoragesUnmodifiable()
				.entries()) {
			doDetachFromAnchorageVisual(anchoragesByRole.getKey(), anchoragesByRole.getValue());
			doAttachToAnchorageVisual(anchoragesByRole.getKey(), anchoragesByRole.getValue());
		}
	}
	refreshVisual();
}
 

@Override
public void onChanged(
		javafx.collections.MapChangeListener.Change<? extends Node, ? extends IVisualPart<? extends Node>> change) {
	// keep model in sync with part hierarchy
	if (change.wasRemoved()) {
		IVisualPart<? extends Node> valueRemoved = change
				.getValueRemoved();
		if (selection.contains(valueRemoved)) {
			selection.remove(valueRemoved);
		}
	}
}
 

@Override
public void onChanged(
		javafx.collections.MapChangeListener.Change<? extends Node, ? extends IVisualPart<? extends Node>> change) {
	// keep model in sync with part hierarchy
	if (change.wasRemoved()) {
		IVisualPart<? extends Node> valueRemoved = change
				.getValueRemoved();
		if (hoverProperty.get() == valueRemoved) {
			clearHover();
		}
		if (hoverIntentProperty.get() == valueRemoved) {
			clearHoverIntent();
		}
	}
}
 

@Override
public void onChanged(
		javafx.collections.MapChangeListener.Change<? extends Node, ? extends IVisualPart<? extends Node>> change) {
	// keep model in sync with part hierarchy
	if (change.wasRemoved()) {
		if (focusedProperty.get() == change.getValueRemoved()) {
			setFocus(null);
		}
	}
}
 

/**
 * Fires notifications to all attached {@link InvalidationListener
 * InvalidationListeners}, and {@link MapChangeListener MapChangeListeners}.
 *
 * @param change
 *            The change that needs to be propagated.
 */
@Override
public void fireValueChangedEvent(
		MapChangeListener.Change<? extends K, ? extends V> change) {
	if (change != null) {
		notifyInvalidationListeners();
		// XXX: We do not notify change listeners here, as the identity of
		// the observed value did not change (see
		// https://bugs.openjdk.java.net/browse/JDK-8089169)
		notifyMapChangeListeners(
				new AtomicChange<>(observableValue, change));
	}
}
 

@Inject
public AccountPresentation(Preferences preferences) {

    this.preferences = preferences;

    preferences.getDontShowAgainMapAsObservable().addListener((MapChangeListener<? super String, ? super Boolean>) change -> {
        if (change.getKey().equals(ACCOUNT_NEWS)) {
            showNotification.set(!change.wasAdded());
        }
    });
}
 

public static <K, V> EventStream<MapChangeListener.Change<? extends K, ? extends V>> changesOf(ObservableMap<K, V> map) {
    return new EventStreamBase<MapChangeListener.Change<? extends K, ? extends V>>() {
        @Override
        protected Subscription observeInputs() {
            MapChangeListener<K, V> listener = c -> emit(c);
            map.addListener(listener);
            return () -> map.removeListener(listener);
        }
    };
}
 

@Override
public void removeListener(
		MapChangeListener<? super K, ? super V> listener) {
	if (helper != null) {
		helper.removeListener(listener);
	}
}
 

@Override
public void addListener(MapChangeListener<? super K, ? super V> listener) {
	if (helper == null) {
		helper = new MapExpressionHelperEx<>(this);
	}
	helper.addListener(listener);
}
 

/**
 * {@inheritDoc}
 */
@Override
public void removeListener(
		MapChangeListener<? super K, ? super V> listener) {
	if (helper != null) {
		helper.removeListener(listener);
	}
}
 

@Override
protected void fireValueChangedEvent(
		MapChangeListener.Change<? extends K, ? extends V> change) {
	if (helper != null) {
		helper.fireValueChangedEvent(change);
	}
}
 

/**
 * {@inheritDoc}
 */
@Override
public void addListener(MapChangeListener<? super K, ? super V> listener) {
	if (helper == null) {
		helper = new MapExpressionHelperEx<>(this);
	}
	helper.addListener(listener);
}
 

/**
 * {@inheritDoc}
 */
@Override
public void removeListener(
		MapChangeListener<? super K, ? super V> listener) {
	// don't delegate to read-only property (fix for
	// https://bugs.openjdk.java.net/browse/JDK-8089557)
	if (helper != null) {
		helper.removeListener(listener);
	}
}
 

/**
 * {@inheritDoc}
 */
@Override
public void addListener(MapChangeListener<? super K, ? super V> listener) {
	// don't delegate to read-only property (fix for
	// https://bugs.openjdk.java.net/browse/JDK-8089557)
	if (helper == null) {
		helper = new MapExpressionHelperEx<>(this);
	}
	helper.addListener(listener);
}
 

@Override
public void removeListener(
		MapChangeListener<? super K, ? super V> listener) {
	if (helper != null) {
		helper.removeListener(listener);
	}
}
 

@Override
public void addListener(
		MapChangeListener<? super K, ? super V> listener) {
	if (helper == null) {
		helper = new MapExpressionHelperEx<>(this);
	}
	helper.addListener(listener);
}
 

private void registerPCL(AnchorKey anchorKey, IAnchor anchor) {
	if (!anchorsPCL.containsKey(anchorKey)) {
		MapChangeListener<? super AnchorKey, ? super Point> pcl = createPCL(
				anchorKey);
		anchorsPCL.put(anchorKey, pcl);
		anchor.positionsUnmodifiableProperty().addListener(pcl);
	}
}