home *** CD-ROM | disk | FTP | other *** search
/ DOS/V Power Report 1998 February / VPR9802A.ISO / APP_DEMO / VC / MAIN.BIN / Menu.java < prev    next >
Text File  |  1997-10-27  |  10KB  |  383 lines
  1. /*
  2.  * @(#)Menu.java    1.37 97/05/05
  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.MenuPeer;
  27. import java.awt.event.KeyEvent;
  28.  
  29. /**
  30.  * A Menu that is a component of a menu bar.
  31.  *
  32.  * @version 1.37, 05/05/97
  33.  * @author Sami Shaio
  34.  */
  35. public class Menu extends MenuItem implements MenuContainer {
  36.     Vector        items = new Vector();
  37.     boolean        tearOff;
  38.     boolean        isHelpMenu;
  39.  
  40.     private static final String base = "menu";
  41.     private static int nameCounter = 0;
  42.  
  43.     /*
  44.      * JDK 1.1 serialVersionUID 
  45.      */
  46.      private static final long serialVersionUID = -8809584163345499784L;
  47.  
  48.     /** 
  49.      * Constructs a new Menu with an empty label.  This menu can
  50.      * not be torn off.
  51.      */
  52.     public Menu() {
  53.     this("", false);
  54.     }
  55.  
  56.     /** 
  57.      * Constructs a new Menu with the specified label.  This menu can
  58.      * not be torn off.
  59.  
  60.      * @param label the label to be added to this menu 
  61.      */
  62.     public Menu(String label) {
  63.     this(label, false);
  64.     }
  65.  
  66.     /** 
  67.      * Constructs a new Menu with the specified label. If tearOff is
  68.      * true, the menu can be torn off - the menu will then be displayed
  69.      * in a separate native dialog.
  70.      *
  71.      * NOTE:  tear-off functionality may not be supported by all AWT
  72.      * implementations.  If a particular implementation doesn't support
  73.      * tear-offs, this value will be silently ignored.
  74.      *
  75.      * @param label the label to be added to this menu
  76.      * @param tearOff the boolean indicating whether or not the menu will be
  77.      * able to be torn off.
  78.      */
  79.     public Menu(String label, boolean tearOff) {
  80.     super(label);
  81.     this.name = base + nameCounter++;
  82.     this.tearOff = tearOff;
  83.     }
  84.  
  85.     /**
  86.      * Creates the menu's peer.  The peer allows us to modify the 
  87.      * appearance of the menu without changing its functionality.
  88.      */
  89.     public void addNotify() {
  90.     if (peer == null) {
  91.         peer = Toolkit.getDefaultToolkit().createMenu(this);
  92.     }
  93.     int nitems = getItemCount();
  94.     for (int i = 0 ; i < nitems ; i++) {
  95.         MenuItem mi = getItem(i);
  96.         mi.parent = this;
  97.         mi.addNotify();
  98.     }
  99.     }
  100.  
  101.     /**
  102.      * Removes the menu's peer.  The peer allows us to modify the appearance
  103.      * of the menu without changing its functionality.
  104.      */
  105.     public void removeNotify() {
  106.     int nitems = getItemCount();
  107.     for (int i = 0 ; i < nitems ; i++) {
  108.         getItem(i).removeNotify();
  109.     }
  110.     super.removeNotify();
  111.     }
  112.  
  113.     /**
  114.      * Returns true if this is a tear-off menu.  
  115.      *
  116.      * NOTE:  tear-off functionality may not be supported by all AWT
  117.      * implementations.  If a particular implementation doesn't support
  118.      * tear-offs, this value will be silently ignored.
  119.      */
  120.     public boolean isTearOff() {
  121.     return tearOff;
  122.     }
  123.  
  124.     /** 
  125.       * Returns the number of elements in this menu.
  126.       */
  127.     public int getItemCount() {
  128.     return countItems();
  129.     }
  130.  
  131.     /** 
  132.      * @deprecated As of JDK version 1.1,
  133.      * replaced by getItemCount().
  134.      */
  135.     public int countItems() {
  136.     return items.size();
  137.     }
  138.  
  139.     /**
  140.      * Returns the item located at the specified index of this menu.
  141.      * @param index the position of the item to be returned
  142.      */
  143.     public MenuItem getItem(int index) {
  144.     return (MenuItem)items.elementAt(index);
  145.     }
  146.  
  147.     /**
  148.      * Adds the specified item to this menu.
  149.      * @param mi the item to be added
  150.      */
  151.     public synchronized MenuItem add(MenuItem mi) {
  152.     if (mi.parent != null) {
  153.         mi.parent.remove(mi);
  154.     }
  155.     items.addElement(mi);
  156.     mi.parent = this;
  157.         MenuPeer peer = (MenuPeer)this.peer;
  158.     if (peer != null) {
  159.         mi.addNotify();
  160.         peer.addItem(mi);
  161.     }
  162.     return mi;
  163.     }
  164.  
  165.     /**
  166.      * Adds an item with with the specified label to this menu.
  167.      * @param label the text on the item
  168.      */
  169.     public void add(String label) {
  170.     add(new MenuItem(label));
  171.     }
  172.  
  173.     /**
  174.      * Inserts the MenuItem to this menu at the specified position.
  175.      * @param menuitem the menu item to be inserted
  176.      * @param index the position at which the menu item should be inserted
  177.      * @exception IllegalArgumentException if index is less than 0.
  178.      */
  179.  
  180.     public synchronized void insert(MenuItem menuitem, int index) {
  181.     if (index < 0) {
  182.         throw new IllegalArgumentException("index less than zero.");
  183.     }
  184.  
  185.         int nitems = getItemCount();
  186.     Vector tempItems = new Vector();
  187.  
  188.     /* Remove the item at index, nitems-index times 
  189.        storing them in a temporary vector in the
  190.        order they appear on the menu.
  191.        */
  192.     for (int i = index ; i < nitems; i++) {
  193.         tempItems.addElement(getItem(index));
  194.         remove(index);
  195.     }
  196.  
  197.     add(menuitem);
  198.  
  199.     /* Add the removed items back to the menu, they are
  200.        already in the correct order in the temp vector.
  201.        */
  202.     for (int i = 0; i < tempItems.size()  ; i++) {
  203.         add((MenuItem)tempItems.elementAt(i));
  204.     }
  205.     }
  206.  
  207.     /**
  208.      * Inserts an item with the specified label to this menu 
  209.      * at the specified position.
  210.      * @param label the text on the item
  211.      * @param index the position at which the menu item should be inserted
  212.      */
  213.  
  214.     public void insert(String label, int index) {
  215.         insert(new MenuItem(label), index);
  216.     }
  217.       
  218.     /**
  219.      * Adds a separator line, or a hypen, to the menu at the current position.
  220.      */
  221.     public void addSeparator() {
  222.     add("-");
  223.     }
  224.  
  225.     /**
  226.      * Inserts a separator at the specified position
  227.      * @param index the position at which the menu separator should be inserted
  228.      * @exception IllegalArgumentException if index is less than 0.
  229.      */
  230.  
  231.     public void insertSeparator(int index) {
  232.     if (index < 0) {
  233.         throw new IllegalArgumentException("index less than zero.");
  234.     }
  235.  
  236.         int nitems = getItemCount();
  237.     Vector tempItems = new Vector();
  238.  
  239.     /* Remove the item at index, nitems-index times 
  240.        storing them in a temporary vector in the
  241.        order they appear on the menu.
  242.        */
  243.     for (int i = index ; i < nitems; i++) {
  244.         tempItems.addElement(getItem(index));
  245.         remove(index);
  246.     }
  247.  
  248.     addSeparator();
  249.  
  250.     /* Add the removed items back to the menu, they are
  251.        already in the correct order in the temp vector.
  252.        */
  253.     for (int i = 0; i < tempItems.size()  ; i++) {
  254.         add((MenuItem)tempItems.elementAt(i));
  255.     }
  256.     }
  257.  
  258.     /**
  259.      * Deletes the item from this menu at the specified index.
  260.      * @param index the position of the item to be removed 
  261.      */
  262.     public synchronized void remove(int index) {
  263.     MenuItem mi = getItem(index);
  264.     items.removeElementAt(index);
  265.         MenuPeer peer = (MenuPeer)this.peer;
  266.     if (peer != null) {
  267.         mi.removeNotify();
  268.         mi.parent = null;
  269.         peer.delItem(index);
  270.     }
  271.     }
  272.  
  273.     /**
  274.      * Deletes the specified item from this menu.
  275.      * @param item the item to be removed from the menu
  276.      */
  277.     public synchronized void remove(MenuComponent item) {
  278.     int index = items.indexOf(item);
  279.     if (index >= 0) {
  280.         remove(index);
  281.     }
  282.     }
  283.  
  284.     /**
  285.      * Deletes all items from this menu.
  286.      */
  287.     public synchronized void removeAll() {
  288.         int nitems = getItemCount();
  289.     for (int i = 0 ; i < nitems ; i++) {
  290.         remove(0);
  291.     }
  292.     }
  293.  
  294.     /*
  295.      * Post an ActionEvent to the target of the MenuPeer 
  296.      * associated with the specified keyboard event (on 
  297.      * keydown).  Returns true if there is an associated 
  298.      * keyboard event.
  299.      */
  300.     boolean handleShortcut(KeyEvent e) {
  301.         int nitems = getItemCount();
  302.         for (int i = 0 ; i < nitems ; i++) {
  303.             MenuItem mi = getItem(i);
  304.             if (mi.handleShortcut(e)) {
  305.                 return true;
  306.             }
  307.         }
  308.         return false;
  309.     }
  310.  
  311.     MenuItem getShortcutMenuItem(MenuShortcut s) {
  312.     int nitems = getItemCount();
  313.     for (int i = 0 ; i < nitems ; i++) {
  314.             MenuItem mi = getItem(i).getShortcutMenuItem(s);
  315.             if (mi != null) {
  316.                 return mi;
  317.             }
  318.     }
  319.         return null;
  320.     }
  321.  
  322.     synchronized Enumeration shortcuts() {
  323.         Vector shortcuts = new Vector();
  324.         int nitems = getItemCount();
  325.     for (int i = 0 ; i < nitems ; i++) {
  326.             MenuItem mi = getItem(i);
  327.             if (mi instanceof Menu) {
  328.                 Enumeration e = ((Menu)mi).shortcuts();
  329.                 while (e.hasMoreElements()) {
  330.                     shortcuts.addElement(e.nextElement());
  331.                 }
  332.             } else {
  333.                 MenuShortcut ms = mi.getShortcut();
  334.                 if (ms != null) {
  335.                     shortcuts.addElement(ms);
  336.                 }
  337.             }
  338.     }
  339.         return shortcuts.elements();
  340.     }
  341.  
  342.     void deleteShortcut(MenuShortcut s) {
  343.     int nitems = getItemCount();
  344.     for (int i = 0 ; i < nitems ; i++) {
  345.         getItem(i).deleteShortcut();
  346.     }
  347.     }
  348.  
  349.  
  350.     /* Serialization support.  A MenuContainer is responsible for
  351.      * restoring the parent fields of its children. 
  352.      */
  353.  
  354.     private int menuSerializedDataVersion = 1;
  355.  
  356.     private void writeObject(java.io.ObjectOutputStream s)
  357.       throws java.lang.ClassNotFoundException,
  358.          java.io.IOException 
  359.     {
  360.       s.defaultWriteObject();
  361.     }
  362.  
  363.     private void readObject(java.io.ObjectInputStream s)
  364.       throws java.lang.ClassNotFoundException,
  365.          java.io.IOException 
  366.     {
  367.       s.defaultReadObject();
  368.       for(int i = 0; i < items.size(); i++) {
  369.     MenuItem item = (MenuItem)items.elementAt(i);
  370.     item.parent = this;
  371.       }
  372.     }
  373.  
  374.     /**
  375.      * Returns the String parameter of the menu.
  376.      */
  377.     public String paramString() {
  378.         String str = ",tearOff=" + tearOff+",isHelpMenu=" + isHelpMenu;
  379.         return super.paramString() + str;
  380.     }
  381. }
  382.  
  383.