basicmenuui.java

gcc的组建

      manager.processMouseEvent(e);
    }

    private boolean popupVisible()
    {
      JMenuBar mb = (JMenuBar) ((JMenu) menuItem).getParent();
      // check if mb.isSelected because if no menus are selected
      // we don't have to look through the list for popup menus
      if (!mb.isSelected())
        return false;
      for (int i = 0; i < mb.getMenuCount(); i++)
      {
         JMenu m = mb.getMenu(i);
        if (m != null && m.isPopupMenuVisible())
          return true;
      }
      return false;
    }

    public void mouseEntered(MouseEvent e)
    {
      /* When mouse enters menu item, it should be considered selected

       if (i) if this menu is a submenu in some other menu
          (ii) or if this menu is in a menu bar and some other menu in a 
          menu bar was just selected and has its popup menu visible. 
               (If nothing was selected, menu should be pressed before
               it will be selected)
      */
      JMenu menu = (JMenu) menuItem;

      // NOTE: the following if used to require !menu.isArmed but I could find
      // no reason for this and it was preventing some JDK-compatible behaviour.
      // Specifically, if a menu is selected but its popup menu not visible,
      // and then another menu is selected whose popup menu IS visible, when
      // the mouse is moved over the first menu, its popup menu should become
      // visible.

      if (! menu.isTopLevelMenu() || popupVisible())
        {
	  // set new selection and forward this event to MenuSelectionManager
	  MenuSelectionManager manager = MenuSelectionManager.defaultManager();
	  manager.setSelectedPath(getPath());
	  manager.processMouseEvent(e);
        }
    }

    public void mouseExited(MouseEvent e)
    {
      MenuSelectionManager manager = MenuSelectionManager.defaultManager();
      manager.processMouseEvent(e);
    }

    public void mouseMoved(MouseEvent e)
    {
      // TODO: What should be done here, if anything?
    }

    public void mousePressed(MouseEvent e)
    {
      MenuSelectionManager manager = MenuSelectionManager.defaultManager();
      JMenu menu = (JMenu) menuItem;
      manager.processMouseEvent(e);

      // Menu should be displayed when the menu is pressed only if 
      // it is top-level menu
      if (menu.isTopLevelMenu())
        {
	  if (menu.getPopupMenu().isVisible())
	    // If menu is visible and menu button was pressed.. 
	    // then need to cancel the menu
	    manager.clearSelectedPath();
	  else
	    {
	      // Display the menu
	      int x = 0;
	      int y = menu.getHeight();

	      manager.setSelectedPath(getPath());

	      JMenuBar mb = (JMenuBar) menu.getParent();

	      // set selectedIndex of the selectionModel of a menuBar
	      mb.getSelectionModel().setSelectedIndex(mb.getComponentIndex(menu));
	    }
        }
    }

    public void mouseReleased(MouseEvent e)
    {
      MenuSelectionManager manager = MenuSelectionManager.defaultManager();
      manager.processMouseEvent(e);
    }
  }

  /**
   * This class handles MenuEvents fired by the JMenu
   */
  protected class MenuHandler implements MenuListener
  {
    /**
     * This method is called when menu is cancelled. The menu is cancelled
     * when its popup menu is closed without selection. It clears selected index
     * in the selectionModel of the menu parent.
     *
     * @param e The MenuEvent.
     */
    public void menuCanceled(MenuEvent e)
    {
      menuDeselected(e);
    }

    /**
     * This method is called when menu is deselected. It clears selected index
     * in the selectionModel of the menu parent.
     *
     * @param e The MenuEvent.
     */
    public void menuDeselected(MenuEvent e)
    {
      JMenu menu = (JMenu) menuItem;
      if (menu.getParent() != null)
        {
          if (menu.isTopLevelMenu())
            ((JMenuBar) menu.getParent()).getSelectionModel().clearSelection();
          else
            ((JPopupMenu) menu.getParent()).getSelectionModel().clearSelection();
        }
    }

    /**
     * This method is called when menu is selected.  It sets selected index
     * in the selectionModel of the menu parent.
     *
     * @param e The MenuEvent.
     */
    public void menuSelected(MenuEvent e)
    {
      JMenu menu = (JMenu) menuItem;
      if (menu.isTopLevelMenu())
	((JMenuBar) menu.getParent()).setSelected(menu);
      else
	((JPopupMenu) menu.getParent()).setSelected(menu);
    }
  }

  /**
   * This class handles PropertyChangeEvents fired from the JMenu
   */
  protected class PropertyChangeHandler implements PropertyChangeListener
  {
    /**
      * This method is called whenever one of the properties of the menu item
      * changes.
      *
      * @param e The PropertyChangeEvent.
      */
    public void propertyChange(PropertyChangeEvent e)
    {
      // TODO: Implement this properly.
    }
  }

  /**
   * @deprecated
   */
  public class ChangeHandler implements ChangeListener
  {
    /**
     * Not used.
     */
    public boolean isSelected;

    /**
     * Not used.
     */
    public JMenu menu;

    /**
     * Not used.
     */
    public BasicMenuUI ui;

    /**
     * Not used.
     */
    public Component wasFocused;

    /**
     * Not used.
     */
    public ChangeHandler(JMenu m, BasicMenuUI ui)
    {
      // Not used.
    }

    /**
     * Not used.
     */
    public void stateChanged(ChangeEvent e)
    {
      // Not used.
    }
  }

  /**
   * This class handles mouse dragged events occuring in the menu.
   */
  protected class MenuDragMouseHandler implements MenuDragMouseListener
  {
    /**
     * This method is invoked when mouse is dragged over the menu item.
     *
     * @param e The MenuDragMouseEvent
     */
    public void menuDragMouseDragged(MenuDragMouseEvent e)
    {
      MenuSelectionManager manager = MenuSelectionManager.defaultManager();
      manager.setSelectedPath(e.getPath());
    }

    /**
     * This method is invoked when mouse enters the menu item while it is
     * being dragged.
     *
     * @param e The MenuDragMouseEvent
     */
    public void menuDragMouseEntered(MenuDragMouseEvent e)
    {
      MenuSelectionManager manager = MenuSelectionManager.defaultManager();
      manager.setSelectedPath(e.getPath());
    }

    /**
     * This method is invoked when mouse exits the menu item while
     * it is being dragged
     *
     * @param e The MenuDragMouseEvent
     */
    public void menuDragMouseExited(MenuDragMouseEvent e)
    {
      // TODO: What should be done here, if anything?
    }

    /**
     * This method is invoked when mouse was dragged and released
     * inside the menu item.
     *
     * @param e The MenuDragMouseEvent
     */
    public void menuDragMouseReleased(MenuDragMouseEvent e)
    {
      // TODO: What should be done here, if anything?
    }
  }

  /**
   * This class handles key events occuring when menu item is visible on the
   * screen.
   */
  protected class MenuKeyHandler implements MenuKeyListener
  {
    /**
     * This method is invoked when key has been pressed
     *
     * @param e A {@link MenuKeyEvent}.
     */
    public void menuKeyPressed(MenuKeyEvent e)
    {
      // TODO: What should be done here, if anything?
    }

    /**
     * This method is invoked when key has been pressed
     *
     * @param e A {@link MenuKeyEvent}.
     */
    public void menuKeyReleased(MenuKeyEvent e)
    {
      // TODO: What should be done here, if anything?
    }

    /**
     * This method is invoked when key has been typed
     * It handles the mnemonic key for the menu item.
     *
     * @param e A {@link MenuKeyEvent}.
     */
    public void menuKeyTyped(MenuKeyEvent e)
    {
      // TODO: What should be done here, if anything?
    }
  }
}