WINGs/dragsource.c

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