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