WINGs/dragsource.c

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