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 == None)
 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 static void
 380 translateCoordinates(WMScreen *scr, Window target, int fromX, int fromY,
 381                      int *x, int *y)
 382 {
 383     Window child;
 384
 385     XTranslateCoordinates(scr->display, scr->rootWin, target,
 386                           fromX, fromY, x, y, &child);
 387 }
 388
 389
 390 static void
 391 updateDraggingInfo(WMScreen *scr, WMDraggingInfo *info,
 392                    XEvent *event, Window iconWindow)
 393 {
 394     Window toplevel;
 395     WMSize size;
 396
 397     size = WMGetPixmapSize(info->image);
 398
 399     if (event->type == MotionNotify) {
 400         info->imageLocation.x = event->xmotion.x_root-(int)size.width/2;
 401         info->imageLocation.y = event->xmotion.y_root-(int)size.height/2;
 402
 403         info->location.x = event->xmotion.x_root;
 404         info->location.y = event->xmotion.y_root;
 405         info->timestamp = event->xmotion.time;
 406
 407     } else if (event->type == ButtonRelease) {
 408         info->imageLocation.x = event->xbutton.x_root-(int)size.width/2;
 409         info->imageLocation.y = event->xbutton.y_root-(int)size.height/2;
 410
 411         info->location.x = event->xbutton.x_root;
 412         info->location.y = event->xbutton.y_root;
 413         info->timestamp = event->xbutton.time;
 414     }
 415
 416     toplevel = findToplevelUnderDragPointer(scr,
 417                                             info->location.x,
 418                                             info->location.y,
 419                                             iconWindow);
 420     info->destinationWindow = toplevel;
 421     /*
 422     if (toplevel == None) {
 423         info->destinationWindow = None;
 424     } else if (toplevel == scr->rootWin) {
 425         info->destinationWindow = scr->rootWin;
 426     } else {
 427         Window child;
 428         int x, y;
 429
 430         XTranslateCoordinates(scr->display, scr->rootWin, toplevel,
 431                               info->location.x, info->location.y,
 432                               &x, &y, &child);
 433
 434         child = findChildInWindow(scr->display, toplevel, x, y);
 435
 436         if (child != None) {
 437             info->destination = W_GetViewForXWindow(scr->display, child);
 438             if (info->destination->droppableTypes == NULL) {
 439                 info->destination = NULL;
 440             } else if (info->destination->dragDestinationProcs == NULL) {
 441                 info->destination = NULL;
 442             }
 443         } else {
 444             info->destination = NULL;
 445         }
 446         info->destinationWindow = toplevel;
 447     }
 448     */
 449 }
 450
 451
 452
 453
 454 static void
 455 processMotion(WMScreen *scr, WMDraggingInfo *info, WMDraggingInfo *oldInfo,
 456               WMRect *rect, unsigned currentAction)
 457 {
 458     unsigned action;
 459
 460     if (info->destinationWindow == None) { /* entered an unsupporeted window */
 461
 462         if (oldInfo->destinationWindow != None
 463             && oldInfo->destinationWindow != scr->rootWin) {
 464             SPIT("left window");
 465
 466             notifyDragLeave(scr, oldInfo);
 467         }
 468
 469     } else if (info->destinationWindow == scr->rootWin) {
 470
 471         if (oldInfo->destinationWindow != None
 472             && oldInfo->destinationWindow != scr->rootWin) {
 473             SPIT("left window to root");
 474
 475             notifyDragLeave(scr, oldInfo);
 476         } else {
 477             /* nothing */
 478         }
 479
 480     } else if (oldInfo->destinationWindow != info->destinationWindow) {
 481
 482         if (oldInfo->destinationWindow != None
 483             && oldInfo->destinationWindow != scr->rootWin) {
 484             notifyDragLeave(scr, oldInfo);
 485             SPIT("crossed");
 486         } else {
 487             SPIT("entered window");
 488         }
 489
 490         action = notifyDragEnter(scr, info);
 491
 492     } else {
 493
 494 #define LEFT_RECT(r, X, Y) (X < r->pos.x || Y < r->pos.y \
 495                                 || X >= r->pos.x + r->size.width \
 496                                 || Y >= r->pos.y + r->size.height)
 497
 498         if (rect->size.width == 0 ||
 499             (LEFT_RECT(rect, info->location.x, info->location.y))) {
 500
 501             action = notifyPosition(scr, info);
 502
 503             rect->size.width = 0;
 504         }
 505     }
 506
 507     /* little trick to simulate XdndStatus for local dnd */
 508     /*
 509     if (bla && action != currentAction) {
 510         XEvent ev;
 511
 512         ev.type = ClientMessage;
 513         ev.xclient.display = scr->display;
 514         ev.xclient.message_type = scr->xdndStatusAtom;
 515         ev.xclient.format = 32;
 516         ev.xclient.window = info->destinationWindow;
 517         ev.xclient.data.l[0] = info->sourceWindow;
 518         ev.xclient.data.l[1] = (action ? 1 : 0);
 519         ev.xclient.data.l[2] = 0;
 520         ev.xclient.data.l[3] = 0;
 521         ev.xclient.data.l[4] = action;
 522
 523         XPutBackEvent(scr->display, &ev);
 524     }*/
 525 }
 526
 527
 528
 529
 530 static void
 531 timeoutCallback(void *data)
 532 {
 533     wwarning("drag & drop timed out while waiting for response from 0x%x\n",
 534              (unsigned)data);
 535     _XErrorOccured = 1;
 536 }
 537
 538 /*
 539  * State Machine For Drag Source:
 540  * ------------------------------
 541  *                                           Events
 542  * State                Call  Mtn   Ent   Lea   Crs   BUp   StA   StR   Fin   TO
 543  * 0) idle              1bu   -     -     -     -     -     -     -     -     -
 544  * 1) drag over target  -     1au   -     2cu   1cbu  5fu   3     4     1w    -
 545  * 2) drag over nothing -     2     1bu   -     -     0     -     -     2w    -
 546  * 3) drag targ+accept  -     3u    -     2cu   1cbu  6f    3     4w    0z    -
 547  * 4) drag targ+reject  -     4u    -     2cu   1cbu  0     3w    4     0z    -
 548  * 5) waiting status    -     5X    5X    5X    5X    -     6f    0     0z    0w
 549  * 6) dropped           -     -     -     -     -     -     -     -     0     0w
 550  *
 551  * Events:
 552  * Call - called WMDragImageFromView()
 553  * Mtn - Motion
 554  * Ent - Enter droppable window
 555  * Lea - Leave droppable window (or rectangle)
 556  * Crs - Leave droppable window (or rectangle) and enter another
 557  * BUp - Button Released
 558  * StA - XdndStatus client msg with Accept drop
 559  * StR - XdndStatus client msg with Reject drop
 560  * Fin - XdndFinish client msg
 561  * TO  - timeout
 562  *
 563  * Actions:
 564  * a - send update message
 565  * b - send enter message
 566  * c - send leave message
 567  * d - release drag section info
 568  * e - send drop message
 569  * f - setup timeout
 570  * u - update dragInfo
 571  *
 572  * X - ignore
 573  * w - warn about unexpected reply
 574  * z - abort operation.. unexpected reply
 575  * -   shouldnt happen
 576  */
 577 void
 578 WMDragImageFromView(WMView *view, WMPixmap *image, char *dataTypes[],
 579                     WMPoint atLocation, WMSize mouseOffset, XEvent *event,
 580                     Bool slideBack)
 581 {
 582     WMScreen *scr = view->screen;
 583     Display *dpy = scr->display;
 584     Window icon;
 585     XEvent ev;
 586     WMSize size;
 587     WMRect rect = {{0,0},{0,0}};
 588     int ostate = -1;
 589     int state;
 590     int action = -1;
 591     XColor black = {0, 0,0,0, DoRed|DoGreen|DoBlue};
 592     XColor green = {0x0045b045, 0x4500,0xb000,0x4500, DoRed|DoGreen|DoBlue};
 593     XColor back = {0, 0xffff,0xffff,0xffff, DoRed|DoGreen|DoBlue};
 594     WMDraggingInfo dragInfo;
 595     WMDraggingInfo oldDragInfo;
 596     WMHandlerID timer = NULL;
 597     WMData *draggedData = NULL;
 598
 599
 600     wassertr(view->dragSourceProcs != NULL);
 601
 602
 603     /* prepare icon to be dragged */
 604     if (image == NULL)
 605         image = scr->defaultObjectIcon;
 606
 607     size = WMGetPixmapSize(image);
 608
 609     icon = makeDragIcon(scr, image);
 610
 611     XMoveWindow(dpy, icon, event->xmotion.x_root-(int)size.width/2,
 612                 event->xmotion.y_root-(int)size.height/2);
 613     XMapRaised(dpy, icon);
 614
 615
 616     /* init dragging info */
 617     memset(&dragInfo, 0, sizeof(WMDraggingInfo));
 618     memset(&oldDragInfo, 0, sizeof(WMDraggingInfo));
 619     dragInfo.image = image;
 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     /* XXX: take ownership of XdndSelection */
 640
 641
 642     if (view->dragSourceProcs->beganDragImage != NULL) {
 643         view->dragSourceProcs->beganDragImage(view, image, atLocation);
 644     }
 645
 646     processMotion(scr, &dragInfo, &oldDragInfo, &rect, action);
 647
 648     state = 1;
 649
 650     while (state != 6 && state != 0 && !_XErrorOccured) {
 651         XAllowEvents(dpy, SyncPointer, CurrentTime);
 652         WMNextEvent(dpy, &ev);
 653
 654         switch (ev.type) {
 655          case MotionNotify:
 656             if (state >= 1 && state <= 4) {
 657                 while (XCheckTypedEvent(dpy, MotionNotify, &ev)) ;
 658
 659                 protectBlock(True);
 660
 661                 oldDragInfo = dragInfo;
 662
 663                 updateDraggingInfo(scr, &dragInfo, &ev, icon);
 664
 665                 XMoveWindow(dpy, icon, dragInfo.imageLocation.x,
 666                             dragInfo.imageLocation.y);
 667
 668                 if (state != 2) {
 669                     processMotion(scr, &dragInfo, &oldDragInfo, &rect, action);
 670                 }
 671                 protectBlock(False);
 672
 673                 /* XXXif entered a different destination, check the operation */
 674
 675                 switch (state) {
 676                  case 1:
 677                     if (oldDragInfo.destinationWindow != None
 678                          && (dragInfo.destinationWindow == None
 679                              || dragInfo.destinationWindow == scr->rootWin)) {
 680                         /* left the droppable window */
 681                         state = 2;
 682                         action = -1;
 683                     }
 684                     break;
 685
 686                  case 2:
 687                     if (dragInfo.destinationWindow != None) {
 688                         state = 1;
 689                         action = -1;
 690                     }
 691                     break;
 692
 693                  case 3:
 694                  case 4:
 695                     if (oldDragInfo.destinationWindow != None
 696                          && (dragInfo.destinationWindow == None
 697                              || dragInfo.destinationWindow == scr->rootWin)) {
 698                         /* left the droppable window */
 699                         state = 2;
 700                         action = -1;
 701                     }
 702                     break;
 703                 }
 704             }
 705             break;
 706
 707
 708          case ButtonRelease:
 709             /* if (state >= 1 && state <= 4) */ {
 710
 711                 protectBlock(True);
 712
 713                 oldDragInfo = dragInfo;
 714
 715                 updateDraggingInfo(scr, &dragInfo, &ev, icon);
 716
 717                 XMoveWindow(dpy, icon, dragInfo.imageLocation.x,
 718                             dragInfo.imageLocation.y);
 719
 720                 processMotion(scr, &dragInfo, &oldDragInfo, &rect,
 721                               action);
 722
 723                 protectBlock(False);
 724
 725                 switch (state) {
 726                  case 1:
 727                     state = 5;
 728                     timer = WMAddTimerHandler(3000, timeoutCallback,
 729                                               (void*)dragInfo.destinationWindow);
 730                     break;
 731                  case 2:
 732                     state = 0;
 733                     break;
 734                  case 3:
 735                     state = 6;
 736                     break;
 737                  case 4:
 738                     state = 0;
 739                     break;
 740                 }
 741             }
 742             break;
 743
 744
 745          case SelectionRequest:
 746
 747             draggedData = NULL;
 748
 749             break;
 750
 751          case ClientMessage:
 752             if ((state == 1 || state == 3 || state == 4 || state == 5)
 753                 && ev.xclient.message_type == scr->xdndStatusAtom
 754                 && ev.xclient.window == dragInfo.destinationWindow) {
 755
 756                 if (ev.xclient.data.l[1] & 1) {
 757                     puts("got accept msg");
 758                     /* will accept drop */
 759                     switch (state) {
 760                      case 1:
 761                      case 3:
 762                      case 4:
 763                         state = 3;
 764                         break;
 765                      case 5:
 766                         if (timer) {
 767                             WMDeleteTimerHandler(timer);
 768                             timer = NULL;
 769                         }
 770                         state = 6;
 771                         break;
 772                     }
 773                     if (ev.xclient.data.l[4] == None) {
 774                         action = 0;
 775                     } else {
 776                         action = ev.xclient.data.l[4];/*XXX*/
 777                     }
 778                 } else {
 779                     puts("got reject msg");
 780                     switch (state) {
 781                      case 1:
 782                      case 3:
 783                      case 4:
 784                         state = 4;
 785                         break;
 786                      case 5:
 787                         state = 0;
 788                         if (timer) {
 789                             WMDeleteTimerHandler(timer);
 790                             timer = NULL;
 791                         }
 792                         break;
 793                     }
 794                     action = 0;
 795                 }
 796
 797                 if (ev.xclient.data.l[1] & (1<<1)) {
 798                     rect.pos.x = ev.xclient.data.l[2] >> 16;
 799                     rect.pos.y = ev.xclient.data.l[2] & 0xffff;
 800                     rect.size.width = ev.xclient.data.l[3] >> 16;
 801                     rect.size.height = ev.xclient.data.l[3] & 0xffff;
 802                 } else {
 803                     rect.size.width = 0;
 804                 }
 805
 806             } else if ((state >= 1 && state <= 5)
 807                        && ev.xclient.message_type == scr->xdndFinishedAtom
 808                        && ev.xclient.window == dragInfo.destinationWindow) {
 809
 810                 wwarning("drag source received unexpected XdndFinished message from %x",
 811                          (unsigned)dragInfo.destinationWindow);
 812
 813                 if (state == 3 || state == 4 || state == 5) {
 814                     state = 0;
 815                     if (timer) {
 816                         WMDeleteTimerHandler(timer);
 817                         timer = NULL;
 818                     }
 819                 }
 820             }
 821
 822          default:
 823             WMHandleEvent(&ev);
 824             break;
 825         }
 826
 827         if (ostate != state) {
 828             printf("state changed to %i\n", state);
 829             if (state == 3) {
 830                 XRecolorCursor(dpy, scr->defaultCursor, &green, &back);
 831             } else if (ostate == 3) {
 832                 XRecolorCursor(dpy, scr->defaultCursor, &black, &back);
 833             }
 834             ostate = state;
 835         }
 836     }
 837
 838     if (timer) {
 839         WMDeleteTimerHandler(timer);
 840         timer = NULL;
 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     /* wait for Finished message and SelectionRequest if not a local drop */
 863
 864
 865
 866     XDestroyWindow(dpy, icon);
 867     if (view->dragSourceProcs->endedDragImage != NULL) {
 868         view->dragSourceProcs->endedDragImage(view, image,
 869                                               dragInfo.imageLocation,
 870                                               True);
 871     }
 872     return;
 873
 874 cancelled:
 875     if (draggedData) {
 876         WMReleaseData(draggedData);
 877     }
 878
 879     if (slideBack) {
 880         slideWindow(dpy, icon,
 881                     dragInfo.imageLocation.x, dragInfo.imageLocation.y,
 882                     atLocation.x, atLocation.y);
 883     }
 884     XDestroyWindow(dpy, icon);
 885     if (view->dragSourceProcs->endedDragImage != NULL) {
 886         view->dragSourceProcs->endedDragImage(view, image,
 887                                               dragInfo.imageLocation,
 888                                               False);
 889     }
 890 }
 891
 892
 893
 894
 895
 896
 897
 898
 899
 900
 901
 902
 903
 904
 905
 906
 907
 908
 909 static Atom*
 910 getTypeList(Window window, XClientMessageEvent *event)
 911 {
 912     int i = 0;
 913     Atom *types = NULL;
 914
 915     if (event->data.l[1] & 1) { /* > 3 types */
 916
 917     } else {
 918         types = wmalloc(4 * sizeof(Atom));
 919         if (event->data.l[2] != None)
 920             types[i++] = event->data.l[2];
 921         if (event->data.l[3] != None)
 922             types[i++] = event->data.l[3];
 923         if (event->data.l[4] != None)
 924             types[i++] = event->data.l[4];
 925         types[i] = 0;
 926     }
 927
 928     if (types[0] == 0) {
 929         wwarning("received invalid drag & drop type list");
 930         /*XXX       return;*/
 931     }
 932
 933     return types;
 934 }
 935
 936
 937 void
 938 W_HandleDNDClientMessage(WMView *toplevel, XClientMessageEvent *event)
 939 {
 940 #if 0
 941     WMScreen *scr = W_VIEW_SCREEN(toplevel);
 942     WMView *oldView = NULL, *newView = NULL;
 943     unsigned operation = 0;
 944     int x, y;
 945
 946     if (event->message_type == scr->xdndEnterAtom) {
 947         Window foo, bar;
 948         int bla;
 949         unsigned ble;
 950         puts("entered");
 951
 952         if (scr->dragInfo.sourceWindow != None) {
 953             puts("received Enter event in bad order");
 954         }
 955
 956         memset(&scr->dragInfo, 0, sizeof(WMDraggingInfo));
 957
 958
 959         if ((event->data.l[0] >> 24) > XDND_VERSION) {
 960             wwarning("received drag & drop request with unsupported version %i",
 961                     (event->data.l[0] >> 24));
 962             return;
 963         }
 964
 965         scr->dragInfo.protocolVersion = event->data.l[1] >> 24;
 966         scr->dragInfo.sourceWindow = event->data.l[0];
 967         scr->dragInfo.destinationWindow = event->window;
 968
 969         /* XXX */
 970         scr->dragInfo.image = NULL;
 971
 972         XQueryPointer(scr->display, scr->rootWin, &foo, &bar,
 973                       &scr->dragInfo.location.x, &scr->dragInfo.location.y,
 974                       &bla, &bla, &ble);
 975
 976         translateCoordinates(scr, scr->dragInfo.destinationWindow,
 977                              scr->dragInfo.location.x,
 978                              scr->dragInfo.location.y, &x, &y);
 979
 980
 981         newView = findViewInToplevel(scr->display,
 982                                   scr->dragInfo.destinationWindow,
 983                                   x, y);
 984
 985         if (IS_DROPPABLE(view)) {
 986
 987             scr->dragInfo.destinationView = view;
 988
 989             operation =
 990                 view->dragDestinationProcs->draggingEntered(view,
 991                                                             &scr->dragInfo);
 992         }
 993         if (operation > 0) {
 994             Atom action;
 995
 996             switch (operation) {
 997              default:
 998                 action = 0;
 999                 break;
1000             }
1001
1002             sendClientMessage(scr->display, scr->dragInfo.sourceWindow,
1003                               scr->xdndStatusAtom,
1004                               scr->dragInfo.destinationWindow,
1005                               1, 0, 0, action);
1006         }
1007
1008     } else if (event->message_type == scr->xdndPositionAtom
1009                && scr->dragInfo.sourceWindow == event->data.l[0]) {
1010
1011         scr->dragInfo.location.x = event->data.l[2] >> 16;
1012         scr->dragInfo.location.y = event->data.l[2] & 0xffff;
1013
1014         if (scr->dragInfo.protocolVersion >= 1) {
1015             scr->dragInfo.timestamp = event->data.l[3];
1016             scr->dragInfo.sourceOperation = event->data.l[4];
1017         } else {
1018             scr->dragInfo.timestamp = CurrentTime;
1019             scr->dragInfo.sourceOperation = 0; /*XXX*/
1020         }
1021
1022         translateCoordinates(scr, scr->dragInfo.destinationWindow,
1023                              scr->dragInfo.location.x,
1024                              scr->dragInfo.location.y, &x, &y);
1025
1026         view = findViewInToplevel(scr->display,
1027                                   scr->dragInfo.destinationWindow,
1028                                   x, y);
1029
1030         if (scr->dragInfo.destinationView != view) {
1031             WMView *oldVIew = scr->dragInfo.destinationView;
1032
1033             oldView->dragDestinationProcs->draggingExited(oldView,
1034                                                           &scr->dragInfo);
1035
1036             scr->dragInfo.destinationView = NULL;
1037         }
1038
1039
1040         if (IS_DROPPABLE(view)) {
1041
1042
1043             operation =
1044                 view->dragDestinationProcs->draggingUpdated(view,
1045                                                             &scr->dragInfo);
1046         }
1047
1048         if (operation == 0) {
1049             sendClientMessage(scr->display, scr->dragInfo.sourceWindow,
1050                               scr->xdndStatusAtom,
1051                               scr->dragInfo.destinationWindow,
1052                               0, 0, 0, None);
1053         } else {
1054             Atom action;
1055
1056             switch (operation) {
1057              default:
1058                 action = 0;
1059                 break;
1060             }
1061
1062             sendClientMessage(scr->display, scr->dragInfo.sourceWindow,
1063                               scr->xdndStatusAtom,
1064                               scr->dragInfo.destinationWindow,
1065                               1, 0, 0, action);
1066         }
1067
1068     } else if (event->message_type == scr->xdndLeaveAtom
1069                && scr->dragInfo.sourceWindow == event->data.l[0]) {
1070
1071         void (*draggingExited)(WMView *self, WMDraggingInfo *info);
1072
1073         puts("leave");
1074     } else if (event->message_type == scr->xdndDropAtom
1075                && scr->dragInfo.sourceWindow == event->data.l[0]) {
1076
1077
1078
1079         puts("drop");
1080     }
1081 #endif
1082 }
1083