1 /*
2 * Copyright (c) 2003, 2015, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package sun.awt.X11;
27
28 import java.awt.Component;
29 import java.awt.Cursor;
30 import java.awt.Window;
31
32 import java.awt.datatransfer.DataFlavor;
33 import java.awt.datatransfer.Transferable;
34
35 import java.awt.dnd.DnDConstants;
36 import java.awt.dnd.DragGestureEvent;
37 import java.awt.dnd.InvalidDnDOperationException;
38
39 import java.util.*;
40
41 import sun.util.logging.PlatformLogger;
42
43 import sun.awt.dnd.SunDragSourceContextPeer;
44 import sun.awt.dnd.SunDropTargetContextPeer;
45 import sun.awt.SunToolkit;
46 import sun.awt.AWTAccessor;
47
48 /**
49 * The XDragSourceContextPeer class is the class responsible for handling
50 * the interaction between the XDnD/Motif DnD subsystem and Java drag sources.
51 *
52 * @since 1.5
53 */
54 public final class XDragSourceContextPeer
55 extends SunDragSourceContextPeer implements XDragSourceProtocolListener {
56 private static final PlatformLogger logger =
57 PlatformLogger.getLogger("sun.awt.X11.xembed.xdnd.XDragSourceContextPeer");
58
59 /* The events selected on the root window when the drag begins. */
60 private static final int ROOT_EVENT_MASK = (int)XConstants.ButtonMotionMask |
61 (int)XConstants.KeyPressMask | (int)XConstants.KeyReleaseMask;
62 /* The events to be delivered during grab. */
63 private static final int GRAB_EVENT_MASK = (int)XConstants.ButtonPressMask |
64 (int)XConstants.ButtonMotionMask | (int)XConstants.ButtonReleaseMask;
65
66 /* The event mask of the root window before the drag operation starts. */
67 private long rootEventMask = 0;
68 private boolean dndInProgress = false;
69 private boolean dragInProgress = false;
70 private long dragRootWindow = 0;
71
72 /* The protocol chosen for the communication with the current drop target. */
73 private XDragSourceProtocol dragProtocol = null;
74 /* The drop action chosen by the current drop target. */
75 private int targetAction = DnDConstants.ACTION_NONE;
76 /* The set of drop actions supported by the drag source. */
77 private int sourceActions = DnDConstants.ACTION_NONE;
78 /* The drop action selected by the drag source based on the modifiers state
79 and the action selected by the current drop target. */
80 private int sourceAction = DnDConstants.ACTION_NONE;
81 /* The data formats supported by the drag source for the current drag
82 operation. */
83 private long[] sourceFormats = null;
84 /* The XID of the root subwindow that contains the current target. */
85 private long targetRootSubwindow = 0;
86 /* window scale factor */
87 int windowScale = 1;
88 /* The pointer location. */
89 private int xRoot = 0;
90 private int yRoot = 0;
91 /* Keyboard modifiers state. */
92 private int eventState = 0;
93
94 /* XEmbed DnD support. We act as a proxy between source and target. */
95 private long proxyModeSourceWindow = 0;
96
97 /* The singleton instance. */
98 private static final XDragSourceContextPeer theInstance =
99 new XDragSourceContextPeer(null);
100
101 private XDragSourceContextPeer(DragGestureEvent dge) {
102 super(dge);
103 }
104
105 static XDragSourceProtocolListener getXDragSourceProtocolListener() {
106 return theInstance;
107 }
108
109 static XDragSourceContextPeer createDragSourceContextPeer(DragGestureEvent dge)
110 throws InvalidDnDOperationException {
111 theInstance.setTrigger(dge);
112 return theInstance;
113 }
114
115 protected void startDrag(Transferable transferable,
116 long[] formats, Map<Long, DataFlavor> formatMap) {
117 Component component = getTrigger().getComponent();
118 Component c = null;
119 XWindowPeer wpeer = null;
120
121 for (c = component; c != null && !(c instanceof Window);
122 c = AWTAccessor.getComponentAccessor().getParent(c));
123
124 if (c instanceof Window) {
125 wpeer = AWTAccessor.getComponentAccessor().getPeer(c);
126 }
127
128 if (wpeer == null) {
129 throw new InvalidDnDOperationException(
130 "Cannot find top-level for the drag source component");
131 }
132
133 long xcursor = 0;
134 long rootWindow = 0;
135 long timeStamp = 0;
136 windowScale = wpeer.getScale();
137
138 /* Retrieve the X cursor for the drag operation. */
139 {
140 Cursor cursor = getCursor();
141 if (cursor != null) {
142 xcursor = XGlobalCursorManager.getCursor(cursor);
143 }
144 }
145
146 XToolkit.awtLock();
147 try {
148 if (proxyModeSourceWindow != 0) {
149 throw new InvalidDnDOperationException("Proxy drag in progress");
150 }
151 if (dndInProgress) {
152 throw new InvalidDnDOperationException("Drag in progress");
153 }
154
155 /* Determine the root window for the drag operation. */
156 {
157 long screen = XlibWrapper.XScreenNumberOfScreen(wpeer.getScreen());
158 rootWindow = XlibWrapper.RootWindow(XToolkit.getDisplay(), screen);
159 }
160
161 timeStamp = XToolkit.getCurrentServerTime();
162
163 int dropActions = getDragSourceContext().getSourceActions();
164
165 Iterator<XDragSourceProtocol> dragProtocols =
166 XDragAndDropProtocols.getDragSourceProtocols();
167 while (dragProtocols.hasNext()) {
168 XDragSourceProtocol dragProtocol = dragProtocols.next();
169 try {
170 dragProtocol.initializeDrag(dropActions, transferable,
171 formatMap, formats);
172 } catch (XException xe) {
173 throw (InvalidDnDOperationException)
174 new InvalidDnDOperationException().initCause(xe);
175 }
176 }
177
178 /* Install X grabs. */
179 {
180 int status;
181 XWindowAttributes wattr = new XWindowAttributes();
182 try {
183 status = XlibWrapper.XGetWindowAttributes(XToolkit.getDisplay(),
184 rootWindow, wattr.pData);
185
186 if (status == 0) {
187 throw new InvalidDnDOperationException("XGetWindowAttributes failed");
188 }
189
190 rootEventMask = wattr.get_your_event_mask();
191
192 XlibWrapper.XSelectInput(XToolkit.getDisplay(), rootWindow,
193 rootEventMask | ROOT_EVENT_MASK);
194 } finally {
195 wattr.dispose();
196 }
197
198 XBaseWindow.ungrabInput();
199
200 status = XlibWrapper.XGrabPointer(XToolkit.getDisplay(), rootWindow,
201 0, GRAB_EVENT_MASK,
202 XConstants.GrabModeAsync,
203 XConstants.GrabModeAsync,
204 XConstants.None, xcursor, timeStamp);
205
206 if (status != XConstants.GrabSuccess) {
207 cleanup(timeStamp);
208 throwGrabFailureException("Cannot grab pointer", status);
209 return;
210 }
211
212 status = XlibWrapper.XGrabKeyboard(XToolkit.getDisplay(), rootWindow,
213 0,
214 XConstants.GrabModeAsync,
215 XConstants.GrabModeAsync,
216 timeStamp);
217
218 if (status != XConstants.GrabSuccess) {
219 cleanup(timeStamp);
220 throwGrabFailureException("Cannot grab keyboard", status);
221 return;
222 }
223 }
224
225 /* Update the global state. */
226 dndInProgress = true;
227 dragInProgress = true;
228 dragRootWindow = rootWindow;
229 sourceActions = dropActions;
230 sourceFormats = formats;
231 } finally {
232 XToolkit.awtUnlock();
233 }
234
235 /* This implementation doesn't use native context */
236 setNativeContext(0);
237
238 SunDropTargetContextPeer.setCurrentJVMLocalSourceTransferable(transferable);
239 }
240
241 public long getProxyModeSourceWindow() {
242 return proxyModeSourceWindow;
243 }
244
245 private void setProxyModeSourceWindowImpl(long window) {
246 proxyModeSourceWindow = window;
247 }
248
249 public static void setProxyModeSourceWindow(long window) {
250 theInstance.setProxyModeSourceWindowImpl(window);
251 }
252
253 /**
254 * set cursor
255 */
256
257 public void setCursor(Cursor c) throws InvalidDnDOperationException {
258 XToolkit.awtLock();
259 try {
260 super.setCursor(c);
261 } finally {
262 XToolkit.awtUnlock();
263 }
264 }
265
266 protected void setNativeCursor(long nativeCtxt, Cursor c, int cType) {
267 assert XToolkit.isAWTLockHeldByCurrentThread();
268
269 if (c == null) {
270 return;
271 }
272
273 long xcursor = XGlobalCursorManager.getCursor(c);
274
275 if (xcursor == 0) {
276 return;
277 }
278
279 XlibWrapper.XChangeActivePointerGrab(XToolkit.getDisplay(),
280 GRAB_EVENT_MASK,
281 xcursor,
282 XConstants.CurrentTime);
283 }
284
285 protected boolean needsBogusExitBeforeDrop() {
286 return false;
287 }
288
289 private void throwGrabFailureException(String msg, int grabStatus)
290 throws InvalidDnDOperationException {
291 String msgCause = "";
292 switch (grabStatus) {
293 case XConstants.GrabNotViewable: msgCause = "not viewable"; break;
294 case XConstants.AlreadyGrabbed: msgCause = "already grabbed"; break;
295 case XConstants.GrabInvalidTime: msgCause = "invalid time"; break;
296 case XConstants.GrabFrozen: msgCause = "grab frozen"; break;
297 default: msgCause = "unknown failure"; break;
298 }
299 throw new InvalidDnDOperationException(msg + ": " + msgCause);
300 }
301
302 /**
303 * The caller must own awtLock.
304 */
305 public void cleanup(long time) {
306 if (dndInProgress) {
307 if (dragProtocol != null) {
308 dragProtocol.sendLeaveMessage(time);
309 }
310
311 if (targetAction != DnDConstants.ACTION_NONE) {
312 dragExit(xRoot, yRoot);
313 }
314
315 dragDropFinished(false, DnDConstants.ACTION_NONE, xRoot, yRoot);
316 }
317
318 Iterator<XDragSourceProtocol> dragProtocols =
319 XDragAndDropProtocols.getDragSourceProtocols();
320 while (dragProtocols.hasNext()) {
321 XDragSourceProtocol dragProtocol = dragProtocols.next();
322 try {
323 dragProtocol.cleanup();
324 } catch (XException xe) {
325 // Ignore the exception.
326 }
327 }
328
329 dndInProgress = false;
330 dragInProgress = false;
331 dragRootWindow = 0;
332 sourceFormats = null;
333 sourceActions = DnDConstants.ACTION_NONE;
334 sourceAction = DnDConstants.ACTION_NONE;
335 eventState = 0;
336 xRoot = 0;
337 yRoot = 0;
338
339 cleanupTargetInfo();
340
341 removeDnDGrab(time);
342 }
343
344 /**
345 * The caller must own awtLock.
346 */
347 private void cleanupTargetInfo() {
348 targetAction = DnDConstants.ACTION_NONE;
349 dragProtocol = null;
350 targetRootSubwindow = 0;
351 }
352
353 private void removeDnDGrab(long time) {
354 assert XToolkit.isAWTLockHeldByCurrentThread();
355
356 XlibWrapper.XUngrabPointer(XToolkit.getDisplay(), time);
357 XlibWrapper.XUngrabKeyboard(XToolkit.getDisplay(), time);
358
359 /* Restore the root event mask if it was changed. */
360 if ((rootEventMask | ROOT_EVENT_MASK) != rootEventMask &&
361 dragRootWindow != 0) {
362
363 XlibWrapper.XSelectInput(XToolkit.getDisplay(),
364 dragRootWindow,
365 rootEventMask);
366 }
367
368 rootEventMask = 0;
369 dragRootWindow = 0;
370 }
371
372 private boolean processClientMessage(XClientMessageEvent xclient) {
373 if (dragProtocol != null) {
374 return dragProtocol.processClientMessage(xclient);
375 }
376 return false;
377 }
378
379 /**
380 * Updates the source action according to the specified state.
381 *
382 * @return true if the source
383 */
384 private boolean updateSourceAction(int state) {
385 int action = SunDragSourceContextPeer.convertModifiersToDropAction(XWindow.getModifiers(state, 0, 0),
386 sourceActions);
387 if (sourceAction == action) {
388 return false;
389 }
390 sourceAction = action;
391 return true;
392 }
393
394 /**
395 * Returns the client window under the specified root subwindow.
396 */
397 private static long findClientWindow(long window) {
398 if (XlibUtil.isTrueToplevelWindow(window)) {
399 return window;
400 }
401
402 Set<Long> children = XlibUtil.getChildWindows(window);
403 for (Long child : children) {
404 long win = findClientWindow(child);
405 if (win != 0) {
406 return win;
407 }
408 }
409
410 return 0;
411 }
412
413 private void doUpdateTargetWindow(long subwindow, long time) {
414 long clientWindow = 0;
415 long proxyWindow = 0;
416 XDragSourceProtocol protocol = null;
417 boolean isReceiver = false;
418
419 if (subwindow != 0) {
420 clientWindow = findClientWindow(subwindow);
421 }
422
423 if (clientWindow != 0) {
424 Iterator<XDragSourceProtocol> dragProtocols =
425 XDragAndDropProtocols.getDragSourceProtocols();
426 while (dragProtocols.hasNext()) {
427 XDragSourceProtocol dragProtocol = dragProtocols.next();
428 if (dragProtocol.attachTargetWindow(clientWindow, time)) {
429 protocol = dragProtocol;
430 break;
431 }
432 }
433 }
434
435 /* Update the global state. */
436 dragProtocol = protocol;
437 targetAction = DnDConstants.ACTION_NONE;
438 targetRootSubwindow = subwindow;
439 }
440
441 private void updateTargetWindow(XMotionEvent xmotion) {
442 assert XToolkit.isAWTLockHeldByCurrentThread();
443
444 int x = scaleDown(xmotion.get_x_root());
445 int y = scaleDown(xmotion.get_y_root());
446 long time = xmotion.get_time();
447 long subwindow = xmotion.get_subwindow();
448
449 /*
450 * If this event had occurred before the pointer was grabbed,
451 * query the server for the current root subwindow.
452 */
453 if (xmotion.get_window() != xmotion.get_root()) {
454 XlibWrapper.XQueryPointer(XToolkit.getDisplay(),
455 xmotion.get_root(),
456 XlibWrapper.larg1, // root
457 XlibWrapper.larg2, // subwindow
458 XlibWrapper.larg3, // x_root
459 XlibWrapper.larg4, // y_root
460 XlibWrapper.larg5, // x
461 XlibWrapper.larg6, // y
462 XlibWrapper.larg7); // modifiers
463 subwindow = Native.getLong(XlibWrapper.larg2);
464 }
465
466 if (targetRootSubwindow != subwindow) {
467 if (dragProtocol != null) {
468 dragProtocol.sendLeaveMessage(time);
469
470 /*
471 * Neither Motif DnD nor XDnD provide a mean for the target
472 * to notify the source that the pointer exits the drop site
473 * that occupies the whole top level.
474 * We detect this situation and post dragExit.
475 */
476 if (targetAction != DnDConstants.ACTION_NONE) {
477 dragExit(x, y);
478 }
479 }
480
481 /* Update the global state. */
482 doUpdateTargetWindow(subwindow, time);
483
484 if (dragProtocol != null) {
485 dragProtocol.sendEnterMessage(sourceFormats,
486 sourceAction,
487 sourceActions,
488 time);
489 }
490 }
491 }
492
493 /*
494 * DO NOT USE is_hint field of xmotion since it could not be set when we
495 * convert XKeyEvent or XButtonRelease to XMotionEvent.
496 */
497 private void processMouseMove(XMotionEvent xmotion) {
498 if (!dragInProgress) {
499 return;
500 }
501
502 int motionXRoot = scaleDown(xmotion.get_x_root());
503 int motionYRoot = scaleDown(xmotion.get_y_root());
504
505 if (xRoot != motionXRoot || yRoot != motionYRoot) {
506 xRoot = motionXRoot;
507 yRoot = motionYRoot;
508
509 postDragSourceDragEvent(targetAction,
510 XWindow.getModifiers(xmotion.get_state(),0,0),
511 xRoot, yRoot, DISPATCH_MOUSE_MOVED);
512 }
513
514 if (eventState != xmotion.get_state()) {
515 if (updateSourceAction(xmotion.get_state()) && dragProtocol != null) {
516 postDragSourceDragEvent(targetAction,
517 XWindow.getModifiers(xmotion.get_state(),0,0),
518 xRoot, yRoot, DISPATCH_CHANGED);
519 }
520 eventState = xmotion.get_state();
521 }
522
523 updateTargetWindow(xmotion);
524
525 if (dragProtocol != null) {
526 dragProtocol.sendMoveMessage(scaleDown(xmotion.get_x_root()),
527 scaleDown(xmotion.get_y_root()),
528 sourceAction, sourceActions,
529 xmotion.get_time());
530 }
531 }
532
533 private void processDrop(XButtonEvent xbutton) {
534 try {
535 dragProtocol.initiateDrop(scaleDown(xbutton.get_x_root()),
536 scaleDown(xbutton.get_y_root()),
537 sourceAction, sourceActions,
538 xbutton.get_time());
539 } catch (XException e) {
540 cleanup(xbutton.get_time());
541 }
542 }
543
544 private boolean processProxyModeEvent(XEvent ev) {
545 if (getProxyModeSourceWindow() == 0) {
546 return false;
547 }
548
549 if (ev.get_type() != XConstants.ClientMessage) {
550 return false;
551 }
552
553 if (logger.isLoggable(PlatformLogger.Level.FINEST)) {
554 logger.finest(" proxyModeSourceWindow=" +
555 getProxyModeSourceWindow() +
556 " ev=" + ev);
557 }
558
559 XClientMessageEvent xclient = ev.get_xclient();
560
561 Iterator<XDragSourceProtocol> dragProtocols =
562 XDragAndDropProtocols.getDragSourceProtocols();
563 while (dragProtocols.hasNext()) {
564 XDragSourceProtocol dragProtocol = dragProtocols.next();
565 if (dragProtocol.processProxyModeEvent(xclient,
566 getProxyModeSourceWindow())) {
567 return true;
568 }
569 }
570
571 return false;
572 }
573
574 /**
575 * The caller must own awtLock.
576 *
577 * @return true if the event was processed and shouldn't be passed along.
578 */
579 private boolean doProcessEvent(XEvent ev) {
580 assert XToolkit.isAWTLockHeldByCurrentThread();
581
582 if (processProxyModeEvent(ev)) {
583 return true;
584 }
585
586 if (!dndInProgress) {
587 return false;
588 }
589
590 switch (ev.get_type()) {
591 case XConstants.ClientMessage: {
592 XClientMessageEvent xclient = ev.get_xclient();
593 return processClientMessage(xclient);
594 }
595 case XConstants.DestroyNotify: {
596 XDestroyWindowEvent xde = ev.get_xdestroywindow();
597
598 /* Target crashed during drop processing - cleanup. */
599 if (!dragInProgress &&
600 dragProtocol != null &&
601 xde.get_window() == dragProtocol.getTargetWindow()) {
602 cleanup(XConstants.CurrentTime);
603 return true;
604 }
605 /* Pass along */
606 return false;
607 }
608 }
609
610 if (!dragInProgress) {
611 return false;
612 }
613
614 /* Process drag-only messages. */
615 switch (ev.get_type()) {
616 case XConstants.KeyRelease:
617 case XConstants.KeyPress: {
618 XKeyEvent xkey = ev.get_xkey();
619 long keysym = XlibWrapper.XKeycodeToKeysym(XToolkit.getDisplay(),
620 xkey.get_keycode(), 0);
621 switch ((int)keysym) {
622 case (int)XKeySymConstants.XK_Escape: {
623 if (ev.get_type() == XConstants.KeyRelease) {
624 cleanup(xkey.get_time());
625 }
626 break;
627 }
628 case (int)XKeySymConstants.XK_Control_R:
629 case (int)XKeySymConstants.XK_Control_L:
630 case (int)XKeySymConstants.XK_Shift_R:
631 case (int)XKeySymConstants.XK_Shift_L: {
632 XlibWrapper.XQueryPointer(XToolkit.getDisplay(),
633 xkey.get_root(),
634 XlibWrapper.larg1, // root
635 XlibWrapper.larg2, // subwindow
636 XlibWrapper.larg3, // x_root
637 XlibWrapper.larg4, // y_root
638 XlibWrapper.larg5, // x
639 XlibWrapper.larg6, // y
640 XlibWrapper.larg7); // modifiers
641 XMotionEvent xmotion = new XMotionEvent();
642 try {
643 xmotion.set_type(XConstants.MotionNotify);
644 xmotion.set_serial(xkey.get_serial());
645 xmotion.set_send_event(xkey.get_send_event());
646 xmotion.set_display(xkey.get_display());
647 xmotion.set_window(xkey.get_window());
648 xmotion.set_root(xkey.get_root());
649 xmotion.set_subwindow(xkey.get_subwindow());
650 xmotion.set_time(xkey.get_time());
651 xmotion.set_x(xkey.get_x());
652 xmotion.set_y(xkey.get_y());
653 xmotion.set_x_root(xkey.get_x_root());
654 xmotion.set_y_root(xkey.get_y_root());
655 xmotion.set_state((int)Native.getLong(XlibWrapper.larg7));
656 // we do not use this field, so it's unset for now
657 // xmotion.set_is_hint(???);
658 xmotion.set_same_screen(xkey.get_same_screen());
659
660 //It's safe to use key event as motion event since we use only their common fields.
661 processMouseMove(xmotion);
662 } finally {
663 xmotion.dispose();
664 }
665 break;
666 }
667 }
668 return true;
669 }
670 case XConstants.ButtonPress:
671 return true;
672 case XConstants.MotionNotify:
673 processMouseMove(ev.get_xmotion());
674 return true;
675 case XConstants.ButtonRelease: {
676 XButtonEvent xbutton = ev.get_xbutton();
677 /*
678 * Ignore the buttons above 20 due to the bit limit for
679 * InputEvent.BUTTON_DOWN_MASK.
680 * One more bit is reserved for FIRST_HIGH_BIT.
681 */
682 if (xbutton.get_button() > SunToolkit.MAX_BUTTONS_SUPPORTED) {
683 return true;
684 }
685
686 /*
687 * On some X servers it could happen that ButtonRelease coordinates
688 * differ from the latest MotionNotify coordinates, so we need to
689 * process it as a mouse motion.
690 */
691 XMotionEvent xmotion = new XMotionEvent();
692 try {
693 xmotion.set_type(XConstants.MotionNotify);
694 xmotion.set_serial(xbutton.get_serial());
695 xmotion.set_send_event(xbutton.get_send_event());
696 xmotion.set_display(xbutton.get_display());
697 xmotion.set_window(xbutton.get_window());
698 xmotion.set_root(xbutton.get_root());
699 xmotion.set_subwindow(xbutton.get_subwindow());
700 xmotion.set_time(xbutton.get_time());
701 xmotion.set_x(xbutton.get_x());
702 xmotion.set_y(xbutton.get_y());
703 xmotion.set_x_root(xbutton.get_x_root());
704 xmotion.set_y_root(xbutton.get_y_root());
705 xmotion.set_state(xbutton.get_state());
706 // we do not use this field, so it's unset for now
707 // xmotion.set_is_hint(???);
708 xmotion.set_same_screen(xbutton.get_same_screen());
709
710 //It's safe to use key event as motion event since we use only their common fields.
711 processMouseMove(xmotion);
712 } finally {
713 xmotion.dispose();
714 }
715 if (xbutton.get_button() == XConstants.buttons[0]
716 || xbutton.get_button() == XConstants.buttons[1]) {
717 // drag is initiated with Button1 or Button2 pressed and
718 // ended on release of either of these buttons (as the same
719 // behavior was with our old Motif DnD-based implementation)
720 removeDnDGrab(xbutton.get_time());
721 dragInProgress = false;
722 if (dragProtocol != null && targetAction != DnDConstants.ACTION_NONE) {
723 /*
724 * ACTION_NONE indicates that either the drop target rejects the
725 * drop or it haven't responded yet. The latter could happen in
726 * case of fast drag, slow target-server connection or slow
727 * drag notifications processing on the target side.
728 */
729 processDrop(xbutton);
730 } else {
731 cleanup(xbutton.get_time());
732 }
733 }
734 return true;
735 }
736 }
737
738 return false;
739 }
740
741 static boolean processEvent(XEvent ev) {
742 XToolkit.awtLock();
743 try {
744 try {
745 return theInstance.doProcessEvent(ev);
746 } catch (XException e) {
747 e.printStackTrace();
748 return false;
749 }
750 } finally {
751 XToolkit.awtUnlock();
752 }
753 }
754
755 /* XDragSourceProtocolListener implementation */
756
757 public void handleDragReply(int action) {
758 // NOTE: we have to use the current pointer location, since
759 // the target didn't specify the coordinates for the reply.
760 handleDragReply(action, xRoot, yRoot);
761 }
762
763 public void handleDragReply(int action, int x, int y) {
764 // NOTE: we have to use the current modifiers state, since
765 // the target didn't specify the modifiers state for the reply.
766 handleDragReply(action, xRoot, yRoot, XWindow.getModifiers(eventState,0,0));
767 }
768
769 public void handleDragReply(int action, int x, int y, int modifiers) {
770 if (action == DnDConstants.ACTION_NONE &&
771 targetAction != DnDConstants.ACTION_NONE) {
772 dragExit(x, y);
773 } else if (action != DnDConstants.ACTION_NONE) {
774 int type = 0;
775
776 if (targetAction == DnDConstants.ACTION_NONE) {
777 type = SunDragSourceContextPeer.DISPATCH_ENTER;
778 } else {
779 type = SunDragSourceContextPeer.DISPATCH_MOTION;
780 }
781
782 // Note that we use the modifiers state a
783 postDragSourceDragEvent(action, modifiers, x, y, type);
784 }
785
786 targetAction = action;
787 }
788
789 public void handleDragFinished() {
790 /* Assume that the drop was successful. */
791 handleDragFinished(true);
792 }
793
794 public void handleDragFinished(boolean success) {
795 /* Assume that the performed drop action is the latest drop action
796 accepted by the drop target. */
797 handleDragFinished(true, targetAction);
798 }
799
800 public void handleDragFinished(boolean success, int action) {
801 // NOTE: we have to use the current pointer location, since
802 // the target didn't specify the coordinates for the reply.
803 handleDragFinished(success, action, xRoot, yRoot);
804 }
805
806 public void handleDragFinished(boolean success, int action, int x, int y) {
807 dragDropFinished(success, action, x, y);
808
809 dndInProgress = false;
810 cleanup(XConstants.CurrentTime);
811 }
812
813 public int scaleUp(int x) {
814 return x * windowScale;
815 }
816
817 public int scaleDown(int x) {
818 return x / windowScale;
819 }
820 }