You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
518 lines
15 KiB
518 lines
15 KiB
/*
|
|
* Copyright (c) 1995, 2015, Oracle and/or its affiliates. All rights reserved.
|
|
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*/
|
|
package java.awt;
|
|
|
|
import java.io.IOException;
|
|
import java.io.ObjectInputStream;
|
|
import java.util.Vector;
|
|
import java.util.Enumeration;
|
|
import sun.awt.AWTAccessor;
|
|
import java.awt.peer.MenuBarPeer;
|
|
import java.awt.event.KeyEvent;
|
|
import javax.accessibility.*;
|
|
|
|
/**
|
|
* The <code>MenuBar</code> class encapsulates the platform's
|
|
* concept of a menu bar bound to a frame. In order to associate
|
|
* the menu bar with a <code>Frame</code> object, call the
|
|
* frame's <code>setMenuBar</code> method.
|
|
* <p>
|
|
* <A NAME="mbexample"></A><!-- target for cross references -->
|
|
* This is what a menu bar might look like:
|
|
* <p>
|
|
* <img src="doc-files/MenuBar-1.gif"
|
|
* alt="Diagram of MenuBar containing 2 menus: Examples and Options.
|
|
* Examples menu is expanded showing items: Basic, Simple, Check, and More Examples."
|
|
* style="float:center; margin: 7px 10px;">
|
|
* <p>
|
|
* A menu bar handles keyboard shortcuts for menu items, passing them
|
|
* along to its child menus.
|
|
* (Keyboard shortcuts, which are optional, provide the user with
|
|
* an alternative to the mouse for invoking a menu item and the
|
|
* action that is associated with it.)
|
|
* Each menu item can maintain an instance of <code>MenuShortcut</code>.
|
|
* The <code>MenuBar</code> class defines several methods,
|
|
* {@link MenuBar#shortcuts} and
|
|
* {@link MenuBar#getShortcutMenuItem}
|
|
* that retrieve information about the shortcuts a given
|
|
* menu bar is managing.
|
|
*
|
|
* @author Sami Shaio
|
|
* @see java.awt.Frame
|
|
* @see java.awt.Frame#setMenuBar(java.awt.MenuBar)
|
|
* @see java.awt.Menu
|
|
* @see java.awt.MenuItem
|
|
* @see java.awt.MenuShortcut
|
|
* @since JDK1.0
|
|
*/
|
|
public class MenuBar extends MenuComponent implements MenuContainer, Accessible {
|
|
|
|
static {
|
|
/* ensure that the necessary native libraries are loaded */
|
|
Toolkit.loadLibraries();
|
|
if (!GraphicsEnvironment.isHeadless()) {
|
|
initIDs();
|
|
}
|
|
AWTAccessor.setMenuBarAccessor(
|
|
new AWTAccessor.MenuBarAccessor() {
|
|
public Menu getHelpMenu(MenuBar menuBar) {
|
|
return menuBar.helpMenu;
|
|
}
|
|
|
|
public Vector<Menu> getMenus(MenuBar menuBar) {
|
|
return menuBar.menus;
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* This field represents a vector of the
|
|
* actual menus that will be part of the MenuBar.
|
|
*
|
|
* @serial
|
|
* @see #countMenus()
|
|
*/
|
|
Vector<Menu> menus = new Vector<>();
|
|
|
|
/**
|
|
* This menu is a special menu dedicated to
|
|
* help. The one thing to note about this menu
|
|
* is that on some platforms it appears at the
|
|
* right edge of the menubar.
|
|
*
|
|
* @serial
|
|
* @see #getHelpMenu()
|
|
* @see #setHelpMenu(Menu)
|
|
*/
|
|
Menu helpMenu;
|
|
|
|
private static final String base = "menubar";
|
|
private static int nameCounter = 0;
|
|
|
|
/*
|
|
* JDK 1.1 serialVersionUID
|
|
*/
|
|
private static final long serialVersionUID = -4930327919388951260L;
|
|
|
|
/**
|
|
* Creates a new menu bar.
|
|
* @exception HeadlessException if GraphicsEnvironment.isHeadless()
|
|
* returns true.
|
|
* @see java.awt.GraphicsEnvironment#isHeadless
|
|
*/
|
|
public MenuBar() throws HeadlessException {
|
|
}
|
|
|
|
/**
|
|
* Construct a name for this MenuComponent. Called by getName() when
|
|
* the name is null.
|
|
*/
|
|
String constructComponentName() {
|
|
synchronized (MenuBar.class) {
|
|
return base + nameCounter++;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Creates the menu bar's peer. The peer allows us to change the
|
|
* appearance of the menu bar without changing any of the menu bar's
|
|
* functionality.
|
|
*/
|
|
public void addNotify() {
|
|
synchronized (getTreeLock()) {
|
|
if (peer == null)
|
|
peer = Toolkit.getDefaultToolkit().createMenuBar(this);
|
|
|
|
int nmenus = getMenuCount();
|
|
for (int i = 0 ; i < nmenus ; i++) {
|
|
getMenu(i).addNotify();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Removes the menu bar's peer. The peer allows us to change the
|
|
* appearance of the menu bar without changing any of the menu bar's
|
|
* functionality.
|
|
*/
|
|
public void removeNotify() {
|
|
synchronized (getTreeLock()) {
|
|
int nmenus = getMenuCount();
|
|
for (int i = 0 ; i < nmenus ; i++) {
|
|
getMenu(i).removeNotify();
|
|
}
|
|
super.removeNotify();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets the help menu on the menu bar.
|
|
* @return the help menu on this menu bar.
|
|
*/
|
|
public Menu getHelpMenu() {
|
|
return helpMenu;
|
|
}
|
|
|
|
/**
|
|
* Sets the specified menu to be this menu bar's help menu.
|
|
* If this menu bar has an existing help menu, the old help menu is
|
|
* removed from the menu bar, and replaced with the specified menu.
|
|
* @param m the menu to be set as the help menu
|
|
*/
|
|
public void setHelpMenu(final Menu m) {
|
|
synchronized (getTreeLock()) {
|
|
if (helpMenu == m) {
|
|
return;
|
|
}
|
|
if (helpMenu != null) {
|
|
remove(helpMenu);
|
|
}
|
|
helpMenu = m;
|
|
if (m != null) {
|
|
if (m.parent != this) {
|
|
add(m);
|
|
}
|
|
m.isHelpMenu = true;
|
|
m.parent = this;
|
|
MenuBarPeer peer = (MenuBarPeer)this.peer;
|
|
if (peer != null) {
|
|
if (m.peer == null) {
|
|
m.addNotify();
|
|
}
|
|
peer.addHelpMenu(m);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Adds the specified menu to the menu bar.
|
|
* If the menu has been part of another menu bar,
|
|
* removes it from that menu bar.
|
|
*
|
|
* @param m the menu to be added
|
|
* @return the menu added
|
|
* @see java.awt.MenuBar#remove(int)
|
|
* @see java.awt.MenuBar#remove(java.awt.MenuComponent)
|
|
*/
|
|
public Menu add(Menu m) {
|
|
synchronized (getTreeLock()) {
|
|
if (m.parent != null) {
|
|
m.parent.remove(m);
|
|
}
|
|
m.parent = this;
|
|
|
|
MenuBarPeer peer = (MenuBarPeer)this.peer;
|
|
if (peer != null) {
|
|
if (m.peer == null) {
|
|
m.addNotify();
|
|
}
|
|
menus.addElement(m);
|
|
peer.addMenu(m);
|
|
} else {
|
|
menus.addElement(m);
|
|
}
|
|
return m;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Removes the menu located at the specified
|
|
* index from this menu bar.
|
|
* @param index the position of the menu to be removed.
|
|
* @see java.awt.MenuBar#add(java.awt.Menu)
|
|
*/
|
|
public void remove(final int index) {
|
|
synchronized (getTreeLock()) {
|
|
Menu m = getMenu(index);
|
|
menus.removeElementAt(index);
|
|
MenuBarPeer peer = (MenuBarPeer)this.peer;
|
|
if (peer != null) {
|
|
peer.delMenu(index);
|
|
m.removeNotify();
|
|
m.parent = null;
|
|
}
|
|
if (helpMenu == m) {
|
|
helpMenu = null;
|
|
m.isHelpMenu = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Removes the specified menu component from this menu bar.
|
|
* @param m the menu component to be removed.
|
|
* @see java.awt.MenuBar#add(java.awt.Menu)
|
|
*/
|
|
public void remove(MenuComponent m) {
|
|
synchronized (getTreeLock()) {
|
|
int index = menus.indexOf(m);
|
|
if (index >= 0) {
|
|
remove(index);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets the number of menus on the menu bar.
|
|
* @return the number of menus on the menu bar.
|
|
* @since JDK1.1
|
|
*/
|
|
public int getMenuCount() {
|
|
return countMenus();
|
|
}
|
|
|
|
/**
|
|
* @deprecated As of JDK version 1.1,
|
|
* replaced by <code>getMenuCount()</code>.
|
|
*/
|
|
@Deprecated
|
|
public int countMenus() {
|
|
return getMenuCountImpl();
|
|
}
|
|
|
|
/*
|
|
* This is called by the native code, so client code can't
|
|
* be called on the toolkit thread.
|
|
*/
|
|
final int getMenuCountImpl() {
|
|
return menus.size();
|
|
}
|
|
|
|
/**
|
|
* Gets the specified menu.
|
|
* @param i the index position of the menu to be returned.
|
|
* @return the menu at the specified index of this menu bar.
|
|
*/
|
|
public Menu getMenu(int i) {
|
|
return getMenuImpl(i);
|
|
}
|
|
|
|
/*
|
|
* This is called by the native code, so client code can't
|
|
* be called on the toolkit thread.
|
|
*/
|
|
final Menu getMenuImpl(int i) {
|
|
return menus.elementAt(i);
|
|
}
|
|
|
|
/**
|
|
* Gets an enumeration of all menu shortcuts this menu bar
|
|
* is managing.
|
|
* @return an enumeration of menu shortcuts that this
|
|
* menu bar is managing.
|
|
* @see java.awt.MenuShortcut
|
|
* @since JDK1.1
|
|
*/
|
|
public synchronized Enumeration<MenuShortcut> shortcuts() {
|
|
Vector<MenuShortcut> shortcuts = new Vector<>();
|
|
int nmenus = getMenuCount();
|
|
for (int i = 0 ; i < nmenus ; i++) {
|
|
Enumeration<MenuShortcut> e = getMenu(i).shortcuts();
|
|
while (e.hasMoreElements()) {
|
|
shortcuts.addElement(e.nextElement());
|
|
}
|
|
}
|
|
return shortcuts.elements();
|
|
}
|
|
|
|
/**
|
|
* Gets the instance of <code>MenuItem</code> associated
|
|
* with the specified <code>MenuShortcut</code> object,
|
|
* or <code>null</code> if none of the menu items being managed
|
|
* by this menu bar is associated with the specified menu
|
|
* shortcut.
|
|
* @param s the specified menu shortcut.
|
|
* @see java.awt.MenuItem
|
|
* @see java.awt.MenuShortcut
|
|
* @since JDK1.1
|
|
*/
|
|
public MenuItem getShortcutMenuItem(MenuShortcut s) {
|
|
int nmenus = getMenuCount();
|
|
for (int i = 0 ; i < nmenus ; i++) {
|
|
MenuItem mi = getMenu(i).getShortcutMenuItem(s);
|
|
if (mi != null) {
|
|
return mi;
|
|
}
|
|
}
|
|
return null; // MenuShortcut wasn't found
|
|
}
|
|
|
|
/*
|
|
* Post an ACTION_EVENT to the target of the MenuPeer
|
|
* associated with the specified keyboard event (on
|
|
* keydown). Returns true if there is an associated
|
|
* keyboard event.
|
|
*/
|
|
boolean handleShortcut(KeyEvent e) {
|
|
// Is it a key event?
|
|
int id = e.getID();
|
|
if (id != KeyEvent.KEY_PRESSED && id != KeyEvent.KEY_RELEASED) {
|
|
return false;
|
|
}
|
|
|
|
// Is the accelerator modifier key pressed?
|
|
int accelKey = Toolkit.getDefaultToolkit().getMenuShortcutKeyMask();
|
|
if ((e.getModifiers() & accelKey) == 0) {
|
|
return false;
|
|
}
|
|
|
|
// Pass MenuShortcut on to child menus.
|
|
int nmenus = getMenuCount();
|
|
for (int i = 0 ; i < nmenus ; i++) {
|
|
Menu m = getMenu(i);
|
|
if (m.handleShortcut(e)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Deletes the specified menu shortcut.
|
|
* @param s the menu shortcut to delete.
|
|
* @since JDK1.1
|
|
*/
|
|
public void deleteShortcut(MenuShortcut s) {
|
|
int nmenus = getMenuCount();
|
|
for (int i = 0 ; i < nmenus ; i++) {
|
|
getMenu(i).deleteShortcut(s);
|
|
}
|
|
}
|
|
|
|
/* Serialization support. Restore the (transient) parent
|
|
* fields of Menubar menus here.
|
|
*/
|
|
|
|
/**
|
|
* The MenuBar's serialized data version.
|
|
*
|
|
* @serial
|
|
*/
|
|
private int menuBarSerializedDataVersion = 1;
|
|
|
|
/**
|
|
* Writes default serializable fields to stream.
|
|
*
|
|
* @param s the <code>ObjectOutputStream</code> to write
|
|
* @see AWTEventMulticaster#save(ObjectOutputStream, String, EventListener)
|
|
* @see #readObject(java.io.ObjectInputStream)
|
|
*/
|
|
private void writeObject(java.io.ObjectOutputStream s)
|
|
throws java.lang.ClassNotFoundException,
|
|
java.io.IOException
|
|
{
|
|
s.defaultWriteObject();
|
|
}
|
|
|
|
/**
|
|
* Reads the <code>ObjectInputStream</code>.
|
|
* Unrecognized keys or values will be ignored.
|
|
*
|
|
* @param s the <code>ObjectInputStream</code> to read
|
|
* @exception HeadlessException if
|
|
* <code>GraphicsEnvironment.isHeadless</code> returns
|
|
* <code>true</code>
|
|
* @see java.awt.GraphicsEnvironment#isHeadless
|
|
* @see #writeObject(java.io.ObjectOutputStream)
|
|
*/
|
|
private void readObject(ObjectInputStream s)
|
|
throws ClassNotFoundException, IOException, HeadlessException
|
|
{
|
|
// HeadlessException will be thrown from MenuComponent's readObject
|
|
s.defaultReadObject();
|
|
for (int i = 0; i < menus.size(); i++) {
|
|
Menu m = menus.elementAt(i);
|
|
m.parent = this;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Initialize JNI field and method IDs
|
|
*/
|
|
private static native void initIDs();
|
|
|
|
|
|
/////////////////
|
|
// Accessibility support
|
|
////////////////
|
|
|
|
/**
|
|
* Gets the AccessibleContext associated with this MenuBar.
|
|
* For menu bars, the AccessibleContext takes the form of an
|
|
* AccessibleAWTMenuBar.
|
|
* A new AccessibleAWTMenuBar instance is created if necessary.
|
|
*
|
|
* @return an AccessibleAWTMenuBar that serves as the
|
|
* AccessibleContext of this MenuBar
|
|
* @since 1.3
|
|
*/
|
|
public AccessibleContext getAccessibleContext() {
|
|
if (accessibleContext == null) {
|
|
accessibleContext = new AccessibleAWTMenuBar();
|
|
}
|
|
return accessibleContext;
|
|
}
|
|
|
|
/**
|
|
* Defined in MenuComponent. Overridden here.
|
|
*/
|
|
int getAccessibleChildIndex(MenuComponent child) {
|
|
return menus.indexOf(child);
|
|
}
|
|
|
|
/**
|
|
* Inner class of MenuBar used to provide default support for
|
|
* accessibility. This class is not meant to be used directly by
|
|
* application developers, but is instead meant only to be
|
|
* subclassed by menu component developers.
|
|
* <p>
|
|
* This class implements accessibility support for the
|
|
* <code>MenuBar</code> class. It provides an implementation of the
|
|
* Java Accessibility API appropriate to menu bar user-interface elements.
|
|
* @since 1.3
|
|
*/
|
|
protected class AccessibleAWTMenuBar extends AccessibleAWTMenuComponent
|
|
{
|
|
/*
|
|
* JDK 1.3 serialVersionUID
|
|
*/
|
|
private static final long serialVersionUID = -8577604491830083815L;
|
|
|
|
/**
|
|
* Get the role of this object.
|
|
*
|
|
* @return an instance of AccessibleRole describing the role of the
|
|
* object
|
|
* @since 1.4
|
|
*/
|
|
public AccessibleRole getAccessibleRole() {
|
|
return AccessibleRole.MENU_BAR;
|
|
}
|
|
|
|
} // class AccessibleAWTMenuBar
|
|
|
|
}
|