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