WINGs/dragsource.c

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