WINGs/dragdestination.c

   1
   2
   3 #include "WINGsP.h"
   4 #include <X11/Xatom.h>
   5
   6 #define XDND_SOURCE_RESPONSE_MAX_DELAY 3000
   7
   8 #define XDND_PROPERTY_FORMAT 32
   9 #define XDND_ACTION_DESCRIPTION_FORMAT 8
  10
  11 #define XDND_SOURCE_VERSION(dragInfo) dragInfo->protocolVersion
  12 #define XDND_DEST_INFO(dragInfo) dragInfo->destInfo
  13 #define XDND_AWARE_VIEW(dragInfo) dragInfo->destInfo->xdndAwareView
  14 #define XDND_SOURCE_WIN(dragInfo) dragInfo->destInfo->sourceWindow
  15 #define XDND_DEST_VIEW(dragInfo) dragInfo->destInfo->destView
  16 #define XDND_DEST_STATE(dragInfo) dragInfo->destInfo->state
  17 #define XDND_SOURCE_ACTION_CHANGED(dragInfo) dragInfo->destInfo->sourceActionChanged
  18 #define XDND_SOURCE_TYPES(dragInfo) dragInfo->destInfo->sourceTypes
  19 #define XDND_TYPE_LIST_AVAILABLE(dragInfo) dragInfo->destInfo->typeListAvailable
  20 #define XDND_REQUIRED_TYPES(dragInfo) dragInfo->destInfo->requiredTypes
  21 #define XDND_SOURCE_ACTION(dragInfo) dragInfo->sourceAction
  22 #define XDND_DEST_ACTION(dragInfo) dragInfo->destinationAction
  23 #define XDND_SOURCE_OPERATIONS(dragInfo) dragInfo->destInfo->sourceOperations
  24 #define XDND_DROP_DATAS(dragInfo) dragInfo->destInfo->dropDatas
  25 #define XDND_DROP_DATA_COUNT(dragInfo) dragInfo->destInfo->dropDataCount
  26 #define XDND_DEST_VIEW_IS_REGISTERED(dragInfo) ((dragInfo->destInfo) != NULL)\
  27     && ((dragInfo->destInfo->destView->dragDestinationProcs) != NULL)
  28
  29
  30 static unsigned char XDNDversion = XDND_VERSION;
  31 static WMHandlerID dndDestinationTimer = NULL;
  32
  33
  34 static void* idleState(WMView *destView, XClientMessageEvent *event,
  35                        WMDraggingInfo *info);
  36 static void* waitEnterState(WMView *destView, XClientMessageEvent *event,
  37                             WMDraggingInfo *info);
  38 static void* inspectDropDataState(WMView *destView, XClientMessageEvent *event,
  39                                   WMDraggingInfo *info);
  40 static void* dropAllowedState(WMView *destView, XClientMessageEvent *event,
  41                               WMDraggingInfo *info);
  42 static void* dropNotAllowedState(WMView *destView, XClientMessageEvent *event,
  43                                  WMDraggingInfo *info);
  44 static void* waitForDropDataState(WMView *destView, XClientMessageEvent *event,
  45                                   WMDraggingInfo *info);
  46
  47 /* ----- Types & datas list ----- */
  48 static void
  49 freeSourceTypeArrayItem(void *type)
  50 {
  51     XFree(type);
  52 }
  53
  54
  55 static WMArray*
  56 createSourceTypeArray(int initialSize)
  57 {
  58     return WMCreateArrayWithDestructor(initialSize, freeSourceTypeArrayItem);
  59 }
  60
  61
  62 static void
  63 freeDropDataArrayItem(void* data)
  64 {
  65     if (data != NULL)
  66         WMReleaseData((WMData*) data);
  67 }
  68
  69
  70 static WMArray*
  71 createDropDataArray(WMArray *requiredTypes)
  72 {
  73     if (requiredTypes != NULL)
  74         return WMCreateArrayWithDestructor(
  75                                            WMGetArrayItemCount(requiredTypes),
  76                                            freeDropDataArrayItem);
  77
  78     else
  79         return WMCreateArray(0);
  80 }
  81
  82 static WMArray*
  83 getTypesFromTypeList(WMScreen *scr, Window sourceWin)
  84 {
  85     Atom dataType;
  86     Atom* typeAtomList;
  87     WMArray* typeList;
  88     int i, format;
  89     unsigned long count, remaining;
  90     unsigned char *data = NULL;
  91
  92     XGetWindowProperty(scr->display, sourceWin, scr->xdndTypeListAtom,
  93                        0, 0x8000000L, False, XA_ATOM, &dataType, &format,
  94                        &count, &remaining, &data);
  95
  96     if (dataType!=XA_ATOM || format!=XDND_PROPERTY_FORMAT || count==0 || !data) {
  97         if (data) {
  98             XFree(data);
  99         }
 100         return createSourceTypeArray(0);
 101     }
 102
 103     typeList = createSourceTypeArray(count);
 104     typeAtomList = (Atom*) data;
 105     for (i=0; i < count; i++) {
 106         WMAddToArray(typeList, XGetAtomName(scr->display, typeAtomList[i]));
 107     }
 108
 109     XFree(data);
 110
 111     return typeList;
 112 }
 113
 114
 115 static WMArray*
 116 getTypesFromThreeTypes(WMScreen *scr, XClientMessageEvent *event)
 117 {
 118     WMArray* typeList;
 119     Atom atom;
 120     int i;
 121
 122     typeList = createSourceTypeArray(3);
 123     for (i = 2; i < 5; i++) {
 124         if (event->data.l[i] != None) {
 125             atom = (Atom)event->data.l[i];
 126             WMAddToArray(typeList, XGetAtomName(scr->display, atom));
 127         }
 128     }
 129
 130     return typeList;
 131 }
 132
 133
 134 void
 135 storeRequiredTypeList(WMDraggingInfo *info)
 136 {
 137     WMView *destView = XDND_DEST_VIEW(info);
 138     WMScreen *scr = W_VIEW_SCREEN(destView);
 139     WMArray *requiredTypes;
 140
 141     /* First, see if the stored source types are enough for dest requirements */
 142     requiredTypes = destView->dragDestinationProcs->requiredDataTypes(
 143                                                                       destView,
 144                                                                       W_ActionToOperation(scr, XDND_SOURCE_ACTION(info)),
 145                                                                       XDND_SOURCE_TYPES(info));
 146
 147     if (requiredTypes == NULL && XDND_TYPE_LIST_AVAILABLE(info)) {
 148         /* None of the stored source types fits, but the whole type list
 149            hasn't been retrieved yet. */
 150         WMFreeArray(XDND_SOURCE_TYPES(info));
 151         XDND_SOURCE_TYPES(info) = getTypesFromTypeList(
 152                                                        scr,
 153                                                        XDND_SOURCE_WIN(info));
 154         /* Don't retrieve the type list again */
 155         XDND_TYPE_LIST_AVAILABLE(info) = False;
 156
 157         requiredTypes =
 158             destView->dragDestinationProcs->requiredDataTypes(
 159                                                               destView,
 160                                                               W_ActionToOperation(scr, XDND_SOURCE_ACTION(info)),
 161                                                               XDND_SOURCE_TYPES(info));
 162     }
 163
 164     XDND_REQUIRED_TYPES(info) = requiredTypes;
 165 }
 166
 167
 168 char*
 169 getNextRequestedDataType(WMDraggingInfo *info)
 170 {
 171     /* get the type of the first data not yet retrieved from selection */
 172     int nextTypeIndex;
 173
 174     if (XDND_REQUIRED_TYPES(info) != NULL) {
 175         nextTypeIndex = WMGetArrayItemCount(XDND_DROP_DATAS(info));
 176         return WMGetFromArray(XDND_REQUIRED_TYPES(info), nextTypeIndex);
 177         /* NULL if no more type */
 178     } else
 179         return NULL;
 180 }
 181
 182
 183 /* ----- Action list ----- */
 184
 185 WMArray*
 186 sourceOperationList(WMScreen *scr, Window sourceWin)
 187 {
 188     Atom dataType, *actionList;
 189     int i, size;
 190     unsigned long count, remaining;
 191     unsigned char* actionDatas = NULL;
 192     unsigned char* descriptionList = NULL;
 193     WMArray* operationArray;
 194     WMDragOperationItem* operationItem;
 195     char* description;
 196
 197     remaining = 0;
 198     XGetWindowProperty(scr->display, sourceWin, scr->xdndActionListAtom,
 199                        0, 0x8000000L, False, XA_ATOM, &dataType, &size,
 200                        &count, &remaining, &actionDatas);
 201
 202     if (dataType!=XA_ATOM || size!=XDND_PROPERTY_FORMAT || count==0 || !actionDatas) {
 203         wwarning("Cannot read action list");
 204         if (actionDatas) {
 205             XFree(actionDatas);
 206         }
 207         return NULL;
 208     }
 209
 210     actionList = (Atom*)actionDatas;
 211
 212     XGetWindowProperty(scr->display, sourceWin, scr->xdndActionDescriptionAtom,
 213                        0, 0x8000000L, False, XA_STRING, &dataType, &size,
 214                        &count, &remaining, &descriptionList);
 215
 216     if (dataType!=XA_STRING || size!=XDND_ACTION_DESCRIPTION_FORMAT ||
 217         count==0 || !descriptionList) {
 218         wwarning("Cannot read action description list");
 219         if (actionList) {
 220             XFree(actionList);
 221         }
 222         if (descriptionList) {
 223             XFree(descriptionList);
 224         }
 225         return NULL;
 226     }
 227
 228     operationArray = WMCreateDragOperationArray(count);
 229     description = (char*)descriptionList;
 230
 231     for (i=0; count > 0; i++) {
 232         size = strlen(description);
 233         operationItem = WMCreateDragOperationItem(
 234                                                   W_ActionToOperation(scr, actionList[i]),
 235                                                   wstrdup(description));
 236
 237         WMAddToArray(operationArray, operationItem);
 238         count -= (size + 1); /* -1 : -NULL char */
 239
 240         /* next description */
 241         description = &(description[size + 1]);
 242     }
 243
 244     XFree(actionList);
 245     XFree(descriptionList);
 246
 247     return operationArray;
 248 }
 249
 250
 251 /* ----- Dragging Info ----- */
 252 static void
 253 updateSourceWindow(WMDraggingInfo *info, XClientMessageEvent *event)
 254 {
 255     XDND_SOURCE_WIN(info) = (Window) event->data.l[0];
 256 }
 257
 258
 259 static WMView*
 260 findChildInView(WMView* parent, int x, int y)
 261 {
 262     if (parent->childrenList == NULL)
 263         return parent;
 264     else {
 265         WMView* child = parent->childrenList;
 266
 267         while (child != NULL
 268                && (! child->flags.mapped
 269                    || x < WMGetViewPosition(child).x
 270                    || x > WMGetViewPosition(child).x + WMGetViewSize(child).width
 271                    || y < WMGetViewPosition(child).y
 272                    || y > WMGetViewPosition(child).y + WMGetViewSize(child).height))
 273
 274             child = child->nextSister;
 275
 276         if (child == NULL)
 277             return parent;
 278         else
 279             return findChildInView(child,
 280                                       x - WMGetViewPosition(child).x,
 281                                       y - WMGetViewPosition(child).y);
 282     }
 283 }
 284
 285
 286 static WMView*
 287 findDestinationViewInToplevel(WMView* toplevel, int x, int y)
 288 {
 289     WMScreen *scr = W_VIEW_SCREEN(toplevel);
 290     Window toplevelWin = WMViewXID(toplevel);
 291     int xInToplevel, yInToplevel;
 292     Window child, foo;
 293     WMView *childView;
 294
 295     XTranslateCoordinates(scr->display, scr->rootWin, toplevelWin,
 296                           x, y, &xInToplevel, &yInToplevel,
 297                           &foo);
 298     return findChildInView(toplevel, xInToplevel, yInToplevel);
 299 }
 300
 301
 302 /* Clear datas only used by current destination view */
 303 static void
 304 freeDestinationViewInfos(WMDraggingInfo *info)
 305 {
 306     if (XDND_SOURCE_TYPES(info) != NULL) {
 307         WMFreeArray(XDND_SOURCE_TYPES(info));
 308         XDND_SOURCE_TYPES(info) = NULL;
 309     }
 310
 311     if (XDND_DROP_DATAS(info) != NULL) {
 312         WMFreeArray(XDND_DROP_DATAS(info));
 313         XDND_DROP_DATAS(info) = NULL;
 314     }
 315
 316     XDND_REQUIRED_TYPES(info) = NULL;
 317 }
 318
 319
 320 void
 321 W_DragDestinationInfoClear(WMDraggingInfo *info)
 322 {
 323     W_DragDestinationStopTimer();
 324
 325     if (XDND_DEST_INFO(info) != NULL) {
 326         freeDestinationViewInfos(info);
 327
 328         wfree(XDND_DEST_INFO(info));
 329         XDND_DEST_INFO(info) = NULL;
 330     }
 331 }
 332
 333
 334 static void
 335 initDestinationDragInfo(WMDraggingInfo *info, WMView *destView)
 336 {
 337     wassertr(destView != NULL);
 338
 339     XDND_DEST_INFO(info) =
 340         (W_DragDestinationInfo*) wmalloc(sizeof(W_DragDestinationInfo));
 341
 342     XDND_DEST_STATE(info) = idleState;
 343     XDND_DEST_VIEW(info) = destView;
 344
 345     XDND_SOURCE_ACTION_CHANGED(info) = False;
 346     XDND_SOURCE_TYPES(info) = NULL;
 347     XDND_REQUIRED_TYPES(info) = NULL;
 348     XDND_DROP_DATAS(info) = NULL;
 349 }
 350
 351
 352 void
 353 W_DragDestinationStoreEnterMsgInfo(WMDraggingInfo *info,
 354                                    WMView *toplevel, XClientMessageEvent *event)
 355 {
 356     WMScreen *scr = W_VIEW_SCREEN(toplevel);
 357
 358     if (XDND_DEST_INFO(info) == NULL)
 359         initDestinationDragInfo(info, toplevel);
 360
 361     XDND_SOURCE_VERSION(info) = (event->data.l[1] >> 24);
 362     XDND_AWARE_VIEW(info) = toplevel;
 363     updateSourceWindow(info, event);
 364
 365 /*
 366     if (event->data.l[1] & 1)
 367         /* XdndTypeList property is available */
 368 /*        XDND_SOURCE_TYPES(info) = getTypesFromTypeList(scr, XDND_SOURCE_WIN(info));
 369     else
 370         XDND_SOURCE_TYPES(info) = getTypesFromThreeTypes(scr, event);
 371 */
 372     XDND_SOURCE_TYPES(info) = getTypesFromThreeTypes(scr, event);
 373
 374     /* to use if the 3 types are not enough */
 375     XDND_TYPE_LIST_AVAILABLE(info) = (event->data.l[1] & 1);
 376 }
 377
 378
 379 void
 380 W_DragDestinationStorePositionMsgInfo(WMDraggingInfo *info,
 381                                       WMView *toplevel, XClientMessageEvent *event)
 382 {
 383     int x = event->data.l[2] >> 16;
 384     int y = event->data.l[2] & 0xffff;
 385     WMView *newDestView;
 386
 387     newDestView = findDestinationViewInToplevel(toplevel, x, y);
 388
 389     if (XDND_DEST_INFO(info) == NULL) {
 390         initDestinationDragInfo(info, newDestView);
 391         XDND_AWARE_VIEW(info) = toplevel;
 392         updateSourceWindow(info, event);
 393     } else {
 394         if (newDestView != XDND_DEST_VIEW(info)) {
 395             updateSourceWindow(info, event);
 396             XDND_DEST_VIEW(info) = newDestView;
 397             XDND_SOURCE_ACTION_CHANGED(info) = False;
 398
 399             if (XDND_DEST_STATE(info) != waitEnterState)
 400                 XDND_DEST_STATE(info) = idleState;
 401         } else {
 402             XDND_SOURCE_ACTION_CHANGED(info) = (XDND_SOURCE_ACTION(info) != event->data.l[4]);
 403         }
 404     }
 405
 406     XDND_SOURCE_ACTION(info) = event->data.l[4];
 407
 408     /* note: source position is not stored */
 409 }
 410
 411 /* ----- End of Dragging Info ----- */
 412
 413
 414 /* ----- Messages ----- */
 415
 416 /* send a DnD message to the source window */
 417 static void
 418 sendDnDClientMessage(WMDraggingInfo *info, Atom message,
 419                      unsigned long data1,
 420                      unsigned long data2,
 421                      unsigned long data3,
 422                      unsigned long data4)
 423 {
 424     if (! W_SendDnDClientMessage(W_VIEW_SCREEN(XDND_AWARE_VIEW(info))->display,
 425                                  XDND_SOURCE_WIN(info),
 426                                  message,
 427                                  WMViewXID(XDND_AWARE_VIEW(info)),
 428                                  data1,
 429                                  data2,
 430                                  data3,
 431                                  data4)) {
 432         /* drop failed */
 433         W_DragDestinationInfoClear(info);
 434     }
 435 }
 436
 437
 438 /* send a xdndStatus message to the source, with position and size
 439    of the destination if it has no subwidget (requesting a position message
 440    on every move otherwise) */
 441 static void
 442 sendStatusMessage(WMView *destView, WMDraggingInfo *info, Atom action)
 443 {
 444     unsigned long data1;
 445
 446     data1 = (action == None) ? 0 : 1;
 447
 448     if (destView->childrenList == NULL) {
 449         WMScreen *scr = W_VIEW_SCREEN(destView);
 450         int destX, destY;
 451         WMSize destSize = WMGetViewSize(destView);
 452         Window foo;
 453
 454         XTranslateCoordinates(scr->display, WMViewXID(destView), scr->rootWin,
 455                               0, 0, &destX, &destY,
 456                               &foo);
 457
 458        sendDnDClientMessage(info,
 459                              W_VIEW_SCREEN(destView)->xdndStatusAtom,
 460                              data1,
 461                              (destX << 16)|destY,
 462                              (destSize.width << 16)|destSize.height,
 463                              action);
 464     } else {
 465         /* set bit 1 to request explicitly position message on every move */
 466         data1 = data1 | 2;
 467
 468         sendDnDClientMessage(info,
 469                              W_VIEW_SCREEN(destView)->xdndStatusAtom,
 470                              data1,
 471                              0,
 472                              0,
 473                              action);
 474     }
 475 }
 476
 477
 478 static void
 479 storeDropData(WMView *destView, Atom selection, Atom target,
 480               Time timestamp, void *cdata, WMData *data)
 481 {
 482     WMScreen *scr = W_VIEW_SCREEN(destView);
 483     WMDraggingInfo *info = &(scr->dragInfo);
 484     WMData *dataToStore = NULL;
 485
 486     if (data != NULL)
 487         dataToStore = WMRetainData(data);
 488
 489     if (XDND_DEST_INFO(info) != NULL && XDND_DROP_DATAS(info) != NULL) {
 490         WMAddToArray(XDND_DROP_DATAS(info), dataToStore);
 491         W_SendDnDClientMessage(scr->display, WMViewXID(destView),
 492                                scr->xdndSelectionAtom,
 493                                WMViewXID(destView),
 494                                0, 0, 0, 0);
 495     }
 496 }
 497
 498
 499 Bool
 500 requestDropDataInSelection(WMView *destView, char* type)
 501 {
 502     WMScreen *scr = W_VIEW_SCREEN(destView);
 503
 504     if (type != NULL) {
 505         if (!WMRequestSelection(destView,
 506                                 scr->xdndSelectionAtom,
 507                                 XInternAtom(scr->display, type, False),
 508                                 CurrentTime,
 509                                 storeDropData, NULL)) {
 510             wwarning("could not request data for dropped data");
 511             return False;
 512         }
 513
 514         return True;
 515     }
 516
 517     return False;
 518 }
 519
 520
 521 Bool
 522 requestDropData(WMDraggingInfo *info)
 523 {
 524     WMView *destView = XDND_DEST_VIEW(info);
 525     char* nextType = getNextRequestedDataType(info);
 526
 527     while ((nextType != NULL)
 528            && (!requestDropDataInSelection(destView, nextType)) ) {
 529         /* store NULL if request failed, and try with next type */
 530         WMAddToArray(XDND_DROP_DATAS(info), NULL);
 531         nextType = getNextRequestedDataType(info);
 532     }
 533
 534     /* remains types to retrieve ? */
 535     return (nextType != NULL);
 536 }
 537
 538
 539 static void
 540 concludeDrop(WMView *destView)
 541 {
 542     destView->dragDestinationProcs->concludeDragOperation(destView);
 543 }
 544
 545
 546 /* send cancel message to the source */
 547 static void
 548 cancelDrop(WMView *destView, WMDraggingInfo *info)
 549 {
 550     sendStatusMessage(destView, info, None);
 551     concludeDrop(destView);
 552     freeDestinationViewInfos(info);
 553 }
 554
 555
 556 /* suspend drop, when dragged icon enter an unregistered view
 557    or a register view that doesn't accept the drop */
 558 static void
 559 suspendDropAuthorization(WMView *destView, WMDraggingInfo *info)
 560 {
 561     sendStatusMessage(destView, info, None);
 562
 563     /* Free datas that depend on destination behaviour */
 564     if (XDND_DROP_DATAS(info) != NULL) {
 565         WMFreeArray(XDND_DROP_DATAS(info));
 566         XDND_DROP_DATAS(info) = NULL;
 567     }
 568
 569     XDND_REQUIRED_TYPES(info) = NULL;
 570 }
 571
 572
 573 /* cancel drop on Enter message, if protocol version is nok */
 574 void
 575 W_DragDestinationCancelDropOnEnter(WMView *toplevel, WMDraggingInfo *info)
 576 {
 577     if (XDND_DEST_VIEW_IS_REGISTERED(info))
 578         cancelDrop(XDND_DEST_VIEW(info), info);
 579     else
 580         sendStatusMessage(toplevel, info, None);
 581
 582     W_DragDestinationInfoClear(info);
 583 }
 584
 585
 586 static void
 587 finishDrop(WMView *destView, WMDraggingInfo *info)
 588 {
 589     sendDnDClientMessage(info,
 590                          W_VIEW_SCREEN(destView)->xdndFinishedAtom,
 591                          0, 0, 0, 0);
 592     concludeDrop(destView);
 593     W_DragDestinationInfoClear(info);
 594 }
 595
 596
 597 static Atom
 598 getAllowedAction(WMView *destView, WMDraggingInfo *info)
 599 {
 600     WMScreen *scr = W_VIEW_SCREEN(destView);
 601
 602     return W_OperationToAction(scr,
 603                                destView->dragDestinationProcs->allowedOperation(
 604                                                                                 destView,
 605                                                                                 W_ActionToOperation(scr, XDND_SOURCE_ACTION(info)),
 606                                                                                 XDND_SOURCE_TYPES(info)));
 607 }
 608
 609
 610 static void*
 611 checkActionAllowed(WMView *destView, WMDraggingInfo* info)
 612 {
 613     XDND_DEST_ACTION(info) =
 614         getAllowedAction(destView, info);
 615
 616     if (XDND_DEST_ACTION(info) == None) {
 617         suspendDropAuthorization(destView, info);
 618         return dropNotAllowedState;
 619     }
 620
 621     sendStatusMessage(destView, info, XDND_DEST_ACTION(info));
 622     return dropAllowedState;
 623 }
 624
 625
 626 static void*
 627 checkDropAllowed(WMView *destView, XClientMessageEvent *event,
 628                  WMDraggingInfo* info)
 629 {
 630     storeRequiredTypeList(info);
 631
 632     if (destView->dragDestinationProcs->inspectDropData != NULL) {
 633         XDND_DROP_DATAS(info) = createDropDataArray(
 634                                                     XDND_REQUIRED_TYPES(info));
 635
 636         /* store first available data */
 637         if (requestDropData(info))
 638             return inspectDropDataState;
 639
 640         /* no data retrieved, but inspect can allow it */
 641         if (destView->dragDestinationProcs->inspectDropData(
 642                                                             destView,
 643                                                             XDND_DROP_DATAS(info)))
 644             return checkActionAllowed(destView, info);
 645
 646         suspendDropAuthorization(destView, info);
 647         return dropNotAllowedState;
 648     }
 649
 650     return checkActionAllowed(destView, info);
 651 }
 652
 653
 654 static WMPoint*
 655 getDropLocationInView(WMView *view)
 656 {
 657     Window rootWin, childWin;
 658     int rootX, rootY;
 659     unsigned int mask;
 660     WMPoint* location;
 661
 662     location = (WMPoint*) wmalloc(sizeof(WMPoint));
 663
 664     XQueryPointer(
 665                   W_VIEW_SCREEN(view)->display,
 666                   WMViewXID(view), &rootWin, &childWin,
 667                   &rootX, &rootY,
 668                   &(location->x), &(location->y),
 669                   &mask);
 670
 671     return location;
 672 }
 673
 674
 675 static void
 676 callPerformDragOperation(WMView *destView, WMDraggingInfo *info)
 677 {
 678     WMArray *operationList = NULL;
 679     WMScreen *scr = W_VIEW_SCREEN(destView);
 680     WMPoint* dropLocation;
 681
 682     if (XDND_SOURCE_ACTION(info) == scr->xdndActionAsk)
 683         operationList = sourceOperationList(scr, XDND_SOURCE_WIN(info));
 684
 685     dropLocation = getDropLocationInView(destView);
 686     destView->dragDestinationProcs->performDragOperation(
 687                                                          destView,
 688                                                          XDND_DROP_DATAS(info),
 689                                                          operationList,
 690                                                          dropLocation);
 691
 692     wfree(dropLocation);
 693     if (operationList != NULL)
 694         WMFreeArray(operationList);
 695 }
 696
 697
 698 /* ----- Destination timer ----- */
 699 static void
 700 dragSourceResponseTimeOut(void *destView)
 701 {
 702     WMView *view = (WMView*) destView;
 703     WMDraggingInfo *info;
 704
 705     wwarning("delay for drag source response expired");
 706     info = &(W_VIEW_SCREEN(view)->dragInfo);
 707     if (XDND_DEST_VIEW_IS_REGISTERED(info))
 708         cancelDrop(view, info);
 709     else {
 710         sendStatusMessage(view, info, None);
 711     }
 712
 713     W_DragDestinationInfoClear(info);
 714 }
 715
 716
 717 void
 718 W_DragDestinationStopTimer()
 719 {
 720     if (dndDestinationTimer != NULL) {
 721         WMDeleteTimerHandler(dndDestinationTimer);
 722         dndDestinationTimer = NULL;
 723     }
 724 }
 725
 726
 727 void
 728 W_DragDestinationStartTimer(WMDraggingInfo *info)
 729 {
 730     W_DragDestinationStopTimer();
 731
 732     if (XDND_DEST_STATE(info) != idleState)
 733         dndDestinationTimer = WMAddTimerHandler(
 734                                                 XDND_SOURCE_RESPONSE_MAX_DELAY,
 735                                                 dragSourceResponseTimeOut,
 736                                                 XDND_DEST_VIEW(info));
 737 }
 738 /* ----- End of Destination timer ----- */
 739
 740
 741 /* ----- Destination states ----- */
 742
 743 #ifdef XDND_DEBUG
 744 static const char*
 745 stateName(W_DndState *state)
 746 {
 747     if (state == NULL)
 748         return "no state defined";
 749
 750     if (state == idleState)
 751         return "idleState";
 752
 753     if (state == waitEnterState)
 754         return "waitEnterState";
 755
 756     if (state == inspectDropDataState)
 757         return "inspectDropDataState";
 758
 759     if (state == dropAllowedState)
 760         return "dropAllowedState";
 761
 762     if (state == dropNotAllowedState)
 763         return "dropNotAllowedState";
 764
 765     if (state == waitForDropDataState)
 766         return "waitForDropDataState";
 767
 768     return "unknown state";
 769 }
 770 #endif
 771
 772
 773 static void*
 774 idleState(WMView *destView, XClientMessageEvent *event,
 775           WMDraggingInfo *info)
 776 {
 777     WMScreen *scr;
 778     Atom sourceMsg;
 779
 780     if (destView->dragDestinationProcs != NULL) {
 781         scr = W_VIEW_SCREEN(destView);
 782         sourceMsg = event->message_type;
 783
 784         if (sourceMsg == scr->xdndPositionAtom) {
 785             destView->dragDestinationProcs->prepareForDragOperation(destView);
 786
 787             if (XDND_SOURCE_TYPES(info) != NULL) {
 788                 /* enter message infos are available */
 789                 return checkDropAllowed(destView, event, info);
 790             }
 791
 792             /* waiting for enter message */
 793             return waitEnterState;
 794         }
 795     }
 796
 797     suspendDropAuthorization(destView, info);
 798     return idleState;
 799 }
 800
 801
 802 /*  Source position and action are stored,
 803  waiting for xdnd protocol version and source type */
 804 static void*
 805 waitEnterState(WMView *destView, XClientMessageEvent *event,
 806                WMDraggingInfo *info)
 807 {
 808     WMScreen *scr = W_VIEW_SCREEN(destView);
 809     Atom sourceMsg = event->message_type;
 810
 811     if (sourceMsg == scr->xdndEnterAtom) {
 812         W_DragDestinationStoreEnterMsgInfo(info, destView, event);
 813         return checkDropAllowed(destView, event, info);
 814     }
 815
 816     return waitEnterState;
 817 }
 818
 819
 820 /* We have requested a data, and have received it */
 821 static void*
 822 inspectDropDataState(WMView *destView, XClientMessageEvent *event,
 823                      WMDraggingInfo *info)
 824 {
 825     WMScreen *scr;
 826     Atom sourceMsg;
 827
 828     scr = W_VIEW_SCREEN(destView);
 829     sourceMsg = event->message_type;
 830
 831     if (sourceMsg == scr->xdndSelectionAtom) {
 832         /* a data has been retrieved, store next available */
 833         if (requestDropData(info))
 834             return inspectDropDataState;
 835
 836         /* all required (and available) datas are stored */
 837         if (destView->dragDestinationProcs->inspectDropData(
 838                                                             destView,
 839                                                             XDND_DROP_DATAS(info)))
 840             return checkActionAllowed(destView, info);
 841
 842         suspendDropAuthorization(destView, info);
 843         return dropNotAllowedState;
 844     }
 845
 846     return inspectDropDataState;
 847 }
 848
 849
 850 static void*
 851 dropNotAllowedState(WMView *destView, XClientMessageEvent *event,
 852                     WMDraggingInfo *info)
 853 {
 854     WMScreen *scr = W_VIEW_SCREEN(destView);
 855     Atom sourceMsg = event->message_type;
 856
 857     if (sourceMsg == scr->xdndDropAtom) {
 858         finishDrop(destView, info);
 859         return idleState;
 860     }
 861
 862     if (sourceMsg == scr->xdndPositionAtom) {
 863         if (XDND_SOURCE_ACTION_CHANGED(info)) {
 864             return checkDropAllowed(destView, event, info);
 865         } else {
 866             sendStatusMessage(destView, info, None);
 867             return dropNotAllowedState;
 868         }
 869     }
 870
 871     return dropNotAllowedState;
 872 }
 873
 874
 875 static void*
 876 dropAllowedState(WMView *destView, XClientMessageEvent *event,
 877                  WMDraggingInfo *info)
 878 {
 879     WMScreen *scr = W_VIEW_SCREEN(destView);
 880     Atom sourceMsg = event->message_type;
 881
 882     if (sourceMsg == scr->xdndDropAtom) {
 883         if (XDND_DROP_DATAS(info) != NULL) {
 884             /* drop datas were cached with inspectDropData call */
 885             callPerformDragOperation(destView, info);
 886         } else {
 887             XDND_DROP_DATAS(info) = createDropDataArray(
 888                                                         XDND_REQUIRED_TYPES(info));
 889
 890             /* store first available data */
 891             if (requestDropData(info))
 892                 return waitForDropDataState;
 893
 894             /* no data retrieved */
 895             callPerformDragOperation(destView, info);
 896         }
 897
 898         finishDrop(destView, info);
 899         return idleState;
 900     }
 901
 902     if (sourceMsg == scr->xdndPositionAtom) {
 903         if (XDND_SOURCE_ACTION_CHANGED(info)) {
 904             return checkDropAllowed(destView, event, info);
 905         } else {
 906             sendStatusMessage(destView, info, XDND_DEST_ACTION(info));
 907             return dropAllowedState;
 908         }
 909     }
 910
 911     return dropAllowedState;
 912 }
 913
 914
 915 static void*
 916 waitForDropDataState(WMView *destView, XClientMessageEvent *event,
 917                      WMDraggingInfo *info)
 918 {
 919     WMScreen *scr = W_VIEW_SCREEN(destView);
 920     Atom sourceMsg = event->message_type;
 921
 922     if (sourceMsg == scr->xdndSelectionAtom) {
 923         /* store next data */
 924         if (requestDropData(info))
 925             return waitForDropDataState;
 926
 927         /* all required (and available) datas are stored */
 928         callPerformDragOperation(destView, info);
 929
 930         finishDrop(destView, info);
 931         return idleState;
 932     }
 933
 934     return waitForDropDataState;
 935 }
 936
 937 /* ----- End of Destination states ----- */
 938
 939
 940 void
 941 W_DragDestinationStateHandler(WMDraggingInfo *info, XClientMessageEvent *event)
 942 {
 943     WMView *destView;
 944     W_DndState* newState;
 945
 946     wassertr(XDND_DEST_INFO(info) != NULL);
 947     wassertr(XDND_DEST_VIEW(info) != NULL);
 948
 949     destView = XDND_DEST_VIEW(info);
 950     if (XDND_DEST_STATE(info) == NULL)
 951         XDND_DEST_STATE(info) = idleState;
 952
 953 #ifdef XDND_DEBUG
 954
 955     printf("current dest state: %s\n",
 956            stateName(XDND_DEST_STATE(info)));
 957 #endif
 958
 959     newState = (W_DndState*) XDND_DEST_STATE(info)(destView, event, info);
 960
 961 #ifdef XDND_DEBUG
 962
 963     printf("new dest state: %s\n", stateName(newState));
 964 #endif
 965
 966     if (XDND_DEST_INFO(info) != NULL) {
 967         XDND_DEST_STATE(info) = newState;
 968         if (XDND_DEST_STATE(info) != idleState)
 969             W_DragDestinationStartTimer(info);
 970     }
 971 }
 972
 973
 974 static void
 975 realizedObserver(void *self, WMNotification *notif)
 976 {
 977     WMView *view = (WMView*)WMGetNotificationObject(notif);
 978     WMScreen *scr = W_VIEW_SCREEN(view);
 979
 980     XChangeProperty(scr->display, W_VIEW_DRAWABLE(view),
 981                     scr->xdndAwareAtom,
 982                     XA_ATOM, XDND_PROPERTY_FORMAT, PropModeReplace,
 983                     &XDNDversion, 1);
 984
 985     WMRemoveNotificationObserver(self);
 986 }
 987
 988
 989 void
 990 W_SetXdndAwareProperty(WMScreen *scr, WMView *view, Atom *types,
 991                        int typeCount)
 992 {
 993     WMView *toplevel = W_TopLevelOfView(view);
 994
 995     if (!toplevel->flags.xdndHintSet) {
 996         toplevel->flags.xdndHintSet = 1;
 997
 998         if (toplevel->flags.realized) {
 999             XChangeProperty(scr->display, W_VIEW_DRAWABLE(toplevel),
1000                             scr->xdndAwareAtom, XA_ATOM, XDND_PROPERTY_FORMAT,
1001                             PropModeReplace, &XDNDversion, 1);
1002         } else {
1003             WMAddNotificationObserver(realizedObserver,
1004                                       /* just use as an id */
1005                                       &view->dragDestinationProcs,
1006                                       WMViewRealizedNotification,
1007                                       toplevel);
1008         }
1009     }
1010 }
1011
1012
1013 void
1014 WMRegisterViewForDraggedTypes(WMView *view, WMArray *acceptedTypes)
1015 {
1016     Atom *types;
1017     int typeCount;
1018     int i;
1019
1020     typeCount = WMGetArrayItemCount(acceptedTypes);
1021     types = wmalloc(sizeof(Atom)*(typeCount+1));
1022
1023     for (i = 0; i < typeCount; i++) {
1024         types[i] = XInternAtom(W_VIEW_SCREEN(view)->display,
1025                                WMGetFromArray(acceptedTypes, i),
1026                                False);
1027     }
1028     types[i] = 0;
1029
1030     view->droppableTypes = types;
1031     /* WMFreeArray(acceptedTypes); */
1032
1033     W_SetXdndAwareProperty(W_VIEW_SCREEN(view), view, types, typeCount);
1034 }
1035
1036
1037 void
1038 WMUnregisterViewDraggedTypes(WMView *view)
1039 {
1040     if (view->droppableTypes != NULL)
1041         wfree(view->droppableTypes);
1042     view->droppableTypes = NULL;
1043 }
1044
1045
1046 /*
1047  requestedOperation: operation requested by the source
1048  sourceDataTypes:  data types (mime-types strings) supported by the source
1049  (never NULL, destroyed when drop ends)
1050  return operation allowed by destination (self)
1051  */
1052 static WMDragOperationType
1053 defAllowedOperation(WMView *self,
1054                     WMDragOperationType requestedOperation,
1055                     WMArray* sourceDataTypes)
1056 {
1057     /* no operation allowed */
1058     return WDOperationNone;
1059 }
1060
1061
1062 /*
1063  requestedOperation: operation requested by the source
1064  sourceDataTypes:  data types (mime-types strings) supported by the source
1065  (never NULL, destroyed when drop ends)
1066  return data types (mime-types strings) required by destination (self)
1067  or NULL if no suitable data type is available (force
1068  to 2nd pass with full source type list).
1069  */
1070 static WMArray*
1071 defRequiredDataTypes (WMView *self,
1072                       WMDragOperationType requestedOperation,
1073                       WMArray* sourceDataTypes)
1074 {
1075     /* no data type allowed (NULL even at 2nd pass) */
1076     return NULL;
1077 }
1078
1079
1080 /*
1081  Executed when the drag enters destination (self)
1082  */
1083 static void
1084 defPrepareForDragOperation(WMView *self)
1085 {
1086 }
1087
1088
1089 /*
1090  Checks datas to be dropped (optional).
1091  dropDatas: datas (WMData*) required by destination (self)
1092  (given in same order as returned by requiredDataTypes).
1093  A NULL data means it couldn't be retreived.
1094  Destroyed when drop ends.
1095  return true if data array is ok
1096  */
1097 /* Bool (*inspectDropData)(WMView *self, WMArray *dropDatas); */
1098
1099
1100 /*
1101  Process drop
1102  dropDatas: datas (WMData*) required by destination (self)
1103  (given in same order as returned by requiredDataTypes).
1104  A NULL data means it couldn't be retrieved.
1105  Destroyed when drop ends.
1106  operationList: if source operation is WDOperationAsk, contains
1107  operations (and associated texts) that can be asked
1108  to source. (destroyed after performDragOperation call)
1109  Otherwise this parameter is NULL.
1110  */
1111 static void
1112 defPerformDragOperation(WMView *self, WMArray *dropDatas,
1113                         WMArray *operationList, WMPoint *dropLocation)
1114 {
1115 }
1116
1117
1118 /* Executed after drop */
1119 static void
1120 defConcludeDragOperation(WMView *self)
1121 {
1122 }
1123
1124
1125 void
1126 WMSetViewDragDestinationProcs(WMView *view, WMDragDestinationProcs *procs)
1127 {
1128     if (view->dragDestinationProcs == NULL) {
1129         view->dragDestinationProcs = wmalloc(sizeof(WMDragDestinationProcs));
1130     } else {
1131         free(view->dragDestinationProcs);
1132     }
1133
1134     *view->dragDestinationProcs = *procs;
1135
1136     /*XXX fill in non-implemented stuffs */
1137     if (procs->allowedOperation == NULL) {
1138         view->dragDestinationProcs->allowedOperation = defAllowedOperation;
1139     }
1140     if (procs->allowedOperation == NULL) {
1141         view->dragDestinationProcs->requiredDataTypes = defRequiredDataTypes;
1142     }
1143
1144     /* note: inspectDropData can be NULL, if data consultation is not needed
1145      to give drop permission */
1146
1147     if (procs->prepareForDragOperation == NULL) {
1148         view->dragDestinationProcs->prepareForDragOperation = defPrepareForDragOperation;
1149     }
1150     if (procs->performDragOperation == NULL) {
1151         view->dragDestinationProcs->performDragOperation = defPerformDragOperation;
1152     }
1153     if (procs->concludeDragOperation == NULL) {
1154         view->dragDestinationProcs->concludeDragOperation = defConcludeDragOperation;
1155     }
1156 }
1157
1158