WINGs/selection.c

   1
   2
   3 #include <stdlib.h>
   4
   5 #include <X11/Xatom.h>
   6
   7 #include "WINGsP.h"
   8
   9 #define MAX_PROPERTY_SIZE 8*1024
  10
  11
  12 char *WMSelectionOwnerDidChangeNotification = "WMSelectionOwnerDidChange";
  13
  14
  15 typedef struct SelectionHandler {
  16     WMView *view;
  17     Atom selection;
  18     Time timestamp;
  19     WMSelectionProcs procs;
  20     void *data;
  21
  22     struct {
  23         unsigned delete_pending:1;
  24         unsigned done_pending:1;
  25     } flags;
  26 } SelectionHandler;
  27
  28
  29 typedef struct SelectionCallback {
  30     WMView *view;
  31     Atom selection;
  32     Atom target;
  33     Time timestamp;
  34     WMSelectionCallback *callback;
  35     void *data;
  36
  37     struct {
  38         unsigned delete_pending:1;
  39         unsigned done_pending:1;
  40     } flags;
  41 } SelectionCallback;
  42
  43
  44
  45 static WMArray *selCallbacks = NULL;
  46
  47 static WMArray *selHandlers = NULL;
  48
  49 static Bool gotXError = False;
  50
  51
  52
  53
  54 void
  55 WMDeleteSelectionHandler(WMView *view, Atom selection, Time timestamp)
  56 {
  57     SelectionHandler *handler;
  58     Display *dpy = W_VIEW_SCREEN(view)->display;
  59     Window win = W_VIEW_DRAWABLE(view);
  60     WMArrayIterator iter;
  61
  62     if (!selHandlers)
  63         return;
  64
  65     printf("deleting selection handler for %d", win);
  66
  67     WM_ITERATE_ARRAY(selHandlers, handler, iter) {
  68         if (handler->view == view
  69             && (handler->selection == selection || selection == None)
  70             && (handler->timestamp == timestamp || timestamp == CurrentTime)) {
  71
  72             if (handler->flags.done_pending) {
  73                 handler->flags.delete_pending = 1;
  74                 puts(": postponed because still pending");
  75                 return;
  76             }
  77             printf(": found & removed");
  78             WMRemoveFromArray(selHandlers, handler);
  79             break;
  80         }
  81     }
  82
  83     printf("\n");
  84
  85     XGrabServer(dpy);
  86     if (XGetSelectionOwner(dpy, selection) == win) {
  87         XSetSelectionOwner(dpy, selection, None, timestamp);
  88     }
  89     XUngrabServer(dpy);
  90 }
  91
  92
  93
  94 void
  95 WMDeleteSelectionCallback(WMView *view, Atom selection, Time timestamp)
  96 {
  97     SelectionCallback *handler;
  98     WMArrayIterator iter;
  99
 100     if (!selCallbacks)
 101         return;
 102
 103     WM_ITERATE_ARRAY(selCallbacks, handler, iter) {
 104         if (handler->view == view
 105             && (handler->selection == selection || selection == None)
 106             && (handler->timestamp == timestamp || timestamp == CurrentTime)) {
 107
 108             if (handler->flags.done_pending) {
 109                 handler->flags.delete_pending = 1;
 110                 return;
 111             }
 112             WMRemoveFromArray(selCallbacks, handler);
 113             break;
 114         }
 115     }
 116 }
 117
 118
 119 static int
 120 handleXError(Display *dpy, XErrorEvent *ev)
 121 {
 122     gotXError = True;
 123
 124     return 1;
 125 }
 126
 127
 128 static Bool
 129 writeSelection(Display *dpy, Window requestor, Atom property, Atom type,
 130                WMData *data)
 131 {
 132     static void *oldHandler;
 133     int format, bpi;
 134
 135     format = WMGetDataFormat(data);
 136     if (format == 0)
 137         format = 8;
 138
 139     bpi = format/8;
 140
 141     /* printf("write to %x: %s\n", requestor, XGetAtomName(dpy, property)); */
 142
 143     oldHandler = XSetErrorHandler(handleXError);
 144
 145     gotXError = False;
 146
 147     XChangeProperty(dpy, requestor, property, type, format, PropModeReplace,
 148                     WMDataBytes(data), WMGetDataLength(data)/bpi);
 149
 150     XFlush(dpy);
 151
 152     XSetErrorHandler(oldHandler);
 153
 154     return !gotXError;
 155 }
 156
 157
 158 static void
 159 notifySelection(XEvent *event, Atom prop)
 160 {
 161     XEvent ev;
 162
 163     /* printf("event to %x\n", event->xselectionrequest.requestor); */
 164
 165     ev.xselection.type = SelectionNotify;
 166     ev.xselection.serial = 0;
 167     ev.xselection.send_event = True;
 168     ev.xselection.display = event->xselectionrequest.display;
 169     ev.xselection.requestor = event->xselectionrequest.requestor;
 170     ev.xselection.target = event->xselectionrequest.target;
 171     ev.xselection.selection = event->xselectionrequest.selection;
 172     ev.xselection.property = prop;
 173     ev.xselection.time = event->xselectionrequest.time;
 174
 175     XSendEvent(event->xany.display, event->xselectionrequest.requestor,
 176                False, 0, &ev);
 177     XFlush(event->xany.display);
 178 }
 179
 180
 181 static void
 182 handleRequestEvent(XEvent *event)
 183 {
 184     SelectionHandler *handler;
 185     WMArrayIterator iter;
 186     WMArray *copy;
 187     Bool handledRequest;
 188
 189     WM_ITERATE_ARRAY(selHandlers, handler, iter) {
 190
 191         switch (event->type) {
 192          case SelectionClear:
 193             if (W_VIEW_DRAWABLE(handler->view)
 194                 != event->xselectionclear.window) {
 195                 break;
 196             }
 197
 198             handler->flags.done_pending = 1;
 199             if (handler->procs.selectionLost)
 200                 handler->procs.selectionLost(handler->view,
 201                                              handler->selection,
 202                                              handler->data);
 203             handler->flags.done_pending = 0;
 204             handler->flags.delete_pending = 1;
 205             break;
 206
 207          case SelectionRequest:
 208             if (W_VIEW_DRAWABLE(handler->view)!=event->xselectionrequest.owner) {
 209                 break;
 210             }
 211
 212             if (handler->procs.convertSelection != NULL
 213                 && handler->selection == event->xselectionrequest.selection) {
 214                 Atom atom;
 215                 WMData *data;
 216                 Atom prop;
 217
 218                 /* they're requesting for something old.. maybe another handler
 219                  * can handle it */
 220                 if (event->xselectionrequest.time < handler->timestamp
 221                     && event->xselectionrequest.time != CurrentTime) {
 222                     break;
 223                 }
 224
 225                 handledRequest = False;
 226
 227                 handler->flags.done_pending = 1;
 228
 229                 data = handler->procs.convertSelection(handler->view,
 230                                                      handler->selection,
 231                                                      event->xselectionrequest.target,
 232                                                      handler->data,
 233                                                      &atom);
 234
 235                 prop = event->xselectionrequest.property;
 236                 /* obsolete clients that don't set the property field */
 237                 if (prop == None)
 238                     prop = event->xselectionrequest.target;
 239
 240                 if (data) {
 241                     if (writeSelection(event->xselectionrequest.display,
 242                                        event->xselectionrequest.requestor,
 243                                        prop, atom, data)) {
 244                         handledRequest = True;
 245                     }
 246                     WMReleaseData(data);
 247                 }
 248
 249                 notifySelection(event, (handledRequest==True ? prop : None));
 250
 251                 if (handler->procs.selectionDone != NULL) {
 252                     handler->procs.selectionDone(handler->view,
 253                                          handler->selection,
 254                                          event->xselectionrequest.target,
 255                                          handler->data);
 256                 }
 257
 258                 handler->flags.done_pending = 0;
 259             }
 260             break;
 261         }
 262     }
 263
 264     /* delete handlers */
 265     copy = WMDuplicateArray(selHandlers);
 266     WM_ITERATE_ARRAY(copy, handler, iter) {
 267         if (handler && handler->flags.delete_pending) {
 268             WMDeleteSelectionHandler(handler->view, handler->selection,
 269                                      handler->timestamp);
 270         }
 271     }
 272     WMFreeArray(copy);
 273 }
 274
 275
 276 static WMData*
 277 getSelectionData(Display *dpy, Window win, Atom where)
 278 {
 279     WMData *wdata;
 280     unsigned char *data;
 281     Atom rtype;
 282     unsigned bits, bpi;
 283     unsigned long len, bytes;
 284
 285
 286     if (XGetWindowProperty(dpy, win, where, 0, MAX_PROPERTY_SIZE,
 287                            False, AnyPropertyType, &rtype, &bits, &len,
 288                            &bytes, &data)!=Success) {
 289         return NULL;
 290     }
 291
 292     bpi = bits/8;
 293
 294     wdata = WMCreateDataWithBytesNoCopy(data, len*bpi, (WMFreeDataProc*)XFree);
 295     WMSetDataFormat(wdata, bits);
 296
 297     return wdata;
 298 }
 299
 300
 301 static void
 302 handleNotifyEvent(XEvent *event)
 303 {
 304     SelectionCallback *handler;
 305     WMArrayIterator iter;
 306     WMArray *copy;
 307     WMData *data;
 308
 309     WM_ITERATE_ARRAY(selCallbacks, handler, iter) {
 310
 311         if (W_VIEW_DRAWABLE(handler->view) != event->xselection.requestor
 312             || handler->selection != event->xselection.selection) {
 313             continue;
 314         }
 315         handler->flags.done_pending = 1;
 316
 317         if (event->xselection.property == None) {
 318             data = NULL;
 319         } else {
 320             data = getSelectionData(event->xselection.display,
 321                                     event->xselection.requestor,
 322                                     event->xselection.property);
 323         }
 324
 325         (*handler->callback)(handler->view, handler->selection,
 326                              handler->target, handler->timestamp,
 327                              handler->data, data);
 328
 329         if (data != NULL) {
 330             WMReleaseData(data);
 331         }
 332         handler->flags.done_pending = 0;
 333         handler->flags.delete_pending = 1;
 334     }
 335
 336     /* delete callbacks */
 337     copy = WMDuplicateArray(selCallbacks);
 338     WM_ITERATE_ARRAY(copy, handler, iter) {
 339         if (handler && handler->flags.delete_pending) {
 340             WMDeleteSelectionCallback(handler->view, handler->selection,
 341                                       handler->timestamp);
 342         }
 343     }
 344     WMFreeArray(copy);
 345 }
 346
 347
 348
 349 void
 350 W_HandleSelectionEvent(XEvent *event)
 351 {
 352     printf("%d received selection ", event->xany.window);
 353     switch(event->type) {
 354     case SelectionNotify:
 355         puts("notify"); break;
 356     case SelectionRequest:
 357         puts("request"); break;
 358     case SelectionClear:
 359         puts("clear"); break;
 360     default:
 361         puts("unknown"); break;
 362     }
 363
 364     if (event->type == SelectionNotify) {
 365         handleNotifyEvent(event);
 366     } else {
 367         handleRequestEvent(event);
 368     }
 369 }
 370
 371
 372
 373 Bool
 374 WMCreateSelectionHandler(WMView *view, Atom selection, Time timestamp,
 375                          WMSelectionProcs *procs, void *cdata)
 376 {
 377     SelectionHandler *handler;
 378     Display *dpy = W_VIEW_SCREEN(view)->display;
 379
 380     XSetSelectionOwner(dpy, selection, W_VIEW_DRAWABLE(view), timestamp);
 381     if (XGetSelectionOwner(dpy, selection) != W_VIEW_DRAWABLE(view)) {
 382         return False;
 383     }
 384
 385     WMPostNotificationName(WMSelectionOwnerDidChangeNotification,
 386                            (void*)selection, (void*)view);
 387
 388     printf("created selection handler for %d\n", W_VIEW_DRAWABLE(view));
 389
 390     handler = wmalloc(sizeof(SelectionHandler));
 391
 392     handler->view = view;
 393     handler->selection = selection;
 394     handler->timestamp = timestamp;
 395     handler->procs = *procs;
 396     handler->data = cdata;
 397     memset(&handler->flags, 0, sizeof(handler->flags));
 398
 399     if (selHandlers == NULL) {
 400         selHandlers = WMCreateArrayWithDestructor(4, wfree);
 401     }
 402
 403     WMAddToArray(selHandlers, handler);
 404
 405     return True;
 406 }
 407
 408
 409
 410 Bool
 411 WMRequestSelection(WMView *view, Atom selection, Atom target, Time timestamp,
 412                    WMSelectionCallback *callback, void *cdata)
 413 {
 414     SelectionCallback *handler;
 415
 416     if (XGetSelectionOwner(W_VIEW_SCREEN(view)->display, selection) == None)
 417         return False;
 418
 419     if (!XConvertSelection(W_VIEW_SCREEN(view)->display, selection, target,
 420                            W_VIEW_SCREEN(view)->clipboardAtom,
 421                            W_VIEW_DRAWABLE(view), timestamp)) {
 422         return False;
 423     }
 424
 425     handler = wmalloc(sizeof(SelectionCallback));
 426
 427     handler->view = view;
 428     handler->selection = selection;
 429     handler->target = target;
 430     handler->timestamp = timestamp;
 431     handler->callback = callback;
 432     handler->data = cdata;
 433     memset(&handler->flags, 0, sizeof(handler->flags));
 434
 435     if (selCallbacks == NULL) {
 436         selCallbacks = WMCreateArrayWithDestructor(4, wfree);
 437     }
 438
 439     WMAddToArray(selCallbacks, handler);
 440
 441     return True;
 442 }
 443