/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package java.awt;
import java.awt.event.FocusListener;
import java.awt.event.MouseEvent;
import java.awt.peer.MenuComponentPeer;
import java.io.Serializable;
import java.util.Locale; //import javax.accessibility.Accessible;
//import javax.accessibility.AccessibleComponent;
//import javax.accessibility.AccessibleContext;
//import javax.accessibility.AccessibleRole;
//import javax.accessibility.AccessibleSelection;
//import javax.accessibility.AccessibleStateSet;
import org.apache.harmony.awt.gl.MultiRectArea;
import org.apache.harmony.awt.state.MenuItemState;
import org.apache.harmony.awt.state.MenuState;
import org.apache.harmony.luni.util.NotImplementedException;
/**
* The MenuComponent abstract class is the superclass for menu components. Menu
* components receive and process AWT events.
*
* @since Android 1.0
*/
public abstract class MenuComponent implements Serializable {
/**
* The Constant serialVersionUID.
*/
private static final long serialVersionUID = -4536902356223894379L;
/**
* The name.
*/
private String name;
/**
* The font.
*/
private Font font;
/**
* The parent.
*/
MenuContainer parent;
/**
* The deprecated event handler.
*/
boolean deprecatedEventHandler = true;
/**
* The selected item index.
*/
private int selectedItemIndex;
// ???AWT: private AccessibleContext accessibleContext;
/**
* The toolkit.
*/
final Toolkit toolkit = Toolkit.getDefaultToolkit();
// ???AWT
/*
* protected abstract class AccessibleAWTMenuComponent extends
* AccessibleContext implements Serializable, AccessibleComponent,
* AccessibleSelection { private static final long serialVersionUID =
* -4269533416223798698L; public void addFocusListener(FocusListener
* listener) { } public boolean contains(Point pt) { return false; } public
* Accessible getAccessibleAt(Point pt) { return null; } public Color
* getBackground() { return null; } public Rectangle getBounds() { return
* null; } public Cursor getCursor() { return null; } public Font getFont()
* { return MenuComponent.this.getFont(); } public FontMetrics
* getFontMetrics(Font font) { return null; } public Color getForeground() {
* return null; } public Point getLocation() { return null; } public Point
* getLocationOnScreen() { return null; } public Dimension getSize() {
* return null; } public boolean isEnabled() { return true; // always
* enabled } public boolean isFocusTraversable() { return true; // always
* focus traversable } public boolean isShowing() { return true;// always
* showing } public boolean isVisible() { return true; // always visible }
* public void removeFocusListener(FocusListener listener) { } public void
* requestFocus() { } public void setBackground(Color color) { } public void
* setBounds(Rectangle rect) { } public void setCursor(Cursor cursor) { }
* public void setEnabled(boolean enabled) { } public void setFont(Font
* font) { MenuComponent.this.setFont(font); } public void
* setForeground(Color color) { } public void setLocation(Point pt) { }
* public void setSize(Dimension pt) { } public void setVisible(boolean
* visible) { } public void addAccessibleSelection(int index) { } public
* void clearAccessibleSelection() { } public Accessible
* getAccessibleSelection(int index) { return null; } public int
* getAccessibleSelectionCount() { return 0; } public boolean
* isAccessibleChildSelected(int index) { return false; } public void
* removeAccessibleSelection(int index) { } public void
* selectAllAccessibleSelection() { }
* @Override public Accessible getAccessibleChild(int index) { return null;
* }
* @Override public int getAccessibleChildrenCount() { return 0; }
* @Override public AccessibleComponent getAccessibleComponent() { return
* this; }
* @Override public String getAccessibleDescription() { return
* super.getAccessibleDescription(); }
* @Override public int getAccessibleIndexInParent() { toolkit.lockAWT();
* try { Accessible aParent = getAccessibleParent(); int aIndex = -1; if
* (aParent instanceof MenuComponent) { MenuComponent parent =
* (MenuComponent) aParent; int count = parent.getItemCount(); for (int i =
* 0; i < count; i++) { MenuComponent comp = parent.getItem(i); if (comp
* instanceof Accessible) { aIndex++; if (comp == MenuComponent.this) {
* return aIndex; } } } } return -1; } finally { toolkit.unlockAWT(); } }
* @Override public String getAccessibleName() { return
* super.getAccessibleName(); }
* @Override public Accessible getAccessibleParent() { toolkit.lockAWT();
* try { Accessible aParent = super.getAccessibleParent(); if (aParent !=
* null) { return aParent; } MenuContainer parent = getParent(); if (parent
* instanceof Accessible) { aParent = (Accessible) parent; } return aParent;
* } finally { toolkit.unlockAWT(); } }
* @Override public AccessibleRole getAccessibleRole() { return
* AccessibleRole.AWT_COMPONENT; }
* @Override public AccessibleSelection getAccessibleSelection() { return
* this; }
* @Override public AccessibleStateSet getAccessibleStateSet() { return new
* AccessibleStateSet(); }
* @Override public Locale getLocale() { return Locale.getDefault(); } }
*/
/**
* The accessor to MenuComponent internal state, utilized by the visual
* theme.
*
* @throws HeadlessException
* the headless exception.
*/
// ???AWT
/*
* class State implements MenuState { Dimension size; Dimension getSize() {
* if (size == null) { calculate(); } return size; } public int getWidth() {
* return getSize().width; } public int getHeight() { return
* getSize().height; } public Font getFont() { return
* MenuComponent.this.getFont(); } public int getItemCount() { return
* MenuComponent.this.getItemCount(); } public int getSelectedItemIndex() {
* return MenuComponent.this.getSelectedItemIndex(); } public boolean
* isFontSet() { return MenuComponent.this.isFontSet(); }
* @SuppressWarnings("deprecation") public FontMetrics getFontMetrics(Font
* f) { return MenuComponent.this.toolkit.getFontMetrics(f); } public Point
* getLocation() { return MenuComponent.this.getLocation(); } public
* MenuItemState getItem(int index) { MenuItem item =
* MenuComponent.this.getItem(index); return item.itemState; } public void
* setSize(int w, int h) { this.size = new Dimension(w, h); } void
* calculate() { size = new Dimension();
* size.setSize(toolkit.theme.calculateMenuSize(this)); } void reset() { for
* (int i = 0; i < getItemCount(); i++) { ((MenuItem.State)
* getItem(i)).reset(); } } }
*/
/**
* Pop-up box for menu. It transfers the paint events, keyboard and mouse
* events to the menu component itself.
*/
// ???AWT
/*
* class MenuPopupBox extends PopupBox { private final Point lastMousePos =
* new Point();
* @Override boolean isMenu() { return true; }
* @Override void paint(Graphics gr) { MenuComponent.this.paint(gr); }
* @Override void onKeyEvent(int eventId, int vKey, long when, int
* modifiers) { MenuComponent.this.onKeyEvent(eventId, vKey, when,
* modifiers); }
* @Override void onMouseEvent(int eventId, Point where, int mouseButton,
* long when, int modifiers, int wheelRotation) { // prevent conflict of
* mouse and keyboard // when sub-menu drops down due to keyboard navigation
* if (lastMousePos.equals(where) && (eventId == MouseEvent.MOUSE_MOVED ||
* eventId == MouseEvent.MOUSE_ENTERED)) { return; }
* lastMousePos.setLocation(where); MenuComponent.this.onMouseEvent(eventId,
* where, mouseButton, when, modifiers); } }
*/
/**
* Instantiates a new MenuComponent object.
*
* @throws HeadlessException
* if the graphical interface environment can't support
* MenuComponents.
*/
public MenuComponent() throws HeadlessException {
toolkit.lockAWT();
try {
Toolkit.checkHeadless();
name = autoName();
selectedItemIndex = -1;
} finally {
toolkit.unlockAWT();
}
}
/**
* Gets the name of the MenuComponent object.
*
* @return the name of the MenuComponent object.
*/
public String getName() {
toolkit.lockAWT();
try {
return name;
} finally {
toolkit.unlockAWT();
}
}
/**
* Returns a String representation of the MenuComponent object.
*
* @return a String representation of the MenuComponent object.
*/
@Override
public String toString() {
toolkit.lockAWT();
try {
return getClass().getName() + "[" + paramString() + "]"; //$NON-NLS-1$ //$NON-NLS-2$
} finally {
toolkit.unlockAWT();
}
}
/**
* Gets the parent menu container.
*
* @return the parent.
*/
public MenuContainer getParent() {
toolkit.lockAWT();
try {
return parent;
} finally {
toolkit.unlockAWT();
}
}
/**
* Sets the name of the MenuComponent to the specified string.
*
* @param name
* the new name of the MenuComponent object.
*/
public void setName(String name) {
toolkit.lockAWT();
try {
this.name = name;
} finally {
toolkit.unlockAWT();
}
}
/**
* Dispatches AWT event.
*
* @param event
* the AWTEvent.
*/
public final void dispatchEvent(AWTEvent event) {
toolkit.lockAWT();
try {
processEvent(event);
if (deprecatedEventHandler) {
postDeprecatedEvent(event);
}
} finally {
toolkit.unlockAWT();
}
}
/**
* Post deprecated event.
*
* @param event
* the event.
*/
void postDeprecatedEvent(AWTEvent event) {
Event evt = event.getEvent();
if (evt != null) {
postEvent(evt);
}
}
/**
* Gets the peer of the MenuComponent; an application must not use this
* method directly.
*
* @return the MenuComponentPeer object.
* @throws NotImplementedException
* if this method is not implemented by a subclass.
* @deprecated an application must not use this method directly.
*/
@Deprecated
public MenuComponentPeer getPeer() throws org.apache.harmony.luni.util.NotImplementedException {
toolkit.lockAWT();
try {
} finally {
toolkit.unlockAWT();
}
if (true) {
throw new RuntimeException("Method is not implemented"); //TODO: implement //$NON-NLS-1$
}
return null;
}
/**
* Gets the locking object of this MenuComponent.
*
* @return the locking object of this MenuComponent.
*/
protected final Object getTreeLock() {
return toolkit.awtTreeLock;
}
/**
* Posts the Event to the MenuComponent.
*
* @param e
* the Event.
* @return true, if the event is posted successfully, false otherwise.
* @deprecated Replaced dispatchEvent method.
*/
@SuppressWarnings("deprecation")
@Deprecated
public boolean postEvent(Event e) {
toolkit.lockAWT();
try {
if (parent != null) {
return parent.postEvent(e);
}
return false;
} finally {
toolkit.unlockAWT();
}
}
/**
* Returns the string representation of the MenuComponent state.
*
* @return returns the string representation of the MenuComponent state.
*/
protected String paramString() {
toolkit.lockAWT();
try {
return getName();
} finally {
toolkit.unlockAWT();
}
}
// ???AWT
/*
* public AccessibleContext getAccessibleContext() { toolkit.lockAWT(); try
* { if (accessibleContext == null) { accessibleContext =
* createAccessibleContext(); } return accessibleContext; } finally {
* toolkit.unlockAWT(); } }
*/
/**
* Gets the font of the MenuComponent object.
*
* @return the Font of the MenuComponent object.
*/
public Font getFont() {
toolkit.lockAWT();
try {
if (font == null && hasDefaultFont()) {
return toolkit.getDefaultFont();
}
if (font == null && parent != null) {
return parent.getFont();
}
return font;
} finally {
toolkit.unlockAWT();
}
}
/**
* Checks if is font set.
*
* @return true, if is font set
*/
boolean isFontSet() {
return font != null
|| ((parent instanceof MenuComponent) && ((MenuComponent)parent).isFontSet());
}
/**
* Checks for default font.
*
* @return true, if successful.
*/
boolean hasDefaultFont() {
return false;
}
/**
* Processes an AWTEevent on this menu component.
*
* @param event
* the AWTEvent.
*/
protected void processEvent(AWTEvent event) {
toolkit.lockAWT();
try {
// do nothing
} finally {
toolkit.unlockAWT();
}
}
/**
* Removes the peer of the MenuComponent.
*/
public void removeNotify() {
toolkit.lockAWT();
try {
} finally {
toolkit.unlockAWT();
}
}
/**
* Sets the Font for this MenuComponent object.
*
* @param font
* the new Font to be used for this MenuComponent.
*/
public void setFont(Font font) {
toolkit.lockAWT();
try {
this.font = font;
} finally {
toolkit.unlockAWT();
}
}
/**
* Sets the parent.
*
* @param parent
* the new parent.
*/
void setParent(MenuContainer parent) {
this.parent = parent;
}
/**
* Gets the location.
*
* @return the location.
*/
Point getLocation() {
// to be overridden
return new Point(0, 0);
}
/**
* Gets the width.
*
* @return the width.
*/
int getWidth() {
// to be overridden
return 1;
}
/**
* Gets the height.
*
* @return the height.
*/
int getHeight() {
// to be overridden
return 1;
}
/**
* Recursively find the menu item for a menu shortcut.
*
* @param gr
* the gr.
* @return the menu item; or null if the item is not available for this
* shortcut.
*/
// ???AWT
/*
* MenuItem getShortcutMenuItemImpl(MenuShortcut ms) { if (ms == null) {
* return null; } for (int i = 0; i < getItemCount(); i++) { MenuItem mi =
* getItem(i); if (mi instanceof Menu) { mi = ((Menu)
* mi).getShortcutMenuItemImpl(ms); if (mi != null) { return mi; } } else if
* (ms.equals(mi.getShortcut())) { return mi; } } return null; }
*/
void paint(Graphics gr) {
gr.setColor(Color.LIGHT_GRAY);
gr.fillRect(0, 0, getWidth(), getHeight());
gr.setColor(Color.BLACK);
}
/**
* Mouse events handler.
*
* @param eventId
* one of the MouseEvent.MOUSE_* constants.
* @param where
* mouse location.
* @param mouseButton
* mouse button that was pressed or released.
* @param when
* event time.
* @param modifiers
* input event modifiers.
*/
void onMouseEvent(int eventId, Point where, int mouseButton, long when, int modifiers) {
// to be overridden
}
/**
* Keyboard event handler.
*
* @param eventId
* one of the KeyEvent.KEY_* constants.
* @param vKey
* the key code.
* @param when
* event time.
* @param modifiers
* input event modifiers.
*/
void onKeyEvent(int eventId, int vKey, long when, int modifiers) {
// to be overridden
}
/**
* Post the ActionEvent or ItemEvent, depending on type of the menu item.
*
* @param index
* the index.
* @return the item rect.
*/
// ???AWT
/*
* void fireItemAction(int item, long when, int modifiers) { MenuItem mi =
* getItem(item); mi.itemSelected(when, modifiers); } MenuItem getItem(int
* index) { // to be overridden return null; } int getItemCount() { return
* 0; }
*/
/**
* @return The sub-menu of currently selecetd item, or null if such a
* sub-menu is not available.
*/
// ???AWT
/*
* Menu getSelectedSubmenu() { if (selectedItemIndex < 0) { return null; }
* MenuItem item = getItem(selectedItemIndex); return (item instanceof Menu)
* ? (Menu) item : null; }
*/
/**
* Convenience method for selectItem(index, true).
*/
// ???AWT
/*
* void selectItem(int index) { selectItem(index, true); }
*/
/**
* Change the selection in the menu.
*
* @param index
* new selecetd item's index.
* @param showSubMenu
* if new selected item has a sub-menu, should that sub-menu be
* displayed.
*/
// ???AWT
/*
* void selectItem(int index, boolean showSubMenu) { if (selectedItemIndex
* == index) { return; } if (selectedItemIndex >= 0 &&
* getItem(selectedItemIndex) instanceof Menu) { ((Menu)
* getItem(selectedItemIndex)).hide(); } MultiRectArea clip =
* getUpdateClip(index, selectedItemIndex); selectedItemIndex = index;
* Graphics gr = getGraphics(clip); if (gr != null) { paint(gr); } if
* (showSubMenu) { showSubMenu(selectedItemIndex); } }
*/
/**
* Change the selected item to the next one in the requested direction
* moving cyclically, skipping separators
*
* @param forward
* the direction to move the selection.
* @param showSubMenu
* if new selected item has a sub-menu, should that sub-menu be
* displayed.
*/
// ???AWT
/*
* void selectNextItem(boolean forward, boolean showSubMenu) { int selected
* = getSelectedItemIndex(); int count = getItemCount(); if (count == 0) {
* return; } if (selected < 0) { selected = (forward ? count - 1 : 0); } int
* i = selected; do { i = (forward ? (i + 1) : (i + count - 1)) % count; i
* %= count; MenuItem item = getItem(i); if (!"-".equals(item.getLabel())) {
* //$NON-NLS-1$ selectItem(i, showSubMenu); return; } } while (i !=
* selected); } void showSubMenu(int index) { if ((index < 0) ||
* !isActive()) { return; } MenuItem item = getItem(index); if (item
* instanceof Menu) { Menu menu = ((Menu) getItem(index)); if
* (menu.getItemCount() == 0) { return; } Point location =
* getSubmenuLocation(index); menu.show(location.x, location.y, false); } }
*/
/**
* @return the menu bar which is the root of current menu's hierarchy; or
* null if the hierarchy root is not a menu bar.
*/
// ???AWT
/*
* MenuBar getMenuBar() { if (parent instanceof MenuBar) { return (MenuBar)
* parent; } if (parent instanceof MenuComponent) { return ((MenuComponent)
* parent).getMenuBar(); } return null; } PopupBox getPopupBox() { return
* null; }
*/
Rectangle getItemRect(int index) {
// to be overridden
return null;
}
/**
* Determine the clip region when menu selection is changed from index1 to
* index2.
*
* @param index1
* old selected item.
* @param index2
* new selected item.
* @return the region to repaint.
*/
final MultiRectArea getUpdateClip(int index1, int index2) {
MultiRectArea clip = new MultiRectArea();
if (index1 >= 0) {
clip.add(getItemRect(index1));
}
if (index2 >= 0) {
clip.add(getItemRect(index2));
}
return clip;
}
/**
* Gets the submenu location.
*
* @param index
* the index.
* @return the submenu location.
*/
Point getSubmenuLocation(int index) {
// to be overridden
return new Point(0, 0);
}
/**
* Gets the selected item index.
*
* @return the selected item index.
*/
int getSelectedItemIndex() {
return selectedItemIndex;
}
/**
* Hide.
*/
void hide() {
selectedItemIndex = -1;
if (parent instanceof MenuComponent) {
((MenuComponent)parent).itemHidden(this);
}
}
/**
* Item hidden.
*
* @param mc
* the mc.
*/
void itemHidden(MenuComponent mc) {
// to be overridden
}
/**
* Checks if is visible.
*
* @return true, if is visible.
*/
boolean isVisible() {
return true;
}
/**
* Checks if is active.
*
* @return true, if is active.
*/
boolean isActive() {
return true;
}
/**
* Hide all menu hierarchy.
*/
void endMenu() {
// ???AWT: toolkit.dispatcher.popupDispatcher.deactivateAll();
}
/**
* Handle the mouse click or Enter key event on a menu's item.
*
* @param when
* the event time.
* @param modifiers
* input event modifiers.
*/
void itemSelected(long when, int modifiers) {
endMenu();
}
/**
* Auto name.
*
* @return the string.
*/
String autoName() {
String name = getClass().getName();
if (name.indexOf("$") != -1) { //$NON-NLS-1$
return null;
}
// ???AWT: int number = toolkit.autoNumber.nextMenuComponent++;
int number = 0;
name = name.substring(name.lastIndexOf(".") + 1) + Integer.toString(number); //$NON-NLS-1$
return name;
}
/**
* Creates the Graphics object for the pop-up box of this menu component.
*
* @param clip
* the clip to set on this Graphics.
* @return the created Graphics object, or null if such object is not
* available.
*/
Graphics getGraphics(MultiRectArea clip) {
// to be overridden
return null;
}
/**
* @return accessible context specific for particular menu component.
*/
// ???AWT
/*
* AccessibleContext createAccessibleContext() { return null; }
*/
}