diff options
Diffstat (limited to 'awt/java/awt/AWTEvent.java')
| -rw-r--r-- | awt/java/awt/AWTEvent.java | 618 |
1 files changed, 618 insertions, 0 deletions
diff --git a/awt/java/awt/AWTEvent.java b/awt/java/awt/AWTEvent.java new file mode 100644 index 0000000..1ed9a37 --- /dev/null +++ b/awt/java/awt/AWTEvent.java @@ -0,0 +1,618 @@ +/* + * 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 AWT events is base class for all AWT events. + * This class and its subclasses supercede the original java.awt.Event class. + */ +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; + } + + } + +} |