619 lines
23 KiB
Java
619 lines
23 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 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;
|
|
}
|
|
|
|
}
|
|
|
|
}
|