obtained gcc-4.6.4.tar.bz2 from upstream website;upstream

verified gcc-4.6.4.tar.bz2.sig;
imported gcc-4.6.4 source tree from verified upstream tarball.

downloading a git-generated archive based on the 'upstream' tag
should provide you with a source tree that is binary identical
to the one extracted from the above tarball.

if you have obtained the source via the command 'git clone',
however, do note that line-endings of files in your working
directory might differ from line-endings of the respective
files in the upstream repository.

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;
+  }
+}