Java ComponentListener类代码示例

import java.awt.event.ComponentListener; //导入依赖的package包/类
/**
 * 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);
    }
}
 

import java.awt.event.ComponentListener; //导入依赖的package包/类
/**
 * 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;
}
 

import java.awt.event.ComponentListener; //导入依赖的package包/类
/**
 * 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);
	}
}
 

import java.awt.event.ComponentListener; //导入依赖的package包/类
/**
 * 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);
    }
}
 

import java.awt.event.ComponentListener; //导入依赖的package包/类
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);
}
 

import java.awt.event.ComponentListener; //导入依赖的package包/类
/**
 * 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;
    }
}
 

import java.awt.event.ComponentListener; //导入依赖的package包/类
/**
 * 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;
}
 

import java.awt.event.ComponentListener; //导入依赖的package包/类
/**
 * 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;
}
 

import java.awt.event.ComponentListener; //导入依赖的package包/类
/**
 * 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);
    }
}
 

import java.awt.event.ComponentListener; //导入依赖的package包/类
@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);
}
 

import java.awt.event.ComponentListener; //导入依赖的package包/类
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;
        }
    }
}
 

import java.awt.event.ComponentListener; //导入依赖的package包/类
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;
}
 

import java.awt.event.ComponentListener; //导入依赖的package包/类
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();
}
 

import java.awt.event.ComponentListener; //导入依赖的package包/类
/** 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;
}
 

import java.awt.event.ComponentListener; //导入依赖的package包/类
@Override
public void removeNotify() {
    super.removeNotify();
    for (ComponentListener l : getComponentListeners()) {
        super.removeComponentListener(l);
    }
}