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) puts(a)
  12
  13
  14 #define IS_DROPPABLE(view) (view!=NULL && view->droppableTypes!=NULL && \
  15                                 view->dragDestinationProcs!=NULL)
  16
  17
  18 static Bool _XErrorOccured = False;
  19
  20
  21
  22
  23 void
  24 WMSetViewDragSourceProcs(WMView *view, WMDragSourceProcs *procs)
  25 {
  26     if (view->dragSourceProcs)
  27         free(view->dragSourceProcs);
  28     view->dragSourceProcs = wmalloc(sizeof(WMDragSourceProcs));
  29
  30     *view->dragSourceProcs = *procs;
  31
  32     /* XXX fill in non-implemented stuffs */
  33 }
  34
  35
  36 /***********************************************************************/
  37
  38
  39 static int
  40 handleXError(Display *dpy, XErrorEvent *ev)
  41 {
  42     _XErrorOccured = True;
  43
  44     return 1;
  45 }
  46
  47
  48 static void
  49 protectBlock(Bool begin)
  50 {
  51     static void *oldHandler = NULL;
  52
  53     if (begin) {
  54         oldHandler = XSetErrorHandler(handleXError);
  55     } else {
  56         XSetErrorHandler(oldHandler);
  57     }
  58 }
  59
  60
  61
  62
  63 static Window
  64 makeDragIcon(WMScreen *scr, WMPixmap *pixmap)
  65 {
  66     Window window;
  67     WMSize size;
  68     unsigned long flags;
  69     XSetWindowAttributes attribs;
  70     Pixmap pix, mask;
  71
  72     if (!pixmap) {
  73         pixmap = scr->defaultObjectIcon;
  74     }
  75     size = WMGetPixmapSize(pixmap);
  76     pix = pixmap->pixmap;
  77     mask = pixmap->mask;
  78
  79     flags = CWSaveUnder|CWBackPixmap|CWOverrideRedirect|CWColormap;
  80     attribs.save_under = True;
  81     attribs.background_pixmap = pix;
  82     attribs.override_redirect = True;
  83     attribs.colormap = scr->colormap;
  84     window = XCreateWindow(scr->display, scr->rootWin, 0, 0, size.width,
  85                            size.height, 0, scr->depth, InputOutput,
  86                            scr->visual, flags, &attribs);
  87
  88 #ifdef SHAPE
  89     if (mask) {
  90         XShapeCombineMask(dpy, scr->balloon->window, ShapeBounding, 0, 0, mask,
  91                           ShapeSet);
  92     }
  93 #endif
  94
  95     return window;
  96 }
  97
  98
  99 static void
 100 slideWindow(Display *dpy, Window win, int srcX, int srcY, int dstX, int dstY)
 101 {
 102     double x, y, dx, dy;
 103     int i;
 104     int iterations;
 105
 106     iterations = WMIN(25, WMAX(abs(dstX-srcX), abs(dstY-srcY)));
 107
 108     x = srcX;
 109     y = srcY;
 110
 111     dx = (double)(dstX-srcX)/iterations;
 112     dy = (double)(dstY-srcY)/iterations;
 113
 114     for (i = 0; i <= iterations; i++) {
 115         XMoveWindow(dpy, win, x, y);
 116         XFlush(dpy);
 117
 118         wusleep(800);
 119
 120         x += dx;
 121         y += dy;
 122     }
 123 }
 124
 125
 126 static Window
 127 findChildInWindow(Display *dpy, Window toplevel, int x, int y)
 128 {
 129     Window foo, bar;
 130     Window *children;
 131     unsigned nchildren;
 132     int i;
 133
 134     if (!XQueryTree(dpy, toplevel, &foo, &bar,
 135                     &children, &nchildren) || children == NULL) {
 136         return None;
 137     }
 138
 139     /* first window that contains the point is the one */
 140     for (i = nchildren-1; i >= 0; i--) {
 141         XWindowAttributes attr;
 142
 143         if (XGetWindowAttributes(dpy, children[i], &attr)
 144             && attr.map_state == IsViewable
 145             && x >= attr.x && y >= attr.y
 146             && x < attr.x + attr.width && y < attr.y + attr.height) {
 147             Window child;
 148
 149             child = findChildInWindow(dpy, children[i],
 150                                       x - attr.x, y - attr.y);
 151
 152             XFree(children);
 153
 154             if (!child)
 155                 return toplevel;
 156             else
 157                 return child;
 158         }
 159     }
 160
 161     XFree(children);
 162     return None;
 163 }
 164
 165
 166 static WMView*
 167 findViewInToplevel(Display *dpy, Window toplevel, int x, int y)
 168 {
 169     Window child;
 170
 171     child = findChildInWindow(dpy, toplevel, x, y);
 172
 173     if (child != None)
 174         return W_GetViewForXWindow(dpy, child);
 175     else
 176         return NULL;
 177 }
 178
 179
 180
 181 static Window
 182 lookForToplevel(WMScreen *scr, Window window, Bool *isAware)
 183 {
 184     Window toplevel = None;
 185     Atom *atoms;
 186     int j, count;
 187
 188     *isAware = False;
 189
 190     atoms = XListProperties(scr->display, window, &count);
 191     for (j = 0; j < count; j++) {
 192         if (atoms[j] == scr->wmStateAtom) {
 193             toplevel = window;
 194         } else if (atoms[j] == scr->xdndAwareAtom) {
 195             *isAware = True;
 196         }
 197     }
 198     if (atoms)
 199         XFree(atoms);
 200
 201     if (toplevel == None) {
 202         Window *children;
 203         Window foo, bar;
 204         unsigned nchildren;
 205
 206         if (!XQueryTree(scr->display, window, &foo, &bar,
 207                         &children, &nchildren) || children == NULL) {
 208             return None;
 209         }
 210
 211         for (j = 0; j < nchildren; j++) {
 212             toplevel = lookForToplevel(scr, children[j], isAware);
 213             if (toplevel != None)
 214                 break;
 215         }
 216
 217         XFree(children);
 218
 219
 220     }
 221
 222     return toplevel;
 223 }
 224
 225
 226
 227 static Window
 228 findToplevelUnderDragPointer(WMScreen *scr, int x, int y, Window iconWindow)
 229 {
 230     Window foo, bar;
 231     Window *children;
 232     unsigned nchildren;
 233     Bool overSomething = False;
 234     int i;
 235
 236     if (!XQueryTree(scr->display, scr->rootWin, &foo, &bar,
 237                     &children, &nchildren) || children == NULL) {
 238         SPIT("couldnt query tree!");
 239         return None;
 240     }
 241
 242     /* try to find the window below the iconWindow by traversing
 243      * the whole window list */
 244
 245     /* first find the position of the iconWindow */
 246     for (i = nchildren-1; i >= 0; i--) {
 247         if (children[i] == iconWindow) {
 248             i--;
 249             break;
 250         }
 251     }
 252     if (i <= 0) {
 253         XFree(children);
 254         return scr->rootWin;
 255     }
 256
 257     /* first window that contains the point is the one */
 258     for (; i >= 0; i--) {
 259         XWindowAttributes attr;
 260
 261         if (XGetWindowAttributes(scr->display, children[i], &attr)
 262             && attr.map_state == IsViewable
 263             && x >= attr.x && y >= attr.y
 264             && x < attr.x + attr.width && y < attr.y + attr.height) {
 265             Window toplevel;
 266             Bool isaware;
 267
 268             overSomething = True;
 269
 270             toplevel = lookForToplevel(scr, children[i], &isaware);
 271
 272             XFree(children);
 273
 274             if (isaware)
 275                 return toplevel;
 276             else
 277                 return None;
 278         }
 279     }
 280
 281     XFree(children);
 282     if (!overSomething)
 283         return scr->rootWin;
 284     else
 285         return None;
 286 }
 287
 288
 289
 290
 291
 292
 293 static void
 294 sendClientMessage(Display *dpy, Window win, Atom message,
 295                   unsigned data1, unsigned data2, unsigned data3,
 296                   unsigned data4, unsigned data5)
 297 {
 298     XEvent ev;
 299
 300     ev.type = ClientMessage;
 301     ev.xclient.message_type = message;
 302     ev.xclient.format = 32;
 303     ev.xclient.window = win;
 304     ev.xclient.data.l[0] = data1;
 305     ev.xclient.data.l[1] = data2;
 306     ev.xclient.data.l[2] = data3;
 307     ev.xclient.data.l[3] = data4;
 308     ev.xclient.data.l[4] = data5;
 309
 310     XSendEvent(dpy, win, False, 0, &ev);
 311     XFlush(dpy);
 312 }
 313
 314
 315
 316
 317 static unsigned
 318 notifyPosition(WMScreen *scr, WMDraggingInfo *info)
 319 {
 320     unsigned operation;
 321
 322     switch (info->sourceOperation) {
 323      default:
 324         operation = None;
 325         break;
 326     }
 327
 328     sendClientMessage(scr->display, info->destinationWindow,
 329                       scr->xdndPositionAtom,
 330                       info->sourceWindow,
 331                       0, /* reserved */
 332                       info->location.x<<16|info->location.y,
 333                       info->timestamp,
 334                       operation/* operation */);
 335
 336     return 0;
 337 }
 338
 339
 340
 341 static void
 342 notifyDrop(WMScreen *scr, WMDraggingInfo *info)
 343 {
 344     sendClientMessage(scr->display, info->destinationWindow,
 345                       scr->xdndDropAtom,
 346                       info->sourceWindow,
 347                       0, /* reserved */
 348                       info->timestamp,
 349                       0, 0);
 350 }
 351
 352
 353
 354 static void
 355 notifyDragLeave(WMScreen *scr, WMDraggingInfo *info)
 356 {
 357     sendClientMessage(scr->display, info->destinationWindow,
 358                       scr->xdndLeaveAtom,
 359                       info->sourceWindow, 0, 0, 0, 0);
 360 }
 361
 362
 363
 364 static unsigned
 365 notifyDragEnter(WMScreen *scr, WMDraggingInfo *info)
 366 {
 367     unsigned d;
 368
 369     d = XDND_VERSION << 24;
 370
 371     sendClientMessage(scr->display, info->destinationWindow,
 372                       scr->xdndEnterAtom,
 373                       info->sourceWindow, d, 0, 0, 0);
 374
 375     return 0;
 376 }
 377
 378
 379
 380 static void
 381 updateDraggingInfo(WMScreen *scr, WMDraggingInfo *info,
 382                    XEvent *event, Window iconWindow)
 383 {
 384     Window toplevel;
 385     WMSize size;
 386
 387     size = WMGetPixmapSize(info->image);
 388
 389     if (event->type == MotionNotify) {
 390         info->imageLocation.x = event->xmotion.x_root-(int)size.width/2;
 391         info->imageLocation.y = event->xmotion.y_root-(int)size.height/2;
 392
 393         info->location.x = event->xmotion.x_root;
 394         info->location.y = event->xmotion.y_root;
 395         info->timestamp = event->xmotion.time;
 396
 397     } else if (event->type == ButtonRelease) {
 398         info->imageLocation.x = event->xbutton.x_root-(int)size.width/2;
 399         info->imageLocation.y = event->xbutton.y_root-(int)size.height/2;
 400
 401         info->location.x = event->xbutton.x_root;
 402         info->location.y = event->xbutton.y_root;
 403         info->timestamp = event->xbutton.time;
 404     }
 405
 406     toplevel = findToplevelUnderDragPointer(scr,
 407                                             info->location.x,
 408                                             info->location.y,
 409                                             iconWindow);
 410     info->destinationWindow = toplevel;
 411     /*
 412     if (toplevel == None) {
 413         info->destinationWindow = None;
 414     } else if (toplevel == scr->rootWin) {
 415         info->destinationWindow = scr->rootWin;
 416     } else {
 417         Window child;
 418         int x, y;
 419
 420         XTranslateCoordinates(scr->display, scr->rootWin, toplevel,
 421                               info->location.x, info->location.y,
 422                               &x, &y, &child);
 423
 424         child = findChildInWindow(scr->display, toplevel, x, y);
 425
 426         if (child != None) {
 427             info->destination = W_GetViewForXWindow(scr->display, child);
 428             if (info->destination->droppableTypes == NULL) {
 429                 info->destination = NULL;
 430             } else if (info->destination->dragDestinationProcs == NULL) {
 431                 info->destination = NULL;
 432             }
 433         } else {
 434             info->destination = NULL;
 435         }
 436         info->destinationWindow = toplevel;
 437     }
 438     */
 439 }
 440
 441
 442
 443
 444 static void
 445 processMotion(WMScreen *scr, WMDraggingInfo *info, WMDraggingInfo *oldInfo,
 446               WMRect *rect, unsigned currentAction)
 447 {
 448     unsigned action;
 449
 450     if (info->destinationWindow == None) { /* entered an unsupporeted window */
 451
 452         if (oldInfo->destinationWindow != None
 453             && oldInfo->destinationWindow != scr->rootWin) {
 454             SPIT("left window");
 455
 456             notifyDragLeave(scr, oldInfo);
 457         }
 458
 459     } else if (info->destinationWindow == scr->rootWin) {
 460
 461         if (oldInfo->destinationWindow != None
 462             && oldInfo->destinationWindow != scr->rootWin) {
 463             SPIT("left window to root");
 464
 465             notifyDragLeave(scr, oldInfo);
 466         } else {
 467             /* nothing */
 468         }
 469
 470     } else if (oldInfo->destinationWindow != info->destinationWindow) {
 471
 472         if (oldInfo->destinationWindow != None
 473             && oldInfo->destinationWindow != scr->rootWin) {
 474             notifyDragLeave(scr, oldInfo);
 475             SPIT("crossed");
 476         } else {
 477             SPIT("entered window");
 478         }
 479
 480         action = notifyDragEnter(scr, info);
 481
 482     } else {
 483
 484 #define LEFT_RECT(r, X, Y) (X < r->pos.x || Y < r->pos.y \
 485                                 || X >= r->pos.x + r->size.width \
 486                                 || Y >= r->pos.y + r->size.height)
 487
 488         if (rect->size.width == 0 ||
 489             (LEFT_RECT(rect, info->location.x, info->location.y))) {
 490
 491             action = notifyPosition(scr, info);
 492
 493             rect->size.width = 0;
 494         }
 495     }
 496
 497     /* little trick to simulate XdndStatus for local dnd */
 498     /*
 499     if (bla && action != currentAction) {
 500         XEvent ev;
 501
 502         ev.type = ClientMessage;
 503         ev.xclient.display = scr->display;
 504         ev.xclient.message_type = scr->xdndStatusAtom;
 505         ev.xclient.format = 32;
 506         ev.xclient.window = info->destinationWindow;
 507         ev.xclient.data.l[0] = info->sourceWindow;
 508         ev.xclient.data.l[1] = (action ? 1 : 0);
 509         ev.xclient.data.l[2] = 0;
 510         ev.xclient.data.l[3] = 0;
 511         ev.xclient.data.l[4] = action;
 512
 513         XPutBackEvent(scr->display, &ev);
 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 = 1;
 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     WMData *draggedData = NULL;
 588
 589
 590     wassertr(view->dragSourceProcs != NULL);
 591
 592
 593     /* prepare icon to be dragged */
 594     if (image == NULL)
 595         image = scr->defaultObjectIcon;
 596
 597     size = WMGetPixmapSize(image);
 598
 599     icon = makeDragIcon(scr, image);
 600
 601     XMoveWindow(dpy, icon, event->xmotion.x_root-(int)size.width/2,
 602                 event->xmotion.y_root-(int)size.height/2);
 603     XMapRaised(dpy, icon);
 604
 605
 606     /* init dragging info */
 607     memset(&dragInfo, 0, sizeof(WMDraggingInfo));
 608     memset(&oldDragInfo, 0, sizeof(WMDraggingInfo));
 609     dragInfo.image = image;
 610     dragInfo.sourceWindow = W_VIEW_DRAWABLE(W_TopLevelOfView(view));
 611
 612     dragInfo.destinationWindow = dragInfo.sourceWindow;
 613
 614     dragInfo.location.x = event->xmotion.x_root;
 615     dragInfo.location.y = event->xmotion.y_root;
 616     dragInfo.imageLocation = atLocation;
 617
 618
 619     /* start pointer grab */
 620     XGrabPointer(dpy, scr->rootWin, False,
 621                  ButtonPressMask|ButtonReleaseMask|ButtonMotionMask,
 622                  GrabModeSync, GrabModeAsync, None, scr->defaultCursor,
 623                  CurrentTime);
 624
 625     XFlush(dpy);
 626
 627     _XErrorOccured = False;
 628
 629     /* XXX: take ownership of XdndSelection */
 630
 631
 632     if (view->dragSourceProcs->beganDragImage != NULL) {
 633         view->dragSourceProcs->beganDragImage(view, image, atLocation);
 634     }
 635
 636     processMotion(scr, &dragInfo, &oldDragInfo, &rect, action);
 637
 638     state = 1;
 639
 640     while (state != 6 && state != 0 && !_XErrorOccured) {
 641         XAllowEvents(dpy, SyncPointer, CurrentTime);
 642         WMNextEvent(dpy, &ev);
 643
 644         switch (ev.type) {
 645          case MotionNotify:
 646             if (state >= 1 && state <= 4) {
 647                 while (XCheckTypedEvent(dpy, MotionNotify, &ev)) ;
 648
 649                 protectBlock(True);
 650
 651                 oldDragInfo = dragInfo;
 652
 653                 updateDraggingInfo(scr, &dragInfo, &ev, icon);
 654
 655                 XMoveWindow(dpy, icon, dragInfo.imageLocation.x,
 656                             dragInfo.imageLocation.y);
 657
 658                 if (state != 2) {
 659                     processMotion(scr, &dragInfo, &oldDragInfo, &rect, action);
 660                 }
 661                 protectBlock(False);
 662
 663                 /* XXXif entered a different destination, check the operation */
 664
 665                 switch (state) {
 666                  case 1:
 667                     if (oldDragInfo.destinationWindow != None
 668                          && (dragInfo.destinationWindow == None
 669                              || dragInfo.destinationWindow == scr->rootWin)) {
 670                         /* left the droppable window */
 671                         state = 2;
 672                         action = -1;
 673                     }
 674                     break;
 675
 676                  case 2:
 677                     if (dragInfo.destinationWindow != None) {
 678                         state = 1;
 679                         action = -1;
 680                     }
 681                     break;
 682
 683                  case 3:
 684                  case 4:
 685                     if (oldDragInfo.destinationWindow != None
 686                          && (dragInfo.destinationWindow == None
 687                              || dragInfo.destinationWindow == scr->rootWin)) {
 688                         /* left the droppable window */
 689                         state = 2;
 690                         action = -1;
 691                     }
 692                     break;
 693                 }
 694             }
 695             break;
 696
 697
 698          case ButtonRelease:
 699             /* if (state >= 1 && state <= 4) */ {
 700
 701                 protectBlock(True);
 702
 703                 oldDragInfo = dragInfo;
 704
 705                 updateDraggingInfo(scr, &dragInfo, &ev, icon);
 706
 707                 XMoveWindow(dpy, icon, dragInfo.imageLocation.x,
 708                             dragInfo.imageLocation.y);
 709
 710                 processMotion(scr, &dragInfo, &oldDragInfo, &rect,
 711                               action);
 712
 713                 protectBlock(False);
 714
 715                 switch (state) {
 716                  case 1:
 717                     state = 5;
 718                     timer = WMAddTimerHandler(3000, timeoutCallback,
 719                                               (void*)dragInfo.destinationWindow);
 720                     break;
 721                  case 2:
 722                     state = 0;
 723                     break;
 724                  case 3:
 725                     state = 6;
 726                     break;
 727                  case 4:
 728                     state = 0;
 729                     break;
 730                 }
 731             }
 732             break;
 733
 734
 735          case SelectionRequest:
 736
 737             draggedData = NULL;
 738
 739             break;
 740
 741          case ClientMessage:
 742             if ((state == 1 || state == 3 || state == 4 || state == 5)
 743                 && ev.xclient.message_type == scr->xdndStatusAtom
 744                 && ev.xclient.window == dragInfo.destinationWindow) {
 745
 746                 if (ev.xclient.data.l[1] & 1) {
 747                     puts("got accept msg");
 748                     /* will accept drop */
 749                     switch (state) {
 750                      case 1:
 751                      case 3:
 752                      case 4:
 753                         state = 3;
 754                         break;
 755                      case 5:
 756                         if (timer) {
 757                             WMDeleteTimerHandler(timer);
 758                             timer = NULL;
 759                         }
 760                         state = 6;
 761                         break;
 762                     }
 763                     if (ev.xclient.data.l[4] == None) {
 764                         action = 0;
 765                     } else {
 766                         action = ev.xclient.data.l[4];/*XXX*/
 767                     }
 768                 } else {
 769                     puts("got reject msg");
 770                     switch (state) {
 771                      case 1:
 772                      case 3:
 773                      case 4:
 774                         state = 4;
 775                         break;
 776                      case 5:
 777                         state = 0;
 778                         if (timer) {
 779                             WMDeleteTimerHandler(timer);
 780                             timer = NULL;
 781                         }
 782                         break;
 783                     }
 784                     action = 0;
 785                 }
 786
 787                 if (ev.xclient.data.l[1] & (1<<1)) {
 788                     rect.pos.x = ev.xclient.data.l[2] >> 16;
 789                     rect.pos.y = ev.xclient.data.l[2] & 0xffff;
 790                     rect.size.width = ev.xclient.data.l[3] >> 16;
 791                     rect.size.height = ev.xclient.data.l[3] & 0xffff;
 792                 } else {
 793                     rect.size.width = 0;
 794                 }
 795
 796             } else if ((state >= 1 && state <= 5)
 797                        && ev.xclient.message_type == scr->xdndFinishedAtom
 798                        && ev.xclient.window == dragInfo.destinationWindow) {
 799
 800                 wwarning("drag source received unexpected XdndFinished message from %x",
 801                          (unsigned)dragInfo.destinationWindow);
 802
 803                 if (state == 3 || state == 4 || state == 5) {
 804                     state = 0;
 805                     if (timer) {
 806                         WMDeleteTimerHandler(timer);
 807                         timer = NULL;
 808                     }
 809                 }
 810             }
 811
 812          default:
 813             WMHandleEvent(&ev);
 814             break;
 815         }
 816
 817         if (ostate != state) {
 818             printf("state changed to %i\n", state);
 819             if (state == 3) {
 820                 XRecolorCursor(dpy, scr->defaultCursor, &green, &back);
 821             } else if (ostate == 3) {
 822                 XRecolorCursor(dpy, scr->defaultCursor, &black, &back);
 823             }
 824             ostate = state;
 825         }
 826     }
 827
 828     if (timer) {
 829         WMDeleteTimerHandler(timer);
 830         timer = NULL;
 831     }
 832
 833     XUngrabPointer(dpy, CurrentTime);
 834
 835     SPIT("exited main loop");
 836
 837     if (_XErrorOccured || state != 6) {
 838         goto cancelled;
 839     }
 840
 841     assert(dragInfo.destinationWindow != None);
 842
 843     protectBlock(True);
 844     notifyDrop(scr, &dragInfo);
 845     protectBlock(False);
 846
 847     if (_XErrorOccured)
 848         goto cancelled;
 849
 850
 851     SPIT("dropped");
 852     /* wait for Finished message and SelectionRequest if not a local drop */
 853
 854
 855
 856     XDestroyWindow(dpy, icon);
 857     if (view->dragSourceProcs->endedDragImage != NULL) {
 858         view->dragSourceProcs->endedDragImage(view, image,
 859                                               dragInfo.imageLocation,
 860                                               True);
 861     }
 862     return;
 863
 864 cancelled:
 865     if (draggedData) {
 866         WMReleaseData(draggedData);
 867     }
 868
 869     if (slideBack) {
 870         slideWindow(dpy, icon,
 871                     dragInfo.imageLocation.x, dragInfo.imageLocation.y,
 872                     atLocation.x, atLocation.y);
 873     }
 874     XDestroyWindow(dpy, icon);
 875     if (view->dragSourceProcs->endedDragImage != NULL) {
 876         view->dragSourceProcs->endedDragImage(view, image,
 877                                               dragInfo.imageLocation,
 878                                               False);
 879     }
 880 }
 881
 882
 883
 884
 885
 886
 887
 888
 889
 890
 891
 892
 893
 894
 895
 896
 897
 898
 899 static Atom*
 900 getTypeList(Window window, XClientMessageEvent *event)
 901 {
 902     int i = 0;
 903     Atom *types = NULL;
 904
 905     if (event->data.l[1] & 1) { /* > 3 types */
 906
 907     } else {
 908         types = wmalloc(4 * sizeof(Atom));
 909         if (event->data.l[2] != None)
 910             types[i++] = event->data.l[2];
 911         if (event->data.l[3] != None)
 912             types[i++] = event->data.l[3];
 913         if (event->data.l[4] != None)
 914             types[i++] = event->data.l[4];
 915         types[i] = NULL;
 916     }
 917
 918     if (types[0] == NULL) {
 919         wwarning("received invalid drag & drop type list");
 920         //XXX       return;
 921     }
 922
 923     return types;
 924 }
 925
 926
 927
 928 void
 929 W_HandleDNDClientMessage(WMView *toplevel, XClientMessageEvent *event)
 930 {
 931     WMScreen *scr = W_VIEW_SCREEN(toplevel);
 932     WMView *view;
 933     int operation;
 934
 935     if (event->message_type == scr->xdndEnterAtom) {
 936         Atom *types;
 937         Window foo, bar;
 938         int bla;
 939         unsigned ble;
 940         puts("entered");
 941
 942         if (scr->dragInfo.sourceWindow != None) {
 943             puts("received Enter event in bad order");
 944         }
 945
 946         memset(&scr->dragInfo, 0, sizeof(WMDraggingInfo));
 947
 948
 949         if ((event->data.l[0] >> 24) > XDND_VERSION) {
 950             wwarning("received drag & drop request with unsupported version %i",
 951                     (event->data.l[0] >> 24));
 952             return;
 953         }
 954
 955         info.protocolVersion = event->data.l[0] >> 24;
 956
 957         info.sourceWindow = event->data.l[0];
 958         info.destinationWindow = event->window;
 959
 960         /* XXX */
 961         info.image = NULL;
 962
 963         XQueryPointer(scr->display, scr->rootWin, &foo, &bar,
 964                       &event->location.x, &event->location.y,
 965                       &bla, &bla, &ble);
 966
 967         view = findViewInToplevel(scr->display,
 968                                   scr->dragInfo.destinationWindow,
 969                                   scr->dragInfo.location.x,
 970                                   scr->dragInfo.location.y);
 971
 972         if (IS_DROPPABLE(view)) {
 973             operation =
 974                 view->dragDestinationProcs->draggingEntered(view,
 975                                                             &scr->dragInfo);
 976         } else {
 977             operation = 0;
 978         }
 979
 980
 981     } else if (event->message_type == scr->xdndPositionAtom
 982                && scr->dragInfo.sourceWindow == event->data.l[0]) {
 983         unsigned operation = 0;
 984
 985         scr->dragInfo.location.x = event->data.l[2] >> 16;
 986         scr->dragInfo.location.y = event->data.l[2] 0xffff;
 987
 988         if (scr->dragInfo.protocolVersion >= 1) {
 989             scr->dragInfo.timestamp = event->data.l[3];
 990             scr->dragInfo.sourceOperation = event->data.l[4];
 991         } else {
 992             scr->dragInfo.timestamp = CurrentTime;
 993             scr->dragInfo.sourceOperation = 0; /*XXX*/
 994         }
 995
 996         child = findChildInWindow(scr->display, scr->dragInfo.destinationWindow,
 997                                   scr->dragInfo.location.x,
 998                                   scr->dragInfo.location.y);
 999         if (child != None) {
1000             view = W_GetViewForXWindow(scr->display, child);
1001         } else {
1002             view = NULL;
1003         }
1004
1005         if (IS_DROPPABLE(view)) {
1006             operation =
1007                 view->dragDestinationProcs->draggingUpdated(view,
1008                                                             &scr->dragInfo);
1009         }
1010
1011         if (operation == 0) {
1012             sendClientMessage(scr->display, scr->xdndStatusAtom,
1013                               scr->dragInfo.sourceWindow,
1014                               scr->dragInfo.destinationWindow,
1015                               0, 0, 0, None);
1016         } else {
1017             Atom action;
1018
1019             switch (operation) {
1020              default:
1021                 action =;
1022                 break;
1023             }
1024
1025             sendClientMessage(scr->display, scr->xdndStatusAtom,
1026                               scr->dragInfo.sourceWindow,
1027                               scr->dragInfo.destinationWindow,
1028                               1, 0, 0, action);
1029         }
1030
1031         puts("position");
1032     } else if (event->message_type == scr->xdndLeaveAtom
1033                && scr->dragInfo.sourceWindow == event->data.l[0]) {
1034
1035         puts("leave");
1036     } else if (event->message_type == scr->xdndDropAtom
1037                && scr->dragInfo.sourceWindow == event->data.l[0]) {
1038
1039         puts("drop");
1040     }
1041 }
1042