diff options
Diffstat (limited to 'libjava/classpath/javax/swing/JMenu.java')
| -rw-r--r-- | libjava/classpath/javax/swing/JMenu.java | 1290 |
1 files changed, 1290 insertions, 0 deletions
diff --git a/libjava/classpath/javax/swing/JMenu.java b/libjava/classpath/javax/swing/JMenu.java new file mode 100644 index 000000000..e715ff98d --- /dev/null +++ b/libjava/classpath/javax/swing/JMenu.java @@ -0,0 +1,1290 @@ +/* JMenu.java -- + Copyright (C) 2002, 2004, 2005, 2006 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; + +import java.awt.Component; +import java.awt.Dimension; +import java.awt.GraphicsConfiguration; +import java.awt.GraphicsDevice; +import java.awt.GraphicsEnvironment; +import java.awt.Insets; +import java.awt.Point; +import java.awt.Rectangle; +import java.awt.Toolkit; +import java.awt.event.KeyEvent; +import java.awt.event.WindowAdapter; +import java.awt.event.WindowEvent; +import java.beans.PropertyChangeEvent; +import java.beans.PropertyChangeListener; +import java.io.Serializable; +import java.util.ArrayList; +import java.util.EventListener; + +import javax.accessibility.Accessible; +import javax.accessibility.AccessibleContext; +import javax.accessibility.AccessibleRole; +import javax.accessibility.AccessibleSelection; +import javax.swing.event.ChangeEvent; +import javax.swing.event.ChangeListener; +import javax.swing.event.MenuEvent; +import javax.swing.event.MenuListener; +import javax.swing.plaf.MenuItemUI; + +/** + * This class represents a menu that can be added to a menu bar or + * can be a submenu in some other menu. When JMenu is selected it + * displays JPopupMenu containing its menu items. + * + * <p> + * JMenu's fires MenuEvents when this menu's selection changes. If this menu + * is selected, then fireMenuSelectedEvent() is invoked. In case when menu is + * deselected or cancelled, then fireMenuDeselectedEvent() or + * fireMenuCancelledEvent() is invoked, respectivelly. + * </p> + */ +public class JMenu extends JMenuItem implements Accessible, MenuElement +{ + /** + * Receives notifications when the JMenu's ButtonModel is changed and + * fires menuSelected or menuDeselected events when appropriate. + */ + private class MenuChangeListener + implements ChangeListener + { + /** + * Indicates the last selected state. + */ + private boolean selected; + + /** + * Receives notification when the JMenu's ButtonModel changes. + */ + public void stateChanged(ChangeEvent ev) + { + ButtonModel m = (ButtonModel) ev.getSource(); + boolean s = m.isSelected(); + if (s != selected) + { + if (s) + fireMenuSelected(); + else + fireMenuDeselected(); + selected = s; + } + } + } + + private static final long serialVersionUID = 4227225638931828014L; + + /** A Popup menu associated with this menu, which pops up when menu is selected */ + private JPopupMenu popupMenu = null; + + /** Whenever menu is selected or deselected the MenuEvent is fired to + menu's registered listeners. */ + private MenuEvent menuEvent = new MenuEvent(this); + + /*Amount of time, in milliseconds, that should pass before popupMenu + associated with this menu appears or disappers */ + private int delay; + + /* PopupListener */ + protected WinListener popupListener; + + /** + * Location at which popup menu associated with this menu will be + * displayed + */ + private Point menuLocation; + + /** + * The ChangeListener for the ButtonModel. + * + * @see MenuChangeListener + */ + private ChangeListener menuChangeListener; + + /** + * Creates a new JMenu object. + */ + public JMenu() + { + super(); + setOpaque(false); + } + + /** + * Creates a new <code>JMenu</code> with the specified label. + * + * @param text label for this menu + */ + public JMenu(String text) + { + super(text); + popupMenu = new JPopupMenu(); + popupMenu.setInvoker(this); + setOpaque(false); + } + + /** + * Creates a new <code>JMenu</code> object. + * + * @param action Action that is used to create menu item tha will be + * added to the menu. + */ + public JMenu(Action action) + { + super(action); + createActionChangeListener(this); + popupMenu = new JPopupMenu(); + popupMenu.setInvoker(this); + setOpaque(false); + } + + /** + * Creates a new <code>JMenu</code> with specified label and an option + * for this menu to be tear-off menu. + * + * @param text label for this menu + * @param tearoff true if this menu should be tear-off and false otherwise + */ + public JMenu(String text, boolean tearoff) + { + // FIXME: tearoff not implemented + this(text); + } + + /** + * Adds specified menu item to this menu + * + * @param item Menu item to add to this menu + * + * @return Menu item that was added + */ + public JMenuItem add(JMenuItem item) + { + return getPopupMenu().add(item); + } + + /** + * Adds specified component to this menu. + * + * @param component Component to add to this menu + * + * @return Component that was added + */ + public Component add(Component component) + { + getPopupMenu().insert(component, -1); + return component; + } + + /** + * Adds specified component to this menu at the given index + * + * @param component Component to add + * @param index Position of this menu item in the menu + * + * @return Component that was added + */ + public Component add(Component component, int index) + { + return getPopupMenu().add(component, index); + } + + /** + * Adds JMenuItem constructed with the specified label to this menu + * + * @param text label for the menu item that will be added + * + * @return Menu Item that was added to this menu + */ + public JMenuItem add(String text) + { + return add(new JMenuItem(text)); + } + + /** + * Adds JMenuItem constructed using properties from specified action. + * + * @param action action to construct the menu item with + * + * @return Menu Item that was added to this menu + */ + public JMenuItem add(Action action) + { + JMenuItem i = createActionComponent(action); + i.setAction(action); + add(i); + return i; + } + + /** + * Removes given menu item from this menu. Nothing happens if + * this menu doesn't contain specified menu item. + * + * @param item Menu Item which needs to be removed + */ + public void remove(JMenuItem item) + { + getPopupMenu().remove(item); + } + + /** + * Removes component at the specified index from this menu + * + * @param index Position of the component that needs to be removed in the menu + */ + public void remove(int index) + { + if (index < 0 || (index > 0 && getMenuComponentCount() == 0)) + throw new IllegalArgumentException(); + + if (getMenuComponentCount() > 0) + popupMenu.remove(index); + } + + /** + * Removes given component from this menu. + * + * @param component Component to remove + */ + public void remove(Component component) + { + int index = getPopupMenu().getComponentIndex(component); + if (index >= 0) + getPopupMenu().remove(index); + } + + /** + * Removes all menu items from the menu + */ + public void removeAll() + { + if (popupMenu != null) + popupMenu.removeAll(); + } + + /** + * Creates JMenuItem with the specified text and inserts it in the + * at the specified index + * + * @param text label for the new menu item + * @param index index at which to insert newly created menu item. + */ + public void insert(String text, int index) + { + this.insert(new JMenuItem(text), index); + } + + /** + * Creates JMenuItem with the specified text and inserts it in the + * at the specified index. IllegalArgumentException is thrown + * if index is less than 0 + * + * @param item menu item to insert + * @param index index at which to insert menu item. + * @return Menu item that was added to the menu + */ + public JMenuItem insert(JMenuItem item, int index) + { + if (index < 0) + throw new IllegalArgumentException("index less than zero"); + + getPopupMenu().insert(item, index); + return item; + } + + /** + * Creates JMenuItem with the associated action and inserts it to the menu + * at the specified index. IllegalArgumentException is thrown + * if index is less than 0 + * + * @param action Action for the new menu item + * @param index index at which to insert newly created menu item. + * @return Menu item that was added to the menu + */ + public JMenuItem insert(Action action, int index) + { + JMenuItem item = new JMenuItem(action); + this.insert(item, index); + + return item; + } + + /** + * This method sets this menuItem's UI to the UIManager's default for the + * current look and feel. + */ + public void updateUI() + { + setUI((MenuItemUI) UIManager.getUI(this)); + } + + /** + * This method returns a name to identify which look and feel class will be + * the UI delegate for the menu. + * + * @return The Look and Feel classID. "MenuUI" + */ + public String getUIClassID() + { + return "MenuUI"; + } + + /** + * Sets model for this menu. + * + * @param model model to set + */ + public void setModel(ButtonModel model) + { + ButtonModel oldModel = getModel(); + if (oldModel != null && menuChangeListener != null) + oldModel.removeChangeListener(menuChangeListener); + + super.setModel(model); + + if (model != null) + { + if (menuChangeListener == null) + menuChangeListener = new MenuChangeListener(); + model.addChangeListener(menuChangeListener); + } + } + + /** + * Returns true if the menu is selected and false otherwise + * + * @return true if the menu is selected and false otherwise + */ + public boolean isSelected() + { + return super.isSelected(); + } + + /** + * Changes this menu selected state if selected is true and false otherwise + * This method fires menuEvents to menu's registered listeners. + * + * @param selected true if the menu should be selected and false otherwise + */ + public void setSelected(boolean selected) + { + ButtonModel m = getModel(); + if (selected != m.isSelected()) + m.setSelected(selected); + } + + /** + * Checks if PopupMenu associated with this menu is visible + * + * @return true if the popup associated with this menu is currently visible + * on the screen and false otherwise. + */ + public boolean isPopupMenuVisible() + { + return getPopupMenu().isVisible(); + } + + /** + * Sets popup menu visibility + * + * @param popup true if popup should be visible and false otherwise + */ + public void setPopupMenuVisible(boolean popup) + { + if (popup != isPopupMenuVisible() && (isEnabled() || ! popup)) + { + if (popup && isShowing()) + { + // Set location as determined by getPopupLocation(). + Point loc = menuLocation == null ? getPopupMenuOrigin() + : menuLocation; + getPopupMenu().show(this, loc.x, loc.y); + } + else + getPopupMenu().setVisible(false); + } + } + + /** + * Returns origin point of the popup menu. This takes the screen bounds + * into account and places the popup where it fits best. + * + * @return the origin of the popup menu + */ + protected Point getPopupMenuOrigin() + { + // The menu's screen location and size. + Point screenLoc = getLocationOnScreen(); + Dimension size = getSize(); + + // Determine the popup's size. + JPopupMenu popup = getPopupMenu(); + Dimension popupSize = popup.getSize(); + if (popupSize.width == 0 || popupSize.height == 0) + popupSize = popup.getPreferredSize(); + + // Determine screen bounds. + Toolkit tk = Toolkit.getDefaultToolkit(); + Rectangle screenBounds = new Rectangle(tk.getScreenSize()); + GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment(); + GraphicsDevice gd = ge.getDefaultScreenDevice(); + GraphicsConfiguration gc = gd.getDefaultConfiguration(); + Insets screenInsets = tk.getScreenInsets(gc); + screenBounds.x -= screenInsets.left; + screenBounds.width -= screenInsets.left + screenInsets.right; + screenBounds.y -= screenInsets.top; + screenBounds.height -= screenInsets.top + screenInsets.bottom; + screenLoc.x -= screenInsets.left; + screenLoc.y -= screenInsets.top; + + Point point = new Point(); + if (isTopLevelMenu()) + { + // If menu in the menu bar. + int xOffset = UIManager.getInt("Menu.menuPopupOffsetX"); + int yOffset = UIManager.getInt("Menu.menuPopupOffsetY"); + // Determine X location. + if (getComponentOrientation().isLeftToRight()) + { + // Prefer popup to the right. + point.x = xOffset; + // Check if it fits, otherwise place popup wherever it fits. + if (screenLoc.x + point.x + popupSize.width + > screenBounds.width + screenBounds.width + && screenBounds.width - size.width + < 2 * (screenLoc.x - screenBounds.x)) + // Popup to the right if there's not enough room. + point.x = size.width - xOffset - popupSize.width; + } + else + { + // Prefer popup to the left. + point.x = size.width - xOffset - popupSize.width; + if (screenLoc.x + point.x < screenBounds.x + && screenBounds.width - size.width + > 2 * (screenLoc.x - screenBounds.x)) + // Popup to the left if there's not enough room. + point.x = xOffset; + } + // Determine Y location. Prefer popping down. + point.y = size.height + yOffset; + if (screenLoc.y + point.y + popupSize.height >= screenBounds.height + && screenBounds.height - size.height + < 2 * (screenLoc.y - screenBounds.y)) + // Position above if there's not enough room below. + point.y = - yOffset - popupSize.height; + } + else + { + // If submenu. + int xOffset = UIManager.getInt("Menu.submenuPopupOffsetX"); + int yOffset = UIManager.getInt("Menu.submenuPopupOffsetY"); + // Determine X location. + if (getComponentOrientation().isLeftToRight()) + { + // Prefer popup to the right. + point.x = size.width + xOffset; + if (screenLoc.x + point.x + popupSize.width + >= screenBounds.x + screenBounds.width + && screenBounds.width - size.width + < 2 * (screenLoc.x - screenBounds.x)) + // Position to the left if there's not enough room on the right. + point.x = - xOffset - popupSize.width; + } + else + { + // Prefer popup on the left side. + point.x = - xOffset - popupSize.width; + if (screenLoc.x + point.x < screenBounds.x + && screenBounds.width - size.width + > 2 * (screenLoc.x - screenBounds.x)) + // Popup to the right if there's not enough room. + point.x = size.width + xOffset; + } + // Determine Y location. Prefer popping down. + point.y = yOffset; + if (screenLoc.y + point.y + popupSize.height + >= screenBounds.y + screenBounds.height + && screenBounds.height - size.height + < 2 * (screenLoc.y - screenBounds.y)) + // Pop up if there's not enough room below. + point.y = size.height - yOffset - popupSize.height; + } + return point; + } + + /** + * Returns delay property. + * + * @return delay property, indicating number of milliseconds before + * popup menu associated with the menu appears or disappears after + * menu was selected or deselected respectively + */ + public int getDelay() + { + return delay; + } + + /** + * Sets delay property for this menu. If given time for the delay + * property is negative, then IllegalArgumentException is thrown + * + * @param delay number of milliseconds before + * popup menu associated with the menu appears or disappears after + * menu was selected or deselected respectively + */ + public void setDelay(int delay) + { + if (delay < 0) + throw new IllegalArgumentException("delay less than 0"); + this.delay = delay; + } + + /** + * Sets location at which popup menu should be displayed + * The location given is relative to this menu item + * + * @param x x-coordinate of the menu location + * @param y y-coordinate of the menu location + */ + public void setMenuLocation(int x, int y) + { + menuLocation = new Point(x, y); + if (popupMenu != null) + popupMenu.setLocation(x, y); + } + + /** + * Creates and returns JMenuItem associated with the given action + * + * @param action Action to use for creation of JMenuItem + * + * @return JMenuItem that was creted with given action + */ + protected JMenuItem createActionComponent(Action action) + { + return new JMenuItem(action); + } + + /** + * Creates ActionChangeListener to listen for PropertyChangeEvents occuring + * in the action that is associated with this menu + * + * @param item menu that contains action to listen to + * + * @return The PropertyChangeListener + */ + protected PropertyChangeListener createActionChangeListener(JMenuItem item) + { + return new ActionChangedListener(item); + } + + /** + * Adds separator to the end of the menu items in the menu. + */ + public void addSeparator() + { + getPopupMenu().addSeparator(); + } + + /** + * Inserts separator in the menu at the specified index. + * + * @param index Index at which separator should be inserted + */ + public void insertSeparator(int index) + { + if (index < 0) + throw new IllegalArgumentException("index less than 0"); + + getPopupMenu().insert(new JPopupMenu.Separator(), index); + } + + /** + * Returns menu item located at the specified index in the menu + * + * @param index Index at which to look for the menu item + * + * @return menu item located at the specified index in the menu + */ + public JMenuItem getItem(int index) + { + if (index < 0) + throw new IllegalArgumentException("index less than 0"); + + if (getItemCount() == 0) + return null; + + Component c = popupMenu.getComponentAtIndex(index); + + if (c instanceof JMenuItem) + return (JMenuItem) c; + else + return null; + } + + /** + * Returns number of items in the menu including separators. + * + * @return number of items in the menu + * + * @see #getMenuComponentCount() + */ + public int getItemCount() + { + return getMenuComponentCount(); + } + + /** + * Checks if this menu is a tear-off menu. + * + * @return true if this menu is a tear-off menu and false otherwise + */ + public boolean isTearOff() + { + // NOT YET IMPLEMENTED + throw new Error("The method isTearOff() has not yet been implemented."); + } + + /** + * Returns number of menu components in this menu + * + * @return number of menu components in this menu + */ + public int getMenuComponentCount() + { + return getPopupMenu().getComponentCount(); + } + + /** + * Returns menu component located at the givent index + * in the menu + * + * @param index index at which to get the menu component in the menu + * + * @return Menu Component located in the menu at the specified index + */ + public Component getMenuComponent(int index) + { + if (getPopupMenu() == null || getMenuComponentCount() == 0) + return null; + + return popupMenu.getComponentAtIndex(index); + } + + /** + * Return components belonging to this menu + * + * @return components belonging to this menu + */ + public Component[] getMenuComponents() + { + return getPopupMenu().getComponents(); + } + + /** + * Checks if this menu is a top level menu. The menu is top + * level menu if it is inside the menu bar. While if the menu + * inside some other menu, it is considered to be a pull-right menu. + * + * @return true if this menu is top level menu, and false otherwise + */ + public boolean isTopLevelMenu() + { + return getParent() instanceof JMenuBar; + } + + /** + * Checks if given component exists in this menu. The submenus of + * this menu are checked as well + * + * @param component Component to look for + * + * @return true if the given component exists in this menu, and false otherwise + */ + public boolean isMenuComponent(Component component) + { + return false; + } + + /** + * Returns popup menu associated with the menu. + * + * @return popup menu associated with the menu. + */ + public JPopupMenu getPopupMenu() + { + if (popupMenu == null) + { + popupMenu = new JPopupMenu(); + popupMenu.setInvoker(this); + } + return popupMenu; + } + + /** + * Adds MenuListener to the menu + * + * @param listener MenuListener to add + */ + public void addMenuListener(MenuListener listener) + { + listenerList.add(MenuListener.class, listener); + } + + /** + * Removes MenuListener from the menu + * + * @param listener MenuListener to remove + */ + public void removeMenuListener(MenuListener listener) + { + listenerList.remove(MenuListener.class, listener); + } + + /** + * Returns all registered <code>MenuListener</code> objects. + * + * @return an array of listeners + * + * @since 1.4 + */ + public MenuListener[] getMenuListeners() + { + return (MenuListener[]) listenerList.getListeners(MenuListener.class); + } + + /** + * This method fires MenuEvents to all menu's MenuListeners. In this case + * menuSelected() method of MenuListeners is called to indicated that the menu + * was selected. + */ + protected void fireMenuSelected() + { + MenuListener[] listeners = getMenuListeners(); + + for (int index = 0; index < listeners.length; ++index) + listeners[index].menuSelected(menuEvent); + } + + /** + * This method fires MenuEvents to all menu's MenuListeners. In this case + * menuDeselected() method of MenuListeners is called to indicated that the menu + * was deselected. + */ + protected void fireMenuDeselected() + { + EventListener[] ll = listenerList.getListeners(MenuListener.class); + + for (int i = 0; i < ll.length; i++) + ((MenuListener) ll[i]).menuDeselected(menuEvent); + } + + /** + * This method fires MenuEvents to all menu's MenuListeners. In this case + * menuSelected() method of MenuListeners is called to indicated that the menu + * was cancelled. The menu is cancelled when it's popup menu is close without selection. + */ + protected void fireMenuCanceled() + { + EventListener[] ll = listenerList.getListeners(MenuListener.class); + + for (int i = 0; i < ll.length; i++) + ((MenuListener) ll[i]).menuCanceled(menuEvent); + } + + /** + * Creates WinListener that listens to the menu;s popup menu. + * + * @param popup JPopupMenu to listen to + * + * @return The WinListener + */ + protected WinListener createWinListener(JPopupMenu popup) + { + return new WinListener(popup); + } + + /** + * Method of the MenuElementInterface. It reacts to the selection + * changes in the menu. If this menu was selected, then it + * displayes popup menu associated with it and if this menu was + * deselected it hides the popup menu. + * + * @param changed true if the menu was selected and false otherwise + */ + public void menuSelectionChanged(boolean changed) + { + // if this menu selection is true, then activate this menu and + // display popup associated with this menu + setSelected(changed); + } + + /** + * Method of MenuElement interface. Returns sub components of + * this menu. + * + * @return array containing popupMenu that is associated with this menu + */ + public MenuElement[] getSubElements() + { + return new MenuElement[] { popupMenu }; + } + + /** + * @return Returns reference to itself + */ + public Component getComponent() + { + return this; + } + + /** + * This method is overriden with empty implementation, s.t the + * accelerator couldn't be set for the menu. The mnemonic should + * be used for the menu instead. + * + * @param keystroke accelerator for this menu + */ + public void setAccelerator(KeyStroke keystroke) + { + throw new Error("setAccelerator() is not defined for JMenu. Use setMnemonic() instead."); + } + + /** + * This method process KeyEvent occuring when the menu is visible + * + * @param event The KeyEvent + */ + protected void processKeyEvent(KeyEvent event) + { + MenuSelectionManager.defaultManager().processKeyEvent(event); + } + + /** + * Programatically performs click + * + * @param time Number of milliseconds for which this menu stays pressed + */ + public void doClick(int time) + { + getModel().setArmed(true); + getModel().setPressed(true); + try + { + java.lang.Thread.sleep(time); + } + catch (java.lang.InterruptedException e) + { + // probably harmless + } + + getModel().setPressed(false); + getModel().setArmed(false); + popupMenu.show(this, this.getWidth(), 0); + } + + /** + * A string that describes this JMenu. Normally only used + * for debugging. + * + * @return A string describing this JMenu + */ + protected String paramString() + { + return super.paramString(); + } + + public AccessibleContext getAccessibleContext() + { + if (accessibleContext == null) + accessibleContext = new AccessibleJMenu(); + + return accessibleContext; + } + + /** + * Implements support for assisitive technologies for <code>JMenu</code>. + */ + protected class AccessibleJMenu extends AccessibleJMenuItem + implements AccessibleSelection + { + private static final long serialVersionUID = -8131864021059524309L; + + protected AccessibleJMenu() + { + // Nothing to do here. + } + + /** + * Returns the number of accessible children of this object. + * + * @return the number of accessible children of this object + */ + public int getAccessibleChildrenCount() + { + Component[] children = getMenuComponents(); + int count = 0; + for (int i = 0; i < children.length; i++) + { + if (children[i] instanceof Accessible) + count++; + } + return count; + } + + /** + * Returns the accessible child with the specified <code>index</code>. + * + * @param index the index of the child to fetch + * + * @return the accessible child with the specified <code>index</code> + */ + public Accessible getAccessibleChild(int index) + { + Component[] children = getMenuComponents(); + int count = 0; + Accessible found = null; + for (int i = 0; i < children.length; i++) + { + if (children[i] instanceof Accessible) + { + if (count == index) + { + found = (Accessible) children[i]; + break; + } + count++; + } + } + return found; + } + + /** + * Returns the accessible selection of this object. AccessibleJMenus handle + * their selection themselves, so we always return <code>this</code> here. + * + * @return the accessible selection of this object + */ + public AccessibleSelection getAccessibleSelection() + { + return this; + } + + /** + * Returns the selected accessible child with the specified + * <code>index</code>. + * + * @param index the index of the accessible selected child to return + * + * @return the selected accessible child with the specified + * <code>index</code> + */ + public Accessible getAccessibleSelection(int index) + { + Accessible selected = null; + // Only one item can be selected, which must therefore have index == 0. + if (index == 0) + { + MenuSelectionManager msm = MenuSelectionManager.defaultManager(); + MenuElement[] me = msm.getSelectedPath(); + if (me != null) + { + for (int i = 0; i < me.length; i++) + { + if (me[i] == JMenu.this) + { + // This JMenu is selected, find and return the next + // JMenuItem in the path. + do + { + if (me[i] instanceof Accessible) + { + selected = (Accessible) me[i]; + break; + } + i++; + } while (i < me.length); + } + if (selected != null) + break; + } + } + } + return selected; + } + + /** + * Returns <code>true</code> if the accessible child with the specified + * index is selected, <code>false</code> otherwise. + * + * @param index the index of the accessible child to check + * + * @return <code>true</code> if the accessible child with the specified + * index is selected, <code>false</code> otherwise + */ + public boolean isAccessibleChildSelected(int index) + { + boolean selected = false; + MenuSelectionManager msm = MenuSelectionManager.defaultManager(); + MenuElement[] me = msm.getSelectedPath(); + if (me != null) + { + Accessible toBeFound = getAccessibleChild(index); + for (int i = 0; i < me.length; i++) + { + if (me[i] == toBeFound) + { + selected = true; + break; + } + } + } + return selected; + } + + /** + * Returns the accessible role of this object, which is + * {@link AccessibleRole#MENU} for the AccessibleJMenu. + * + * @return the accessible role of this object + */ + public AccessibleRole getAccessibleRole() + { + return AccessibleRole.MENU; + } + + /** + * Returns the number of selected accessible children. This will be + * <code>0</code> if no item is selected, or <code>1</code> if an item + * is selected. AccessibleJMenu can have maximum 1 selected item. + * + * @return the number of selected accessible children + */ + public int getAccessibleSelectionCount() + { + int count = 0; + MenuSelectionManager msm = MenuSelectionManager.defaultManager(); + MenuElement[] me = msm.getSelectedPath(); + if (me != null) + { + for (int i = 0; i < me.length; i++) + { + if (me[i] == JMenu.this) + { + if (i + 1 < me.length) + { + count = 1; + break; + } + } + } + } + return count; + } + + /** + * Selects the accessible child with the specified index. + * + * @param index the index of the accessible child to select + */ + public void addAccessibleSelection(int index) + { + Accessible child = getAccessibleChild(index); + if (child != null && child instanceof JMenuItem) + { + JMenuItem mi = (JMenuItem) child; + MenuSelectionManager msm = MenuSelectionManager.defaultManager(); + msm.setSelectedPath(createPath(JMenu.this)); + } + } + + /** + * Removes the item with the specified index from the selection. + * + * @param index the index of the selected item to remove from the selection + */ + public void removeAccessibleSelection(int index) + { + Accessible child = getAccessibleChild(index); + if (child != null) + { + MenuSelectionManager msm = MenuSelectionManager.defaultManager(); + MenuElement[] oldSelection = msm.getSelectedPath(); + for (int i = 0; i < oldSelection.length; i++) + { + if (oldSelection[i] == child) + { + // Found the specified child in the selection. Remove it + // from the selection. + MenuElement[] newSel = new MenuElement[i - 1]; + System.arraycopy(oldSelection, 0, newSel, 0, i - 1); + msm.setSelectedPath(newSel); + break; + } + } + } + } + + /** + * Removes all possibly selected accessible children of this object from + * the selection. + */ + public void clearAccessibleSelection() + { + MenuSelectionManager msm = MenuSelectionManager.defaultManager(); + MenuElement[] oldSelection = msm.getSelectedPath(); + for (int i = 0; i < oldSelection.length; i++) + { + if (oldSelection[i] == JMenu.this) + { + // Found this menu in the selection. Remove all children from + // the selection. + MenuElement[] newSel = new MenuElement[i]; + System.arraycopy(oldSelection, 0, newSel, 0, i); + msm.setSelectedPath(newSel); + break; + } + } + } + + /** + * AccessibleJMenu don't support multiple selection, so this method + * does nothing. + */ + public void selectAllAccessibleSelection() + { + // Nothing to do here. + } + } + + protected class WinListener extends WindowAdapter implements Serializable + { + private static final long serialVersionUID = -6415815570638474823L; + + /** + * Creates a new <code>WinListener</code>. + * + * @param popup the popup menu which is observed + */ + public WinListener(JPopupMenu popup) + { + // TODO: What should we do with the popup argument? + } + + /** + * Receives notification when the popup menu is closing and deselects + * the menu. + * + * @param event the window event + */ + public void windowClosing(WindowEvent event) + { + setSelected(false); + } + } + + /** + * This class listens to PropertyChangeEvents occuring in menu's action + */ + private class ActionChangedListener implements PropertyChangeListener + { + /** menu item associated with the action */ + private JMenuItem menuItem; + + /** Creates new ActionChangedListener and adds it to menuItem's action */ + public ActionChangedListener(JMenuItem menuItem) + { + this.menuItem = menuItem; + + Action a = menuItem.getAction(); + if (a != null) + a.addPropertyChangeListener(this); + } + + /**This method is invoked when some change occures in menuItem's action*/ + public void propertyChange(PropertyChangeEvent evt) + { + // FIXME: Need to implement + } + } + + /** + * Creates an array to be feeded as argument to + * {@link MenuSelectionManager#setSelectedPath(MenuElement[])} for the + * specified element. This has the effect of selecting the specified element + * and all its parents. + * + * @param leaf the leaf element for which to create the selected path + * + * @return the selected path array + */ + MenuElement[] createPath(JMenu leaf) + { + ArrayList path = new ArrayList(); + MenuElement[] array = null; + Component current = leaf.getPopupMenu(); + while (true) + { + if (current instanceof JPopupMenu) + { + JPopupMenu popupMenu = (JPopupMenu) current; + path.add(0, popupMenu); + current = popupMenu.getInvoker(); + } + else if (current instanceof JMenu) + { + JMenu menu = (JMenu) current; + path.add(0, menu); + current = menu.getParent(); + } + else if (current instanceof JMenuBar) + { + JMenuBar menuBar = (JMenuBar) current; + path.add(0, menuBar); + array = new MenuElement[path.size()]; + array = (MenuElement[]) path.toArray(array); + break; + } + } + return array; + } +} |