replicant-frameworks_native/awt/java/awt/MenuComponent.java

/*
 *  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; }
     */
}