| /* BasicPopupMenuUI.java |
| Copyright (C) 2002, 2004, 2005 Free Software Foundation, Inc. |
| |
| This file is part of GNU Classpath. |
| |
| GNU Classpath is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 2, or (at your option) |
| any later version. |
| |
| GNU Classpath is distributed in the hope that it will be useful, but |
| WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with GNU Classpath; see the file COPYING. If not, write to the |
| Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA |
| 02110-1301 USA. |
| |
| Linking this library statically or dynamically with other modules is |
| making a combined work based on this library. Thus, the terms and |
| conditions of the GNU General Public License cover the whole |
| combination. |
| |
| As a special exception, the copyright holders of this library give you |
| permission to link this library with independent modules to produce an |
| executable, regardless of the license terms of these independent |
| modules, and to copy and distribute the resulting executable under |
| terms of your choice, provided that you also meet, for each linked |
| independent module, the terms and conditions of the license of that |
| module. An independent module is a module which is not derived from |
| or based on this library. If you modify this library, you may extend |
| this exception to your version of the library, but you are not |
| obligated to do so. If you do not wish to do so, delete this |
| exception statement from your version. */ |
| |
| package javax.swing.plaf.basic; |
| |
| import java.awt.Component; |
| import java.awt.Dimension; |
| import java.awt.KeyboardFocusManager; |
| import java.awt.event.ActionEvent; |
| import java.awt.event.ComponentEvent; |
| import java.awt.event.ComponentListener; |
| import java.awt.event.MouseEvent; |
| import java.util.EventListener; |
| |
| import javax.swing.AbstractAction; |
| import javax.swing.Action; |
| import javax.swing.ActionMap; |
| import javax.swing.BoxLayout; |
| import javax.swing.InputMap; |
| import javax.swing.JApplet; |
| import javax.swing.JComponent; |
| import javax.swing.JFrame; |
| import javax.swing.JMenu; |
| import javax.swing.JMenuBar; |
| import javax.swing.JMenuItem; |
| import javax.swing.JPopupMenu; |
| import javax.swing.JRootPane; |
| import javax.swing.LookAndFeel; |
| import javax.swing.MenuElement; |
| import javax.swing.MenuSelectionManager; |
| import javax.swing.SwingUtilities; |
| import javax.swing.UIManager; |
| import javax.swing.event.ChangeEvent; |
| import javax.swing.event.ChangeListener; |
| import javax.swing.event.PopupMenuEvent; |
| import javax.swing.event.PopupMenuListener; |
| import javax.swing.plaf.ActionMapUIResource; |
| import javax.swing.plaf.ComponentUI; |
| import javax.swing.plaf.PopupMenuUI; |
| |
| /** |
| * UI Delegate for JPopupMenu |
| */ |
| public class BasicPopupMenuUI extends PopupMenuUI |
| { |
| /** |
| * Handles keyboard navigation through menus. |
| */ |
| private static class NavigateAction |
| extends AbstractAction |
| { |
| |
| /** |
| * Creates a new NavigateAction instance. |
| * |
| * @param name the name of the action |
| */ |
| NavigateAction(String name) |
| { |
| super(name); |
| } |
| |
| /** |
| * Actually performs the action. |
| */ |
| public void actionPerformed(ActionEvent event) |
| { |
| String name = (String) getValue(Action.NAME); |
| if (name.equals("selectNext")) |
| navigateNextPrevious(true); |
| else if (name.equals("selectPrevious")) |
| navigateNextPrevious(false); |
| else if (name.equals("selectChild")) |
| navigateParentChild(true); |
| else if (name.equals("selectParent")) |
| navigateParentChild(false); |
| else if (name.equals("cancel")) |
| cancel(); |
| else if (name.equals("return")) |
| doReturn(); |
| else |
| assert false : "Must not reach here"; |
| } |
| |
| /** |
| * Navigates to the next or previous menu item. |
| * |
| * @param dir <code>true</code>: navigate to next, <code>false</code>: |
| * navigate to previous |
| */ |
| private void navigateNextPrevious(boolean dir) |
| { |
| MenuSelectionManager msm = MenuSelectionManager.defaultManager(); |
| MenuElement path[] = msm.getSelectedPath(); |
| int len = path.length; |
| if (len >= 2) |
| { |
| |
| if (path[0] instanceof JMenuBar && |
| path[1] instanceof JMenu && len == 2) |
| { |
| |
| // A toplevel menu is selected, but its popup not yet shown. |
| // Show the popup and select the first item |
| JPopupMenu popup = ((JMenu)path[1]).getPopupMenu(); |
| MenuElement next = |
| findEnabledChild(popup.getSubElements(), -1, true); |
| MenuElement[] newPath; |
| |
| if (next != null) |
| { |
| newPath = new MenuElement[4]; |
| newPath[3] = next; |
| } |
| else |
| { |
| // Menu has no enabled items, show the popup anyway. |
| newPath = new MenuElement[3]; |
| } |
| System.arraycopy(path, 0, newPath, 0, 2); |
| newPath[2] = popup; |
| msm.setSelectedPath(newPath); |
| } |
| else if (path[len - 1] instanceof JPopupMenu && |
| path[len - 2] instanceof JMenu) |
| { |
| // Select next item in already shown popup menu. |
| JMenu menu = (JMenu) path[len - 2]; |
| JPopupMenu popup = menu.getPopupMenu(); |
| MenuElement next = |
| findEnabledChild(popup.getSubElements(), -1, dir); |
| |
| if (next != null) |
| { |
| MenuElement[] newPath = new MenuElement[len + 1]; |
| System.arraycopy(path, 0, newPath, 0, len); |
| newPath[len] = next; |
| msm.setSelectedPath(newPath); |
| } |
| else |
| { |
| // All items in the popup are disabled. |
| // Find the parent popup menu and select |
| // its next item. If there's no parent popup menu , do nothing. |
| if (len > 2 && path[len - 3] instanceof JPopupMenu) |
| { |
| popup = ((JPopupMenu) path[len - 3]); |
| next = findEnabledChild(popup.getSubElements(), |
| menu, dir); |
| if (next != null && next != menu) |
| { |
| MenuElement[] newPath = new MenuElement[len - 1]; |
| System.arraycopy(path, 0, newPath, 0, len - 2); |
| newPath[len - 2] = next; |
| msm.setSelectedPath(newPath); |
| } |
| } |
| } |
| } |
| else |
| { |
| // Only select the next item. |
| MenuElement subs[] = path[len - 2].getSubElements(); |
| MenuElement nextChild = |
| findEnabledChild(subs, path[len - 1], dir); |
| if (nextChild == null) |
| { |
| nextChild = findEnabledChild(subs, -1, dir); |
| } |
| if (nextChild != null) |
| { |
| path[len-1] = nextChild; |
| msm.setSelectedPath(path); |
| } |
| } |
| } |
| } |
| |
| private MenuElement findEnabledChild(MenuElement[] children, |
| MenuElement start, boolean dir) |
| { |
| MenuElement found = null; |
| for (int i = 0; i < children.length && found == null; i++) |
| { |
| if (children[i] == start) |
| { |
| found = findEnabledChild(children, i, dir); |
| } |
| } |
| return found; |
| } |
| |
| /** |
| * Searches the next or previous enabled child menu element. |
| * |
| * @param children the children to search through |
| * @param start the index at which to start |
| * @param dir the direction (true == forward, false == backward) |
| * |
| * @return the found element or null |
| */ |
| private MenuElement findEnabledChild(MenuElement[] children, |
| int start, boolean dir) |
| { |
| MenuElement result = null; |
| if (dir) |
| { |
| result = findNextEnabledChild(children, start + 1, children.length-1); |
| if (result == null) |
| result = findNextEnabledChild(children, 0, start - 1); |
| } |
| else |
| { |
| result = findPreviousEnabledChild(children, start - 1, 0); |
| if (result == null) |
| result = findPreviousEnabledChild(children, children.length-1, |
| start + 1); |
| } |
| return result; |
| } |
| |
| /** |
| * Finds the next child element that is enabled and visible. |
| * |
| * @param children the children to search through |
| * @param start the start index |
| * @param end the end index |
| * |
| * @return the found child, or null |
| */ |
| private MenuElement findNextEnabledChild(MenuElement[] children, int start, |
| int end) |
| { |
| MenuElement found = null; |
| for (int i = start; i <= end && found == null; i++) |
| { |
| if (children[i] != null) |
| { |
| Component comp = children[i].getComponent(); |
| if (comp != null && comp.isEnabled() && comp.isVisible()) |
| { |
| found = children[i]; |
| } |
| } |
| } |
| return found; |
| } |
| |
| /** |
| * Finds the previous child element that is enabled and visible. |
| * |
| * @param children the children to search through |
| * @param start the start index |
| * @param end the end index |
| * |
| * @return the found child, or null |
| */ |
| private MenuElement findPreviousEnabledChild(MenuElement[] children, |
| int start, int end) |
| { |
| MenuElement found = null; |
| for (int i = start; i >= end && found == null; i--) |
| { |
| if (children[i] != null) |
| { |
| Component comp = children[i].getComponent(); |
| if (comp != null && comp.isEnabled() && comp.isVisible()) |
| { |
| found = children[i]; |
| } |
| } |
| } |
| return found; |
| } |
| |
| /** |
| * Navigates to the parent or child menu item. |
| * |
| * @param selectChild <code>true</code>: navigate to child, |
| * <code>false</code>: navigate to parent |
| */ |
| private void navigateParentChild(boolean selectChild) |
| { |
| MenuSelectionManager msm = MenuSelectionManager.defaultManager(); |
| MenuElement path[] = msm.getSelectedPath(); |
| int len = path.length; |
| |
| if (selectChild) |
| { |
| if (len > 0 && path[len - 1] instanceof JMenu |
| && ! ((JMenu) path[len-1]).isTopLevelMenu()) |
| { |
| // We have a submenu, open it. |
| JMenu menu = (JMenu) path[len - 1]; |
| JPopupMenu popup = menu.getPopupMenu(); |
| MenuElement[] subs = popup.getSubElements(); |
| MenuElement item = findEnabledChild(subs, -1, true); |
| MenuElement[] newPath; |
| |
| if (item == null) |
| { |
| newPath = new MenuElement[len + 1]; |
| } |
| else |
| { |
| newPath = new MenuElement[len + 2]; |
| newPath[len + 1] = item; |
| } |
| System.arraycopy(path, 0, newPath, 0, len); |
| newPath[len] = popup; |
| msm.setSelectedPath(newPath); |
| return; |
| } |
| } |
| else |
| { |
| int popupIndex = len-1; |
| if (len > 2 |
| && (path[popupIndex] instanceof JPopupMenu |
| || path[--popupIndex] instanceof JPopupMenu) |
| && ! ((JMenu) path[popupIndex - 1]).isTopLevelMenu()) |
| { |
| // We have a submenu, close it. |
| MenuElement newPath[] = new MenuElement[popupIndex]; |
| System.arraycopy(path, 0, newPath, 0, popupIndex); |
| msm.setSelectedPath(newPath); |
| return; |
| } |
| } |
| |
| // If we got here, we have not selected a child or parent. |
| // Check if we have a toplevel menu selected. If so, then select |
| // another one. |
| if (len > 1 && path[0] instanceof JMenuBar) |
| { |
| MenuElement currentMenu = path[1]; |
| MenuElement nextMenu = findEnabledChild(path[0].getSubElements(), |
| currentMenu, selectChild); |
| |
| if (nextMenu != null && nextMenu != currentMenu) |
| { |
| MenuElement newSelection[]; |
| if (len == 2) |
| { |
| // Menu is selected but its popup not shown. |
| newSelection = new MenuElement[2]; |
| newSelection[0] = path[0]; |
| newSelection[1] = nextMenu; |
| } |
| else |
| { |
| // Menu is selected and its popup is shown. |
| newSelection = new MenuElement[3]; |
| newSelection[0] = path[0]; |
| newSelection[1] = nextMenu; |
| newSelection[2] = ((JMenu) nextMenu).getPopupMenu(); |
| } |
| msm.setSelectedPath(newSelection); |
| } |
| } |
| } |
| |
| /** |
| * Handles cancel requests (ESC key). |
| */ |
| private void cancel() |
| { |
| // Fire popup menu cancelled event. Unfortunately the |
| // firePopupMenuCancelled() is protected in JPopupMenu so we work |
| // around this limitation by fetching the listeners and notifying them |
| // directly. |
| JPopupMenu lastPopup = (JPopupMenu) getLastPopup(); |
| EventListener[] ll = lastPopup.getListeners(PopupMenuListener.class); |
| for (int i = 0; i < ll.length; i++) |
| { |
| PopupMenuEvent ev = new PopupMenuEvent(lastPopup); |
| ((PopupMenuListener) ll[i]).popupMenuCanceled(ev); |
| } |
| |
| // Close the last popup or the whole selection if there's only one |
| // popup left. |
| MenuSelectionManager msm = MenuSelectionManager.defaultManager(); |
| MenuElement path[] = msm.getSelectedPath(); |
| if(path.length > 4) |
| { |
| MenuElement newPath[] = new MenuElement[path.length - 2]; |
| System.arraycopy(path,0,newPath,0,path.length-2); |
| MenuSelectionManager.defaultManager().setSelectedPath(newPath); |
| } |
| else |
| msm.clearSelectedPath(); |
| } |
| |
| /** |
| * Returns the last popup menu in the current selection or null. |
| * |
| * @return the last popup menu in the current selection or null |
| */ |
| private JPopupMenu getLastPopup() |
| { |
| MenuSelectionManager msm = MenuSelectionManager.defaultManager(); |
| MenuElement[] p = msm.getSelectedPath(); |
| JPopupMenu popup = null; |
| for(int i = p.length - 1; popup == null && i >= 0; i--) |
| { |
| if (p[i] instanceof JPopupMenu) |
| popup = (JPopupMenu) p[i]; |
| } |
| return popup; |
| } |
| |
| /** |
| * Handles ENTER key requests. This normally opens submenus on JMenu |
| * items, or activates the menu item as if it's been clicked on it. |
| */ |
| private void doReturn() |
| { |
| KeyboardFocusManager fmgr = |
| KeyboardFocusManager.getCurrentKeyboardFocusManager(); |
| Component focusOwner = fmgr.getFocusOwner(); |
| if((focusOwner == null || (focusOwner instanceof JRootPane))) |
| { |
| MenuSelectionManager msm = MenuSelectionManager.defaultManager(); |
| MenuElement path[] = msm.getSelectedPath(); |
| MenuElement lastElement; |
| if(path.length > 0) |
| { |
| lastElement = path[path.length - 1]; |
| if(lastElement instanceof JMenu) |
| { |
| MenuElement newPath[] = new MenuElement[path.length + 1]; |
| System.arraycopy(path,0,newPath,0,path.length); |
| newPath[path.length] = ((JMenu) lastElement).getPopupMenu(); |
| msm.setSelectedPath(newPath); |
| } |
| else if(lastElement instanceof JMenuItem) |
| { |
| JMenuItem mi = (JMenuItem)lastElement; |
| if (mi.getUI() instanceof BasicMenuItemUI) |
| { |
| ((BasicMenuItemUI)mi.getUI()).doClick(msm); |
| } |
| else |
| { |
| msm.clearSelectedPath(); |
| mi.doClick(0); |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| /** |
| * Installs keyboard actions when a popup is opened, and uninstalls the |
| * keyboard actions when closed. This listens on the default |
| * MenuSelectionManager. |
| */ |
| private class KeyboardHelper |
| implements ChangeListener |
| { |
| private MenuElement[] lastSelectedPath = new MenuElement[0]; |
| private Component lastFocused; |
| private JRootPane invokerRootPane; |
| |
| public void stateChanged(ChangeEvent event) |
| { |
| MenuSelectionManager msm = (MenuSelectionManager) event.getSource(); |
| MenuElement[] p = msm.getSelectedPath(); |
| JPopupMenu popup = getActivePopup(p); |
| if (popup == null || popup.isFocusable()) |
| { |
| if (lastSelectedPath.length != 0 && p.length != 0 ) |
| { |
| if (! invokerEquals(p[0], lastSelectedPath[0])) |
| { |
| uninstallKeyboardActionsImpl(); |
| lastSelectedPath = new MenuElement[0]; |
| } |
| } |
| |
| if (lastSelectedPath.length == 0 && p.length > 0) |
| { |
| JComponent invoker; |
| if (popup == null) |
| { |
| if (p.length == 2 && p[0] instanceof JMenuBar |
| && p[1] instanceof JMenu) |
| { |
| // A menu has been selected but not opened. |
| invoker = (JComponent)p[1]; |
| popup = ((JMenu)invoker).getPopupMenu(); |
| } |
| else |
| { |
| return; |
| } |
| } |
| else |
| { |
| Component c = popup.getInvoker(); |
| if(c instanceof JFrame) |
| { |
| invoker = ((JFrame) c).getRootPane(); |
| } |
| else if(c instanceof JApplet) |
| { |
| invoker = ((JApplet) c).getRootPane(); |
| } |
| else |
| { |
| while (!(c instanceof JComponent)) |
| { |
| if (c == null) |
| { |
| return; |
| } |
| c = c.getParent(); |
| } |
| invoker = (JComponent)c; |
| } |
| } |
| |
| // Remember current focus owner. |
| lastFocused = KeyboardFocusManager. |
| getCurrentKeyboardFocusManager().getFocusOwner(); |
| |
| // Install keybindings used for menu navigation. |
| invokerRootPane = SwingUtilities.getRootPane(invoker); |
| if (invokerRootPane != null) |
| { |
| invokerRootPane.requestFocus(true); |
| installKeyboardActionsImpl(); |
| } |
| } |
| else if (lastSelectedPath.length != 0 && p.length == 0) |
| { |
| // menu hidden -- return focus to where it had been before |
| // and uninstall menu keybindings |
| uninstallKeyboardActionsImpl(); |
| } |
| } |
| |
| // Remember the last path selected |
| lastSelectedPath = p; |
| } |
| |
| private JPopupMenu getActivePopup(MenuElement[] path) |
| { |
| JPopupMenu active = null; |
| for (int i = path.length - 1; i >= 0 && active == null; i--) |
| { |
| MenuElement elem = path[i]; |
| if (elem instanceof JPopupMenu) |
| { |
| active = (JPopupMenu) elem; |
| } |
| } |
| return active; |
| } |
| |
| private boolean invokerEquals(MenuElement el1, MenuElement el2) |
| { |
| Component invoker1 = el1.getComponent(); |
| Component invoker2 = el2.getComponent(); |
| if (invoker1 instanceof JPopupMenu) |
| invoker1 = ((JPopupMenu) invoker1).getInvoker(); |
| if (invoker2 instanceof JPopupMenu) |
| invoker2 = ((JPopupMenu) invoker2).getInvoker(); |
| return invoker1 == invoker2; |
| } |
| } |
| |
| /* popupMenu for which this UI delegate is for*/ |
| protected JPopupMenu popupMenu; |
| |
| /* PopupMenuListener listens to popup menu events fired by JPopupMenu*/ |
| private transient PopupMenuListener popupMenuListener; |
| |
| /* ComponentListener listening to popupMenu's invoker. |
| * This is package-private to avoid an accessor method. */ |
| TopWindowListener topWindowListener; |
| |
| /** |
| * Counts how many popup menus are handled by this UI or a subclass. |
| * This is used to install a KeyboardHelper on the MenuSelectionManager |
| * for the first popup, and uninstall this same KeyboardHelper when the |
| * last popup is uninstalled. |
| */ |
| private static int numPopups; |
| |
| /** |
| * This is the KeyboardHelper that listens on the MenuSelectionManager. |
| */ |
| private static KeyboardHelper keyboardHelper; |
| |
| /** |
| * Creates a new BasicPopupMenuUI object. |
| */ |
| public BasicPopupMenuUI() |
| { |
| popupMenuListener = new PopupMenuHandler(); |
| topWindowListener = new TopWindowListener(); |
| } |
| |
| /** |
| * Factory method to create a BasicPopupMenuUI for the given {@link |
| * JComponent}, which should be a {@link JMenuItem}. |
| * |
| * @param x The {@link JComponent} a UI is being created for. |
| * |
| * @return A BasicPopupMenuUI for the {@link JComponent}. |
| */ |
| public static ComponentUI createUI(JComponent x) |
| { |
| return new BasicPopupMenuUI(); |
| } |
| |
| /** |
| * Installs and initializes all fields for this UI delegate. Any properties |
| * of the UI that need to be initialized and/or set to defaults will be |
| * done now. It will also install any listeners necessary. |
| * |
| * @param c The {@link JComponent} that is having this UI installed. |
| */ |
| public void installUI(JComponent c) |
| { |
| super.installUI(c); |
| |
| // Install KeyboardHelper when the first popup is initialized. |
| if (numPopups == 0) |
| { |
| keyboardHelper = new KeyboardHelper(); |
| MenuSelectionManager msm = MenuSelectionManager.defaultManager(); |
| msm.addChangeListener(keyboardHelper); |
| } |
| numPopups++; |
| |
| popupMenu = (JPopupMenu) c; |
| popupMenu.setLayout(new DefaultMenuLayout(popupMenu, BoxLayout.Y_AXIS)); |
| popupMenu.setBorderPainted(true); |
| JPopupMenu.setDefaultLightWeightPopupEnabled(true); |
| |
| installDefaults(); |
| installListeners(); |
| installKeyboardActions(); |
| } |
| |
| /** |
| * This method installs the defaults that are defined in the Basic look |
| * and feel for this {@link JPopupMenu}. |
| */ |
| public void installDefaults() |
| { |
| LookAndFeel.installColorsAndFont(popupMenu, "PopupMenu.background", |
| "PopupMenu.foreground", "PopupMenu.font"); |
| LookAndFeel.installBorder(popupMenu, "PopupMenu.border"); |
| popupMenu.setOpaque(true); |
| } |
| |
| /** |
| * This method installs the listeners for the {@link JMenuItem}. |
| */ |
| protected void installListeners() |
| { |
| popupMenu.addPopupMenuListener(popupMenuListener); |
| } |
| |
| /** |
| * This method installs the keyboard actions for this {@link JPopupMenu}. |
| */ |
| protected void installKeyboardActions() |
| { |
| // We can't install the keyboard actions here, because then all |
| // popup menus would have their actions registered in the KeyboardManager. |
| // So we install it when the popup menu is opened, and uninstall it |
| // when it's closed. This is done in the KeyboardHelper class. |
| // Install InputMap. |
| } |
| |
| /** |
| * Called by the KeyboardHandler when a popup is made visible. |
| */ |
| void installKeyboardActionsImpl() |
| { |
| Object[] bindings; |
| if (popupMenu.getComponentOrientation().isLeftToRight()) |
| { |
| bindings = (Object[]) |
| SharedUIDefaults.get("PopupMenu.selectedWindowInputMapBindings"); |
| } |
| else |
| { |
| bindings = (Object[]) SharedUIDefaults.get |
| ("PopupMenu.selectedWindowInputMapBindings.RightToLeft"); |
| } |
| InputMap inputMap = LookAndFeel.makeComponentInputMap(popupMenu, bindings); |
| SwingUtilities.replaceUIInputMap(popupMenu, |
| JComponent.WHEN_IN_FOCUSED_WINDOW, |
| inputMap); |
| |
| // Install ActionMap. |
| SwingUtilities.replaceUIActionMap(popupMenu, getActionMap()); |
| } |
| |
| /** |
| * Creates and returns the shared action map for JTrees. |
| * |
| * @return the shared action map for JTrees |
| */ |
| private ActionMap getActionMap() |
| { |
| ActionMap am = (ActionMap) UIManager.get("PopupMenu.actionMap"); |
| if (am == null) |
| { |
| am = createDefaultActions(); |
| UIManager.getLookAndFeelDefaults().put("PopupMenu.actionMap", am); |
| } |
| return am; |
| } |
| |
| /** |
| * Creates the default actions when there are none specified by the L&F. |
| * |
| * @return the default actions |
| */ |
| private ActionMap createDefaultActions() |
| { |
| ActionMapUIResource am = new ActionMapUIResource(); |
| Action action = new NavigateAction("selectNext"); |
| am.put(action.getValue(Action.NAME), action); |
| action = new NavigateAction("selectPrevious"); |
| am.put(action.getValue(Action.NAME), action); |
| action = new NavigateAction("selectParent"); |
| am.put(action.getValue(Action.NAME), action); |
| action = new NavigateAction("selectChild"); |
| am.put(action.getValue(Action.NAME), action); |
| action = new NavigateAction("return"); |
| am.put(action.getValue(Action.NAME), action); |
| action = new NavigateAction("cancel"); |
| am.put(action.getValue(Action.NAME), action); |
| |
| return am; |
| } |
| |
| /** |
| * Performs the opposite of installUI. Any properties or resources that need |
| * to be cleaned up will be done now. It will also uninstall any listeners |
| * it has. In addition, any properties of this UI will be nulled. |
| * |
| * @param c The {@link JComponent} that is having this UI uninstalled. |
| */ |
| public void uninstallUI(JComponent c) |
| { |
| uninstallListeners(); |
| uninstallDefaults(); |
| uninstallKeyboardActions(); |
| popupMenu = null; |
| |
| // Install KeyboardHelper when the first popup is initialized. |
| numPopups--; |
| if (numPopups == 0) |
| { |
| MenuSelectionManager msm = MenuSelectionManager.defaultManager(); |
| msm.removeChangeListener(keyboardHelper); |
| } |
| |
| } |
| |
| /** |
| * This method uninstalls the defaults and sets any objects created during |
| * install to null |
| */ |
| protected void uninstallDefaults() |
| { |
| popupMenu.setBackground(null); |
| popupMenu.setBorder(null); |
| popupMenu.setFont(null); |
| popupMenu.setForeground(null); |
| } |
| |
| /** |
| * Unregisters all the listeners that this UI delegate was using. |
| */ |
| protected void uninstallListeners() |
| { |
| popupMenu.removePopupMenuListener(popupMenuListener); |
| } |
| |
| /** |
| * Uninstalls any keyboard actions. |
| */ |
| protected void uninstallKeyboardActions() |
| { |
| // We can't install the keyboard actions here, because then all |
| // popup menus would have their actions registered in the KeyboardManager. |
| // So we install it when the popup menu is opened, and uninstall it |
| // when it's closed. This is done in the KeyboardHelper class. |
| // Install InputMap. |
| } |
| |
| /** |
| * Called by the KeyboardHandler when a popup is made invisible. |
| */ |
| void uninstallKeyboardActionsImpl() |
| { |
| SwingUtilities.replaceUIInputMap(popupMenu, |
| JComponent.WHEN_IN_FOCUSED_WINDOW, null); |
| SwingUtilities.replaceUIActionMap(popupMenu, null); |
| } |
| |
| /** |
| * This method returns the minimum size of the JPopupMenu. |
| * |
| * @param c The JComponent to find a size for. |
| * |
| * @return The minimum size. |
| */ |
| public Dimension getMinimumSize(JComponent c) |
| { |
| return null; |
| } |
| |
| /** |
| * This method returns the preferred size of the JPopupMenu. |
| * |
| * @param c The JComponent to find a size for. |
| * |
| * @return The preferred size. |
| */ |
| public Dimension getPreferredSize(JComponent c) |
| { |
| return null; |
| } |
| |
| /** |
| * This method returns the minimum size of the JPopupMenu. |
| * |
| * @param c The JComponent to find a size for. |
| * |
| * @return The minimum size. |
| */ |
| public Dimension getMaximumSize(JComponent c) |
| { |
| return null; |
| } |
| |
| /** |
| * Return true if given mouse event is a platform popup trigger, and false |
| * otherwise |
| * |
| * @param e MouseEvent that is to be checked for popup trigger event |
| * |
| * @return true if given mouse event is a platform popup trigger, and false |
| * otherwise |
| */ |
| public boolean isPopupTrigger(MouseEvent e) |
| { |
| return false; |
| } |
| |
| /** |
| * This listener handles PopupMenuEvents fired by JPopupMenu |
| */ |
| private class PopupMenuHandler implements PopupMenuListener |
| { |
| /** |
| * This method is invoked when JPopupMenu is cancelled. |
| * |
| * @param event the PopupMenuEvent |
| */ |
| public void popupMenuCanceled(PopupMenuEvent event) |
| { |
| MenuSelectionManager manager = MenuSelectionManager.defaultManager(); |
| manager.clearSelectedPath(); |
| } |
| |
| /** |
| * This method is invoked when JPopupMenu becomes invisible |
| * |
| * @param event the PopupMenuEvent |
| */ |
| public void popupMenuWillBecomeInvisible(PopupMenuEvent event) |
| { |
| // remove listener that listens to component events fired |
| // by the top - level window that this popup belongs to. |
| Component invoker = popupMenu.getInvoker(); |
| Component rootContainer = SwingUtilities.getRoot(invoker); |
| if (rootContainer != null) |
| rootContainer.removeComponentListener(topWindowListener); |
| } |
| |
| /** |
| * This method is invoked when JPopupMenu becomes visible |
| * |
| * @param event the PopupMenuEvent |
| */ |
| public void popupMenuWillBecomeVisible(PopupMenuEvent event) |
| { |
| // Adds topWindowListener to top-level window to listener to |
| // ComponentEvents fired by it. We need to cancel this popup menu |
| // if topWindow to which this popup belongs was resized or moved. |
| Component invoker = popupMenu.getInvoker(); |
| Component rootContainer = SwingUtilities.getRoot(invoker); |
| if (rootContainer != null) |
| rootContainer.addComponentListener(topWindowListener); |
| |
| // if this popup menu is a free floating popup menu, |
| // then by default its first element should be always selected when |
| // this popup menu becomes visible. |
| MenuSelectionManager manager = MenuSelectionManager.defaultManager(); |
| |
| if (manager.getSelectedPath().length == 0) |
| { |
| // Set selected path to point to the first item in the popup menu |
| MenuElement[] path = new MenuElement[2]; |
| path[0] = popupMenu; |
| Component[] comps = popupMenu.getComponents(); |
| if (comps.length != 0 && comps[0] instanceof MenuElement) |
| { |
| path[1] = (MenuElement) comps[0]; |
| manager.setSelectedPath(path); |
| } |
| } |
| } |
| } |
| |
| /** |
| * ComponentListener that listens to Component Events fired by the top - |
| * level window to which popup menu belongs. If top-level window was |
| * resized, moved or hidded then popup menu will be hidded and selected |
| * path of current menu hierarchy will be set to null. |
| */ |
| private class TopWindowListener implements ComponentListener |
| { |
| /** |
| * This method is invoked when top-level window is resized. This method |
| * closes current menu hierarchy. |
| * |
| * @param e The ComponentEvent |
| */ |
| public void componentResized(ComponentEvent e) |
| { |
| MenuSelectionManager manager = MenuSelectionManager.defaultManager(); |
| manager.clearSelectedPath(); |
| } |
| |
| /** |
| * This method is invoked when top-level window is moved. This method |
| * closes current menu hierarchy. |
| * |
| * @param e The ComponentEvent |
| */ |
| public void componentMoved(ComponentEvent e) |
| { |
| MenuSelectionManager manager = MenuSelectionManager.defaultManager(); |
| manager.clearSelectedPath(); |
| } |
| |
| /** |
| * This method is invoked when top-level window is shown This method |
| * does nothing by default. |
| * |
| * @param e The ComponentEvent |
| */ |
| public void componentShown(ComponentEvent e) |
| { |
| MenuSelectionManager manager = MenuSelectionManager.defaultManager(); |
| manager.clearSelectedPath(); |
| } |
| |
| /** |
| * This method is invoked when top-level window is hidden This method |
| * closes current menu hierarchy. |
| * |
| * @param e The ComponentEvent |
| */ |
| public void componentHidden(ComponentEvent e) |
| { |
| MenuSelectionManager manager = MenuSelectionManager.defaultManager(); |
| manager.clearSelectedPath(); |
| } |
| } |
| |
| } |
