void forwardKeyEvent(KeyEvent e) {
xembedLog.fine("Try to forward key event");
byte[] bdata = getBData(e);
long data = Native.toData(bdata);
if (data == 0) {
return;
}
try {
XKeyEvent ke = new XKeyEvent(data);
ke.set_window(xembed.handle);
if (xembedLog.isLoggable(PlatformLogger.FINE))
xembedLog.fine("Forwarding native key event: " + ke);
XToolkit.awtLock();
try {
XlibWrapper.XSendEvent(
XToolkit.getDisplay(), xembed.handle, false, XConstants.NoEventMask, data);
} finally {
XToolkit.awtUnlock();
}
} finally {
XlibWrapper.unsafe.freeMemory(data);
}
}
private void init(KeyEvent e) {
byte[] bdata = getBData(e);
long data = Native.toData(bdata);
if (data == 0) {
return;
}
try {
XToolkit.awtLock();
try {
keysym = XWindow.getKeySymForAWTKeyCode(e.getKeyCode());
} finally {
XToolkit.awtUnlock();
}
XKeyEvent ke = new XKeyEvent(data);
// We recognize only these masks
modifiers =
ke.get_state() & (XConstants.ShiftMask | XConstants.ControlMask | XConstants.LockMask);
if (xembedLog.isLoggable(PlatformLogger.FINEST))
xembedLog.finest("Mapped " + e + " to " + this);
} finally {
XlibWrapper.unsafe.freeMemory(data);
}
}
/**
* The caller must own awtLock.
*
* @returns true if the even was processed and shouldn't be passed along.
*/
private boolean doProcessEvent(XEvent ev) {
assert XToolkit.isAWTLockHeldByCurrentThread();
if (processProxyModeEvent(ev)) {
return true;
}
if (!dndInProgress) {
return false;
}
switch (ev.get_type()) {
case XConstants.ClientMessage:
{
XClientMessageEvent xclient = ev.get_xclient();
return processClientMessage(xclient);
}
case XConstants.DestroyNotify:
{
XDestroyWindowEvent xde = ev.get_xdestroywindow();
/* Target crashed during drop processing - cleanup. */
if (!dragInProgress
&& dragProtocol != null
&& xde.get_window() == dragProtocol.getTargetWindow()) {
cleanup(XConstants.CurrentTime);
return true;
}
/* Pass along */
return false;
}
}
if (!dragInProgress) {
return false;
}
/* Process drag-only messages. */
switch (ev.get_type()) {
case XConstants.KeyRelease:
case XConstants.KeyPress:
{
XKeyEvent xkey = ev.get_xkey();
long keysym = XlibWrapper.XKeycodeToKeysym(XToolkit.getDisplay(), xkey.get_keycode(), 0);
switch ((int) keysym) {
case (int) XKeySymConstants.XK_Escape:
{
if (ev.get_type() == (int) XConstants.KeyRelease) {
cleanup(xkey.get_time());
}
break;
}
case (int) XKeySymConstants.XK_Control_R:
case (int) XKeySymConstants.XK_Control_L:
case (int) XKeySymConstants.XK_Shift_R:
case (int) XKeySymConstants.XK_Shift_L:
{
XlibWrapper.XQueryPointer(
XToolkit.getDisplay(),
xkey.get_root(),
XlibWrapper.larg1, // root
XlibWrapper.larg2, // subwindow
XlibWrapper.larg3, // x_root
XlibWrapper.larg4, // y_root
XlibWrapper.larg5, // x
XlibWrapper.larg6, // y
XlibWrapper.larg7); // modifiers
XMotionEvent xmotion = new XMotionEvent();
try {
xmotion.set_type(XConstants.MotionNotify);
xmotion.set_serial(xkey.get_serial());
xmotion.set_send_event(xkey.get_send_event());
xmotion.set_display(xkey.get_display());
xmotion.set_window(xkey.get_window());
xmotion.set_root(xkey.get_root());
xmotion.set_subwindow(xkey.get_subwindow());
xmotion.set_time(xkey.get_time());
xmotion.set_x(xkey.get_x());
xmotion.set_y(xkey.get_y());
xmotion.set_x_root(xkey.get_x_root());
xmotion.set_y_root(xkey.get_y_root());
xmotion.set_state((int) Native.getLong(XlibWrapper.larg7));
// we do not use this field, so it's unset for now
// xmotion.set_is_hint(???);
xmotion.set_same_screen(xkey.get_same_screen());
// It's safe to use key event as motion event since we use only their common
// fields.
processMouseMove(xmotion);
} finally {
xmotion.dispose();
}
break;
}
}
return true;
}
case XConstants.ButtonPress:
return true;
case XConstants.MotionNotify:
processMouseMove(ev.get_xmotion());
return true;
case XConstants.ButtonRelease:
{
XButtonEvent xbutton = ev.get_xbutton();
/*
* Ignore the buttons above 20 due to the bit limit for
* InputEvent.BUTTON_DOWN_MASK.
* One more bit is reserved for FIRST_HIGH_BIT.
*/
if (xbutton.get_button() > SunToolkit.MAX_BUTTONS_SUPPORTED) {
return true;
}
/*
* On some X servers it could happen that ButtonRelease coordinates
* differ from the latest MotionNotify coordinates, so we need to
* process it as a mouse motion.
*/
XMotionEvent xmotion = new XMotionEvent();
try {
xmotion.set_type(XConstants.MotionNotify);
xmotion.set_serial(xbutton.get_serial());
xmotion.set_send_event(xbutton.get_send_event());
xmotion.set_display(xbutton.get_display());
xmotion.set_window(xbutton.get_window());
xmotion.set_root(xbutton.get_root());
xmotion.set_subwindow(xbutton.get_subwindow());
xmotion.set_time(xbutton.get_time());
xmotion.set_x(xbutton.get_x());
xmotion.set_y(xbutton.get_y());
xmotion.set_x_root(xbutton.get_x_root());
xmotion.set_y_root(xbutton.get_y_root());
xmotion.set_state(xbutton.get_state());
// we do not use this field, so it's unset for now
// xmotion.set_is_hint(???);
xmotion.set_same_screen(xbutton.get_same_screen());
// It's safe to use key event as motion event since we use only their common fields.
processMouseMove(xmotion);
} finally {
xmotion.dispose();
}
if (xbutton.get_button() == XConstants.buttons[0]
|| xbutton.get_button() == XConstants.buttons[1]) {
// drag is initiated with Button1 or Button2 pressed and
// ended on release of either of these buttons (as the same
// behavior was with our old Motif DnD-based implementation)
removeDnDGrab(xbutton.get_time());
dragInProgress = false;
if (dragProtocol != null && targetAction != DnDConstants.ACTION_NONE) {
/*
* ACTION_NONE indicates that either the drop target rejects the
* drop or it haven't responded yet. The latter could happen in
* case of fast drag, slow target-server connection or slow
* drag notifications processing on the target side.
*/
processDrop(xbutton);
} else {
cleanup(xbutton.get_time());
}
}
return true;
}
}
return false;
}