WINGs/dragsource.c

   1
   2
   3 #include "wconfig.h"
   4 #include "WINGsP.h"
   5
   6 #include <X11/Xatom.h>
   7 #include <X11/cursorfont.h>
   8 #ifdef SHAPE
   9 #include <X11/extensions/shape.h>
  10 #endif
  11
  12
  13
  14 #define XDND_DESTINATION_RESPONSE_MAX_DELAY 10000
  15 #define MIN_X_MOVE_OFFSET 5
  16 #define MIN_Y_MOVE_OFFSET 5
  17 #define MAX_SLIDEBACK_ITER 15
  18
  19 #define VERSION_INFO(dragInfo) dragInfo->protocolVersion
  20 #define XDND_PROPERTY_FORMAT 32
  21 #define XDND_ACTION_DESCRIPTION_FORMAT 8
  22
  23 #define XDND_SOURCE_INFO(dragInfo) dragInfo->sourceInfo
  24 #define XDND_DEST_WIN(dragInfo) dragInfo->sourceInfo->destinationWindow
  25 #define XDND_SOURCE_ACTION(dragInfo) dragInfo->sourceAction
  26 #define XDND_DEST_ACTION(dragInfo) dragInfo->destinationAction
  27 #define XDND_SOURCE_VIEW(dragInfo) dragInfo->sourceInfo->sourceView
  28 #define XDND_SOURCE_STATE(dragInfo) dragInfo->sourceInfo->state
  29 #define XDND_SELECTION_PROCS(dragInfo) dragInfo->sourceInfo->selectionProcs
  30 #define XDND_DRAG_ICON(dragInfo) dragInfo->sourceInfo->icon
  31 #define XDND_MOUSE_OFFSET(dragInfo) dragInfo->sourceInfo->mouseOffset
  32 #define XDND_DRAG_CURSOR(dragInfo) dragInfo->sourceInfo->dragCursor
  33 #define XDND_DRAG_ICON_POS(dragInfo) dragInfo->sourceInfo->imageLocation
  34 #define XDND_NO_POS_ZONE(dragInfo) dragInfo->sourceInfo->noPositionMessageZone
  35 #define XDND_TIMESTAMP(dragInfo) dragInfo->timestamp
  36 #define XDND_3_TYPES(dragInfo) dragInfo->sourceInfo->firstThreeTypes
  37 #define XDND_SOURCE_VIEW_STORED(dragInfo) dragInfo->sourceInfo != NULL \
  38     && dragInfo->sourceInfo->sourceView != NULL
  39
  40
  41 static WMHandlerID dndSourceTimer = NULL;
  42
  43
  44 static void* idleState(WMView *srcView, XClientMessageEvent *event,
  45                        WMDraggingInfo *info);
  46 static void* dropAllowedState(WMView *srcView, XClientMessageEvent *event,
  47                               WMDraggingInfo *info);
  48 static void* finishDropState(WMView *srcView, XClientMessageEvent *event,
  49                              WMDraggingInfo *info);
  50
  51 #ifdef XDND_DEBUG
  52 static const char*
  53 stateName(W_DndState *state)
  54 {
  55     if (state == NULL)
  56         return "no state defined";
  57
  58     if (state == idleState)
  59         return "idleState";
  60
  61     if (state == dropAllowedState)
  62         return "dropAllowedState";
  63
  64     if (state == finishDropState)
  65         return "finishDropState";
  66
  67     return "unknown state";
  68 }
  69 #endif
  70
  71
  72 static WMScreen*
  73 sourceScreen(WMDraggingInfo *info)
  74 {
  75     return W_VIEW_SCREEN(XDND_SOURCE_VIEW(info));
  76 }
  77
  78
  79 static void
  80 endDragProcess(WMDraggingInfo *info, Bool deposited)
  81 {
  82     WMView *view = XDND_SOURCE_VIEW(info);
  83     WMScreen *scr = W_VIEW_SCREEN(XDND_SOURCE_VIEW(info));
  84
  85     /* free selection handler while view exists */
  86     WMDeleteSelectionHandler(view,
  87                              scr->xdndSelectionAtom,
  88                              CurrentTime);
  89     wfree(XDND_SELECTION_PROCS(info));
  90
  91     if (XDND_DRAG_CURSOR(info) != None) {
  92         XFreeCursor(scr->display,
  93                     XDND_DRAG_CURSOR(info));
  94         XDND_DRAG_CURSOR(info) = None;
  95     }
  96
  97     if (view->dragSourceProcs->endedDrag != NULL) {
  98         /* this can destroy source view (with a "move" action for example) */
  99         view->dragSourceProcs->endedDrag(view, &XDND_DRAG_ICON_POS(info),
 100                                          deposited);
 101     }
 102
 103     /* clear remaining draggging infos */
 104     wfree(XDND_SOURCE_INFO(info));
 105     XDND_SOURCE_INFO(info) = NULL;
 106 }
 107
 108
 109 /* ----- drag cursor ----- */
 110 static void
 111 initDragCursor(WMDraggingInfo *info)
 112 {
 113     WMScreen *scr = sourceScreen(info);
 114     XColor cursorFgColor, cursorBgColor;
 115
 116     /* green */
 117     cursorFgColor.red = 0x4500;
 118     cursorFgColor.green = 0xb000;
 119     cursorFgColor.blue = 0x4500;
 120
 121     /* white */
 122     cursorBgColor.red = 0xffff;
 123     cursorBgColor.green = 0xffff;
 124     cursorBgColor.blue = 0xffff;
 125
 126     XDND_DRAG_CURSOR(info) = XCreateFontCursor(scr->display, XC_left_ptr);
 127     XRecolorCursor(scr->display,
 128                    XDND_DRAG_CURSOR(info),
 129                    &cursorFgColor,
 130                    &cursorBgColor);
 131
 132     XFlush(scr->display);
 133 }
 134
 135 static void
 136 recolorCursor(WMDraggingInfo *info, Bool dropIsAllowed)
 137 {
 138     WMScreen *scr = sourceScreen(info);
 139
 140     if (dropIsAllowed) {
 141         XDefineCursor(scr->display,
 142                       scr->rootWin,
 143                       XDND_DRAG_CURSOR(info));
 144     } else {
 145         XDefineCursor(scr->display,
 146                       scr->rootWin,
 147                       scr->defaultCursor);
 148     }
 149
 150     XFlush(scr->display);
 151 }
 152 /* ----- end of drag cursor ----- */
 153
 154
 155 /* ----- selection procs ----- */
 156 static WMData*
 157 convertSelection(WMView *view, Atom selection, Atom target,
 158                  void *cdata, Atom *type)
 159 {
 160     WMScreen *scr;
 161     WMData *data;
 162     char *typeName;
 163
 164     scr = W_VIEW_SCREEN(view);
 165     typeName = XGetAtomName(scr->display, target);
 166
 167     *type = target;
 168
 169     if (view->dragSourceProcs->fetchDragData != NULL) {
 170         data = view->dragSourceProcs->fetchDragData(
 171                                                     view,
 172                                                     typeName);
 173     } else {
 174         data = NULL;
 175     }
 176
 177     if (typeName != NULL)
 178         XFree(typeName);
 179
 180     return data;
 181 }
 182
 183
 184 static void
 185 selectionLost(WMView *view, Atom selection, void *cdata)
 186 {
 187     wwarning("DND selection lost during drag operation...");
 188 }
 189
 190
 191 static void
 192 selectionDone(WMView *view, Atom selection, Atom target, void *cdata)
 193 {
 194 #ifdef XDND_DEBUG
 195     printf("selection done\n");
 196 #endif
 197 }
 198 /* ----- end of selection procs ----- */
 199
 200
 201 /* ----- visual part ----- */
 202
 203 static Window
 204 makeDragIcon(WMScreen *scr, WMPixmap *pixmap)
 205 {
 206     Window window;
 207     WMSize size;
 208     unsigned long flags;
 209     XSetWindowAttributes attribs;
 210     Pixmap pix, mask;
 211
 212     if (!pixmap) {
 213         pixmap = scr->defaultObjectIcon;
 214     }
 215
 216     size = WMGetPixmapSize(pixmap);
 217     pix = pixmap->pixmap;
 218     mask = pixmap->mask;
 219
 220     flags = CWSaveUnder|CWBackPixmap|CWOverrideRedirect|CWColormap;
 221     attribs.save_under = True;
 222     attribs.background_pixmap = pix;
 223     attribs.override_redirect = True;
 224     attribs.colormap = scr->colormap;
 225
 226     window = XCreateWindow(scr->display, scr->rootWin, 0, 0, size.width,
 227                            size.height, 0, scr->depth, InputOutput,
 228                            scr->visual, flags, &attribs);
 229
 230 #ifdef SHAPE
 231
 232     if (mask) {
 233         XShapeCombineMask(scr->display, window, ShapeBounding, 0, 0, mask,
 234                           ShapeSet);
 235     }
 236 #endif
 237
 238     return window;
 239 }
 240
 241
 242 static void
 243 slideWindow(Display *dpy, Window win, int srcX, int srcY, int dstX, int dstY)
 244 {
 245     double x, y, dx, dy;
 246     int i;
 247     int iterations;
 248
 249     iterations = WMIN(MAX_SLIDEBACK_ITER,
 250                       WMAX(abs(dstX-srcX), abs(dstY-srcY)));
 251
 252     x = srcX;
 253     y = srcY;
 254
 255     dx = (double)(dstX-srcX)/iterations;
 256     dy = (double)(dstY-srcY)/iterations;
 257
 258     for (i = 0; i <= iterations; i++) {
 259         XMoveWindow(dpy, win, x, y);
 260         XFlush(dpy);
 261
 262         wusleep(800);
 263
 264         x += dx;
 265         y += dy;
 266     }
 267 }
 268
 269
 270 static int
 271 getInitialDragImageCoord(int viewCoord, int mouseCoord,
 272                          int viewSize, int iconSize)
 273 {
 274     if (iconSize >= viewSize) {
 275         /* center icon coord on view */
 276         return viewCoord - iconSize/2;
 277     } else {
 278         /* try to center icon on mouse pos */
 279
 280         if (mouseCoord - iconSize/2 <= viewCoord)
 281             /* if icon was centered on mouse, it would be off view
 282              thus, put icon left (resp. top) side
 283              at view (resp. top) side */
 284             return viewCoord;
 285
 286         else if (mouseCoord + iconSize/2 >= viewCoord + viewSize)
 287             /* if icon was centered on mouse, it would be off view
 288              thus, put icon right (resp. bottom) side
 289              at view right (resp. bottom) side */
 290             return viewCoord + viewSize - iconSize;
 291
 292         else
 293             return mouseCoord - iconSize/2;
 294     }
 295
 296 }
 297
 298 static void
 299 initDragImagePos(WMView *view, WMDraggingInfo *info, XEvent *event)
 300 {
 301     WMSize iconSize = WMGetPixmapSize(view->dragImage);
 302     WMSize viewSize = WMGetViewSize(view);
 303     WMPoint viewPos;
 304     Window foo;
 305
 306     XTranslateCoordinates(W_VIEW_SCREEN(view)->display,
 307                           WMViewXID(view), W_VIEW_SCREEN(view)->rootWin,
 308                           0, 0, &(viewPos.x), &(viewPos.y),
 309                           &foo);
 310
 311     /* set icon pos */
 312     XDND_DRAG_ICON_POS(info).x =
 313         getInitialDragImageCoord(viewPos.x, event->xmotion.x_root,
 314                                  viewSize.width, iconSize.width);
 315
 316     XDND_DRAG_ICON_POS(info).y =
 317         getInitialDragImageCoord(viewPos.y, event->xmotion.y_root,
 318                                  viewSize.height, iconSize.height);
 319
 320     /* set mouse offset relative to icon */
 321     XDND_MOUSE_OFFSET(info).x =
 322         event->xmotion.x_root - XDND_DRAG_ICON_POS(info).x;
 323     XDND_MOUSE_OFFSET(info).y =
 324         event->xmotion.y_root - XDND_DRAG_ICON_POS(info).y;
 325 }
 326
 327
 328 static void
 329 refreshDragImage(WMView *view, WMDraggingInfo *info)
 330 {
 331     WMScreen *scr = W_VIEW_SCREEN(view);
 332
 333     XMoveWindow(scr->display, XDND_DRAG_ICON(info),
 334                 XDND_DRAG_ICON_POS(info).x,
 335                 XDND_DRAG_ICON_POS(info).y);
 336 }
 337
 338
 339 static void
 340 startDragImage(WMView *view, WMDraggingInfo *info, XEvent* event)
 341 {
 342     WMScreen *scr = W_VIEW_SCREEN(view);
 343
 344     XDND_DRAG_ICON(info) = makeDragIcon(scr, view->dragImage);
 345     initDragImagePos(view, info, event);
 346     refreshDragImage(view, info);
 347     XMapRaised(scr->display, XDND_DRAG_ICON(info));
 348
 349     initDragCursor(info);
 350 }
 351
 352
 353 static void
 354 endDragImage(WMDraggingInfo *info, Bool slideBack)
 355 {
 356     WMView *view = XDND_SOURCE_VIEW(info);
 357     Display *dpy = W_VIEW_SCREEN(view)->display;
 358
 359     if (slideBack) {
 360         WMPoint toLocation;
 361         Window foo;
 362
 363         XTranslateCoordinates(W_VIEW_SCREEN(view)->display,
 364                               WMViewXID(view), W_VIEW_SCREEN(view)->rootWin,
 365                               0, 0, &(toLocation.x), &(toLocation.y),
 366                               &foo);
 367
 368         slideWindow(dpy, XDND_DRAG_ICON(info),
 369                     XDND_DRAG_ICON_POS(info).x,
 370                     XDND_DRAG_ICON_POS(info).y,
 371                     toLocation.x,
 372                     toLocation.y);
 373     }
 374
 375     XDestroyWindow(dpy, XDND_DRAG_ICON(info));
 376 }
 377
 378 /* ----- end of visual part ----- */
 379
 380
 381 /* ----- messages ----- */
 382
 383 /* send a DnD message to the destination window */
 384 static Bool
 385 sendDnDClientMessage(WMDraggingInfo *info, Atom message,
 386                      unsigned long data1,
 387                      unsigned long data2,
 388                      unsigned long data3,
 389                      unsigned long data4)
 390 {
 391     Display *dpy = sourceScreen(info)->display;
 392     Window srcWin = WMViewXID(XDND_SOURCE_VIEW(info));
 393     Window destWin = XDND_DEST_WIN(info);
 394
 395     if (! W_SendDnDClientMessage(dpy,
 396                                  destWin,
 397                                  message,
 398                                  srcWin,
 399                                  data1,
 400                                  data2,
 401                                  data3,
 402                                  data4)) {
 403         /* drop failed */
 404         recolorCursor(info, False);
 405         endDragImage(info, True);
 406         endDragProcess(info, False);
 407         return False;
 408     }
 409
 410     return True;
 411 }
 412
 413
 414 static Bool
 415 sendEnterMessage(WMDraggingInfo *info)
 416 {
 417     WMScreen *scr = sourceScreen(info);
 418     unsigned long data1;
 419
 420     data1 = (VERSION_INFO(info) << 24)|1; /* 1: support of type list */
 421
 422     return sendDnDClientMessage(info, scr->xdndEnterAtom,
 423                                 data1,
 424                                 XDND_3_TYPES(info)[0],
 425                                 XDND_3_TYPES(info)[1],
 426                                 XDND_3_TYPES(info)[2]);
 427 }
 428
 429
 430 /*
 431 // this functon doesn't return something in all cases.
 432 // control reaches end of non-void function. fix this -Dan */
 433 static Bool
 434 sendPositionMessage(WMDraggingInfo *info, WMPoint *mousePos)
 435 {
 436     WMScreen *scr = sourceScreen(info);
 437     WMRect *noPosZone = &(XDND_NO_POS_ZONE(info));
 438
 439     if (noPosZone->size.width != 0 || noPosZone->size.height != 0) {
 440         if (mousePos->x < noPosZone->pos.x
 441             || mousePos->x > (noPosZone->pos.x + noPosZone->size.width)
 442             || mousePos->y < noPosZone->pos.y
 443             || mousePos->y > (noPosZone->pos.y + noPosZone->size.width)) {
 444             /* send position if out of zone defined by destination */
 445             return sendDnDClientMessage(info, scr->xdndPositionAtom,
 446                                         0,
 447                                         mousePos->x<<16|mousePos->y,
 448                                         XDND_TIMESTAMP(info),
 449                                         XDND_SOURCE_ACTION(info));
 450         }
 451     } else {
 452         /* send position on each move */
 453         return sendDnDClientMessage(info, scr->xdndPositionAtom,
 454                                     0,
 455                                     mousePos->x<<16|mousePos->y,
 456                                     XDND_TIMESTAMP(info),
 457                                     XDND_SOURCE_ACTION(info));
 458     }
 459 }
 460
 461
 462 static Bool
 463 sendLeaveMessage(WMDraggingInfo *info)
 464 {
 465     WMScreen *scr = sourceScreen(info);
 466
 467     return sendDnDClientMessage(info, scr->xdndLeaveAtom,
 468                                 0, 0, 0, 0);
 469 }
 470
 471
 472 static Bool
 473 sendDropMessage(WMDraggingInfo *info)
 474 {
 475     WMScreen *scr = sourceScreen(info);
 476
 477     return sendDnDClientMessage(info,
 478                                 scr->xdndDropAtom,
 479                                 0,
 480                                 XDND_TIMESTAMP(info),
 481                                 0, 0);
 482 }
 483
 484 /* ----- end of messages ----- */
 485
 486
 487 static Atom*
 488 getTypeAtomList(WMScreen *scr, WMView *view, int* count)
 489 {
 490     WMArray* types;
 491     Atom* typeAtoms;
 492     int i;
 493
 494     types = view->dragSourceProcs->dropDataTypes(view);
 495
 496     if (types != NULL) {
 497         *count = WMGetArrayItemCount(types);
 498         if (*count > 0) {
 499             typeAtoms = wmalloc((*count)*sizeof(Atom));
 500             for (i=0; i < *count; i++) {
 501                 typeAtoms[i] = XInternAtom(scr->display,
 502                                            WMGetFromArray(types, i),
 503                                            False);
 504             }
 505
 506             /* WMFreeArray(types); */
 507             return typeAtoms;
 508         }
 509
 510         /* WMFreeArray(types); */
 511     }
 512
 513     *count = 1;
 514     typeAtoms = wmalloc(sizeof(Atom));
 515     *typeAtoms = None;
 516
 517     return typeAtoms;
 518 }
 519
 520
 521 static void
 522 registerDropTypes(WMScreen *scr, WMView *view, WMDraggingInfo *info)
 523 {
 524     Atom* typeList;
 525     int i, count;
 526
 527     typeList = getTypeAtomList(scr, view, &count);
 528
 529     /* store the first 3 types */
 530     for(i=0; i < 3 && i < count; i++)
 531         XDND_3_TYPES(info)[i] = typeList[i];
 532
 533     for(; i < 3; i++)
 534         XDND_3_TYPES(info)[i] = None;
 535
 536
 537     /* store the entire type list */
 538     XChangeProperty(scr->display,
 539                     WMViewXID(view),
 540                     scr->xdndTypeListAtom,
 541                     XA_ATOM,
 542                     XDND_PROPERTY_FORMAT,
 543                     PropModeReplace,
 544                     (unsigned char*) typeList,
 545                     count);
 546 }
 547
 548
 549 static void
 550 registerOperationList(WMScreen *scr, WMView *view, WMArray* operationArray)
 551 {
 552     Atom* actionList;
 553     WMDragOperationType operation;
 554     int count = WMGetArrayItemCount(operationArray);
 555     int i;
 556
 557     actionList = wmalloc(sizeof(Atom)*count);
 558
 559     for(i=0; i < count; i++) {
 560         operation = WMGetDragOperationItemType(
 561                                                WMGetFromArray(operationArray, i));
 562         actionList[i] = W_OperationToAction(scr, operation);
 563     }
 564
 565     XChangeProperty(scr->display,
 566                     WMViewXID(view),
 567                     scr->xdndActionListAtom,
 568                     XA_ATOM,
 569                     XDND_PROPERTY_FORMAT,
 570                     PropModeReplace,
 571                     (unsigned char*) actionList,
 572                     count);
 573 }
 574
 575 static void
 576 registerDescriptionList(WMScreen *scr, WMView *view, WMArray* operationArray)
 577 {
 578     char *text, *textListItem, *textList;
 579     int count = WMGetArrayItemCount(operationArray);
 580     int i;
 581     int size = 0;
 582
 583     /* size of XA_STRING info */
 584     for(i=0; i < count; i++) {
 585         size += strlen(WMGetDragOperationItemText(
 586                                                   WMGetFromArray(operationArray, i))) + 1; /* +1 = +NULL */
 587     }
 588
 589     /* create text list */
 590     textList = wmalloc(size);
 591     textListItem = textList;
 592
 593     for(i=0; i < count; i++) {
 594         text = WMGetDragOperationItemText(WMGetFromArray(operationArray, i));
 595         strcpy(textListItem, text);
 596
 597         /* to next text offset */
 598         textListItem  = &(textListItem[strlen(textListItem) + 1]);
 599     }
 600
 601     XChangeProperty(scr->display,
 602                     WMViewXID(view),
 603                     scr->xdndActionDescriptionAtom,
 604                     XA_STRING,
 605                     XDND_ACTION_DESCRIPTION_FORMAT,
 606                     PropModeReplace,
 607                     (unsigned char*) textList,
 608                     size);
 609 }
 610
 611 /* called if wanted operation is WDOperationAsk */
 612 static void
 613 registerSupportedOperations(WMView *view)
 614 {
 615     WMScreen *scr = W_VIEW_SCREEN(view);
 616     WMArray* operationArray;
 617
 618     operationArray = view->dragSourceProcs->askedOperations(view);
 619
 620     registerOperationList(scr, view, operationArray);
 621     registerDescriptionList(scr, view, operationArray);
 622
 623     /* WMFreeArray(operationArray); */
 624 }
 625
 626
 627 static void
 628 initSourceDragInfo(WMView *sourceView, WMDraggingInfo *info)
 629 {
 630     WMRect emptyZone;
 631
 632     XDND_SOURCE_INFO(info) = (W_DragSourceInfo*) wmalloc(sizeof(W_DragSourceInfo));
 633
 634     XDND_SOURCE_VIEW(info) = sourceView;
 635     XDND_DEST_WIN(info) = None;
 636     XDND_DRAG_ICON(info) = None;
 637
 638     XDND_SOURCE_ACTION(info) = W_OperationToAction(
 639                                                    W_VIEW_SCREEN(sourceView),
 640                                                    sourceView->dragSourceProcs->wantedDropOperation(sourceView));
 641
 642     XDND_DEST_ACTION(info) = None;
 643
 644     XDND_SOURCE_STATE(info) = idleState;
 645
 646     emptyZone.pos = wmkpoint(0, 0);
 647     emptyZone.size = wmksize(0, 0);
 648     XDND_NO_POS_ZONE(info) = emptyZone;
 649 }
 650
 651
 652 /*
 653  Returned array is destroyed after dropDataTypes call
 654  */
 655 static WMArray*
 656 defDropDataTypes(WMView *self)
 657 {
 658     return NULL;
 659 }
 660
 661
 662 static WMDragOperationType
 663 defWantedDropOperation(WMView *self)
 664 {
 665     return WDOperationNone;
 666 }
 667
 668
 669 /*
 670  Must be defined if wantedDropOperation return WDOperationAsk
 671  (useless otherwise).
 672  Return a WMDragOperationItem array (destroyed after call).
 673  A WMDragOperationItem links a label to an operation.
 674  static WMArray*
 675  defAskedOperations(WMView *self); */
 676
 677
 678 static Bool
 679 defAcceptDropOperation(WMView *self, WMDragOperationType allowedOperation)
 680 {
 681     return False;
 682 }
 683
 684
 685 static void
 686 defBeganDrag(WMView *self, WMPoint *point)
 687 {
 688 }
 689
 690
 691 static void
 692 defEndedDrag(WMView *self, WMPoint *point, Bool deposited)
 693 {
 694 }
 695
 696
 697 /*
 698  Returned data is not destroyed
 699  */
 700 static WMData*
 701 defFetchDragData(WMView *self, char *type)
 702 {
 703     return NULL;
 704 }
 705
 706
 707 void
 708 WMSetViewDragSourceProcs(WMView *view, WMDragSourceProcs *procs)
 709 {
 710     if (view->dragSourceProcs)
 711         wfree(view->dragSourceProcs);
 712     view->dragSourceProcs = wmalloc(sizeof(WMDragSourceProcs));
 713
 714     *view->dragSourceProcs = *procs;
 715
 716     if (procs->dropDataTypes == NULL)
 717         view->dragSourceProcs->dropDataTypes = defDropDataTypes;
 718
 719     if (procs->wantedDropOperation == NULL)
 720         view->dragSourceProcs->wantedDropOperation = defWantedDropOperation;
 721
 722     /*
 723      Note: askedOperations can be NULL, if wantedDropOperation never returns
 724      WDOperationAsk.
 725      */
 726
 727     if (procs->acceptDropOperation == NULL)
 728         view->dragSourceProcs->acceptDropOperation = defAcceptDropOperation;
 729
 730     if (procs->beganDrag == NULL)
 731         view->dragSourceProcs->beganDrag = defBeganDrag;
 732
 733     if (procs->endedDrag == NULL)
 734         view->dragSourceProcs->endedDrag = defEndedDrag;
 735
 736     if (procs->fetchDragData == NULL)
 737         view->dragSourceProcs->fetchDragData = defFetchDragData;
 738 }
 739
 740
 741 static Bool
 742 isXdndAware(WMScreen *scr, Window win)
 743 {
 744     Atom type;
 745     int format;
 746     unsigned long count, remain;
 747     unsigned char *winXdndVersion;
 748
 749     if (win == None)
 750         return False;
 751
 752     XGetWindowProperty(scr->display, win, scr->xdndAwareAtom,
 753                        0, 1, False, XA_ATOM, &type, &format,
 754                        &count, &remain, &winXdndVersion);
 755
 756     if (type != XA_ATOM
 757         || format != XDND_PROPERTY_FORMAT
 758         || count == 0 || !winXdndVersion) {
 759         if (winXdndVersion)
 760             XFree(winXdndVersion);
 761         return False;
 762     }
 763
 764     XFree(winXdndVersion);
 765     return (count == 1); /* xdnd version is set */
 766 }
 767
 768
 769 static Window*
 770 windowChildren(Display *dpy, Window win, unsigned *nchildren)
 771 {
 772     Window *children;
 773     Window foo, bar;
 774
 775     if (!XQueryTree(dpy, win, &foo, &bar, &children, nchildren)) {
 776         *nchildren = 0;
 777         return NULL;
 778     } else
 779         return children;
 780 }
 781
 782 static Window
 783 lookForAwareWindow(WMScreen *scr, WMPoint *mousePos, Window win)
 784 {
 785     int tmpx, tmpy;
 786     Window child;
 787
 788     /* Since xdnd v3, only the toplevel window should be aware */
 789     if (isXdndAware(scr, win))
 790         return win;
 791
 792     /* inspect child under pointer */
 793     if (XTranslateCoordinates(scr->display, scr->rootWin, win,
 794                               mousePos->x, mousePos->y, &tmpx, &tmpy,
 795                               &child)) {
 796         if (child == None)
 797             return None;
 798         else
 799             return lookForAwareWindow(scr, mousePos, child);
 800     }
 801
 802     return None;
 803 }
 804
 805
 806 static Window
 807 findDestination(WMDraggingInfo *info, WMPoint *mousePos)
 808 {
 809     WMScreen *scr = sourceScreen(info);
 810     unsigned nchildren;
 811     Window *children = windowChildren(scr->display, scr->rootWin, &nchildren);
 812     int i;
 813     XWindowAttributes attr;
 814
 815     if (isXdndAware(scr, scr->rootWin))
 816         return scr->rootWin;
 817
 818     /* exclude drag icon (and upper) from search */
 819     for (i = nchildren-1; i >= 0; i--) {
 820         if (children[i] == XDND_DRAG_ICON(info)) {
 821             i--;
 822             break;
 823         }
 824     }
 825
 826     if (i < 0) {
 827         /* root window has no child under drag icon, and is not xdnd aware. */
 828         return None;
 829     }
 830
 831     /* inspecting children, from upper to lower */
 832     for (; i >= 0; i--) {
 833         if (XGetWindowAttributes(scr->display, children[i], &attr)
 834             && attr.map_state == IsViewable
 835             && mousePos->x >= attr.x
 836             && mousePos->y >= attr.y
 837             && mousePos->x < attr.x + attr.width
 838             && mousePos->y < attr.y + attr.height) {
 839             return lookForAwareWindow(scr, mousePos, children[i]);
 840         }
 841     }
 842
 843     /* No child window under drag pointer */
 844     return None;
 845 }
 846
 847
 848 static void
 849 initMotionProcess(WMView *view, WMDraggingInfo *info,
 850                   XEvent *event, WMPoint *startLocation)
 851 {
 852     WMScreen *scr = W_VIEW_SCREEN(view);
 853
 854     /* take ownership of XdndSelection */
 855     XDND_SELECTION_PROCS(info) =
 856         (WMSelectionProcs*) wmalloc(sizeof(WMSelectionProcs));
 857     XDND_SELECTION_PROCS(info)->convertSelection = convertSelection;
 858     XDND_SELECTION_PROCS(info)->selectionLost = selectionLost;
 859     XDND_SELECTION_PROCS(info)->selectionDone = selectionDone;
 860     XDND_TIMESTAMP(info) = event->xmotion.time;
 861
 862     if (!WMCreateSelectionHandler(view, scr->xdndSelectionAtom,
 863                                   CurrentTime,
 864                                   XDND_SELECTION_PROCS(info), NULL)) {
 865         wwarning("could not get ownership or DND selection");
 866         return;
 867     }
 868
 869     registerDropTypes(scr, view, info);
 870
 871     if (XDND_SOURCE_ACTION(info) == W_VIEW_SCREEN(view)->xdndActionAsk)
 872         registerSupportedOperations(view);
 873
 874     if (view->dragSourceProcs->beganDrag != NULL) {
 875         view->dragSourceProcs->beganDrag(view, startLocation);
 876     }
 877 }
 878
 879
 880 static void
 881 processMotion(WMDraggingInfo *info, Window windowUnderDrag, WMPoint *mousePos)
 882 {
 883     /* // WMScreen *scr = sourceScreen(info); */
 884     Window newDestination = findDestination(info, mousePos);
 885
 886     W_DragSourceStopTimer();
 887
 888     if (newDestination != XDND_DEST_WIN(info)) {
 889         recolorCursor(info, False);
 890
 891         if (XDND_DEST_WIN(info) != None) {
 892             /* leaving a xdnd window */
 893             sendLeaveMessage(info);
 894         }
 895
 896         XDND_DEST_WIN(info) = newDestination;
 897         XDND_SOURCE_STATE(info) = idleState;
 898         XDND_DEST_ACTION(info) = None;
 899         XDND_NO_POS_ZONE(info).size.width = 0;
 900         XDND_NO_POS_ZONE(info).size.height = 0;
 901
 902         if (newDestination != None) {
 903             /* entering a xdnd window */
 904             if (! sendEnterMessage(info)) {
 905                 XDND_DEST_WIN(info) = None;
 906                 return;
 907             }
 908
 909             W_DragSourceStartTimer(info);
 910         }
 911     } else {
 912         if (XDND_DEST_WIN(info) != None) {
 913             if (! sendPositionMessage(info, mousePos)) {
 914                 XDND_DEST_WIN(info) = None;
 915                 return;
 916             }
 917
 918             W_DragSourceStartTimer(info);
 919         }
 920     }
 921 }
 922
 923
 924 static Bool
 925 processButtonRelease(WMDraggingInfo *info)
 926 {
 927     if (XDND_SOURCE_STATE(info) == dropAllowedState) {
 928         /* begin drop */
 929         W_DragSourceStopTimer();
 930
 931         if (! sendDropMessage(info))
 932             return False;
 933
 934         W_DragSourceStartTimer(info);
 935         return True;
 936     } else {
 937         if (XDND_DEST_WIN(info) != None)
 938             sendLeaveMessage(info);
 939
 940         W_DragSourceStopTimer();
 941         return False;
 942     }
 943 }
 944
 945
 946 Bool
 947 WMIsDraggingFromView(WMView *view)
 948 {
 949     WMDraggingInfo *info = &W_VIEW_SCREEN(view)->dragInfo;
 950
 951     return ( XDND_SOURCE_INFO(info) != NULL
 952             &&  XDND_SOURCE_STATE(info) != finishDropState);
 953     /* return W_VIEW_SCREEN(view)->dragInfo.sourceInfo != NULL; */
 954 }
 955
 956
 957 void
 958 WMDragImageFromView(WMView *view, XEvent *event)
 959 {
 960     WMDraggingInfo *info = &W_VIEW_SCREEN(view)->dragInfo;
 961     WMPoint mouseLocation;
 962
 963     switch(event->type) {
 964     case ButtonPress:
 965         if (event->xbutton.button == Button1) {
 966             XEvent nextEvent;
 967
 968             XPeekEvent(event->xbutton.display, &nextEvent);
 969
 970             /* Initialize only if a drag really begins (avoid clicks) */
 971             if (nextEvent.type == MotionNotify) {
 972                 initSourceDragInfo(view, info);
 973             }
 974         }
 975
 976         break;
 977
 978     case ButtonRelease:
 979         if (WMIsDraggingFromView(view)) {
 980             Bool dropBegan = processButtonRelease(info);
 981
 982             recolorCursor(info, False);
 983             if (dropBegan) {
 984                 endDragImage(info, False);
 985                 XDND_SOURCE_STATE(info) = finishDropState;
 986             } else {
 987                 /* drop failed */
 988                 endDragImage(info, True);
 989                 endDragProcess(info,False);
 990             }
 991         }
 992         break;
 993
 994     case MotionNotify:
 995         if (WMIsDraggingFromView(view)) {
 996             mouseLocation = wmkpoint(event->xmotion.x_root,
 997                                      event->xmotion.y_root);
 998
 999             if (abs(XDND_DRAG_ICON_POS(info).x - mouseLocation.x) >=
1000                 MIN_X_MOVE_OFFSET
1001                 || abs(XDND_DRAG_ICON_POS(info).y - mouseLocation.y) >=
1002                 MIN_Y_MOVE_OFFSET) {
1003                 if (XDND_DRAG_ICON(info) == None) {
1004                     initMotionProcess(view, info, event, &mouseLocation);
1005                     startDragImage(view, info, event);
1006                 } else {
1007                     XDND_DRAG_ICON_POS(info).x =
1008                         mouseLocation.x - XDND_MOUSE_OFFSET(info).x;
1009                     XDND_DRAG_ICON_POS(info).y =
1010                         mouseLocation.y - XDND_MOUSE_OFFSET(info).y;
1011
1012                     refreshDragImage(view, info);
1013                     processMotion(info,
1014                                   event->xmotion.window,
1015                                   &mouseLocation);
1016                 }
1017             }
1018         }
1019         break;
1020     }
1021 }
1022
1023
1024 /* Minimal mouse events handler: no right or double-click detection,
1025  only drag is supported */
1026 static void
1027 dragImageHandler(XEvent *event, void *cdata)
1028 {
1029     WMView *view = (WMView*)cdata;
1030
1031     WMDragImageFromView(view, event);
1032 }
1033
1034
1035 /* ----- source states ----- */
1036
1037 #ifdef XDND_DEBUG
1038 static void
1039 traceStatusMsg(Display *dpy, XClientMessageEvent *statusEvent)
1040 {
1041     printf("Xdnd status message:\n");
1042
1043     if (statusEvent->data.l[1] & 0x2UL)
1044         printf("send position on every move\n");
1045     else {
1046         int x, y, w, h;
1047         x = statusEvent->data.l[2] >> 16;
1048         y = statusEvent->data.l[2] & 0xFFFFL;
1049         w = statusEvent->data.l[3] >> 16;
1050         h = statusEvent->data.l[3] & 0xFFFFL;
1051
1052         printf("send position out of ((%d,%d) , (%d,%d))\n",
1053                x, y, x+w, y+h);
1054     }
1055
1056     if (statusEvent->data.l[1] & 0x1L)
1057         printf("allowed action: %s\n",
1058                XGetAtomName(dpy, statusEvent->data.l[4]));
1059     else
1060         printf("no action allowed\n");
1061 }
1062 #endif
1063
1064
1065 static void
1066 storeDropAction(WMDraggingInfo *info, Atom destAction)
1067 {
1068     WMView* sourceView = XDND_SOURCE_VIEW(info);
1069     WMScreen *scr = W_VIEW_SCREEN(sourceView);
1070
1071     if (sourceView->dragSourceProcs->acceptDropOperation != NULL) {
1072         if (sourceView->dragSourceProcs->acceptDropOperation(
1073                                                              sourceView,
1074                                                              W_ActionToOperation(scr, destAction)))
1075             XDND_DEST_ACTION(info) = destAction;
1076         else
1077             XDND_DEST_ACTION(info) = None;
1078     } else {
1079         XDND_DEST_ACTION(info) = destAction;
1080     }
1081 }
1082
1083
1084 static void
1085 storeStatusMessageInfos(WMDraggingInfo *info, XClientMessageEvent *statusEvent)
1086 {
1087     WMRect* noPosZone = &(XDND_NO_POS_ZONE(info));
1088
1089 #ifdef XDND_DEBUG
1090
1091     traceStatusMsg(sourceScreen(info)->display, statusEvent);
1092 #endif
1093
1094     if (statusEvent->data.l[1] & 0x2UL) {
1095         /* bit 1 set: destination wants position messages on every move */
1096         noPosZone->size.width = 0;
1097         noPosZone->size.height = 0;
1098     } else {
1099         /* don't send another position message while in given rectangle */
1100         noPosZone->pos.x = statusEvent->data.l[2] >> 16;
1101         noPosZone->pos.y = statusEvent->data.l[2] & 0xFFFFL;
1102         noPosZone->size.width = statusEvent->data.l[3] >> 16;
1103         noPosZone->size.height = statusEvent->data.l[3] & 0xFFFFL;
1104     }
1105
1106     if ((statusEvent->data.l[1] & 0x1L) || statusEvent->data.l[4] != None) {
1107         /* destination accept drop */
1108         storeDropAction(info, statusEvent->data.l[4]);
1109     } else {
1110         XDND_DEST_ACTION(info) = None;
1111     }
1112 }
1113
1114
1115 static void*
1116 idleState(WMView *view, XClientMessageEvent *event, WMDraggingInfo *info)
1117 {
1118     WMScreen *scr;
1119     Atom destMsg = event->message_type;
1120
1121     scr = W_VIEW_SCREEN(view);
1122
1123     if (destMsg == scr->xdndStatusAtom) {
1124         storeStatusMessageInfos(info, event);
1125
1126         if (XDND_DEST_ACTION(info) != None) {
1127             recolorCursor(info, True);
1128             W_DragSourceStartTimer(info);
1129             return dropAllowedState;
1130         } else {
1131             /* drop denied */
1132             recolorCursor(info, False);
1133             return idleState;
1134         }
1135     }
1136
1137     if (destMsg == scr->xdndFinishedAtom) {
1138         wwarning("received xdndFinishedAtom before drop began");
1139     }
1140
1141     W_DragSourceStartTimer(info);
1142     return idleState;
1143 }
1144
1145
1146 static void*
1147 dropAllowedState(WMView *view, XClientMessageEvent *event, WMDraggingInfo *info)
1148 {
1149     WMScreen *scr = W_VIEW_SCREEN(view);
1150     Atom destMsg = event->message_type;
1151
1152     if (destMsg == scr->xdndStatusAtom) {
1153         storeStatusMessageInfos(info, event);
1154
1155         if (XDND_DEST_ACTION(info) == None) {
1156             /* drop denied */
1157             recolorCursor(info, False);
1158             return idleState;
1159         }
1160     }
1161
1162     W_DragSourceStartTimer(info);
1163     return dropAllowedState;
1164 }
1165
1166
1167 static void*
1168 finishDropState(WMView *view, XClientMessageEvent *event, WMDraggingInfo *info)
1169 {
1170     WMScreen *scr = W_VIEW_SCREEN(view);
1171     Atom destMsg = event->message_type;
1172
1173     if (destMsg == scr->xdndFinishedAtom) {
1174         endDragProcess(info, True);
1175         return NULL;
1176     }
1177
1178     W_DragSourceStartTimer(info);
1179     return finishDropState;
1180 }
1181 /* ----- end of source states ----- */
1182
1183
1184 /* ----- source timer ----- */
1185 static void
1186 dragSourceResponseTimeOut(void *source)
1187 {
1188     WMView *view = (WMView*)source;
1189     WMDraggingInfo *info = &(W_VIEW_SCREEN(view)->dragInfo);
1190
1191     wwarning("delay for drag destination response expired");
1192     sendLeaveMessage(info);
1193
1194     recolorCursor(info, False);
1195     if (XDND_SOURCE_STATE(info) == finishDropState) {
1196         /* drop failed */
1197         endDragImage(info, True);
1198         endDragProcess(info, False);
1199     } else {
1200         XDND_SOURCE_STATE(info) = idleState;
1201     }
1202 }
1203
1204 void
1205 W_DragSourceStopTimer()
1206 {
1207     if (dndSourceTimer != NULL) {
1208         WMDeleteTimerHandler(dndSourceTimer);
1209         dndSourceTimer = NULL;
1210     }
1211 }
1212
1213 void
1214 W_DragSourceStartTimer(WMDraggingInfo *info)
1215 {
1216     W_DragSourceStopTimer();
1217
1218     dndSourceTimer = WMAddTimerHandler(
1219                                        XDND_DESTINATION_RESPONSE_MAX_DELAY,
1220                                        dragSourceResponseTimeOut,
1221                                        XDND_SOURCE_VIEW(info));
1222 }
1223
1224 /* ----- End of Destination timer ----- */
1225
1226
1227 void
1228 W_DragSourceStateHandler(WMDraggingInfo *info, XClientMessageEvent *event)
1229 {
1230     WMView *view;
1231     W_DndState* newState;
1232
1233     if (XDND_SOURCE_VIEW_STORED(info)) {
1234         view = XDND_SOURCE_VIEW(info);
1235 #ifdef XDND_DEBUG
1236
1237         printf("current source state: %s\n",
1238                stateName(XDND_SOURCE_STATE(info)));
1239 #endif
1240
1241         newState = (W_DndState*) XDND_SOURCE_STATE(info)(view, event, info);
1242
1243 #ifdef XDND_DEBUG
1244
1245         printf("new source state: %s\n", stateName(newState));
1246 #endif
1247
1248         if (newState != NULL)
1249             XDND_SOURCE_STATE(info) = newState;
1250         /* else drop finished, and info has been flushed */
1251     }
1252 }
1253
1254
1255 void WMSetViewDragImage(WMView* view, WMPixmap *dragImage)
1256 {
1257     if (view->dragImage != NULL)
1258         WMReleasePixmap(view->dragImage);
1259
1260     view->dragImage = WMRetainPixmap(dragImage);
1261 }
1262
1263
1264 void WMReleaseViewDragImage(WMView* view)
1265 {
1266     if (view->dragImage != NULL)
1267         WMReleasePixmap(view->dragImage);
1268 }
1269
1270
1271 /* Create a drag handler, associating drag event masks with dragEventProc */
1272 void
1273 WMCreateDragHandler(WMView *view, WMEventProc *dragEventProc, void *clientData)
1274 {
1275     WMCreateEventHandler(view,
1276                          ButtonPressMask|ButtonReleaseMask|Button1MotionMask,
1277                          dragEventProc, clientData);
1278 }
1279
1280
1281 void
1282 WMDeleteDragHandler(WMView *view, WMEventProc *dragEventProc, void *clientData)
1283 {
1284     WMDeleteEventHandler(view,
1285                          ButtonPressMask|ButtonReleaseMask|Button1MotionMask,
1286                          dragEventProc, clientData);
1287 }
1288
1289
1290 /* set default drag handler for view */
1291 void
1292 WMSetViewDraggable(WMView *view, WMDragSourceProcs *dragSourceProcs,
1293                    WMPixmap *dragImage)
1294 {
1295     wassertr(dragImage != NULL);
1296     view->dragImage = WMRetainPixmap(dragImage);
1297
1298     WMSetViewDragSourceProcs(view, dragSourceProcs);
1299
1300     WMCreateDragHandler(view, dragImageHandler, view);
1301 }
1302
1303
1304 void
1305 WMUnsetViewDraggable(WMView *view)
1306 {
1307     if (view->dragSourceProcs) {
1308         wfree(view->dragSourceProcs);
1309         view->dragSourceProcs = NULL;
1310     }
1311
1312     WMReleaseViewDragImage(view);
1313
1314     WMDeleteDragHandler(view, dragImageHandler, view);
1315 }
1316
1317