basicmenuui.java

java jdk 1.4的源码

/*
 * @(#)BasicMenuUI.java	1.151 03/05/06
 *
 * Copyright 2003 Sun Microsystems, Inc. All rights reserved.
 * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */

package javax.swing.plaf.basic;

import java.awt.*;
import java.awt.event.*;
import java.beans.*;
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.plaf.*;
import javax.swing.border.*;
import java.util.Arrays;
import java.util.ArrayList;


/**
 * A default L&F implementation of MenuUI.  This implementation 
 * is a "combined" view/controller.
 *
 * @version 1.151 05/06/03
 * @author Georges Saab
 * @author David Karlton
 * @author Arnaud Weber
 */
public class BasicMenuUI extends BasicMenuItemUI 
{
    protected ChangeListener         changeListener;
    protected PropertyChangeListener propertyChangeListener;
    protected MenuListener           menuListener;

    private int lastMnemonic = 0;

    /** Uses as the parent of the windowInputMap when selected. */
    private InputMap selectedWindowInputMap;

    /* diagnostic aids -- should be false for production builds. */
    private static final boolean TRACE =   false; // trace creates and disposes
    private static final boolean VERBOSE = false; // show reuse hits/misses
    private static final boolean DEBUG =   false;  // show bad params, misc.

    private static boolean crossMenuMnemonic = true;

    public static ComponentUI createUI(JComponent x) {
	return new BasicMenuUI();
    }

    protected void installDefaults() {
	super.installDefaults();
	updateDefaultBackgroundColor();
	((JMenu)menuItem).setDelay(200);
        crossMenuMnemonic = UIManager.getBoolean("Menu.crossMenuMnemonic");
    }

    protected String getPropertyPrefix() {
	return "Menu";
    }

    protected void installListeners() {
	super.installListeners();

	if (changeListener == null)
	    changeListener = createChangeListener(menuItem);

	if (changeListener != null)
	    menuItem.addChangeListener(changeListener);

	if (propertyChangeListener == null)
	    propertyChangeListener = createPropertyChangeListener(menuItem);

	if (propertyChangeListener != null)
	    menuItem.addPropertyChangeListener(propertyChangeListener);
	    
	if (menuListener == null)
	    menuListener = createMenuListener(menuItem);

	if (menuListener != null)
	    ((JMenu)menuItem).addMenuListener(menuListener);
    }

    protected void installKeyboardActions() {
	super.installKeyboardActions();
	updateMnemonicBinding();
    }

    void updateMnemonicBinding() {
	int mnemonic = menuItem.getModel().getMnemonic();
        int[] shortcutKeys = (int[])UIManager.get("Menu.shortcutKeys");
	if (mnemonic == lastMnemonic || shortcutKeys == null) {
	    return;
	}
	if (lastMnemonic != 0 && windowInputMap != null) {
            for (int i=0; i<shortcutKeys.length; i++) {
                windowInputMap.remove(KeyStroke.getKeyStroke
                                      (lastMnemonic, shortcutKeys[i], false));
            }
	}
	if (mnemonic != 0) {
	    if (windowInputMap == null) {
		windowInputMap = createInputMap(JComponent.
					      WHEN_IN_FOCUSED_WINDOW);
		SwingUtilities.replaceUIInputMap(menuItem, JComponent.
				       WHEN_IN_FOCUSED_WINDOW, windowInputMap);
	    }
            for (int i=0; i<shortcutKeys.length; i++) {
                windowInputMap.put(KeyStroke.getKeyStroke(mnemonic,
                                         shortcutKeys[i], false),
                                   "selectMenu");
            }
        }
	lastMnemonic = mnemonic;
    }

    protected void uninstallKeyboardActions() {
	super.uninstallKeyboardActions();
    }

    /**
     * The ActionMap for BasicMenUI can not be shared, this is subclassed
     * to create a new one for each invocation.
     */
    ActionMap getActionMap() {
	return createActionMap();
    }

    /**
     * Invoked to create the ActionMap.
     */
    ActionMap createActionMap() {
	ActionMap am = super.createActionMap();
	if (am != null) {
	    am.put("selectMenu", new PostAction((JMenu)menuItem, true));
	}
	return am;
    }

    protected MouseInputListener createMouseInputListener(JComponent c) {
	return new MouseInputHandler();
    }

    protected MenuListener createMenuListener(JComponent c) {
	return null;
    }

    protected ChangeListener createChangeListener(JComponent c) {
	return null;
    }

    protected PropertyChangeListener createPropertyChangeListener(JComponent c) {
        return new PropertyChangeHandler();
    }

    protected void uninstallDefaults() {
	menuItem.setArmed(false);
	menuItem.setSelected(false);
	menuItem.resetKeyboardActions();
	super.uninstallDefaults();
    }

    protected void uninstallListeners() {
	super.uninstallListeners();

	if (changeListener != null)
	    menuItem.removeChangeListener(changeListener);

	if (propertyChangeListener != null)
	    menuItem.removePropertyChangeListener(propertyChangeListener);

	if (menuListener != null)
	    ((JMenu)menuItem).removeMenuListener(menuListener);

	changeListener = null;
	propertyChangeListener = null;
	menuListener = null;
    }

    protected MenuDragMouseListener createMenuDragMouseListener(JComponent c) {
	return new MenuDragMouseHandler();
    }
    
    protected MenuKeyListener createMenuKeyListener(JComponent c) {
	return new MenuKeyHandler();
    }

    public Dimension getMaximumSize(JComponent c) {
	if (((JMenu)menuItem).isTopLevelMenu() == true) {
	    Dimension d = c.getPreferredSize();
	    return new Dimension(d.width, Short.MAX_VALUE);
	}
        return null;
    }

    protected void setupPostTimer(JMenu menu) {
        Timer timer = new Timer(menu.getDelay(),new PostAction(menu,false));
        timer.setRepeats(false);
        timer.start();
    }

    private static void appendPath(MenuElement[] path, MenuElement elem) {
        MenuElement newPath[] = new MenuElement[path.length+1];
        System.arraycopy(path, 0, newPath, 0, path.length);
        newPath[path.length] = elem;
        MenuSelectionManager.defaultManager().setSelectedPath(newPath);
    }

    private static class PostAction extends AbstractAction {
	JMenu menu;
        boolean force=false;

        PostAction(JMenu menu,boolean shouldForce) {
	    this.menu = menu;
            this.force = shouldForce;
	}
	
	public void actionPerformed(ActionEvent e) {
            if (!crossMenuMnemonic) {
                JPopupMenu pm = getActivePopupMenu();
                if (pm != null && pm != menu.getParent()) {
                    return;
                }
            }

	    final MenuSelectionManager defaultManager = MenuSelectionManager.defaultManager();
            if(force) {
                Container cnt = menu.getParent();
                if(cnt != null && cnt instanceof JMenuBar) {
                    MenuElement me[];
                    MenuElement subElements[];
		    
                    subElements = menu.getPopupMenu().getSubElements();
                    if(subElements.length > 0) {
                        me = new MenuElement[4];
                        me[0] = (MenuElement) cnt;
                        me[1] = (MenuElement) menu;
                        me[2] = (MenuElement) menu.getPopupMenu();
                        me[3] = subElements[0];
                    } else {
                        me = new MenuElement[3];
                        me[0] = (MenuElement)cnt;
                        me[1] = menu;
                        me[2] = (MenuElement) menu.getPopupMenu();
                    }
                    defaultManager.setSelectedPath(me);
		}
            } else {
                MenuElement path[] = defaultManager.getSelectedPath();
                if(path.length > 0 && path[path.length-1] == menu) {
                    appendPath(path, menu.getPopupMenu());
                }
            }
        }

	public boolean isEnabled() {
	    return menu.getModel().isEnabled();
	}
    }

    /*
     * Set the background color depending on whether this is a toplevel menu
     * in a menubar or a submenu of another menu.
     */
    private void updateDefaultBackgroundColor() {
	if (!UIManager.getBoolean("Menu.useMenuBarBackgroundForTopLevel")) {
	   return;
	}
	JMenu menu = (JMenu)menuItem;
	if (menu.getBackground() instanceof UIResource) {
	    if (menu.isTopLevelMenu()) {
		menu.setBackground(UIManager.getColor("MenuBar.background"));
	    } else {
		menu.setBackground(UIManager.getColor(getPropertyPrefix() + ".background"));
	    }
	}		    
    }

    private class PropertyChangeHandler implements PropertyChangeListener {
        public void propertyChange(PropertyChangeEvent e) {
	    String prop = e.getPropertyName();
	    if(prop.equals(AbstractButton.MNEMONIC_CHANGED_PROPERTY)) {
		updateMnemonicBinding();
	    } else if (prop == "ancestor") {
		updateDefaultBackgroundColor();
	    }
	}
    }

    /**
     * Instantiated and used by a menu item to handle the current menu selection
     * from mouse events. A MouseInputHandler processes and forwards all mouse events
     * to a shared instance of the MenuSelectionManager. 
     * <p>
     * This class is protected so that it can be subclassed by other look and
     * feels to implement their own mouse handling behavior. All overridden
     * methods should call the parent methods so that the menu selection
     * is correct.
     *
     * @see javax.swing.MenuSelectionManager
     * @since 1.4
     */
    protected class MouseInputHandler implements MouseInputListener {
	public void mouseClicked(MouseEvent e) {}

	/**
	 * Invoked when the mouse has been clicked on the menu. This
	 * method clears or sets the selection path of the
	 * MenuSelectionManager.
	 *