< prev index next >

src/java.desktop/share/classes/java/awt/Menu.java

Print this page




  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 package java.awt;
  26 
  27 import java.io.IOException;
  28 import java.io.ObjectInputStream;
  29 import java.util.Vector;
  30 import java.util.Enumeration;
  31 import java.awt.peer.MenuPeer;
  32 import java.awt.event.KeyEvent;
  33 import javax.accessibility.*;
  34 import sun.awt.AWTAccessor;
  35 
  36 /**
  37  * A <code>Menu</code> object is a pull-down menu component
  38  * that is deployed from a menu bar.
  39  * <p>
  40  * A menu can optionally be a <i>tear-off</i> menu. A tear-off menu
  41  * can be opened and dragged away from its parent menu bar or menu.
  42  * It remains on the screen after the mouse button has been released.
  43  * The mechanism for tearing off a menu is platform dependent, since
  44  * the look and feel of the tear-off menu is determined by its peer.
  45  * On platforms that do not support tear-off menus, the tear-off
  46  * property is ignored.
  47  * <p>
  48  * Each item in a menu must belong to the <code>MenuItem</code>
  49  * class. It can be an instance of <code>MenuItem</code>, a submenu
  50  * (an instance of <code>Menu</code>), or a check box (an instance of
  51  * <code>CheckboxMenuItem</code>).
  52  *
  53  * @author Sami Shaio
  54  * @see     java.awt.MenuItem
  55  * @see     java.awt.CheckboxMenuItem
  56  * @since   1.0
  57  */
  58 public class Menu extends MenuItem implements MenuContainer, Accessible {
  59 
  60     static {
  61         /* ensure that the necessary native libraries are loaded */
  62         Toolkit.loadLibraries();
  63         if (!GraphicsEnvironment.isHeadless()) {
  64             initIDs();
  65         }
  66 
  67         AWTAccessor.setMenuAccessor(
  68             new AWTAccessor.MenuAccessor() {
  69                 public Vector<MenuItem> getItems(Menu menu) {
  70                     return menu.items;
  71                 }
  72             });
  73     }
  74 
  75     /**
  76      * A vector of the items that will be part of the Menu.
  77      *
  78      * @serial
  79      * @see #countItems()
  80      */
  81     Vector<MenuItem> items = new Vector<>();
  82 
  83     /**
  84      * This field indicates whether the menu has the
  85      * tear of property or not.  It will be set to
  86      * <code>true</code> if the menu has the tear off
  87      * property and it will be set to <code>false</code>
  88      * if it does not.
  89      * A torn off menu can be deleted by a user when
  90      * it is no longer needed.
  91      *
  92      * @serial
  93      * @see #isTearOff()
  94      */
  95     boolean             tearOff;
  96 
  97     /**
  98      * This field will be set to <code>true</code>
  99      * if the Menu in question is actually a help
 100      * menu.  Otherwise it will be set to <code>
 101      * false</code>.
 102      *
 103      * @serial
 104      */
 105     boolean             isHelpMenu;
 106 
 107     private static final String base = "menu";
 108     private static int nameCounter = 0;
 109 
 110     /*
 111      * JDK 1.1 serialVersionUID
 112      */
 113      private static final long serialVersionUID = -8809584163345499784L;
 114 
 115     /**
 116      * Constructs a new menu with an empty label. This menu is not
 117      * a tear-off menu.
 118      * @exception HeadlessException if GraphicsEnvironment.isHeadless()
 119      * returns true.
 120      * @see java.awt.GraphicsEnvironment#isHeadless
 121      * @since      1.1


 129      * a tear-off menu.
 130      * @param       label the menu's label in the menu bar, or in
 131      *                   another menu of which this menu is a submenu.
 132      * @exception HeadlessException if GraphicsEnvironment.isHeadless()
 133      * returns true.
 134      * @see java.awt.GraphicsEnvironment#isHeadless
 135      */
 136     public Menu(String label) throws HeadlessException {
 137         this(label, false);
 138     }
 139 
 140     /**
 141      * Constructs a new menu with the specified label,
 142      * indicating whether the menu can be torn off.
 143      * <p>
 144      * Tear-off functionality may not be supported by all
 145      * implementations of AWT.  If a particular implementation doesn't
 146      * support tear-off menus, this value is silently ignored.
 147      * @param       label the menu's label in the menu bar, or in
 148      *                   another menu of which this menu is a submenu.
 149      * @param       tearOff   if <code>true</code>, the menu
 150      *                   is a tear-off menu.
 151      * @exception HeadlessException if GraphicsEnvironment.isHeadless()
 152      * returns true.
 153      * @see java.awt.GraphicsEnvironment#isHeadless
 154      */
 155     public Menu(String label, boolean tearOff) throws HeadlessException {
 156         super(label);
 157         this.tearOff = tearOff;
 158     }
 159 
 160     /**
 161      * Construct a name for this MenuComponent.  Called by getName() when
 162      * the name is null.
 163      */
 164     String constructComponentName() {
 165         synchronized (Menu.class) {
 166             return base + nameCounter++;
 167         }
 168     }
 169 


 187     /**
 188      * Removes the menu's peer.  The peer allows us to modify the appearance
 189      * of the menu without changing its functionality.
 190      */
 191     public void removeNotify() {
 192         synchronized (getTreeLock()) {
 193             int nitems = getItemCount();
 194             for (int i = 0 ; i < nitems ; i++) {
 195                 getItem(i).removeNotify();
 196             }
 197             super.removeNotify();
 198         }
 199     }
 200 
 201     /**
 202      * Indicates whether this menu is a tear-off menu.
 203      * <p>
 204      * Tear-off functionality may not be supported by all
 205      * implementations of AWT.  If a particular implementation doesn't
 206      * support tear-off menus, this value is silently ignored.
 207      * @return      <code>true</code> if this is a tear-off menu;
 208      *                         <code>false</code> otherwise.
 209      */
 210     public boolean isTearOff() {
 211         return tearOff;
 212     }
 213 
 214     /**
 215       * Get the number of items in this menu.
 216       * @return the number of items in this menu
 217       * @since      1.1
 218       */
 219     public int getItemCount() {
 220         return countItems();
 221     }
 222 
 223     /**
 224      * Returns the number of items in this menu.
 225      *
 226      * @return the number of items in this menu
 227      * @deprecated As of JDK version 1.1,
 228      * replaced by <code>getItemCount()</code>.
 229      */
 230     @Deprecated
 231     public int countItems() {
 232         return countItemsImpl();
 233     }
 234 
 235     /*
 236      * This is called by the native code, so client code can't
 237      * be called on the toolkit thread.
 238      */
 239     final int countItemsImpl() {
 240         return items.size();
 241     }
 242 
 243     /**
 244      * Gets the item located at the specified index of this menu.
 245      * @param     index the position of the item to be returned.
 246      * @return    the item located at the specified index.
 247      */
 248     public MenuItem getItem(int index) {


 287      * Adds an item with the specified label to this menu.
 288      *
 289      * @param       label   the text on the item
 290      * @see         java.awt.Menu#insert(java.lang.String, int)
 291      * @see         java.awt.Menu#insert(java.awt.MenuItem, int)
 292      */
 293     public void add(String label) {
 294         add(new MenuItem(label));
 295     }
 296 
 297     /**
 298      * Inserts a menu item into this menu
 299      * at the specified position.
 300      *
 301      * @param         menuitem  the menu item to be inserted.
 302      * @param         index     the position at which the menu
 303      *                          item should be inserted.
 304      * @see           java.awt.Menu#add(java.lang.String)
 305      * @see           java.awt.Menu#add(java.awt.MenuItem)
 306      * @exception     IllegalArgumentException if the value of
 307      *                    <code>index</code> is less than zero
 308      * @since         1.1
 309      */
 310 
 311     public void insert(MenuItem menuitem, int index) {
 312         synchronized (getTreeLock()) {
 313             if (index < 0) {
 314                 throw new IllegalArgumentException("index less than zero.");
 315             }
 316 
 317             int nitems = getItemCount();
 318             Vector<MenuItem> tempItems = new Vector<>();
 319 
 320             /* Remove the item at index, nitems-index times
 321                storing them in a temporary vector in the
 322                order they appear on the menu.
 323             */
 324             for (int i = index ; i < nitems; i++) {
 325                 tempItems.addElement(getItem(index));
 326                 remove(index);
 327             }
 328 
 329             add(menuitem);
 330 
 331             /* Add the removed items back to the menu, they are
 332                already in the correct order in the temp vector.
 333             */
 334             for (int i = 0; i < tempItems.size()  ; i++) {
 335                 add(tempItems.elementAt(i));
 336             }
 337         }
 338     }
 339 
 340     /**
 341      * Inserts a menu item with the specified label into this menu
 342      * at the specified position.  This is a convenience method for
 343      * <code>insert(menuItem, index)</code>.
 344      *
 345      * @param       label the text on the item
 346      * @param       index the position at which the menu item
 347      *                      should be inserted
 348      * @see         java.awt.Menu#add(java.lang.String)
 349      * @see         java.awt.Menu#add(java.awt.MenuItem)
 350      * @exception     IllegalArgumentException if the value of
 351      *                    <code>index</code> is less than zero
 352      * @since       1.1
 353      */
 354 
 355     public void insert(String label, int index) {
 356         insert(new MenuItem(label), index);
 357     }
 358 
 359     /**
 360      * Adds a separator line, or a hypen, to the menu at the current position.
 361      * @see         java.awt.Menu#insertSeparator(int)
 362      */
 363     public void addSeparator() {
 364         add("-");
 365     }
 366 
 367     /**
 368      * Inserts a separator at the specified position.
 369      * @param       index the position at which the
 370      *                       menu separator should be inserted.
 371      * @exception   IllegalArgumentException if the value of
 372      *                       <code>index</code> is less than 0.
 373      * @see         java.awt.Menu#addSeparator
 374      * @since       1.1
 375      */
 376 
 377     public void insertSeparator(int index) {
 378         synchronized (getTreeLock()) {
 379             if (index < 0) {
 380                 throw new IllegalArgumentException("index less than zero.");
 381             }
 382 
 383             int nitems = getItemCount();
 384             Vector<MenuItem> tempItems = new Vector<>();
 385 
 386             /* Remove the item at index, nitems-index times
 387                storing them in a temporary vector in the
 388                order they appear on the menu.
 389             */
 390             for (int i = index ; i < nitems; i++) {
 391                 tempItems.addElement(getItem(index));
 392                 remove(index);


 406     /**
 407      * Removes the menu item at the specified index from this menu.
 408      * @param       index the position of the item to be removed.
 409      */
 410     public void remove(int index) {
 411         synchronized (getTreeLock()) {
 412             MenuItem mi = getItem(index);
 413             items.removeElementAt(index);
 414             MenuPeer peer = (MenuPeer)this.peer;
 415             if (peer != null) {
 416                 peer.delItem(index);
 417                 mi.removeNotify();
 418                 mi.parent = null;
 419             }
 420         }
 421     }
 422 
 423     /**
 424      * Removes the specified menu item from this menu.
 425      * @param  item the item to be removed from the menu.
 426      *         If <code>item</code> is <code>null</code>
 427      *         or is not in this menu, this method does
 428      *         nothing.
 429      */
 430     public void remove(MenuComponent item) {
 431         synchronized (getTreeLock()) {
 432             int index = items.indexOf(item);
 433             if (index >= 0) {
 434                 remove(index);
 435             }
 436         }
 437     }
 438 
 439     /**
 440      * Removes all items from this menu.
 441      * @since       1.1
 442      */
 443     public void removeAll() {
 444         synchronized (getTreeLock()) {
 445             int nitems = getItemCount();
 446             for (int i = nitems-1 ; i >= 0 ; i--) {


 502         for (int i = 0 ; i < nitems ; i++) {
 503             getItem(i).deleteShortcut(s);
 504         }
 505     }
 506 
 507 
 508     /* Serialization support.  A MenuContainer is responsible for
 509      * restoring the parent fields of its children.
 510      */
 511 
 512     /**
 513      * The menu serialized Data Version.
 514      *
 515      * @serial
 516      */
 517     private int menuSerializedDataVersion = 1;
 518 
 519     /**
 520      * Writes default serializable fields to stream.
 521      *
 522      * @param s the <code>ObjectOutputStream</code> to write
 523      * @see AWTEventMulticaster#save(ObjectOutputStream, String, EventListener)
 524      * @see #readObject(ObjectInputStream)
 525      */
 526     private void writeObject(java.io.ObjectOutputStream s)
 527       throws java.io.IOException
 528     {
 529       s.defaultWriteObject();
 530     }
 531 
 532     /**
 533      * Reads the <code>ObjectInputStream</code>.
 534      * Unrecognized keys or values will be ignored.
 535      *
 536      * @param s the <code>ObjectInputStream</code> to read
 537      * @exception HeadlessException if
 538      *   <code>GraphicsEnvironment.isHeadless</code> returns
 539      *   <code>true</code>
 540      * @see java.awt.GraphicsEnvironment#isHeadless
 541      * @see #writeObject(ObjectOutputStream)
 542      */
 543     private void readObject(ObjectInputStream s)
 544       throws IOException, ClassNotFoundException, HeadlessException
 545     {
 546       // HeadlessException will be thrown from MenuComponent's readObject
 547       s.defaultReadObject();
 548       for(int i = 0; i < items.size(); i++) {
 549         MenuItem item = items.elementAt(i);
 550         item.parent = this;
 551       }
 552     }
 553 
 554     /**
 555      * Returns a string representing the state of this <code>Menu</code>.
 556      * This method is intended to be used only for debugging purposes, and the
 557      * content and format of the returned string may vary between
 558      * implementations. The returned string may be empty but may not be
 559      * <code>null</code>.
 560      *
 561      * @return the parameter string of this menu
 562      */
 563     public String paramString() {
 564         String str = ",tearOff=" + tearOff+",isHelpMenu=" + isHelpMenu;
 565         return super.paramString() + str;
 566     }
 567 
 568     /**
 569      * Initialize JNI field and method IDs
 570      */
 571     private static native void initIDs();
 572 
 573 
 574 /////////////////
 575 // Accessibility support
 576 ////////////////
 577 
 578     /**
 579      * Gets the AccessibleContext associated with this Menu.


 589         if (accessibleContext == null) {
 590             accessibleContext = new AccessibleAWTMenu();
 591         }
 592         return accessibleContext;
 593     }
 594 
 595     /**
 596      * Defined in MenuComponent. Overridden here.
 597      */
 598     int getAccessibleChildIndex(MenuComponent child) {
 599         return items.indexOf(child);
 600     }
 601 
 602     /**
 603      * Inner class of Menu used to provide default support for
 604      * accessibility.  This class is not meant to be used directly by
 605      * application developers, but is instead meant only to be
 606      * subclassed by menu component developers.
 607      * <p>
 608      * This class implements accessibility support for the
 609      * <code>Menu</code> class.  It provides an implementation of the
 610      * Java Accessibility API appropriate to menu user-interface elements.
 611      * @since 1.3
 612      */
 613     protected class AccessibleAWTMenu extends AccessibleAWTMenuItem
 614     {
 615         /*
 616          * JDK 1.3 serialVersionUID
 617          */
 618         private static final long serialVersionUID = 5228160894980069094L;
 619 
 620         /**
 621          * Get the role of this object.
 622          *
 623          * @return an instance of AccessibleRole describing the role of the
 624          * object
 625          */
 626         public AccessibleRole getAccessibleRole() {
 627             return AccessibleRole.MENU;
 628         }
 629 


  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 package java.awt;
  26 
  27 import java.io.IOException;
  28 import java.io.ObjectInputStream;
  29 import java.util.Vector;
  30 import java.util.Enumeration;
  31 import java.awt.peer.MenuPeer;
  32 import java.awt.event.KeyEvent;
  33 import javax.accessibility.*;
  34 import sun.awt.AWTAccessor;
  35 
  36 /**
  37  * A {@code Menu} object is a pull-down menu component
  38  * that is deployed from a menu bar.
  39  * <p>
  40  * A menu can optionally be a <i>tear-off</i> menu. A tear-off menu
  41  * can be opened and dragged away from its parent menu bar or menu.
  42  * It remains on the screen after the mouse button has been released.
  43  * The mechanism for tearing off a menu is platform dependent, since
  44  * the look and feel of the tear-off menu is determined by its peer.
  45  * On platforms that do not support tear-off menus, the tear-off
  46  * property is ignored.
  47  * <p>
  48  * Each item in a menu must belong to the {@code MenuItem}
  49  * class. It can be an instance of {@code MenuItem}, a submenu
  50  * (an instance of {@code Menu}), or a check box (an instance of
  51  * {@code CheckboxMenuItem}).
  52  *
  53  * @author Sami Shaio
  54  * @see     java.awt.MenuItem
  55  * @see     java.awt.CheckboxMenuItem
  56  * @since   1.0
  57  */
  58 public class Menu extends MenuItem implements MenuContainer, Accessible {
  59 
  60     static {
  61         /* ensure that the necessary native libraries are loaded */
  62         Toolkit.loadLibraries();
  63         if (!GraphicsEnvironment.isHeadless()) {
  64             initIDs();
  65         }
  66 
  67         AWTAccessor.setMenuAccessor(
  68             new AWTAccessor.MenuAccessor() {
  69                 public Vector<MenuItem> getItems(Menu menu) {
  70                     return menu.items;
  71                 }
  72             });
  73     }
  74 
  75     /**
  76      * A vector of the items that will be part of the Menu.
  77      *
  78      * @serial
  79      * @see #countItems()
  80      */
  81     Vector<MenuItem> items = new Vector<>();
  82 
  83     /**
  84      * This field indicates whether the menu has the
  85      * tear of property or not.  It will be set to
  86      * {@code true} if the menu has the tear off
  87      * property and it will be set to {@code false}
  88      * if it does not.
  89      * A torn off menu can be deleted by a user when
  90      * it is no longer needed.
  91      *
  92      * @serial
  93      * @see #isTearOff()
  94      */
  95     boolean             tearOff;
  96 
  97     /**
  98      * This field will be set to {@code true}
  99      * if the Menu in question is actually a help
 100      * menu.  Otherwise it will be set to
 101      * {@code false}.
 102      *
 103      * @serial
 104      */
 105     boolean             isHelpMenu;
 106 
 107     private static final String base = "menu";
 108     private static int nameCounter = 0;
 109 
 110     /*
 111      * JDK 1.1 serialVersionUID
 112      */
 113      private static final long serialVersionUID = -8809584163345499784L;
 114 
 115     /**
 116      * Constructs a new menu with an empty label. This menu is not
 117      * a tear-off menu.
 118      * @exception HeadlessException if GraphicsEnvironment.isHeadless()
 119      * returns true.
 120      * @see java.awt.GraphicsEnvironment#isHeadless
 121      * @since      1.1


 129      * a tear-off menu.
 130      * @param       label the menu's label in the menu bar, or in
 131      *                   another menu of which this menu is a submenu.
 132      * @exception HeadlessException if GraphicsEnvironment.isHeadless()
 133      * returns true.
 134      * @see java.awt.GraphicsEnvironment#isHeadless
 135      */
 136     public Menu(String label) throws HeadlessException {
 137         this(label, false);
 138     }
 139 
 140     /**
 141      * Constructs a new menu with the specified label,
 142      * indicating whether the menu can be torn off.
 143      * <p>
 144      * Tear-off functionality may not be supported by all
 145      * implementations of AWT.  If a particular implementation doesn't
 146      * support tear-off menus, this value is silently ignored.
 147      * @param       label the menu's label in the menu bar, or in
 148      *                   another menu of which this menu is a submenu.
 149      * @param       tearOff   if {@code true}, the menu
 150      *                   is a tear-off menu.
 151      * @exception HeadlessException if GraphicsEnvironment.isHeadless()
 152      * returns true.
 153      * @see java.awt.GraphicsEnvironment#isHeadless
 154      */
 155     public Menu(String label, boolean tearOff) throws HeadlessException {
 156         super(label);
 157         this.tearOff = tearOff;
 158     }
 159 
 160     /**
 161      * Construct a name for this MenuComponent.  Called by getName() when
 162      * the name is null.
 163      */
 164     String constructComponentName() {
 165         synchronized (Menu.class) {
 166             return base + nameCounter++;
 167         }
 168     }
 169 


 187     /**
 188      * Removes the menu's peer.  The peer allows us to modify the appearance
 189      * of the menu without changing its functionality.
 190      */
 191     public void removeNotify() {
 192         synchronized (getTreeLock()) {
 193             int nitems = getItemCount();
 194             for (int i = 0 ; i < nitems ; i++) {
 195                 getItem(i).removeNotify();
 196             }
 197             super.removeNotify();
 198         }
 199     }
 200 
 201     /**
 202      * Indicates whether this menu is a tear-off menu.
 203      * <p>
 204      * Tear-off functionality may not be supported by all
 205      * implementations of AWT.  If a particular implementation doesn't
 206      * support tear-off menus, this value is silently ignored.
 207      * @return      {@code true} if this is a tear-off menu;
 208      *                         {@code false} otherwise.
 209      */
 210     public boolean isTearOff() {
 211         return tearOff;
 212     }
 213 
 214     /**
 215       * Get the number of items in this menu.
 216       * @return the number of items in this menu
 217       * @since      1.1
 218       */
 219     public int getItemCount() {
 220         return countItems();
 221     }
 222 
 223     /**
 224      * Returns the number of items in this menu.
 225      *
 226      * @return the number of items in this menu
 227      * @deprecated As of JDK version 1.1,
 228      * replaced by {@code getItemCount()}.
 229      */
 230     @Deprecated
 231     public int countItems() {
 232         return countItemsImpl();
 233     }
 234 
 235     /*
 236      * This is called by the native code, so client code can't
 237      * be called on the toolkit thread.
 238      */
 239     final int countItemsImpl() {
 240         return items.size();
 241     }
 242 
 243     /**
 244      * Gets the item located at the specified index of this menu.
 245      * @param     index the position of the item to be returned.
 246      * @return    the item located at the specified index.
 247      */
 248     public MenuItem getItem(int index) {


 287      * Adds an item with the specified label to this menu.
 288      *
 289      * @param       label   the text on the item
 290      * @see         java.awt.Menu#insert(java.lang.String, int)
 291      * @see         java.awt.Menu#insert(java.awt.MenuItem, int)
 292      */
 293     public void add(String label) {
 294         add(new MenuItem(label));
 295     }
 296 
 297     /**
 298      * Inserts a menu item into this menu
 299      * at the specified position.
 300      *
 301      * @param         menuitem  the menu item to be inserted.
 302      * @param         index     the position at which the menu
 303      *                          item should be inserted.
 304      * @see           java.awt.Menu#add(java.lang.String)
 305      * @see           java.awt.Menu#add(java.awt.MenuItem)
 306      * @exception     IllegalArgumentException if the value of
 307      *                    {@code index} is less than zero
 308      * @since         1.1
 309      */
 310 
 311     public void insert(MenuItem menuitem, int index) {
 312         synchronized (getTreeLock()) {
 313             if (index < 0) {
 314                 throw new IllegalArgumentException("index less than zero.");
 315             }
 316 
 317             int nitems = getItemCount();
 318             Vector<MenuItem> tempItems = new Vector<>();
 319 
 320             /* Remove the item at index, nitems-index times
 321                storing them in a temporary vector in the
 322                order they appear on the menu.
 323             */
 324             for (int i = index ; i < nitems; i++) {
 325                 tempItems.addElement(getItem(index));
 326                 remove(index);
 327             }
 328 
 329             add(menuitem);
 330 
 331             /* Add the removed items back to the menu, they are
 332                already in the correct order in the temp vector.
 333             */
 334             for (int i = 0; i < tempItems.size()  ; i++) {
 335                 add(tempItems.elementAt(i));
 336             }
 337         }
 338     }
 339 
 340     /**
 341      * Inserts a menu item with the specified label into this menu
 342      * at the specified position.  This is a convenience method for
 343      * {@code insert(menuItem, index)}.
 344      *
 345      * @param       label the text on the item
 346      * @param       index the position at which the menu item
 347      *                      should be inserted
 348      * @see         java.awt.Menu#add(java.lang.String)
 349      * @see         java.awt.Menu#add(java.awt.MenuItem)
 350      * @exception     IllegalArgumentException if the value of
 351      *                    {@code index} is less than zero
 352      * @since       1.1
 353      */
 354 
 355     public void insert(String label, int index) {
 356         insert(new MenuItem(label), index);
 357     }
 358 
 359     /**
 360      * Adds a separator line, or a hypen, to the menu at the current position.
 361      * @see         java.awt.Menu#insertSeparator(int)
 362      */
 363     public void addSeparator() {
 364         add("-");
 365     }
 366 
 367     /**
 368      * Inserts a separator at the specified position.
 369      * @param       index the position at which the
 370      *                       menu separator should be inserted.
 371      * @exception   IllegalArgumentException if the value of
 372      *                       {@code index} is less than 0.
 373      * @see         java.awt.Menu#addSeparator
 374      * @since       1.1
 375      */
 376 
 377     public void insertSeparator(int index) {
 378         synchronized (getTreeLock()) {
 379             if (index < 0) {
 380                 throw new IllegalArgumentException("index less than zero.");
 381             }
 382 
 383             int nitems = getItemCount();
 384             Vector<MenuItem> tempItems = new Vector<>();
 385 
 386             /* Remove the item at index, nitems-index times
 387                storing them in a temporary vector in the
 388                order they appear on the menu.
 389             */
 390             for (int i = index ; i < nitems; i++) {
 391                 tempItems.addElement(getItem(index));
 392                 remove(index);


 406     /**
 407      * Removes the menu item at the specified index from this menu.
 408      * @param       index the position of the item to be removed.
 409      */
 410     public void remove(int index) {
 411         synchronized (getTreeLock()) {
 412             MenuItem mi = getItem(index);
 413             items.removeElementAt(index);
 414             MenuPeer peer = (MenuPeer)this.peer;
 415             if (peer != null) {
 416                 peer.delItem(index);
 417                 mi.removeNotify();
 418                 mi.parent = null;
 419             }
 420         }
 421     }
 422 
 423     /**
 424      * Removes the specified menu item from this menu.
 425      * @param  item the item to be removed from the menu.
 426      *         If {@code item} is {@code null}
 427      *         or is not in this menu, this method does
 428      *         nothing.
 429      */
 430     public void remove(MenuComponent item) {
 431         synchronized (getTreeLock()) {
 432             int index = items.indexOf(item);
 433             if (index >= 0) {
 434                 remove(index);
 435             }
 436         }
 437     }
 438 
 439     /**
 440      * Removes all items from this menu.
 441      * @since       1.1
 442      */
 443     public void removeAll() {
 444         synchronized (getTreeLock()) {
 445             int nitems = getItemCount();
 446             for (int i = nitems-1 ; i >= 0 ; i--) {


 502         for (int i = 0 ; i < nitems ; i++) {
 503             getItem(i).deleteShortcut(s);
 504         }
 505     }
 506 
 507 
 508     /* Serialization support.  A MenuContainer is responsible for
 509      * restoring the parent fields of its children.
 510      */
 511 
 512     /**
 513      * The menu serialized Data Version.
 514      *
 515      * @serial
 516      */
 517     private int menuSerializedDataVersion = 1;
 518 
 519     /**
 520      * Writes default serializable fields to stream.
 521      *
 522      * @param s the {@code ObjectOutputStream} to write
 523      * @see AWTEventMulticaster#save(ObjectOutputStream, String, EventListener)
 524      * @see #readObject(ObjectInputStream)
 525      */
 526     private void writeObject(java.io.ObjectOutputStream s)
 527       throws java.io.IOException
 528     {
 529       s.defaultWriteObject();
 530     }
 531 
 532     /**
 533      * Reads the {@code ObjectInputStream}.
 534      * Unrecognized keys or values will be ignored.
 535      *
 536      * @param s the {@code ObjectInputStream} to read
 537      * @exception HeadlessException if
 538      *   {@code GraphicsEnvironment.isHeadless} returns
 539      *   {@code true}
 540      * @see java.awt.GraphicsEnvironment#isHeadless
 541      * @see #writeObject(ObjectOutputStream)
 542      */
 543     private void readObject(ObjectInputStream s)
 544       throws IOException, ClassNotFoundException, HeadlessException
 545     {
 546       // HeadlessException will be thrown from MenuComponent's readObject
 547       s.defaultReadObject();
 548       for(int i = 0; i < items.size(); i++) {
 549         MenuItem item = items.elementAt(i);
 550         item.parent = this;
 551       }
 552     }
 553 
 554     /**
 555      * Returns a string representing the state of this {@code Menu}.
 556      * This method is intended to be used only for debugging purposes, and the
 557      * content and format of the returned string may vary between
 558      * implementations. The returned string may be empty but may not be
 559      * {@code null}.
 560      *
 561      * @return the parameter string of this menu
 562      */
 563     public String paramString() {
 564         String str = ",tearOff=" + tearOff+",isHelpMenu=" + isHelpMenu;
 565         return super.paramString() + str;
 566     }
 567 
 568     /**
 569      * Initialize JNI field and method IDs
 570      */
 571     private static native void initIDs();
 572 
 573 
 574 /////////////////
 575 // Accessibility support
 576 ////////////////
 577 
 578     /**
 579      * Gets the AccessibleContext associated with this Menu.


 589         if (accessibleContext == null) {
 590             accessibleContext = new AccessibleAWTMenu();
 591         }
 592         return accessibleContext;
 593     }
 594 
 595     /**
 596      * Defined in MenuComponent. Overridden here.
 597      */
 598     int getAccessibleChildIndex(MenuComponent child) {
 599         return items.indexOf(child);
 600     }
 601 
 602     /**
 603      * Inner class of Menu used to provide default support for
 604      * accessibility.  This class is not meant to be used directly by
 605      * application developers, but is instead meant only to be
 606      * subclassed by menu component developers.
 607      * <p>
 608      * This class implements accessibility support for the
 609      * {@code Menu} class.  It provides an implementation of the
 610      * Java Accessibility API appropriate to menu user-interface elements.
 611      * @since 1.3
 612      */
 613     protected class AccessibleAWTMenu extends AccessibleAWTMenuItem
 614     {
 615         /*
 616          * JDK 1.3 serialVersionUID
 617          */
 618         private static final long serialVersionUID = 5228160894980069094L;
 619 
 620         /**
 621          * Get the role of this object.
 622          *
 623          * @return an instance of AccessibleRole describing the role of the
 624          * object
 625          */
 626         public AccessibleRole getAccessibleRole() {
 627             return AccessibleRole.MENU;
 628         }
 629 
< prev index next >