Modifier and Type	Class and Description
pack-priv static class	ControlAcceleratorSupport.IdentityWrapperListChangeListener We need to store all the listeners added to each ObservableList so that we can remove them.

Modifier and Type	Field and Description
private static Map<MenuItem, WeakReference<ChangeListener<KeyCombination>>>	changeListenerMap
private static Map<ListChangeListener<MenuItem>, WeakReference<ListChangeListener<MenuItem>>>	menuListChangeListenerMap
private static Map<Object, WeakReference<ChangeListener<Scene>>>	sceneChangeListenerMap

Access	Constructor and Description
public	ControlAcceleratorSupport()

Modifier and Type	Method and Description
public static void	addAcceleratorsIntoScene(ObservableList<MenuItem> items, Tab anchor)
public static void	addAcceleratorsIntoScene(ObservableList<MenuItem> items, TableColumnBase<?, ?> anchor)
public static void	addAcceleratorsIntoScene(ObservableList<MenuItem> items, Node anchor)
private static void	addAcceleratorsIntoScene(ObservableList<MenuItem> items, Object anchor)
private static void	doAcceleratorInstall(final ObservableList<MenuItem> items, final Scene scene)
private static void	doAcceleratorInstall(final List<? extends MenuItem> items, final Scene scene)
private static ReadOnlyObjectProperty<? extends Control>	getControlProperty(Object obj)
private static ChangeListener<KeyCombination>	getListener(final Scene scene, MenuItem menuItem)
private static ChangeListener<Scene>	getSceneChangeListener(Object anchor, ObservableList<MenuItem> items)
public static void	removeAcceleratorsFromScene(ObservableList<? extends MenuItem> items, Tab anchor)
public static void	removeAcceleratorsFromScene(ObservableList<? extends MenuItem> items, TableColumnBase<?, ?> anchor)
public static void	removeAcceleratorsFromScene(ObservableList<? extends MenuItem> items, Node anchor)
public static void	removeAcceleratorsFromScene(ObservableList<? extends MenuItem> items, Scene scene)
private static void	removeAcceleratorsFromScene(List<? extends MenuItem> items, Scene scene)

changeListenerMap	back to summary
private static Map<MenuItem, WeakReference<ChangeListener<KeyCombination>>> changeListenerMap

menuListChangeListenerMap	back to summary
private static Map<ListChangeListener<MenuItem>, WeakReference<ListChangeListener<MenuItem>>> menuListChangeListenerMap

sceneChangeListenerMap	back to summary
private static Map<Object, WeakReference<ChangeListener<Scene>>> sceneChangeListenerMap

ControlAcceleratorSupport	back to summary
public ControlAcceleratorSupport()

Method Detail

addAcceleratorsIntoScene	back to summary
public static void addAcceleratorsIntoScene(ObservableList<MenuItem> items, Tab anchor)

addAcceleratorsIntoScene	back to summary
public static void addAcceleratorsIntoScene(ObservableList<MenuItem> items, TableColumnBase<?, ?> anchor)

addAcceleratorsIntoScene	back to summary
public static void addAcceleratorsIntoScene(ObservableList<MenuItem> items, Node anchor)

addAcceleratorsIntoScene	back to summary
private static void addAcceleratorsIntoScene(ObservableList<MenuItem> items, Object anchor)

doAcceleratorInstall	back to summary
private static void doAcceleratorInstall(final ObservableList<MenuItem> items, final Scene scene)

doAcceleratorInstall	back to summary
private static void doAcceleratorInstall(final List<? extends MenuItem> items, final Scene scene)

getControlProperty	back to summary
private static ReadOnlyObjectProperty<? extends Control> getControlProperty(Object obj)

getListener	back to summary
private static ChangeListener<KeyCombination> getListener(final Scene scene, MenuItem menuItem)

getSceneChangeListener	back to summary
private static ChangeListener<Scene> getSceneChangeListener(Object anchor, ObservableList<MenuItem> items)

removeAcceleratorsFromScene	back to summary
public static void removeAcceleratorsFromScene(ObservableList<? extends MenuItem> items, Tab anchor)

removeAcceleratorsFromScene	back to summary
public static void removeAcceleratorsFromScene(ObservableList<? extends MenuItem> items, TableColumnBase<?, ?> anchor)

removeAcceleratorsFromScene	back to summary
public static void removeAcceleratorsFromScene(ObservableList<? extends MenuItem> items, Node anchor)

removeAcceleratorsFromScene	back to summary
public static void removeAcceleratorsFromScene(ObservableList<? extends MenuItem> items, Scene scene)

removeAcceleratorsFromScene	back to summary
private static void removeAcceleratorsFromScene(List<? extends MenuItem> items, Scene scene)

com.sun.javafx.scene.control back to summary

pack-priv Class ControlAcceleratorSupport.IdentityWrapperListChangeListener

Class Inheritance

extends Object
implements ListChangeListener<MenuItem>

java.lang.Object
com.sun.javafx.scene.control.ControlAcceleratorSupport.IdentityWrapperListChangeListener

All Implemented Interfaces

javafx.collections.ListChangeListener

We need to store all the listeners added to each ObservableList so that we can remove them. For this we need a map mapping ObservableList to various listeners such as ListChangeListeners, but the map needs to be a WeakHashMap. The ideal key to the WeakHashMap would be the ObservableList itself, except for the fact that its equals method compares the list contents. If a WeakIdentityHashMap existed, we could use that instead with the ObservableList as the key. We can't use an IdentityWrapper as the key to the HashMap because we need a strong reference (ideally from the ObservableList itself) to the IdentityWrapper else it'll be garbage collected. Since every ObservableList gets a ListChangeListener, we can use that as an IdentityWrapper and rely on the fact ObservableList has a strong reference to the ListChangeListener.

Field Summary

Modifier and Type	Field and Description
pack-priv ObservableList<? extends MenuItem>	innerList

Constructor Summary

Access	Constructor and Description
public	IdentityWrapperListChangeListener(ObservableList<? extends MenuItem> list)

Method Summary

Modifier and Type	Method and Description
public boolean	equals(Object o) Overrides java.lang.Object.equals. Indicates whether some other object is "equal to" this one.
public int	hashCode() Overrides java.lang.Object.hashCode. Returns a hash code value for this object.
public void	onChanged(ListChangeListener.Change<? extends MenuItem> c) Implements javafx.collections.ListChangeListener.onChanged. Called after a change has been made to an ObservableList.

Inherited from java.lang.Object:: clone finalize getClass notify notifyAll toString wait wait wait

Field Detail

innerList	back to summary
pack-priv ObservableList<? extends MenuItem> innerList

Constructor Detail

IdentityWrapperListChangeListener	back to summary
public IdentityWrapperListChangeListener(ObservableList<? extends MenuItem> list)

Method Detail

equals back to summary

equals	back to summary
public boolean equals(Object o) Overrides java.lang.Object.equals. Doc from java.lang.Object.equals. Indicates whether some other object is "equal to" this one. The `equals` method implements an equivalence relation on non-null object references: It is reflexive: for any non-null reference value `x`, `x.equals(x)` should return `true`. It is symmetric: for any non-null reference values `x` and `y`, `x.equals(y)` should return `true` if and only if `y.equals(x)` returns `true`. It is transitive: for any non-null reference values `x`, `y`, and `z`, if `x.equals(y)` returns `true` and `y.equals(z)` returns `true`, then `x.equals(z)` should return `true`. It is consistent: for any non-null reference values `x` and `y`, multiple invocations of `x.equals(y)` consistently return `true` or consistently return `false`, provided no information used in `equals` comparisons on the objects is modified. For any non-null reference value `x`, `x.equals(null)` should return `false`. An equivalence relation partitions the elements it operates on into equivalence classes; all the members of an equivalence class are equal to each other. Members of an equivalence class are substitutable for each other, at least for some purposes. Annotations @Override

public boolean equals(Object o)

Overrides java.lang.Object.equals.

Doc from java.lang.Object.equals.

Indicates whether some other object is "equal to" this one.

The equals method implements an equivalence relation on non-null object references:

It is reflexive: for any non-null reference value x, x.equals(x) should return true.
It is symmetric: for any non-null reference values x and y, x.equals(y) should return true if and only if y.equals(x) returns true.
It is transitive: for any non-null reference values x, y, and z, if x.equals(y) returns true and y.equals(z) returns true, then x.equals(z) should return true.
It is consistent: for any non-null reference values x and y, multiple invocations of x.equals(y) consistently return true or consistently return false, provided no information used in equals comparisons on the objects is modified.
For any non-null reference value x, x.equals(null) should return false.

An equivalence relation partitions the elements it operates on into equivalence classes; all the members of an equivalence class are equal to each other. Members of an equivalence class are substitutable for each other, at least for some purposes.

Annotations

@Override

hashCode back to summary

hashCode	back to summary
public int hashCode() Overrides java.lang.Object.hashCode. Doc from java.lang.Object.hashCode. Returns a hash code value for this object. This method is supported for the benefit of hash tables such as those provided by `java.util.HashMap`. The general contract of `hashCode` is: Whenever it is invoked on the same object more than once during an execution of a Java application, the `hashCode` method must consistently return the same integer, provided no information used in `equals` comparisons on the object is modified. This integer need not remain consistent from one execution of an application to another execution of the same application. If two objects are equal according to the `equals` method, then calling the `hashCode` method on each of the two objects must produce the same integer result. It is not required that if two objects are unequal according to the `equals` method, then calling the `hashCode` method on each of the two objects must produce distinct integer results. However, the programmer should be aware that producing distinct integer results for unequal objects may improve the performance of hash tables. Annotations @Override

public int hashCode()

Overrides java.lang.Object.hashCode.

Doc from java.lang.Object.hashCode.

Returns a hash code value for this object. This method is supported for the benefit of hash tables such as those provided by java.util.HashMap.

The general contract of hashCode is:

Whenever it is invoked on the same object more than once during an execution of a Java application, the hashCode method must consistently return the same integer, provided no information used in equals comparisons on the object is modified. This integer need not remain consistent from one execution of an application to another execution of the same application.
If two objects are equal according to the equals method, then calling the hashCode method on each of the two objects must produce the same integer result.
It is not required that if two objects are unequal according to the equals method, then calling the hashCode method on each of the two objects must produce distinct integer results. However, the programmer should be aware that producing distinct integer results for unequal objects may improve the performance of hash tables.

Annotations

@Override

onChanged	back to summary
public void onChanged(ListChangeListener.Change<? extends MenuItem> c) Implements javafx.collections.ListChangeListener.onChanged. Doc from javafx.collections.ListChangeListener.onChanged. Called after a change has been made to an ObservableList. Annotations @Override

onChanged

back to summary

public void onChanged(ListChangeListener.Change<? extends MenuItem> c)

Implements javafx.collections.ListChangeListener.onChanged.

Doc from javafx.collections.ListChangeListener.onChanged.

Called after a change has been made to an ObservableList.

Annotations