public  void addChangeListener(ChangeListener l) 
{
        listenerList.add(ChangeListener.class, l);
}

Adds a ChangeListener to the button.

 public  void clearSelectedPath() 
{
        if (selection.size()  > 0) {
            setSelectedPath(null);
        }
}

Tell the menu selection to close and unselect all the menu components. Call this method when a choice has been made

 public Component componentForPoint(Component source,
    Point sourcePoint) 
{
        int screenX,screenY;
        Point p = sourcePoint;
        int i,c,j,d;
        Component mc;
        Rectangle r2;
        int cWidth,cHeight;
        MenuElement menuElement;
        MenuElement subElements[];
        Vector tmp;
        int selectionSize;
        SwingUtilities.convertPointToScreen(p,source);
        screenX = p.x;
        screenY = p.y;
        tmp = (Vector)selection.clone();
        selectionSize = tmp.size();
        for(i=selectionSize - 1 ; i  >= 0 ; i--) {
            menuElement = (MenuElement) tmp.elementAt(i);
            subElements = menuElement.getSubElements();
            for(j = 0, d = subElements.length ; j <  d ; j++) {
                if (subElements[j] == null)
                    continue;
                mc = subElements[j].getComponent();
                if(!mc.isShowing())
                    continue;
                if(mc instanceof JComponent) {
                    cWidth  = ((JComponent)mc).getWidth();
                    cHeight = ((JComponent)mc).getHeight();
                } else {
                    r2 = mc.getBounds();
                    cWidth  = r2.width;
                    cHeight = r2.height;
                }
                p.x = screenX;
                p.y = screenY;
                SwingUtilities.convertPointFromScreen(p,mc);
                /** Return the deepest component on the selection
                 *  path in whose bounds the event's point occurs
                 */
                if (p.x  >= 0 && p.x <  cWidth && p.y  >= 0 && p.y <  cHeight) {
                    return mc;
                }
            }
        }
        return null;
}

Returns the component in the currently selected path which contains sourcePoint.

 public static MenuSelectionManager defaultManager() 
{
                   
        synchronized (MENU_SELECTION_MANAGER_KEY) {
            AppContext context = AppContext.getAppContext();
            MenuSelectionManager msm = (MenuSelectionManager)context.get(
                                                 MENU_SELECTION_MANAGER_KEY);
            if (msm == null) {
                msm = new MenuSelectionManager();
                context.put(MENU_SELECTION_MANAGER_KEY, msm);
            }
            return msm;
        }
}

Returns the default menu selection manager.

 protected  void fireStateChanged() 
{
        // Guaranteed to return a non-null array
        Object[] listeners = listenerList.getListenerList();
        // Process the listeners last to first, notifying
        // those that are interested in this event
        for (int i = listeners.length-2; i >=0; i-=2) {
            if (listeners[i]==ChangeListener.class) {
                // Lazily create the event:
                if (changeEvent == null)
                    changeEvent = new ChangeEvent(this);
                ((ChangeListener)listeners[i+1]).stateChanged(changeEvent);
            }
        }
}

Notifies all listeners that have registered interest for notification on this event type. The event instance is created lazily.

 public ChangeListener[] getChangeListeners() 
{
        return (ChangeListener[])listenerList.getListeners(
                ChangeListener.class);
}

Returns an array of all the ChangeListeners added to this MenuSelectionManager with addChangeListener().

 public MenuElement[] getSelectedPath() 
{
        MenuElement res[] = new MenuElement[selection.size()];
        int i,c;
        for(i=0,c=selection.size();i< c;i++)
            res[i] = (MenuElement) selection.elementAt(i);
        return res;
}

Returns the path to the currently selected menu item

 public boolean isComponentPartOfCurrentMenu(Component c) 
{
        if(selection.size()  > 0) {
            MenuElement me = (MenuElement)selection.elementAt(0);
            return isComponentPartOfCurrentMenu(me,c);
        } else
            return false;
}

Return true if c is part of the currently used menu

 public  void processKeyEvent(KeyEvent e) 
{
        MenuElement[] sel2 = new MenuElement[0];
        sel2 = (MenuElement[])selection.toArray(sel2);
        int selSize = sel2.length;
        MenuElement[] path;
        if (selSize <  1) {
            return;
        }
        for (int i=selSize-1; i >=0; i--) {
            MenuElement elem = sel2[i];
            MenuElement[] subs = elem.getSubElements();
            path = null;
            for (int j=0; j< subs.length; j++) {
                if (subs[j] == null || !subs[j].getComponent().isShowing()
                    || !subs[j].getComponent().isEnabled()) {
                    continue;
                }
                if(path == null) {
                    path = new MenuElement[i+2];
                    System.arraycopy(sel2, 0, path, 0, i+1);
                    }
                path[i+1] = subs[j];
                subs[j].processKeyEvent(e, path, this);
                if (e.isConsumed()) {
                    return;
            }
        }
    }
        // finally dispatch event to the first component in path
        path = new MenuElement[1];
        path[0] = sel2[0];
        path[0].processKeyEvent(e, path, this);
        if (e.isConsumed()) {
            return;
        }
}

When a MenuElement receives an event from a KeyListener, it should never process the event directly. Instead all MenuElements should call this method with the event.

 public  void processMouseEvent(MouseEvent event) 
{
        int screenX,screenY;
        Point p;
        int i,c,j,d;
        Component mc;
        Rectangle r2;
        int cWidth,cHeight;
        MenuElement menuElement;
        MenuElement subElements[];
        MenuElement path[];
        Vector tmp;
        int selectionSize;
        p = event.getPoint();
        Component source = event.getComponent();
        if ((source != null) && !source.isShowing()) {
            // This can happen if a mouseReleased removes the
            // containing component -- bug 4146684
            return;
        }
        int type = event.getID();
        int modifiers = event.getModifiers();
        // 4188027: drag enter/exit added in JDK 1.1.7A, JDK1.2
        if ((type==MouseEvent.MOUSE_ENTERED||
             type==MouseEvent.MOUSE_EXITED)
            && ((modifiers & (InputEvent.BUTTON1_MASK |
                              InputEvent.BUTTON2_MASK | InputEvent.BUTTON3_MASK)) !=0 )) {
            return;
        }
        if (source != null) {
            SwingUtilities.convertPointToScreen(p, source);
        }
        screenX = p.x;
        screenY = p.y;
        tmp = (Vector)selection.clone();
        selectionSize = tmp.size();
        boolean success = false;
        for (i=selectionSize - 1;i  >= 0 && success == false; i--) {
            menuElement = (MenuElement) tmp.elementAt(i);
            subElements = menuElement.getSubElements();
            path = null;
            for (j = 0, d = subElements.length;j <  d && success == false; j++) {
                if (subElements[j] == null)
                    continue;
                mc = subElements[j].getComponent();
                if(!mc.isShowing())
                    continue;
                if(mc instanceof JComponent) {
                    cWidth  = ((JComponent)mc).getWidth();
                    cHeight = ((JComponent)mc).getHeight();
                } else {
                    r2 = mc.getBounds();
                    cWidth  = r2.width;
                    cHeight = r2.height;
                }
                p.x = screenX;
                p.y = screenY;
                SwingUtilities.convertPointFromScreen(p,mc);
                /** Send the event to visible menu element if menu element currently in
                 *  the selected path or contains the event location
                 */
                if(
                   (p.x  >= 0 && p.x <  cWidth && p.y  >= 0 && p.y <  cHeight)) {
                    int k;
                    if(path == null) {
                        path = new MenuElement[i+2];
                        for(k=0;k< =i;k++)
                            path[k] = (MenuElement)tmp.elementAt(k);
                    }
                    path[i+1] = subElements[j];
                    MenuElement currentSelection[] = getSelectedPath();
                    // Enter/exit detection -- needs tuning...
                    if (currentSelection[currentSelection.length-1] !=
                        path[i+1] &&
                        (currentSelection.length <  2 ||
                         currentSelection[currentSelection.length-2] !=
                         path[i+1])) {
                        Component oldMC = currentSelection[currentSelection.length-1].getComponent();
                        MouseEvent exitEvent = new MouseEvent(oldMC, MouseEvent.MOUSE_EXITED,
                                                              event.getWhen(),
                                                              event.getModifiers(), p.x, p.y,
                                                              event.getXOnScreen(),
                                                              event.getYOnScreen(),
                                                              event.getClickCount(),
                                                              event.isPopupTrigger(),
                                                              MouseEvent.NOBUTTON);
                        currentSelection[currentSelection.length-1].
                            processMouseEvent(exitEvent, path, this);
                        MouseEvent enterEvent = new MouseEvent(mc,
                                                               MouseEvent.MOUSE_ENTERED,
                                                               event.getWhen(),
                                                               event.getModifiers(), p.x, p.y,
                                                               event.getXOnScreen(),
                                                               event.getYOnScreen(),
                                                               event.getClickCount(),
                                                               event.isPopupTrigger(),
                                                               MouseEvent.NOBUTTON);
                        subElements[j].processMouseEvent(enterEvent, path, this);
                    }
                    MouseEvent mouseEvent = new MouseEvent(mc, event.getID(),event. getWhen(),
                                                           event.getModifiers(), p.x, p.y,
                                                           event.getXOnScreen(),
                                                           event.getYOnScreen(),
                                                           event.getClickCount(),
                                                           event.isPopupTrigger(),
                                                           MouseEvent.NOBUTTON);
                    subElements[j].processMouseEvent(mouseEvent, path, this);
                    success = true;
                    event.consume();
                }
            }
        }
}

When a MenuElement receives an event from a MouseListener, it should never process the event directly. Instead all MenuElements should call this method with the event.

 public  void removeChangeListener(ChangeListener l) 
{
        listenerList.remove(ChangeListener.class, l);
}

Removes a ChangeListener from the button.

 public  void setSelectedPath(MenuElement[] path) 
{
                                                                                
        int i,c;
        int currentSelectionCount = selection.size();
        int firstDifference = 0;
        if(path == null) {
            path = new MenuElement[0];
        }
        if (DEBUG) {
            System.out.print("Previous:  "); printMenuElementArray(getSelectedPath());
            System.out.print("New:  "); printMenuElementArray(path);
        }
        for(i=0,c=path.length;i< c;i++) {
            if(i <  currentSelectionCount && (MenuElement)selection.elementAt(i) == path[i])
                firstDifference++;
            else
                break;
        }
        for(i=currentSelectionCount - 1 ; i  >= firstDifference ; i--) {
            MenuElement me = (MenuElement)selection.elementAt(i);
            selection.removeElementAt(i);
            me.menuSelectionChanged(false);
        }
        for(i = firstDifference, c = path.length ; i <  c ; i++) {
            if (path[i] != null) {
                selection.addElement(path[i]);
                path[i].menuSelectionChanged(true);
            }
        }
        fireStateChanged();
}

Changes the selection in the menu hierarchy. The elements in the array are sorted in order from the root menu element to the currently selected menu element.

Note that this method is public but is used by the look and feel engine and should not be called by client applications.