home *** CD-ROM | disk | FTP | other *** search
/ DOS/V Power Report 1998 February / VPR9802A.ISO / APP_DEMO / VC / MAIN.BIN / MenuBar.java < prev    next >
Text File  |  1997-10-27  |  7KB  |  288 lines
  1. /*
  2.  * @(#)MenuBar.java    1.32 97/01/27
  3.  * 
  4.  * Copyright (c) 1995, 1996 Sun Microsystems, Inc. All Rights Reserved.
  5.  * 
  6.  * This software is the confidential and proprietary information of Sun
  7.  * Microsystems, Inc. ("Confidential Information").  You shall not
  8.  * disclose such Confidential Information and shall use it only in
  9.  * accordance with the terms of the license agreement you entered into
  10.  * with Sun.
  11.  * 
  12.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
  13.  * SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  14.  * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
  15.  * PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
  16.  * SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
  17.  * THIS SOFTWARE OR ITS DERIVATIVES.
  18.  * 
  19.  * CopyrightVersion 1.1_beta
  20.  * 
  21.  */
  22. package java.awt;
  23.  
  24. import java.util.Vector;
  25. import java.util.Enumeration;
  26. import java.awt.peer.MenuBarPeer;
  27. import java.awt.event.KeyEvent;
  28.  
  29. /**
  30.  * A class that encapsulates the platform's concept of a menu bar bound
  31.  * to a Frame. In order to associate the MenuBar with an actual Frame,
  32.  * the Frame.setMenuBar() method should be called.
  33.  *
  34.  * @see Frame#setMenuBar
  35.  *
  36.  * @version 1.32, 01/27/97
  37.  * @author Sami Shaio
  38.  *
  39.  */
  40. public class MenuBar extends MenuComponent implements MenuContainer {
  41.     Vector menus = new Vector();
  42.     Menu helpMenu;
  43.  
  44.     private static final String base = "menubar";
  45.     private static int nameCounter = 0;
  46.  
  47.     /*
  48.      * JDK 1.1 serialVersionUID 
  49.      */
  50.      private static final long serialVersionUID = -4930327919388951260L;
  51.  
  52.     /**
  53.      * Creates a new menu bar.
  54.      */
  55.     public MenuBar() {
  56.         this.name = base + nameCounter++;
  57.     }
  58.  
  59.     /**
  60.      * Creates the menu bar's peer.  The peer allows us to change the 
  61.      * appearance of the menu bar without changing any of the menu bar's 
  62.      * functionality.
  63.      */
  64.     public void addNotify() {
  65.     peer = Toolkit.getDefaultToolkit().createMenuBar(this);
  66.  
  67.     int nmenus = getMenuCount();
  68.     for (int i = 0 ; i < nmenus ; i++) {
  69.         getMenu(i).addNotify();
  70.     }
  71.     }
  72.  
  73.     /**
  74.      * Removes the menu bar's peer.  The peer allows us to change the 
  75.      * appearance of the menu bar without changing any of the menu bar's 
  76.      * functionality.
  77.      */
  78.     public void removeNotify() {
  79.     int nmenus = getMenuCount();
  80.     for (int i = 0 ; i < nmenus ; i++) {
  81.         getMenu(i).removeNotify();
  82.     }
  83.     super.removeNotify();
  84.     }
  85.  
  86.     /**
  87.      * Gets the help menu on the menu bar.
  88.      */
  89.     public Menu getHelpMenu() {
  90.     return helpMenu;
  91.     }
  92.  
  93.     /**
  94.      * Sets the help menu to the specified menu on the menu bar.
  95.      * @param m the menu to be set
  96.      */
  97.     public synchronized void setHelpMenu(Menu m) {
  98.     if (helpMenu == m) {
  99.         return;
  100.     }
  101.     if (helpMenu != null) {
  102.         helpMenu.removeNotify();
  103.         helpMenu.parent = null;
  104.     }
  105.     if (m.parent != this) {
  106.         add(m);
  107.     }
  108.     helpMenu = m;
  109.     if (m != null) {
  110.         m.isHelpMenu = true;
  111.         m.parent = this;
  112.         MenuBarPeer peer = (MenuBarPeer)this.peer;
  113.         if (peer != null) {
  114.         if (m.peer == null) {
  115.             m.addNotify();
  116.         }
  117.         peer.addHelpMenu(m);
  118.         }
  119.     }
  120.     }
  121.  
  122.     /**
  123.      * Adds the specified menu to the menu bar.
  124.      * @param m the menu to be added to the menu bar
  125.      */
  126.     public synchronized Menu add(Menu m) {
  127.     if (m.parent != null) {
  128.         m.parent.remove(m);
  129.     }
  130.     menus.addElement(m);
  131.     m.parent = this;
  132.  
  133.     MenuBarPeer peer = (MenuBarPeer)this.peer;
  134.     if (peer != null) {
  135.         if (m.peer == null) {
  136.         m.addNotify();
  137.         }
  138.         peer.addMenu(m);
  139.     }
  140.     return m;
  141.     }
  142.  
  143.     /**
  144.      * Removes the menu located at the specified index from the menu bar.
  145.      * @param index the position of the menu to be removed
  146.      */
  147.     public synchronized void remove(int index) {
  148.     MenuBarPeer peer = (MenuBarPeer)this.peer;
  149.     if (peer != null) {
  150.         Menu m = getMenu(index);
  151.         m.removeNotify();
  152.         m.parent = null;
  153.         peer.delMenu(index);
  154.     }
  155.     menus.removeElementAt(index);
  156.     }
  157.  
  158.     /**
  159.      * Removes the specified menu from the menu bar.
  160.      * @param m the menu to be removed
  161.      */
  162.     public synchronized void remove(MenuComponent m) {
  163.     int index = menus.indexOf(m);
  164.     if (index >= 0) {
  165.         remove(index);
  166.     }
  167.     }
  168.  
  169.     /**
  170.      * Counts the number of menus on the menu bar.
  171.      */
  172.     public int getMenuCount() {
  173.     return countMenus();
  174.     }
  175.  
  176.     /**
  177.      * @deprecated As of JDK version 1.1,
  178.      * replaced by getMenuCount().
  179.      */
  180.     public int countMenus() {
  181.     return menus.size();
  182.     }
  183.  
  184.     /**
  185.      * Gets the specified menu.
  186.      * @param i the menu to be returned
  187.      */
  188.     public Menu getMenu(int i) {
  189.     return (Menu)menus.elementAt(i);
  190.     }
  191.  
  192.     /** 
  193.      * Get an Enumeration of all MenuShortcuts this MenuBar manages.
  194.      */
  195.     public synchronized Enumeration shortcuts() {
  196.         Vector shortcuts = new Vector();
  197.     int nmenus = getMenuCount();
  198.     for (int i = 0 ; i < nmenus ; i++) {
  199.             Enumeration e = getMenu(i).shortcuts();
  200.             while (e.hasMoreElements()) {
  201.                 shortcuts.addElement(e.nextElement());
  202.             }
  203.     }
  204.         return shortcuts.elements();
  205.     }
  206.  
  207.     /**
  208.      * Return the MenuItem associated with a MenuShortcut,
  209.      * or null if none has been specified.
  210.      * @param s the MenuShortcut to search for
  211.      */
  212.      public MenuItem getShortcutMenuItem(MenuShortcut s) {
  213.     int nmenus = getMenuCount();
  214.     for (int i = 0 ; i < nmenus ; i++) {
  215.             MenuItem mi = getMenu(i).getShortcutMenuItem(s);
  216.             if (mi != null) {
  217.                 return mi;
  218.             }
  219.     }
  220.         return null;  // MenuShortcut wasn't found
  221.      }
  222.  
  223.     /*
  224.      * Post an ACTION_EVENT to the target of the MenuPeer 
  225.      * associated with the specified keyboard event (on 
  226.      * keydown).  Returns true if there is an associated 
  227.      * keyboard event.
  228.      */
  229.     boolean handleShortcut(KeyEvent e) {
  230.         // Is it a key event?
  231.         int id = e.getID();
  232.         if (id != KeyEvent.KEY_PRESSED && id != KeyEvent.KEY_RELEASED) {
  233.             return false;
  234.         }
  235.  
  236.         // Is the accelerator modifier key pressed?
  237.         int accelKey = Toolkit.getDefaultToolkit().getMenuShortcutKeyMask();
  238.         if ((e.getModifiers() & accelKey) == 0) {
  239.             return false;
  240.         }
  241.  
  242.         // Pass MenuShortcut on to child menus.
  243.     int nmenus = getMenuCount();
  244.     for (int i = 0 ; i < nmenus ; i++) {
  245.         Menu m = getMenu(i);
  246.             if (m.handleShortcut(e)) {
  247.                 return true;
  248.             }
  249.         }
  250.         return false;
  251.     }
  252.  
  253.     /**
  254.      * Delete the specified MenuShortcut.
  255.      * @param s the MenuShortcut to delete
  256.      */
  257.     public void deleteShortcut(MenuShortcut s) {
  258.     int nmenus = getMenuCount();
  259.     for (int i = 0 ; i < nmenus ; i++) {
  260.         getMenu(i).deleteShortcut(s);
  261.         }
  262.     }
  263.  
  264.     /* Serialization support.  Restore the (transient) parent 
  265.      * fields of Menubar menus here.
  266.      */
  267.  
  268.     private int menuBarSerializedDataVersion = 1;
  269.  
  270.     private void writeObject(java.io.ObjectOutputStream s)
  271.       throws java.lang.ClassNotFoundException,
  272.          java.io.IOException 
  273.     {
  274.       s.defaultWriteObject();
  275.     }
  276.  
  277.     private void readObject(java.io.ObjectInputStream s)
  278.       throws java.lang.ClassNotFoundException,
  279.          java.io.IOException 
  280.     {
  281.       s.defaultReadObject();
  282.       for (int i = 0; i < menus.size(); i++) {
  283.     Menu m = (Menu)menus.elementAt(i);
  284.     m.parent = this;
  285.       }
  286.     }
  287. }
  288.