libjava/classpath/java/awt/MenuComponent.java

   1 /* MenuComponent.java -- Superclass of all AWT menu components
   2    Copyright (C) 1999, 2000, 2002, 2003, 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.event.FocusEvent;
  43 import java.awt.event.FocusListener;
  44 import java.awt.peer.MenuComponentPeer;
  45 import java.io.Serializable;
  46 import java.util.Locale;
  47
  48 import javax.accessibility.Accessible;
  49 import javax.accessibility.AccessibleComponent;
  50 import javax.accessibility.AccessibleContext;
  51 import javax.accessibility.AccessibleRole;
  52 import javax.accessibility.AccessibleSelection;
  53 import javax.accessibility.AccessibleStateSet;
  54
  55 /**
  56   * This is the superclass of all menu AWT widgets.
  57   *
  58   * @author Aaron M. Renn (arenn@urbanophile.com)
  59   * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
  60   */
  61 public abstract class MenuComponent implements Serializable
  62 {
  63
  64 //Serialization Constant
  65   private static final long serialVersionUID = -4536902356223894379L;
  66
  67   /**
  68    * The font for this component.
  69    *
  70    * @see #getFont()
  71    * @see #setFont(java.awt.Font)
  72    * @serial the component's font.
  73    */
  74   private Font font;
  75
  76   /**
  77    * The name of the component.
  78    *
  79    * @see #getName()
  80    * @see #setName(String)
  81    * @serial the component's name.
  82    */
  83   private String name;
  84
  85   /**
  86    * The parent of this component.
  87    *
  88    * @see #getParent()
  89    * @see #setParent(java.awt.MenuContainer)
  90    * @serial ignored.
  91    */
  92   transient MenuContainer parent;
  93
  94   /**
  95    * The native peer for this component.
  96    *
  97    * @see #getPeer()
  98    * @see #setPeer(java.awt.peer.MenuComponentPeer)
  99    * @serial ignored.
 100    */
 101   transient MenuComponentPeer peer;
 102
 103   /**
 104    * The synchronization locking object for this component.
 105    *
 106    * @serial ignored.
 107    */
 108   private transient Object tree_lock = this;
 109
 110   /**
 111    * The toolkit for this object.
 112    *
 113    * @see #getToolkit()
 114    * @serial ignored.
 115    */
 116   private static transient Toolkit toolkit = Toolkit.getDefaultToolkit();
 117
 118   /**
 119    * The accessible context for this component.
 120    *
 121    * @see #getAccessibleContext()
 122    * @serial the accessibility information for this component.
 123    */
 124   AccessibleContext accessibleContext;
 125
 126   /**
 127    * Was the name of the component set?  This value defaults
 128    * to false and becomes true after a call to <code>setName()</code>.
 129    * Please note that this does not guarantee that name will then
 130    * be non-null, as this may be the value passed to <code>setName()</code>.
 131    *
 132    * @see #setName(String)
 133    * @serial true if the name value has been explicitly set by calling
 134    *         <code>setName()</code>.
 135    */
 136   private boolean nameExplicitlySet;
 137
 138   /**
 139    * Does this component handle new events?  Events will be handled
 140    * by this component if this is true.  Otherwise, they will be forwarded
 141    * up the component hierarchy.  This implementation does not use this
 142    * variable; it is merely provided for serialization compatability.
 143    *
 144    * @see #dispatchEvent(AWTEvent)
 145    * @serial true if events are to be processed locally.  Unused.
 146    */
 147   private boolean newEventsOnly;
 148
 149   /**
 150    * The focus listener chain handler which deals with focus events for
 151    * the accessible context of this component.
 152    *
 153    * @see AccessibleAWTMenuComponent#addFocusListener(java.awt.event.FocusListener)
 154    * @serial ignored.
 155    * This is package-private to avoid an accessor method.
 156    */
 157   transient FocusListener focusListener;
 158
 159   /**
 160    * Default constructor for subclasses.
 161    *
 162    * @throws HeadlessException ff GraphicsEnvironment.isHeadless() is true
 163    */
 164   public MenuComponent()
 165   {
 166     if (GraphicsEnvironment.isHeadless())
 167       throw new HeadlessException();
 168   }
 169
 170 /**
 171   * Returns the font in use for this component.
 172   *
 173   * @return the font for this component
 174   */
 175   public Font getFont()
 176   {
 177     if (font != null)
 178       return font;
 179
 180     if (parent != null)
 181       return parent.getFont();
 182
 183     return null;
 184   }
 185
 186   /**
 187    * Sets the font for this component to the specified font.
 188    *
 189    * @param font the new font for this component
 190    */
 191   public void setFont(Font font)
 192   {
 193     this.font = font;
 194   }
 195
 196   /**
 197    * Returns the name of this component.
 198    *
 199    * @return the name of this component
 200    */
 201   public String getName()
 202   {
 203     if (name == null && ! nameExplicitlySet)
 204       name = generateName();
 205     return name;
 206   }
 207
 208   /**
 209    * Subclasses should override this to return unique component names like
 210    * "menuitem0".
 211    *
 212    * @return the generated name for this menu component
 213    */
 214   String generateName()
 215   {
 216     // MenuComponent is abstract.
 217     return null;
 218   }
 219
 220   /**
 221    * Sets the name of this component to the specified name.
 222    *
 223    * @param name the new name of this component
 224    */
 225   public void setName(String name)
 226   {
 227     this.name = name;
 228     nameExplicitlySet = true;
 229   }
 230
 231   /**
 232    * Returns the parent of this component.
 233    *
 234    * @return the parent of this component
 235    */
 236   public MenuContainer getParent()
 237   {
 238     return parent;
 239   }
 240
 241   /**
 242    * Sets the parent of this component.
 243    *
 244    * @param parent the parent to set
 245    */
 246   final void setParent(MenuContainer parent)
 247   {
 248     this.parent = parent;
 249   }
 250
 251   /**
 252    * Returns the native windowing system peer for this component.
 253    *
 254    * @return the peer for this component
 255    *
 256    * @deprecated
 257    */
 258   public MenuComponentPeer getPeer()
 259   {
 260     return peer;
 261   }
 262
 263   /**
 264    * Sets the peer for this component.
 265    *
 266    * @param peer the peer to set
 267    */
 268   final void setPeer(MenuComponentPeer peer)
 269   {
 270     this.peer = peer;
 271   }
 272
 273   /**
 274    * Destroys this component's native peer
 275    */
 276   public void removeNotify()
 277   {
 278     if (peer != null)
 279       peer.dispose();
 280     peer = null;
 281   }
 282
 283   /**
 284    * Returns the toolkit in use for this component.
 285    *
 286    * @return the toolkit for this component
 287    */
 288   final Toolkit getToolkit()
 289   {
 290     return toolkit;
 291   }
 292
 293   /**
 294    * Returns the object used for synchronization locks on this component
 295    * when performing tree and layout functions.
 296    *
 297    * @return the synchronization lock for this component
 298    */
 299   protected final Object getTreeLock()
 300   {
 301     return tree_lock;
 302   }
 303
 304   /**
 305    * Sets the sync lock object for this component.
 306    *
 307    * @param treeLock the sync lock to set
 308    */
 309   final void setTreeLock(Object treeLock)
 310   {
 311     this.tree_lock = treeLock;
 312   }
 313
 314   /**
 315    * AWT 1.0 event dispatcher.
 316    *
 317    * @return true if the event was dispatched, false otherwise
 318    *
 319    * @deprecated Deprecated in favor of <code>dispatchEvent()</code>.
 320    */
 321   public boolean
 322   postEvent(Event event)
 323   {
 324     boolean retVal = false;
 325     MenuContainer parent = getParent();
 326     if (parent != null)
 327       retVal = parent.postEvent(event);
 328
 329     return retVal;
 330   }
 331
 332   /**
 333    * Sends this event to this component or a subcomponent for processing.
 334    *
 335    * @param event The event to dispatch
 336    */
 337   public final void dispatchEvent(AWTEvent event)
 338   {
 339     // Convert AWT 1.1 event to AWT 1.0 event.
 340     Event oldStyleEvent = Component.translateEvent(event);
 341     if (oldStyleEvent != null)
 342       {
 343         postEvent(oldStyleEvent);
 344       }
 345
 346     // See comment in Component.dispatchEvent().
 347     dispatchEventImpl(event);
 348   }
 349
 350   /**
 351    * Implementation of dispatchEvent. Allows trusted package classes
 352    * to dispatch additional events first.  This implementation first
 353    * translates <code>event</code> to an AWT 1.0 event and sends the
 354    * result to {@link #postEvent}.  The event is then
 355    * passed on to {@link #processEvent} for local processing.
 356    *
 357    * @param event the event to dispatch
 358    */
 359   void dispatchEventImpl(AWTEvent event)
 360   {
 361     // Do local processing.
 362     processEvent(event);
 363   }
 364
 365   /**
 366    * Processes the specified event.  In this class, this method simply
 367    * calls one of the more specific event handlers.
 368    *
 369    * @param event the event to process
 370    */
 371   protected void processEvent(AWTEvent event)
 372   {
 373     // Pass a focus event to the focus listener for
 374     // the accessibility context.
 375     if (event instanceof FocusEvent)
 376       {
 377         if (focusListener != null)
 378           {
 379             switch (event.id)
 380             {
 381             case FocusEvent.FOCUS_GAINED:
 382               focusListener.focusGained((FocusEvent) event);
 383               break;
 384             case FocusEvent.FOCUS_LOST:
 385               focusListener.focusLost((FocusEvent) event);
 386               break;
 387             }
 388           }
 389       }
 390   }
 391
 392   /**
 393    * Returns a string representation of this component.
 394    *
 395    * @return a string representation of this component
 396    */
 397   public String toString()
 398   {
 399     return getClass().getName() + "[" + paramString() + "]";
 400   }
 401
 402   /**
 403    * Returns a debugging string for this component
 404    */
 405   protected String paramString()
 406   {
 407     return "name=" + getName();
 408   }
 409
 410   /**
 411    * Gets the AccessibleContext associated with this <code>MenuComponent</code>.
 412    * As an abstract class, we return null.  Concrete subclasses should return
 413    * their implementation of the accessibility context.
 414    *
 415    * @return null
 416    */
 417   public AccessibleContext getAccessibleContext()
 418   {
 419     return null;
 420   }
 421
 422   /**
 423    * This class provides a base for the accessibility support of menu
 424    * components.
 425    *
 426    * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
 427    */
 428   protected abstract class AccessibleAWTMenuComponent
 429     extends AccessibleContext
 430     implements Serializable, AccessibleComponent, AccessibleSelection
 431   {
 432
 433     /**
 434      * Compatible with JDK 1.4.2 revision 5
 435      */
 436     private static final long serialVersionUID = -4269533416223798698L;
 437
 438     /**
 439      * This is the default constructor.  It should be called by
 440      * concrete subclasses to ensure necessary groundwork is completed.
 441      */
 442     protected AccessibleAWTMenuComponent()
 443     {
 444       // Nothing to do here.
 445     }
 446
 447     /**
 448      * Replaces or supplements the component's selection with the
 449      * <code>Accessible</code> child at the supplied index.  If
 450      * the component supports multiple selection, the child is
 451      * added to the current selection.  Otherwise, the current
 452      * selection becomes the specified child.  If the child is
 453      * already selected, nothing happens.
 454      * <br />
 455      * <br />
 456      * As the existence of children can not be determined from
 457      * this abstract class, the implementation of this method
 458      * is left to subclasses.
 459      *
 460      * @param index the index of the specified child within a
 461      *        zero-based list of the component's children
 462      */
 463     public void addAccessibleSelection(int index)
 464     {
 465       // Subclasses with children should implement this.
 466     }
 467
 468     /**
 469      * Registers the specified focus listener to receive
 470      * focus events from this component.
 471      *
 472      * @param listener the new focus listener
 473      */
 474     public void addFocusListener(FocusListener listener)
 475     {
 476        // Chain the new focus listener to the existing chain
 477        // of focus listeners.  Each new focus listener is
 478        // coupled via multicasting to the existing chain.
 479       focusListener = AWTEventMulticaster.add(focusListener, listener);
 480     }
 481
 482     /**
 483      * Clears the component's current selection.  Following
 484      * the calling of this method, no children of the component
 485      * will be selected.
 486      * <br />
 487      * <br />
 488      * As the existence of children can not be determined from
 489      * this abstract class, the implementation of this method
 490      * is left to subclasses.
 491      */
 492     public void clearAccessibleSelection()
 493     {
 494       // Nothing to do here.
 495     }
 496
 497     /**
 498      * Returns true if the specified point lies within the
 499      * component.  The supplied co-ordinates are assumed to
 500      * be relative to the co-ordinate system of the component
 501      * itself.  Thus, the point (0,0) is the upper left corner
 502      * of this component.
 503      * <br />
 504      * <br />
 505      * Please note that this method depends on a correctly implemented
 506      * version of the <code>getBounds()</code> method.  Subclasses
 507      * must provide the bounding rectangle via <code>getBounds()</code>
 508      * in order for this method to work.
 509      *
 510      * @param point the point to check against this component
 511      * @return true if the point is within this component
 512      * @see #getBounds()
 513      */
 514     public boolean contains(Point point)
 515     {
 516       // We can simply return the result of a
 517       // test for containment in the bounding rectangle.
 518       return getBounds().contains(point);
 519     }
 520
 521     /**
 522      * Returns the <code>Accessible</code> child of this component present
 523      * at the specified point.  The supplied co-ordinates are
 524      * assumed to be relative to the co-ordinate system of this
 525      * component (the parent of any returned accessible).  Thus,
 526      * the point (0,0) is the upper left corner of this menu
 527      * component.
 528      * <br />
 529      * <br />
 530      * As the existence of children can not be determined from
 531      * this abstract class, the implementation of this method
 532      * is left to subclasses.
 533      *
 534      * @param point the point at which the returned accessible
 535      *        is located
 536      * @return null
 537      */
 538     public Accessible getAccessibleAt(Point point)
 539     {
 540       return null;
 541     }
 542
 543     /**
 544      * Returns the <code>Accessible</code> child at the supplied
 545      * index within the list of children of this component.
 546      * <br />
 547      * <br />
 548      * As the existence of children can not be determined from
 549      * this abstract class, the implementation of this method
 550      * is left to subclasses.
 551      *
 552      * @param index the index of the <code>Accessible</code> child
 553      *        to retrieve
 554      *
 555      * @return null
 556      */
 557     public Accessible getAccessibleChild(int index)
 558     {
 559       return null;
 560     }
 561
 562     /**
 563      * Returns the number of children of this component which
 564      * implement the <code>Accessible</code> interface.  If
 565      * all children of this component are accessible, then
 566      * the returned value will be the same as the number of
 567      * children.
 568      * <br />
 569      * <br />
 570      *
 571      * @return 0
 572      */
 573     public int getAccessibleChildrenCount()
 574     {
 575       return 0;
 576     }
 577
 578     /**
 579      * Retrieves the <code>AccessibleComponent</code> associated
 580      * with this accessible context and its component.  As the
 581      * context itself implements <code>AccessibleComponent</code>,
 582      * this is the return value.
 583      *
 584      * @return the context itself
 585      */
 586     public AccessibleComponent getAccessibleComponent()
 587     {
 588       return this;
 589     }
 590
 591     /**
 592      * Returns the accessible name for this menu component.  This
 593      * is the name given to the component, which may be null if
 594      * not set using <code>setName()</code>.
 595      * <br />
 596      * <br />
 597      * The name is not the most appropriate description of this
 598      * object.  Subclasses should preferably provide a more
 599      * accurate description.  For example, a File menu could
 600      * have the description `Lists commands related to the
 601      * file system'.
 602      *
 603      * @return a description of the component.  Currently,
 604      *         this is just the contents of the name property
 605      *
 606      * @see MenuComponent#setName(String)
 607      */
 608     public String getAccessibleDescription()
 609     {
 610       return MenuComponent.this.getName();
 611     }
 612
 613     /**
 614      * Retrieves the index of this component within its parent.
 615      * If no parent exists, -1 is returned.
 616      *
 617      * @return -1 as the parent, a <code>MenuContainer</code>
 618      *         is not <code>Accessible</code>
 619      */
 620     public int getAccessibleIndexInParent()
 621     {
 622       return -1;
 623     }
 624
 625     /**
 626      * Returns the accessible name of this component.  This
 627      * is the name given to the component, which may be null if
 628      * not set using <code>setName()</code>.
 629      * <br />
 630      * <br />
 631      * The name property is not the most suitable string to return
 632      * for this method.  The string should be localized, and
 633      * relevant to the operation of the component.  For example,
 634      * it could be the text of a menu item.  However, this can
 635      * not be used at this level of abstraction, so it is the
 636      * responsibility of subclasses to provide a more appropriate
 637      * name.
 638      *
 639      * @return a localized name for this component.  Currently, this
 640      *         is just the contents of the name property
 641      *
 642      * @see MenuComponent#setName(String)
 643      */
 644     public String getAccessibleName()
 645     {
 646       return MenuComponent.this.getName();
 647     }
 648
 649     /**
 650      * Returns the <code>Accessible</code> parent of this component.
 651      * As the parent of a <code>MenuComponent</code> is a
 652      * <code>MenuContainer</code>, which doesn't implement
 653      * <code>Accessible</code>, this method returns null.
 654      *
 655      * @return null
 656      */
 657     public Accessible getAccessibleParent()
 658     {
 659       return null;
 660     }
 661
 662     /**
 663      * Returns the accessible role of this component.
 664      * <br />
 665      * <br />
 666      * The abstract implementation of this method returns
 667      * <code>AccessibleRole.AWT_COMPONENT</code>,
 668      * as the abstract component has no specific role.  This
 669      * method should be overridden by concrete subclasses, so
 670      * as to return an appropriate role for the component.
 671      *
 672      * @return <code>AccessibleRole.AWT_COMPONENT</code>
 673      */
 674     public AccessibleRole getAccessibleRole()
 675     {
 676       return AccessibleRole.AWT_COMPONENT;
 677     }
 678
 679     /**
 680      * Retrieves the <code>AccessibleSelection</code> associated
 681      * with this accessible context and its component.  As the
 682      * context itself implements <code>AccessibleSelection</code>,
 683      * this is the return value.
 684      *
 685      * @return the context itself
 686      */
 687     public AccessibleSelection getAccessibleSelection()
 688     {
 689       return this;
 690     }
 691
 692     /**
 693      * Retrieves the <code>Accessible</code> selected child
 694      * at the specified index.  If there are no selected children
 695      * or the index is outside the range of selected children,
 696      * null is returned.  Please note that the index refers
 697      * to the index of the child in the list of <strong>selected
 698      * children</strong>, and not the index of the child in
 699      * the list of all <code>Accessible</code> children.
 700      * <br />
 701      * <br />
 702      * As the existence of children can not be determined from
 703      * this abstract class, the implementation of this method
 704      * is left to subclasses.
 705      *
 706      * @param index the index of the selected <code>Accessible</code>
 707      *        child
 708      */
 709     public Accessible getAccessibleSelection(int index)
 710     {
 711       return null;
 712     }
 713
 714     /**
 715      * Returns a count of the number of <code>Accessible</code>
 716      * children of this component which are currently selected.
 717      * If there are no children currently selected, 0 is returned.
 718      * <br />
 719      * <br />
 720      * As the existence of children can not be determined from
 721      * this abstract class, the implementation of this method
 722      * is left to subclasses.
 723      *
 724      * @return 0
 725      */
 726     public int getAccessibleSelectionCount()
 727     {
 728       return 0;
 729     }
 730
 731     /**
 732      * Retrieves the current state of this component
 733      * in an accessible form.  For example, a given component
 734      * may be visible, selected, disabled, etc.
 735      * <br />
 736      * <br />
 737      * As this class tells us virtually nothing about the component,
 738      * except for its name and font, no state information can be
 739      * provided.  This implementation thus returns an empty
 740      * state set, and it is left to concrete subclasses to provide
 741      * a more acceptable and relevant state set.  Changes to these
 742      * properties also need to be handled using
 743      * <code>PropertyChangeListener</code>s.
 744      *
 745      * @return an empty <code>AccessibleStateSet</code>
 746      */
 747     public AccessibleStateSet getAccessibleStateSet()
 748     {
 749       return new AccessibleStateSet();
 750     }
 751
 752     /**
 753      * Returns the background color of the component, or null
 754      * if this property is unsupported.
 755      * <br />
 756      * <br />
 757      * This abstract class knows nothing about how the component
 758      * is drawn on screen, so this method simply returns the
 759      * default system background color used for rendering menus.
 760      * Concrete subclasses which handle the drawing of an onscreen
 761      * menu component should override this method and provide
 762      * the appropriate information.
 763      *
 764      * @return the default system background color for menus
 765      *
 766      * @see #setBackground(java.awt.Color)
 767      */
 768     public Color getBackground()
 769     {
 770       return SystemColor.menu;
 771     }
 772
 773     /**
 774      * Returns a <code>Rectangle</code> which represents the
 775      * bounds of this component.  The returned rectangle has the
 776      * height and width of the component's bounds, and is positioned
 777      * at a location relative to this component's parent, the
 778      * <code>MenuContainer</code>.  null is returned if bounds
 779      * are not supported by the component.
 780      * <br />
 781      * <br />
 782      * This abstract class knows nothing about how the component
 783      * is drawn on screen, so this method simply returns null.
 784      * Concrete subclasses which handle the drawing of an onscreen
 785      * menu component should override this method and provide
 786      * the appropriate information.
 787      *
 788      * @return null
 789      *
 790      * @see #setBounds(java.awt.Rectangle)
 791      */
 792     public Rectangle getBounds()
 793     {
 794       return null;
 795     }
 796
 797     /**
 798      * Returns the <code>Cursor</code> displayed when the pointer
 799      * is positioned over this component.  Alternatively, null
 800      * is returned if the component doesn't support the cursor
 801      * property.
 802      * <br />
 803      * <br />
 804      * This abstract class knows nothing about how the component
 805      * is drawn on screen, so this method simply returns the default
 806      * system cursor.  Concrete subclasses which handle the drawing
 807      * of an onscreen menu component may override this method and provide
 808      * the appropriate information.
 809      *
 810      * @return the default system cursor
 811      *
 812      * @see #setCursor(java.awt.Cursor)
 813      */
 814     public Cursor getCursor()
 815     {
 816       return Cursor.getDefaultCursor();
 817     }
 818
 819     /**
 820      * Returns the <code>Font</code> used for text created by this component.
 821      *
 822      * @return the current font
 823      *
 824      * @see #setFont(java.awt.Font)
 825      */
 826     public Font getFont()
 827     {
 828       return MenuComponent.this.getFont();
 829     }
 830
 831     /**
 832      * Retrieves information on the rendering and metrics of the supplied
 833      * font.  If font metrics are not supported by this component, null
 834      * is returned.
 835      * <br />
 836      * <br />
 837      * The abstract implementation of this method simply uses the toolkit
 838      * to obtain the <code>FontMetrics</code>.  Concrete subclasses may
 839      * find it more efficient to invoke their peer class directly, if one
 840      * is available.
 841      *
 842      * @param font the font about which to retrieve rendering and metric
 843      *        information
 844      *
 845      * @return the metrics of the given font, as provided by the system
 846      *         toolkit
 847      *
 848      * @throws NullPointerException if the supplied font was null
 849      */
 850     public FontMetrics getFontMetrics(Font font)
 851     {
 852       return MenuComponent.this.getToolkit().getFontMetrics(font);
 853     }
 854
 855     /**
 856      * Returns the foreground color of the component, or null
 857      * if this property is unsupported.
 858      * <br />
 859      * <br />
 860      * This abstract class knows nothing about how the component
 861      * is drawn on screen, so this method simply returns the
 862      * default system text color used for rendering menus.
 863      * Concrete subclasses which handle the drawing of an onscreen
 864      * menu component should override this method and provide
 865      * the appropriate information.
 866      *
 867      * @return the default system text color for menus
 868      *
 869      * @see #setForeground(java.awt.Color)
 870      */
 871     public Color getForeground()
 872     {
 873       return SystemColor.menuText;
 874     }
 875
 876     /**
 877      * Returns the locale currently in use by this component.
 878      * <br />
 879      * <br />
 880      * This abstract class has no property relating to the
 881      * locale used by the component, so this method simply
 882      * returns the default locale for the current instance
 883      * of the Java Virtual Machine (JVM).  Concrete subclasses
 884      * which maintain such a property should override this method
 885      * and provide the locale information more accurately.
 886      *
 887      * @return the default locale for this JVM instance
 888      */
 889     public Locale getLocale()
 890     {
 891       return Locale.getDefault();
 892     }
 893
 894     /**
 895      * Returns the location of the component, with co-ordinates
 896      * relative to the parent component and using the co-ordinate
 897      * space of the screen.  Thus, the point (0,0) is the upper
 898      * left corner of the parent component.
 899      * <br />
 900      * <br />
 901      * Please note that this method depends on a correctly implemented
 902      * version of the <code>getBounds()</code> method.  Subclasses
 903      * must provide the bounding rectangle via <code>getBounds()</code>
 904      * in order for this method to work.
 905      *
 906      * @return the location of the component, relative to its parent
 907      *
 908      * @see #setLocation(java.awt.Point)
 909      */
 910     public Point getLocation()
 911     {
 912       // Simply return the location of the bounding rectangle.
 913       return getBounds().getLocation();
 914     }
 915
 916     /**
 917      * Returns the location of the component, with co-ordinates
 918      * relative to the screen.  Thus, the point (0,0) is the upper
 919      * left corner of the screen.  null is returned if the component
 920      * is either not on screen or if this property is unsupported.
 921      * <br />
 922      * <br />
 923      * This abstract class knows nothing about how the component
 924      * is drawn on screen, so this method simply returns null.
 925      * Concrete subclasses which handle the drawing of an onscreen
 926      * menu component should override this method and provide
 927      * the appropriate information.
 928      *
 929      * @return the location of the component, relative to the screen
 930      */
 931     public Point getLocationOnScreen()
 932     {
 933       return null;
 934     }
 935
 936     /**
 937      * Returns the size of the component.
 938      * <br />
 939      * <br />
 940      * Please note that this method depends on a correctly implemented
 941      * version of the <code>getBounds()</code> method.  Subclasses
 942      * must provide the bounding rectangle via <code>getBounds()</code>
 943      * in order for this method to work.
 944      *
 945      * @return the size of the component
 946      *
 947      * @see #setSize(java.awt.Dimension)
 948      */
 949     public Dimension getSize()
 950     {
 951       // Simply return the size of the bounding rectangle.
 952       return getBounds().getSize();
 953     }
 954
 955     /**
 956      * Returns true if the accessible child specified by the supplied index
 957      * is currently selected.
 958      * <br />
 959      * <br />
 960      * As the existence of children can not be determined from
 961      * this abstract class, the implementation of this method
 962      * is left to subclasses.
 963      *
 964      * @param index the index of the accessible child to check for selection
 965      *
 966      * @return false
 967      */
 968     public boolean isAccessibleChildSelected(int index)
 969     {
 970       return false;
 971     }
 972
 973     /**
 974      * Returns true if this component is currently enabled.
 975      * <br />
 976      * <br />
 977      * As this abstract component has no properties related to
 978      * its enabled or disabled state, the implementation of this
 979      * method is left to subclasses.
 980      *
 981      * @return false
 982      *
 983      * @see #setEnabled(boolean)
 984      */
 985     public boolean isEnabled()
 986     {
 987       return false;
 988     }
 989
 990     /**
 991      * Returns true if this component is included in the traversal
 992      * of the current focus from one component to the other.
 993      * <br />
 994      * <br />
 995      * As this abstract component has no properties related to
 996      * its ability to accept the focus, the implementation of this
 997      * method is left to subclasses.
 998      *
 999      * @return false
1000      */
1001     public boolean isFocusTraversable()
1002     {
1003       return false;
1004     }
1005
1006     /**
1007      * Returns true if the component is being shown on screen.
1008      * A component is determined to be shown if it is visible,
1009      * and each parent component is also visible.  Please note
1010      * that, even when a component is showing, it may still be
1011      * obscured by other components in front.  This method only
1012      * determines if the component is being drawn on the screen.
1013      * <br />
1014      * <br />
1015      * As this abstract component and its parent have no properties
1016      * relating to visibility, the implementation of this method is
1017      * left to subclasses.
1018      *
1019      * @return false
1020      *
1021      * @see #isVisible()
1022      */
1023     public boolean isShowing()
1024     {
1025       return false;
1026     }
1027
1028     /**
1029      * Returns true if the component is visible.  A component may
1030      * be visible but not drawn on the screen if one of its parent
1031      * components is not visible.  To determine if the component is
1032      * actually drawn on screen, <code>isShowing()</code> should be
1033      * used.
1034      * <br />
1035      * <br />
1036      * As this abstract component has no properties relating to its
1037      * visibility, the implementation of this method is left to subclasses.
1038      *
1039      * @return false
1040      *
1041      * @see #isShowing()
1042      * @see #setVisible(boolean)
1043      */
1044     public boolean isVisible()
1045     {
1046       return false;
1047     }
1048
1049     /**
1050      * Removes the accessible child specified by the supplied index from
1051      * the list of currently selected children.  If the child specified
1052      * is not selected, nothing happens.
1053      * <br />
1054      * <br />
1055      * As the existence of children can not be determined from
1056      * this abstract class, the implementation of this method
1057      * is left to subclasses.
1058      *
1059      * @param index the index of the <code>Accessible</code> child
1060      */
1061     public void removeAccessibleSelection(int index)
1062     {
1063       // Subclasses with children should implement this.
1064     }
1065
1066     /**
1067      * Removes the specified focus listener from the list of registered
1068      * focus listeners for this component.
1069      *
1070      * @param listener the listener to remove
1071      */
1072     public void removeFocusListener(FocusListener listener)
1073     {
1074       // Remove the focus listener from the chain.
1075       focusListener = AWTEventMulticaster.remove(focusListener, listener);
1076     }
1077
1078     /**
1079      * Requests that this component gains focus.  This depends on the
1080      * component being focus traversable.
1081      * <br />
1082      * <br />
1083      * As this abstract component has no properties relating to its
1084      * focus traversability, or access to a peer with request focusing
1085      * abilities, the implementation of this method is left to subclasses.
1086      */
1087     public void requestFocus()
1088     {
1089       // Ignored.
1090     }
1091
1092     /**
1093      * Selects all <code>Accessible</code> children of this component which
1094      * it is possible to select.  The component needs to support multiple
1095      * selections.
1096      * <br />
1097      * <br />
1098      * This abstract component provides a simplistic implementation of this
1099      * method, which ignores the ability of the component to support multiple
1100      * selections and simply uses <code>addAccessibleSelection</code> to
1101      * add each <code>Accessible</code> child to the selection.  The last
1102      * <code>Accessible</code> component is thus selected for components
1103      * which don't support multiple selections.  Concrete implementations should
1104      * override this with a more appopriate and efficient implementation, which
1105      * properly takes into account the ability of the component to support multiple
1106      * selections.
1107      */
1108     public void selectAllAccessibleSelection()
1109     {
1110       // Simply call addAccessibleSelection() on all accessible children.
1111       for (int a = 0; a < getAccessibleChildrenCount(); ++a)
1112         {
1113           addAccessibleSelection(a);
1114         }
1115     }
1116
1117     /**
1118      * Sets the background color of the component to that specified.
1119      * Unspecified behaviour occurs when null is given as the new
1120      * background color.
1121      * <br />
1122      * <br />
1123      * This abstract class knows nothing about how the component
1124      * is drawn on screen, so this method simply ignores the supplied
1125      * color and continues to use the default system color.
1126      * Concrete subclasses which handle the drawing of an onscreen
1127      * menu component should override this method and provide
1128      * the appropriate information.
1129      *
1130      * @param color the new color to use for the background
1131      *
1132      * @see #getBackground()
1133      */
1134     public void setBackground(Color color)
1135     {
1136       // Ignored.
1137     }
1138
1139     /**
1140      * Sets the height and width of the component, and its position
1141      * relative to this component's parent, to the values specified
1142      * by the supplied rectangle.  Unspecified behaviour occurs when
1143      * null is given as the new bounds.
1144      * <br />
1145      * <br />
1146      * This abstract class knows nothing about how the component
1147      * is drawn on screen, so this method simply ignores the new
1148      * rectangle and continues to return null from <code>getBounds()</code>.
1149      * Concrete subclasses which handle the drawing of an onscreen
1150      * menu component should override this method and provide
1151      * the appropriate information.
1152      *
1153      * @param rectangle a rectangle which specifies the new bounds of
1154      *        the component
1155      *
1156      * @see #getBounds()
1157      */
1158     public void setBounds(Rectangle rectangle)
1159     {
1160       // Ignored.
1161     }
1162
1163     /**
1164      * Sets the <code>Cursor</code> used when the pointer is positioned over the
1165      * component.  Unspecified behaviour occurs when null is given as the new
1166      * cursor.
1167      * <br />
1168      * <br />
1169      * This abstract class knows nothing about how the component
1170      * is drawn on screen, so this method simply ignores the new cursor
1171      * and continues to return the default system cursor.  Concrete
1172      * subclasses which handle the drawing of an onscreen menu component
1173      * may override this method and provide the appropriate information.
1174      *
1175      * @param cursor the new cursor to use
1176      *
1177      * @see #getCursor()
1178      */
1179     public void setCursor(Cursor cursor)
1180     {
1181       // Ignored.
1182     }
1183
1184     /**
1185      * Sets the enabled/disabled state of this component.
1186      * <br />
1187      * <br />
1188      * As this abstract component has no properties related to
1189      * its enabled or disabled state, the implementation of this
1190      * method is left to subclasses.
1191      *
1192      * @param enabled true if the component should be enabled,
1193      *        false otherwise
1194      *
1195      * @see #isEnabled()
1196      */
1197     public void setEnabled(boolean enabled)
1198     {
1199       // Ignored.
1200     }
1201
1202     /**
1203      * Sets the <code>Font</code> used for text created by this component.
1204      * Unspecified behaviour occurs when null is given as the new
1205      * font.
1206      *
1207      * @param font the new font to use for text.
1208      * @see #getFont()
1209      */
1210     public void setFont(Font font)
1211     {
1212       // Call the method of the enclosing component.
1213       MenuComponent.this.setFont(font);
1214     }
1215
1216     /**
1217      * Sets the foreground color of the component to that specified.
1218      * Unspecified behaviour occurs when null is given as the new
1219      * background color.
1220      * <br />
1221      * <br />
1222      * This abstract class knows nothing about how the component
1223      * is drawn on screen, so this method simply ignores the supplied
1224      * color and continues to return the default system text color used
1225      * for rendering menus.
1226      * Concrete subclasses which handle the drawing of an onscreen
1227      * menu component should override this method and provide
1228      * the appropriate information.
1229      *
1230      * @param color the new foreground color
1231      *
1232      * @see #getForeground()
1233      */
1234     public void setForeground(Color color)
1235     {
1236       // Ignored.
1237     }
1238
1239     /**
1240      * Sets the location of the component, with co-ordinates
1241      * relative to the parent component and using the co-ordinate
1242      * space of the screen.  Thus, the point (0,0) is the upper
1243      * left corner of the parent component.
1244      * <br />
1245      * <br />
1246      * Please note that this method depends on a correctly implemented
1247      * version of the <code>getBounds()</code> method.  Subclasses
1248      * must provide the bounding rectangle via <code>getBounds()</code>
1249      * in order for this method to work.
1250      *
1251      * @param point the location of the component, relative to its parent
1252      *
1253      * @see #getLocation()
1254      */
1255     public void setLocation(Point point)
1256     {
1257       getBounds().setLocation(point);
1258     }
1259
1260     /**
1261      * Sets the size of the component.
1262      * <br />
1263      * <br />
1264      * Please note that this method depends on a correctly implemented
1265      * version of the <code>getBounds()</code> method.  Subclasses
1266      * must provide the bounding rectangle via <code>getBounds()</code>
1267      * in order for this method to work.
1268      *
1269      * @param size the new size of the component
1270      *
1271      * @see #getSize()
1272      */
1273     public void setSize(Dimension size)
1274     {
1275       getBounds().setSize(size);
1276     }
1277
1278     /**
1279      * Sets the visibility state of the component.  A component may
1280      * be visible but not drawn on the screen if one of its parent
1281      * components is not visible.  To determine if the component is
1282      * actually drawn on screen, <code>isShowing()</code> should be
1283      * used.
1284      * <br />
1285      * <br />
1286      * As this abstract component has no properties relating to its
1287      * visibility, the implementation of this method is left to subclasses.
1288      *
1289      * @param visibility the new visibility of the component -- true if
1290      *        the component is visible, false if not
1291      *
1292      * @see #isShowing()
1293      * @see #isVisible()
1294      */
1295     public void setVisible(boolean visibility)
1296     {
1297       // Ignored.
1298     }
1299
1300   }
1301
1302 }