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