src/xdnd.c

   1 /* Many part of code are ripped of an example from JX's site */
   2
   3 #include "wconfig.h"
   4
   5 #ifdef XDND
   6
   7 #include <X11/Xlib.h>
   8 #include "WindowMaker.h"
   9 #include "window.h"
  10 #include "dock.h"
  11 #include "xdnd.h"
  12 #include "motif.h"
  13
  14 #include "workspace.h"
  15
  16 #include "stdlib.h"
  17
  18 #include <X11/Xatom.h>
  19
  20
  21 #define XDND_VERSION 3L
  22
  23 Atom _XA_XdndAware;
  24 Atom _XA_XdndEnter;
  25 Atom _XA_XdndLeave;
  26 Atom _XA_XdndDrop;
  27 Atom _XA_XdndPosition;
  28 Atom _XA_XdndStatus;
  29 Atom _XA_XdndActionCopy;
  30 Atom _XA_XdndSelection;
  31 Atom _XA_XdndFinished;
  32 Atom _XA_WINDOWMAKER_XDNDEXCHANGE;
  33
  34 /*
  35 Atom _XA_MOTIF_DRAG_RECEIVER_INFO;
  36 Atom _XA_MOTIF_DRAG_AND_DROP_MESSAGE;
  37 */
  38
  39 Atom atom_support;
  40
  41 void wXDNDInitializeAtoms()
  42 {
  43
  44     _XA_XdndAware = XInternAtom(dpy, "XdndAware", False);
  45     _XA_XdndEnter = XInternAtom(dpy, "XdndEnter", False);
  46     _XA_XdndLeave = XInternAtom(dpy, "XdndLeave", False);
  47     _XA_XdndDrop = XInternAtom(dpy, "XdndDrop", False);
  48     _XA_XdndPosition = XInternAtom(dpy, "XdndPosition", False);
  49     _XA_XdndStatus = XInternAtom(dpy, "XdndStatus", False);
  50     _XA_XdndActionCopy = XInternAtom(dpy, "XdndActionCopy", False);
  51     _XA_XdndSelection = XInternAtom(dpy, "XdndSelection", False);
  52     _XA_XdndFinished = XInternAtom(dpy, "XdndFinished", False);
  53
  54     _XA_WINDOWMAKER_XDNDEXCHANGE = XInternAtom(dpy, "_WINDOWMAKER_XDNDEXCHANGE", False);
  55
  56     /*
  57     _XA_MOTIF_DRAG_RECEIVER_INFO = XInternAtom(dpy, "_MOTIF_DRAG_RECEIVER_INFO",False);
  58     _XA_MOTIF_DRAG_AND_DROP_MESSAGE = XInternAtom(dpy, "_MOTIF_DRAG_AND_DROP_MESSAGE", False);
  59     */
  60 }
  61
  62 void wXDNDMakeAwareness(Window window) {
  63     long int xdnd_version = 3;
  64     /*
  65     MotifDragReceiverInfo info;
  66     */
  67     XChangeProperty (dpy, window, _XA_XdndAware, XA_ATOM,
  68             32, PropModeAppend, (char *)&xdnd_version, 1);
  69
  70     /*** MOTIF ***
  71     info.byte_order = '\0';
  72     info.protocol_version = 0;
  73     info.protocol_style = XmDRAG_DYNAMIC;
  74     info.proxy_window = 0;
  75     info.num_drop_sites = 0;
  76     info.total_size = sizeof(info);
  77
  78     XChangeProperty (dpy, window,
  79                    _XA_MOTIF_DRAG_RECEIVER_INFO,
  80                    _XA_MOTIF_DRAG_RECEIVER_INFO,
  81                    8, PropModeReplace,
  82                    (unsigned char *)&info,
  83                    sizeof (info));
  84                    */
  85 }
  86
  87 void wXDNDClearAwareness(Window window) {
  88     long int xdnd_version = 3;
  89     XDeleteProperty (dpy, window, _XA_XdndAware);
  90 }
  91
  92 Bool
  93 wXDNDProcessSelection(XEvent *event)
  94 {
  95         WScreen *scr = wScreenForWindow(event->xselection.requestor);
  96     char *dropdata;
  97     char *retain;
  98     Atom ret_type;
  99     int ret_format;
 100     unsigned long ret_item;
 101     unsigned long remain_byte;
 102     char * delme;
 103     XEvent xevent;
 104     Window selowner = XGetSelectionOwner(dpy,_XA_XdndSelection);
 105     WMBag *items;
 106
 107
 108     XGetWindowProperty(dpy, event->xselection.requestor,
 109             _XA_WINDOWMAKER_XDNDEXCHANGE,
 110             0, 65536, True, atom_support, &ret_type, &ret_format,
 111             &ret_item, &remain_byte, (unsigned char **)&delme);
 112     if (delme){
 113                 scr->xdestring=delme;
 114     }
 115
 116     /*send finished*/
 117     memset (&xevent, 0, sizeof(xevent));
 118     xevent.xany.type = ClientMessage;
 119     xevent.xany.display = dpy;
 120     xevent.xclient.window = selowner;
 121     xevent.xclient.message_type = _XA_XdndFinished;
 122     xevent.xclient.format = 32;
 123     XDND_FINISHED_TARGET_WIN(&xevent) = event->xselection.requestor;
 124     XSendEvent(dpy, selowner, 0, 0, &xevent);
 125
 126     /*process dropping*/
 127     if (scr->xdestring) {
 128         int length, str_size;
 129         int total_size = 0;
 130         char *tmp;
 131
 132         items = WMCreateBag(1);
 133         retain = wstrdup(scr->xdestring);
 134         XFree(scr->xdestring); /* since xdestring was created by Xlib */
 135
 136         length = strlen(retain);
 137
 138         /* search in string */
 139         while (length--) {
 140             if (retain[length] == '\r') { /* useless char, nuke it */
 141                 retain[length] = 0;
 142             }
 143             if (retain[length] == '\n') {
 144                 str_size = strlen(&retain[length + 1]);
 145                 if(str_size) {
 146                     WMPutInBag(items, wstrdup(&retain[length + 1]));
 147                     total_size += str_size + 3; /* reserve for " \"\"" */
 148                     if (length)
 149                         WMAppendBag(items, WMCreateBag(1));
 150                 }
 151                 retain[length] = 0;
 152             }
 153         }
 154         /* final one */
 155         WMPutInBag(items, wstrdup(retain));
 156         total_size += strlen(retain) + 3;
 157         free(retain);
 158
 159         /* now pack new string */
 160         scr->xdestring = wmalloc(total_size);
 161         scr->xdestring[0]=0; /* empty string */
 162         for(length = WMGetBagItemCount(items)-1; length >=0; length--) {
 163             tmp = WMGetFromBag(items, length);
 164             if (!strncmp(tmp,"file:",5)) {
 165                 /* add more 2 chars while removing 5 is harmless */
 166                 strcat(scr->xdestring, " \"");
 167                 strcat(scr->xdestring, &tmp[5]);
 168                 strcat(scr->xdestring, "\"");
 169             } else {
 170                 /* unsupport object, still need more " ? tell ]d */
 171                 strcat(scr->xdestring, &tmp[5]);
 172             }
 173             free(tmp);
 174         }
 175         WMFreeBag(items);
 176         wDockReceiveDNDDrop(scr,event);
 177         printf("free ");
 178         puts(scr->xdestring);
 179         free(scr->xdestring); /* this xdestring is not from Xlib (no XFree) */
 180     }
 181 }
 182
 183 Bool
 184 isAwareXDND(Window window)
 185 {
 186     Atom actual;
 187     int format;
 188     unsigned long count, remaining;
 189     unsigned char *data=0;
 190     Atom *types, *t;
 191
 192     if (!window) return False;
 193     XGetWindowProperty (dpy, window, _XA_XdndAware,
 194                     0, 0x8000000L, False, XA_ATOM,
 195                     &actual, &format,
 196                     &count, &remaining, &data);
 197     if (actual != XA_ATOM || format != 32 || count == 0 || !data) {
 198         if (data)
 199             XFree (data);
 200         return False;
 201     }
 202     if (data)
 203         XFree (data);
 204     return True;
 205 }
 206
 207 Bool
 208 acceptXDND(Window window)
 209 {
 210         WScreen *scr = wScreenForWindow(window);
 211     WWindow *wwin = wWindowFor(window);
 212     WDock *dock;
 213     int icon_pos,i;
 214
 215     icon_pos = -1;
 216     if ((dock = scr->dock)!=NULL) {
 217         for (i=0; i<dock->max_icons; i++) {
 218             if (dock->icon_array[i]
 219                 && dock->icon_array[i]->icon->core->window==window) {
 220                 icon_pos = i;
 221                 break;
 222             }
 223         }
 224     }
 225     if (icon_pos<0 && (dock = scr->workspaces[scr->current_workspace]->clip)!=NULL) {
 226         for (i=0; i<dock->max_icons; i++) {
 227             if (dock->icon_array[i]
 228                 && dock->icon_array[i]->icon->core->window==window) {
 229                 icon_pos = i;
 230                 break;
 231             }
 232         }
 233     }
 234     if (icon_pos<0) return False;
 235     if (!dock) return False;
 236     if (isAwareXDND(dock->icon_array[icon_pos]->icon->icon_win)) return False;
 237
 238     if (dock->icon_array[icon_pos]->dnd_command!=NULL) return True;
 239
 240     return False;
 241 }
 242
 243 Bool
 244 wXDNDProcessClientMessage(XClientMessageEvent *event)
 245 {
 246     /* test */
 247     {
 248     char * name = XGetAtomName(dpy, event->message_type);
 249     /*
 250     printf("Get %s\n",name);
 251     */
 252     XFree(name);
 253     }
 254
 255     /*
 256     if (event->message_type == _XA_MOTIF_DRAG_AND_DROP_MESSAGE) {
 257         printf("motif dnd msg %d\n",event->data.b[0]);
 258         if (event->data.b[0] == XmDROP_START){
 259             unsigned x_root, y_root, flags;
 260             unsigned char reason;
 261             unsigned long timestamp;
 262             Atom atom;
 263             Window source_window;
 264             MotifDragInitiatorInfo *initiator_info;
 265             Atom ret_type;
 266             int ret_format;
 267             unsigned long ret_item;
 268             unsigned long remain_byte;
 269
 270             reason = event->data.b[0];
 271             flags = event->data.s[1];
 272             timestamp = event->data.l[1];
 273             x_root = event->data.s[4];
 274             y_root = event->data.s[5];
 275             atom = event->data.l[3];
 276             source_window = event->data.l[4];
 277
 278     XGetWindowProperty(dpy, source_window, atom,
 279             0, sizeof(*initiator_info), True, atom_support,
 280             &ret_type, &ret_format,
 281             &ret_item, &remain_byte, (unsigned char **)&initiator_info);
 282         }
 283     }
 284     else */
 285     if (event->message_type == _XA_XdndEnter) {
 286         if ((event->data.l[1] & 1) == 0){
 287             atom_support = event->data.l[2];
 288         }
 289         /*
 290         else puts("enter more than 3 types");
 291         */
 292         return True;
 293     } else if (event->message_type == _XA_XdndLeave) {
 294         return True;
 295     } else if (event->message_type == _XA_XdndDrop) {
 296         if (event->data.l[0] == XGetSelectionOwner(dpy, _XA_XdndSelection)){
 297             XConvertSelection(dpy, _XA_XdndSelection, atom_support,
 298                     _XA_WINDOWMAKER_XDNDEXCHANGE, event->window, CurrentTime);
 299         }
 300         /*
 301         else puts("wierd selection owner");
 302         */
 303         return True;
 304     } else if (event->message_type == _XA_XdndPosition) {
 305         XEvent xevent;
 306         Window srcwin = event->data.l[0];
 307         if (atom_support != XInternAtom(dpy, "text/uri-list", False)) {
 308             return True;
 309         }
 310         {
 311             memset (&xevent, 0, sizeof(xevent));
 312             xevent.xany.type = ClientMessage;
 313             xevent.xany.display = dpy;
 314             xevent.xclient.window = srcwin;
 315             xevent.xclient.message_type = _XA_XdndStatus;
 316             xevent.xclient.format = 32;
 317
 318             XDND_STATUS_TARGET_WIN (&xevent) = event->window;
 319             XDND_STATUS_WILL_ACCEPT_SET (&xevent, acceptXDND(event->window));
 320             XDND_STATUS_WANT_POSITION_SET(&xevent, True);
 321             XDND_STATUS_RECT_SET(&xevent, 0, 0, 1024,768);
 322             XDND_STATUS_ACTION(&xevent) = _XA_XdndActionCopy;
 323
 324             XSendEvent(dpy, srcwin, 0, 0, &xevent);
 325         }
 326         return True;
 327     }
 328     return False;
 329 }
 330
 331 #endif