1 /*

     2  * Copyright 1997-2005 Sun Microsystems, Inc.  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.  Sun designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

    22  * CA 95054 USA or visit www.sun.com if you need additional information or

    23  * have any questions.

    24  */

    25 

    26 #ifdef HEADLESS

    27     #error This file should not be included in headless library

    28 #endif

    29 

    30 #include <stdio.h>

    31 #include <string.h>

    32 

    33 #include "jvm.h"

    34 #include "jni.h"

    35 #include "jni_util.h"

    36 #include "jlong.h"

    37 

    38 #include "awt_DataTransferer.h"

    39 #include "awt_XmDnD.h"

    40 

    41 #include "awt_p.h"

    42 

    43 #include "java_awt_Cursor.h"

    44 #include "java_awt_dnd_DnDConstants.h"

    45 #include "java_awt_event_MouseEvent.h"

    46 #include "sun_awt_dnd_SunDragSourceContextPeer.h"

    47 #include "sun_awt_motif_MComponentPeer.h"

    48 #include "sun_awt_motif_MDragSourceContextPeer.h"

    49 #include "sun_awt_motif_MDropTargetContextPeer.h"

    50 

    51 #include <X11/cursorfont.h>

    52 #include <X11/Xutil.h>

    53 /*

    54  * Fix for 4285634.

    55  * Include the private Motif header to enable access to lastEventState.

    56  */

    57 #include <Xm/DragCP.h>

    58 

    59 #include "awt_Component.h"

    60 #include "awt_Cursor.h"

    61 #include "awt_AWTEvent.h"

    62 

    63 extern struct MComponentPeerIDs mComponentPeerIDs;

    64 extern struct CursorIDs cursorIDs;

    65 extern struct ContainerIDs containerIDs;

    66 

    67 /* globals */

    68 

    69 

    70 /* forwards */

    71 

    72 static void awt_XmDropProc(Widget, XtPointer, XmDropProcCallbackStruct*);

    73 static void awt_XmDragProc(Widget, XtPointer, XmDragProcCallbackStruct*);

    74 

    75 static void awt_XmTransferProc(Widget, XtPointer, Atom*, Atom*, XtPointer,

    76                                unsigned long*, int32_t*);

    77 

    78 /* for XmDragContext callbacks etc ... */

    79 static void awt_XmDragEnterProc(Widget, XtPointer,

    80                                 XmDropSiteEnterCallbackStruct*);

    81 static void awt_XmDragMotionProc(Widget, XtPointer,

    82                                  XmDragMotionCallbackStruct*);

    83 static void awt_XmDragLeaveProc(Widget, XtPointer,

    84                                 XmDropSiteLeaveCallbackStruct*);

    85 static void awt_XmDropOperationChangedProc(Widget, XtPointer,

    86                                            XmDropStartCallbackStruct*);

    87 static void awt_XmDropFinishProc(Widget, XtPointer,

    88                                  XmDropFinishCallbackStruct*);

    89 

    90 static unsigned char DnDConstantsToXm(jint operations);

    91 static jint XmToDnDConstants(unsigned char operations);

    92 static unsigned char selectOperation(unsigned char operations);

    93 

    94 static void flush_cache(JNIEnv* env);

    95 static void    cacheDropDone(Boolean dropDone);

    96 static Boolean isDropDone();

    97 

    98 static void setCursor(JNIEnv* env, Display* d, jobject c, jint type, Time t);

    99 

   100 static Atom MOTIF_DROP_ATOM = None;

   101 

   102 /* in canvas.c */

   103 extern jint getModifiers(uint32_t state, jint button, jint keyCode);

   104 

   105 /**

   106  * static cache of DropTarget related info.

   107  */

   108 

   109 static struct {

   110     Widget        w;                /* if NULL, cache invalid */

   111 

   112     jobject       peer;

   113     jobject       component;

   114 

   115     jobject       dtcpeer;

   116 

   117     Widget        dt;

   118 

   119     jlongArray    targets;

   120     Cardinal      nTargets;

   121 

   122     Boolean       dropDone;

   123     int32_t       transfersPending;

   124     Widget        transfer;

   125 

   126     jint          dropAction;       /* used only on JVM transfers */

   127 

   128     Boolean       flushPending;

   129 

   130     Window win;

   131     uint32_t state;

   132 } _cache;

   133 

   134 uint32_t

   135 buttonToMask(uint32_t button) {

   136     switch (button) {

   137         case Button1:

   138             return Button1Mask;

   139         case Button2:

   140             return Button2Mask;

   141         case Button3:

   142             return Button3Mask;

   143         case Button4:

   144             return Button4Mask;

   145         case Button5:

   146             return Button5Mask;

   147         default:

   148             return 0;

   149     }

   150 }

   151 

   152 /* Fix for 4215643: extract the values cached on drag start and send

   153    ButtonRelease event to the window which originated the drag */

   154 

   155 void

   156 dragsource_track_release(Widget w, XtPointer client_data,

   157                          XEvent * event, Boolean * cont)

   158 {

   159     DASSERT (event != NULL);

   160 

   161     if (_cache.win != None &&

   162         (buttonToMask(event->xbutton.button) & _cache.state)) {

   163 

   164         JNIEnv *env = (JNIEnv *) JNU_GetEnv(jvm, JNI_VERSION_1_2);

   165         Window win = event->xbutton.window;

   166         event->xbutton.window = _cache.win;

   167         awt_put_back_event(env, event);

   168         event->xbutton.window = win;

   169         _cache.win = None;

   170         _cache.state = 0;

   171         XtRemoveEventHandler(w, ButtonReleaseMask, False,

   172                              dragsource_track_release, NULL);

   173     }

   174 }

   175 

   176 static void

   177 cancel_drag(XtPointer client_data, XtIntervalId* id) {

   178     Time time = awt_util_getCurrentServerTime();

   179     Widget dc = XmGetDragContext(awt_root_shell, time);

   180 

   181     if (dc != NULL) {

   182         Boolean sourceIsExternal = True;

   183         XtVaGetValues(dc, XmNsourceIsExternal, &sourceIsExternal, NULL);

   184         if (!sourceIsExternal) {

   185             XEvent xevent;

   186             XmDragCancel(dc);

   187 

   188             /*

   189              * When running the internal drag-and-drop event loop

   190              * (see DragC.c:InitiatorMainLoop) Motif DnD uses XtAppNextEvent,

   191              * that processes all timer callbacks and then returns the next X

   192              * event from the queue. Motif DnD doesn't check if the drag

   193              * operation is cancelled after XtAppNextEvent returns and processes

   194              * the returned event. When the drag operation is cancelled the

   195              * XmDragContext widget is destroyed and Motif will crash if the new

   196              * event is dispatched to the destroyed XmDragContext.

   197              * We cancel the drag operation in the timer callback, so we putback

   198              * a dummy X event. This event will be returned from XtAppNextEvent

   199              * and Motif DnD will safely exit from the internal event loop.

   200              */

   201             xevent.type = LASTEvent;

   202             xevent.xany.send_event = True;

   203             xevent.xany.display = awt_display;

   204             xevent.xany.window = XtWindow(awt_root_shell);

   205             XPutBackEvent(awt_display, &xevent);

   206         }

   207     }

   208 }

   209 

   210 #define DONT_CARE -1

   211 

   212 static void

   213 awt_popupCallback(Widget shell, XtPointer closure, XtPointer call_data) {

   214     XtGrabKind grab_kind = XtGrabNone;

   215 

   216     if (call_data != NULL) {

   217         grab_kind = *((XtGrabKind*)call_data);

   218     }

   219 

   220     if (XmIsVendorShell(shell)) {

   221         int input_mode;

   222         XtVaGetValues(shell, XmNmwmInputMode, &input_mode, NULL);

   223         switch (input_mode) {

   224         case DONT_CARE:

   225         case MWM_INPUT_MODELESS:

   226             grab_kind = XtGrabNonexclusive; break;

   227         case MWM_INPUT_PRIMARY_APPLICATION_MODAL:

   228         case MWM_INPUT_SYSTEM_MODAL:

   229         case MWM_INPUT_FULL_APPLICATION_MODAL:

   230             grab_kind = XtGrabExclusive; break;

   231         }

   232     }

   233 

   234     if (grab_kind == XtGrabExclusive) {

   235         /*

   236          * We should cancel the drag on the toolkit thread. Otherwise, it can be

   237          * called while the toolkit thread is waiting inside some drag callback.

   238          * In this case Motif will crash when the drag callback returns.

   239          */

   240         XtAppAddTimeOut(awt_appContext, 0L, cancel_drag, NULL);

   241     }

   242 }

   243 

   244 static XtInitProc xt_shell_initialize = NULL;

   245 

   246 static void

   247 awt_ShellInitialize(Widget req, Widget new, ArgList args, Cardinal *num_args) {

   248     XtAddCallback(new, XtNpopupCallback, awt_popupCallback, NULL);

   249     (*xt_shell_initialize)(req, new, args, num_args);

   250 }

   251 

   252 /*

   253  * Fix for 4484572.

   254  * Modify the 'initialize' routine for all ShellWidget instances, so that it

   255  * will install an XtNpopupCallback that cancels the current drag operation.

   256  * It is needed, since AWT doesn't have full control over all ShellWidget

   257  * instances (e.g. XmPopupMenu internally creates and popups an XmMenuShell).

   258  */

   259 static void

   260 awt_set_ShellInitialize() {

   261     static Boolean inited = False;

   262 

   263     DASSERT(!inited);

   264     if (inited) {

   265         return;

   266     }

   267 

   268     xt_shell_initialize = shellWidgetClass->core_class.initialize;

   269     shellWidgetClass->core_class.initialize = (XtInitProc)awt_ShellInitialize;

   270     inited = True;

   271 }

   272 

   273 /**

   274  * global function to initialize this client as a Dynamic-only app.

   275  *

   276  * gets called once during toolkit initialization.

   277  */

   278 

   279 void awt_initialize_Xm_DnD(Display* dpy) {

   280     JNIEnv* env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);

   281     jclass  clazz;

   282 

   283     XtVaSetValues(XmGetXmDisplay(dpy),

   284                   XmNdragInitiatorProtocolStyle, XmDRAG_DYNAMIC,

   285                   XmNdragReceiverProtocolStyle,  XmDRAG_DYNAMIC,

   286                   NULL

   287                   );

   288 

   289     MOTIF_DROP_ATOM = XInternAtom(dpy, _XA_MOTIF_DROP, False);

   290     if (XSaveContext(dpy, MOTIF_DROP_ATOM, awt_convertDataContext,

   291                      (XPointer)NULL) == XCNOMEM) {

   292         JNU_ThrowInternalError(env, "");

   293         return;

   294     }

   295 

   296     /* No drop in progress. */

   297     cacheDropDone(True);

   298 

   299     /*

   300      * Fix for BugTraq ID 4407057.

   301      * Have to disable Motif default drag support, since it doesn't work

   302      * reliably with our event dispatch mechanism. To do this we allow a drag

   303      * operation only if it is registered on the awt_root_shell.

   304      */

   305     awt_motif_enableSingleDragInitiator(awt_root_shell);

   306 

   307     awt_set_ShellInitialize();

   308 

   309     /*

   310      * load the Cursor stuff

   311      */

   312 

   313     clazz = (*env)->FindClass(env, "sun/awt/motif/MCustomCursor");

   314 

   315     if (!JNU_IsNull(env, ((*env)->ExceptionOccurred(env)))) {

   316         (*env)->ExceptionDescribe(env);

   317         (*env)->ExceptionClear(env);

   318     }

   319 }

   320 

   321 typedef struct DSInfoRec {

   322     Widget         widget;

   323 

   324     Pixmap         animation_mask;

   325     Pixmap         animation_pixmap;

   326     int32_t        animation_pixmap_depth;

   327     unsigned char  animation_style;

   328     XtPointer      client_data;

   329     XtCallbackProc drag_proc;

   330     XtCallbackProc drop_proc;

   331     XRectangle     *drop_rectangles;

   332     unsigned char  drop_site_activity;

   333     unsigned char  drop_site_operations;

   334     unsigned char  drop_site_type;

   335     Atom           *import_targets;

   336     Cardinal       num_drop_rectangles;

   337     Cardinal       num_import_targets;

   338 

   339     struct DSInfoRec* next;

   340 } DSInfoRec, * DSInfoPtr;

   341 

   342 #define ARG_COUNT 14

   343 

   344 /*

   345  * Allocates DSInfoRect structure, retrieves all attributes of a Motif drop site

   346  * registered on the specified widget and puts them into the allocated storage.

   347  * The caller should free the storage after use.

   348  */

   349 DSInfoPtr get_drop_site_info(Widget w) {

   350     Arg       arglist[ARG_COUNT];

   351     Cardinal  argcount = 0;

   352     DSInfoPtr info = ZALLOC(DSInfoRec);

   353 

   354     if (info == NULL) {

   355         JNIEnv* env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);

   356         JNU_ThrowOutOfMemoryError(env, "OutOfMemoryError");

   357         return NULL;

   358     }

   359 

   360     XtSetArg(arglist[argcount], XmNanimationMask,

   361              (XtArgVal)&info->animation_mask); argcount++;

   362     XtSetArg(arglist[argcount], XmNanimationPixmap,

   363              (XtArgVal)&info->animation_pixmap); argcount++;

   364     XtSetArg(arglist[argcount], XmNanimationPixmapDepth,

   365              (XtArgVal)&info->animation_pixmap_depth); argcount++;

   366     XtSetArg(arglist[argcount], XmNanimationStyle,

   367              (XtArgVal)&info->animation_style); argcount++;

   368     XtSetArg(arglist[argcount], XmNclientData,

   369              (XtArgVal)&info->client_data); argcount++;

   370     XtSetArg(arglist[argcount], XmNdragProc,

   371              (XtArgVal)&info->drag_proc); argcount++;

   372     XtSetArg(arglist[argcount], XmNdropProc,

   373              (XtArgVal)&info->drop_proc); argcount++;

   374     XtSetArg(arglist[argcount], XmNdropSiteActivity,

   375              (XtArgVal)&info->drop_site_activity); argcount++;

   376     XtSetArg(arglist[argcount], XmNdropSiteOperations,

   377              (XtArgVal)&info->drop_site_operations); argcount++;

   378     XtSetArg(arglist[argcount], XmNdropSiteType,

   379              (XtArgVal)&info->drop_site_type); argcount++;

   380     XtSetArg(arglist[argcount], XmNnumDropRectangles,

   381              (XtArgVal)&info->num_drop_rectangles); argcount++;

   382     XtSetArg(arglist[argcount], XmNnumImportTargets,

   383              (XtArgVal)&info->num_import_targets); argcount++;

   384     DASSERT(argcount == ARG_COUNT - 2);

   385 

   386     XmDropSiteRetrieve(w, arglist, argcount);

   387 

   388     if (info->num_import_targets > 0) {

   389         Atom *targets = NULL;

   390 

   391         info->import_targets = malloc(info->num_import_targets * sizeof(Atom));

   392 

   393         if (info->import_targets == NULL) {

   394             JNIEnv* env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);

   395 

   396             free(info);

   397             JNU_ThrowOutOfMemoryError(env, "OutOfMemoryError");

   398             return NULL;

   399         }

   400 

   401         XtSetArg(arglist[0], XmNimportTargets, (XtArgVal)&targets);

   402         XmDropSiteRetrieve(w, arglist, 1);

   403 

   404         memcpy(info->import_targets, targets,

   405                info->num_import_targets * sizeof(Atom));

   406     }

   407 

   408     if (info->drop_site_type == XmDROP_SITE_SIMPLE && info->num_drop_rectangles > 0) {

   409             XRectangle *rectangles = NULL;

   410             info->drop_rectangles =

   411                 malloc(info->num_drop_rectangles * sizeof(XRectangle));

   412 

   413             if (info->drop_rectangles == NULL) {

   414                 JNIEnv* env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);

   415 

   416                 if (info->import_targets != NULL) {

   417                     free(info->import_targets);

   418                 }

   419                 free(info);

   420                 JNU_ThrowOutOfMemoryError(env, "OutOfMemoryError");

   421                 return NULL;

   422             }

   423 

   424             XtSetArg(arglist[0], XmNdropRectangles, (XtArgVal)&rectangles);

   425             XmDropSiteRetrieve(w, arglist, 1);

   426 

   427             memcpy(info->drop_rectangles, rectangles,

   428                    info->num_drop_rectangles * sizeof(XRectangle));

   429     } else /* if (info->drop_site_type == XmDROP_SITE_COMPOSITE) */ {

   430         info->num_drop_rectangles = 1;

   431         info->drop_rectangles = NULL;

   432     }

   433 

   434     info->widget = w;

   435     return info;

   436 }

   437 

   438 /*

   439  * Registers a Motif drop site on a widget given the information

   440  * in the passed DSInfoRec structure.

   441  */

   442 void restore_drop_site(DSInfoPtr info) {

   443     Arg      arglist[ARG_COUNT];

   444     Cardinal argcount = 0;

   445 

   446     if (info->drop_site_type == XmDROP_SITE_COMPOSITE) {

   447         info->num_drop_rectangles = 1;

   448         info->drop_rectangles = NULL;

   449     }

   450 

   451     XtSetArg(arglist[argcount], XmNanimationMask,

   452              (XtArgVal)info->animation_mask); argcount++;

   453     XtSetArg(arglist[argcount], XmNanimationPixmap,

   454              (XtArgVal)info->animation_pixmap); argcount++;

   455     XtSetArg(arglist[argcount], XmNanimationPixmapDepth,

   456              (XtArgVal)info->animation_pixmap_depth); argcount++;

   457     XtSetArg(arglist[argcount], XmNanimationStyle,

   458              (XtArgVal)info->animation_style); argcount++;

   459     XtSetArg(arglist[argcount], XmNclientData,

   460              (XtArgVal)info->client_data); argcount++;

   461     XtSetArg(arglist[argcount], XmNdragProc,

   462              (XtArgVal)info->drag_proc); argcount++;

   463     XtSetArg(arglist[argcount], XmNdropProc,

   464              (XtArgVal)info->drop_proc); argcount++;

   465     XtSetArg(arglist[argcount], XmNdropRectangles,

   466              (XtArgVal)info->drop_rectangles); argcount++;

   467     XtSetArg(arglist[argcount], XmNdropSiteActivity,

   468              (XtArgVal)info->drop_site_activity); argcount++;

   469     XtSetArg(arglist[argcount], XmNdropSiteOperations,

   470              (XtArgVal)info->drop_site_operations); argcount++;

   471     XtSetArg(arglist[argcount], XmNdropSiteType,

   472              (XtArgVal)info->drop_site_type); argcount++;

   473     XtSetArg(arglist[argcount], XmNimportTargets,

   474              (XtArgVal)info->import_targets); argcount++;

   475     XtSetArg(arglist[argcount], XmNnumDropRectangles,

   476              (XtArgVal)info->num_drop_rectangles); argcount++;

   477     XtSetArg(arglist[argcount], XmNnumImportTargets,

   478              (XtArgVal)info->num_import_targets); argcount++;

   479     DASSERT(argcount == ARG_COUNT);

   480 

   481     XmDropSiteUnregister(info->widget);

   482     XmDropSiteRegister(info->widget, arglist, argcount);

   483     XmDropSiteConfigureStackingOrder(info->widget, (Widget)NULL, XmABOVE);

   484 }

   485 

   486 #undef ARG_COUNT

   487 

   488 /*

   489  * This routine ensures that hierarchy of Motif drop sites is not broken

   490  * when a new drop site is registered or an existing drop site is

   491  * unregistered. It unregisters all drop sites registered on the descendants of

   492  * the specified widget, then registers or unregisters a Motif drop site on the

   493  * root widget depending on the value of registerNewSite. After that the routine

   494  * restores all the drop sites on the descendants.

   495  * The routine recursively traverses through the hierarchy of descendant Motif

   496  * drop sites and stores the info for all drop sites in a list. Then this list

   497  * is used to restore all descendant drop sites.

   498  * @param w    current widget in the hierarchy traversal

   499  * @param top  root widget of the traversed hierarchy - the one to be inserted or

   500  *             removed

   501  * @param list a list of DSInfoRec structures which keep drop site info for

   502  *             child drop sites

   503  * @param registerNewSite if True a new Motif drop site should be registered on

   504  *             the root widget. If False an existing drop site of the root widget

   505  *             should be unregistered.

   506  * @param isDropSite if True the widget being currently traversed has an

   507  *             associated Motif drop site.

   508  */

   509 static DSInfoPtr

   510 update_drop_site_hierarchy(Widget w, Widget top, DSInfoPtr list,

   511                            Boolean registerNewSite, Boolean isDropSite) {

   512 

   513     Widget     parent = NULL;

   514     Widget     *children = NULL;

   515     Cardinal   num_children = 0;

   516 

   517     if (w == NULL || !XtIsObject(w) || w->core.being_destroyed) {

   518         return NULL;

   519     }

   520 

   521     /* Get the child drop sites of the widget.*/

   522     if (XmDropSiteQueryStackingOrder(w, &parent, &children,

   523                                      &num_children) == 0) {

   524         /*

   525          * The widget is declared to be a drop site, but the query fails.

   526          * The drop site must be corrupted. Truncate traversal.

   527          */

   528         if (isDropSite) {

   529             return NULL;

   530         }

   531     } else {

   532         /* The query succeded, so the widget is definitely a drop site. */

   533         isDropSite = True;

   534     }

   535 

   536     /* Traverse descendants of the widget, if it is composite. */

   537     if (XtIsComposite(w)) {

   538         Cardinal   i = 0;

   539 

   540         /* If it is not a drop site, check all its children. */

   541         if (!isDropSite) {

   542             XtVaGetValues(w, XmNchildren, &children,

   543                           XmNnumChildren, &num_children, NULL);

   544         }

   545 

   546         for (i = 0; i < num_children; i++) {

   547             list = update_drop_site_hierarchy(children[i], top, list,

   548                                               registerNewSite, isDropSite);

   549         }

   550     }

   551 

   552     /* The storage allocated by XmDropSiteQueryStackingOrder must be freed.*/

   553     if (isDropSite && children != NULL) {

   554         XtFree((void*)children);

   555     }

   556 

   557     if (w != top) {

   558         if (isDropSite) {

   559             /* Prepend drop site info to the list and unregister a drop site.*/

   560             DSInfoPtr info = get_drop_site_info(w);

   561 

   562             if (info != NULL) {

   563                 info->next = list;

   564                 list = info;

   565             }

   566             XmDropSiteUnregister(w);

   567         }

   568     } else {

   569         /* Traversal is complete.*/

   570         DSInfoPtr info = list;

   571 

   572         if (isDropSite) {

   573             XmDropSiteUnregister(w);

   574         }

   575 

   576         if (registerNewSite) {

   577             Arg              args[10];

   578             unsigned int nargs = 0;

   579 

   580 #define SetArg(n, v) args[nargs].name = n; args[nargs++].value = (XtArgVal)(v);

   581 

   582             SetArg(XmNanimationStyle,   XmDRAG_UNDER_NONE);

   583             SetArg(XmNdragProc,                awt_XmDragProc);

   584             SetArg(XmNdropProc,                awt_XmDropProc);

   585             SetArg(XmNdropSiteActivity, XmDROP_SITE_ACTIVE);

   586 

   587             SetArg(XmNdropSiteOperations,

   588                    XmDROP_LINK | XmDROP_MOVE | XmDROP_COPY);

   589 

   590             SetArg(XmNimportTargets,    NULL);

   591             SetArg(XmNnumImportTargets, 0);

   592 

   593             SetArg(XmNdropSiteType,     XmDROP_SITE_COMPOSITE);

   594             SetArg(XmNdropRectangles,   (XRectangle*)NULL);

   595 #undef  SetArg

   596 

   597             XmDropSiteRegister(w, args, nargs);

   598             XmDropSiteConfigureStackingOrder(w, (Widget)NULL, XmABOVE);

   599         }

   600 

   601         /* Go through the list and restore all child drop sites.*/

   602         while (info != NULL) {

   603             restore_drop_site(info);

   604 

   605             info = info->next;

   606             list->next = NULL;

   607             if (list->import_targets != NULL) {

   608                 free(list->import_targets);

   609             }

   610             if (list->drop_rectangles != NULL) {

   611                 free(list->drop_rectangles);

   612             }

   613             free(list);

   614             list = info;

   615         }

   616     }

   617     return list;

   618 }

   619 

   620 void

   621 register_drop_site(Widget w) {

   622     update_drop_site_hierarchy(w, w, NULL, True, False);

   623 }

   624 

   625 void

   626 unregister_drop_site(Widget w) {

   627     update_drop_site_hierarchy(w, w, NULL, False, True);

   628 }

   629 

   630 DECLARE_JAVA_CLASS(dSCClazz, "sun/awt/motif/MDragSourceContextPeer")

   631 DECLARE_JAVA_CLASS(dTCClazz, "sun/awt/motif/MDropTargetContextPeer")

   632 

   633 static void

   634 call_dSCenter(JNIEnv* env, jobject this, jint targetActions,

   635               jint modifiers, jint x, jint y) {

   636     DECLARE_VOID_JAVA_METHOD(dSCenter, dSCClazz, "dragEnter", "(IIII)V");

   637     DASSERT(!JNU_IsNull(env, this));

   638     (*env)->CallVoidMethod(env, this, dSCenter, targetActions, modifiers, x, y);

   639 }

   640 

   641 static void

   642 call_dSCmotion(JNIEnv* env, jobject this, jint targetActions,

   643                jint modifiers, jint x, jint y) {

   644     DECLARE_VOID_JAVA_METHOD(dSCmotion, dSCClazz, "dragMotion", "(IIII)V");

   645     DASSERT(!JNU_IsNull(env, this));

   646     (*env)->CallVoidMethod(env, this, dSCmotion, targetActions,

   647                            modifiers, x, y);

   648 }

   649 

   650 static void

   651 call_dSCchanged(JNIEnv* env, jobject this, jint targetActions,

   652                 jint modifiers, jint x, jint y) {

   653     DECLARE_VOID_JAVA_METHOD(dSCchanged, dSCClazz, "operationChanged",

   654                              "(IIII)V");

   655     DASSERT(!JNU_IsNull(env, this));

   656     (*env)->CallVoidMethod(env, this, dSCchanged, targetActions,

   657                            modifiers, x, y);

   658 }

   659 

   660 static void

   661 call_dSCmouseMoved(JNIEnv* env, jobject this, jint targetActions,

   662                    jint modifiers, jint x, jint y) {

   663     DECLARE_VOID_JAVA_METHOD(dSCmouseMoved, dSCClazz, "dragMouseMoved",

   664                              "(IIII)V");

   665     DASSERT(!JNU_IsNull(env, this));

   666     (*env)->CallVoidMethod(env, this, dSCmouseMoved, targetActions,

   667                            modifiers, x, y);

   668 }

   669 

   670 static void

   671 call_dSCexit(JNIEnv* env, jobject this, jint x, jint y) {

   672     DECLARE_VOID_JAVA_METHOD(dSCexit, dSCClazz, "dragExit", "(II)V");

   673     DASSERT(!JNU_IsNull(env, this));

   674     (*env)->CallVoidMethod(env, this, dSCexit, x, y);

   675 }

   676 

   677 static void

   678 call_dSCddfinished(JNIEnv* env, jobject this, jboolean success,

   679                    jint operations, jint x, jint y) {

   680     DECLARE_VOID_JAVA_METHOD(dSCddfinished, dSCClazz, "dragDropFinished",

   681                              "(ZIII)V");

   682     DASSERT(!JNU_IsNull(env, this));

   683     (*env)->CallVoidMethod(env, this, dSCddfinished, success, operations, x, y);

   684 }

   685 

   686 static jobject

   687 call_dTCcreate(JNIEnv* env) {

   688     DECLARE_STATIC_OBJECT_JAVA_METHOD(dTCcreate, dTCClazz,

   689                                      "createMDropTargetContextPeer",

   690                                      "()Lsun/awt/motif/MDropTargetContextPeer;");

   691     return (*env)->CallStaticObjectMethod(env, clazz, dTCcreate);

   692 }

   693 

   694 static jint

   695 call_dTCenter(JNIEnv* env, jobject this, jobject component, jint x, jint y,

   696               jint dropAction, jint actions, jlongArray formats,

   697               jlong nativeCtxt) {

   698     DECLARE_JINT_JAVA_METHOD(dTCenter, dTCClazz, "handleEnterMessage",

   699                             "(Ljava/awt/Component;IIII[JJ)I");

   700     DASSERT(!JNU_IsNull(env, this));

   701     return (*env)->CallIntMethod(env, this, dTCenter, component, x, y, dropAction,

   702                                  actions, formats, nativeCtxt);

   703 }

   704 

   705 static void

   706 call_dTCexit(JNIEnv* env, jobject this, jobject component, jlong nativeCtxt) {

   707     DECLARE_VOID_JAVA_METHOD(dTCexit, dTCClazz, "handleExitMessage",

   708                             "(Ljava/awt/Component;J)V");

   709     DASSERT(!JNU_IsNull(env, this));

   710     (*env)->CallVoidMethod(env, this, dTCexit, component, nativeCtxt);

   711 }

   712 

   713 static jint

   714 call_dTCmotion(JNIEnv* env, jobject this, jobject component, jint x, jint y,

   715                jint dropAction, jint actions, jlongArray formats,

   716                jlong nativeCtxt) {

   717     DECLARE_JINT_JAVA_METHOD(dTCmotion, dTCClazz, "handleMotionMessage",

   718                             "(Ljava/awt/Component;IIII[JJ)I");

   719     DASSERT(!JNU_IsNull(env, this));

   720     return (*env)->CallIntMethod(env, this, dTCmotion, component, x, y,

   721                                  dropAction, actions, formats, nativeCtxt);

   722 }

   723 

   724 static void

   725 call_dTCdrop(JNIEnv* env, jobject this, jobject component, jint x, jint y,

   726              jint dropAction, jint actions, jlongArray formats,

   727              jlong nativeCtxt) {

   728     DECLARE_VOID_JAVA_METHOD(dTCdrop, dTCClazz, "handleDropMessage",

   729                             "(Ljava/awt/Component;IIII[JJ)V");

   730     DASSERT(!JNU_IsNull(env, this));

   731     (*env)->CallVoidMethod(env, this, dTCdrop, component, x, y,

   732                            dropAction, actions, formats, nativeCtxt);

   733 }

   734 

   735 static void

   736 call_dTCnewData(JNIEnv* env, jobject this, jlong format, jobject type,

   737                 jbyteArray data) {

   738     DECLARE_VOID_JAVA_METHOD(dTCnewData, dTCClazz, "newData",

   739                             "(JLjava/lang/String;[B)V");

   740     DASSERT(!JNU_IsNull(env, this));

   741     (*env)->CallVoidMethod(env, this, dTCnewData, format, type, data);

   742 }

   743 

   744 static void

   745 call_dTCtxFailed(JNIEnv* env, jobject this, jlong format) {

   746     DECLARE_VOID_JAVA_METHOD(dTCtxFailed, dTCClazz, "transferFailed", "(J)V");

   747     DASSERT(!JNU_IsNull(env, this));

   748     (*env)->CallVoidMethod(env, this, dTCtxFailed, format);

   749 }

   750 

   751 /*

   752  * Class:     sun_awt_motif_MComponentPeer

   753  * Method:    addNativeDropTarget

   754  * Signature: (Ljava/awt/dnd/DropTarget;)V

   755  */

   756 

   757 JNIEXPORT void JNICALL Java_sun_awt_motif_MComponentPeer_addNativeDropTarget

   758     (JNIEnv *env, jobject this, jobject droptarget)

   759 {

   760     struct ComponentData* cdata     = (struct ComponentData *)NULL;

   761     DropSitePtr          dropsite  = (DropSitePtr)NULL;

   762 

   763     if (JNU_IsNull(env, droptarget)) {

   764         JNU_ThrowNullPointerException(env, "NullPointerException");

   765         return;

   766     }

   767 

   768     AWT_LOCK();

   769 

   770     cdata = (struct ComponentData *)

   771         JNU_GetLongFieldAsPtr(env, this, mComponentPeerIDs.pData);

   772 

   773     if (cdata == NULL || cdata->widget == NULL) {

   774         JNU_ThrowNullPointerException(env, "NullPointerException");

   775         AWT_UNLOCK();

   776         return;

   777     }

   778 

   779     /* introduce a new Component as a root of a set of DropTargets */

   780 

   781     if ((dropsite = cdata->dsi) == (DropSitePtr)NULL) {

   782         dropsite = cdata->dsi = (DropSitePtr)ZALLOC(DropSiteInfo);

   783 

   784         if (dropsite == (DropSitePtr)NULL) {

   785             JNU_ThrowOutOfMemoryError (env, "OutOfMemoryError");

   786             AWT_UNLOCK ();

   787             return;

   788         }

   789 

   790         dropsite->component = (*env)->NewGlobalRef

   791             (env, (*env)->GetObjectField(env, this,

   792                                          mComponentPeerIDs.target));

   793         dropsite->isComposite = True;

   794 

   795         /*

   796          * Fix for Bug Id 4389284.

   797          * Revalidate drop site hierarchy so that this drop site doesn't obscure

   798          * drop sites that are already registered on its children.

   799          */

   800         register_drop_site(cdata->widget);

   801     }

   802 

   803     dropsite->dsCnt++;

   804 

   805     AWT_UNLOCK();

   806 }

   807 

   808 /*

   809  * Class:     sun_awt_motif_MComponentPeer

   810  * Method:    removeNativeDropTarget

   811  * Signature: (Ljava/awt/dnd/DropTarget;)V

   812  */

   813 

   814 JNIEXPORT void JNICALL Java_sun_awt_motif_MComponentPeer_removeNativeDropTarget

   815     (JNIEnv *env, jobject this, jobject droptarget)

   816 {

   817     struct ComponentData* cdata;

   818     DropSitePtr           dropsite;

   819 

   820     if (JNU_IsNull(env, droptarget)) {

   821         JNU_ThrowNullPointerException(env, "NullPointerException");

   822         return;

   823     }

   824 

   825     AWT_LOCK();

   826 

   827     cdata = (struct ComponentData *)

   828         JNU_GetLongFieldAsPtr(env, this, mComponentPeerIDs.pData);

   829 

   830     if (cdata == NULL || cdata->widget == NULL) {

   831         JNU_ThrowNullPointerException(env, "NullPointerException");

   832         AWT_UNLOCK();

   833         return;

   834     }

   835 

   836     if ((dropsite = cdata->dsi) == (DropSitePtr)NULL) {

   837         JNU_ThrowNullPointerException(env, "NullPointerException");

   838         AWT_UNLOCK();

   839         return;

   840     }

   841 

   842     dropsite->dsCnt--;

   843     if (dropsite->dsCnt == 0) {

   844         /*

   845          * Fix for Bug Id 4411368.

   846          * Revalidate drop site hierarchy to prevent crash when a composite drop

   847          * site is unregistered before its child drop sites.

   848          */

   849         unregister_drop_site(cdata->widget);

   850 

   851         (*env)->DeleteGlobalRef(env, dropsite->component);

   852 

   853         free((void *)(cdata->dsi));

   854         cdata->dsi = (DropSitePtr)NULL;

   855     }

   856 

   857     AWT_UNLOCK();

   858 }

   859 

   860 /**

   861  *

   862  */

   863 

   864 JNIEXPORT void JNICALL

   865 Java_sun_awt_motif_MDragSourceContextPeer_setNativeCursor(JNIEnv *env,

   866                                                           jobject this,

   867                                                           jlong nativeCtxt,

   868                                                           jobject cursor,

   869                                                           jint type) {

   870     /*

   871      * NOTE: no need to synchronize on awt_lock here, since we should have

   872      * already acquired it in MDragSourceContextPeer.setCursor().

   873      */

   874     setCursor(env, awt_display, cursor, type, CurrentTime);

   875 }

   876 

   877 /**

   878  *

   879  */

   880 

   881 JNIEXPORT jlong JNICALL

   882 Java_sun_awt_motif_MDropTargetContextPeer_startTransfer(JNIEnv *env,

   883                                                         jobject this,

   884                                                         jlong dragContextVal,

   885                                                         jlong atom) {

   886     XmDropTransferEntryRec trec;

   887     Widget                 dropTransfer;

   888     Arg                    args[3];

   889     Cardinal               nargs = 0;

   890     jboolean               isCopy;

   891     Widget                 dragContext = (Widget)jlong_to_ptr(dragContextVal);

   892 

   893     AWT_LOCK();

   894 

   895     trec.target      = (Atom) atom;

   896     trec.client_data = (XtPointer)trec.target;

   897 

   898 

   899 #define SetArg(n, v) args[nargs].name = n; args[nargs++].value = (XtArgVal)(v);

   900 

   901     SetArg(XmNdropTransfers,    &trec);

   902     SetArg(XmNnumDropTransfers, 1    );

   903     SetArg(XmNtransferProc,     awt_XmTransferProc);

   904 

   905 #undef SetArg

   906 

   907     _cache.transfer = dropTransfer =

   908         XmDropTransferStart(dragContext, args, nargs);

   909 

   910     _cache.transfersPending++;

   911 

   912     AWT_NOTIFY_ALL();

   913     AWT_UNLOCK();

   914 

   915     return ptr_to_jlong(dropTransfer);

   916 }

   917 

   918 /**

   919  *

   920  */

   921 

   922 JNIEXPORT void JNICALL

   923 Java_sun_awt_motif_MDropTargetContextPeer_addTransfer(JNIEnv *env,

   924                                                       jobject this,

   925                                                       jlong dropTransferVal,

   926                                                       jlong atom) {

   927     XmDropTransferEntryRec trec;

   928     jboolean               isCopy;

   929     Widget                 dropTransfer=(Widget)jlong_to_ptr(dropTransferVal);

   930     trec.target      = (Atom)atom;

   931     trec.client_data = (XtPointer)trec.target;

   932 

   933     AWT_LOCK();

   934 

   935     XmDropTransferAdd(dropTransfer, &trec, 1);

   936 

   937     _cache.transfersPending++;

   938 

   939     AWT_NOTIFY_ALL();

   940     AWT_UNLOCK();

   941 }

   942 

   943 /**

   944  *

   945  */

   946 

   947 JNIEXPORT void JNICALL Java_sun_awt_motif_MDropTargetContextPeer_dropDone

   948     (JNIEnv *env, jobject this, jlong dragContextVal, jlong dropTransferVal,

   949      jboolean isLocal, jboolean success, jint dropAction)

   950 {

   951     Widget dropTransfer = (Widget)jlong_to_ptr(dropTransferVal);

   952     Widget dragContext = (Widget)jlong_to_ptr(dragContextVal);

   953 

   954     AWT_LOCK();

   955 

   956     if (_cache.w == (Widget)NULL) {

   957         AWT_UNLOCK();

   958         return;

   959     }

   960 

   961     if (!isDropDone()) {

   962         if (dropTransfer != (jlong)NULL) {

   963             XtVaSetValues(dropTransfer,

   964                           XmNtransferStatus,

   965                           success == JNI_TRUE

   966                           ? XmTRANSFER_SUCCESS : XmTRANSFER_FAILURE,

   967                           NULL

   968                           );

   969         } else {

   970             /*

   971              * start a transfer that notifies failure

   972              * this causes src side callbacks to be processed.

   973              * However, you cannot pass an a success, so the workaround is

   974              * to set _cache.transferSuccess to the proper value and read it

   975              * on the other side.

   976              */

   977 

   978 

   979             Arg arg;

   980 

   981             /*

   982              * this is the workaround code

   983              */

   984             _cache.transfer = NULL;

   985             _cache.dropAction = dropAction;

   986 

   987             /*

   988              * End workaround code

   989              */

   990 

   991             arg.name  = XmNtransferStatus;

   992             arg.value = (XtArgVal)(success == JNI_TRUE ? XmTRANSFER_SUCCESS

   993                                    : XmTRANSFER_FAILURE

   994                                    );

   995 

   996             XmDropTransferStart(dragContext, &arg, 1);

   997         }

   998 

   999         /*

  1000          * bugid# 4146717

  1001          *

  1002          * If this is a local tx, then we never exec the awt_XmTransferProc,

  1003          * thus we need to flush the cache here as it is our only chance,

  1004          * otherwise we leave a mess for the next operation to fail on ....

  1005          *

  1006          */

  1007 

  1008         if (isLocal == JNI_TRUE)

  1009             flush_cache(env); /* flush now, last chance */

  1010         else

  1011             _cache.flushPending = True; /* flush pending in transfer proc */

  1012     }

  1013 

  1014     cacheDropDone(True);

  1015 

  1016     AWT_NOTIFY_ALL();

  1017     AWT_UNLOCK();

  1018 }

  1019 

  1020 

  1021 static Boolean exitIdleProc = False;

  1022 static int32_t x_root = -1, y_root = -1;

  1023 

  1024 extern void waitForEvents(JNIEnv *env, int32_t fdXPipe, int32_t fdAWTPipe);

  1025 

  1026 static jint convertModifiers(uint32_t modifiers) {

  1027     return getModifiers(modifiers, 0, 0);

  1028 }

  1029 

  1030 static void

  1031 checkMouseMoved(XtPointer client_data) {

  1032     Window rootWindow, childWindow;

  1033     int32_t xw, yw, xr, yr;

  1034     uint32_t modifiers;

  1035 

  1036     /*

  1037      * When dragging over the root window XmNdragMotionCallback is not called

  1038      * (Motif feature).

  1039      * Since there is no legal way to receive MotionNotify events during drag

  1040      * we have to query for mouse position periodically.

  1041      */

  1042     if (XQueryPointer(awt_display, XDefaultRootWindow(awt_display),

  1043                       &rootWindow, &childWindow,

  1044                       &xr, &yr, &xw, &yw, &modifiers) &&

  1045         childWindow == None && (xr != x_root || yr != y_root)) {

  1046 

  1047         JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);

  1048         jobject this = (jobject)client_data;

  1049 

  1050         call_dSCmouseMoved(env, this, XmDROP_NOOP, convertModifiers(modifiers),

  1051                            xr, yr);

  1052 

  1053         if ((*env)->ExceptionCheck(env) == JNI_TRUE) {

  1054             (*env)->ExceptionDescribe(env);

  1055             (*env)->ExceptionClear(env);

  1056         }

  1057 

  1058         x_root = xr;

  1059         y_root = yr;

  1060     }

  1061 }

  1062 

  1063 static void IdleProc(XtPointer client_data, XtIntervalId* id) {

  1064     if (!exitIdleProc) {

  1065         JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);

  1066         /* The pipe where X events arrive */

  1067         int32_t fdXPipe = ConnectionNumber(awt_display) ;

  1068 

  1069         /*

  1070          * Motif DnD internal event loop doesn't process the events

  1071          * from the AWT putback event queue. So we pass -1 instead

  1072          * of the AWT read pipe descriptor to disable checking of

  1073          * the putback event queue.

  1074          */

  1075         waitForEvents(env, fdXPipe, -1);

  1076 

  1077         checkMouseMoved(client_data);

  1078         /* Reschedule the timer callback */

  1079         XtAppAddTimeOut(awt_appContext, AWT_DND_POLL_INTERVAL / 10,

  1080                         IdleProc, client_data);

  1081     }

  1082 }

  1083 

  1084 static void RemoveIdleProc(Widget w,

  1085                            XtPointer client_data,

  1086                            XmDropFinishCallbackStruct* cbstruct) {

  1087     exitIdleProc = True;

  1088 }

  1089 

  1090 /**

  1091  *

  1092  */

  1093 

  1094 JNIEXPORT jlong JNICALL

  1095 Java_sun_awt_motif_MDragSourceContextPeer_startDrag(JNIEnv *env,

  1096                                                     jobject this,

  1097                                                     jobject component,

  1098                                                     jobject transferable,

  1099                                                     jobject trigger,

  1100                                                     jobject cursor,

  1101                                                     jint ctype,

  1102                                                     jint actions,

  1103                                                     jlongArray formats,

  1104                                                     jobject formatMap) {

  1105     Arg                    args[32];

  1106     Cardinal               nargs = 0;

  1107     jobject                dscp  = (*env)->NewGlobalRef(env, this);

  1108     jbyteArray             bdata =

  1109         (jbyteArray)(*env)->GetObjectField(env, trigger, awtEventIDs.bdata);

  1110     Atom*                  targets = NULL;

  1111     jlong*                 jTargets;

  1112     jsize                  nTargets;

  1113     Widget                 dc;

  1114     XtCallbackRec          dsecbr[2];

  1115     XtCallbackRec          dmcbr[2];

  1116     XtCallbackRec          occbr[2];

  1117     XtCallbackRec          dslcbr[2];

  1118     XtCallbackRec          dscbr[2];

  1119     XtCallbackRec          ddfcbr[2];

  1120     XEvent*                xevent;

  1121     unsigned char          xmActions = DnDConstantsToXm(actions);

  1122     jboolean               isCopy=JNI_TRUE;

  1123     awt_convertDataCallbackStruct* structPtr;

  1124 

  1125 #ifndef _LP64 /* Atom and jlong are different sizes in the 32-bit build */

  1126     jsize                  i;

  1127     jlong*                 saveJTargets;

  1128     Atom*                  saveTargets;

  1129 #endif

  1130 

  1131     if (xmActions == XmDROP_NOOP) {

  1132         JNU_ThrowByName(env, "java/awt/dnd/InvalidDnDOperationException",

  1133                         "Invalid source actions.");

  1134         return ptr_to_jlong(NULL);