arch/all-x11/hidd/x11clipboard.c

   1 /*
   2     Copyright © 1995-2006, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: X11 hidd. Host clipboard support.
   6     Lang: English.
   7 */
   8
   9
  10 #include <proto/exec.h>
  11 #include <proto/oop.h>
  12 #include <proto/utility.h>
  13
  14 #define size_t aros_size_t
  15 #include <hidd/unixio.h>
  16 #include <hidd/hidd.h>
  17
  18 #include <oop/ifmeta.h>
  19
  20 #include <dos/dos.h>
  21
  22 #include <exec/types.h>
  23 #include <exec/lists.h>
  24 #include <exec/memory.h>
  25 #include <exec/libraries.h>
  26 #include <exec/resident.h>
  27 #include <hardware/intbits.h>
  28 #include <utility/utility.h>
  29
  30 #include <aros/asmcall.h>
  31 #undef size_t
  32
  33 #define timeval sys_timeval
  34 #include <sys/types.h>
  35 #include <signal.h>
  36 #include <stddef.h>
  37 #include <stdio.h>
  38 #include <stdlib.h>
  39 #include <string.h>
  40 #include <unistd.h>
  41 #undef timeval
  42
  43 #include <X11/Xlib.h>
  44 #include <X11/Xutil.h>
  45 #include <X11/Xatom.h>
  46
  47 #include "x11.h"
  48 #include "x11gfx_intern.h"
  49
  50 #define DEBUG 1
  51 #include <aros/debug.h>
  52
  53 #undef XSD
  54 #define XSD(cl) xsd
  55
  56 /****************************************************************************************/
  57
  58 #define REQ_CMD(msg)        ((msg)->mn_Node.ln_Pri)
  59 #define REQ_PARAM(msg)      ((msg)->mn_Node.ln_Name)
  60
  61 #define REQ_RETVAL(msg)     ((msg)->mn_Node.ln_Name)
  62 #define REQ_SUCCESS(msg)    ((msg)->mn_Node.ln_Pri)
  63
  64 /****************************************************************************************/
  65
  66 STATIC VOID listen_for_xevent(struct x11_staticdata *xsd, long event, BOOL yesno)
  67 {
  68     XWindowAttributes xwa;
  69
  70     LOCK_X11
  71     XGetWindowAttributes(xsd->display,
  72                          xsd->dummy_window_for_creating_pixmaps,
  73                          &xwa);
  74     if (yesno)
  75     {
  76         event = xwa.your_event_mask | event;
  77     }
  78     else
  79     {
  80         event = xwa.your_event_mask &~ event;
  81     }
  82
  83     XSelectInput(xsd->display, xsd->dummy_window_for_creating_pixmaps, event);
  84     UNLOCK_X11
  85 }
  86
  87 /****************************************************************************************/
  88
  89 STATIC VOID reply_async_request(struct x11_staticdata *xsd, void *primary_retval, int success)
  90 {
  91     xsd->hostclipboard_readstate = HOSTCLIPBOARDSTATE_IDLE;
  92     REQ_SUCCESS(xsd->hostclipboardmsg) = success;
  93     REQ_RETVAL(xsd->hostclipboardmsg) = (char *)primary_retval;
  94     ReplyMsg(xsd->hostclipboardmsg);
  95
  96     xsd->hostclipboardmsg = NULL;
  97
  98     /* In case messages were sent, while an async request was in progress */
  99     Signal(xsd->hostclipboardmp->mp_SigTask, 1L << xsd->hostclipboardmp->mp_SigBit);
 100 }
 101
 102 /****************************************************************************************/
 103
 104 ULONG x11clipboard_init(struct x11_staticdata *xsd)
 105 {
 106     ULONG hostclipboardmask = 0;
 107
 108     xsd->hostclipboardmp = CreateMsgPort();
 109     if (xsd->hostclipboardmp)
 110     {
 111         xsd->hostclipboardmp->mp_Node.ln_Name = "HOST_CLIPBOARD";
 112         hostclipboardmask = 1L << xsd->hostclipboardmp->mp_SigBit;
 113
 114         AddPort(xsd->hostclipboardmp);
 115     }
 116
 117     return hostclipboardmask;
 118 }
 119
 120 /****************************************************************************************/
 121
 122 VOID x11clipboard_handle_commands(struct x11_staticdata *xsd)
 123 {
 124     struct Message *msg;
 125
 126     if (xsd->hostclipboardmsg) return;
 127
 128     D(bug("X11CLIPBOARD: handle_commands\n"));
 129     while((msg = GetMsg(xsd->hostclipboardmp)))
 130     {
 131         char cmd = REQ_CMD(msg);
 132         BOOL  async = FALSE;
 133
 134         REQ_SUCCESS(msg) = FALSE;
 135
 136         if (cmd == 'R')
 137         {
 138             D(bug("X11CLIPBOARD: handle_commands - READ\n"));
 139
 140             if ((xsd->hostclipboard_readstate == HOSTCLIPBOARDSTATE_IDLE))
 141             {
 142                 LOCK_X11
 143                 XConvertSelection(xsd->display,
 144                                   xsd->clipboard_atom,
 145                                   XA_STRING,
 146                                   xsd->clipboard_property_atom,
 147                                   xsd->dummy_window_for_creating_pixmaps,
 148                                   CurrentTime);
 149
 150                 UNLOCK_X11
 151
 152                 xsd->hostclipboard_readstate = HOSTCLIPBOARDSTATE_READ;
 153                 async = TRUE;
 154             }
 155         }
 156         else if (cmd == 'W')
 157         {
 158             unsigned char *srcbuffer = (unsigned char *)REQ_PARAM(msg);
 159             ULONG          size = strlen(srcbuffer);
 160             unsigned char *newbuffer;
 161
 162             D(bug("X11CLIPBOARD: handle_commands: WRITE\n"));
 163
 164             newbuffer = AllocVec(size, MEMF_ANY);
 165             if (newbuffer)
 166             {
 167                 memcpy(newbuffer, srcbuffer, size);
 168
 169                 if (xsd->hostclipboard_writebuffer)
 170                 {
 171                     FreeVec(xsd->hostclipboard_writebuffer);
 172                 }
 173
 174                 xsd->hostclipboard_writebuffer = newbuffer;
 175                 xsd->hostclipboard_writebuffer_size = size;
 176
 177                 LOCK_X11
 178                 XSetSelectionOwner(xsd->display, xsd->clipboard_atom,
 179                                    xsd->dummy_window_for_creating_pixmaps, xsd->x_time);
 180                 UNLOCK_X11
 181
 182                 REQ_SUCCESS(msg) = TRUE;
 183                 REQ_RETVAL(msg) = NULL;
 184             }
 185             else
 186             {
 187                 REQ_SUCCESS(msg) = FALSE;
 188                 REQ_RETVAL(msg) = NULL;
 189             }
 190         }
 191
 192         if (async)
 193         {
 194             xsd->hostclipboardmsg = msg;
 195             break;
 196         }
 197
 198         ReplyMsg(msg);
 199     }
 200 }
 201
 202 /****************************************************************************************/
 203
 204 BOOL x11clipboard_want_event(XEvent *event)
 205 {
 206     if ((event->type == SelectionNotify) ||
 207         (event->type == PropertyNotify) ||
 208         (event->type == SelectionRequest))
 209     {
 210         return TRUE;
 211     }
 212
 213     return FALSE;
 214 }
 215
 216 /****************************************************************************************/
 217
 218 VOID x11clipboard_handle_event(struct x11_staticdata *xsd, XEvent *event)
 219 {
 220     switch(event->type)
 221     {
 222         case SelectionNotify:
 223             D(bug("X11CLIPBOARD: SelectionNotify Event\n"));
 224
 225             if (xsd->hostclipboardmsg && (xsd->hostclipboard_readstate == HOSTCLIPBOARDSTATE_READ))
 226             {
 227                 Atom                actual_type;
 228                 int                 actual_format;
 229                 unsigned long   nitems;
 230                 unsigned long   bytes_after;
 231                 unsigned char  *buffer, *arosbuffer;
 232
 233                 LOCK_X11
 234                 XGetWindowProperty(xsd->display,
 235                                    xsd->dummy_window_for_creating_pixmaps,
 236                                    xsd->clipboard_property_atom,
 237                                    0,
 238                                    0,
 239                                    False,
 240                                    AnyPropertyType,
 241                                    &actual_type,
 242                                    &actual_format,
 243                                    &nitems,
 244                                    &bytes_after,
 245                                    &buffer);
 246                 XFree(buffer);
 247                 UNLOCK_X11
 248
 249                 if (actual_type == xsd->clipboard_incr_atom)
 250                 {
 251                     LOCK_X11
 252                     listen_for_xevent(xsd, PropertyChangeMask, TRUE);
 253                     XDeleteProperty(xsd->display,
 254                                     xsd->dummy_window_for_creating_pixmaps,
 255                                     xsd->clipboard_property_atom);
 256                     XFlush(xsd->display);
 257                     UNLOCK_X11;
 258
 259                     xsd->hostclipboard_readstate = HOSTCLIPBOARDSTATE_READ_INCR;
 260
 261                     D(bug("X11CLIPBOARD: SelectionNotify - INCR protocol\n"));
 262                     break;
 263                 }
 264
 265                 if (actual_format != 8)
 266                 {
 267                     D(bug("X11CLIPBOARD: SelectionNotify - format is <> 8, so terminating READ request with error.\n"));
 268
 269                     reply_async_request(xsd, NULL, FALSE);
 270                     break;
 271                 }
 272
 273                 LOCK_X11
 274                 XGetWindowProperty(xsd->display,
 275                                    xsd->dummy_window_for_creating_pixmaps,
 276                                    xsd->clipboard_property_atom,
 277                                    0,
 278                                    bytes_after,
 279                                    False,
 280                                    AnyPropertyType,
 281                                    &actual_type,
 282                                    &actual_format,
 283                                    &nitems,
 284                                    &bytes_after,
 285                                    &buffer);
 286
 287                 XDeleteProperty(xsd->display,
 288                                 xsd->dummy_window_for_creating_pixmaps,
 289                                 xsd->clipboard_property_atom);
 290
 291                 arosbuffer = AllocVec(nitems + 1, MEMF_ANY);
 292                 if (arosbuffer)
 293                 {
 294                     memcpy(arosbuffer, buffer, nitems);
 295                     arosbuffer[nitems] = '\0';
 296                 }
 297                 XFree(buffer);
 298                 UNLOCK_X11;
 299
 300                 D(bug("X11CLIPBOARD: SelectionNotify - terminating READ request with %s\n", arosbuffer ? "success" : "failure"));
 301
 302                 reply_async_request(xsd, arosbuffer, arosbuffer ? TRUE : FALSE);
 303
 304             } /* if (xsd->hostclipboardmsg && (xsd->hostclipboard_readstate == HOSTCLIPBOARDSTATE_READ))*/
 305             break;
 306
 307         case PropertyNotify:
 308             D(bug("X11CLIPBOARD: PropertyNotify Event\n"));
 309
 310             if (xsd->hostclipboardmsg && (xsd->hostclipboard_readstate == HOSTCLIPBOARDSTATE_READ_INCR))
 311             {
 312                 if ((event->xproperty.atom == xsd->clipboard_property_atom) &&
 313                     (event->xproperty.state == PropertyNewValue))
 314                 {
 315                     Atom            actual_type;
 316                     int             actual_format;
 317                     unsigned long   nitems;
 318                     unsigned long   bytes_after;
 319                     unsigned char  *buffer, *arosbuffer;
 320
 321                     D(bug("X11CLIPBOARD: PropertyNotify - property event okay\n"));
 322
 323                     LOCK_X11
 324                     XGetWindowProperty(xsd->display,
 325                                        xsd->dummy_window_for_creating_pixmaps,
 326                                        xsd->clipboard_property_atom,
 327                                        0,
 328                                        0,
 329                                        False,
 330                                        AnyPropertyType,
 331                                        &actual_type,
 332                                        &actual_format,
 333                                        &nitems,
 334                                        &bytes_after,
 335                                        &buffer);
 336                     XFree(buffer);
 337                     UNLOCK_X11
 338
 339                     if (actual_format == 8)
 340                     {
 341                         D(bug("X11CLIPBOARD: PropertyNotify - format(8) okay\n"));
 342                         if (bytes_after == 0)
 343                         {
 344                             D(bug("X11CLIPBOARD: PropertyNotify - last one detected. Terminating READ request with %s\n",
 345                                   xsd->hostclipboard_incrbuffer ? "success" : "failure"));
 346
 347                             reply_async_request(xsd, xsd->hostclipboard_incrbuffer,
 348                                                 xsd->hostclipboard_incrbuffer ? TRUE : FALSE);
 349
 350                             xsd->hostclipboard_incrbuffer = NULL;
 351                             xsd->hostclipboard_incrbuffer_size = 0;
 352
 353                             listen_for_xevent(xsd, PropertyChangeMask, FALSE);
 354                         }
 355                         else
 356                         {
 357                             LOCK_X11
 358                             XGetWindowProperty(xsd->display,
 359                                                xsd->dummy_window_for_creating_pixmaps,
 360                                                xsd->clipboard_property_atom,
 361                                                0,
 362                                                bytes_after,
 363                                                False,
 364                                                AnyPropertyType,
 365                                                &actual_type,
 366                                                &actual_format,
 367                                                &nitems,
 368                                                &bytes_after,
 369                                                &buffer);
 370
 371                             if (!xsd->hostclipboard_incrbuffer)
 372                             {
 373                                 /* No buffer allocated yet. */
 374
 375                                 D(bug("X11CLIPBOARD: PropertyNotify - First INCR packet of size %d\n", nitems));
 376                                 xsd->hostclipboard_incrbuffer = AllocVec(nitems + 1, MEMF_ANY);
 377                                 if (xsd->hostclipboard_incrbuffer)
 378                                 {
 379                                     memcpy(xsd->hostclipboard_incrbuffer, buffer, nitems);
 380                                     xsd->hostclipboard_incrbuffer[nitems] = '\0';
 381                                     xsd->hostclipboard_incrbuffer_size = nitems;
 382                                 }
 383                                 else
 384                                 {
 385                                     D(bug("X11CLIPBOARD: PropertyNotify - Allocation of incrbuffer failed! Terminating READ request with failure\n"));
 386
 387                                     reply_async_request(xsd, NULL, FALSE);
 388
 389                                     listen_for_xevent(xsd, PropertyChangeMask, FALSE);
 390                                 }
 391                             }
 392                             else
 393                             {
 394                                 /* Buffer already allocated. Do a re-allocation! */
 395
 396                                 D(bug("X11CLIPBOARD: PropertyNotify - One more INCR packet of size %d. Total size now %d\n",
 397                                       nitems, xsd->hostclipboard_incrbuffer_size + nitems));
 398
 399                                 arosbuffer = AllocVec(xsd->hostclipboard_incrbuffer_size + nitems + 1, MEMF_ANY);
 400                                 if (arosbuffer)
 401                                 {
 402                                     memcpy(arosbuffer, xsd->hostclipboard_incrbuffer, xsd->hostclipboard_incrbuffer_size);
 403                                     FreeVec(xsd->hostclipboard_incrbuffer);
 404                                     xsd->hostclipboard_incrbuffer = arosbuffer;
 405
 406                                     memcpy(xsd->hostclipboard_incrbuffer + xsd->hostclipboard_incrbuffer_size,
 407                                            buffer,
 408                                            nitems);
 409
 410                                     xsd->hostclipboard_incrbuffer_size += nitems;
 411                                     xsd->hostclipboard_incrbuffer[xsd->hostclipboard_incrbuffer_size] = '\0';
 412                                 }
 413                                 else
 414                                 {
 415                                     D(bug("X11CLIPBOARD: PropertyNotify - Reallocation of incrbuffer failed! Terminating READ request with failure\n"));
 416
 417                                     FreeVec(xsd->hostclipboard_incrbuffer);
 418
 419                                     reply_async_request(xsd, NULL, FALSE);
 420
 421                                     xsd->hostclipboard_incrbuffer = NULL;
 422                                     xsd->hostclipboard_incrbuffer_size = 0;
 423
 424                                     listen_for_xevent(xsd, PropertyChangeMask, FALSE);
 425                                 }
 426
 427                             } /* if (!xsd->hostclipboard_incrbuffer) else ... */
 428
 429                             XFree(buffer);
 430                             UNLOCK_X11
 431
 432                         } /* if (bytes_after == 0) else ... */
 433
 434                     } /* if (actual_format == 8) */
 435
 436                     LOCK_X11
 437                     XDeleteProperty(xsd->display,
 438                                     xsd->dummy_window_for_creating_pixmaps,
 439                                     xsd->clipboard_property_atom);
 440                     XFlush(xsd->display);
 441                     UNLOCK_X11
 442
 443                 } /* if it's right property and the property has new value */
 444
 445             } /* if (xsd->hostclipboardmsg && (xsd->hostclipboard_readstate == HOSTCLIPBOARDSTATE_READ_INCR)) */
 446
 447             break;
 448
 449         case SelectionRequest:
 450             D(bug("X11CLIPBOARD: SelectionRequest Event\n"));
 451
 452             if (xsd->hostclipboard_writebuffer)
 453             {
 454                 XEvent e;
 455
 456                 D(bug("X11CLIPBOARD: SelectionRequest Event - state okay\n"));
 457
 458                 e.xselection.type       = SelectionNotify;
 459                 e.xselection.display    = event->xselectionrequest.display;
 460                 e.xselection.requestor  = event->xselectionrequest.requestor;
 461                 e.xselection.selection  = event->xselectionrequest.selection;
 462                 e.xselection.target     = event->xselectionrequest.target;
 463                 e.xselection.property   = event->xselectionrequest.property;
 464                 e.xselection.time       = event->xselectionrequest.time;
 465
 466                 xsd->hostclipboard_writerequest_window = event->xselectionrequest.requestor;
 467                 xsd->hostclipboard_writerequest_property = event->xselectionrequest.property;
 468
 469                 if (event->xselectionrequest.target == xsd->clipboard_targets_atom)
 470                 {
 471                     long supported_targets[] = {XA_STRING};
 472
 473                     LOCK_X11
 474                     XChangeProperty(xsd->display,
 475                                     xsd->hostclipboard_writerequest_window,
 476                                     xsd->hostclipboard_writerequest_property,
 477                                     xsd->clipboard_targets_atom,
 478                                     32,
 479                                     PropModeReplace,
 480                                     (unsigned char *)supported_targets,
 481                                     sizeof(supported_targets) / sizeof(supported_targets[0]));
 482                     UNLOCK_X11
 483
 484                 }
 485                 else if (event->xselectionrequest.target == XA_STRING)
 486                 {
 487
 488                     LOCK_X11
 489                     xsd->hostclipboard_write_chunks = XMaxRequestSize(xsd->display) * 4 / 2;
 490
 491                     /* FIXME TODO: Use INCR protocol for large requests */
 492                     if (1)// && xsd->hostclipboard_writebuffer_size <= xsd->hostclipboard_write_chunks)
 493                     {
 494                         D(bug("X11CLIPBOARD: SelectionRequest Event - one chunk is enough\n"));
 495
 496                         //D(bug("[%s]\n", xsd->hostclipboard_writebuffer));
 497
 498                         XChangeProperty(xsd->display,
 499                                         xsd->hostclipboard_writerequest_window,
 500                                         xsd->hostclipboard_writerequest_property,
 501                                         XA_STRING,
 502                                         8,
 503                                         PropModeReplace,
 504                                         (unsigned char *)xsd->hostclipboard_writebuffer,
 505                                         (int)xsd->hostclipboard_writebuffer_size);
 506                     }
 507                     else
 508                     {
 509                         /* FIXME TODO: Use INCR protocol for large requests */
 510
 511                         e.xselection.property = None;
 512                     }
 513                     UNLOCK_X11
 514                 }
 515                 else
 516                 {
 517                     e.xselection.property = None;
 518                 }
 519
 520                 D(bug("X11CLIPBOARD: SelectionRequest Event - sending SelectionNotify event to clipboard requestor\n"));
 521
 522                 LOCK_X11
 523                 XSendEvent(xsd->display,
 524                            xsd->hostclipboard_writerequest_window,
 525                            False,
 526                            NoEventMask,
 527                            &e);
 528                 XFlush(xsd->display);
 529                 UNLOCK_X11
 530             }
 531             break;
 532
 533     } /* switch(event->type) */
 534
 535 }
 536
 537 /****************************************************************************************/
 538