/** * Adds a <code>ChangeListener</code>. ChangeListeners are * notified after changes of any attribute. * * @param l the ChangeListener to add * @see #removeChangeListener */ @Override public final void addChangeListener(ChangeListener l) { listenerList.add(ChangeListener.class, l); }
/** * Returns an array of all the change listeners * registered on this <code>Highlighter</code>. * * @return all of this model's <code>ChangeListener</code>s * or an empty * array if no change listeners are currently registered * * @see #addChangeListener * @see #removeChangeListener * * @since 1.4 */ @Override public final ChangeListener[] getChangeListeners() { return listenerList.getListeners(ChangeListener.class); }
/** * Removes a <code>ChangeListener</code>e. * * @param l the <code>ChangeListener</code> to remove * @see #addChangeListener */ @Override public final void removeChangeListener(ChangeListener l) { listenerList.remove(ChangeListener.class, l); }
/** * Adds the listener as a listener of the specified type. * As a side-effect, cleans out any garbage collected * listeners before adding. * @param t the type of the listener to be added * @param l the listener to be added */ public synchronized <T extends EventListener> void add(Class<T> t, T l) { if (l==null) { // In an ideal world, we would do an assertion here // to help developers know they are probably doing // something wrong return; } if (!t.isInstance(l)) { throw new IllegalArgumentException("Listener " + l + " is not of type " + t); } cleanReferences(); getReferences().add(new WeakReference<T>(l)); getClasses().add(t); }
/** * Passes back the event listener list as an array * of ListenerType-listener pairs. * As a side-effect, cleans out any * garbage collected listeners before building the array. * * @return a array of listenerType-listener pairs. */ public Object[] getListenerList() { List<? extends EventListener> listeners = cleanReferences(); Object[] result = new Object[listeners.size() * 2]; for (int i = 0; i < listeners.size(); i++) { result[2*i + 1] = listeners.get(i); result[2*i] = getClasses().get(i); } return result; }
/** * Returns a list of strongly referenced EventListeners. Removes * internal weak references to garbage collected listeners. * * @return */ @SuppressWarnings("unchecked") private synchronized <T extends EventListener> List<T> cleanReferences() { List<T> listeners = new ArrayList<T>(); for (int i = getReferences().size() - 1; i >= 0; i--) { Object listener = getReferences().get(i).get(); if (listener == null) { getReferences().remove(i); getClasses().remove(i); } else { listeners.add(0, (T) listener); } } return listeners; }
/** * Notifies registered <code>ChangeListener</code>s about * state changes.<p> * * Note: subclasses should be polite and implement any property * setters to fire only if the property is really changed. * */ protected final void fireStateChanged() { Object[] listeners = listenerList.getListenerList(); for (int i = listeners.length - 2; i >= 0; i -= 2) { if (listeners[i] == ChangeListener.class) { if (changeEvent == null) { changeEvent = new ChangeEvent(this); } ((ChangeListener) listeners[i + 1]).stateChanged(changeEvent); } } }
/** * Adds the listener as a listener of the specified type. * As a side-effect, cleans out any garbage collected * listeners before adding. * @param t the type of the listener to be added * @param l the listener to be added */ public synchronized <T extends EventListener> void add(Class<T> t, T l) { if (l==null) { // In an ideal world, we would do an assertion here // to help developers know they are probably doing // something wrong return; } if (!t.isInstance(l)) { throw new IllegalArgumentException("Listener " + l + " is not of type " + t); } cleanReferences(); getReferences().add(new WeakReference<T>(l)); getClasses().add(t); }
/** * Passes back the event listener list as an array * of ListenerType-listener pairs. * As a side-effect, cleans out any * garbage collected listeners before building the array. * * @return a array of listenerType-listener pairs. */ public Object[] getListenerList() { List<? extends EventListener> listeners = cleanReferences(); Object[] result = new Object[listeners.size() * 2]; for (int i = 0; i < listeners.size(); i++) { result[2*i + 1] = listeners.get(i); result[2*i] = getClasses().get(i); } return result; }
/** * Returns a list of strongly referenced EventListeners. Removes * internal weak references to garbage collected listeners. * * @return */ @SuppressWarnings("unchecked") private synchronized <T extends EventListener> List<T> cleanReferences() { List<T> listeners = new ArrayList<T>(); for (int i = getReferences().size() - 1; i >= 0; i--) { Object listener = getReferences().get(i).get(); if (listener == null) { getReferences().remove(i); getClasses().remove(i); } else { listeners.add(0, (T) listener); } } return listeners; }
/** * Notifies registered <code>ChangeListener</code>s about * state changes.<p> * * Note: subclasses should be polite and implement any property * setters to fire only if the property is really changed. * */ protected final void fireStateChanged() { Object[] listeners = listenerList.getListenerList(); for (int i = listeners.length - 2; i >= 0; i -= 2) { if (listeners[i] == ChangeListener.class) { if (changeEvent == null) { changeEvent = new ChangeEvent(this); } ((ChangeListener) listeners[i + 1]).stateChanged(changeEvent); } } }
/** * Adds the listener as a listener of the specified type. * As a side-effect, cleans out any garbage collected * listeners before adding. * @param t the type of the listener to be added * @param l the listener to be added */ public synchronized <T extends EventListener> void add(Class<T> t, T l) { if (l==null) { // In an ideal world, we would do an assertion here // to help developers know they are probably doing // something wrong return; } if (!t.isInstance(l)) { throw new IllegalArgumentException("Listener " + l + " is not of type " + t); } cleanReferences(); getReferences().add(new WeakReference<T>(l)); getClasses().add(t); }
/** * Passes back the event listener list as an array * of ListenerType-listener pairs. * As a side-effect, cleans out any * garbage collected listeners before building the array. * * @return a array of listenerType-listener pairs. */ public Object[] getListenerList() { List<? extends EventListener> listeners = cleanReferences(); Object[] result = new Object[listeners.size() * 2]; for (int i = 0; i < listeners.size(); i++) { result[2*i + 1] = listeners.get(i); result[2*i] = getClasses().get(i); } return result; }
/** * Returns a list of strongly referenced EventListeners. Removes * internal weak references to garbage collected listeners. * * @return */ @SuppressWarnings("unchecked") private synchronized <T extends EventListener> List<T> cleanReferences() { List<T> listeners = new ArrayList<T>(); for (int i = getReferences().size() - 1; i >= 0; i--) { Object listener = getReferences().get(i).get(); if (listener == null) { getReferences().remove(i); getClasses().remove(i); } else { listeners.add(0, (T) listener); } } return listeners; }
/** * Adds a <code>ChangeListener</code>. ChangeListeners are * notified after changes of any attribute. * * @param l the ChangeListener to add * @see #removeChangeListener */ @Override public final void addChangeListener(ChangeListener l) { listenerList.add(ChangeListener.class, l); }
/** * Removes a <code>ChangeListener</code>e. * * @param l the <code>ChangeListener</code> to remove * @see #addChangeListener */ @Override public final void removeChangeListener(ChangeListener l) { listenerList.remove(ChangeListener.class, l); }
/** * Returns an array of all the change listeners * registered on this <code>Highlighter</code>. * * @return all of this model's <code>ChangeListener</code>s * or an empty * array if no change listeners are currently registered * * @see #addChangeListener * @see #removeChangeListener * * @since 1.4 */ @Override public final ChangeListener[] getChangeListeners() { return listenerList.getListeners(ChangeListener.class); }
/** * Notifies registered <code>ChangeListener</code>s about * state changes.<p> * * Note: subclasses should be polite and implement any property * setters to fire only if the property is really changed. * */ protected final void fireStateChanged() { Object[] listeners = listenerList.getListenerList(); for (int i = listeners.length - 2; i >= 0; i -= 2) { if (listeners[i] == ChangeListener.class) { if (changeEvent == null) { changeEvent = new ChangeEvent(this); } ((ChangeListener) listeners[i + 1]).stateChanged(changeEvent); } } }
/** * Adds the listener as a listener of the specified type. * As a side-effect, cleans out any garbage collected * listeners before adding. * @param t the type of the listener to be added * @param l the listener to be added */ public synchronized <T extends EventListener> void add(Class<T> t, T l) { if (l==null) { // In an ideal world, we would do an assertion here // to help developers know they are probably doing // something wrong return; } if (!t.isInstance(l)) { throw new IllegalArgumentException("Listener " + l + " is not of type " + t); } cleanReferences(); getReferences().add(new WeakReference<T>(l)); getClasses().add(t); }
/** * Passes back the event listener list as an array * of ListenerType-listener pairs. * As a side-effect, cleans out any * garbage collected listeners before building the array. * * @return a array of listenerType-listener pairs. */ public Object[] getListenerList() { List<? extends EventListener> listeners = cleanReferences(); Object[] result = new Object[listeners.size() * 2]; for (int i = 0; i < listeners.size(); i++) { result[2*i + 1] = listeners.get(i); result[2*i] = getClasses().get(i); } return result; }