682 lines
24 KiB
Java
682 lines
24 KiB
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.
|
|
*/
|
|
/**
|
|
* @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;
|
|
}
|
|
|
|
}
|
|
|
|
}
|