Java 类java.awt.event.ComponentListener 实例源码

/**
 * Installs/resets a ComponentListener to resize the
 * given window to minWidth/Height if needed.
 *
 * @param window
 * @param minWidth
 * @param minHeight
 */
public static void setMinimumSizeManager(Window window, int minWidth,
                                         int minHeight) {
    ComponentListener[] listeners = window.getComponentListeners();
    ComponentListener listener = null;
    for (ComponentListener l : listeners) {
        if (l instanceof MinSizeComponentListener) {
            listener = l;
            break;
        }
    }
    if (listener == null) {
        window.addComponentListener(new MinSizeComponentListener(
                window, minWidth, minHeight));
    } else {
        ((MinSizeComponentListener) listener).resetSizes(minWidth,
                minHeight);
    }
}

/**
 * Creates and returns a scroll panel which wraps the specified view component.<br>
 * The returned scroll panel disables vertical scroll bar, and only displays the horizontal scroll bar when the view does not fit
 * into the size of the view port. When the view fits into the view port, the scroll pane will not claim the space of the scroll bar.
 * 
 * @param view               view to wrap in the scroll pane
 * @param parentToRevalidate parent to revalidate when the scroll pane decides to change its size
 * 
 * @return the created self managed scroll pane
 */
public static JScrollPane createSelfManagedScrollPane( final Component view, final JComponent parentToRevalidate ) {
    final JScrollPane scrollPane = new JScrollPane( view );

    scrollPane.setVerticalScrollBarPolicy( JScrollPane.VERTICAL_SCROLLBAR_NEVER );
    scrollPane.getHorizontalScrollBar().setPreferredSize( new Dimension( 0, 12 ) ); // Only want to restrict the height, width doesn't matter (it takes up whole width)
    scrollPane.getHorizontalScrollBar().setUnitIncrement( 10 );

    final ComponentListener scrollPaneComponentListener = new ComponentAdapter() {
        @Override
        public void componentResized( final ComponentEvent event ) {
            scrollPane.setHorizontalScrollBarPolicy( view.getWidth() < scrollPane.getWidth() ? JScrollPane.HORIZONTAL_SCROLLBAR_NEVER : JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS );
            scrollPane.setPreferredSize( null );
            scrollPane.setPreferredSize( new Dimension( 10, scrollPane.getPreferredSize().height ) );
            parentToRevalidate.revalidate();
        }
    };
    scrollPane.addComponentListener( scrollPaneComponentListener );

    return scrollPane;
}

/**
 * Removes all listeners associated with the given Component. This is useful when removing to to make sure
 * it does not stick around.
 */
public static void removeAllListeners(Component com) {
    for (FocusListener fl : com.getFocusListeners()) {
        com.removeFocusListener(fl);
    }

    for (MouseListener ml : com.getMouseListeners()) {
        com.removeMouseListener(ml);
    }

    for (MouseMotionListener mml : com.getMouseMotionListeners()) {
        com.removeMouseMotionListener(mml);
    }

    for (KeyListener kl : com.getKeyListeners()) {
        com.removeKeyListener(kl);
    }

    for (ComponentListener cl : com.getComponentListeners()) {
        com.removeComponentListener(cl);
    }
}

/**
 * Installs/resets a ComponentListener to resize the
 * given window to minWidth/Height if needed.
 *
 * @param window
 * @param minWidth
 * @param minHeight
 */
public static void setMinimumSizeManager(Window window, int minWidth,
                                         int minHeight) {
    ComponentListener[] listeners = window.getComponentListeners();
    ComponentListener listener = null;
    for (ComponentListener l : listeners) {
        if (l instanceof MinSizeComponentListener) {
            listener = l;
            break;
        }
    }
    if (listener == null) {
        window.addComponentListener(new MinSizeComponentListener(
                window, minWidth, minHeight));
    } else {
        ((MinSizeComponentListener) listener).resetSizes(minWidth,
                                                         minHeight);
    }
}

public DockingWindow addView(int order, Configurable obj) {
    Component component = (Component) obj.getData().getProperty(TabProperty.COMPONENT);
    View view = new View(
            (String) obj.getData().getProperty(TabProperty.TITLE),
            (Icon) obj.getData().getProperty(TabProperty.ICON),
            component
    );

    if (component instanceof ComponentListener) {
        view.addComponentListener((ComponentListener) component);
    }

    if (order == 1 && obj instanceof DockingWindowListener) {
        DockingWindowListener dockingWindowListener = (DockingWindowListener) obj;
        view.addListener(dockingWindowListener);
        if (firstTabWindow.getChildWindowCount() == 0) {
            dockingWindowListener.windowShown(view);
        }
    }

    return addView(order, view);
}

/**
 * Fire a component event to the Layer component listeners, with the palette
 * as the component, letting them know if it's visible or not.
 */
public void firePaletteEvent(ComponentEvent event) {
    if (localHackList == null) {
        return;
    }

    palette = (Container) event.getSource();
    int eventType = event.getID();
    for (ComponentListener listener : localHackList) {
        if (eventType == ComponentEvent.COMPONENT_HIDDEN) {
            listener.componentHidden(event);
        } else if (eventType == ComponentEvent.COMPONENT_SHOWN) {
            listener.componentShown(event);
        }
    }

    if (eventType == ComponentEvent.COMPONENT_HIDDEN) {
        palette = null;
    }
}

/**
 * Get a layer's associated palette as a top-level window
 * 
 * @param gui the Component to place in the window
 * @param cl the listener to associate with the palette
 * @return the frame that the palette is in
 */
public static JFrame getPaletteWindow(Component gui, String windowName,
                                      ComponentListener cl) {

    JScrollPane scrollPane = new JScrollPane(gui, ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED, ScrollPaneConstants.HORIZONTAL_SCROLLBAR_AS_NEEDED);
    scrollPane.setAlignmentX(Component.LEFT_ALIGNMENT);
    scrollPane.setAlignmentY(Component.TOP_ALIGNMENT);

    // create the palette internal window
    JFrame paletteWindow = new JFrame(windowName);

    paletteWindow.addComponentListener(cl);
    paletteWindow.getContentPane().add(scrollPane);
    //layout all the components
    paletteWindow.pack();
    return paletteWindow;
}

/**
 * Get a layer's associated palette as a top-level window
 * 
 * @param gui the Component to place in the window
 * @param cl the listener to associate with the palette
 * @return the frame that the palette is in
 */
public static JFrame getNoScrollPaletteWindow(Component gui,
                                              String windowName,
                                              ComponentListener cl) {

    JPanel pane = new JPanel();
    pane.setLayout(new BoxLayout(pane, BoxLayout.Y_AXIS));
    pane.setAlignmentX(Component.CENTER_ALIGNMENT);
    pane.setAlignmentY(Component.BOTTOM_ALIGNMENT);
    pane.add(gui);
    JFrame paletteWindow = new JFrame(windowName);
    paletteWindow.addComponentListener(cl);
    paletteWindow.getContentPane().add(pane);
    paletteWindow.pack();

    return paletteWindow;
}

/**
 * Sets the content in the JInternalFrame/JDialog.
 */
public void setContent(Component comp) {

    if (content instanceof ComponentListener) {
        removeComponentListener((ComponentListener) content);
    }

    content = comp;
    if (display != null) {
        display.setContent(comp);
    }

    if (content instanceof ComponentListener) {
        addComponentListener((ComponentListener) content);
    }
}

@SuppressWarnings("unchecked")
public <T extends EventListener> T[] getListeners(Class<T> listenerType) {
    if (ComponentListener.class.isAssignableFrom(listenerType)) {
        return (T[]) getComponentListeners();
    } else if (FocusListener.class.isAssignableFrom(listenerType)) {
        return (T[]) getFocusListeners();
    } else if (HierarchyBoundsListener.class.isAssignableFrom(listenerType)) {
        return (T[]) getHierarchyBoundsListeners();
    } else if (HierarchyListener.class.isAssignableFrom(listenerType)) {
        return (T[]) getHierarchyListeners();
    } else if (InputMethodListener.class.isAssignableFrom(listenerType)) {
        return (T[]) getInputMethodListeners();
    } else if (KeyListener.class.isAssignableFrom(listenerType)) {
        return (T[]) getKeyListeners();
    } else if (MouseWheelListener.class.isAssignableFrom(listenerType)) {
        return (T[]) getMouseWheelListeners();
    } else if (MouseMotionListener.class.isAssignableFrom(listenerType)) {
        return (T[]) getMouseMotionListeners();
    } else if (MouseListener.class.isAssignableFrom(listenerType)) {
        return (T[]) getMouseListeners();
    } else if (PropertyChangeListener.class.isAssignableFrom(listenerType)) {
        return (T[]) getPropertyChangeListeners();
    }
    return (T[]) Array.newInstance(listenerType, 0);
}

private void processComponentEventImpl(ComponentEvent e, Collection<ComponentListener> c) {
    for (ComponentListener listener : c) {
        switch (e.getID()) {
            case ComponentEvent.COMPONENT_HIDDEN:
                listener.componentHidden(e);
                break;
            case ComponentEvent.COMPONENT_MOVED:
                listener.componentMoved(e);
                break;
            case ComponentEvent.COMPONENT_RESIZED:
                listener.componentResized(e);
                break;
            case ComponentEvent.COMPONENT_SHOWN:
                listener.componentShown(e);
                break;
        }
    }
}

private void hideMe() {
    final JComponent parent = (JComponent) textfield.getParent();
    final Rectangle bounds = textfield.getBounds();
    textfield.removeFocusListener(textFieldListener);
    textfield.removeKeyListener((KeyListener) textFieldListener);
    textfield.removeMouseListener((MouseListener) textFieldListener);
    mFocusListener
            .removeComponentListener((ComponentListener) textFieldListener);
    // workaround for java bug
    // http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=7075600, see
    // FreeMindStarter
    parent.remove(textfield);
    parent.revalidate();
    parent.repaint(bounds);
    textFieldListener = null;
}

private void showPopupPanel() {
    if (mPopup == null)
        mPopup = new ComponentUtils.ModalPopup(this);

    PopupPanel panel = this.getPanel().orElse(null);
    if (panel == null)
        return;

    mPopup.removeAll();
    panel.onShow();

    for (ComponentListener cl : panel.getComponentListeners())
        panel.removeComponentListener(cl);

    panel.addComponentListener(new ComponentAdapter() {
        @Override
        public void componentHidden(ComponentEvent e) {
            mPopup.close();
        }
    });
    mPopup.add(panel);
    mPopup.showPopup();
}

@SuppressWarnings("unchecked")
public <T extends EventListener> T[] getListeners(Class<T> listenerType) {
    if (ComponentListener.class.isAssignableFrom(listenerType)) {
        return (T[]) getComponentListeners();
    } else if (FocusListener.class.isAssignableFrom(listenerType)) {
        return (T[]) getFocusListeners();
    } else if (HierarchyBoundsListener.class.isAssignableFrom(listenerType)) {
        return (T[]) getHierarchyBoundsListeners();
    } else if (HierarchyListener.class.isAssignableFrom(listenerType)) {
        return (T[]) getHierarchyListeners();
    } else if (InputMethodListener.class.isAssignableFrom(listenerType)) {
        return (T[]) getInputMethodListeners();
    } else if (KeyListener.class.isAssignableFrom(listenerType)) {
        return (T[]) getKeyListeners();
    } else if (MouseWheelListener.class.isAssignableFrom(listenerType)) {
        return (T[]) getMouseWheelListeners();
    } else if (MouseMotionListener.class.isAssignableFrom(listenerType)) {
        return (T[]) getMouseMotionListeners();
    } else if (MouseListener.class.isAssignableFrom(listenerType)) {
        return (T[]) getMouseListeners();
    } else if (PropertyChangeListener.class.isAssignableFrom(listenerType)) {
        return (T[]) getPropertyChangeListeners();
    }
    return (T[]) Array.newInstance(listenerType, 0);
}

private void processComponentEventImpl(ComponentEvent e, Collection<ComponentListener> c) {
    for (ComponentListener listener : c) {
        switch (e.getID()) {
            case ComponentEvent.COMPONENT_HIDDEN:
                listener.componentHidden(e);
                break;
            case ComponentEvent.COMPONENT_MOVED:
                listener.componentMoved(e);
                break;
            case ComponentEvent.COMPONENT_RESIZED:
                listener.componentResized(e);
                break;
            case ComponentEvent.COMPONENT_SHOWN:
                listener.componentShown(e);
                break;
        }
    }
}

@SuppressWarnings("unchecked")
public <T extends EventListener> T[] getListeners(Class<T> listenerType) {
    if (ComponentListener.class.isAssignableFrom(listenerType)) {
        return (T[]) getComponentListeners();
    } else if (FocusListener.class.isAssignableFrom(listenerType)) {
        return (T[]) getFocusListeners();
    } else if (HierarchyBoundsListener.class.isAssignableFrom(listenerType)) {
        return (T[]) getHierarchyBoundsListeners();
    } else if (HierarchyListener.class.isAssignableFrom(listenerType)) {
        return (T[]) getHierarchyListeners();
    } else if (InputMethodListener.class.isAssignableFrom(listenerType)) {
        return (T[]) getInputMethodListeners();
    } else if (KeyListener.class.isAssignableFrom(listenerType)) {
        return (T[]) getKeyListeners();
    } else if (MouseWheelListener.class.isAssignableFrom(listenerType)) {
        return (T[]) getMouseWheelListeners();
    } else if (MouseMotionListener.class.isAssignableFrom(listenerType)) {
        return (T[]) getMouseMotionListeners();
    } else if (MouseListener.class.isAssignableFrom(listenerType)) {
        return (T[]) getMouseListeners();
    } else if (PropertyChangeListener.class.isAssignableFrom(listenerType)) {
        return (T[]) getPropertyChangeListeners();
    }
    return (T[]) Array.newInstance(listenerType, 0);
}

private void processComponentEventImpl(ComponentEvent e, Collection<ComponentListener> c) {
    for (ComponentListener listener : c) {
        switch (e.getID()) {
            case ComponentEvent.COMPONENT_HIDDEN:
                listener.componentHidden(e);
                break;
            case ComponentEvent.COMPONENT_MOVED:
                listener.componentMoved(e);
                break;
            case ComponentEvent.COMPONENT_RESIZED:
                listener.componentResized(e);
                break;
            case ComponentEvent.COMPONENT_SHOWN:
                listener.componentShown(e);
                break;
        }
    }
}

private void hideMe() {
    final JComponent parent = (JComponent) textfield.getParent();
    final Rectangle bounds = textfield.getBounds();
    textfield.removeFocusListener(textFieldListener);
    textfield.removeKeyListener((KeyListener) textFieldListener);
    textfield.removeMouseListener((MouseListener) textFieldListener);
    mFocusListener
            .removeComponentListener((ComponentListener) textFieldListener);
    // workaround for java bug
    // http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=7075600, see
    // FreeMindStarter
    parent.remove(textfield);
    parent.revalidate();
    parent.repaint(bounds);
    textFieldListener = null;
}

/** Create a component listener to handle size changes if the table model
 * is large-model */
private ComponentListener getComponentListener() {
    if (componentListener == null) {
        componentListener = new SizeManager();
    }
    return componentListener;
}

@Override
public void removeNotify() {
    super.removeNotify();
    for (ComponentListener l : getComponentListeners()) {
        super.removeComponentListener(l);
    }
}

public void dispose() {
    ComponentListener[] listeners = getComponentListeners();
    for (int i=0; i<listeners.length; i++) {
        removeComponentListener(listeners[i]);
    }
    MouseListener[] mlisteners = getMouseListeners();
    for (int i=0; i<mlisteners.length; i++) {
        removeMouseListener(mlisteners[i]);
    }
    KeyListener[] klisteners = getKeyListeners();
    for (int i=0; i<klisteners.length; i++) {
        removeKeyListener(klisteners[i]);
    }
}

/**
 * Maps {@code Component.addComponentListener(ComponentListener)}
 * through queue
 */
public void addComponentListener(final ComponentListener componentListener) {
    runMapping(new MapVoidAction("addComponentListener") {
        @Override
        public void map() {
            getSource().addComponentListener(componentListener);
        }
    });
}

/**
 * Maps {@code Component.removeComponentListener(ComponentListener)}
 * through queue
 */
public void removeComponentListener(final ComponentListener componentListener) {
    runMapping(new MapVoidAction("removeComponentListener") {
        @Override
        public void map() {
            getSource().removeComponentListener(componentListener);
        }
    });
}

/**
 * Maps {@code Component.addComponentListener(ComponentListener)}
 * through queue
 */
public void addComponentListener(final ComponentListener componentListener) {
    runMapping(new MapVoidAction("addComponentListener") {
        @Override
        public void map() {
            getSource().addComponentListener(componentListener);
        }
    });
}

/**
 * Maps {@code Component.removeComponentListener(ComponentListener)}
 * through queue
 */
public void removeComponentListener(final ComponentListener componentListener) {
    runMapping(new MapVoidAction("removeComponentListener") {
        @Override
        public void map() {
            getSource().removeComponentListener(componentListener);
        }
    });
}

public void fireComponentResizedAdAPI(){
    final ComponentEvent event = new ComponentEvent(this, ComponentEvent.COMPONENT_RESIZED);

    final ComponentListener[] listeners = getComponentListeners();
    for (int i = 0; i < listeners.length; i++) {
        listeners[i].componentResized(event);
    }
}

public void fireComponentMovedAdAPI(){
    final ComponentEvent event = new ComponentEvent(this, ComponentEvent.COMPONENT_MOVED);

    final ComponentListener[] listeners = getComponentListeners();
    for (int i = 0; i < listeners.length; i++) {
        listeners[i].componentMoved(event);
    }
}

public void fireComponentShowAdAPI(){
    final ComponentEvent event = new ComponentEvent(this, ComponentEvent.COMPONENT_SHOWN);

    final ComponentListener[] listeners = getComponentListeners();
    for (int i = 0; i < listeners.length; i++) {
        listeners[i].componentShown(event);
    }
}

public void fireComponentHiddenAdAPI(){
    final ComponentEvent event = new ComponentEvent(this, ComponentEvent.COMPONENT_HIDDEN);

    final ComponentListener[] listeners = getComponentListeners();
    for (int i = 0; i < listeners.length; i++) {
        listeners[i].componentHidden(event);
    }
}

/**
 * Deserializes this component. This regenerates all serializable listeners
 * which were registered originally.
 *
 * @param s the stream to read from
 * @throws ClassNotFoundException if deserialization fails
 * @throws IOException if the stream fails
 */
private void readObject(ObjectInputStream s)
  throws ClassNotFoundException, IOException
{
  s.defaultReadObject();
  String key = (String) s.readObject();
  while (key != null)
    {
      Object listener = s.readObject();
      if ("componentL".equals(key))
        addComponentListener((ComponentListener) listener);
      else if ("focusL".equals(key))
        addFocusListener((FocusListener) listener);
      else if ("keyL".equals(key))
        addKeyListener((KeyListener) listener);
      else if ("mouseL".equals(key))
        addMouseListener((MouseListener) listener);
      else if ("mouseMotionL".equals(key))
        addMouseMotionListener((MouseMotionListener) listener);
      else if ("inputMethodL".equals(key))
        addInputMethodListener((InputMethodListener) listener);
      else if ("hierarchyL".equals(key))
        addHierarchyListener((HierarchyListener) listener);
      else if ("hierarchyBoundsL".equals(key))
        addHierarchyBoundsListener((HierarchyBoundsListener) listener);
      else if ("mouseWheelL".equals(key))
        addMouseWheelListener((MouseWheelListener) listener);
      key = (String) s.readObject();
    }
}

/**
 * This method is called when the component is resized.
 *
 * @param event the <code>ComponentEvent</code> indicating the resize
 */
public void componentResized(ComponentEvent event)
{
  if (applet != null)
    {
      ComponentListener[] l = applet.getComponentListeners();
      for (int i = 0; i < l.length; i++)
        l[i].componentResized(event);
    }
}

/**
 * This method is called when the component is moved.
 *
 * @param event the <code>ComponentEvent</code> indicating the move
 */
public void componentMoved(ComponentEvent event)
{
  if (applet != null)
    {
      ComponentListener[] l = applet.getComponentListeners();
      for (int i = 0; i < l.length; i++)
        l[i].componentMoved(event);
    }
}

/**
 * This method is called when the component is made visible.
 *
 * @param event the <code>ComponentEvent</code> indicating the visibility
 */
public void componentShown(ComponentEvent event)
{
  if (applet != null)
    {
      ComponentListener[] l = applet.getComponentListeners();
      for (int i = 0; i < l.length; i++)
        l[i].componentShown(event);
    }
}

/**
 * This method is called when the component is hidden.
 *
 * @param event the <code>ComponentEvent</code> indicating the visibility
 */
public void componentHidden(ComponentEvent event)
{
  if (applet != null)
    {
      ComponentListener[] l = applet.getComponentListeners();
      for (int i = 0; i < l.length; i++)
        l[i].componentHidden(event);
    }
}

/**
 * This method is called when the component is resized.
 *
 * @param event the <code>ComponentEvent</code> indicating the resize
 */
public void componentResized(ComponentEvent event)
{
  if (applet != null)
    {
      ComponentListener[] l = applet.getComponentListeners();
      for (int i = 0; i < l.length; i++)
        l[i].componentResized(event);
    }
}

/**
 * This method is called when the component is moved.
 *
 * @param event the <code>ComponentEvent</code> indicating the move
 */
public void componentMoved(ComponentEvent event)
{
  if (applet != null)
    {
      ComponentListener[] l = applet.getComponentListeners();
      for (int i = 0; i < l.length; i++)
        l[i].componentMoved(event);
    }
}

/**
 * This method is called when the component is made visible.
 *
 * @param event the <code>ComponentEvent</code> indicating the visibility
 */
public void componentShown(ComponentEvent event)
{
  if (applet != null)
    {
      ComponentListener[] l = applet.getComponentListeners();
      for (int i = 0; i < l.length; i++)
        l[i].componentShown(event);
    }
}

/**
 * This method is called when the component is hidden.
 *
 * @param event the <code>ComponentEvent</code> indicating the visibility
 */
public void componentHidden(ComponentEvent event)
{
  if (applet != null)
    {
      ComponentListener[] l = applet.getComponentListeners();
      for (int i = 0; i < l.length; i++)
        l[i].componentHidden(event);
    }
}

private static FrameState findFrameState(@NotNull Component component) {
  for (ComponentListener listener : component.getComponentListeners()) {
    if (listener instanceof FrameState) {
      return (FrameState)listener;
    }
  }
  return null;
}

/**
* Returns true if the {@link Popup} this class handles is visible. Since
* there is no available method in the {@link Popup} class to check whether
* it is visible, it checks if listeners are attached to the owning frame or
* glass pane instead.
*/
  public boolean isPopupVisible() {
    ComponentListener[] componentListeners = owningFrame.getComponentListeners();
    if (Arrays.asList(componentListeners).contains(resizeListener)) {
        return true;
    }

    MouseListener[] mouseListeners = glassPane.getMouseListeners();
    if (Arrays.asList(mouseListeners).contains(clickListener)) {
        return true;
    }

    return false;

  }