Source for java.awt.MenuBar

   1: /* MenuBar.java -- An AWT menu bar class
   2:    Copyright (C) 1999, 2000, 2001, 2002, 2004, 2005, 2006
   3:    Free Software Foundation, Inc.
   4: 
   5: This file is part of GNU Classpath.
   6: 
   7: GNU Classpath is free software; you can redistribute it and/or modify
   8: it under the terms of the GNU General Public License as published by
   9: the Free Software Foundation; either version 2, or (at your option)
  10: any later version.
  11: 
  12: GNU Classpath is distributed in the hope that it will be useful, but
  13: WITHOUT ANY WARRANTY; without even the implied warranty of
  14: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15: General Public License for more details.
  16: 
  17: You should have received a copy of the GNU General Public License
  18: along with GNU Classpath; see the file COPYING.  If not, write to the
  19: Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  20: 02110-1301 USA.
  21: 
  22: Linking this library statically or dynamically with other modules is
  23: making a combined work based on this library.  Thus, the terms and
  24: conditions of the GNU General Public License cover the whole
  25: combination.
  26: 
  27: As a special exception, the copyright holders of this library give you
  28: permission to link this library with independent modules to produce an
  29: executable, regardless of the license terms of these independent
  30: modules, and to copy and distribute the resulting executable under
  31: terms of your choice, provided that you also meet, for each linked
  32: independent module, the terms and conditions of the license of that
  33: module.  An independent module is a module which is not derived from
  34: or based on this library.  If you modify this library, you may extend
  35: this exception to your version of the library, but you are not
  36: obligated to do so.  If you do not wish to do so, delete this
  37: exception statement from your version. */
  38: 
  39: 
  40: package java.awt;
  41: 
  42: import java.awt.peer.MenuBarPeer;
  43: 
  44: import java.io.Serializable;
  45: import java.util.Enumeration;
  46: import java.util.Vector;
  47: 
  48: import javax.accessibility.Accessible;
  49: import javax.accessibility.AccessibleContext;
  50: import javax.accessibility.AccessibleRole;
  51: 
  52: /**
  53:   * This class implements a menu bar in the AWT system.
  54:   *
  55:   * @author Aaron M. Renn (arenn@urbanophile.com)
  56:   * @author Tom Tromey (tromey@redhat.com)
  57:   * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
  58:   */
  59: public class MenuBar extends MenuComponent
  60:   implements MenuContainer, Serializable, Accessible
  61: {
  62: 
  63:   // Serialization Constant
  64:   private static final long serialVersionUID = -4930327919388951260L;
  65: 
  66:   /**
  67:    * The number used to generate the name returned by getName.
  68:    */
  69:   private static transient long next_menubar_number;
  70:   
  71:   /**
  72:    * @serial The menu used for providing help information
  73:    */
  74:   private Menu helpMenu;
  75: 
  76:   /**
  77:    * @serial The menus contained in this menu bar.
  78:    */
  79:   private Vector menus = new Vector();
  80: 
  81:   /**
  82:    * Initializes a new instance of <code>MenuBar</code>.
  83:    *
  84:    * @throws HeadlessException if GraphicsEnvironment.isHeadless() is true
  85:    */
  86:   public MenuBar()
  87:   {
  88:     if (GraphicsEnvironment.isHeadless())
  89:       throw new HeadlessException();
  90:   }
  91: 
  92:   /**
  93:    * Returns the help menu for this menu bar.  This may be <code>null</code>.
  94:    *
  95:    * @return the help menu for this menu bar
  96:    */
  97:   public Menu getHelpMenu()
  98:   {
  99:     return helpMenu;
 100:   }
 101: 
 102:   /**
 103:    * Sets the help menu for this menu bar.
 104:    *
 105:    * @param menu the new help menu for this menu bar
 106:    */
 107:   public synchronized void setHelpMenu(Menu menu)
 108:   {
 109:     MenuBarPeer myPeer = (MenuBarPeer) getPeer ();
 110: 
 111:     if (helpMenu != null)
 112:       {
 113:     if (myPeer != null)
 114:       helpMenu.removeNotify();
 115:         helpMenu.setParent(null);
 116:       }
 117:     helpMenu = menu;
 118: 
 119:     MenuContainer parent = menu.getParent();
 120:     if (parent != null)
 121:       parent.remove(menu);
 122:     menu.setParent(this);
 123: 
 124:     if (myPeer != null)
 125:       {
 126:         menu.addNotify();
 127:         myPeer.addHelpMenu(menu);
 128:       }
 129:   }
 130: 
 131:   /**
 132:    * Add a menu to this MenuBar.  If the menu has already has a
 133:    * parent, it is first removed from its old parent before being
 134:    * added.
 135:    *
 136:    * @param menu the menu to add
 137:    *
 138:    * @return the menu that was added
 139:    */
 140:   public synchronized Menu add(Menu menu)
 141:   {
 142:     MenuBarPeer myPeer = (MenuBarPeer) getPeer ();
 143: 
 144:     MenuContainer parent = menu.getParent();
 145:     if (parent != null)
 146:       parent.remove(menu);
 147: 
 148:     menus.addElement(menu);
 149:     menu.setParent(this);
 150: 
 151:     if (myPeer != null)
 152:       {
 153:         menu.addNotify();
 154:         myPeer.addMenu(menu);
 155:       }
 156:     return menu;
 157:   }
 158: 
 159:   /**
 160:    * Removes the menu at the specified index.
 161:    *
 162:    * @param index the index of the menu to remove from the menu bar
 163:    */
 164:   public synchronized void remove(int index)
 165:   {
 166:     Menu m = (Menu) menus.remove(index);
 167:     MenuBarPeer mp = (MenuBarPeer) getPeer();
 168: 
 169:     if (mp != null)
 170:       m.removeNotify();
 171: 
 172:     m.setParent(null);
 173: 
 174:     if (mp != null)
 175:       mp.delMenu(index);
 176:   }
 177: 
 178:   /**
 179:    * Removes the specified menu from the menu bar.
 180:    *
 181:    * @param menu the menu to remove from the menu bar
 182:    */
 183:   public void remove(MenuComponent menu)
 184:   {
 185:     int index = menus.indexOf(menu);
 186:     if (index == -1)
 187:       return;
 188: 
 189:     remove(index);
 190:   }
 191: 
 192:   /**
 193:    * Returns the number of elements in this menu bar.
 194:    *
 195:    * @return the number of elements in the menu bar
 196:    */
 197:   public int getMenuCount()
 198:   {
 199:     return countMenus();
 200:   }
 201: 
 202:   /**
 203:    * Returns the number of elements in this menu bar.
 204:    *
 205:    * @return the number of elements in the menu bar
 206:    *
 207:    * @deprecated This method is deprecated in favor of
 208:    *             <code>getMenuCount()</code>.
 209:    */
 210:   public int countMenus()
 211:   {
 212:     return menus.size() + (getHelpMenu() == null ? 0 : 1);
 213:   }
 214: 
 215:   /**
 216:    * Returns the menu at the specified index.
 217:    *
 218:    * @param index the index of the menu
 219:    *
 220:    * @return the requested menu
 221:    *
 222:    * @throws ArrayIndexOutOfBoundsException if the index is not valid
 223:    */
 224:   public Menu getMenu(int index)
 225:   {
 226:     return (Menu) menus.elementAt(index);
 227:   }
 228: 
 229:   /**
 230:    * Creates this object's native peer.
 231:    */
 232:   public void addNotify()
 233:   {
 234:     MenuBarPeer peer = (MenuBarPeer) getPeer();
 235:     if (peer == null)
 236:       {
 237:     peer = getToolkit().createMenuBar(this);
 238:     setPeer(peer);
 239:       }
 240: 
 241:     Enumeration e = menus.elements();
 242:     while (e.hasMoreElements())
 243:       {
 244:         Menu mi = (Menu)e.nextElement();
 245:         mi.addNotify();
 246:     peer.addMenu(mi);
 247:       }
 248: 
 249:     if (helpMenu != null)
 250:       {
 251:         helpMenu.addNotify();
 252:         peer.addHelpMenu(helpMenu);
 253:       }
 254:   }
 255: 
 256:   /**
 257:    * Destroys this object's native peer.
 258:    */
 259:   public void removeNotify()
 260:   {
 261:     Enumeration e = menus.elements();
 262:     while (e.hasMoreElements())
 263:       {
 264:         Menu mi = (Menu) e.nextElement();
 265:         mi.removeNotify();
 266:       }
 267:     super.removeNotify();
 268:   }
 269: 
 270:   /**
 271:    * Returns a list of all shortcuts for the menus in this menu bar.
 272:    *
 273:    * @return a list of all shortcuts for the menus in this menu bar
 274:    */
 275:   public synchronized Enumeration<MenuShortcut> shortcuts()
 276:   {
 277:     Vector shortcuts = new Vector();
 278:     Enumeration e = menus.elements();
 279: 
 280:     while (e.hasMoreElements())
 281:       {
 282:         Menu menu = (Menu)e.nextElement();
 283:         if (menu.getShortcut() != null)
 284:           shortcuts.addElement(menu.getShortcut());
 285:       }
 286: 
 287:     return shortcuts.elements();
 288:   }
 289: 
 290:   /**
 291:    * Returns the menu item for the specified shortcut, or <code>null</code>
 292:    * if no such item exists.
 293:    *
 294:    * @param shortcut the shortcut to return the menu item for
 295:    *
 296:    * @return the menu item for the specified shortcut
 297:    */
 298:   public MenuItem getShortcutMenuItem(MenuShortcut shortcut)
 299:   {
 300:     Enumeration e = menus.elements();
 301: 
 302:     while (e.hasMoreElements())
 303:       {
 304:         Menu menu = (Menu) e.nextElement();
 305:         MenuShortcut s = menu.getShortcut();
 306:         if ((s != null) && s.equals(shortcut))
 307:           return menu;
 308:       }
 309: 
 310:     return null;
 311:   }
 312: 
 313:   /**
 314:    * Deletes the specified menu shortcut.
 315:    *
 316:    * @param shortcut the shortcut to delete
 317:    */
 318:   public void deleteShortcut(MenuShortcut shortcut)
 319:   {
 320:     MenuItem it;
 321:     // This is a slow implementation, but it probably doesn't matter.
 322:     while ((it = getShortcutMenuItem (shortcut)) != null)
 323:       it.deleteShortcut();
 324:   }
 325: 
 326:   /**
 327:    * Gets the AccessibleContext associated with this <code>MenuBar</code>.
 328:    * The context is created, if necessary.
 329:    *
 330:    * @return the associated context
 331:    */
 332:   public AccessibleContext getAccessibleContext()
 333:   {
 334:     // Create the context if this is the first request.
 335:     if (accessibleContext == null)
 336:       accessibleContext = new AccessibleAWTMenuBar();
 337:     return accessibleContext;
 338:   }
 339:   
 340:   /**
 341:    * Generate a unique name for this <code>MenuBar</code>.
 342:    *
 343:    * @return A unique name for this <code>MenuBar</code>.
 344:    */
 345:   String generateName()
 346:   {
 347:     return "menubar" + getUniqueLong();
 348:   }
 349: 
 350:   private static synchronized long getUniqueLong()
 351:   {
 352:     return next_menubar_number++;
 353:   }
 354: 
 355:   /**
 356:    * This class provides accessibility support for AWT menu bars.
 357:    *
 358:    * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
 359:    */
 360:   protected class AccessibleAWTMenuBar
 361:     extends AccessibleAWTMenuComponent
 362:   {
 363:   
 364:     /**
 365:      * Compatible with JDK 1.4.2 revision 5
 366:      */
 367:     private static final long serialVersionUID = -8577604491830083815L;
 368: 
 369:     /**
 370:      * This is the default constructor, which simply calls the default
 371:      * constructor of the superclass.
 372:      */
 373:     protected AccessibleAWTMenuBar()
 374:     {
 375:       super();
 376:     }
 377: 
 378:     /**
 379:      * Returns the accessible role relating to the menu bar.
 380:      *
 381:      * @return <code>AccessibleRole.MENU_BAR</code>
 382:      */
 383:     public AccessibleRole getAccessibleRole()
 384:     {
 385:       return AccessibleRole.MENU_BAR;
 386:     }
 387: 
 388:   }
 389: 
 390: }