WINGs/dragsource.c

   1
   2 #include "../src/config.h"
   3
   4 #include <X11/Xlib.h>
   5 #include <X11/Xutil.h>
   6 #include <X11/Xatom.h>
   7
   8 #ifdef SHAPE
   9 #include <X11/extensions/shape.h>
  10 #endif
  11
  12 #include <math.h>
  13
  14
  15 #include "WINGsP.h"
  16
  17
  18
  19
  20 #define SPIT(a)
  21
  22
  23 #define IS_DROPPABLE(view) (view!=NULL && view->droppableTypes!=NULL && \
  24                                 view->dragDestinationProcs!=NULL)
  25
  26
  27 static Atom operationToAction(WMScreen *scr, WMDragOperationType operation);
  28 static WMDragOperationType actionToOperation(WMScreen *scr, Atom action);
  29
  30 static Bool _XErrorOccured = False;
  31
  32
  33
  34 static unsigned
  35 defDraggingSourceOperation(WMView *self, Bool local)
  36 {
  37     return WDOperationCopy;
  38 }
  39
  40
  41 static void
  42 defBeganDragImage(WMView *self, WMPixmap *image, WMPoint point)
  43 {
  44 }
  45
  46
  47 static void
  48 defEndedDragImage(WMView *self, WMPixmap *image, WMPoint point, Bool deposited)
  49 {
  50 }
  51
  52
  53 static WMData*
  54 defFetchDragData(WMView *self, char *type)
  55 {
  56     return NULL;
  57 }
  58
  59
  60 void
  61 WMSetViewDragSourceProcs(WMView *view, WMDragSourceProcs *procs)
  62 {
  63     if (view->dragSourceProcs)
  64         wfree(view->dragSourceProcs);
  65     view->dragSourceProcs = wmalloc(sizeof(WMDragSourceProcs));
  66
  67     *view->dragSourceProcs = *procs;
  68
  69     if (procs->draggingSourceOperation == NULL) {
  70         view->dragSourceProcs->draggingSourceOperation = defDraggingSourceOperation;
  71     }
  72     if (procs->beganDragImage == NULL) {
  73         view->dragSourceProcs->beganDragImage = defBeganDragImage;
  74     }
  75     if (procs->endedDragImage == NULL) {
  76         view->dragSourceProcs->endedDragImage = defEndedDragImage;
  77     }
  78     if (procs->fetchDragData == NULL) {
  79         view->dragSourceProcs->fetchDragData = defFetchDragData;
  80     }
  81 }
  82
  83
  84 /***********************************************************************/
  85
  86
  87 static int
  88 handleXError(Display *dpy, XErrorEvent *ev)
  89 {
  90     _XErrorOccured = True;
  91
  92     return 1;
  93 }
  94
  95
  96 static void
  97 protectBlock(Bool begin)
  98 {
  99     static void *oldHandler = NULL;
 100
 101     if (begin) {
 102         oldHandler = XSetErrorHandler(handleXError);
 103     } else {
 104         XSetErrorHandler(oldHandler);
 105     }
 106 }
 107
 108
 109
 110
 111 static Window
 112 makeDragIcon(WMScreen *scr, WMPixmap *pixmap)
 113 {
 114     Window window;
 115     WMSize size;
 116     unsigned long flags;
 117     XSetWindowAttributes attribs;
 118     Pixmap pix, mask;
 119
 120     if (!pixmap) {
 121         pixmap = scr->defaultObjectIcon;
 122     }
 123     size = WMGetPixmapSize(pixmap);
 124     pix = pixmap->pixmap;
 125     mask = pixmap->mask;
 126
 127     flags = CWSaveUnder|CWBackPixmap|CWOverrideRedirect|CWColormap;
 128     attribs.save_under = True;
 129     attribs.background_pixmap = pix;
 130     attribs.override_redirect = True;
 131     attribs.colormap = scr->colormap;
 132     window = XCreateWindow(scr->display, scr->rootWin, 0, 0, size.width,
 133                            size.height, 0, scr->depth, InputOutput,
 134                            scr->visual, flags, &attribs);
 135
 136 #ifdef SHAPE
 137     if (mask) {
 138         XShapeCombineMask(scr->display, window, ShapeBounding, 0, 0, mask,
 139                           ShapeSet);
 140     }
 141 #endif
 142
 143     return window;
 144 }
 145
 146
 147 static void
 148 slideWindow(Display *dpy, Window win, int srcX, int srcY, int dstX, int dstY)
 149 {
 150     double x, y, dx, dy;
 151     int i;
 152     int iterations;
 153
 154     iterations = WMIN(25, WMAX(abs(dstX-srcX), abs(dstY-srcY)));
 155
 156     x = srcX;
 157     y = srcY;
 158
 159     dx = (double)(dstX-srcX)/iterations;
 160     dy = (double)(dstY-srcY)/iterations;
 161
 162     for (i = 0; i <= iterations; i++) {
 163         XMoveWindow(dpy, win, x, y);
 164         XFlush(dpy);
 165
 166         wusleep(800);
 167
 168         x += dx;
 169         y += dy;
 170     }
 171 }
 172
 173
 174 static Window
 175 findChildInWindow(Display *dpy, Window toplevel, int x, int y)
 176 {
 177     Window foo, bar;
 178     Window *children;
 179     unsigned nchildren;
 180     int i;
 181
 182     if (!XQueryTree(dpy, toplevel, &foo, &bar,
 183                     &children, &nchildren) || children == NULL) {
 184         return None;
 185     }
 186
 187     /* first window that contains the point is the one */
 188     for (i = nchildren-1; i >= 0; i--) {
 189         XWindowAttributes attr;
 190
 191         if (XGetWindowAttributes(dpy, children[i], &attr)
 192             && attr.map_state == IsViewable
 193             && x >= attr.x && y >= attr.y
 194             && x < attr.x + attr.width && y < attr.y + attr.height) {
 195             Window child, tmp;
 196
 197             tmp = children[i];
 198
 199             child = findChildInWindow(dpy, tmp, x - attr.x, y - attr.y);
 200
 201             XFree(children);
 202
 203             if (child == None)
 204                 return tmp;
 205             else
 206                 return child;
 207         }
 208     }
 209
 210     XFree(children);
 211     return None;
 212 }
 213
 214
 215 static WMView*
 216 findViewInToplevel(Display *dpy, Window toplevel, int x, int y)
 217 {
 218     Window child;
 219
 220     child = findChildInWindow(dpy, toplevel, x, y);
 221
 222     if (child != None) {
 223         return W_GetViewForXWindow(dpy, child);
 224     } else {
 225         return NULL;
 226     }
 227 }
 228
 229
 230
 231 static Window
 232 lookForToplevel(WMScreen *scr, Window window, Bool *isAware)
 233 {
 234     Window toplevel = None;
 235     Atom *atoms;
 236     int j, count;
 237
 238     *isAware = False;
 239
 240     atoms = XListProperties(scr->display, window, &count);
 241     for (j = 0; j < count; j++) {
 242         if (atoms[j] == scr->wmStateAtom) {
 243             toplevel = window;
 244         } else if (atoms[j] == scr->xdndAwareAtom) {
 245             *isAware = True;
 246         }
 247     }
 248     if (atoms)
 249         XFree(atoms);
 250
 251     if (toplevel == None) {
 252         Window *children;
 253         Window foo, bar;
 254         unsigned nchildren;
 255
 256         if (!XQueryTree(scr->display, window, &foo, &bar,
 257                         &children, &nchildren) || children == NULL) {
 258             return None;
 259         }
 260
 261         for (j = 0; j < nchildren; j++) {
 262             toplevel = lookForToplevel(scr, children[j], isAware);
 263             if (toplevel != None)
 264                 break;
 265         }
 266
 267         XFree(children);
 268     }
 269
 270     return toplevel;
 271 }
 272
 273
 274
 275 static Window
 276 findToplevelUnderDragPointer(WMScreen *scr, int x, int y, Window iconWindow)
 277 {
 278     Window foo, bar;
 279     Window *children;
 280     unsigned nchildren;
 281     Bool overSomething = False;
 282     int i;
 283
 284     if (!XQueryTree(scr->display, scr->rootWin, &foo, &bar,
 285                     &children, &nchildren) || children == NULL) {
 286         SPIT("couldnt query tree!");
 287         return None;
 288     }
 289
 290     /* try to find the window below the iconWindow by traversing
 291      * the whole window list */
 292
 293     /* first find the position of the iconWindow */
 294     for (i = nchildren-1; i >= 0; i--) {
 295         if (children[i] == iconWindow) {
 296             i--;
 297             break;
 298         }
 299     }
 300     if (i <= 0) {
 301         XFree(children);
 302         return scr->rootWin;
 303     }
 304
 305     /* first window that contains the point is the one */
 306     for (; i >= 0; i--) {
 307         XWindowAttributes attr;
 308
 309         if (XGetWindowAttributes(scr->display, children[i], &attr)
 310             && attr.map_state == IsViewable
 311             && x >= attr.x && y >= attr.y
 312             && x < attr.x + attr.width && y < attr.y + attr.height) {
 313             Window toplevel;
 314             Bool isaware;
 315
 316             overSomething = True;
 317
 318             toplevel = lookForToplevel(scr, children[i], &isaware);
 319
 320             XFree(children);
 321
 322             if (isaware)
 323                 return toplevel;
 324             else
 325                 return None;
 326         }
 327     }
 328
 329     XFree(children);
 330     if (!overSomething)
 331         return scr->rootWin;
 332     else
 333         return None;
 334 }
 335
 336
 337
 338
 339
 340
 341 static void
 342 sendClientMessage(Display *dpy, Window win, Atom message,
 343                   unsigned data1, unsigned data2, unsigned data3,
 344                   unsigned data4, unsigned data5)
 345 {
 346     XEvent ev;
 347
 348     ev.type = ClientMessage;
 349     ev.xclient.message_type = message;
 350     ev.xclient.format = 32;
 351     ev.xclient.window = win;
 352     ev.xclient.data.l[0] = data1;
 353     ev.xclient.data.l[1] = data2;
 354     ev.xclient.data.l[2] = data3;
 355     ev.xclient.data.l[3] = data4;
 356     ev.xclient.data.l[4] = data5;
 357
 358     XSendEvent(dpy, win, False, 0, &ev);
 359     XFlush(dpy);
 360 }
 361
 362
 363
 364
 365 static unsigned
 366 notifyPosition(WMScreen *scr, WMDraggingInfo *info)
 367 {
 368     Atom action = operationToAction(scr, info->sourceOperation);
 369
 370     sendClientMessage(scr->display, info->destinationWindow,
 371                       scr->xdndPositionAtom,
 372                       info->sourceWindow,
 373                       0, /* reserved */
 374                       info->location.x<<16|info->location.y,
 375                       info->timestamp,
 376                       action/* operation */);
 377
 378     return 0;
 379 }
 380
 381
 382
 383 static void
 384 notifyDrop(WMScreen *scr, WMDraggingInfo *info)
 385 {
 386     sendClientMessage(scr->display, info->destinationWindow,
 387                       scr->xdndDropAtom,
 388                       info->sourceWindow,
 389                       0, /* reserved */
 390                       info->timestamp,
 391                       0, 0);
 392 }
 393
 394
 395
 396 static void
 397 notifyDragLeave(WMScreen *scr, WMDraggingInfo *info)
 398 {
 399     sendClientMessage(scr->display, info->destinationWindow,
 400                       scr->xdndLeaveAtom,
 401                       info->sourceWindow, 0, 0, 0, 0);
 402 }
 403
 404
 405
 406 static unsigned
 407 notifyDragEnter(WMScreen *scr, WMDraggingInfo *info)
 408 {
 409     unsigned d;
 410
 411     d = XDND_VERSION << 24;
 412
 413     sendClientMessage(scr->display, info->destinationWindow,
 414                       scr->xdndEnterAtom,
 415                       info->sourceWindow, d, 0, 0, 0);
 416
 417     return 0;
 418 }
 419
 420
 421 static void
 422 translateCoordinates(WMScreen *scr, Window target, int fromX, int fromY,
 423                      int *x, int *y)
 424 {
 425     Window child;
 426
 427     XTranslateCoordinates(scr->display, scr->rootWin, target,
 428                           fromX, fromY, x, y, &child);
 429 }
 430
 431
 432 static void
 433 updateDraggingInfo(WMScreen *scr, WMDraggingInfo *info, WMSize offset,
 434                    XEvent *event, Window iconWindow)
 435 {
 436     Window toplevel;
 437
 438     if (event->type == MotionNotify) {
 439         info->imageLocation.x = event->xmotion.x_root-offset.width;
 440         info->imageLocation.y = event->xmotion.y_root-offset.height;
 441
 442         info->location.x = event->xmotion.x_root;
 443         info->location.y = event->xmotion.y_root;
 444 /*      info->timestamp = event->xmotion.time;*/
 445
 446     } else if (event->type == ButtonRelease) {
 447         info->imageLocation.x = event->xbutton.x_root-offset.width;
 448         info->imageLocation.y = event->xbutton.y_root-offset.height;
 449
 450         info->location.x = event->xbutton.x_root;
 451         info->location.y = event->xbutton.y_root;
 452 /*      info->timestamp = event->xbutton.time;*/
 453     }
 454
 455     toplevel = findToplevelUnderDragPointer(scr,
 456                                             info->location.x,
 457                                             info->location.y,
 458                                             iconWindow);
 459     info->destinationWindow = toplevel;
 460 }
 461
 462
 463
 464
 465 static void
 466 processMotion(WMScreen *scr, WMDraggingInfo *info, WMDraggingInfo *oldInfo,
 467               WMRect *rect, unsigned currentAction)
 468 {
 469     unsigned action;
 470
 471     if (info->destinationWindow == None) { /* entered an unsupporeted window */
 472
 473         if (oldInfo->destinationWindow != None
 474             && oldInfo->destinationWindow != scr->rootWin) {
 475             SPIT("left window");
 476
 477             notifyDragLeave(scr, oldInfo);
 478         }
 479
 480     } else if (info->destinationWindow == scr->rootWin) {
 481
 482         if (oldInfo->destinationWindow != None
 483             && oldInfo->destinationWindow != scr->rootWin) {
 484             SPIT("left window to root");
 485
 486             notifyDragLeave(scr, oldInfo);
 487         } else {
 488             /* nothing */
 489         }
 490
 491     } else if (oldInfo->destinationWindow != info->destinationWindow) {
 492
 493         if (oldInfo->destinationWindow != None
 494             && oldInfo->destinationWindow != scr->rootWin) {
 495             notifyDragLeave(scr, oldInfo);
 496             SPIT("crossed");
 497         } else {
 498             SPIT("entered window");
 499         }
 500
 501         action = notifyDragEnter(scr, info);
 502
 503     } else {
 504
 505 #define LEFT_RECT(r, X, Y) (X < r->pos.x || Y < r->pos.y \
 506                                 || X >= r->pos.x + r->size.width \
 507                                 || Y >= r->pos.y + r->size.height)
 508
 509         if (rect->size.width == 0 ||
 510             (LEFT_RECT(rect, info->location.x, info->location.y))) {
 511
 512             action = notifyPosition(scr, info);
 513
 514             rect->size.width = 0;
 515         }
 516     }
 517 }
 518
 519
 520
 521 static WMData*
 522 convertSelection(WMView *view, Atom selection, Atom target,
 523                  void *cdata, Atom *type)
 524 {
 525     WMScreen *scr = W_VIEW_SCREEN(view);
 526     WMData *data;
 527     char *typeName = XGetAtomName(scr->display, target);
 528
 529     *type = target;
 530
 531     data = view->dragSourceProcs->fetchDragData(view, typeName);
 532
 533     if (typeName != NULL)
 534         XFree(typeName);
 535
 536     return data;
 537 }
 538
 539
 540 static void
 541 selectionLost(WMView *view, Atom selection, void *cdata)
 542 {
 543     if (W_VIEW_SCREEN(view)->dragSourceView == view) {
 544         wwarning("DND selection lost during drag operation...");
 545         W_VIEW_SCREEN(view)->dragSourceView = NULL;
 546     }
 547 }
 548
 549
 550 static void
 551 selectionDone(WMView *view, Atom selection, Atom target, void *cdata)
 552 {
 553
 554 }
 555
 556
 557
 558
 559
 560 static void
 561 setMouseOffsetHint(WMView *view, WMSize mouseOffset)
 562 {
 563     WMScreen *scr = W_VIEW_SCREEN(view);
 564     long hint[2];
 565
 566     /*
 567      * Tell the offset from the topleft corner of the icon being
 568      * dragged. Not from XDND, but it's backwards compatible.
 569      */
 570
 571     hint[0] = mouseOffset.width;
 572     hint[1] = mouseOffset.height;
 573
 574     XChangeProperty(scr->display, W_VIEW_DRAWABLE(view),
 575                     scr->wmIconDragOffsetAtom, XA_INTEGER, 32,
 576                     PropModeReplace, (unsigned char*)hint, 2);
 577 }
 578
 579
 580 static Bool
 581 getMouseOffsetHint(WMScreen *scr, Window source, WMSize *mouseOffset)
 582 {
 583     long *hint;
 584     Atom type_ret;
 585     int fmt_ret;
 586     unsigned long nitems_ret, bytes_after_ret;
 587     Bool ok = False;
 588
 589
 590     hint = NULL;
 591
 592     XGetWindowProperty(scr->display, source,
 593                        scr->wmIconDragOffsetAtom, 0, 2, False, XA_INTEGER,
 594                        &type_ret, &fmt_ret, &nitems_ret, &bytes_after_ret,
 595                        (unsigned char **)&hint);
 596
 597     if (hint && nitems_ret == 2) {
 598         mouseOffset->width = hint[0];
 599         mouseOffset->height = hint[1];
 600         ok = True;
 601     }
 602     if (hint)
 603         XFree(hint);
 604
 605     return ok;
 606 }
 607
 608
 609
 610 static void
 611 timeoutCallback(void *data)
 612 {
 613     wwarning("drag & drop timed out while waiting for response from 0x%x\n",
 614              (unsigned)data);
 615     _XErrorOccured = 2;
 616 }
 617
 618 /*
 619  * State Machine For Drag Source:
 620  * ------------------------------
 621  *                                           Events
 622  * State                Call  Mtn   Ent   Lea   Crs   BUp   StA   StR   Fin   TO
 623  * 0) idle              1bu   -     -     -     -     -     -     -     -     -
 624  * 1) drag over target  -     1au   -     2cu   1cbu  5fu   3     4     1w    -
 625  * 2) drag over nothing -     2     1bu   -     -     0     -     -     2w    -
 626  * 3) drag targ+accept  -     3u    -     2cu   1cbu  6f    3     4w    0z    -
 627  * 4) drag targ+reject  -     4u    -     2cu   1cbu  0     3w    4     0z    -
 628  * 5) waiting status    -     5X    5X    5X    5X    -     6f    0     0z    0w
 629  * 6) dropped           -     -     -     -     -     -     -     -     0     0w
 630  *
 631  * Events:
 632  * Call - called WMDragImageFromView()
 633  * Mtn - Motion
 634  * Ent - Enter droppable window
 635  * Lea - Leave droppable window (or rectangle)
 636  * Crs - Leave droppable window (or rectangle) and enter another
 637  * BUp - Button Released
 638  * StA - XdndStatus client msg with Accept drop
 639  * StR - XdndStatus client msg with Reject drop
 640  * Fin - XdndFinish client msg
 641  * TO  - timeout
 642  *
 643  * Actions:
 644  * a - send update message
 645  * b - send enter message
 646  * c - send leave message
 647  * d - release drag section info
 648  * e - send drop message
 649  * f - setup timeout
 650  * u - update dragInfo
 651  *
 652  * X - ignore
 653  * w - warn about unexpected reply
 654  * z - abort operation.. unexpected reply
 655  * -   shouldnt happen
 656  */
 657 void
 658 WMDragImageFromView(WMView *view, WMPixmap *image, char *dataTypes[],
 659                     WMPoint atLocation, WMSize mouseOffset, XEvent *event,
 660                     Bool slideBack)
 661 {
 662     WMScreen *scr = view->screen;
 663     Display *dpy = scr->display;
 664     WMView *toplevel = W_TopLevelOfView(view);
 665     Window icon;
 666     XEvent ev;
 667     WMRect rect = {{0,0},{0,0}};
 668     int ostate = -1;
 669     int state;
 670     int action = -1;
 671     XColor black = {0, 0,0,0, DoRed|DoGreen|DoBlue};
 672     XColor green = {0x0045b045, 0x4500,0xb000,0x4500, DoRed|DoGreen|DoBlue};
 673     XColor back = {0, 0xffff,0xffff,0xffff, DoRed|DoGreen|DoBlue};
 674     WMDraggingInfo dragInfo;
 675     WMDraggingInfo oldDragInfo;
 676     WMHandlerID timer = NULL;
 677     static WMSelectionProcs handler = {
 678         convertSelection,
 679             selectionLost,
 680             selectionDone
 681     };
 682
 683
 684     if (scr->dragSourceView != NULL)
 685         return;
 686
 687     wassertr(view->dragSourceProcs != NULL);
 688
 689
 690     /* prepare icon to be dragged */
 691     if (image == NULL)
 692         image = scr->defaultObjectIcon;
 693
 694     icon = makeDragIcon(scr, image);
 695
 696     XMoveWindow(dpy, icon, atLocation.x, atLocation.y);
 697     XMapRaised(dpy, icon);
 698
 699
 700     /* init dragging info */
 701
 702     scr->dragSourceView = view;
 703
 704     memset(&dragInfo, 0, sizeof(WMDraggingInfo));
 705     memset(&oldDragInfo, 0, sizeof(WMDraggingInfo));
 706     dragInfo.image = image;
 707     dragInfo.sourceView = view;
 708     dragInfo.sourceWindow = W_VIEW_DRAWABLE(toplevel);
 709
 710     dragInfo.destinationWindow = dragInfo.sourceWindow;
 711
 712     dragInfo.location.x = atLocation.x + mouseOffset.width;
 713     dragInfo.location.y = atLocation.y + mouseOffset.height;
 714     dragInfo.imageLocation = atLocation;
 715
 716
 717     /* start pointer grab */
 718     XGrabPointer(dpy, scr->rootWin, False,
 719                  ButtonPressMask|ButtonReleaseMask|ButtonMotionMask,
 720                  GrabModeAsync, GrabModeAsync, None, scr->defaultCursor,
 721                  CurrentTime);
 722
 723     XFlush(dpy);
 724
 725     _XErrorOccured = False;
 726
 727     /* take ownership of XdndSelection */
 728     if (!WMCreateSelectionHandler(view, scr->xdndSelectionAtom,
 729                                   event->xmotion.time,
 730                                   &handler, NULL)) {
 731         wwarning("could not get ownership or DND selection");
 732         return;
 733     }
 734
 735     setMouseOffsetHint(toplevel, mouseOffset);
 736
 737     if (view->dragSourceProcs->beganDragImage != NULL) {
 738         view->dragSourceProcs->beganDragImage(view, image, atLocation);
 739     }
 740
 741     processMotion(scr, &dragInfo, &oldDragInfo, &rect, action);
 742
 743     state = 1;
 744
 745     while (state != 6 && state != 0 && !_XErrorOccured) {
 746         WMNextEvent(dpy, &ev);
 747
 748         switch (ev.type) {
 749          case MotionNotify:
 750             if (state >= 1 && state <= 4) {
 751                 while (XCheckTypedEvent(dpy, MotionNotify, &ev)) ;
 752
 753                 protectBlock(True);
 754
 755                 oldDragInfo = dragInfo;
 756
 757                 updateDraggingInfo(scr, &dragInfo, mouseOffset, &ev, icon);
 758
 759                 XMoveWindow(dpy, icon, dragInfo.imageLocation.x,
 760                             dragInfo.imageLocation.y);
 761
 762                 processMotion(scr, &dragInfo, &oldDragInfo, &rect, action);
 763
 764                 protectBlock(False);
 765
 766                 /* XXXif entered a different destination, check the operation */
 767
 768                 switch (state) {
 769                  case 1:
 770                     if (oldDragInfo.destinationWindow != None
 771                          && oldDragInfo.destinationWindow != scr->rootWin
 772                          && (dragInfo.destinationWindow == None
 773                              || dragInfo.destinationWindow == scr->rootWin)) {
 774                         /* left the droppable window */
 775                         state = 2;
 776                         action = -1;
 777                     }
 778                     break;
 779
 780                  case 2:
 781                     if (dragInfo.destinationWindow != None
 782                         && dragInfo.destinationWindow != scr->rootWin) {
 783
 784                         state = 1;
 785                         action = -1;
 786                     }
 787                     break;
 788
 789                  case 3:
 790                  case 4:
 791                     if (oldDragInfo.destinationWindow != None
 792                          && oldDragInfo.destinationWindow != scr->rootWin
 793                          && (dragInfo.destinationWindow == None
 794                              || dragInfo.destinationWindow == scr->rootWin)) {
 795                         /* left the droppable window */
 796                         state = 2;
 797                         action = -1;
 798                     }
 799                     break;
 800                 }
 801             }
 802             break;
 803
 804
 805          case ButtonRelease:
 806             /* if (state >= 1 && state <= 4) */ {
 807
 808                 protectBlock(True);
 809
 810                 oldDragInfo = dragInfo;
 811
 812                 updateDraggingInfo(scr, &dragInfo, mouseOffset, &ev, icon);
 813
 814                 XMoveWindow(dpy, icon, dragInfo.imageLocation.x,
 815                             dragInfo.imageLocation.y);
 816
 817                 if (state == 4 || state == 1) {
 818                     dragInfo.destinationWindow = None;
 819                     dragInfo.destView = NULL;
 820                 }
 821                 processMotion(scr, &dragInfo, &oldDragInfo, &rect, action);
 822
 823                 dragInfo.timestamp = ev.xbutton.time;
 824
 825                 protectBlock(False);
 826
 827                 switch (state) {
 828                  case 1:
 829                     state = 5;
 830                     timer = WMAddTimerHandler(3000, timeoutCallback,
 831                                               (void*)dragInfo.destinationWindow);
 832                     break;
 833                  case 2:
 834                     state = 0;
 835                     break;
 836                  case 3:
 837                     state = 6;
 838                     break;
 839                  case 4:
 840                     state = 0;
 841                     break;
 842                 }
 843             }
 844             break;
 845
 846          case ClientMessage:
 847             if ((state == 1 || state == 3 || state == 4 || state == 5)
 848                 && ev.xclient.message_type == scr->xdndStatusAtom
 849                 && ev.xclient.data.l[0] == dragInfo.destinationWindow) {
 850
 851                 if (ev.xclient.data.l[1] & 1) {
 852                     SPIT("got accept msg");
 853                     /* will accept drop */
 854                     switch (state) {
 855                      case 1:
 856                      case 3:
 857                      case 4:
 858                         state = 3;
 859                         break;
 860                      case 5:
 861                         if (timer) {
 862                             WMDeleteTimerHandler(timer);
 863                             timer = NULL;
 864                         }
 865                         state = 6;
 866                         break;
 867                     }
 868                     action = actionToOperation(scr, ev.xclient.data.l[4]);
 869                 } else {
 870                     SPIT("got reject msg");
 871                     switch (state) {
 872                      case 1:
 873                      case 3:
 874                      case 4:
 875                         state = 4;
 876                         break;
 877                      case 5:
 878                         state = 0;
 879                         if (timer) {
 880                             WMDeleteTimerHandler(timer);
 881                             timer = NULL;
 882                         }
 883                         break;
 884                     }
 885                     action = 0;
 886                 }
 887
 888                 if (ev.xclient.data.l[1] & (1<<1)) {
 889                     rect.pos.x = ev.xclient.data.l[2] >> 16;
 890                     rect.pos.y = ev.xclient.data.l[2] & 0xffff;
 891                     rect.size.width = ev.xclient.data.l[3] >> 16;
 892                     rect.size.height = ev.xclient.data.l[3] & 0xffff;
 893                 } else {
 894                     rect.size.width = 0;
 895                 }
 896
 897             } else if ((state >= 1 && state <= 5)
 898                        && ev.xclient.message_type == scr->xdndFinishedAtom
 899                        && ev.xclient.window == dragInfo.destinationWindow) {
 900
 901                 wwarning("drag source received unexpected XdndFinished message from %x",
 902                          (unsigned)dragInfo.destinationWindow);
 903
 904                 if (state == 3 || state == 4 || state == 5) {
 905                     state = 0;
 906                     if (timer) {
 907                         WMDeleteTimerHandler(timer);
 908                         timer = NULL;
 909                     }
 910                 }
 911             }
 912
 913          default:
 914             WMHandleEvent(&ev);
 915             break;
 916         }
 917
 918         if (ostate != state) {
 919             if (state == 3) {
 920                 XRecolorCursor(dpy, scr->defaultCursor, &green, &back);
 921             } else if (ostate == 3) {
 922                 XRecolorCursor(dpy, scr->defaultCursor, &black, &back);
 923             }
 924             ostate = state;
 925         }
 926     }
 927
 928     if (timer) {
 929         WMDeleteTimerHandler(timer);
 930         timer = NULL;
 931     } else if (_XErrorOccured) {
 932         /* got a timeout, send leave */
 933         notifyDragLeave(scr, &dragInfo);
 934     }
 935
 936     XUngrabPointer(dpy, CurrentTime);
 937
 938     SPIT("exited main loop");
 939
 940     if (_XErrorOccured || state != 6) {
 941         goto cancelled;
 942     }
 943
 944     assert(dragInfo.destinationWindow != None);
 945
 946     protectBlock(True);
 947     notifyDrop(scr, &dragInfo);
 948     protectBlock(False);
 949
 950     if (_XErrorOccured)
 951         goto cancelled;
 952
 953
 954     SPIT("dropped");
 955
 956
 957     XDestroyWindow(dpy, icon);
 958
 959     return;
 960
 961 cancelled:
 962     scr->dragSourceView = NULL;
 963
 964     WMDeleteSelectionHandler(view, scr->xdndSelectionAtom,
 965                              event->xmotion.time);
 966
 967     if (slideBack) {
 968         slideWindow(dpy, icon,
 969                     dragInfo.imageLocation.x, dragInfo.imageLocation.y,
 970                     atLocation.x, atLocation.y);
 971     }
 972     XDestroyWindow(dpy, icon);
 973     if (view->dragSourceProcs->endedDragImage != NULL) {
 974         view->dragSourceProcs->endedDragImage(view, image,
 975                                               dragInfo.imageLocation,
 976                                               False);
 977     }
 978 }
 979
 980
 981
 982
 983
 984
 985
 986
 987
 988
 989
 990
 991 static Atom
 992 operationToAction(WMScreen *scr, WMDragOperationType operation)
 993 {
 994     switch (operation) {
 995      case WDOperationNone:
 996         return None;
 997
 998      case WDOperationCopy:
 999         return scr->xdndActionCopy;
1000
1001      case WDOperationMove:
1002         return scr->xdndActionMove;
1003
1004      case WDOperationLink:
1005         return scr->xdndActionLink;
1006
1007      case WDOperationAsk:
1008         return scr->xdndActionAsk;
1009
1010      case WDOperationPrivate:
1011         return scr->xdndActionPrivate;
1012
1013      default:
1014         return None;
1015     }
1016 }
1017
1018
1019 static WMDragOperationType
1020 actionToOperation(WMScreen *scr, Atom action)
1021 {
1022     if (action == scr->xdndActionCopy) {
1023         return WDOperationCopy;
1024
1025     } else if (action == scr->xdndActionMove) {
1026         return WDOperationMove;
1027
1028     } else if (action == scr->xdndActionLink) {
1029         return WDOperationLink;
1030
1031     } else if (action == scr->xdndActionAsk) {
1032         return WDOperationAsk;
1033
1034     } else if (action == scr->xdndActionPrivate) {
1035         return WDOperationPrivate;
1036
1037     } else if (action == None) {
1038
1039         return WDOperationCopy;
1040     } else {
1041         char *tmp = XGetAtomName(scr->display, action);
1042
1043         wwarning("unknown XDND action %s from 0x%x", tmp,
1044                  (unsigned)scr->dragInfo.sourceWindow);
1045         XFree(tmp);
1046
1047         return WDOperationCopy;
1048     }
1049 }
1050
1051
1052
1053
1054
1055
1056 static Atom*
1057 getTypeList(Window window, XClientMessageEvent *event)
1058 {
1059     int i = 0;
1060     Atom *types = NULL;
1061
1062     if (event->data.l[1] & 1) { /* > 3 types */
1063
1064     } else {
1065         types = wmalloc(4 * sizeof(Atom));
1066         if (event->data.l[2] != None)
1067             types[i++] = event->data.l[2];
1068         if (event->data.l[3] != None)
1069             types[i++] = event->data.l[3];
1070         if (event->data.l[4] != None)
1071             types[i++] = event->data.l[4];
1072         types[i] = 0;
1073     }
1074
1075     if (types[0] == 0) {
1076         wwarning("received invalid drag & drop type list");
1077         /*XXX       return;*/
1078     }
1079
1080     return types;
1081 }
1082
1083
1084
1085 #define DISPATCH(view, func, info) (view)->dragDestinationProcs->func(view, info)
1086
1087
1088
1089 static void
1090 receivedData(WMView *view, Atom selection, Atom target,
1091              Time timestamp, void *cdata, WMData *data)
1092 {
1093     WMScreen *scr = W_VIEW_SCREEN(view);
1094     WMDraggingInfo *info = (WMDraggingInfo*)cdata;
1095     Bool res;
1096
1097     res = view->dragDestinationProcs->performDragOperation(view, info);
1098
1099     if (res) {
1100         DISPATCH(view, concludeDragOperation, info);
1101     }
1102
1103     /* send finished message */
1104     sendClientMessage(scr->display, info->sourceWindow,
1105                       scr->xdndFinishedAtom,
1106                       info->destinationWindow,
1107                       0, 0, 0, 0);
1108
1109     memset(&scr->dragInfo, 0, sizeof(WMDraggingInfo));
1110 }
1111
1112
1113
1114 void
1115 W_HandleDNDClientMessage(WMView *toplevel, XClientMessageEvent *event)
1116 {
1117     WMScreen *scr = W_VIEW_SCREEN(toplevel);
1118     WMView *oldView = NULL;
1119     WMView *newView = NULL;
1120     unsigned operation = 0;
1121     int x, y;
1122     enum {
1123         WNothing,
1124         WEnter,
1125         WLeave,
1126         WCross, /* leave one and enter another */
1127         WUpdate,
1128         WDrop
1129     };
1130     Window source;
1131     int what = WNothing;
1132     Bool sendStatus = False;
1133
1134
1135     source = scr->dragInfo.sourceWindow;
1136     oldView = scr->dragInfo.destView;
1137
1138     if (event->message_type == scr->xdndFinishedAtom) {
1139         WMView *view = scr->dragSourceView;
1140
1141         WMDeleteSelectionHandler(view, scr->xdndSelectionAtom,
1142                                  scr->dragInfo.timestamp);
1143
1144         if (view->dragSourceProcs->endedDragImage != NULL) {
1145             view->dragSourceProcs->endedDragImage(view,
1146                                                   scr->dragInfo.image,
1147                                                   scr->dragInfo.imageLocation,
1148                                                   True);
1149         }
1150
1151         scr->dragSourceView = NULL;
1152
1153         return;
1154     }
1155
1156
1157
1158     if (event->message_type == scr->xdndEnterAtom) {
1159         Window foo, bar;
1160         int bla;
1161         unsigned ble;
1162
1163         if (scr->dragInfo.sourceWindow != None) {
1164             puts("received Enter event in bad order");
1165         }
1166
1167         memset(&scr->dragInfo, 0, sizeof(WMDraggingInfo));
1168
1169
1170         if ((event->data.l[1] >> 24) > XDND_VERSION) {
1171             wwarning("received drag & drop request with unsupported version %i",
1172                     (event->data.l[1] >> 24));
1173             return;
1174         }
1175
1176         scr->dragInfo.protocolVersion = event->data.l[1] >> 24;
1177         scr->dragInfo.sourceWindow = source = event->data.l[0];
1178         scr->dragInfo.destinationWindow = event->window;
1179
1180         getMouseOffsetHint(scr, source, &scr->dragInfo.mouseOffset);
1181
1182         /* XXX */
1183         scr->dragInfo.image = NULL;
1184
1185         XQueryPointer(scr->display, scr->rootWin, &foo, &bar,
1186                       &scr->dragInfo.location.x, &scr->dragInfo.location.y,
1187                       &bla, &bla, &ble);
1188
1189         scr->dragInfo.imageLocation = scr->dragInfo.location;
1190         scr->dragInfo.imageLocation.x -= scr->dragInfo.mouseOffset.width;
1191         scr->dragInfo.imageLocation.y -= scr->dragInfo.mouseOffset.height;
1192
1193         translateCoordinates(scr, scr->dragInfo.destinationWindow,
1194                              scr->dragInfo.location.x,
1195                              scr->dragInfo.location.y, &x, &y);
1196
1197
1198         newView = findViewInToplevel(scr->display,
1199                                      scr->dragInfo.destinationWindow,
1200                                      x, y);
1201
1202     } else if (event->message_type == scr->xdndPositionAtom
1203                && scr->dragInfo.sourceWindow == event->data.l[0]) {
1204
1205         scr->dragInfo.location.x = event->data.l[2] >> 16;
1206         scr->dragInfo.location.y = event->data.l[2] & 0xffff;
1207
1208         scr->dragInfo.imageLocation = scr->dragInfo.location;
1209         scr->dragInfo.imageLocation.x -= scr->dragInfo.mouseOffset.width;
1210         scr->dragInfo.imageLocation.y -= scr->dragInfo.mouseOffset.height;
1211
1212         if (scr->dragInfo.protocolVersion >= 1) {
1213             scr->dragInfo.timestamp = event->data.l[3];
1214             scr->dragInfo.sourceOperation = actionToOperation(scr,
1215                                                             event->data.l[4]);
1216
1217         } else {
1218             scr->dragInfo.timestamp = CurrentTime;
1219             scr->dragInfo.sourceOperation = WDOperationCopy;
1220         }
1221
1222         translateCoordinates(scr, scr->dragInfo.destinationWindow,
1223                              scr->dragInfo.location.x,
1224                              scr->dragInfo.location.y, &x, &y);
1225
1226         newView = findViewInToplevel(scr->display,
1227                                      scr->dragInfo.destinationWindow,
1228                                      x, y);
1229
1230     } else if (event->message_type == scr->xdndLeaveAtom
1231                && scr->dragInfo.sourceWindow == event->data.l[0]) {
1232
1233         memset(&scr->dragInfo, 0, sizeof(WMDraggingInfo));
1234
1235     } else if (event->message_type == scr->xdndDropAtom
1236                && scr->dragInfo.sourceWindow == event->data.l[0]) {
1237
1238         /* drop */
1239         if (oldView != NULL)
1240             what = WDrop;
1241
1242     } else {
1243         return;
1244     }
1245
1246
1247     /*
1248      * Now map the XDND events to WINGs events.
1249      */
1250
1251     if (what == WNothing) {
1252         if (IS_DROPPABLE(newView)) {
1253             if (!IS_DROPPABLE(oldView)) { /* entered */
1254                 what = WEnter;
1255             } else if (oldView == newView) { /* updated */
1256                 what = WUpdate;
1257             } else {
1258                 what = WCross;
1259             }
1260         } else {
1261             if (IS_DROPPABLE(oldView)) {
1262                 what = WLeave;
1263             } else {
1264                 /* just send rejection msg */
1265                 sendStatus = True;
1266             }
1267         }
1268     }
1269
1270
1271
1272     switch (what) {
1273
1274      case WEnter:
1275         scr->dragInfo.destView = newView;
1276         operation = DISPATCH(newView, draggingEntered, &scr->dragInfo);
1277         sendStatus = True;
1278         break;
1279
1280      case WLeave:
1281         scr->dragInfo.destView = NULL;
1282         DISPATCH(oldView, draggingExited, &scr->dragInfo);
1283         sendStatus = True;
1284         operation = WDOperationNone;
1285         break;
1286
1287      case WCross:
1288         DISPATCH(oldView, draggingExited, &scr->dragInfo);
1289         scr->dragInfo.destView = newView;
1290         operation = DISPATCH(newView, draggingEntered, &scr->dragInfo);
1291         sendStatus = True;
1292         break;
1293
1294      case WUpdate:
1295         operation = DISPATCH(oldView, draggingUpdated, &scr->dragInfo);
1296         sendStatus = True;
1297         break;
1298
1299      case WDrop:
1300         {
1301             Bool res;
1302
1303             res = DISPATCH(oldView, prepareForDragOperation, &scr->dragInfo);
1304
1305             if (res) {
1306                 res = DISPATCH(oldView, performDragOperation, &scr->dragInfo);
1307             }
1308
1309             if (res) {
1310
1311             }
1312         }
1313         break;
1314
1315      default:
1316         break;
1317     }
1318
1319
1320
1321     if (sendStatus) {
1322         Atom action;
1323
1324         action = operationToAction(scr, operation);
1325
1326         sendClientMessage(scr->display, source,
1327                           scr->xdndStatusAtom,
1328                           scr->dragInfo.destinationWindow,
1329                           action != None ? 1 : 0, 0, 0, action);
1330     }
1331 }
1332
1333
1334
1335