diff options
Diffstat (limited to 'awt/java/awt/AWTEvent.java')
| -rw-r--r-- | awt/java/awt/AWTEvent.java | 681 |
1 files changed, 681 insertions, 0 deletions
diff --git a/awt/java/awt/AWTEvent.java b/awt/java/awt/AWTEvent.java new file mode 100644 index 0000000..a8dc83a --- /dev/null +++ b/awt/java/awt/AWTEvent.java @@ -0,0 +1,681 @@ +/* + * 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. + */ +/** + * @author Dmitry A. Durnev, Michael Danilov + * @version $Revision$ + */ + +package java.awt; + +import java.util.EventObject; +import java.util.Hashtable; +import java.util.EventListener; + +import java.awt.event.*; + +/** + * The abstract class AWTEvent is the base class for all AWT events. This class + * and its subclasses supersede the original java.awt.Event class. + * + * @since Android 1.0 + */ +public abstract class AWTEvent extends EventObject { + + /** + * The Constant serialVersionUID. + */ + private static final long serialVersionUID = -1825314779160409405L; + + /** + * The Constant COMPONENT_EVENT_MASK indicates the event relates to a + * component. + */ + public static final long COMPONENT_EVENT_MASK = 1; + + /** + * The Constant CONTAINER_EVENT_MASK indicates the event relates to a + * container. + */ + public static final long CONTAINER_EVENT_MASK = 2; + + /** + * The Constant FOCUS_EVENT_MASK indicates the event relates to the focus. + */ + public static final long FOCUS_EVENT_MASK = 4; + + /** + * The Constant KEY_EVENT_MASK indicates the event relates to a key. + */ + public static final long KEY_EVENT_MASK = 8; + + /** + * The Constant MOUSE_EVENT_MASK indicates the event relates to the mouse. + */ + public static final long MOUSE_EVENT_MASK = 16; + + /** + * The Constant MOUSE_MOTION_EVENT_MASK indicates the event relates to a + * mouse motion. + */ + public static final long MOUSE_MOTION_EVENT_MASK = 32; + + /** + * The Constant WINDOW_EVENT_MASK indicates the event relates to a window. + */ + public static final long WINDOW_EVENT_MASK = 64; + + /** + * The Constant ACTION_EVENT_MASK indicates the event relates to an action. + */ + public static final long ACTION_EVENT_MASK = 128; + + /** + * The Constant ADJUSTMENT_EVENT_MASK indicates the event relates to an + * adjustment. + */ + public static final long ADJUSTMENT_EVENT_MASK = 256; + + /** + * The Constant ITEM_EVENT_MASK indicates the event relates to an item. + */ + public static final long ITEM_EVENT_MASK = 512; + + /** + * The Constant TEXT_EVENT_MASK indicates the event relates to text. + */ + public static final long TEXT_EVENT_MASK = 1024; + + /** + * The Constant INPUT_METHOD_EVENT_MASK indicates the event relates to an + * input method. + */ + public static final long INPUT_METHOD_EVENT_MASK = 2048; + + /** + * The Constant PAINT_EVENT_MASK indicates the event relates to a paint + * method. + */ + public static final long PAINT_EVENT_MASK = 8192; + + /** + * The Constant INVOCATION_EVENT_MASK indicates the event relates to a + * method invocation. + */ + public static final long INVOCATION_EVENT_MASK = 16384; + + /** + * The Constant HIERARCHY_EVENT_MASK indicates the event relates to a + * hierarchy. + */ + public static final long HIERARCHY_EVENT_MASK = 32768; + + /** + * The Constant HIERARCHY_BOUNDS_EVENT_MASK indicates the event relates to + * hierarchy bounds. + */ + public static final long HIERARCHY_BOUNDS_EVENT_MASK = 65536; + + /** + * The Constant MOUSE_WHEEL_EVENT_MASK indicates the event relates to the + * mouse wheel. + */ + public static final long MOUSE_WHEEL_EVENT_MASK = 131072; + + /** + * The Constant WINDOW_STATE_EVENT_MASK indicates the event relates to a + * window state. + */ + public static final long WINDOW_STATE_EVENT_MASK = 262144; + + /** + * The Constant WINDOW_FOCUS_EVENT_MASK indicates the event relates to a + * window focus. + */ + public static final long WINDOW_FOCUS_EVENT_MASK = 524288; + + /** + * The Constant RESERVED_ID_MAX indicates the maximum value for reserved AWT + * event IDs. + */ + public static final int RESERVED_ID_MAX = 1999; + + /** + * The Constant eventsMap. + */ + private static final Hashtable<Integer, EventDescriptor> eventsMap = new Hashtable<Integer, EventDescriptor>(); + + /** + * The converter. + */ + private static EventConverter converter; + + /** + * The ID of the event. + */ + protected int id; + + /** + * The consumed indicates whether or not the event is sent back down to the + * peer once the source has processed it (false means it's sent to the peer, + * true means it's not). + */ + protected boolean consumed; + + /** + * The dispatched by kfm. + */ + boolean dispatchedByKFM; + + /** + * The is posted. + */ + transient boolean isPosted; + + static { + eventsMap.put(new Integer(KeyEvent.KEY_TYPED), new EventDescriptor(KEY_EVENT_MASK, + KeyListener.class)); + eventsMap.put(new Integer(KeyEvent.KEY_PRESSED), new EventDescriptor(KEY_EVENT_MASK, + KeyListener.class)); + eventsMap.put(new Integer(KeyEvent.KEY_RELEASED), new EventDescriptor(KEY_EVENT_MASK, + KeyListener.class)); + eventsMap.put(new Integer(MouseEvent.MOUSE_CLICKED), new EventDescriptor(MOUSE_EVENT_MASK, + MouseListener.class)); + eventsMap.put(new Integer(MouseEvent.MOUSE_PRESSED), new EventDescriptor(MOUSE_EVENT_MASK, + MouseListener.class)); + eventsMap.put(new Integer(MouseEvent.MOUSE_RELEASED), new EventDescriptor(MOUSE_EVENT_MASK, + MouseListener.class)); + eventsMap.put(new Integer(MouseEvent.MOUSE_MOVED), new EventDescriptor( + MOUSE_MOTION_EVENT_MASK, MouseMotionListener.class)); + eventsMap.put(new Integer(MouseEvent.MOUSE_ENTERED), new EventDescriptor(MOUSE_EVENT_MASK, + MouseListener.class)); + eventsMap.put(new Integer(MouseEvent.MOUSE_EXITED), new EventDescriptor(MOUSE_EVENT_MASK, + MouseListener.class)); + eventsMap.put(new Integer(MouseEvent.MOUSE_DRAGGED), new EventDescriptor( + MOUSE_MOTION_EVENT_MASK, MouseMotionListener.class)); + eventsMap.put(new Integer(MouseEvent.MOUSE_WHEEL), new EventDescriptor( + MOUSE_WHEEL_EVENT_MASK, MouseWheelListener.class)); + eventsMap.put(new Integer(ComponentEvent.COMPONENT_MOVED), new EventDescriptor( + COMPONENT_EVENT_MASK, ComponentListener.class)); + eventsMap.put(new Integer(ComponentEvent.COMPONENT_RESIZED), new EventDescriptor( + COMPONENT_EVENT_MASK, ComponentListener.class)); + eventsMap.put(new Integer(ComponentEvent.COMPONENT_SHOWN), new EventDescriptor( + COMPONENT_EVENT_MASK, ComponentListener.class)); + eventsMap.put(new Integer(ComponentEvent.COMPONENT_HIDDEN), new EventDescriptor( + COMPONENT_EVENT_MASK, ComponentListener.class)); + eventsMap.put(new Integer(FocusEvent.FOCUS_GAINED), new EventDescriptor(FOCUS_EVENT_MASK, + FocusListener.class)); + eventsMap.put(new Integer(FocusEvent.FOCUS_LOST), new EventDescriptor(FOCUS_EVENT_MASK, + FocusListener.class)); + eventsMap.put(new Integer(PaintEvent.PAINT), new EventDescriptor(PAINT_EVENT_MASK, null)); + eventsMap.put(new Integer(PaintEvent.UPDATE), new EventDescriptor(PAINT_EVENT_MASK, null)); + eventsMap.put(new Integer(WindowEvent.WINDOW_OPENED), new EventDescriptor( + WINDOW_EVENT_MASK, WindowListener.class)); + eventsMap.put(new Integer(WindowEvent.WINDOW_CLOSING), new EventDescriptor( + WINDOW_EVENT_MASK, WindowListener.class)); + eventsMap.put(new Integer(WindowEvent.WINDOW_CLOSED), new EventDescriptor( + WINDOW_EVENT_MASK, WindowListener.class)); + eventsMap.put(new Integer(WindowEvent.WINDOW_DEICONIFIED), new EventDescriptor( + WINDOW_EVENT_MASK, WindowListener.class)); + eventsMap.put(new Integer(WindowEvent.WINDOW_ICONIFIED), new EventDescriptor( + WINDOW_EVENT_MASK, WindowListener.class)); + eventsMap.put(new Integer(WindowEvent.WINDOW_STATE_CHANGED), new EventDescriptor( + WINDOW_STATE_EVENT_MASK, WindowStateListener.class)); + eventsMap.put(new Integer(WindowEvent.WINDOW_LOST_FOCUS), new EventDescriptor( + WINDOW_FOCUS_EVENT_MASK, WindowFocusListener.class)); + eventsMap.put(new Integer(WindowEvent.WINDOW_GAINED_FOCUS), new EventDescriptor( + WINDOW_FOCUS_EVENT_MASK, WindowFocusListener.class)); + eventsMap.put(new Integer(WindowEvent.WINDOW_DEACTIVATED), new EventDescriptor( + WINDOW_EVENT_MASK, WindowListener.class)); + eventsMap.put(new Integer(WindowEvent.WINDOW_ACTIVATED), new EventDescriptor( + WINDOW_EVENT_MASK, WindowListener.class)); + eventsMap.put(new Integer(HierarchyEvent.HIERARCHY_CHANGED), new EventDescriptor( + HIERARCHY_EVENT_MASK, HierarchyListener.class)); + eventsMap.put(new Integer(HierarchyEvent.ANCESTOR_MOVED), new EventDescriptor( + HIERARCHY_BOUNDS_EVENT_MASK, HierarchyBoundsListener.class)); + eventsMap.put(new Integer(HierarchyEvent.ANCESTOR_RESIZED), new EventDescriptor( + HIERARCHY_BOUNDS_EVENT_MASK, HierarchyBoundsListener.class)); + eventsMap.put(new Integer(ContainerEvent.COMPONENT_ADDED), new EventDescriptor( + CONTAINER_EVENT_MASK, ContainerListener.class)); + eventsMap.put(new Integer(ContainerEvent.COMPONENT_REMOVED), new EventDescriptor( + CONTAINER_EVENT_MASK, ContainerListener.class)); + eventsMap.put(new Integer(InputMethodEvent.INPUT_METHOD_TEXT_CHANGED), new EventDescriptor( + INPUT_METHOD_EVENT_MASK, InputMethodListener.class)); + eventsMap.put(new Integer(InputMethodEvent.CARET_POSITION_CHANGED), new EventDescriptor( + INPUT_METHOD_EVENT_MASK, InputMethodListener.class)); + eventsMap.put(new Integer(InvocationEvent.INVOCATION_DEFAULT), new EventDescriptor( + INVOCATION_EVENT_MASK, null)); + eventsMap.put(new Integer(ItemEvent.ITEM_STATE_CHANGED), new EventDescriptor( + ITEM_EVENT_MASK, ItemListener.class)); + eventsMap.put(new Integer(TextEvent.TEXT_VALUE_CHANGED), new EventDescriptor( + TEXT_EVENT_MASK, TextListener.class)); + eventsMap.put(new Integer(ActionEvent.ACTION_PERFORMED), new EventDescriptor( + ACTION_EVENT_MASK, ActionListener.class)); + eventsMap.put(new Integer(AdjustmentEvent.ADJUSTMENT_VALUE_CHANGED), new EventDescriptor( + ADJUSTMENT_EVENT_MASK, AdjustmentListener.class)); + converter = new EventConverter(); + } + + /** + * Instantiates a new AWT event from the specified Event object. + * + * @param event + * the Event object. + */ + public AWTEvent(Event event) { + this(event.target, event.id); + } + + /** + * Instantiates a new AWT event with the specified object and type. + * + * @param source + * the source Object. + * @param id + * the event's type. + */ + public AWTEvent(Object source, int id) { + super(source); + this.id = id; + consumed = false; + } + + /** + * Gets the event's type. + * + * @return the event type ID. + */ + public int getID() { + return id; + } + + /** + * Sets a new source for the AWTEvent. + * + * @param newSource + * the new source Object for the AWTEvent. + */ + public void setSource(Object newSource) { + source = newSource; + } + + /** + * Returns a String representation of the AWTEvent. + * + * @return the String representation of the AWTEvent. + */ + @Override + public String toString() { + /* + * The format is based on 1.5 release behavior which can be revealed by + * the following code: AWTEvent event = new AWTEvent(new Component(){}, + * 1){}; System.out.println(event); + */ + String name = ""; //$NON-NLS-1$ + + if (source instanceof Component && (source != null)) { + Component comp = (Component)getSource(); + name = comp.getName(); + if (name == null) { + name = ""; //$NON-NLS-1$ + } + } + + return (getClass().getName() + "[" + paramString() + "]" //$NON-NLS-1$ //$NON-NLS-2$ + + " on " + (name.length() > 0 ? name : source)); //$NON-NLS-1$ + } + + /** + * Returns a string representation of the AWTEvent state. + * + * @return a string representation of the AWTEvent state. + */ + public String paramString() { + // nothing to implement: all event types must override this method + return ""; //$NON-NLS-1$ + } + + /** + * Checks whether or not this AWTEvent has been consumed. + * + * @return true, if this AWTEvent has been consumed, false otherwise. + */ + protected boolean isConsumed() { + return consumed; + } + + /** + * Consumes the AWTEvent. + */ + protected void consume() { + consumed = true; + } + + /** + * Convert AWTEvent object to a corresponding (deprecated) Event object. + * + * @return new Event object which is a converted AWTEvent object or null if + * the conversion is not possible + */ + Event getEvent() { + + if (id == ActionEvent.ACTION_PERFORMED) { + ActionEvent ae = (ActionEvent)this; + return converter.convertActionEvent(ae); + + } else if (id == AdjustmentEvent.ADJUSTMENT_VALUE_CHANGED) { + AdjustmentEvent ae = (AdjustmentEvent)this; + return converter.convertAdjustmentEvent(ae); + + // ???AWT + // } else if (id == ComponentEvent.COMPONENT_MOVED + // && source instanceof Window) { + // //the only type of Component events is COMPONENT_MOVED on window + // ComponentEvent ce = (ComponentEvent) this; + // return converter.convertComponentEvent(ce); + + } else if (id >= FocusEvent.FOCUS_FIRST && id <= FocusEvent.FOCUS_LAST) { + // nothing to convert + + // ???AWT + // } else if (id == ItemEvent.ITEM_STATE_CHANGED) { + // ItemEvent ie = (ItemEvent) this; + // return converter.convertItemEvent(ie); + + } else if (id == KeyEvent.KEY_PRESSED || id == KeyEvent.KEY_RELEASED) { + KeyEvent ke = (KeyEvent)this; + return converter.convertKeyEvent(ke); + } else if (id >= MouseEvent.MOUSE_FIRST && id <= MouseEvent.MOUSE_LAST) { + MouseEvent me = (MouseEvent)this; + return converter.convertMouseEvent(me); + } else if (id == WindowEvent.WINDOW_CLOSING || id == WindowEvent.WINDOW_ICONIFIED + || id == WindowEvent.WINDOW_DEICONIFIED) { + // nothing to convert + } else { + return null; + } + return new Event(source, id, null); + } + + /** + * The class EventDescriptor. + */ + static final class EventDescriptor { + + /** + * The event mask. + */ + final long eventMask; + + /** + * The listener type. + */ + final Class<? extends EventListener> listenerType; + + /** + * Instantiates a new event descriptor. + * + * @param eventMask + * the event mask. + * @param listenerType + * the listener type. + */ + EventDescriptor(long eventMask, Class<? extends EventListener> listenerType) { + this.eventMask = eventMask; + this.listenerType = listenerType; + } + + } + + /** + * The class EventTypeLookup. + */ + static final class EventTypeLookup { + + /** + * The last event. + */ + private AWTEvent lastEvent = null; + + /** + * The last event descriptor. + */ + private EventDescriptor lastEventDescriptor = null; + + /** + * Gets the event descriptor. + * + * @param event + * the event. + * @return the event descriptor. + */ + EventDescriptor getEventDescriptor(AWTEvent event) { + synchronized (this) { + if (event != lastEvent) { + lastEvent = event; + lastEventDescriptor = eventsMap.get(new Integer(event.id)); + } + + return lastEventDescriptor; + } + } + + /** + * Gets the event mask. + * + * @param event + * the event. + * @return the event mask. + */ + long getEventMask(AWTEvent event) { + final EventDescriptor ed = getEventDescriptor(event); + return ed == null ? -1 : ed.eventMask; + } + } + + /** + * The class EventConverter. + */ + static final class EventConverter { + + /** + * The constant OLD_MOD_MASK. + */ + static final int OLD_MOD_MASK = Event.ALT_MASK | Event.CTRL_MASK | Event.META_MASK + | Event.SHIFT_MASK; + + /** + * Convert action event. + * + * @param ae + * the ae. + * @return the event. + */ + Event convertActionEvent(ActionEvent ae) { + Event evt = new Event(ae.getSource(), ae.getID(), ae.getActionCommand()); + evt.when = ae.getWhen(); + evt.modifiers = ae.getModifiers() & OLD_MOD_MASK; + + /* + * if (source instanceof Button) { arg = ((Button) + * source).getLabel(); } else if (source instanceof Checkbox) { arg + * = new Boolean(((Checkbox) source).getState()); } else if (source + * instanceof CheckboxMenuItem) { arg = ((CheckboxMenuItem) + * source).getLabel(); } else if (source instanceof Choice) { arg = + * ((Choice) source).getSelectedItem(); } else if (source instanceof + * List) { arg = ((List) source).getSelectedItem(); } else if + * (source instanceof MenuItem) { arg = ((MenuItem) + * source).getLabel(); } else if (source instanceof TextField) { arg + * = ((TextField) source).getText(); } + */ + return evt; + } + + /** + * Convert adjustment event. + * + * @param ae + * the ae. + * @return the event. + */ + Event convertAdjustmentEvent(AdjustmentEvent ae) { + // TODO: Event.SCROLL_BEGIN/SCROLL_END + return new Event(ae.source, ae.id + ae.getAdjustmentType() - 1, new Integer(ae + .getValue())); + } + + /** + * Convert component event. + * + * @param ce + * the ce. + * @return the event. + */ + Event convertComponentEvent(ComponentEvent ce) { + Component comp = ce.getComponent(); + Event evt = new Event(comp, Event.WINDOW_MOVED, null); + evt.x = comp.getX(); + evt.y = comp.getY(); + return evt; + } + + // ???AWT + /* + * Event convertItemEvent(ItemEvent ie) { int oldId = ie.id + + * ie.getStateChange() - 1; Object source = ie.source; int idx = -1; if + * (source instanceof List) { List list = (List) source; idx = + * list.getSelectedIndex(); } else if (source instanceof Choice) { + * Choice choice = (Choice) source; idx = choice.getSelectedIndex(); } + * Object arg = idx >= 0 ? new Integer(idx) : null; return new + * Event(source, oldId, arg); } + */ + + /** + * Convert key event. + * + * @param ke + * the ke. + * @return the event. + */ + Event convertKeyEvent(KeyEvent ke) { + int oldId = ke.id; + // leave only old Event's modifiers + + int mod = ke.getModifiers() & OLD_MOD_MASK; + Component comp = ke.getComponent(); + char keyChar = ke.getKeyChar(); + int keyCode = ke.getKeyCode(); + int key = convertKey(keyChar, keyCode); + if (key >= Event.HOME && key <= Event.INSERT) { + oldId += 2; // non-ASCII key -> action key + } + return new Event(comp, ke.getWhen(), oldId, 0, 0, key, mod); + } + + /** + * Convert mouse event. + * + * @param me + * the me. + * @return the event. + */ + Event convertMouseEvent(MouseEvent me) { + int id = me.id; + if (id != MouseEvent.MOUSE_CLICKED) { + Event evt = new Event(me.source, id, null); + evt.x = me.getX(); + evt.y = me.getY(); + int mod = me.getModifiers(); + // in Event modifiers mean button number for mouse events: + evt.modifiers = mod & (Event.ALT_MASK | Event.META_MASK); + if (id == MouseEvent.MOUSE_PRESSED) { + evt.clickCount = me.getClickCount(); + } + return evt; + } + return null; + } + + /** + * Convert key. + * + * @param keyChar + * the key char. + * @param keyCode + * the key code. + * @return the int. + */ + int convertKey(char keyChar, int keyCode) { + int key; + // F1 - F12 + if (keyCode >= KeyEvent.VK_F1 && keyCode <= KeyEvent.VK_F12) { + key = Event.F1 + keyCode - KeyEvent.VK_F1; + } else { + switch (keyCode) { + default: // non-action key + key = keyChar; + break; + // action keys: + case KeyEvent.VK_HOME: + key = Event.HOME; + break; + case KeyEvent.VK_END: + key = Event.END; + break; + case KeyEvent.VK_PAGE_UP: + key = Event.PGUP; + break; + case KeyEvent.VK_PAGE_DOWN: + key = Event.PGDN; + break; + case KeyEvent.VK_UP: + key = Event.UP; + break; + case KeyEvent.VK_DOWN: + key = Event.DOWN; + break; + case KeyEvent.VK_LEFT: + key = Event.LEFT; + break; + case KeyEvent.VK_RIGHT: + key = Event.RIGHT; + break; + case KeyEvent.VK_PRINTSCREEN: + key = Event.PRINT_SCREEN; + break; + case KeyEvent.VK_SCROLL_LOCK: + key = Event.SCROLL_LOCK; + break; + case KeyEvent.VK_CAPS_LOCK: + key = Event.CAPS_LOCK; + break; + case KeyEvent.VK_NUM_LOCK: + key = Event.NUM_LOCK; + break; + case KeyEvent.VK_PAUSE: + key = Event.PAUSE; + break; + case KeyEvent.VK_INSERT: + key = Event.INSERT; + break; + } + } + return key; + } + + } + +} |