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
|