JMenu.java

/*
 * Copyright (c) 1997, 2023, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation. Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

packagejavax.swing;

importjava.awt.Component;
importjava.awt.ComponentOrientation;
importjava.awt.Container;
importjava.awt.Dimension;
importjava.awt.GraphicsConfiguration;
importjava.awt.GraphicsDevice;
importjava.awt.GraphicsEnvironment;
importjava.awt.Insets;
importjava.awt.Point;
importjava.awt.Rectangle;
importjava.awt.Toolkit;
importjava.awt.event.KeyEvent;
importjava.awt.event.WindowAdapter;
importjava.awt.event.WindowEvent;
importjava.beans.BeanProperty;
importjava.beans.JavaBean;
importjava.beans.PropertyChangeListener;
importjava.io.IOException;
importjava.io.ObjectOutputStream;
importjava.io.Serial;
importjava.io.Serializable;
importjava.util.ArrayList;

importjavax.accessibility.Accessible;
importjavax.accessibility.AccessibleContext;
importjavax.accessibility.AccessibleRole;
importjavax.accessibility.AccessibleSelection;
importjavax.swing.event.ChangeEvent;
importjavax.swing.event.ChangeListener;
importjavax.swing.event.EventListenerList;
importjavax.swing.event.MenuEvent;
importjavax.swing.event.MenuListener;
importjavax.swing.plaf.MenuItemUI;
importjavax.swing.plaf.PopupMenuUI;

/**
 * An implementation of a menu -- a popup window containing
 * <code>JMenuItem</code>s that
 * is displayed when the user selects an item on the <code>JMenuBar</code>.
 * In addition to <code>JMenuItem</code>s, a <code>JMenu</code> can
 * also contain <code>JSeparator</code>s.
 * <p>
 * In essence, a menu is a button with an associated <code>JPopupMenu</code>.
 * When the "button" is pressed, the <code>JPopupMenu</code> appears. If the
 * "button" is on the <code>JMenuBar</code>, the menu is a top-level window.
 * If the "button" is another menu item, then the <code>JPopupMenu</code> is
 * "pull-right" menu.
 * <p>
 * Menus can be configured, and to some degree controlled, by
 * <code><a href="Action.html">Action</a></code>s. Using an
 * <code>Action</code> with a menu has many benefits beyond directly
 * configuring a menu. Refer to <a href="Action.html#buttonActions">
 * Swing Components Supporting <code>Action</code></a> for more
 * details, and you can find more information in <a
 * href="https://docs.oracle.com/javase/tutorial/uiswing/misc/action.html">How
 * to Use Actions</a>, a section in <em>The Java Tutorial</em>.
 * <p>
 * For information and examples of using menus see
 * <a href="https://docs.oracle.com/javase/tutorial/uiswing/components/menu.html">How to Use Menus</a>,
 * a section in <em>The Java Tutorial.</em>
 * <p>
 * <strong>Warning:</strong> Swing is not thread safe. For more
 * information see <a
 * href="package-summary.html#threading">Swing's Threading
 * Policy</a>.
 * <p>
 * <strong>Warning:</strong>
 * Serialized objects of this class will not be compatible with
 * future Swing releases. The current serialization support is
 * appropriate for short term storage or RMI between applications running
 * the same version of Swing. As of 1.4, support for long term storage
 * of all JavaBeans
 * has been added to the <code>java.beans</code> package.
 * Please see {@link java.beans.XMLEncoder}.
 *
 * @author Georges Saab
 * @author David Karlton
 * @author Arnaud Weber
 * @see JMenuItem
 * @see JSeparator
 * @see JMenuBar
 * @see JPopupMenu
 * @since 1.2
 */
@JavaBean(description = "A popup window containing menu items displayed in a menu bar.")
@SwingContainer
@SuppressWarnings("serial")
publicclassJMenuextendsJMenuItemimplementsAccessible,MenuElement
{
/**
 * @see #getUIClassID
 * @see #readObject
 */
privatestaticfinalStringuiClassID = "MenuUI";

/*
 * The popup menu portion of the menu.
 */
privateJPopupMenupopupMenu;

/*
 * The button's model listeners. Default is <code>null</code>.
 */
privateChangeListenermenuChangeListener = null;

/*
 * Only one <code>MenuEvent</code> is needed for each menu since the
 * event's only state is the source property. The source of events
 * generated is always "this". Default is <code>null</code>.
 */
privateMenuEventmenuEvent = null;

/*
 * Used by the look and feel (L&F) code to handle
 * implementation specific menu behaviors.
 */
privateintdelay;

/*
 * Location of the popup component. Location is <code>null</code>
 * if it was not customized by <code>setMenuLocation</code>
 */
privatePointcustomMenuLocation = null;

/* Diagnostic aids -- should be false for production builds. */
privatestaticfinalbooleanTRACE = false; // trace creates and disposes
privatestaticfinalbooleanVERBOSE = false; // show reuse hits/misses
privatestaticfinalbooleanDEBUG = false; // show bad params, misc.

/**
 * Constructs a new <code>JMenu</code> with no text.
 */
publicJMenu() {
this("");
 }

/**
 * Constructs a new <code>JMenu</code> with the supplied string
 * as its text.
 *
 * @param s the text for the menu label
 */
publicJMenu(Strings) {
super(s);
 }

/**
 * Constructs a menu whose properties are taken from the
 * <code>Action</code> supplied.
 * @param a an <code>Action</code>
 *
 * @since 1.3
 */
publicJMenu(Actiona) {
this();
setAction(a);
 }

/**
 * Constructs a new <code>JMenu</code> with the supplied string as
 * its text and specified as a tear-off menu or not.
 *
 * @param s the text for the menu label
 * @param b can the menu be torn off (not yet implemented)
 */
publicJMenu(Strings, booleanb) {
this(s);
 }


/**
 * Overridden to do nothing. We want JMenu to be focusable, but
 * <code>JMenuItem</code> doesn't want to be, thus we override this
 * to do nothing. We don't invoke <code>setFocusable(true)</code> after
 * super's constructor has completed as this has the side effect that
 * <code>JMenu</code> will be considered traversable via the
 * keyboard, which we don't want. Making a Component traversable by
 * the keyboard after invoking <code>setFocusable(true)</code> is OK,
 * as <code>setFocusable</code> is new API
 * and is speced as such, but internally we don't want to use it like
 * this else we change the keyboard traversability.
 */
voidinitFocusability() {
 }

/**
 * Resets the UI property with a value from the current look and feel.
 *
 * @see JComponent#updateUI
 */
publicvoidupdateUI() {
setUI((MenuItemUI)UIManager.getUI(this));

if ( popupMenu != null )
 {
popupMenu.setUI((PopupMenuUI)UIManager.getUI(popupMenu));
 }

 }


/**
 * Returns the name of the L&amp;F class that renders this component.
 *
 * @return the string "MenuUI"
 * @see JComponent#getUIClassID
 * @see UIDefaults#getUI
 */
@BeanProperty(bound = false)
publicStringgetUIClassID() {
returnuiClassID;
 }

// public void repaint(long tm, int x, int y, int width, int height) {
// Thread.currentThread().dumpStack();
// super.repaint(tm,x,y,width,height);
// }

/**
 * Sets the data model for the "menu button" -- the label
 * that the user clicks to open or close the menu.
 *
 * @param newModel the <code>ButtonModel</code>
 * @see #getModel
 */
publicvoidsetModel(ButtonModelnewModel) {
ButtonModeloldModel = getModel();

super.setModel(newModel);

if (oldModel != null && menuChangeListener != null) {
oldModel.removeChangeListener(menuChangeListener);
menuChangeListener = null;
 }

model = newModel;

if (newModel != null) {
menuChangeListener = createMenuChangeListener();
newModel.addChangeListener(menuChangeListener);
 }
 }

/**
 * Returns true if the menu is currently selected (highlighted).
 *
 * @return true if the menu is selected, else false
 */
publicbooleanisSelected() {
returngetModel().isSelected();
 }

/**
 * Sets the selection status of the menu.
 *
 * @param b true to select (highlight) the menu; false to de-select
 * the menu
 */
@BeanProperty(expert = true, hidden = true, description
 = "When the menu is selected, its popup child is shown.")
publicvoidsetSelected(booleanb) {
ButtonModelmodel = getModel();
booleanoldValue = model.isSelected();

// TIGER - 4840653
// Removed code which fired an AccessibleState.SELECTED
// PropertyChangeEvent since this resulted in two
// identical events being fired since
// AbstractButton.fireItemStateChanged also fires the
// same event. This caused screen readers to speak the
// name of the item twice.

if (b != model.isSelected()) {
getModel().setSelected(b);
 }
 }

/**
 * Returns true if the menu's popup window is visible.
 *
 * @return true if the menu is visible, else false
 */
publicbooleanisPopupMenuVisible() {
ensurePopupMenuCreated();
returnpopupMenu.isVisible();
 }

/**
 * Sets the visibility of the menu's popup. If the menu is
 * not enabled, this method will have no effect.
 *
 * @param b a boolean value -- true to make the menu visible,
 * false to hide it
 */
@BeanProperty(bound = false, expert = true, hidden = true, description
 = "The popup menu's visibility")
publicvoidsetPopupMenuVisible(booleanb) {
if (DEBUG) {
System.out.println("in JMenu.setPopupMenuVisible " + b);
// Thread.dumpStack();
 }

booleanisVisible = isPopupMenuVisible();
if (b != isVisible && (isEnabled() || !b)) {
ensurePopupMenuCreated();
if ((b==true) && isShowing()) {
// Set location of popupMenu (pulldown or pullright)
Pointp = getCustomMenuLocation();
if (p == null) {
p = getPopupMenuOrigin();
 }
getPopupMenu().show(this, p.x, p.y);
 } else {
getPopupMenu().setVisible(false);
 }
 }
 }

/**
 * Computes the origin for the <code>JMenu</code>'s popup menu.
 * This method uses Look and Feel properties named
 * <code>Menu.menuPopupOffsetX</code>,
 * <code>Menu.menuPopupOffsetY</code>,
 * <code>Menu.submenuPopupOffsetX</code>, and
 * <code>Menu.submenuPopupOffsetY</code>
 * to adjust the exact location of popup.
 *
 * @return a <code>Point</code> in the coordinate space of the
 * menu which should be used as the origin
 * of the <code>JMenu</code>'s popup menu
 *
 * @since 1.3
 */
protectedPointgetPopupMenuOrigin() {
intx;
inty;
JPopupMenupm = getPopupMenu();
// Figure out the sizes needed to calculate the menu position
Dimensions = getSize();
DimensionpmSize = pm.getSize();
// For the first time the menu is popped up,
// the size has not yet been initiated
if (pmSize.width==0) {
pmSize = pm.getPreferredSize();
 }
Pointposition = getLocationOnScreen();
Toolkittoolkit = Toolkit.getDefaultToolkit();
GraphicsConfigurationgc = getGraphicsConfiguration();
RectanglescreenBounds = newRectangle(toolkit.getScreenSize());
GraphicsEnvironmentge =
GraphicsEnvironment.getLocalGraphicsEnvironment();
GraphicsDevice[] gd = ge.getScreenDevices();
for(inti = 0; i < gd.length; i++) {
if(gd[i].getType() == GraphicsDevice.TYPE_RASTER_SCREEN) {
GraphicsConfigurationdgc =
gd[i].getDefaultConfiguration();
if(dgc.getBounds().contains(position)) {
gc = dgc;
break;
 }
 }
 }


if (gc != null) {
screenBounds = gc.getBounds();
// take screen insets (e.g. taskbar) into account
InsetsscreenInsets = toolkit.getScreenInsets(gc);

screenBounds.width -=
Math.abs(screenInsets.left + screenInsets.right);
screenBounds.height -=
Math.abs(screenInsets.top + screenInsets.bottom);
position.x -= Math.abs(screenInsets.left);
position.y -= Math.abs(screenInsets.top);
 }

Containerparent = getParent();
if (parentinstanceofJPopupMenu) {
// We are a submenu (pull-right)
intxOffset = UIManager.getInt("Menu.submenuPopupOffsetX");
intyOffset = UIManager.getInt("Menu.submenuPopupOffsetY");

if( SwingUtilities.isLeftToRight(this) ) {
// First determine x:
x = s.width + xOffset; // Prefer placement to the right
if (position.x + x + pmSize.width >= screenBounds.width
 + screenBounds.x &&
// popup doesn't fit - place it wherever there's more room
screenBounds.width - s.width < 2*(position.x
 - screenBounds.x)) {

x = 0 - xOffset - pmSize.width;
 }
 } else {
// First determine x:
x = 0 - xOffset - pmSize.width; // Prefer placement to the left
if (position.x + x < screenBounds.x &&
// popup doesn't fit - place it wherever there's more room
screenBounds.width - s.width > 2*(position.x -
screenBounds.x)) {

x = s.width + xOffset;
 }
 }
// Then the y:
y = yOffset; // Prefer dropping down
if (position.y + y + pmSize.height >= screenBounds.height
 + screenBounds.y &&
// popup doesn't fit - place it wherever there's more room
screenBounds.height - s.height < 2*(position.y
 - screenBounds.y)) {

y = s.height - yOffset - pmSize.height;
 }
 } else {
// We are a toplevel menu (pull-down)
intxOffset = UIManager.getInt("Menu.menuPopupOffsetX");
intyOffset = UIManager.getInt("Menu.menuPopupOffsetY");

if( SwingUtilities.isLeftToRight(this) ) {
// First determine the x:
x = xOffset; // Extend to the right
if (position.x + x + pmSize.width >= screenBounds.width
 + screenBounds.x &&
// popup doesn't fit - place it wherever there's more room
screenBounds.width - s.width < 2*(position.x
 - screenBounds.x)) {

x = s.width - xOffset - pmSize.width;
 }
 } else {
// First determine the x:
x = s.width - xOffset - pmSize.width; // Extend to the left
if (position.x + x < screenBounds.x &&
// popup doesn't fit - place it wherever there's more room
screenBounds.width - s.width > 2*(position.x
 - screenBounds.x)) {

x = xOffset;
 }
 }
// Then the y:
y = s.height + yOffset; // Prefer dropping down
if (position.y + y + pmSize.height >= screenBounds.height
 + screenBounds.y &&
// popup doesn't fit - place it wherever there's more room
screenBounds.height - s.height < 2*(position.y
 - screenBounds.y)) {

y = 0 - yOffset - pmSize.height; // Otherwise drop 'up'
 }
 }
// Note that the position may be later adjusted to fit the menu into the screen if possible.
// However, the code that does it (JPopupMenu.adjustPopupLocationToFitScreen) has no idea which screen
// to fit into, and determines it by the position calculated here, so we need to make sure it's on
// the correct screen, otherwise the menu may appear on the wrong screen (JDK-6415065).
// (Both x and y are relative to the JMenu position here, that's why we need these +-position.x/y here.)
if (position.y + y < screenBounds.y) { // Above the current screen?
y = screenBounds.y - position.y; // The top of the screen relative to this JMenu.
 }
if (position.y + y >= screenBounds.y + screenBounds.height) { // Below the current screen?
y = screenBounds.y + screenBounds.height - 1 - position.y; // The bottom of the screen...
 }
if (position.x + x < screenBounds.x) { // To the left of the current screen?
x = screenBounds.x - position.x; // The left edge of the screen...
 }
if (position.x + x >= screenBounds.x + screenBounds.width) { // To the right of the current screen?
x = screenBounds.x + screenBounds.width - 1 - position.x; // The right edge of the screen...
 }
returnnewPoint(x,y);
 }


/**
 * Returns the suggested delay, in milliseconds, before submenus
 * are popped up or down.
 * Each look and feel (L&amp;F) may determine its own policy for
 * observing the <code>delay</code> property.
 * In most cases, the delay is not observed for top level menus
 * or while dragging. The default for <code>delay</code> is 0.
 * This method is a property of the look and feel code and is used
 * to manage the idiosyncrasies of the various UI implementations.
 *
 *
 * @return the <code>delay</code> property
 */
publicintgetDelay() {
returndelay;
 }

/**
 * Sets the suggested delay before the menu's <code>PopupMenu</code>
 * is popped up or down. Each look and feel (L&amp;F) may determine
 * it's own policy for observing the delay property. In most cases,
 * the delay is not observed for top level menus or while dragging.
 * This method is a property of the look and feel code and is used
 * to manage the idiosyncrasies of the various UI implementations.
 *
 * @param d the number of milliseconds to delay
 * @throws IllegalArgumentException if <code>d</code>
 * is less than 0
 */
@BeanProperty(bound = false, expert = true, description
 = "The delay between menu selection and making the popup menu visible")
publicvoidsetDelay(intd) {
if (d < 0)
thrownewIllegalArgumentException("Delay must be a positive integer");

delay = d;
 }

/**
 * The window-closing listener for the popup.
 *
 * @see WinListener
 */
protectedWinListenerpopupListener;

privatevoidensurePopupMenuCreated() {
if (popupMenu == null) {
finalJMenuthisMenu = this;
this.popupMenu = newJPopupMenu();
popupMenu.setInvoker(this);
popupListener = createWinListener(popupMenu);
 }
 }

/*
 * Return the customized location of the popup component.
 */
privatePointgetCustomMenuLocation() {
returncustomMenuLocation;
 }

/**
 * Sets the location of the popup component.
 *
 * @param x the x coordinate of the popup's new position
 * @param y the y coordinate of the popup's new position
 */
publicvoidsetMenuLocation(intx, inty) {
customMenuLocation = newPoint(x, y);
if (popupMenu != null)
popupMenu.setLocation(x, y);
 }

/**
 * Appends a menu item to the end of this menu.
 * Returns the menu item added.
 *
 * @param menuItem the <code>JMenuitem</code> to be added
 * @return the <code>JMenuItem</code> added
 */
publicJMenuItemadd(JMenuItemmenuItem) {
ensurePopupMenuCreated();
returnpopupMenu.add(menuItem);
 }

/**
 * Appends a component to the end of this menu.
 * Returns the component added.
 *
 * @param c the <code>Component</code> to add
 * @return the <code>Component</code> added
 */
publicComponentadd(Componentc) {
ensurePopupMenuCreated();
popupMenu.add(c);
returnc;
 }

/**
 * Adds the specified component to this container at the given
 * position. If <code>index</code> equals -1, the component will
 * be appended to the end.
 * @param c the <code>Component</code> to add
 * @param index the position at which to insert the component
 * @return the <code>Component</code> added
 * @see #remove
 * @see java.awt.Container#add(Component, int)
 */
publicComponentadd(Componentc, intindex) {
ensurePopupMenuCreated();
popupMenu.add(c, index);
returnc;
 }

/**
 * Creates a new menu item with the specified text and appends
 * it to the end of this menu.
 *
 * @param s the string for the menu item to be added
 * @return the new {@code JMenuItem}
 */
publicJMenuItemadd(Strings) {
returnadd(newJMenuItem(s));
 }

/**
 * Creates a new menu item attached to the specified {@code Action} object
 * and appends it to the end of this menu.
 *
 * @param a the {@code Action} for the menu item to be added
 * @return the new {@code JMenuItem}
 * @see Action
 */
publicJMenuItemadd(Actiona) {
JMenuItemmi = createActionComponent(a);
mi.setAction(a);
add(mi);
returnmi;
 }

/**
 * Factory method which creates the <code>JMenuItem</code> for
 * <code>Action</code>s added to the <code>JMenu</code>.
 *
 * @param a the <code>Action</code> for the menu item to be added
 * @return the new menu item
 * @see Action
 *
 * @since 1.3
 */
protectedJMenuItemcreateActionComponent(Actiona) {
JMenuItemmi = newJMenuItem() {
protectedPropertyChangeListenercreateActionPropertyChangeListener(Actiona) {
PropertyChangeListenerpcl = createActionChangeListener(this);
if (pcl == null) {
pcl = super.createActionPropertyChangeListener(a);
 }
returnpcl;
 }
 };
mi.setHorizontalTextPosition(JButton.TRAILING);
mi.setVerticalTextPosition(JButton.CENTER);
returnmi;
 }

/**
 * Returns a properly configured {@code PropertyChangeListener}
 * which updates the control as changes to the {@code Action} occur.
 *
 * @param b a menu item for which to create a {@code PropertyChangeListener}
 * @return a {@code PropertyChangeListener} for {@code b}
 */
protectedPropertyChangeListenercreateActionChangeListener(JMenuItemb) {
returnb.createActionPropertyChangeListener0(b.getAction());
 }

/**
 * Appends a new separator to the end of the menu.
 */
publicvoidaddSeparator()
 {
ensurePopupMenuCreated();
popupMenu.addSeparator();
 }

/**
 * Inserts a new menu item with the specified text at a
 * given position.
 *
 * @param s the text for the menu item to add
 * @param pos an integer specifying the position at which to add the
 * new menu item
 * @throws IllegalArgumentException when the value of
 * <code>pos</code> &lt; 0
 */
publicvoidinsert(Strings, intpos) {
if (pos < 0) {
thrownewIllegalArgumentException("index less than zero.");
 }

ensurePopupMenuCreated();
popupMenu.insert(newJMenuItem(s), pos);
 }

/**
 * Inserts the specified <code>JMenuitem</code> at a given position.
 *
 * @param mi the <code>JMenuitem</code> to add
 * @param pos an integer specifying the position at which to add the
 * new <code>JMenuitem</code>
 * @return the new menu item
 * @throws IllegalArgumentException if the value of
 * <code>pos</code> &lt; 0
 */
publicJMenuIteminsert(JMenuItemmi, intpos) {
if (pos < 0) {
thrownewIllegalArgumentException("index less than zero.");
 }
ensurePopupMenuCreated();
popupMenu.insert(mi, pos);
returnmi;
 }

/**
 * Inserts a new menu item attached to the specified <code>Action</code>
 * object at a given position.
 *
 * @param a the <code>Action</code> object for the menu item to add
 * @param pos an integer specifying the position at which to add the
 * new menu item
 * @return the new menu item
 * @throws IllegalArgumentException if the value of
 * <code>pos</code> &lt; 0
 */
publicJMenuIteminsert(Actiona, intpos) {
if (pos < 0) {
thrownewIllegalArgumentException("index less than zero.");
 }

ensurePopupMenuCreated();
JMenuItemmi = newJMenuItem(a);
mi.setHorizontalTextPosition(JButton.TRAILING);
mi.setVerticalTextPosition(JButton.CENTER);
popupMenu.insert(mi, pos);
returnmi;
 }

/**
 * Inserts a separator at the specified position.
 *
 * @param index an integer specifying the position at which to
 * insert the menu separator
 * @throws IllegalArgumentException if the value of
 * <code>index</code> &lt; 0
 */
publicvoidinsertSeparator(intindex) {
if (index < 0) {
thrownewIllegalArgumentException("index less than zero.");
 }

ensurePopupMenuCreated();
popupMenu.insert( newJPopupMenu.Separator(), index );
 }

/**
 * Returns the {@code JMenuItem} at the specified position.
 * If the component at {@code pos} is not a menu item,
 * {@code null} is returned.
 * This method is included for AWT compatibility.
 *
 * @param pos an integer specifying the position
 * @return the menu item at the specified position; or <code>null</code>
 * if the item as the specified position is not a menu item
 * @throws IllegalArgumentException if the value of
 * {@code pos} &lt; 0
 */
publicJMenuItemgetItem(intpos) {
if (pos < 0) {
thrownewIllegalArgumentException("index less than zero.");
 }

Componentc = getMenuComponent(pos);
if (cinstanceofJMenuItem) {
JMenuItemmi = (JMenuItem) c;
returnmi;
 }

// 4173633
returnnull;
 }

/**
 * Returns the number of items on the menu, including separators.
 * This method is included for AWT compatibility.
 *
 * @return an integer equal to the number of items on the menu
 * @see #getMenuComponentCount
 */
@BeanProperty(bound = false)
publicintgetItemCount() {
returngetMenuComponentCount();
 }

/**
 * Returns true if the menu can be torn off. This method is not
 * yet implemented.
 *
 * @return true if the menu can be torn off, else false
 * @throws Error if invoked -- this method is not yet implemented
 */
@BeanProperty(bound = false)
publicbooleanisTearOff() {
thrownewError("boolean isTearOff() {} not yet implemented");
 }

/**
 * Removes the specified menu item from this menu. If there is no
 * popup menu, this method will have no effect.
 *
 * @param item the <code>JMenuItem</code> to be removed from the menu
 */
publicvoidremove(JMenuItemitem) {
if (popupMenu != null)
popupMenu.remove(item);
 }

/**
 * Removes the menu item at the specified index from this menu.
 *
 * @param pos the position of the item to be removed
 * @throws IllegalArgumentException if the value of
 * <code>pos</code> &lt; 0, or if <code>pos</code>
 * is greater than the number of menu items
 */
publicvoidremove(intpos) {
if (pos < 0) {
thrownewIllegalArgumentException("index less than zero.");
 }
if (pos > getItemCount()) {
thrownewIllegalArgumentException("index greater than the number of items.");
 }
if (popupMenu != null)
popupMenu.remove(pos);
 }

/**
 * Removes the component <code>c</code> from this menu.
 *
 * @param c the component to be removed
 */
publicvoidremove(Componentc) {
if (popupMenu != null)
popupMenu.remove(c);
 }

/**
 * Removes all menu items from this menu.
 */
publicvoidremoveAll() {
if (popupMenu != null)
popupMenu.removeAll();
 }

/**
 * Returns the number of components on the menu.
 *
 * @return an integer containing the number of components on the menu
 */
@BeanProperty(bound = false)
publicintgetMenuComponentCount() {
intcomponentCount = 0;
if (popupMenu != null)
componentCount = popupMenu.getComponentCount();
returncomponentCount;
 }

/**
 * Returns the component at position <code>n</code>.
 *
 * @param n the position of the component to be returned
 * @return the component requested, or <code>null</code>
 * if there is no popup menu
 *
 */
publicComponentgetMenuComponent(intn) {
if (popupMenu != null)
returnpopupMenu.getComponent(n);

returnnull;
 }

/**
 * Returns an array of <code>Component</code>s of the menu's
 * subcomponents. Note that this returns all <code>Component</code>s
 * in the popup menu, including separators.
 *
 * @return an array of <code>Component</code>s or an empty array
 * if there is no popup menu
 */
@BeanProperty(bound = false)
publicComponent[] getMenuComponents() {
if (popupMenu != null)
returnpopupMenu.getComponents();

returnnewComponent[0];
 }

/**
 * Returns true if the menu is a 'top-level menu', that is, if it is
 * the direct child of a menubar.
 *
 * @return true if the menu is activated from the menu bar;
 * false if the menu is activated from a menu item
 * on another menu
 */
@BeanProperty(bound = false)
publicbooleanisTopLevelMenu() {
returngetParent() instanceofJMenuBar;

 }

/**
 * Returns true if the specified component exists in the
 * submenu hierarchy.
 *
 * @param c the <code>Component</code> to be tested
 * @return true if the <code>Component</code> exists, false otherwise
 */
publicbooleanisMenuComponent(Componentc) {
// Are we in the MenuItem part of the menu
if (c == this)
returntrue;
// Are we in the PopupMenu?
if (cinstanceofJPopupMenu) {
JPopupMenucomp = (JPopupMenu) c;
if (comp == this.getPopupMenu())
returntrue;
 }
// Are we in a Component on the PopupMenu
intncomponents = this.getMenuComponentCount();
Component[] component = this.getMenuComponents();
for (inti = 0 ; i < ncomponents ; i++) {
Componentcomp = component[i];
// Are we in the current component?
if (comp == c)
returntrue;
// Hmmm, what about Non-menu containers?

// Recursive call for the Menu case
if (compinstanceofJMenu) {
JMenusubMenu = (JMenu) comp;
if (subMenu.isMenuComponent(c))
returntrue;
 }
 }
returnfalse;
 }


/*
 * Returns a point in the coordinate space of this menu's popupmenu
 * which corresponds to the point <code>p</code> in the menu's
 * coordinate space.
 *
 * @param p the point to be translated
 * @return the point in the coordinate space of this menu's popupmenu
 */
privatePointtranslateToPopupMenu(Pointp) {
returntranslateToPopupMenu(p.x, p.y);
 }

/*
 * Returns a point in the coordinate space of this menu's popupmenu
 * which corresponds to the point (x,y) in the menu's coordinate space.
 *
 * @param x the x coordinate of the point to be translated
 * @param y the y coordinate of the point to be translated
 * @return the point in the coordinate space of this menu's popupmenu
 */
privatePointtranslateToPopupMenu(intx, inty) {
intnewX;
intnewY;

if (getParent() instanceofJPopupMenu) {
newX = x - getSize().width;
newY = y;
 } else {
newX = x;
newY = y - getSize().height;
 }

returnnewPoint(newX, newY);
 }

/**
 * Returns the popupmenu associated with this menu. If there is
 * no popupmenu, it will create one.
 *
 * @return the {@code JPopupMenu} associated with this menu