Imported GNU Classpath 0.90

       * scripts/makemake.tcl: Set gnu/java/awt/peer/swing to ignore.
       * gnu/classpath/jdwp/VMFrame.java (SIZE): New constant.
       * java/lang/VMCompiler.java: Use gnu.java.security.hash.MD5.
       * java/lang/Math.java: New override file.
       * java/lang/Character.java: Merged from Classpath.
       (start, end): Now 'int's.
       (canonicalName): New field.
       (CANONICAL_NAME, NO_SPACES_NAME, CONSTANT_NAME): New constants.
       (UnicodeBlock): Added argument.
       (of): New overload.
       (forName): New method.
       Updated unicode blocks.
       (sets): Updated.
       * sources.am: Regenerated.
       * Makefile.in: Likewise.


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@111942 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 996 insertions, 1032 deletions

diff --git a/libjava/classpath/java/awt/MenuComponent.java b/libjava/classpath/java/awt/MenuComponent.java
index 375d08436e0..9bb875069e0 100644
--- a/libjava/classpath/java/awt/MenuComponent.java
+++ b/libjava/classpath/java/awt/MenuComponent.java
@@ -1,5 +1,6 @@
 /* MenuComponent.java -- Superclass of all AWT menu components
-   Copyright (C) 1999, 2000, 2002, 2003, 2004, 2005  Free Software Foundation, Inc.
+   Copyright (C) 1999, 2000, 2002, 2003, 2004, 2005, 2006
+   Free Software Foundation, Inc.
 
 This file is part of GNU Classpath.
 
@@ -60,26 +61,16 @@ import javax.accessibility.AccessibleStateSet;
 public abstract class MenuComponent implements Serializable
 {
 
-/*
- * Static Variables
- */
+//Serialization Constant
+  private static final long serialVersionUID = -4536902356223894379L;
 
-// Serialization Constant
-private static final long serialVersionUID = -4536902356223894379L;
-
-/*************************************************************************/
-  
-/*
- * Instance Variables
- */
-
-/**
- * The font for this component.
- *
- * @see #getFont()
- * @see #setFont(java.awt.Font)
- * @serial the component's font.
- */
+  /**
+   * The font for this component.
+   *
+   * @see #getFont()
+   * @see #setFont(java.awt.Font)
+   * @serial the component's font.
+   */
   private Font font;
 
   /**
@@ -165,1160 +156,1133 @@ private static final long serialVersionUID = -4536902356223894379L;
    */
   transient FocusListener focusListener;
 
-/*************************************************************************/
-
-/*
- * Constructors
- */
-
-/**
-  * Default constructor for subclasses.
-  *
-  * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true.
-  */
-public
-MenuComponent()
-{
-  if (GraphicsEnvironment.isHeadless())
-    throw new HeadlessException ();
-}
-
-/*************************************************************************/
-
-/*
- * Instance Methods
- */
+  /**
+   * Default constructor for subclasses.
+   *
+   * @throws HeadlessException ff GraphicsEnvironment.isHeadless() is true
+   */
+  public MenuComponent()
+  {
+    if (GraphicsEnvironment.isHeadless())
+      throw new HeadlessException();
+  }
 
 /**
   * Returns the font in use for this component.
   *
-  * @return The font for this component.
-  */
-public Font
-getFont()
-{
-  if (font != null)
-    return font;
-
-  if (parent != null)
-    return parent.getFont ();
-
-  return null;
-}
-
-/*************************************************************************/
-
-/**
-  * Sets the font for this component to the specified font.
-  *
-  * @param font The new font for this component.
-  */
-public void
-setFont(Font font)
-{
-  this.font = font;
-}
-
-/*************************************************************************/
-
-/**
-  * Returns the name of this component.
-  *
-  * @return The name of this component.
-  */
-public String
-getName()
-{
-  return(name);
-}
-
-/*************************************************************************/
-
-/**
-  * Sets the name of this component to the specified name.
-  *
-  * @param name The new name of this component.
-  */
-public void
-setName(String name)
-{
-  this.name = name;
-  nameExplicitlySet = true;
-}
-
-/*************************************************************************/
-
-/**
-  * Returns the parent of this component.
-  * 
-  * @return The parent of this component.
-  */
-public MenuContainer
-getParent()
-{
-  return(parent);
-} 
-
-/*************************************************************************/
-
-// Sets the parent of this component.
-final void
-setParent(MenuContainer parent)
-{
-  this.parent = parent;
-}
-
-/*************************************************************************/
-
-/**
-  * Returns the native windowing system peer for this component.
-  *
-  * @return The peer for this component.
-  *
-  * @deprecated
-  */
-public MenuComponentPeer
-getPeer()
-{
-  return(peer);
-}
-
-/*************************************************************************/
-
-// Sets the peer for this component.
-final void
-setPeer(MenuComponentPeer peer)
-{
-  this.peer = peer;
-}
-
-/*************************************************************************/
-
-/**
-  * Destroys this component's native peer
-  */
-public void
-removeNotify()
-{
-  if (peer != null)
-    peer.dispose();
-  peer = null;
-}
-
-/*************************************************************************/
-
-/**
-  * Returns the toolkit in use for this component.
-  *
-  * @return The toolkit for this component.
-  */
-final Toolkit
-getToolkit()
-{
-  return(toolkit);
-}
-
-/*************************************************************************/
-
-/**
-  * Returns the object used for synchronization locks on this component
-  * when performing tree and layout functions.
-  *
-  * @return The synchronization lock for this component.
-  */
-protected final Object
-getTreeLock()
-{
-  return(tree_lock);
-}
-
-/*************************************************************************/
-
-// The sync lock object for this component.
-final void
-setTreeLock(Object tree_lock)
-{
-  this.tree_lock = tree_lock;
-}
-
-/*************************************************************************/
-
-/**
-  * AWT 1.0 event dispatcher.
-  *
-  * @deprecated Deprecated in favor of <code>dispatchEvent()</code>.
-  * @return true if the event was dispatched, false otherwise.
-  */
-public boolean
-postEvent(Event event)
-{
-  // This is overridden by subclasses that support events.
-  return false;
-}
-/*************************************************************************/
-
-/**
-  * Sends this event to this component or a subcomponent for processing.
-  *
-  * @param event The event to dispatch
-  */
-public final void dispatchEvent(AWTEvent event)
-{
-  // See comment in Component.dispatchEvent().
-  dispatchEventImpl(event);
-}
-
-
-/**
- * Implementation of dispatchEvent. Allows trusted package classes
- * to dispatch additional events first.  This implementation first
- * translates <code>event</code> to an AWT 1.0 event and sends the
- * result to {@link #postEvent}.  The event is then
- * passed on to {@link #processEvent} for local processing.
- *
- * @param event the event to dispatch.
- */
-void dispatchEventImpl(AWTEvent event)
-{
-  Event oldStyleEvent;
-
-  // This is overridden by subclasses that support events.
-  /* Convert AWT 1.1 event to AWT 1.0 event */
-  oldStyleEvent = Component.translateEvent(event);
-  if (oldStyleEvent != null)
-    {
-      postEvent(oldStyleEvent);
-    }
-  /* Do local processing */
-  processEvent(event);
-}
-
-/*************************************************************************/
-
-/**
-  * Processes the specified event.  In this class, this method simply
-  * calls one of the more specific event handlers.
-  * 
-  * @param event The event to process.
-  */
-protected void
-processEvent(AWTEvent event)
-{
-  /* 
-     Pass a focus event to the focus listener for
-     the accessibility context.
-  */
-  if (event instanceof FocusEvent)
-    {
-      if (focusListener != null)
-        {
-          switch (event.id)
-            {
-            case FocusEvent.FOCUS_GAINED:
-              focusListener.focusGained((FocusEvent) event);
-              break;
-            case FocusEvent.FOCUS_LOST:
-              focusListener.focusLost((FocusEvent) event);
-              break;
-            }
-        }
-    }
-}
-
-/*************************************************************************/
-
-/**
-  * Returns a string representation of this component.
-  *
-  * @return A string representation of this component
+  * @return the font for this component
   */
-public String
-toString()
-{
-  return this.getClass().getName() + "[" + paramString() + "]";
-}
-
-/*************************************************************************/
-
-/**
- * Returns a debugging string for this component
- */
-protected String
-paramString()
-{
-  return "name=" + getName();
-}
-
-/**
- * Gets the AccessibleContext associated with this <code>MenuComponent</code>.
- * As an abstract class, we return null.  Concrete subclasses should return
- * their implementation of the accessibility context.
- *
- * @return null.
- */
-
-public AccessibleContext getAccessibleContext()
-{
-  return null;
-}
+  public Font getFont()
+  {
+    if (font != null)
+      return font;
 
-/**
- * This class provides a base for the accessibility support of menu
- * components.
- *
- * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
- */
-protected abstract class AccessibleAWTMenuComponent
-  extends AccessibleContext
-  implements Serializable, AccessibleComponent, AccessibleSelection
-{
+    if (parent != null)
+      return parent.getFont();
 
-  /**
-   * Compatible with JDK 1.4.2 revision 5
-   */
-  private static final long serialVersionUID = -4269533416223798698L;
-
-  /**
-   * This is the default constructor.  It should be called by
-   * concrete subclasses to ensure necessary groundwork is completed.
-   */
-  protected AccessibleAWTMenuComponent()
-  {
+    return null;
   }
 
   /**
-   * Replaces or supplements the component's selection with the
-   * <code>Accessible</code> child at the supplied index.  If
-   * the component supports multiple selection, the child is
-   * added to the current selection.  Otherwise, the current
-   * selection becomes the specified child.  If the child is
-   * already selected, nothing happens.
-   * <br />
-   * <br />
-   * As the existence of children can not be determined from
-   * this abstract class, the implementation of this method
-   * is left to subclasses.
+   * Sets the font for this component to the specified font.
    *
-   * @param index the index of the specified child within a
-   *        zero-based list of the component's children.
+   * @param font the new font for this component
    */
-  public void addAccessibleSelection(int index)
+  public void setFont(Font font)
   {
-    /* Subclasses with children should implement this */
+    this.font = font;
   }
 
   /**
-   * Registers the specified focus listener to receive
-   * focus events from this component.
+   * Returns the name of this component.
    *
-   * @param listener the new focus listener.
+   * @return the name of this component
    */
-  public void addFocusListener(FocusListener listener)
+  public String getName()
   {
-    /*
-     * Chain the new focus listener to the existing chain
-     * of focus listeners.  Each new focus listener is
-     * coupled via multicasting to the existing chain.
-     */
-    focusListener = AWTEventMulticaster.add(focusListener, listener);
+    return name;
   }
 
   /**
-   * Clears the component's current selection.  Following
-   * the calling of this method, no children of the component
-   * will be selected.
-   * <br />
-   * <br />
-   * As the existence of children can not be determined from
-   * this abstract class, the implementation of this method
-   * is left to subclasses.
-   */
-  public void clearAccessibleSelection()
-  {
-  }
-
-  /**
-   * Returns true if the specified point lies within the
-   * component.  The supplied co-ordinates are assumed to
-   * be relative to the co-ordinate system of the component
-   * itself.  Thus, the point (0,0) is the upper left corner
-   * of this component.
-   * <br />
-   * <br />
-   * Please note that this method depends on a correctly implemented
-   * version of the <code>getBounds()</code> method.  Subclasses
-   * must provide the bounding rectangle via <code>getBounds()</code>
-   * in order for this method to work.  
+   * Sets the name of this component to the specified name.
    *
-   * @param point the point to check against this component.
-   * @return true if the point is within this component.
-   * @see #getBounds()
+   * @param name the new name of this component
    */
-  public boolean contains(Point point)
+  public void setName(String name)
   {
-    /* 
-       We can simply return the result of a
-       test for containment in the bounding rectangle 
-    */
-    return getBounds().contains(point);
+    this.name = name;
+    nameExplicitlySet = true;
   }
 
   /**
-   * Returns the <code>Accessible</code> child of this component present
-   * at the specified point.  The supplied co-ordinates are
-   * assumed to be relative to the co-ordinate system of this
-   * component (the parent of any returned accessible).  Thus,
-   * the point (0,0) is the upper left corner of this menu
-   * component.
-   * <br />
-   * <br />
-   * As the existence of children can not be determined from
-   * this abstract class, the implementation of this method
-   * is left to subclasses.
+   * Returns the parent of this component.
    * 
-   * @param point the point at which the returned accessible
-   *        is located.
-   * @return null.
+   * @return the parent of this component
    */
-  public Accessible getAccessibleAt(Point point)
+  public MenuContainer getParent()
   {
-    return null;
-  }
+    return parent;
+  } 
 
   /**
-   * Returns the <code>Accessible</code> child at the supplied
-   * index within the list of children of this component.
-   * <br />
-   * <br />
-   * As the existence of children can not be determined from
-   * this abstract class, the implementation of this method
-   * is left to subclasses.
+   * Sets the parent of this component.
    *
-   * @param index the index of the <code>Accessible</code> child
-   *        to retrieve.
-   * @return null.
+   * @param parent the parent to set
    */
-  public Accessible getAccessibleChild(int index)
+  final void setParent(MenuContainer parent)
   {
-    return null;
+    this.parent = parent;
   }
 
   /**
-   * Returns the number of children of this component which
-   * implement the <code>Accessible</code> interface.  If
-   * all children of this component are accessible, then
-   * the returned value will be the same as the number of
-   * children.
-   * <br />
-   * <br />
+   * Returns the native windowing system peer for this component.
+   *
+   * @return the peer for this component
    *
-   * @return 0.
+   * @deprecated
    */
-  public int getAccessibleChildrenCount()
+  public MenuComponentPeer getPeer()
   {
-    return 0;
+    return peer;
   }
 
   /**
-   * Retrieves the <code>AccessibleComponent</code> associated
-   * with this accessible context and its component.  As the
-   * context itself implements <code>AccessibleComponent</code>,
-   * this is the return value.
+   * Sets the peer for this component.
    *
-   * @return the context itself.
+   * @param peer the peer to set
    */
-  public AccessibleComponent getAccessibleComponent()
+  final void setPeer(MenuComponentPeer peer)
   {
-    return this;
+    this.peer = peer;
   }
 
   /**
-   * Returns the accessible name for this menu component.  This
-   * is the name given to the component, which may be null if
-   * not set using <code>setName()</code>.
-   * <br />
-   * <br />
-   * The name is not the most appropriate description of this
-   * object.  Subclasses should preferably provide a more
-   * accurate description.  For example, a File menu could
-   * have the description `Lists commands related to the
-   * file system'.
-   *
-   * @return a description of the component.  Currently,
-   *         this is just the contents of the name property.
-   * @see MenuComponent#setName(String)
+   * Destroys this component's native peer
    */
-  public String getAccessibleDescription()
+  public void removeNotify()
   {
-    return MenuComponent.this.getName();
+    if (peer != null)
+      peer.dispose();
+    peer = null;
   }
 
   /**
-   * Retrieves the index of this component within its parent.
-   * If no parent exists, -1 is returned.
+   * Returns the toolkit in use for this component.
    *
-   * @return -1 as the parent, a <code>MenuContainer</code>
-   *         is not <code>Accessible</code>.
+   * @return the toolkit for this component
    */
-  public int getAccessibleIndexInParent()
+  final Toolkit getToolkit()
   {
-    return -1;
+    return toolkit;
   }
 
   /**
-   * Returns the accessible name of this component.  This
-   * is the name given to the component, which may be null if
-   * not set using <code>setName()</code>.
-   * <br />
-   * <br />
-   * The name property is not the most suitable string to return
-   * for this method.  The string should be localized, and
-   * relevant to the operation of the component.  For example,
-   * it could be the text of a menu item.  However, this can
-   * not be used at this level of abstraction, so it is the
-   * responsibility of subclasses to provide a more appropriate
-   * name.
+   * Returns the object used for synchronization locks on this component
+   * when performing tree and layout functions.
    *
-   * @return a localized name for this component.  Currently, this
-   *         is just the contents of the name property.
-   * @see MenuComponent#setName(String)
+   * @return the synchronization lock for this component
    */
-  public String getAccessibleName()
+  protected final Object getTreeLock()
   {
-    return MenuComponent.this.getName();
+    return tree_lock;
   }
 
   /**
-   * Returns the <code>Accessible</code> parent of this component.
-   * As the parent of a <code>MenuComponent</code> is a
-   * <code>MenuContainer</code>, which doesn't implement
-   * <code>Accessible</code>, this method returns null.
+   * Sets the sync lock object for this component.
    *
-   * @return null.
+   * @param treeLock the sync lock to set
    */
-  public Accessible getAccessibleParent()
+  final void setTreeLock(Object treeLock)
   {
-    return null;
+    this.tree_lock = treeLock;
   }
 
   /**
-   * Returns the accessible role of this component.
-   * <br />
-   * <br />
-   * The abstract implementation of this method returns
-   * <code>AccessibleRole.AWT_COMPONENT</code>,
-   * as the abstract component has no specific role.  This
-   * method should be overridden by concrete subclasses, so
-   * as to return an appropriate role for the component.
+   * AWT 1.0 event dispatcher.
    *
-   * @return <code>AccessibleRole.AWT_COMPONENT</code>.
+   * @return true if the event was dispatched, false otherwise
+   *
+   * @deprecated Deprecated in favor of <code>dispatchEvent()</code>.
    */
-  public AccessibleRole getAccessibleRole()
+  public boolean
+  postEvent(Event event)
   {
-    return AccessibleRole.AWT_COMPONENT;
+    boolean retVal = false;
+    MenuContainer parent = getParent();
+    if (parent != null)
+      retVal = parent.postEvent(event);
+
+    return retVal;
   }
 
   /**
-   * Retrieves the <code>AccessibleSelection</code> associated
-   * with this accessible context and its component.  As the
-   * context itself implements <code>AccessibleSelection</code>,
-   * this is the return value.
+   * Sends this event to this component or a subcomponent for processing.
    *
-   * @return the context itself.
+   * @param event The event to dispatch
    */
-  public AccessibleSelection getAccessibleSelection()
+  public final void dispatchEvent(AWTEvent event)
   {
-    return this;
+    // Convert AWT 1.1 event to AWT 1.0 event.
+    Event oldStyleEvent = Component.translateEvent(event);
+    if (oldStyleEvent != null)
+      {
+        postEvent(oldStyleEvent);
+      }
+
+    // See comment in Component.dispatchEvent().
+    dispatchEventImpl(event);
   }
 
   /**
-   * Retrieves the <code>Accessible</code> selected child
-   * at the specified index.  If there are no selected children
-   * or the index is outside the range of selected children,
-   * null is returned.  Please note that the index refers
-   * to the index of the child in the list of <strong>selected
-   * children</strong>, and not the index of the child in
-   * the list of all <code>Accessible</code> children.
-   * <br />
-   * <br />
-   * As the existence of children can not be determined from
-   * this abstract class, the implementation of this method
-   * is left to subclasses.
+   * Implementation of dispatchEvent. Allows trusted package classes
+   * to dispatch additional events first.  This implementation first
+   * translates <code>event</code> to an AWT 1.0 event and sends the
+   * result to {@link #postEvent}.  The event is then
+   * passed on to {@link #processEvent} for local processing.
    *
-   * @param index the index of the selected <code>Accessible</code>
-   *        child.
+   * @param event the event to dispatch
    */
-  public Accessible getAccessibleSelection(int index)
+  void dispatchEventImpl(AWTEvent event)
   {
-    return null;
+    // Do local processing.
+    processEvent(event);
   }
 
   /**
-   * Returns a count of the number of <code>Accessible</code>
-   * children of this component which are currently selected.
-   * If there are no children currently selected, 0 is returned.
-   * <br />
-   * <br />
-   * As the existence of children can not be determined from
-   * this abstract class, the implementation of this method
-   * is left to subclasses.
-   *
-   * @return 0.
+   * Processes the specified event.  In this class, this method simply
+   * calls one of the more specific event handlers.
+   * 
+   * @param event the event to process
    */
-  public int getAccessibleSelectionCount()
+  protected void processEvent(AWTEvent event)
   {
-    return 0;
+    // Pass a focus event to the focus listener for
+    // the accessibility context.
+    if (event instanceof FocusEvent)
+      {
+        if (focusListener != null)
+          {
+            switch (event.id)
+            {
+            case FocusEvent.FOCUS_GAINED:
+              focusListener.focusGained((FocusEvent) event);
+              break;
+            case FocusEvent.FOCUS_LOST:
+              focusListener.focusLost((FocusEvent) event);
+              break;
+            }
+          }
+      }
   }
 
   /**
-   * Retrieves the current state of this component
-   * in an accessible form.  For example, a given component
-   * may be visible, selected, disabled, etc.
-   * <br />
-   * <br />
-   * As this class tells us virtually nothing about the component,
-   * except for its name and font, no state information can be
-   * provided.  This implementation thus returns an empty
-   * state set, and it is left to concrete subclasses to provide
-   * a more acceptable and relevant state set.  Changes to these
-   * properties also need to be handled using
-   * <code>PropertyChangeListener</code>s.
+   * Returns a string representation of this component.
    *
-   * @return an empty <code>AccessibleStateSet</code>.
+   * @return a string representation of this component
    */
-  public AccessibleStateSet getAccessibleStateSet()
+  public String toString()
   {
-    return new AccessibleStateSet();
+    return getClass().getName() + "[" + paramString() + "]";
   }
 
   /**
-   * Returns the background color of the component, or null
-   * if this property is unsupported.
-   * <br />
-   * <br />
-   * This abstract class knows nothing about how the component
-   * is drawn on screen, so this method simply returns the
-   * default system background color used for rendering menus.
-   * Concrete subclasses which handle the drawing of an onscreen
-   * menu component should override this method and provide
-   * the appropriate information.
-   *
-   * @return the default system background color for menus.
-   * @see #setBackground(java.awt.Color)
+   * Returns a debugging string for this component
    */
-  public Color getBackground()
+  protected String paramString()
   {
-    return SystemColor.menu;
+    return "name=" + getName();
   }
 
   /**
-   * Returns a <code>Rectangle</code> which represents the
-   * bounds of this component.  The returned rectangle has the
-   * height and width of the component's bounds, and is positioned
-   * at a location relative to this component's parent, the
-   * <code>MenuContainer</code>.  null is returned if bounds
-   * are not supported by the component.
-   * <br />
-   * <br />
-   * This abstract class knows nothing about how the component
-   * is drawn on screen, so this method simply returns null.
-   * Concrete subclasses which handle the drawing of an onscreen
-   * menu component should override this method and provide
-   * the appropriate information.
+   * Gets the AccessibleContext associated with this <code>MenuComponent</code>.
+   * As an abstract class, we return null.  Concrete subclasses should return
+   * their implementation of the accessibility context.
    *
-   * @return null.
-   * @see #setBounds(java.awt.Rectangle)
+   * @return null
    */
-  public Rectangle getBounds()
+  public AccessibleContext getAccessibleContext()
   {
     return null;
   }
 
   /**
-   * Returns the <code>Cursor</code> displayed when the pointer
-   * is positioned over this component.  Alternatively, null
-   * is returned if the component doesn't support the cursor
-   * property.
-   * <br />
-   * <br />
-   * This abstract class knows nothing about how the component
-   * is drawn on screen, so this method simply returns the default
-   * system cursor.  Concrete subclasses which handle the drawing
-   * of an onscreen menu component may override this method and provide
-   * the appropriate information.
+   * This class provides a base for the accessibility support of menu
+   * components.
    *
-   * @return the default system cursor.
-   * @see #setCursor(java.awt.Cursor)
+   * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
    */
-  public Cursor getCursor()
+  protected abstract class AccessibleAWTMenuComponent
+    extends AccessibleContext
+    implements Serializable, AccessibleComponent, AccessibleSelection
   {
-    return Cursor.getDefaultCursor();
-  }
 
-  /**
-   * Returns the <code>Font</code> used for text created by this component.
-   *
-   * @return the current font.
-   * @see #setFont(java.awt.Font)
-   */
-  public Font getFont()
-  {
-    return MenuComponent.this.getFont();
-  }
+    /**
+     * Compatible with JDK 1.4.2 revision 5
+     */
+    private static final long serialVersionUID = -4269533416223798698L;
 
-  /**
-   * Retrieves information on the rendering and metrics of the supplied
-   * font.  If font metrics are not supported by this component, null
-   * is returned.
-   * <br />
-   * <br />
-   * The abstract implementation of this method simply uses the toolkit
-   * to obtain the <code>FontMetrics</code>.  Concrete subclasses may
-   * find it more efficient to invoke their peer class directly, if one
-   * is available.
-   *
-   * @param font the font about which to retrieve rendering and metric
-   *        information.
-   * @return the metrics of the given font, as provided by the system
-   *         toolkit.
-   * @throws NullPointerException if the supplied font was null.
-   */
-  public FontMetrics getFontMetrics(Font font)
-  {
-    return MenuComponent.this.getToolkit().getFontMetrics(font);
-  }
+    /**
+     * This is the default constructor.  It should be called by
+     * concrete subclasses to ensure necessary groundwork is completed.
+     */
+    protected AccessibleAWTMenuComponent()
+    {
+      // Nothing to do here.
+    }
 
-  /**
-   * Returns the foreground color of the component, or null
-   * if this property is unsupported.
-   * <br />
-   * <br />
-   * This abstract class knows nothing about how the component
-   * is drawn on screen, so this method simply returns the
-   * default system text color used for rendering menus.
-   * Concrete subclasses which handle the drawing of an onscreen
-   * menu component should override this method and provide
-   * the appropriate information.
-   *
-   * @return the default system text color for menus.
-   * @see #setForeground(java.awt.Color)
-   */
-  public Color getForeground()
-  {
-    return SystemColor.menuText;
-  }
+    /**
+     * Replaces or supplements the component's selection with the
+     * <code>Accessible</code> child at the supplied index.  If
+     * the component supports multiple selection, the child is
+     * added to the current selection.  Otherwise, the current
+     * selection becomes the specified child.  If the child is
+     * already selected, nothing happens.
+     * <br />
+     * <br />
+     * As the existence of children can not be determined from
+     * this abstract class, the implementation of this method
+     * is left to subclasses.
+     *
+     * @param index the index of the specified child within a
+     *        zero-based list of the component's children
+     */
+    public void addAccessibleSelection(int index)
+    {
+      // Subclasses with children should implement this.
+    }
 
-  /**
-   * Returns the locale currently in use by this component.
-   * <br />
-   * <br />
-   * This abstract class has no property relating to the
-   * locale used by the component, so this method simply
-   * returns the default locale for the current instance
-   * of the Java Virtual Machine (JVM).  Concrete subclasses
-   * which maintain such a property should override this method
-   * and provide the locale information more accurately.
-   *
-   * @return the default locale for this JVM instance.
-   */
-  public Locale getLocale()
-  {
-    return Locale.getDefault();
-  }
+    /**
+     * Registers the specified focus listener to receive
+     * focus events from this component.
+     *
+     * @param listener the new focus listener
+     */
+    public void addFocusListener(FocusListener listener)
+    {
+       // Chain the new focus listener to the existing chain
+       // of focus listeners.  Each new focus listener is
+       // coupled via multicasting to the existing chain.
+      focusListener = AWTEventMulticaster.add(focusListener, listener);
+    }
 
-  /**
-   * Returns the location of the component, with co-ordinates
-   * relative to the parent component and using the co-ordinate
-   * space of the screen.  Thus, the point (0,0) is the upper
-   * left corner of the parent component.
-   * <br />
-   * <br />
-   * Please note that this method depends on a correctly implemented
-   * version of the <code>getBounds()</code> method.  Subclasses
-   * must provide the bounding rectangle via <code>getBounds()</code>
-   * in order for this method to work.  
-   *
-   * @return the location of the component, relative to its parent.
-   * @see #setLocation(java.awt.Point)
-   */
-  public Point getLocation()
-  {
-    /* Simply return the location of the bounding rectangle */
-    return getBounds().getLocation();
-  }
+    /**
+     * Clears the component's current selection.  Following
+     * the calling of this method, no children of the component
+     * will be selected.
+     * <br />
+     * <br />
+     * As the existence of children can not be determined from
+     * this abstract class, the implementation of this method
+     * is left to subclasses.
+     */
+    public void clearAccessibleSelection()
+    {
+      // Nothing to do here.
+    }
 
-  /**
-   * Returns the location of the component, with co-ordinates
-   * relative to the screen.  Thus, the point (0,0) is the upper
-   * left corner of the screen.  null is returned if the component
-   * is either not on screen or if this property is unsupported.
-   * <br />
-   * <br />
-   * This abstract class knows nothing about how the component
-   * is drawn on screen, so this method simply returns null.
-   * Concrete subclasses which handle the drawing of an onscreen
-   * menu component should override this method and provide
-   * the appropriate information.
-   *
-   * @return the location of the component, relative to the screen.
-   */
-  public Point getLocationOnScreen()
-  {
-    return null;
-  }
+    /**
+     * Returns true if the specified point lies within the
+     * component.  The supplied co-ordinates are assumed to
+     * be relative to the co-ordinate system of the component
+     * itself.  Thus, the point (0,0) is the upper left corner
+     * of this component.
+     * <br />
+     * <br />
+     * Please note that this method depends on a correctly implemented
+     * version of the <code>getBounds()</code> method.  Subclasses
+     * must provide the bounding rectangle via <code>getBounds()</code>
+     * in order for this method to work.  
+     *
+     * @param point the point to check against this component
+     * @return true if the point is within this component
+     * @see #getBounds()
+     */
+    public boolean contains(Point point)
+    {
+      // We can simply return the result of a
+      // test for containment in the bounding rectangle.
+      return getBounds().contains(point);
+    }
 
-  /**
-   * Returns the size of the component.
-   * <br />
-   * <br />
-   * Please note that this method depends on a correctly implemented
-   * version of the <code>getBounds()</code> method.  Subclasses
-   * must provide the bounding rectangle via <code>getBounds()</code>
-   * in order for this method to work.  
-   *
-   * @return the size of the component.
-   * @see #setSize(java.awt.Dimension)
-   */
-  public Dimension getSize()
-  {
-    /* Simply return the size of the bounding rectangle */
-    return getBounds().getSize();
-  }
+    /**
+     * Returns the <code>Accessible</code> child of this component present
+     * at the specified point.  The supplied co-ordinates are
+     * assumed to be relative to the co-ordinate system of this
+     * component (the parent of any returned accessible).  Thus,
+     * the point (0,0) is the upper left corner of this menu
+     * component.
+     * <br />
+     * <br />
+     * As the existence of children can not be determined from
+     * this abstract class, the implementation of this method
+     * is left to subclasses.
+     * 
+     * @param point the point at which the returned accessible
+     *        is located
+     * @return null
+     */
+    public Accessible getAccessibleAt(Point point)
+    {
+      return null;
+    }
 
-  /**
-   * Returns true if the accessible child specified by the supplied index
-   * is currently selected.
-   * <br />
-   * <br />
-   * As the existence of children can not be determined from
-   * this abstract class, the implementation of this method
-   * is left to subclasses.
-   *
-   * @param index the index of the accessible child to check for selection.
-   * @return false.
-   */
-  public boolean isAccessibleChildSelected(int index)
-  {
-    return false;
-  }
+    /**
+     * Returns the <code>Accessible</code> child at the supplied
+     * index within the list of children of this component.
+     * <br />
+     * <br />
+     * As the existence of children can not be determined from
+     * this abstract class, the implementation of this method
+     * is left to subclasses.
+     *
+     * @param index the index of the <code>Accessible</code> child
+     *        to retrieve
+     *
+     * @return null
+     */
+    public Accessible getAccessibleChild(int index)
+    {
+      return null;
+    }
 
-  /**
-   * Returns true if this component is currently enabled.
-   * <br />
-   * <br />
-   * As this abstract component has no properties related to
-   * its enabled or disabled state, the implementation of this
-   * method is left to subclasses.
-   *
-   * @return false.
-   * @see #setEnabled(boolean)
-   */
-  public boolean isEnabled()
-  {
-    return false;
-  }
+    /**
+     * Returns the number of children of this component which
+     * implement the <code>Accessible</code> interface.  If
+     * all children of this component are accessible, then
+     * the returned value will be the same as the number of
+     * children.
+     * <br />
+     * <br />
+     *
+     * @return 0
+     */
+    public int getAccessibleChildrenCount()
+    {
+      return 0;
+    }
 
-  /**
-   * Returns true if this component is included in the traversal
-   * of the current focus from one component to the other.
-   * <br />
-   * <br />
-   * As this abstract component has no properties related to
-   * its ability to accept the focus, the implementation of this
-   * method is left to subclasses.
-   *
-   * @return false.
-   */
-  public boolean isFocusTraversable()
-  {
-    return false;
-  }
+    /**
+     * Retrieves the <code>AccessibleComponent</code> associated
+     * with this accessible context and its component.  As the
+     * context itself implements <code>AccessibleComponent</code>,
+     * this is the return value.
+     *
+     * @return the context itself
+     */
+    public AccessibleComponent getAccessibleComponent()
+    {
+      return this;
+    }
 
-  /**
-   * Returns true if the component is being shown on screen.
-   * A component is determined to be shown if it is visible,
-   * and each parent component is also visible.  Please note
-   * that, even when a component is showing, it may still be
-   * obscured by other components in front.  This method only
-   * determines if the component is being drawn on the screen.
-   * <br />
-   * <br />
-   * As this abstract component and its parent have no properties
-   * relating to visibility, the implementation of this method is
-   * left to subclasses.
-   *
-   * @return false.
-   * @see #isVisible()
-   */
-  public boolean isShowing()
-  {
-    return false;
-  }
+    /**
+     * Returns the accessible name for this menu component.  This
+     * is the name given to the component, which may be null if
+     * not set using <code>setName()</code>.
+     * <br />
+     * <br />
+     * The name is not the most appropriate description of this
+     * object.  Subclasses should preferably provide a more
+     * accurate description.  For example, a File menu could
+     * have the description `Lists commands related to the
+     * file system'.
+     *
+     * @return a description of the component.  Currently,
+     *         this is just the contents of the name property
+     *
+     * @see MenuComponent#setName(String)
+     */
+    public String getAccessibleDescription()
+    {
+      return MenuComponent.this.getName();
+    }
 
-  /**
-   * Returns true if the component is visible.  A component may
-   * be visible but not drawn on the screen if one of its parent
-   * components is not visible.  To determine if the component is
-   * actually drawn on screen, <code>isShowing()</code> should be
-   * used.
-   * <br />
-   * <br />
-   * As this abstract component has no properties relating to its
-   * visibility, the implementation of this method is left to subclasses.
-   *
-   * @return false.
-   * @see #isShowing()
-   * @see #setVisible(boolean)
-   */
-  public boolean isVisible()
-  {
-    return false;
-  }
+    /**
+     * Retrieves the index of this component within its parent.
+     * If no parent exists, -1 is returned.
+     *
+     * @return -1 as the parent, a <code>MenuContainer</code>
+     *         is not <code>Accessible</code>
+     */
+    public int getAccessibleIndexInParent()
+    {
+      return -1;
+    }
 
-  /**
-   * Removes the accessible child specified by the supplied index from
-   * the list of currently selected children.  If the child specified
-   * is not selected, nothing happens.
-   * <br />
-   * <br />
-   * As the existence of children can not be determined from
-   * this abstract class, the implementation of this method
-   * is left to subclasses.
-   *
-   * @param index the index of the <code>Accessible</code> child.
-   */
-  public void removeAccessibleSelection(int index)
-  {
-    /* Subclasses with children should implement this */
-  }
+    /**
+     * Returns the accessible name of this component.  This
+     * is the name given to the component, which may be null if
+     * not set using <code>setName()</code>.
+     * <br />
+     * <br />
+     * The name property is not the most suitable string to return
+     * for this method.  The string should be localized, and
+     * relevant to the operation of the component.  For example,
+     * it could be the text of a menu item.  However, this can
+     * not be used at this level of abstraction, so it is the
+     * responsibility of subclasses to provide a more appropriate
+     * name.
+     *
+     * @return a localized name for this component.  Currently, this
+     *         is just the contents of the name property
+     *
+     * @see MenuComponent#setName(String)
+     */
+    public String getAccessibleName()
+    {
+      return MenuComponent.this.getName();
+    }
 
-  /**
-   * Removes the specified focus listener from the list of registered
-   * focus listeners for this component.
-   *
-   * @param listener the listener to remove.
-   */
-  public void removeFocusListener(FocusListener listener)
-  {
-    /* Remove the focus listener from the chain */
-    focusListener = AWTEventMulticaster.remove(focusListener, listener);
-  }
+    /**
+     * Returns the <code>Accessible</code> parent of this component.
+     * As the parent of a <code>MenuComponent</code> is a
+     * <code>MenuContainer</code>, which doesn't implement
+     * <code>Accessible</code>, this method returns null.
+     *
+     * @return null
+     */
+    public Accessible getAccessibleParent()
+    {
+      return null;
+    }
 
-  /**
-   * Requests that this component gains focus.  This depends on the
-   * component being focus traversable.
-   * <br />
-   * <br />
-   * As this abstract component has no properties relating to its
-   * focus traversability, or access to a peer with request focusing
-   * abilities, the implementation of this method is left to subclasses.
-   */
-  public void requestFocus()
-  {
-    /* Ignored */
-  }
+    /**
+     * Returns the accessible role of this component.
+     * <br />
+     * <br />
+     * The abstract implementation of this method returns
+     * <code>AccessibleRole.AWT_COMPONENT</code>,
+     * as the abstract component has no specific role.  This
+     * method should be overridden by concrete subclasses, so
+     * as to return an appropriate role for the component.
+     *
+     * @return <code>AccessibleRole.AWT_COMPONENT</code>
+     */
+    public AccessibleRole getAccessibleRole()
+    {
+      return AccessibleRole.AWT_COMPONENT;
+    }
 
-  /**
-   * Selects all <code>Accessible</code> children of this component which
-   * it is possible to select.  The component needs to support multiple
-   * selections.
-   * <br />
-   * <br />
-   * This abstract component provides a simplistic implementation of this
-   * method, which ignores the ability of the component to support multiple
-   * selections and simply uses <code>addAccessibleSelection</code> to
-   * add each <code>Accessible</code> child to the selection.  The last
-   * <code>Accessible</code> component is thus selected for components
-   * which don't support multiple selections.  Concrete implementations should
-   * override this with a more appopriate and efficient implementation, which
-   * properly takes into account the ability of the component to support multiple
-   * selections. 
-   */
-  public void selectAllAccessibleSelection()
-  {
-    /* Simply call addAccessibleSelection() on all accessible children */
-    for (int a = 0; a < getAccessibleChildrenCount(); ++a)
-      {
-        addAccessibleSelection(a);
-      }
-  }
+    /**
+     * Retrieves the <code>AccessibleSelection</code> associated
+     * with this accessible context and its component.  As the
+     * context itself implements <code>AccessibleSelection</code>,
+     * this is the return value.
+     *
+     * @return the context itself
+     */
+    public AccessibleSelection getAccessibleSelection()
+    {
+      return this;
+    }
 
-  /**
-   * Sets the background color of the component to that specified.
-   * Unspecified behaviour occurs when null is given as the new
-   * background color.
-   * <br />
-   * <br />
-   * This abstract class knows nothing about how the component
-   * is drawn on screen, so this method simply ignores the supplied
-   * color and continues to use the default system color.   
-   * Concrete subclasses which handle the drawing of an onscreen
-   * menu component should override this method and provide
-   * the appropriate information.
-   *
-   * @param color the new color to use for the background.
-   * @see #getBackground()
-   */
-  public void setBackground(Color color)
-  {
-    /* Ignored */
-  }
+    /**
+     * Retrieves the <code>Accessible</code> selected child
+     * at the specified index.  If there are no selected children
+     * or the index is outside the range of selected children,
+     * null is returned.  Please note that the index refers
+     * to the index of the child in the list of <strong>selected
+     * children</strong>, and not the index of the child in
+     * the list of all <code>Accessible</code> children.
+     * <br />
+     * <br />
+     * As the existence of children can not be determined from
+     * this abstract class, the implementation of this method
+     * is left to subclasses.
+     *
+     * @param index the index of the selected <code>Accessible</code>
+     *        child
+     */
+    public Accessible getAccessibleSelection(int index)
+    {
+      return null;
+    }
 
-  /**
-   * Sets the height and width of the component, and its position
-   * relative to this component's parent, to the values specified
-   * by the supplied rectangle.  Unspecified behaviour occurs when
-   * null is given as the new bounds.
-   * <br />
-   * <br />
-   * This abstract class knows nothing about how the component
-   * is drawn on screen, so this method simply ignores the new
-   * rectangle and continues to return null from <code>getBounds()</code>.
-   * Concrete subclasses which handle the drawing of an onscreen
-   * menu component should override this method and provide
-   * the appropriate information.
-   *
-   * @param rectangle a rectangle which specifies the new bounds of
-   *        the component.
-   * @see #getBounds()
-   */
-  public void setBounds(Rectangle rectangle)
-  {
-    /* Ignored */
-  }
+    /**
+     * Returns a count of the number of <code>Accessible</code>
+     * children of this component which are currently selected.
+     * If there are no children currently selected, 0 is returned.
+     * <br />
+     * <br />
+     * As the existence of children can not be determined from
+     * this abstract class, the implementation of this method
+     * is left to subclasses.
+     *
+     * @return 0
+     */
+    public int getAccessibleSelectionCount()
+    {
+      return 0;
+    }
 
-  /**
-   * Sets the <code>Cursor</code> used when the pointer is positioned over the
-   * component.  Unspecified behaviour occurs when null is given as the new
-   * cursor.
-   * <br />
-   * <br />
-   * This abstract class knows nothing about how the component
-   * is drawn on screen, so this method simply ignores the new cursor
-   * and continues to return the default system cursor.  Concrete
-   * subclasses which handle the drawing of an onscreen menu component
-   * may override this method and provide the appropriate information.
-   *
-   * @param cursor the new cursor to use.
-   * @see #getCursor()
-   */
-  public void setCursor(Cursor cursor)
-  {
-    /* Ignored */
-  }
+    /**
+     * Retrieves the current state of this component
+     * in an accessible form.  For example, a given component
+     * may be visible, selected, disabled, etc.
+     * <br />
+     * <br />
+     * As this class tells us virtually nothing about the component,
+     * except for its name and font, no state information can be
+     * provided.  This implementation thus returns an empty
+     * state set, and it is left to concrete subclasses to provide
+     * a more acceptable and relevant state set.  Changes to these
+     * properties also need to be handled using
+     * <code>PropertyChangeListener</code>s.
+     *
+     * @return an empty <code>AccessibleStateSet</code>
+     */
+    public AccessibleStateSet getAccessibleStateSet()
+    {
+      return new AccessibleStateSet();
+    }
 
-  /**
-   * Sets the enabled/disabled state of this component.
-   * <br />
-   * <br />
-   * As this abstract component has no properties related to
-   * its enabled or disabled state, the implementation of this
-   * method is left to subclasses.
-   *
-   * @param enabled true if the component should be enabled,
-   *        false otherwise.
-   * @see #isEnabled()
-   */
-  public void setEnabled(boolean enabled)
-  {
-    /* Ignored */
-  }
+    /**
+     * Returns the background color of the component, or null
+     * if this property is unsupported.
+     * <br />
+     * <br />
+     * This abstract class knows nothing about how the component
+     * is drawn on screen, so this method simply returns the
+     * default system background color used for rendering menus.
+     * Concrete subclasses which handle the drawing of an onscreen
+     * menu component should override this method and provide
+     * the appropriate information.
+     *
+     * @return the default system background color for menus
+     *
+     * @see #setBackground(java.awt.Color)
+     */
+    public Color getBackground()
+    {
+      return SystemColor.menu;
+    }
 
-  /**
-   * Sets the <code>Font</code> used for text created by this component.
-   * Unspecified behaviour occurs when null is given as the new
-   * font.
-   *
-   * @param font the new font to use for text.
-   * @see #getFont()
-   */
-  public void setFont(Font font)
-  {
-    /* Call the method of the enclosing component */
-    MenuComponent.this.setFont(font);
-  }
+    /**
+     * Returns a <code>Rectangle</code> which represents the
+     * bounds of this component.  The returned rectangle has the
+     * height and width of the component's bounds, and is positioned
+     * at a location relative to this component's parent, the
+     * <code>MenuContainer</code>.  null is returned if bounds
+     * are not supported by the component.
+     * <br />
+     * <br />
+     * This abstract class knows nothing about how the component
+     * is drawn on screen, so this method simply returns null.
+     * Concrete subclasses which handle the drawing of an onscreen
+     * menu component should override this method and provide
+     * the appropriate information.
+     *
+     * @return null
+     *
+     * @see #setBounds(java.awt.Rectangle)
+     */
+    public Rectangle getBounds()
+    {
+      return null;
+    }
 
-  /**
-   * Sets the foreground color of the component to that specified.
-   * Unspecified behaviour occurs when null is given as the new
-   * background color.
-   * <br />
-   * <br />
-   * This abstract class knows nothing about how the component
-   * is drawn on screen, so this method simply ignores the supplied
-   * color and continues to return the default system text color used
-   * for rendering menus.
-   * Concrete subclasses which handle the drawing of an onscreen
-   * menu component should override this method and provide
-   * the appropriate information.
-   *
-   * @param color the new foreground color.
-   * @see #getForeground()
-   */
-  public void setForeground(Color color)
-  {
-    /* Ignored */
-  }
+    /**
+     * Returns the <code>Cursor</code> displayed when the pointer
+     * is positioned over this component.  Alternatively, null
+     * is returned if the component doesn't support the cursor
+     * property.
+     * <br />
+     * <br />
+     * This abstract class knows nothing about how the component
+     * is drawn on screen, so this method simply returns the default
+     * system cursor.  Concrete subclasses which handle the drawing
+     * of an onscreen menu component may override this method and provide
+     * the appropriate information.
+     *
+     * @return the default system cursor
+     *
+     * @see #setCursor(java.awt.Cursor)
+     */
+    public Cursor getCursor()
+    {
+      return Cursor.getDefaultCursor();
+    }
 
-  /**
-   * Sets the location of the component, with co-ordinates
-   * relative to the parent component and using the co-ordinate
-   * space of the screen.  Thus, the point (0,0) is the upper
-   * left corner of the parent component.
-   * <br />
-   * <br />
-   * Please note that this method depends on a correctly implemented
-   * version of the <code>getBounds()</code> method.  Subclasses
-   * must provide the bounding rectangle via <code>getBounds()</code>
-   * in order for this method to work.  
-   *
-   * @param point the location of the component, relative to its parent.
-   * @see #getLocation()
-   */
-  public void setLocation(Point point)
-  {
-    getBounds().setLocation(point);
-  }
+    /**
+     * Returns the <code>Font</code> used for text created by this component.
+     *
+     * @return the current font
+     *
+     * @see #setFont(java.awt.Font)
+     */
+    public Font getFont()
+    {
+      return MenuComponent.this.getFont();
+    }
 
-  /**
-   * Sets the size of the component.
-   * <br />
-   * <br />
-   * Please note that this method depends on a correctly implemented
-   * version of the <code>getBounds()</code> method.  Subclasses
-   * must provide the bounding rectangle via <code>getBounds()</code>
-   * in order for this method to work.  
-   *
-   * @param size the new size of the component.
-   * @see #getSize()
-   */
-  public void setSize(Dimension size)
-  {
-    getBounds().setSize(size);
-  }
+    /**
+     * Retrieves information on the rendering and metrics of the supplied
+     * font.  If font metrics are not supported by this component, null
+     * is returned.
+     * <br />
+     * <br />
+     * The abstract implementation of this method simply uses the toolkit
+     * to obtain the <code>FontMetrics</code>.  Concrete subclasses may
+     * find it more efficient to invoke their peer class directly, if one
+     * is available.
+     *
+     * @param font the font about which to retrieve rendering and metric
+     *        information
+     *
+     * @return the metrics of the given font, as provided by the system
+     *         toolkit
+     *
+     * @throws NullPointerException if the supplied font was null
+     */
+    public FontMetrics getFontMetrics(Font font)
+    {
+      return MenuComponent.this.getToolkit().getFontMetrics(font);
+    }
 
-  /**
-   * Sets the visibility state of the component.  A component may
-   * be visible but not drawn on the screen if one of its parent
-   * components is not visible.  To determine if the component is
-   * actually drawn on screen, <code>isShowing()</code> should be
-   * used.
-   * <br />
-   * <br />
-   * As this abstract component has no properties relating to its
-   * visibility, the implementation of this method is left to subclasses.
-   *
-   * @param visibility the new visibility of the component -- true if
-   *        the component is visible, false if not.
-   * @see #isShowing()
-   * @see #isVisible()
-   */
-  public void setVisible(boolean visibility)
-  {
-    /* Ignored */
-  }
+    /**
+     * Returns the foreground color of the component, or null
+     * if this property is unsupported.
+     * <br />
+     * <br />
+     * This abstract class knows nothing about how the component
+     * is drawn on screen, so this method simply returns the
+     * default system text color used for rendering menus.
+     * Concrete subclasses which handle the drawing of an onscreen
+     * menu component should override this method and provide
+     * the appropriate information.
+     *
+     * @return the default system text color for menus
+     *
+     * @see #setForeground(java.awt.Color)
+     */
+    public Color getForeground()
+    {
+      return SystemColor.menuText;
+    }
 
-} /* class AccessibleAWTMenuComponent */
-          
+    /**
+     * Returns the locale currently in use by this component.
+     * <br />
+     * <br />
+     * This abstract class has no property relating to the
+     * locale used by the component, so this method simply
+     * returns the default locale for the current instance
+     * of the Java Virtual Machine (JVM).  Concrete subclasses
+     * which maintain such a property should override this method
+     * and provide the locale information more accurately.
+     *
+     * @return the default locale for this JVM instance
+     */
+    public Locale getLocale()
+    {
+      return Locale.getDefault();
+    }
+
+    /**
+     * Returns the location of the component, with co-ordinates
+     * relative to the parent component and using the co-ordinate
+     * space of the screen.  Thus, the point (0,0) is the upper
+     * left corner of the parent component.
+     * <br />
+     * <br />
+     * Please note that this method depends on a correctly implemented
+     * version of the <code>getBounds()</code> method.  Subclasses
+     * must provide the bounding rectangle via <code>getBounds()</code>
+     * in order for this method to work.  
+     *
+     * @return the location of the component, relative to its parent
+     *
+     * @see #setLocation(java.awt.Point)
+     */
+    public Point getLocation()
+    {
+      // Simply return the location of the bounding rectangle.
+      return getBounds().getLocation();
+    }
+
+    /**
+     * Returns the location of the component, with co-ordinates
+     * relative to the screen.  Thus, the point (0,0) is the upper
+     * left corner of the screen.  null is returned if the component
+     * is either not on screen or if this property is unsupported.
+     * <br />
+     * <br />
+     * This abstract class knows nothing about how the component
+     * is drawn on screen, so this method simply returns null.
+     * Concrete subclasses which handle the drawing of an onscreen
+     * menu component should override this method and provide
+     * the appropriate information.
+     *
+     * @return the location of the component, relative to the screen
+     */
+    public Point getLocationOnScreen()
+    {
+      return null;
+    }
+
+    /**
+     * Returns the size of the component.
+     * <br />
+     * <br />
+     * Please note that this method depends on a correctly implemented
+     * version of the <code>getBounds()</code> method.  Subclasses
+     * must provide the bounding rectangle via <code>getBounds()</code>
+     * in order for this method to work.  
+     *
+     * @return the size of the component
+     *
+     * @see #setSize(java.awt.Dimension)
+     */
+    public Dimension getSize()
+    {
+      // Simply return the size of the bounding rectangle.
+      return getBounds().getSize();
+    }
+
+    /**
+     * Returns true if the accessible child specified by the supplied index
+     * is currently selected.
+     * <br />
+     * <br />
+     * As the existence of children can not be determined from
+     * this abstract class, the implementation of this method
+     * is left to subclasses.
+     *
+     * @param index the index of the accessible child to check for selection
+     *
+     * @return false
+     */
+    public boolean isAccessibleChildSelected(int index)
+    {
+      return false;
+    }
+
+    /**
+     * Returns true if this component is currently enabled.
+     * <br />
+     * <br />
+     * As this abstract component has no properties related to
+     * its enabled or disabled state, the implementation of this
+     * method is left to subclasses.
+     *
+     * @return false
+     *
+     * @see #setEnabled(boolean)
+     */
+    public boolean isEnabled()
+    {
+      return false;
+    }
 
-} // class MenuComponent
+    /**
+     * Returns true if this component is included in the traversal
+     * of the current focus from one component to the other.
+     * <br />
+     * <br />
+     * As this abstract component has no properties related to
+     * its ability to accept the focus, the implementation of this
+     * method is left to subclasses.
+     *
+     * @return false
+     */
+    public boolean isFocusTraversable()
+    {
+      return false;
+    }
+
+    /**
+     * Returns true if the component is being shown on screen.
+     * A component is determined to be shown if it is visible,
+     * and each parent component is also visible.  Please note
+     * that, even when a component is showing, it may still be
+     * obscured by other components in front.  This method only
+     * determines if the component is being drawn on the screen.
+     * <br />
+     * <br />
+     * As this abstract component and its parent have no properties
+     * relating to visibility, the implementation of this method is
+     * left to subclasses.
+     *
+     * @return false
+     *
+     * @see #isVisible()
+     */
+    public boolean isShowing()
+    {
+      return false;
+    }
+
+    /**
+     * Returns true if the component is visible.  A component may
+     * be visible but not drawn on the screen if one of its parent
+     * components is not visible.  To determine if the component is
+     * actually drawn on screen, <code>isShowing()</code> should be
+     * used.
+     * <br />
+     * <br />
+     * As this abstract component has no properties relating to its
+     * visibility, the implementation of this method is left to subclasses.
+     *
+     * @return false
+     *
+     * @see #isShowing()
+     * @see #setVisible(boolean)
+     */
+    public boolean isVisible()
+    {
+      return false;
+    }
+
+    /**
+     * Removes the accessible child specified by the supplied index from
+     * the list of currently selected children.  If the child specified
+     * is not selected, nothing happens.
+     * <br />
+     * <br />
+     * As the existence of children can not be determined from
+     * this abstract class, the implementation of this method
+     * is left to subclasses.
+     *
+     * @param index the index of the <code>Accessible</code> child
+     */
+    public void removeAccessibleSelection(int index)
+    {
+      // Subclasses with children should implement this.
+    }
+
+    /**
+     * Removes the specified focus listener from the list of registered
+     * focus listeners for this component.
+     *
+     * @param listener the listener to remove
+     */
+    public void removeFocusListener(FocusListener listener)
+    {
+      // Remove the focus listener from the chain.
+      focusListener = AWTEventMulticaster.remove(focusListener, listener);
+    }
+
+    /**
+     * Requests that this component gains focus.  This depends on the
+     * component being focus traversable.
+     * <br />
+     * <br />
+     * As this abstract component has no properties relating to its
+     * focus traversability, or access to a peer with request focusing
+     * abilities, the implementation of this method is left to subclasses.
+     */
+    public void requestFocus()
+    {
+      // Ignored.
+    }
+
+    /**
+     * Selects all <code>Accessible</code> children of this component which
+     * it is possible to select.  The component needs to support multiple
+     * selections.
+     * <br />
+     * <br />
+     * This abstract component provides a simplistic implementation of this
+     * method, which ignores the ability of the component to support multiple
+     * selections and simply uses <code>addAccessibleSelection</code> to
+     * add each <code>Accessible</code> child to the selection.  The last
+     * <code>Accessible</code> component is thus selected for components
+     * which don't support multiple selections.  Concrete implementations should
+     * override this with a more appopriate and efficient implementation, which
+     * properly takes into account the ability of the component to support multiple
+     * selections. 
+     */
+    public void selectAllAccessibleSelection()
+    {
+      // Simply call addAccessibleSelection() on all accessible children.
+      for (int a = 0; a < getAccessibleChildrenCount(); ++a)
+        {
+          addAccessibleSelection(a);
+        }
+    }
+
+    /**
+     * Sets the background color of the component to that specified.
+     * Unspecified behaviour occurs when null is given as the new
+     * background color.
+     * <br />
+     * <br />
+     * This abstract class knows nothing about how the component
+     * is drawn on screen, so this method simply ignores the supplied
+     * color and continues to use the default system color.   
+     * Concrete subclasses which handle the drawing of an onscreen
+     * menu component should override this method and provide
+     * the appropriate information.
+     *
+     * @param color the new color to use for the background
+     *
+     * @see #getBackground()
+     */
+    public void setBackground(Color color)
+    {
+      // Ignored.
+    }
+
+    /**
+     * Sets the height and width of the component, and its position
+     * relative to this component's parent, to the values specified
+     * by the supplied rectangle.  Unspecified behaviour occurs when
+     * null is given as the new bounds.
+     * <br />
+     * <br />
+     * This abstract class knows nothing about how the component
+     * is drawn on screen, so this method simply ignores the new
+     * rectangle and continues to return null from <code>getBounds()</code>.
+     * Concrete subclasses which handle the drawing of an onscreen
+     * menu component should override this method and provide
+     * the appropriate information.
+     *
+     * @param rectangle a rectangle which specifies the new bounds of
+     *        the component
+     *
+     * @see #getBounds()
+     */
+    public void setBounds(Rectangle rectangle)
+    {
+      // Ignored.
+    }
+
+    /**
+     * Sets the <code>Cursor</code> used when the pointer is positioned over the
+     * component.  Unspecified behaviour occurs when null is given as the new
+     * cursor.
+     * <br />
+     * <br />
+     * This abstract class knows nothing about how the component
+     * is drawn on screen, so this method simply ignores the new cursor
+     * and continues to return the default system cursor.  Concrete
+     * subclasses which handle the drawing of an onscreen menu component
+     * may override this method and provide the appropriate information.
+     *
+     * @param cursor the new cursor to use
+     *
+     * @see #getCursor()
+     */
+    public void setCursor(Cursor cursor)
+    {
+      // Ignored.
+    }
+
+    /**
+     * Sets the enabled/disabled state of this component.
+     * <br />
+     * <br />
+     * As this abstract component has no properties related to
+     * its enabled or disabled state, the implementation of this
+     * method is left to subclasses.
+     *
+     * @param enabled true if the component should be enabled,
+     *        false otherwise
+     *
+     * @see #isEnabled()
+     */
+    public void setEnabled(boolean enabled)
+    {
+      // Ignored.
+    }
+
+    /**
+     * Sets the <code>Font</code> used for text created by this component.
+     * Unspecified behaviour occurs when null is given as the new
+     * font.
+     *
+     * @param font the new font to use for text.
+     * @see #getFont()
+     */
+    public void setFont(Font font)
+    {
+      // Call the method of the enclosing component.
+      MenuComponent.this.setFont(font);
+    }
+
+    /**
+     * Sets the foreground color of the component to that specified.
+     * Unspecified behaviour occurs when null is given as the new
+     * background color.
+     * <br />
+     * <br />
+     * This abstract class knows nothing about how the component
+     * is drawn on screen, so this method simply ignores the supplied
+     * color and continues to return the default system text color used
+     * for rendering menus.
+     * Concrete subclasses which handle the drawing of an onscreen
+     * menu component should override this method and provide
+     * the appropriate information.
+     *
+     * @param color the new foreground color
+     *
+     * @see #getForeground()
+     */
+    public void setForeground(Color color)
+    {
+      // Ignored.
+    }
+
+    /**
+     * Sets the location of the component, with co-ordinates
+     * relative to the parent component and using the co-ordinate
+     * space of the screen.  Thus, the point (0,0) is the upper
+     * left corner of the parent component.
+     * <br />
+     * <br />
+     * Please note that this method depends on a correctly implemented
+     * version of the <code>getBounds()</code> method.  Subclasses
+     * must provide the bounding rectangle via <code>getBounds()</code>
+     * in order for this method to work.  
+     *
+     * @param point the location of the component, relative to its parent
+     *
+     * @see #getLocation()
+     */
+    public void setLocation(Point point)
+    {
+      getBounds().setLocation(point);
+    }
+
+    /**
+     * Sets the size of the component.
+     * <br />
+     * <br />
+     * Please note that this method depends on a correctly implemented
+     * version of the <code>getBounds()</code> method.  Subclasses
+     * must provide the bounding rectangle via <code>getBounds()</code>
+     * in order for this method to work.  
+     *
+     * @param size the new size of the component
+     *
+     * @see #getSize()
+     */
+    public void setSize(Dimension size)
+    {
+      getBounds().setSize(size);
+    }
+
+    /**
+     * Sets the visibility state of the component.  A component may
+     * be visible but not drawn on the screen if one of its parent
+     * components is not visible.  To determine if the component is
+     * actually drawn on screen, <code>isShowing()</code> should be
+     * used.
+     * <br />
+     * <br />
+     * As this abstract component has no properties relating to its
+     * visibility, the implementation of this method is left to subclasses.
+     *
+     * @param visibility the new visibility of the component -- true if
+     *        the component is visible, false if not
+     *
+     * @see #isShowing()
+     * @see #isVisible()
+     */
+    public void setVisible(boolean visibility)
+    {
+      // Ignored.
+    }
+
+  }
+
+}