1 /*

     2  * Copyright 2003-2006 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 "awt_dnd.h"

    31 

    32 #include "jlong.h"

    33 

    34 #include "awt_DataTransferer.h"

    35 #include "awt_MToolkit.h"

    36 

    37 #include "java_awt_dnd_DnDConstants.h"

    38 #include "java_awt_event_MouseEvent.h"

    39 

    40 #include "sun_awt_motif_MComponentPeer.h"

    41 #include "awt_xembed.h"

    42 

    43 #define DT_INITIAL_STATE 0

    44 #define DT_ENTERED_STATE 1

    45 #define DT_OVER_STATE    2

    46 

    47 extern struct ComponentIDs componentIDs;

    48 extern struct MComponentPeerIDs mComponentPeerIDs;

    49 

    50 /**************************** XEmbed server DnD support ***********************/

    51 extern void

    52 set_xembed_drop_target(JNIEnv* env, jobject server);

    53 extern void

    54 remove_xembed_drop_target(JNIEnv* env, jobject server);

    55 extern Boolean

    56 is_xembed_client(Window window);

    57 

    58 DECLARE_JAVA_CLASS(MEmbedCanvasPeerClass, "sun/awt/motif/MEmbedCanvasPeer");

    59 /******************************************************************************/

    60 

    61 typedef enum {

    62     EventSuccess,    /* Event is successfully processed. */

    63     EventFailure     /* Failed to process the event. */

    64 } EventStatus;

    65 

    66 typedef enum {

    67     EnterEvent,    /* XdndEnter, TOP_LEVEL_ENTER */

    68     MotionEvent,   /* XdndPosition, DRAG_MOTION, OPERATION_CHANGED */

    69     LeaveEvent,    /* XdndLeave, TOP_LEVEL_LEAVE */

    70     DropEvent,     /* XdndDrop, DROP_START */

    71     UnknownEvent

    72 } EventType;

    73 

    74 static Protocol source_protocol = NO_PROTOCOL;

    75 static unsigned int source_protocol_version = 0;

    76 static Window source_window = None;

    77 static Atom source_atom = None;

    78 static long source_window_mask = None;

    79 static jint source_actions = java_awt_dnd_DnDConstants_ACTION_NONE;

    80 /*

    81  * According to XDnD protocol, XdndActionList is optional.

    82  * In case if XdndActionList is not set on the source, the list of drop actions

    83  * supported by the source is constructed as follows:

    84  *  - "copy" is always included;

    85  *  - "move" is included if at least one XdndPosition message received

    86  *    after the latest XdndEnter passed XdndActionMove in data.l[4];

    87  *  - "link" is included if at least one XdndPosition message received

    88  *    after the latest XdndEnter passed XdndActionLink in data.l[4].

    89  * We use a boolean flag to signal that we are building the list of drop actions

    90  * supported by the source.

    91  */

    92 static Boolean track_source_actions = False;

    93 static jint user_action = java_awt_dnd_DnDConstants_ACTION_NONE;

    94 static jlongArray source_data_types = NULL;

    95 static Atom* source_data_types_native = NULL;

    96 static unsigned int source_data_types_count = 0;

    97 static int source_x = 0;

    98 static int source_y = 0;

    99 static jobject target_component = NULL;

   100 /*

   101  * The Motif DnD protocol prescribes that DROP_START message should always be

   102  * preceeded with TOP_LEVEL_LEAVE message. We need to cleanup on TOP_LEVEL_LEAVE

   103  * message, but DROP_START wouldn't be processed properly.

   104  * To resolve this issue we postpone cleanup using a boolean flag this flag is

   105  * set when we receive the TOP_LEVEL_LEAVE message and cleared when the next

   106  * client message arrives if that message is not DROP_START. If that message is

   107  * a DROP_START message, the flag is cleared after the DROP_START is processed.

   108  */

   109 static Boolean motif_top_level_leave_postponed = False;

   110 /*

   111  * We store a postponed TOP_LEVEL_LEAVE message here.

   112  */

   113 static XClientMessageEvent motif_top_level_leave_postponed_event;

   114 

   115 /* Forward declarations */

   116 static Window get_root_for_window(Window window);

   117 static Window get_outer_canvas_for_window(Window window);

   118 static Boolean register_drop_site(Widget outer_canvas, XtPointer componentRef);

   119 static Boolean is_xdnd_drag_message_type(unsigned long message_type);

   120 static Boolean register_xdnd_drop_site(Display* dpy, Window toplevel,

   121                                        Window window);

   122 

   123 /**************************** JNI stuff ***************************************/

   124 

   125 DECLARE_JAVA_CLASS(dtcp_clazz, "sun/awt/motif/X11DropTargetContextPeer")

   126 

   127 static void

   128 dt_postDropTargetEvent(JNIEnv* env, jobject component, int x, int y,

   129                        jint dropAction, jint event_id,

   130                        XClientMessageEvent* event) {

   131     DECLARE_STATIC_VOID_JAVA_METHOD(dtcp_postDropTargetEventToPeer, dtcp_clazz,

   132                                     "postDropTargetEventToPeer",

   133                                     "(Ljava/awt/Component;IIII[JJI)V");

   134 

   135     {

   136         void* copy = NULL;

   137 

   138         if (event != NULL) {

   139             /*

   140              * For XDnD messages we append the information from the latest

   141              * XdndEnter to the context. It is done to be able to reconstruct

   142              * XdndEnter for an XEmbed client.

   143              */

   144             Boolean isXDnDMessage =

   145                 is_xdnd_drag_message_type(event->message_type);

   146 

   147             if (isXDnDMessage) {

   148                 copy = malloc(sizeof(XClientMessageEvent) +

   149                                                  4 * sizeof(long));

   150             } else {

   151                 copy = malloc(sizeof(XClientMessageEvent));

   152             }

   153 

   154             if (copy == NULL) {

   155                 DTRACE_PRINTLN2("%s:%d malloc failed.", __FILE__, __LINE__);

   156                 return;

   157             }

   158 

   159             memcpy(copy, event, sizeof(XClientMessageEvent));

   160 

   161             if (isXDnDMessage) {

   162                 size_t msgSize = sizeof(XClientMessageEvent);

   163                 long data1 = source_protocol_version << XDND_PROTOCOL_SHIFT;

   164                 long * appended_data;

   165                 if (source_data_types_native != NULL &&

   166                     source_data_types_count > 3) {

   167 

   168                     data1 |= XDND_DATA_TYPES_BIT;

   169                 }

   170 

   171                 appended_data = (long*)((char*)copy + msgSize);

   172                 appended_data[0] = data1;

   173                 appended_data[1] = source_data_types_count > 0 ?

   174                     source_data_types_native[0] : 0;

   175                 appended_data[2] = source_data_types_count > 1 ?

   176                     source_data_types_native[1] : 0;

   177                 appended_data[3] = source_data_types_count > 2 ?

   178                     source_data_types_native[2] : 0;

   179             }

   180         }

   181 

   182         DASSERT(!JNU_IsNull(env, component));

   183 

   184         (*env)->CallStaticVoidMethod(env, clazz, dtcp_postDropTargetEventToPeer,

   185                                      component, x, y, dropAction,

   186                                      source_actions, source_data_types,

   187                                      ptr_to_jlong(copy), event_id);

   188     }

   189 }

   190 

   191 /******************************************************************************/

   192 

   193 /********************* Embedded drop site list support ************************/

   194 

   195 struct EmbeddedDropSiteListEntryRec;

   196 

   197 typedef struct EmbeddedDropSiteListEntryRec EmbeddedDropSiteListEntry;

   198 

   199 struct EmbeddedDropSiteListEntryRec {

   200     Window toplevel;

   201     Window root;

   202     /*

   203      * We select for PropertyNotify events on the toplevel, so we need to

   204      * restore the event mask when we are done with this toplevel.

   205      */

   206     long event_mask;

   207     unsigned int embedded_sites_count;

   208     Window* embedded_sites;

   209     EmbeddedDropSiteListEntry* next;

   210 };

   211 

   212 static EmbeddedDropSiteListEntry* embedded_drop_site_list = NULL;

   213 

   214 struct EmbeddedDropSiteProtocolListEntryRec;

   215 

   216 typedef struct EmbeddedDropSiteProtocolListEntryRec EmbeddedDropSiteProtocolListEntry;

   217 

   218 struct EmbeddedDropSiteProtocolListEntryRec {

   219     Window window;

   220     Window proxy;

   221     /*

   222      * We override the XdndAware property on the toplevel, so we should keep its

   223      * original contents - the XDnD protocol version supported by the browser.

   224      * This is needed to adjust XDnD messages forwarded to the browser.

   225      */

   226     unsigned int protocol_version;

   227     /* True if the toplevel was already registered as a drag receiver and

   228        we just changed the proxy. False, otherwise */

   229     Boolean overriden;

   230     EmbeddedDropSiteProtocolListEntry* next;

   231 };

   232 

   233 static EmbeddedDropSiteProtocolListEntry* embedded_motif_protocol_list = NULL;

   234 static EmbeddedDropSiteProtocolListEntry* embedded_xdnd_protocol_list = NULL;

   235 

   236 typedef enum {

   237     RegFailure, /* Proxy registration failed */

   238     RegSuccess, /* The new drop site is registered with the new proxy */

   239     RegOverride, /* The new proxy is set for the existing drop site */

   240     RegAlreadyRegistered /* This proxy is already set for this drop site */

   241 } ProxyRegistrationStatus;

   242 

   243 /* Forward declarations. */

   244 static EmbeddedDropSiteProtocolListEntry*

   245 get_xdnd_protocol_entry_for_toplevel(Window toplevel);

   246 static EmbeddedDropSiteProtocolListEntry*

   247 get_motif_protocol_entry_for_toplevel(Window toplevel);

   248 static void remove_xdnd_protocol_entry_for_toplevel(Window toplevel);

   249 static void remove_motif_protocol_entry_for_toplevel(Window toplevel);

   250 

   251 /*

   252  * Registers the toplevel as a Motif drag receiver if it is not registered yet,

   253  * sets the specified new_proxy for it and returns the previous proxy in old_proxy.

   254  * Does nothing if the new_proxy is already set as a proxy for this toplevel.

   255  * Returns the completion status.

   256  */

   257 static ProxyRegistrationStatus

   258 set_motif_proxy(Display* dpy, Window toplevel, Window new_proxy, Window *old_proxy) {

   259     Boolean        override = False;

   260 

   261     Atom           type;

   262     int            format;

   263     unsigned long  nitems;

   264     unsigned long  after;

   265     unsigned char* data;

   266     unsigned char  ret;

   267 

   268     DASSERT(old_proxy != NULL);

   269 

   270     *old_proxy = None;

   271 

   272     data = NULL;

   273     ret = checked_XGetWindowProperty(dpy, toplevel,

   274                                      _XA_MOTIF_DRAG_RECEIVER_INFO, 0, 0xFFFF,

   275                                      False, AnyPropertyType, &type, &format,

   276                                      &nitems, &after, &data);

   277 

   278     /* Check if toplevel is a valid window. */

   279     if (ret != Success) {

   280         return RegFailure;

   281     }

   282 

   283     if (ret == Success && data != NULL && type != None && format == 8

   284         && nitems >= MOTIF_RECEIVER_INFO_SIZE) {

   285         unsigned char byte_order = read_card8((char*)data, 0);

   286         void* p = (char*)data + 4;

   287 

   288         /* Browser and plugin have different byte orders - report failure for now. */

   289         if (MOTIF_BYTE_ORDER != byte_order) {

   290             XFree(data);

   291             return RegFailure;

   292         }

   293 

   294         *old_proxy = read_card32((char*)data, 4, byte_order);

   295 

   296         /* If the proxy is already set to the specified window - return. */

   297         if (*old_proxy == new_proxy) {

   298             XFree(data);

   299             return RegAlreadyRegistered;

   300         }

   301 

   302         /* replace the proxy window */

   303         write_card32(&p, new_proxy);

   304 

   305         override = True;

   306     } else {

   307         void* p;

   308 

   309         if (ret == Success) {

   310             XFree(data);

   311             data = NULL;

   312         }

   313 

   314         data = malloc(MOTIF_RECEIVER_INFO_SIZE);

   315 

   316         if (data == NULL) {

   317             DTRACE_PRINTLN2("%s:%d malloc failed.", __FILE__, __LINE__);

   318             return RegFailure;

   319         }

   320 

   321         p = data;

   322 

   323         write_card8(&p, MOTIF_BYTE_ORDER);

   324         write_card8(&p, MOTIF_DND_PROTOCOL_VERSION); /* protocol version */

   325         write_card8(&p, MOTIF_DYNAMIC_STYLE); /* protocol style */

   326         write_card8(&p, 0); /* pad */

   327         write_card32(&p, new_proxy); /* proxy window */

   328         write_card16(&p, 0); /* num_drop_sites */

   329         write_card16(&p, 0); /* pad */

   330         write_card32(&p, MOTIF_RECEIVER_INFO_SIZE);

   331     }

   332 

   333     ret = checked_XChangeProperty(dpy, toplevel,

   334                                   _XA_MOTIF_DRAG_RECEIVER_INFO,

   335                                   _XA_MOTIF_DRAG_RECEIVER_INFO, 8,

   336                                   PropModeReplace, (unsigned char*)data,

   337                                   MOTIF_RECEIVER_INFO_SIZE);

   338 

   339     if (data != NULL) {

   340         XFree(data);

   341         data = NULL;

   342     }

   343 

   344     if (ret == Success) {

   345         if (override) {

   346             return RegOverride;

   347         } else {

   348             return RegSuccess;

   349         }

   350     } else {

   351         return RegFailure;

   352     }

   353 }

   354 

   355 /*

   356  * Registers the toplevel as a XDnD drag receiver if it is not registered yet,

   357  * sets the specified new_proxy for it and returns the previous proxy in

   358  * old_proxy and the original XDnD protocol version in old_version.

   359  * Does nothing if the new_proxy is already set as a proxy for this toplevel.

   360  * Returns the completion status.

   361  */

   362 static ProxyRegistrationStatus

   363 set_xdnd_proxy(Display* dpy, Window toplevel, Window new_proxy,

   364                Window* old_proxy, unsigned int* old_version) {

   365     Atom version_atom = XDND_PROTOCOL_VERSION;

   366     Window xdnd_proxy = None;

   367     Boolean override = False;

   368 

   369     Atom           type;

   370     int            format;

   371     unsigned long  nitems;

   372     unsigned long  after;

   373     unsigned char* data;

   374     unsigned char  ret;

   375 

   376     DASSERT(old_proxy != NULL);

   377 

   378     *old_proxy = None;

   379 

   380     data = NULL;

   381     ret = checked_XGetWindowProperty(dpy, toplevel, XA_XdndAware, 0, 1,

   382                                      False, AnyPropertyType, &type, &format,

   383                                      &nitems, &after, &data);

   384 

   385     if (ret != Success) {

   386         return RegFailure;

   387     }

   388 

   389     if (ret == Success && data != NULL && type == XA_ATOM) {

   390         unsigned int protocol_version = *((unsigned int*)data);

   391 

   392         override = True;

   393         *old_version = protocol_version;

   394 

   395         /* XdndProxy is not supported for prior to XDnD version 4 */

   396         if (protocol_version >= 4) {

   397             int status;

   398 

   399             XFree(data);

   400 

   401             data = NULL;

   402             status = XGetWindowProperty(dpy, toplevel, XA_XdndProxy, 0, 1,

   403                                         False, XA_WINDOW, &type, &format,

   404                                         &nitems, &after, &data);

   405 

   406             if (status == Success && data != NULL && type == XA_WINDOW) {

   407                 xdnd_proxy = *((Window*)data);

   408 

   409                 if (xdnd_proxy != None) {

   410                     XFree(data);

   411 

   412                     data = NULL;

   413                     status = XGetWindowProperty(dpy, xdnd_proxy, XA_XdndProxy,

   414                                                 0, 1, False, XA_WINDOW, &type,

   415                                                 &format, &nitems, &after, &data);

   416 

   417                     if (status != Success || data == NULL || type != XA_WINDOW ||

   418                         *((Window*)data) != xdnd_proxy) {

   419                         /* Ignore invalid proxy. */

   420                         xdnd_proxy = None;

   421                     }

   422                 }

   423 

   424                 if (xdnd_proxy != None) {

   425                     XFree(data);

   426 

   427                     data = NULL;

   428                     status = XGetWindowProperty(dpy, xdnd_proxy, XA_XdndAware,

   429                                                 0, 1, False, AnyPropertyType,

   430                                                 &type, &format, &nitems, &after,

   431                                                 &data);

   432 

   433                     if (status == Success && data != NULL && type == XA_ATOM) {

   434                         unsigned int proxy_version = *((unsigned int*)data);

   435 

   436                         if (proxy_version != protocol_version) {

   437                             /* Ignore invalid proxy. */

   438                             xdnd_proxy = None;

   439                         }

   440                     } else {

   441                         /* Ignore invalid proxy. */

   442                         xdnd_proxy = None;

   443                     }

   444                 }

   445             }

   446 

   447             *old_proxy = xdnd_proxy;

   448         }

   449     }

   450 

   451     XFree(data);

   452 

   453     /* If the proxy is already set to the specified window - return. */

   454     if (xdnd_proxy == new_proxy) {

   455         return RegAlreadyRegistered;

   456     }

   457 

   458     /* The proxy window must have the XdndAware set, as XDnD protocol prescribes

   459        to check the proxy window for XdndAware. */

   460     ret = checked_XChangeProperty(dpy, new_proxy, XA_XdndAware, XA_ATOM, 32,

   461                                   PropModeReplace,

   462                                   (unsigned char*)&version_atom, 1);

   463 

   464     if (ret != Success) {

   465         return RegFailure;

   466     }

   467 

   468     /* The proxy window must have the XdndProxy set to point to itself. */

   469     ret = checked_XChangeProperty(dpy, new_proxy, XA_XdndProxy, XA_WINDOW, 32,

   470                                   PropModeReplace,

   471                                   (unsigned char*)&new_proxy, 1);

   472 

   473     if (ret != Success) {

   474         return RegFailure;

   475     }

   476 

   477     ret = checked_XChangeProperty(dpy, toplevel, XA_XdndAware, XA_ATOM, 32,

   478                                   PropModeReplace,

   479                                   (unsigned char*)&version_atom, 1);

   480 

   481     if (ret != Success) {

   482         return RegFailure;

   483     }

   484 

   485     ret = checked_XChangeProperty(dpy, toplevel, XA_XdndProxy, XA_WINDOW, 32,

   486                                   PropModeReplace,

   487                                   (unsigned char*)&new_proxy, 1);

   488 

   489     if (ret == Success) {

   490         if (override) {

   491             return RegOverride;

   492         } else {

   493             return RegSuccess;

   494         }

   495     } else {

   496         return RegFailure;

   497     }

   498 }

   499 

   500 /*

   501  * 'toplevel' is the browser toplevel window. To register a drop site on the

   502  * plugin window we set the proxy for the browser toplevel window to point to

   503  * the awt_root_shell window.

   504  *

   505  * We assume that only one JVM per browser instance is possible. This

   506  * assumption is true with the current plugin implementation - it creates a

   507  * single JVM for all plugin instances created by the given plugin factory.

   508  *

   509  * When a client message event for the browser toplevel window is received, we

   510  * will iterate over drop sites registered with this toplevel and determine if

   511  * the mouse pointer is currently over one of them (there could be several

   512  * plugin windows in one browser window - for example if an HTML page contains

   513  * frames and several frames contain a plugin object).

   514  *

   515  * If the pointer is not over any of the plugin drop sites the client message

   516  * will be resent to the browser, otherwise it will be processed normally.

   517  */

   518 static EmbeddedDropSiteListEntry*

   519 awt_dnd_dt_init_proxy(Display* dpy, Window root, Window toplevel, Window window) {

   520     Window         awt_root_window = get_awt_root_window();

   521     Window         motif_proxy = None;

   522     Boolean        motif_override = False;

   523     unsigned long  event_mask = 0;

   524 

   525     if (awt_root_window == None) {

   526         return NULL;

   527     }

   528 

   529     /* Grab server, since we are working with the window that belongs to

   530        another client. REMIND: ungrab when done!!! */

   531     XGrabServer(dpy);

   532 

   533     {

   534         ProxyRegistrationStatus motif_status = RegFailure;

   535 

   536         motif_status = set_motif_proxy(dpy, toplevel, awt_root_window, &motif_proxy);

   537 

   538         switch (motif_status) {

   539         case RegFailure:

   540         case RegAlreadyRegistered:

   541             XUngrabServer(dpy);

   542             /* Workaround for bug 5039226 */

   543             XSync(dpy, False);

   544             return NULL;

   545         case RegOverride:

   546             motif_override = True;

   547             break;

   548         case RegSuccess:

   549             motif_override = False;

   550             break;

   551         default:

   552             DASSERT(False);

   553         }

   554 

   555 

   556     }

   557 

   558     {

   559         XWindowAttributes xwa;

   560         XGetWindowAttributes(dpy, toplevel, &xwa);

   561         event_mask = xwa.your_event_mask;

   562         if ((event_mask & PropertyChangeMask) == 0) {

   563             XSelectInput(dpy, toplevel, event_mask | PropertyChangeMask);

   564         }

   565     }

   566 

   567     XUngrabServer(dpy);

   568     /* Workaround for bug 5039226 */

   569     XSync(dpy, False);

   570 

   571     /* Add protocol specific entries for the toplevel. */

   572     {

   573         EmbeddedDropSiteProtocolListEntry* motif_entry = NULL;

   574 

   575         motif_entry = malloc(sizeof(EmbeddedDropSiteProtocolListEntry));

   576 

   577         if (motif_entry == NULL) {

   578             return NULL;

   579         }

   580 

   581         motif_entry->window = toplevel;

   582         motif_entry->proxy = motif_proxy;

   583         motif_entry->protocol_version = 0;

   584         motif_entry->overriden = motif_override;

   585         motif_entry->next = embedded_motif_protocol_list;

   586         embedded_motif_protocol_list = motif_entry;

   587     }

   588 

   589     {

   590         EmbeddedDropSiteListEntry* entry = NULL;

   591         Window* sites = NULL;

   592 

   593         entry = malloc(sizeof(EmbeddedDropSiteListEntry));

   594 

   595         if (entry == NULL) {

   596             return NULL;

   597         }

   598 

   599         sites = malloc(sizeof(Window));

   600 

   601         if (sites == NULL) {

   602             free(entry);

   603             return NULL;

   604         }

   605 

   606         sites[0] = window;

   607 

   608         entry->toplevel = toplevel;

   609         entry->root = root;

   610         entry->event_mask = event_mask;

   611         entry->embedded_sites_count = 1;

   612         entry->embedded_sites = sites;

   613         entry->next = NULL;

   614 

   615         return entry;

   616     }

   617 }

   618 

   619 static void

   620 register_xdnd_embedder(Display* dpy, EmbeddedDropSiteListEntry* entry, long window) {

   621     Window         awt_root_window = get_awt_root_window();

   622     Window         toplevel = entry->toplevel;

   623     Window         xdnd_proxy = None;

   624     unsigned int   xdnd_protocol_version = 0;

   625     Boolean        xdnd_override = False;

   626     Boolean        register_xdnd = True;

   627     Boolean        motif_overriden = False;

   628 

   629     EmbeddedDropSiteProtocolListEntry* motif_entry = embedded_motif_protocol_list;

   630     while (motif_entry != NULL) {

   631         if (motif_entry->window == toplevel) {

   632             motif_overriden = motif_entry->overriden;

   633             break;

   634         }

   635         motif_entry = motif_entry->next;

   636     }

   637 

   638     /*

   639      * First check if the window is an XEmbed client.

   640      * In this case we don't have to setup a proxy on the toplevel,

   641      * instead we register the XDnD drop site on the embedded window.

   642      */

   643     if (isXEmbedActiveByWindow(window)) {

   644         register_xdnd_drop_site(dpy, toplevel, window);

   645         return;

   646     }

   647 

   648     /*

   649      * By default, we register a drop site that supports both dnd

   650      * protocols. This approach is not appropriate in plugin

   651      * scenario if the browser doesn't support XDnD. If we forcibly set

   652      * XdndAware on the browser toplevel, any drag source that supports both

   653      * protocols and prefers XDnD will be unable to drop anything on the

   654      * browser.

   655      * The solution for this problem is not to register XDnD drop site

   656      * if the browser supports only Motif DnD.

   657      */

   658     if (motif_overriden) {

   659         int            status;

   660         Atom           type;

   661         int            format;

   662         unsigned long  nitems;

   663         unsigned long  after;

   664         unsigned char* data;

   665 

   666         data = NULL;

   667         status = XGetWindowProperty(dpy, toplevel, XA_XdndAware, 0, 1,

   668                                     False, AnyPropertyType, &type, &format,

   669                                     &nitems, &after, &data);

   670 

   671         XFree(data);

   672         data = NULL;

   673 

   674         if (type != XA_ATOM) {

   675             register_xdnd = False;

   676         }

   677     }

   678 

   679     if (register_xdnd) {

   680         ProxyRegistrationStatus xdnd_status;

   681         /* Grab server, since we are working with the window that belongs to

   682            another client. REMIND: ungrab when done!!! */

   683         XGrabServer(dpy);

   684 

   685         xdnd_status =

   686             set_xdnd_proxy(dpy, toplevel, awt_root_window, &xdnd_proxy,

   687                            &xdnd_protocol_version);

   688 

   689         XUngrabServer(dpy);

   690 

   691         switch (xdnd_status) {

   692         case RegFailure:

   693         case RegAlreadyRegistered:

   694             return;

   695         case RegOverride:

   696             xdnd_override = True;

   697             break;

   698         case RegSuccess:

   699             xdnd_override = False;

   700             break;

   701         default:

   702             DASSERT(False);

   703         }

   704 

   705         {

   706             EmbeddedDropSiteProtocolListEntry* xdnd_entry = NULL;

   707 

   708             xdnd_entry = malloc(sizeof(EmbeddedDropSiteProtocolListEntry));

   709 

   710             if (xdnd_entry == NULL) {

   711                 return;

   712             }

   713 

   714             xdnd_entry->window = toplevel;

   715             xdnd_entry->proxy = xdnd_proxy;

   716             xdnd_entry->protocol_version = xdnd_protocol_version;

   717             xdnd_entry->overriden = xdnd_override;

   718             xdnd_entry->next = embedded_xdnd_protocol_list;

   719             embedded_xdnd_protocol_list = xdnd_entry;

   720         }

   721     }

   722 }

   723 

   724 /*

   725  * If embedded_drop_site_list already contains an entry with the specified

   726  * 'toplevel', the method registers the specified 'window' as an embedded drop

   727  * site for this 'toplevel' and returns True.

   728  * Otherwise, it checks if the 'toplevel' is a registered drop site for adds

   729  * (window, component) pair to the list and returns True

   730  * if completes successfully.

   731  */

   732 static Boolean

   733 add_to_embedded_drop_site_list(Display* dpy, Window root, Window toplevel,

   734                                Window window) {

   735     EmbeddedDropSiteListEntry* entry = embedded_drop_site_list;

   736 

   737     while (entry != NULL) {

   738         if (entry->toplevel == toplevel) {

   739             void* p = realloc(entry->embedded_sites,

   740                               sizeof(Window) *

   741                               (entry->embedded_sites_count + 1));

   742             if (p == NULL) {

   743                 return False;

   744             }

   745             entry->embedded_sites = p;

   746             entry->embedded_sites[entry->embedded_sites_count++] = window;

   747 

   748             register_xdnd_embedder(dpy, entry, window);

   749 

   750             return True;

   751         }

   752         entry = entry->next;

   753     }

   754 

   755     entry = awt_dnd_dt_init_proxy(dpy, root, toplevel, window);

   756 

   757     if (entry == NULL) {

   758         return False;

   759     }

   760 

   761     register_xdnd_embedder(dpy, entry, window);

   762 

   763     entry->next = embedded_drop_site_list;

   764     embedded_drop_site_list = entry;

   765 

   766     return True;

   767 }

   768 

   769 /*

   770  * Removes the window from the list of embedded drop sites for the toplevel.

   771  * Returns True if the window was successfully removed, False otherwise.

   772  */

   773 static Boolean

   774 remove_from_embedded_drop_site_list(Display* dpy, Window toplevel, Window window) {

   775     EmbeddedDropSiteListEntry* entry = embedded_drop_site_list;

   776     EmbeddedDropSiteListEntry* prev = NULL;

   777 

   778     while (entry != NULL) {

   779         if (entry->toplevel == toplevel) {

   780             unsigned int idx;

   781 

   782             for (idx = 0; idx < entry->embedded_sites_count; idx++) {

   783                 if (entry->embedded_sites[idx] == window) {

   784                     int tail = entry->embedded_sites_count - idx - 1;

   785                     if (tail > 0) {

   786                         memmove(entry->embedded_sites + idx,

   787                                 entry->embedded_sites + idx + 1,

   788                                 tail * sizeof(Window));

   789                     }

   790                     entry->embedded_sites_count--;

   791 

   792                     /* If the list of embedded drop sites for this toplevel

   793                        becomes empty - restore the original proxies and remove

   794                        the entry. */

   795                     if (entry->embedded_sites_count == 0) {

   796                         Widget w = XtWindowToWidget(dpy, toplevel);

   797 

   798                         if (w != NULL) {

   799                             JNIEnv *env = (JNIEnv*)JNU_GetEnv(jvm, JNI_VERSION_1_4);

   800                             Widget copy = w;

   801                             jobject peer = findPeer(&w);

   802 

   803                             if (!JNU_IsNull(env, peer) &&

   804                                 (*env)->IsInstanceOf(env, peer,

   805                                                      get_MEmbedCanvasPeerClass(env)) == JNI_TRUE) {

   806                                 remove_xembed_drop_target(env, peer);

   807                             }

   808                         } else {

   809                             EmbeddedDropSiteProtocolListEntry* xdnd_entry =

   810                                 get_xdnd_protocol_entry_for_toplevel(toplevel);

   811                             EmbeddedDropSiteProtocolListEntry* motif_entry =

   812                                 get_motif_protocol_entry_for_toplevel(toplevel);

   813 

   814                             if (xdnd_entry != NULL) {

   815                                 if (xdnd_entry->overriden == True) {

   816                                     XChangeProperty(dpy, toplevel, XA_XdndAware,

   817                                                     XA_ATOM, 32,

   818                                                     PropModeReplace,

   819                                                     (unsigned char*)&xdnd_entry->protocol_version,

   820                                                     1);

   821 

   822                                     XChangeProperty(dpy, toplevel, XA_XdndProxy,

   823                                                     XA_WINDOW, 32,

   824                                                     PropModeReplace,

   825                                                     (unsigned char*)&xdnd_entry->proxy, 1);

   826                                 } else {

   827                                     XDeleteProperty(dpy, toplevel, XA_XdndAware);

   828                                     XDeleteProperty(dpy, toplevel, XA_XdndProxy);

   829                                 }

   830                                 remove_xdnd_protocol_entry_for_toplevel(toplevel);

   831                             }

   832 

   833                             if (motif_entry != NULL) {

   834                                 if (motif_entry->overriden == True) {

   835                                     /* Request status */

   836                                     int status;

   837 

   838                                     Atom           type;

   839                                     int            format;

   840                                     unsigned long  nitems;

   841                                     unsigned long  after;

   842                                     unsigned char* data;

   843 

   844                                     data = NULL;

   845                                     status = XGetWindowProperty(dpy, toplevel,

   846                                                                 _XA_MOTIF_DRAG_RECEIVER_INFO, 0, 0xFFFF,

   847                                                                 False, AnyPropertyType, &type, &format,

   848                                                                 &nitems, &after, &data);

   849 

   850                                     if (status == Success && data != NULL && type != None &&

   851                                         format == 8 && nitems >= MOTIF_RECEIVER_INFO_SIZE) {

   852                                         unsigned char byte_order = read_card8((char*)data, 0);

   853                                         void* p = (char*)data + 4;

   854 

   855                                         DASSERT(MOTIF_BYTE_ORDER == byte_order);

   856 

   857                                         if (MOTIF_BYTE_ORDER == byte_order) {

   858                                             /* restore the original proxy window */

   859                                             write_card32(&p, motif_entry->proxy);

   860 

   861                                             XChangeProperty(dpy, toplevel,

   862                                                             _XA_MOTIF_DRAG_RECEIVER_INFO,

   863                                                             _XA_MOTIF_DRAG_RECEIVER_INFO, 8,

   864                                                             PropModeReplace,

   865                                                             (unsigned char*)data,

   866                                                             MOTIF_RECEIVER_INFO_SIZE);

   867                                         }

   868                                     }

   869 

   870                                     if (status == Success) {

   871                                         XFree(data);

   872                                     }

   873                                 } else {

   874                                     XDeleteProperty(dpy, toplevel, _XA_MOTIF_DRAG_RECEIVER_INFO);

   875                                 }

   876 

   877                                 remove_motif_protocol_entry_for_toplevel(toplevel);

   878                             }

   879 

   880                             if ((entry->event_mask & PropertyChangeMask) == 0) {

   881                                 XSelectInput(dpy, toplevel, entry->event_mask);

   882                             }

   883                         }

   884 

   885                         if (prev == NULL) {

   886                             embedded_drop_site_list = entry->next;

   887                         } else {

   888                             prev->next = entry->next;

   889                         }

   890 

   891                         free(entry);

   892                     }

   893                     return True;

   894                 }

   895             }

   896             return False;

   897         }

   898         prev = entry;

   899         entry = entry->next;

   900     }

   901     return False;

   902 }

   903 

   904 static EmbeddedDropSiteListEntry*

   905 get_entry_for_toplevel(Window toplevel) {

   906     EmbeddedDropSiteListEntry* entry = embedded_drop_site_list;

   907 

   908     while (entry != NULL) {

   909         if (entry->toplevel == toplevel) {

   910             return entry;

   911         }

   912         entry = entry->next;

   913     }

   914     return NULL;

   915 }

   916 

   917 static EmbeddedDropSiteProtocolListEntry*

   918 get_motif_protocol_entry_for_toplevel(Window toplevel) {

   919     EmbeddedDropSiteProtocolListEntry* entry = embedded_motif_protocol_list;

   920 

   921     while (entry != NULL) {

   922         if (entry->window == toplevel) {

   923             return entry;

   924         }

   925         entry = entry->next;

   926     }

   927     return NULL;

   928 }

   929 

   930 static EmbeddedDropSiteProtocolListEntry*

   931 get_xdnd_protocol_entry_for_toplevel(Window toplevel) {

   932     EmbeddedDropSiteProtocolListEntry* entry = embedded_xdnd_protocol_list;

   933 

   934     while (entry != NULL) {

   935         if (entry->window == toplevel) {

   936             return entry;

   937         }

   938         entry = entry->next;

   939     }

   940     return NULL;

   941 }

   942 

   943 static void

   944 remove_motif_protocol_entry_for_toplevel(Window toplevel) {

   945     EmbeddedDropSiteProtocolListEntry* entry = embedded_motif_protocol_list;

   946     EmbeddedDropSiteProtocolListEntry* prev_entry = NULL;

   947 

   948     while (entry != NULL) {

   949         if (entry->window == toplevel) {

   950             if (prev_entry != NULL) {

   951                 prev_entry->next = entry->next;

   952             } else {

   953                 embedded_motif_protocol_list = entry->next;

   954             }

   955             free(entry);

   956         }

   957         entry = entry->next;

   958         prev_entry = entry;

   959     }

   960 }

   961 

   962 static void

   963 remove_xdnd_protocol_entry_for_toplevel(Window toplevel) {

   964     EmbeddedDropSiteProtocolListEntry* entry = embedded_xdnd_protocol_list;

   965     EmbeddedDropSiteProtocolListEntry* prev_entry = NULL;

   966 

   967     while (entry != NULL) {

   968         if (entry->window == toplevel) {

   969             if (prev_entry != NULL) {

   970                 prev_entry->next = entry->next;

   971             } else {

   972                 embedded_xdnd_protocol_list = entry->next;

   973             }

   974             free(entry);

   975         }

   976         entry = entry->next;

   977     }

   978 }

   979 

   980 static Boolean

   981 is_embedding_toplevel(Window toplevel) {

   982     return get_entry_for_toplevel(toplevel) != NULL;

   983 }

   984 

   985 static Window

   986 get_embedded_window(Display* dpy, Window toplevel, int x, int y) {

   987     EmbeddedDropSiteListEntry* entry = get_entry_for_toplevel(toplevel);

   988 

   989     if (entry != NULL) {

   990         unsigned int idx;

   991 

   992         for (idx = 0; idx < entry->embedded_sites_count; idx++) {

   993             Window site = entry->embedded_sites[idx];

   994             Window child = None;

   995             int x_return, y_return;

   996 

   997             if (XTranslateCoordinates(dpy, entry->root, site, x, y,

   998                                       &x_return, &y_return, &child)) {

   999                 if (x_return >= 0 && y_return >= 0) {

  1000                     XWindowAttributes xwa;

  1001                     XGetWindowAttributes(dpy, site, &xwa);

  1002                     if (xwa.map_state != IsUnmapped &&

  1003                         x_return < xwa.width && y_return < xwa.height) {

  1004                         return site;

  1005                     }

  1006                 }

  1007             }

  1008         }

  1009     }

  1010 

  1011     return None;

  1012 }

  1013 

  1014 /*

  1015  * If the toplevel is not an embedding toplevel does nothing and returns False.

  1016  * Otherwise, sets xdnd_proxy for the specified toplevel to the 'proxy_window',

  1017  * xdnd_protocol_version to 'version', xdnd_override to 'override', returns True.

  1018  */

  1019 static Boolean

  1020 set_xdnd_proxy_for_toplevel(Window toplevel, Window proxy_window,

  1021                             unsigned int version, Boolean override) {

  1022     EmbeddedDropSiteProtocolListEntry* entry =

  1023         get_xdnd_protocol_entry_for_toplevel(toplevel);

  1024 

  1025     if (entry == NULL) {

  1026         return False;

  1027     }

  1028 

  1029     entry->proxy = proxy_window;

  1030     entry->protocol_version = version;

  1031     entry->overriden = override;

  1032 

  1033     return True;

  1034 }

  1035 

  1036 /*

  1037  * If the toplevel is not an embedding toplevel does nothing and returns False.

  1038  * Otherwise, sets motif_proxy for the specified toplevel to the proxy_window,

  1039  * motif_override to 'override' and returns True.

  1040  */

  1041 static Boolean

  1042 set_motif_proxy_for_toplevel(Window toplevel, Window proxy_window, Boolean override) {

  1043     EmbeddedDropSiteProtocolListEntry* entry =

  1044         get_motif_protocol_entry_for_toplevel(toplevel);

  1045 

  1046     if (entry == NULL) {

  1047         return False;

  1048     }

  1049 

  1050     entry->proxy = proxy_window;

  1051     entry->overriden = override;

  1052 

  1053     return True;

  1054 }

  1055 

  1056 /*

  1057  * Forwards a drag notification to the embedding toplevel modifying the event

  1058  * to match the protocol version supported by the toplevel.

  1059  * Returns True if the event is sent, False otherwise.

  1060  */

  1061 static Boolean

  1062 forward_client_message_to_toplevel(Window toplevel, XClientMessageEvent* event) {

  1063     EmbeddedDropSiteProtocolListEntry* protocol_entry = NULL;

  1064     Window proxy = None;

  1065 

  1066     if (event->message_type == _XA_MOTIF_DRAG_AND_DROP_MESSAGE) {

  1067         protocol_entry = get_motif_protocol_entry_for_toplevel(toplevel);

  1068     } else {

  1069         /* Assume XDnD */

  1070         protocol_entry = get_xdnd_protocol_entry_for_toplevel(toplevel);

  1071         if (protocol_entry != NULL) {

  1072             /* Adjust the event to match the XDnD protocol version. */

  1073             unsigned int version = protocol_entry->protocol_version;

  1074             if (event->message_type == XA_XdndEnter) {

  1075                 unsigned int min_version = source_protocol_version < version ?

  1076                     source_protocol_version : version;

  1077                 event->data.l[1] = min_version << XDND_PROTOCOL_SHIFT;

  1078                 event->data.l[1] |= source_data_types_count > 3 ? XDND_DATA_TYPES_BIT : 0;

  1079             }

  1080         }

  1081     }

  1082 

  1083     if (protocol_entry == NULL) {

  1084         return False;

  1085     }

  1086 

  1087     if (!protocol_entry->overriden) {

  1088         return False;

  1089     }

  1090     proxy = protocol_entry->proxy;

  1091 

  1092     if (proxy == None) {

  1093         proxy = toplevel;

  1094     }

  1095 

  1096     event->window = toplevel;

  1097 

  1098     XSendEvent(event->display, proxy, False, NoEventMask, (XEvent*)event);

  1099 

  1100     return True;

  1101 }

  1102 

  1103 /******************************************************************************/

  1104 

  1105 /********************* Drop site list support *********************************/

  1106 

  1107 struct DropSiteListEntryRec;

  1108 

  1109 typedef struct DropSiteListEntryRec DropSiteListEntry;

  1110 

  1111 struct DropSiteListEntryRec {

  1112     Window             window;

  1113     Window             root;

  1114     /*

  1115      * The closest to the root ancestor with WM_STATE property set.

  1116      * Normally toplevel == window.

  1117      * In plugin scenario toplevel is the browser toplevel window.

  1118      */

  1119     Window             toplevel;

  1120     /*

  1121      * Java top-level position is the outer canvas position, not the shell

  1122      * window position. We need to keep the outer canvas ID (and the root ID) to

  1123      * translate from mouse position root coordinates to the Java component

  1124      * coordinates.

  1125      */

  1126     Window             outer_canvas;

  1127     jobject            component;

  1128     DropSiteListEntry* next;

  1129 };

  1130 

  1131 static DropSiteListEntry* drop_site_list = NULL;

  1132 

  1133 /*

  1134  * If drop_site_list already contains an entry with the same window,