WINGs/dragdestination.c

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