git.oblomov.eu Git - wine/blob - windows/x11drv/clipboard.c

   1 /*
   2  * X11 clipboard windows driver
   3  *
   4  * Copyright 1994 Martin Ayotte
   5  *           1996 Alex Korobka
   6  *           1999 Noel Borthwick
   7  *
   8  * NOTES:
   9  *    This file contains the X specific implementation for the windows
  10  *    Clipboard API.
  11  *
  12  *    Wine's internal clipboard is exposed to external apps via the X
  13  *    selection mechanism.
  14  *    Currently the driver asserts ownership via two selection atoms:
  15  *    1. PRIMARY(XA_PRIMARY)
  16  *    2. CLIPBOARD
  17  *
  18  *    In our implementation, the CLIPBOARD selection takes precedence over PRIMARY,
  19  *    i.e. if a CLIPBOARD selection is available, it is used instead of PRIMARY.
  20  *    When Wine takes ownership of the clipboard, it takes ownership of BOTH selections.
  21  *    While giving up selection ownership, if the CLIPBOARD selection is lost,
  22  *    it will lose both PRIMARY and CLIPBOARD and empty the clipboard.
  23  *    However if only PRIMARY is lost, it will continue to hold the CLIPBOARD selection
  24  *    (leaving the clipboard cache content unaffected).
  25  *
  26  *      Every format exposed via a windows clipboard format is also exposed through
  27  *    a corresponding X selection target. A selection target atom is synthesized
  28  *    whenever a new Windows clipboard format is registered via RegisterClipboardFormat,
  29  *    or when a built-in format is used for the first time.
  30  *    Windows native format are exposed by prefixing the format name with "<WCF>"
  31  *    This allows us to uniquely identify windows native formats exposed by other
  32  *    running WINE apps.
  33  *
  34  *      In order to allow external applications to query WINE for supported formats,
  35  *    we respond to the "TARGETS" selection target. (See EVENT_SelectionRequest
  36  *    for implementation) We use the same mechanism to query external clients for
  37  *    availability of a particular format, by caching the list of available targets
  38  *    by using the clipboard cache's "delayed render" mechanism. If a selection client
  39  *    does not support the "TARGETS" selection target, we actually attempt to retrieve
  40  *    the format requested as a fallback mechanism.
  41  *
  42  *      Certain Windows native formats are automatically converted to X native formats
  43  *    and vice versa. If a native format is available in the selection, it takes
  44  *    precedence, in order to avoid unnecessary conversions.
  45  *
  46  */
  47
  48 #include "config.h"
  49
  50 #include <string.h>
  51 #include <stdio.h>
  52 #include <stdlib.h>
  53 #include <unistd.h>
  54 #include <fcntl.h>
  55
  56 #include "ts_xlib.h"
  57 #include "winreg.h"
  58 #include "clipboard.h"
  59 #include "win.h"
  60 #include "x11drv.h"
  61 #include "debugtools.h"
  62
  63 DEFAULT_DEBUG_CHANNEL(clipboard);
  64
  65 /* Selection masks */
  66
  67 #define S_NOSELECTION    0
  68 #define S_PRIMARY        1
  69 #define S_CLIPBOARD      2
  70
  71 /* X selection context info */
  72
  73 static char _CLIPBOARD[] = "CLIPBOARD";        /* CLIPBOARD atom name */
  74 static char FMT_PREFIX[] = "<WCF>";            /* Prefix for windows specific formats */
  75 static int selectionAcquired = 0;              /* Contains the current selection masks */
  76 static Window selectionWindow = None;          /* The top level X window which owns the selection */
  77 static Window selectionPrevWindow = None;      /* The last X window that owned the selection */
  78 static Window PrimarySelectionOwner = None;    /* The window which owns the primary selection */
  79 static Window ClipboardSelectionOwner = None;  /* The window which owns the clipboard selection */
  80 static unsigned long cSelectionTargets = 0;    /* Number of target formats reported by TARGETS selection */
  81 static Atom selectionCacheSrc = XA_PRIMARY;    /* The selection source from which the clipboard cache was filled */
  82 static HANDLE selectionClearEvent = 0;/* Synchronization object used to block until server is started */
  83
  84 typedef struct tagPROPERTY
  85 {
  86     struct tagPROPERTY *next;
  87     Atom                atom;
  88     Pixmap              pixmap;
  89 } PROPERTY;
  90
  91 static PROPERTY *prop_head;
  92
  93
  94 /**************************************************************************
  95  *              X11DRV_CLIPBOARD_MapPropertyToFormat
  96  *
  97  *  Map an X selection property type atom name to a windows clipboard format ID
  98  */
  99 UINT X11DRV_CLIPBOARD_MapPropertyToFormat(char *itemFmtName)
 100 {
 101     /*
 102      * If the property name starts with FMT_PREFIX strip this off and
 103      * get the ID for a custom Windows registered format with this name.
 104      * We can also understand STRING, PIXMAP and BITMAP.
 105      */
 106     if ( NULL == itemFmtName )
 107         return 0;
 108     else if ( 0 == strncmp(itemFmtName, FMT_PREFIX, strlen(FMT_PREFIX)) )
 109         return RegisterClipboardFormatA(itemFmtName + strlen(FMT_PREFIX));
 110     else if ( 0 == strcmp(itemFmtName, "STRING") )
 111         return CF_UNICODETEXT;
 112     else if ( 0 == strcmp(itemFmtName, "PIXMAP")
 113                 ||  0 == strcmp(itemFmtName, "BITMAP") )
 114     {
 115         /*
 116          * Return CF_DIB as first preference, if WINE is the selection owner
 117          * and if CF_DIB exists in the cache.
 118          * If wine dowsn't own the selection we always return CF_DIB
 119          */
 120         if ( !X11DRV_IsSelectionOwner() )
 121             return CF_DIB;
 122         else if ( CLIPBOARD_IsPresent(CF_DIB) )
 123             return CF_DIB;
 124         else
 125             return CF_BITMAP;
 126     }
 127
 128     WARN("\tNo mapping to Windows clipboard format for property %s\n", itemFmtName);
 129     return 0;
 130 }
 131
 132 /**************************************************************************
 133  *              X11DRV_CLIPBOARD_MapFormatToProperty
 134  *
 135  *  Map a windows clipboard format ID to an X selection property atom
 136  */
 137 Atom X11DRV_CLIPBOARD_MapFormatToProperty(UINT wFormat)
 138 {
 139     Atom prop = None;
 140
 141     switch (wFormat)
 142     {
 143         /* We support only CF_UNICODETEXT, other formats are synthesized */
 144         case CF_OEMTEXT:
 145         case CF_TEXT:
 146             return None;
 147
 148         case CF_UNICODETEXT:
 149             prop = XA_STRING;
 150             break;
 151
 152         case CF_DIB:
 153         case CF_BITMAP:
 154         {
 155             /*
 156              * Request a PIXMAP, only if WINE is NOT the selection owner,
 157              * AND the requested format is not in the cache.
 158              */
 159             if ( !X11DRV_IsSelectionOwner() && !CLIPBOARD_IsPresent(wFormat) )
 160             {
 161               prop = XA_PIXMAP;
 162               break;
 163             }
 164             /* Fall through to the default case in order to use the native format */
 165         }
 166
 167         default:
 168         {
 169             /*
 170              * If an X atom is registered for this format, return that
 171              * Otherwise register a new atom.
 172              */
 173             char str[256];
 174             char *fmtName = CLIPBOARD_GetFormatName(wFormat);
 175             strcpy(str, FMT_PREFIX);
 176
 177             if (fmtName)
 178             {
 179                 strncat(str, fmtName, sizeof(str) - strlen(FMT_PREFIX));
 180                 prop = TSXInternAtom(thread_display(), str, False);
 181             }
 182             break;
 183         }
 184     }
 185
 186     if (prop == None)
 187         TRACE("\tNo mapping to X property for Windows clipboard format %d(%s)\n",
 188               wFormat, CLIPBOARD_GetFormatName(wFormat));
 189
 190     return prop;
 191 }
 192
 193 /**************************************************************************
 194  *              X11DRV_CLIPBOARD_IsNativeProperty
 195  *
 196  *  Checks if a property is a native Wine property type
 197  */
 198 BOOL X11DRV_CLIPBOARD_IsNativeProperty(Atom prop)
 199 {
 200     char *itemFmtName = TSXGetAtomName(thread_display(), prop);
 201     BOOL bRet = FALSE;
 202
 203     if ( 0 == strncmp(itemFmtName, FMT_PREFIX, strlen(FMT_PREFIX)) )
 204         bRet = TRUE;
 205
 206     TSXFree(itemFmtName);
 207     return bRet;
 208 }
 209
 210
 211 /**************************************************************************
 212  *              X11DRV_CLIPBOARD_LaunchServer
 213  * Launches the clipboard server. This is called from X11DRV_CLIPBOARD_ResetOwner
 214  * when the selection can no longer be recyled to another top level window.
 215  * In order to make the selection persist after Wine shuts down a server
 216  * process is launched which services subsequent selection requests.
 217  */
 218 BOOL X11DRV_CLIPBOARD_LaunchServer()
 219 {
 220     int iWndsLocks;
 221     char clearSelection[8] = "0";
 222     int persistent_selection = 1;
 223     HKEY hkey;
 224
 225     /* If persistant selection has been disabled in the .winerc Clipboard section,
 226      * don't launch the server
 227      */
 228     if(!RegOpenKeyA(HKEY_LOCAL_MACHINE, "Software\\Wine\\Wine\\Config\\Clipboard", &hkey))
 229     {
 230         char buffer[20];
 231         DWORD type, count = sizeof(buffer);
 232         if(!RegQueryValueExA(hkey, "PersistentSelection", 0, &type, buffer, &count))
 233             persistent_selection = atoi(buffer);
 234
 235         /* Get the clear selection preference */
 236         count = sizeof(clearSelection);
 237         RegQueryValueExA(hkey, "ClearAllSelections", 0, &type, clearSelection, &count);
 238         RegCloseKey(hkey);
 239     }
 240     if ( !persistent_selection )
 241         return FALSE;
 242
 243     /*  Start up persistant WINE X clipboard server process which will
 244      *  take ownership of the X selection and continue to service selection
 245      *  requests from other apps.
 246      */
 247     selectionWindow = selectionPrevWindow;
 248     if ( !fork() )
 249     {
 250         /* NOTE: This code only executes in the context of the child process
 251          * Do note make any Wine specific calls here.
 252          */
 253         int dbgClasses = 0;
 254         char selMask[8], dbgClassMask[8];
 255
 256         sprintf(selMask, "%d", selectionAcquired);
 257
 258         /* Build the debug class mask to pass to the server, by inheriting
 259          * the settings for the clipboard debug channel.
 260          */
 261         dbgClasses |= FIXME_ON(clipboard) ? 1 : 0;
 262         dbgClasses |= ERR_ON(clipboard) ? 2 : 0;
 263         dbgClasses |= WARN_ON(clipboard) ? 4 : 0;
 264         dbgClasses |= TRACE_ON(clipboard) ? 8 : 0;
 265         sprintf(dbgClassMask, "%d", dbgClasses);
 266
 267         /* Exec the clipboard server passing it the selection and debug class masks */
 268         execl( BINDIR "/wineclipsrv", "wineclipsrv",
 269                selMask, dbgClassMask, clearSelection, NULL );
 270         execlp( "wineclipsrv", "wineclipsrv", selMask, dbgClassMask, clearSelection, NULL );
 271         execl( "./windows/x11drv/wineclipsrv", "wineclipsrv",
 272                selMask, dbgClassMask, clearSelection, NULL );
 273
 274         /* Exec Failed! */
 275         perror("Could not start Wine clipboard server");
 276         exit( 1 ); /* Exit the child process */
 277     }
 278
 279     /* Wait until the clipboard server acquires the selection.
 280      * We must release the windows lock to enable Wine to process
 281      * selection messages in response to the servers requests.
 282      */
 283
 284     iWndsLocks = WIN_SuspendWndsLock();
 285
 286     /* We must wait until the server finishes acquiring the selection,
 287      * before proceeding, otherwise the window which owns the selection
 288      * will be destroyed prematurely!
 289      * Create a non-signalled, auto-reset event which will be set by
 290      * X11DRV_CLIPBOARD_ReleaseSelection, and wait until this gets
 291      * signalled before proceeding.
 292      */
 293
 294     if ( !(selectionClearEvent = CreateEventA(NULL, FALSE, FALSE, NULL)) )
 295         ERR("Could not create wait object. Clipboard server won't start!\n");
 296     else
 297     {
 298         /* Wait until we lose the selection, timing out after a minute */
 299         DWORD start_time, timeout, elapsed, ret;
 300
 301         TRACE("Waiting for clipboard server to acquire selection\n");
 302
 303         timeout = 60000;
 304         start_time = GetTickCount();
 305         elapsed=0;
 306         do
 307         {
 308             ret = MsgWaitForMultipleObjects( 1, &selectionClearEvent, FALSE, timeout - elapsed, QS_ALLINPUT );
 309             if (ret != WAIT_OBJECT_0+1)
 310                 break;
 311             elapsed = GetTickCount() - start_time;
 312             if (elapsed > timeout)
 313                 break;
 314         }
 315         while (1);
 316         if ( ret != WAIT_OBJECT_0 )
 317             TRACE("Server could not acquire selection, or a timeout occurred!\n");
 318         else
 319             TRACE("Server successfully acquired selection\n");
 320
 321         /* Release the event */
 322         CloseHandle(selectionClearEvent);
 323         selectionClearEvent = 0;
 324     }
 325
 326     WIN_RestoreWndsLock(iWndsLocks);
 327
 328     return TRUE;
 329 }
 330
 331
 332 /**************************************************************************
 333  *              X11DRV_CLIPBOARD_CacheDataFormats
 334  *
 335  * Caches the list of data formats available from the current selection.
 336  * This queries the selection owner for the TARGETS property and saves all
 337  * reported property types.
 338  */
 339 int X11DRV_CLIPBOARD_CacheDataFormats( Atom SelectionName )
 340 {
 341     Display *display = thread_display();
 342     HWND           hWnd = 0;
 343     HWND           hWndClipWindow = GetOpenClipboardWindow();
 344     XEvent         xe;
 345     Atom           aTargets;
 346     Atom           atype=AnyPropertyType;
 347     int            aformat;
 348     unsigned long  remain;
 349     Atom*          targetList=NULL;
 350     Window         w;
 351     Window         ownerSelection = 0;
 352
 353     TRACE("enter\n");
 354     /*
 355      * Empty the clipboard cache
 356      */
 357     CLIPBOARD_EmptyCache(TRUE);
 358
 359     cSelectionTargets = 0;
 360     selectionCacheSrc = SelectionName;
 361
 362     hWnd = (hWndClipWindow) ? hWndClipWindow : GetActiveWindow();
 363
 364     ownerSelection = TSXGetSelectionOwner(display, SelectionName);
 365     if ( !hWnd || (ownerSelection == None) )
 366         return cSelectionTargets;
 367
 368     /*
 369      * Query the selection owner for the TARGETS property
 370      */
 371     w = X11DRV_get_whole_window( GetAncestor(hWnd,GA_ROOT) );
 372
 373     aTargets = TSXInternAtom(display, "TARGETS", False);
 374
 375     TRACE("Requesting TARGETS selection for '%s' (owner=%08x)...\n",
 376           TSXGetAtomName(display, selectionCacheSrc), (unsigned)ownerSelection );
 377     wine_tsx11_lock();
 378     XConvertSelection(display, selectionCacheSrc, aTargets,
 379                     TSXInternAtom(display, "SELECTION_DATA", False),
 380                     w, CurrentTime);
 381
 382     /*
 383      * Wait until SelectionNotify is received
 384      */
 385     while( TRUE )
 386     {
 387        if( XCheckTypedWindowEvent(display, w, SelectionNotify, &xe) )
 388            if( xe.xselection.selection == selectionCacheSrc )
 389                break;
 390     }
 391     wine_tsx11_unlock();
 392
 393     /* Verify that the selection returned a valid TARGETS property */
 394     if ( (xe.xselection.target != aTargets)
 395           || (xe.xselection.property == None) )
 396     {
 397         TRACE("\tExit, could not retrieve TARGETS\n");
 398         return cSelectionTargets;
 399     }
 400
 401     /* Read the TARGETS property contents */
 402     if(TSXGetWindowProperty(display, xe.xselection.requestor, xe.xselection.property,
 403                             0, 0x3FFF, True, AnyPropertyType/*XA_ATOM*/, &atype, &aformat,
 404                             &cSelectionTargets, &remain, (unsigned char**)&targetList) != Success)
 405         TRACE("\tCouldn't read TARGETS property\n");
 406     else
 407     {
 408        TRACE("\tType %s,Format %d,nItems %ld, Remain %ld\n",
 409              TSXGetAtomName(display,atype),aformat,cSelectionTargets, remain);
 410        /*
 411         * The TARGETS property should have returned us a list of atoms
 412         * corresponding to each selection target format supported.
 413         */
 414        if( (atype == XA_ATOM || atype == aTargets) && aformat == 32 )
 415        {
 416           int i;
 417           LPWINE_CLIPFORMAT lpFormat;
 418
 419           /* Cache these formats in the clipboard cache */
 420
 421           for (i = 0; i < cSelectionTargets; i++)
 422           {
 423               char *itemFmtName = TSXGetAtomName(display, targetList[i]);
 424               UINT wFormat = X11DRV_CLIPBOARD_MapPropertyToFormat(itemFmtName);
 425
 426               /*
 427                * If the clipboard format maps to a Windows format, simply store
 428                * the atom identifier and record its availablity status
 429                * in the clipboard cache.
 430                */
 431               if (wFormat)
 432               {
 433                   lpFormat = CLIPBOARD_LookupFormat( wFormat );
 434
 435                   /* Don't replace if the property already cached is a native format,
 436                    * or if a PIXMAP is being replaced by a BITMAP.
 437                    */
 438                   if (lpFormat->wDataPresent &&
 439                         ( X11DRV_CLIPBOARD_IsNativeProperty(lpFormat->drvData)
 440                           || (lpFormat->drvData == XA_PIXMAP && targetList[i] == XA_BITMAP) )
 441                      )
 442                   {
 443                       TRACE("\tAtom# %d: '%s' --> FormatID(%d) %s (Skipped)\n",
 444                             i, itemFmtName, wFormat, lpFormat->Name);
 445                   }
 446                   else
 447                   {
 448                       lpFormat->wDataPresent = 1;
 449                       lpFormat->drvData = targetList[i];
 450                       TRACE("\tAtom# %d: '%s' --> FormatID(%d) %s\n",
 451                             i, itemFmtName, wFormat, lpFormat->Name);
 452                   }
 453               }
 454
 455               TSXFree(itemFmtName);
 456           }
 457        }
 458
 459        /* Free the list of targets */
 460        TSXFree(targetList);
 461     }
 462
 463     return cSelectionTargets;
 464 }
 465
 466 /**************************************************************************
 467  *              X11DRV_CLIPBOARD_ReadSelection
 468  *  Reads the contents of the X selection property into the WINE clipboard cache
 469  *  converting the selection into a format compatible with the windows clipboard
 470  *  if possible.
 471  *  This method is invoked only to read the contents of a the selection owned
 472  *  by an external application. i.e. when we do not own the X selection.
 473  */
 474 static BOOL X11DRV_CLIPBOARD_ReadSelection(UINT wFormat, Window w, Atom prop, Atom reqType)
 475 {
 476     Display *display = thread_display();
 477     Atom              atype=AnyPropertyType;
 478     int               aformat;
 479     unsigned long     total,nitems,remain,itemSize,val_cnt;
 480     long              lRequestLength,bwc;
 481     unsigned char*    val;
 482     unsigned char*    buffer;
 483     LPWINE_CLIPFORMAT lpFormat;
 484     BOOL              bRet = FALSE;
 485     HWND              hWndClipWindow = GetOpenClipboardWindow();
 486
 487
 488     if(prop == None)
 489         return bRet;
 490
 491     TRACE("Reading X selection...\n");
 492
 493     TRACE("\tretrieving property %s from window %ld into %s\n",
 494           TSXGetAtomName(display,reqType), (long)w, TSXGetAtomName(display,prop) );
 495
 496     /*
 497      * First request a zero length in order to figure out the request size.
 498      */
 499     if(TSXGetWindowProperty(display,w,prop,0,0,False, AnyPropertyType/*reqType*/,
 500                             &atype, &aformat, &nitems, &itemSize, &val) != Success)
 501     {
 502         WARN("\tcouldn't get property size\n");
 503         return bRet;
 504     }
 505
 506     /* Free zero length return data if any */
 507     if ( val )
 508     {
 509        TSXFree(val);
 510        val = NULL;
 511     }
 512
 513     TRACE("\tretrieving %ld bytes...\n", itemSize * aformat/8);
 514     lRequestLength = (itemSize * aformat/8)/4  + 1;
 515
 516    bwc = aformat/8;
 517    /* we want to read the property, but not it too large of chunks or
 518       we could hang the cause problems. Lets go for 4k blocks */
 519
 520     if(TSXGetWindowProperty(display,w,prop,0,4096,False,
 521                             AnyPropertyType/*reqType*/,
 522                             &atype, &aformat, &nitems, &remain, &buffer)
 523         != Success)
 524     {
 525         WARN("\tcouldn't read property\n");
 526         return bRet;
 527     }
 528    val = (char*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,
 529                           nitems*bwc);
 530    memcpy(val,buffer,nitems*bwc);
 531    TSXFree(buffer);
 532
 533    for (total = nitems*bwc,val_cnt=0; remain;)
 534    {
 535        val_cnt +=nitems*bwc;
 536        TSXGetWindowProperty(display, w, prop,
 537                           (total / 4), 4096, False,
 538                           AnyPropertyType, &atype,
 539                           &aformat, &nitems, &remain,
 540                           &buffer);
 541
 542        total += nitems*bwc;
 543        HeapReAlloc(GetProcessHeap(),0,val, total);
 544        memcpy(&val[val_cnt], buffer, nitems*(aformat/8));
 545        TSXFree(buffer);
 546    }
 547    nitems = total;
 548
 549     /*
 550      * Translate the X property into the appropriate Windows clipboard
 551      * format, if possible.
 552      */
 553     if ( (reqType == XA_STRING)
 554          && (atype == XA_STRING) && (aformat == 8) )
 555     /* convert Unix text to CF_UNICODETEXT */
 556     {
 557       int          i,inlcount = 0;
 558       char*      lpstr;
 559
 560       for(i=0; i <= nitems; i++)
 561           if( val[i] == '\n' ) inlcount++;
 562
 563       if( (lpstr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, nitems + inlcount + 1)) )
 564       {
 565           static UINT text_cp = (UINT)-1;
 566           UINT count;
 567           HANDLE hUnicodeText;
 568
 569           for(i=0,inlcount=0; i <= nitems; i++)
 570           {
 571              if( val[i] == '\n' ) lpstr[inlcount++]='\r';
 572              lpstr[inlcount++]=val[i];
 573           }
 574
 575           if(text_cp == (UINT)-1)
 576           {
 577               HKEY hkey;
 578               /* default value */
 579               text_cp = CP_ACP;
 580               if(!RegOpenKeyA(HKEY_LOCAL_MACHINE, "Software\\Wine\\Wine\\Config\\x11drv", &hkey))
 581               {
 582                   char buf[20];
 583                   DWORD type, count = sizeof(buf);
 584                   if(!RegQueryValueExA(hkey, "TextCP", 0, &type, buf, &count))
 585                       text_cp = atoi(buf);
 586                   RegCloseKey(hkey);
 587               }
 588           }
 589
 590           count = MultiByteToWideChar(text_cp, 0, lpstr, -1, NULL, 0);
 591           hUnicodeText = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, count * sizeof(WCHAR));
 592           if(hUnicodeText)
 593           {
 594               WCHAR *textW = GlobalLock(hUnicodeText);
 595               MultiByteToWideChar(text_cp, 0, lpstr, -1, textW, count);
 596               GlobalUnlock(hUnicodeText);
 597               if (!SetClipboardData(CF_UNICODETEXT, hUnicodeText))
 598               {
 599             ERR("Not SET! Need to free our own block\n");
 600                     GlobalFree(hUnicodeText);
 601           }
 602               bRet = TRUE;
 603           }
 604           HeapFree(GetProcessHeap(), 0, lpstr);
 605       }
 606     }
 607     else if ( reqType == XA_PIXMAP || reqType == XA_BITMAP ) /* treat PIXMAP as CF_DIB or CF_BITMAP */
 608     {
 609       /* Get the first pixmap handle passed to us */
 610       Pixmap *pPixmap = (Pixmap *)val;
 611       HANDLE hTargetImage = 0;  /* Handle to store the converted bitmap or DIB */
 612
 613       if (aformat != 32 || nitems < 1 || atype != XA_PIXMAP
 614           || (wFormat != CF_BITMAP && wFormat != CF_DIB))
 615       {
 616           WARN("\tUnimplemented format conversion request\n");
 617           goto END;
 618       }
 619
 620       if ( wFormat == CF_BITMAP )
 621       {
 622         /* For CF_BITMAP requests we must return an HBITMAP */
 623         hTargetImage = X11DRV_BITMAP_CreateBitmapFromPixmap(*pPixmap, TRUE);
 624       }
 625       else if (wFormat == CF_DIB)
 626       {
 627         HWND hwnd = GetOpenClipboardWindow();
 628         HDC hdc = GetDC(hwnd);
 629
 630         /* For CF_DIB requests we must return an HGLOBAL storing a packed DIB */
 631         hTargetImage = X11DRV_DIB_CreateDIBFromPixmap(*pPixmap, hdc, TRUE);
 632
 633         ReleaseDC(hwnd, hdc);
 634       }
 635
 636       if (!hTargetImage)
 637       {
 638           WARN("PIXMAP conversion failed!\n" );
 639           goto END;
 640       }
 641
 642       /* Delete previous clipboard data */
 643       lpFormat = CLIPBOARD_LookupFormat(wFormat);
 644       if (lpFormat->wDataPresent && (lpFormat->hData16 || lpFormat->hData32))
 645           CLIPBOARD_DeleteRecord(lpFormat, !(hWndClipWindow));
 646
 647       /* Update the clipboard record */
 648       lpFormat->wDataPresent = 1;
 649       lpFormat->hData32 = hTargetImage;
 650       lpFormat->hData16 = 0;
 651
 652       bRet = TRUE;
 653     }
 654
 655     /* For native properties simply copy the X data without conversion */
 656     else if (X11DRV_CLIPBOARD_IsNativeProperty(reqType)) /* <WCF>* */
 657     {
 658       HANDLE hClipData = 0;
 659       void*  lpClipData;
 660       int cBytes = nitems * aformat/8;
 661
 662       if( cBytes )
 663       {
 664         /* Turn on the DDESHARE flag to enable shared 32 bit memory */
 665         hClipData = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, cBytes );
 666         if( (lpClipData = GlobalLock(hClipData)) )
 667         {
 668             memcpy(lpClipData, val, cBytes);
 669             GlobalUnlock(hClipData);
 670         }
 671         else
 672             hClipData = 0;
 673       }
 674
 675       if( hClipData )
 676       {
 677           /* delete previous clipboard record if any */
 678           lpFormat = CLIPBOARD_LookupFormat(wFormat);
 679           if (lpFormat->wDataPresent || lpFormat->hData16 || lpFormat->hData32)
 680               CLIPBOARD_DeleteRecord(lpFormat, !(hWndClipWindow));
 681
 682           /* Update the clipboard record */
 683           lpFormat->wDataPresent = 1;
 684           lpFormat->hData32 = hClipData;
 685           lpFormat->hData16 = 0;
 686
 687           bRet = TRUE;
 688       }
 689     }
 690     else
 691     {
 692         WARN("\tUnimplemented format conversion request\n");
 693         goto END;
 694     }
 695
 696 END:
 697     /* Delete the property on the window now that we are done
 698      * This will send a PropertyNotify event to the selection owner. */
 699     TSXDeleteProperty(display,w,prop);
 700
 701     /* Free the retrieved property data */
 702     HeapFree(GetProcessHeap(),0,val);
 703     return bRet;
 704 }
 705
 706 /**************************************************************************
 707  *              X11DRV_CLIPBOARD_ReleaseSelection
 708  *
 709  * Release an XA_PRIMARY or XA_CLIPBOARD selection that we own, in response
 710  * to a SelectionClear event.
 711  * This can occur in response to another client grabbing the X selection.
 712  * If the XA_CLIPBOARD selection is lost, we relinquish XA_PRIMARY as well.
 713  */
 714 void X11DRV_CLIPBOARD_ReleaseSelection(Atom selType, Window w, HWND hwnd)
 715 {
 716     Display *display = thread_display();
 717     Atom xaClipboard = TSXInternAtom(display, "CLIPBOARD", False);
 718     int clearAllSelections = 0;
 719     HKEY hkey;
 720
 721     if(!RegOpenKeyA(HKEY_LOCAL_MACHINE, "Software\\Wine\\Wine\\Config\\Clipboard", &hkey))
 722     {
 723         char buffer[20];
 724         DWORD type, count = sizeof(buffer);
 725         if(!RegQueryValueExA(hkey, "ClearAllSelections", 0, &type, buffer, &count))
 726             clearAllSelections = atoi(buffer);
 727         RegCloseKey(hkey);
 728     }
 729
 730     /* w is the window that lost the selection
 731      * selectionPrevWindow is nonzero if CheckSelection() was called.
 732      */
 733
 734     TRACE("\tevent->window = %08x (sw = %08x, spw=%08x)\n",
 735           (unsigned)w, (unsigned)selectionWindow, (unsigned)selectionPrevWindow );
 736
 737     if( selectionAcquired )
 738     {
 739         if( w == selectionWindow || selectionPrevWindow == None)
 740         {
 741             /* If we're losing the CLIPBOARD selection, or if the preferences in .winerc
 742              * dictate that *all* selections should be cleared on loss of a selection,
 743              * we must give up all the selections we own.
 744              */
 745             if ( clearAllSelections || (selType == xaClipboard) )
 746             {
 747               /* completely give up the selection */
 748               TRACE("Lost CLIPBOARD (+PRIMARY) selection\n");
 749
 750               /* We are completely giving up the selection.
 751                * Make sure we can open the windows clipboard first. */
 752
 753               if ( !OpenClipboard(hwnd) )
 754               {
 755                   /*
 756                    * We can't empty the clipboard if we cant open it so abandon.
 757                    * Wine will think that it still owns the selection but this is
 758                    * safer than losing the selection without properly emptying
 759                    * the clipboard. Perhaps we should forcibly re-assert ownership
 760                    * of the CLIPBOARD selection in this case...
 761                    */
 762                   ERR("\tClipboard is busy. Could not give up selection!\n");
 763                   return;
 764               }
 765
 766               /* We really lost CLIPBOARD but want to voluntarily lose PRIMARY */
 767               if ( (selType == xaClipboard)
 768                    && (selectionAcquired & S_PRIMARY) )
 769               {
 770                   XSetSelectionOwner(display, XA_PRIMARY, None, CurrentTime);
 771               }
 772
 773               /* We really lost PRIMARY but want to voluntarily lose CLIPBOARD  */
 774               if ( (selType == XA_PRIMARY)
 775                    && (selectionAcquired & S_CLIPBOARD) )
 776               {
 777                   XSetSelectionOwner(display, xaClipboard, None, CurrentTime);
 778               }
 779
 780               selectionWindow = None;
 781               PrimarySelectionOwner = ClipboardSelectionOwner = 0;
 782
 783               /* Empty the windows clipboard.
 784                * We should pretend that we still own the selection BEFORE calling
 785                * EmptyClipboard() since otherwise this has the side effect of
 786                * triggering X11DRV_CLIPBOARD_Acquire() and causing the X selection
 787                * to be re-acquired by us!
 788                */
 789               selectionAcquired = (S_PRIMARY | S_CLIPBOARD);
 790               EmptyClipboard();
 791               CloseClipboard();
 792
 793               /* Give up ownership of the windows clipboard */
 794               CLIPBOARD_ReleaseOwner();
 795
 796               /* Reset the selection flags now that we are done */
 797               selectionAcquired = S_NOSELECTION;
 798             }
 799             else if ( selType == XA_PRIMARY ) /* Give up only PRIMARY selection */
 800             {
 801                 TRACE("Lost PRIMARY selection\n");
 802                 PrimarySelectionOwner = 0;
 803                 selectionAcquired &= ~S_PRIMARY;  /* clear S_PRIMARY mask */
 804             }
 805
 806             cSelectionTargets = 0;
 807         }
 808         /* but we'll keep existing data for internal use */
 809         else if( w == selectionPrevWindow )
 810         {
 811             Atom xaClipboard = TSXInternAtom(display, _CLIPBOARD, False);
 812
 813             w = TSXGetSelectionOwner(display, XA_PRIMARY);
 814             if( w == None )
 815                 TSXSetSelectionOwner(display, XA_PRIMARY, selectionWindow, CurrentTime);
 816
 817             w = TSXGetSelectionOwner(display, xaClipboard);
 818             if( w == None )
 819                 TSXSetSelectionOwner(display, xaClipboard, selectionWindow, CurrentTime);
 820         }
 821     }
 822
 823     /* Signal to a selectionClearEvent listener if the selection is completely lost */
 824     if (selectionClearEvent && !selectionAcquired)
 825     {
 826         TRACE("Lost all selections, signalling to selectionClearEvent listener\n");
 827         SetEvent(selectionClearEvent);
 828     }
 829
 830     selectionPrevWindow = None;
 831 }
 832
 833 /**************************************************************************
 834  *              ReleaseClipboard (X11DRV.@)
 835  *  Voluntarily release all currently owned X selections
 836  */
 837 void X11DRV_ReleaseClipboard(void)
 838 {
 839     Display *display = thread_display();
 840     if( selectionAcquired )
 841     {
 842         XEvent xe;
 843         Window savePrevWindow = selectionWindow;
 844         Atom xaClipboard = TSXInternAtom(display, _CLIPBOARD, False);
 845         BOOL bHasPrimarySelection = selectionAcquired & S_PRIMARY;
 846
 847         selectionAcquired   = S_NOSELECTION;
 848         selectionPrevWindow = selectionWindow;
 849         selectionWindow     = None;
 850
 851         TRACE("\tgiving up selection (spw = %08x)\n",
 852              (unsigned)selectionPrevWindow);
 853
 854         wine_tsx11_lock();
 855
 856         TRACE("Releasing CLIPBOARD selection\n");
 857         XSetSelectionOwner(display, xaClipboard, None, CurrentTime);
 858         if( selectionPrevWindow )
 859             while( !XCheckTypedWindowEvent( display, selectionPrevWindow,
 860                                             SelectionClear, &xe ) );
 861
 862         if ( bHasPrimarySelection )
 863         {
 864             TRACE("Releasing XA_PRIMARY selection\n");
 865             selectionPrevWindow = savePrevWindow; /* May be cleared in X11DRV_CLIPBOARD_ReleaseSelection */
 866             XSetSelectionOwner(display, XA_PRIMARY, None, CurrentTime);
 867
 868             if( selectionPrevWindow )
 869                 while( !XCheckTypedWindowEvent( display, selectionPrevWindow,
 870                                                 SelectionClear, &xe ) );
 871         }
 872         wine_tsx11_unlock();
 873     }
 874
 875     /* Get rid of any Pixmap resources we may still have */
 876     while (prop_head)
 877     {
 878         PROPERTY *prop = prop_head;
 879         prop_head = prop->next;
 880         XFreePixmap( gdi_display, prop->pixmap );
 881         HeapFree( GetProcessHeap(), 0, prop );
 882     }
 883 }
 884
 885 /**************************************************************************
 886  *              AcquireClipboard (X11DRV.@)
 887  */
 888 void X11DRV_AcquireClipboard(void)
 889 {
 890     Display *display = thread_display();
 891     Window       owner;
 892     HWND         hWndClipWindow = GetOpenClipboardWindow();
 893
 894     /*
 895      * Acquire X selection if we don't already own it.
 896      * Note that we only acquire the selection if it hasn't been already
 897      * acquired by us, and ignore the fact that another X window may be
 898      * asserting ownership. The reason for this is we need *any* top level
 899      * X window to hold selection ownership. The actual clipboard data requests
 900      * are made via GetClipboardData from EVENT_SelectionRequest and this
 901      * ensures that the real HWND owner services the request.
 902      * If the owning X window gets destroyed the selection ownership is
 903      * re-cycled to another top level X window in X11DRV_CLIPBOARD_ResetOwner.
 904      *
 905      */
 906
 907     if ( !(selectionAcquired == (S_PRIMARY | S_CLIPBOARD)) )
 908     {
 909         Atom xaClipboard = TSXInternAtom(display, _CLIPBOARD, False);
 910         owner = X11DRV_get_whole_window( GetAncestor( hWndClipWindow ? hWndClipWindow : AnyPopup(),
 911                                                       GA_ROOT ) );
 912
 913         /* Grab PRIMARY selection if not owned */
 914         if ( !(selectionAcquired & S_PRIMARY) )
 915             TSXSetSelectionOwner(display, XA_PRIMARY, owner, CurrentTime);
 916
 917         /* Grab CLIPBOARD selection if not owned */
 918         if ( !(selectionAcquired & S_CLIPBOARD) )
 919             TSXSetSelectionOwner(display, xaClipboard, owner, CurrentTime);
 920
 921         if( TSXGetSelectionOwner(display,XA_PRIMARY) == owner )
 922             selectionAcquired |= S_PRIMARY;
 923
 924         if( TSXGetSelectionOwner(display,xaClipboard) == owner)
 925             selectionAcquired |= S_CLIPBOARD;
 926
 927         if (selectionAcquired)
 928         {
 929             selectionWindow = owner;
 930             TRACE("Grabbed X selection, owner=(%08x)\n", (unsigned) owner);
 931         }
 932     }
 933 }
 934
 935 /**************************************************************************
 936  *              IsClipboardFormatAvailable (X11DRV.@)
 937  *
 938  * Checks if the specified format is available in the current selection
 939  * Only invoked when WINE is not the selection owner
 940  */
 941 BOOL X11DRV_IsClipboardFormatAvailable(UINT wFormat)
 942 {
 943     Display *display = thread_display();
 944     Atom xaClipboard = TSXInternAtom(display, _CLIPBOARD, False);
 945     Window ownerPrimary = TSXGetSelectionOwner(display,XA_PRIMARY);
 946     Window ownerClipboard = TSXGetSelectionOwner(display,xaClipboard);
 947
 948     TRACE("enter for %d\n", wFormat);
 949
 950     /*
 951      * If the selection has not been previously cached, or the selection has changed,
 952      * try and cache the list of available selection targets from the current selection.
 953      */
 954     if ( !cSelectionTargets || (PrimarySelectionOwner != ownerPrimary)
 955                          || (ClipboardSelectionOwner != ownerClipboard) )
 956     {
 957         /*
 958          * First try caching the CLIPBOARD selection.
 959          * If unavailable try PRIMARY.
 960          */
 961         if ( X11DRV_CLIPBOARD_CacheDataFormats(xaClipboard) == 0 )
 962         {
 963             X11DRV_CLIPBOARD_CacheDataFormats(XA_PRIMARY);
 964         }
 965
 966         ClipboardSelectionOwner = ownerClipboard;
 967         PrimarySelectionOwner = ownerPrimary;
 968     }
 969
 970     /* Exit if there is no selection */
 971     if ( !ownerClipboard && !ownerPrimary )
 972     {
 973         TRACE("There is no selection owner\n");
 974         return FALSE;
 975     }
 976
 977     /* Check if the format is available in the clipboard cache */
 978     if ( CLIPBOARD_IsPresent(wFormat) )
 979         return TRUE;
 980
 981     /*
 982      * Many X client apps (such as XTerminal) don't support being queried
 983      * for the "TARGETS" target atom. To handle such clients we must actually
 984      * try to convert the selection to the requested type.
 985      */
 986     if ( !cSelectionTargets )
 987         return X11DRV_GetClipboardData( wFormat );
 988
 989     TRACE("There is no selection\n");
 990     return FALSE;
 991 }
 992
 993 /**************************************************************************
 994  *              RegisterClipboardFormat (X11DRV.@)
 995  *
 996  * Registers a custom X clipboard format
 997  * Returns: TRUE - success,  FALSE - failure
 998  */
 999 BOOL X11DRV_RegisterClipboardFormat( LPCSTR FormatName )
1000 {
1001     Display *display = thread_display();
1002     Atom prop = None;
1003     char str[256];
1004
1005     /*
1006      * If an X atom is registered for this format, return that
1007      * Otherwise register a new atom.
1008      */
1009     if (FormatName)
1010     {
1011         /* Add a WINE specific prefix to the format */
1012         strcpy(str, FMT_PREFIX);
1013         strncat(str, FormatName, sizeof(str) - strlen(FMT_PREFIX));
1014         prop = TSXInternAtom(display, str, False);
1015     }
1016
1017     return (prop) ? TRUE : FALSE;
1018 }
1019
1020 /**************************************************************************
1021  *              IsSelectionOwner (X11DRV.@)
1022  *
1023  * Returns: TRUE - We(WINE) own the selection, FALSE - Selection not owned by us
1024  */
1025 BOOL X11DRV_IsSelectionOwner(void)
1026 {
1027     return selectionAcquired;
1028 }
1029
1030 /**************************************************************************
1031  *              SetClipboardData (X11DRV.@)
1032  *
1033  * We don't need to do anything special here since the clipboard code
1034  * maintains the cache.
1035  *
1036  */
1037 void X11DRV_SetClipboardData(UINT wFormat)
1038 {
1039     /* Make sure we have acquired the X selection */
1040     X11DRV_AcquireClipboard();
1041 }
1042
1043 /**************************************************************************
1044  *              GetClipboardData (X11DRV.@)
1045  *
1046  * This method is invoked only when we DO NOT own the X selection
1047  *
1048  * NOTE: Clipboard driver get requests only for CF_UNICODETEXT data.
1049  * We always get the data from the selection client each time,
1050  * since we have no way of determining if the data in our cache is stale.
1051  */
1052 BOOL X11DRV_GetClipboardData(UINT wFormat)
1053 {
1054     Display *display = thread_display();
1055     BOOL bRet = selectionAcquired;
1056     HWND hWndClipWindow = GetOpenClipboardWindow();
1057     HWND hWnd = (hWndClipWindow) ? hWndClipWindow : GetActiveWindow();
1058     LPWINE_CLIPFORMAT lpFormat;
1059
1060     TRACE("%d\n", wFormat);
1061
1062     if (!selectionAcquired)
1063     {
1064         XEvent xe;
1065         Atom propRequest;
1066         Window w = X11DRV_get_whole_window( GetAncestor( hWnd, GA_ROOT ));
1067         if(!w)
1068         {
1069             FIXME("No parent win found %x %x\n", hWnd, hWndClipWindow);
1070             return FALSE;
1071         }
1072
1073         /* Map the format ID requested to an X selection property.
1074          * If the format is in the cache, use the atom associated
1075          * with it.
1076          */
1077
1078         lpFormat = CLIPBOARD_LookupFormat( wFormat );
1079         if (lpFormat && lpFormat->wDataPresent && lpFormat->drvData)
1080             propRequest = (Atom)lpFormat->drvData;
1081         else
1082             propRequest = X11DRV_CLIPBOARD_MapFormatToProperty(wFormat);
1083
1084         if (propRequest)
1085         {
1086             TRACE("Requesting %s selection from %s...\n",
1087                   TSXGetAtomName(display, propRequest),
1088                   TSXGetAtomName(display, selectionCacheSrc) );
1089             wine_tsx11_lock();
1090             XConvertSelection(display, selectionCacheSrc, propRequest,
1091                             TSXInternAtom(display, "SELECTION_DATA", False),
1092                             w, CurrentTime);
1093
1094             /* wait until SelectionNotify is received */
1095
1096             while( TRUE )
1097             {
1098                if( XCheckTypedWindowEvent(display, w, SelectionNotify, &xe) )
1099                    if( xe.xselection.selection == selectionCacheSrc )
1100                        break;
1101             }
1102             wine_tsx11_unlock();
1103
1104             /*
1105              *  Read the contents of the X selection property into WINE's
1106              *  clipboard cache converting the selection to be compatible if possible.
1107              */
1108             bRet = X11DRV_CLIPBOARD_ReadSelection( wFormat,
1109                                                    xe.xselection.requestor,
1110                                                    xe.xselection.property,
1111                                                    xe.xselection.target);
1112         }
1113         else
1114             bRet = FALSE;
1115
1116         TRACE("\tpresent %s = %i\n", CLIPBOARD_GetFormatName(wFormat), bRet );
1117     }
1118
1119     TRACE("Returning %d\n", bRet);
1120
1121     return bRet;
1122 }
1123
1124 /**************************************************************************
1125  *              ResetSelectionOwner (X11DRV.@)
1126  *
1127  * Called from DestroyWindow() to prevent X selection from being lost when
1128  * a top level window is destroyed, by switching ownership to another top
1129  * level window.
1130  * Any top level window can own the selection. See X11DRV_CLIPBOARD_Acquire
1131  * for a more detailed description of this.
1132  */
1133 void X11DRV_ResetSelectionOwner(HWND hwnd, BOOL bFooBar)
1134 {
1135     Display *display = thread_display();
1136     HWND hWndClipOwner = 0;
1137     HWND tmp;
1138     Window XWnd = X11DRV_get_whole_window(hwnd);
1139     Atom xaClipboard;
1140     BOOL bLostSelection = FALSE;
1141
1142     /* There is nothing to do if we don't own the selection,
1143      * or if the X window which currently owns the selecion is different
1144      * from the one passed in.
1145      */
1146     if ( !selectionAcquired || XWnd != selectionWindow
1147          || selectionWindow == None )
1148        return;
1149
1150     if ( (bFooBar && XWnd) || (!bFooBar && !XWnd) )
1151        return;
1152
1153     hWndClipOwner = GetClipboardOwner();
1154     xaClipboard = TSXInternAtom(display, _CLIPBOARD, False);
1155
1156     TRACE("clipboard owner = %04x, selection window = %08x\n",
1157           hWndClipOwner, (unsigned)selectionWindow);
1158
1159     /* now try to salvage current selection from being destroyed by X */
1160
1161     TRACE("\tchecking %08x\n", (unsigned) XWnd);
1162
1163     selectionPrevWindow = selectionWindow;
1164     selectionWindow = None;
1165
1166     if (!(tmp = GetWindow( hwnd, GW_HWNDNEXT ))) tmp = GetWindow( hwnd, GW_HWNDFIRST );
1167     if (tmp && tmp != hwnd) selectionWindow = X11DRV_get_whole_window(tmp);
1168
1169     if( selectionWindow != None )
1170     {
1171         /* We must pretend that we don't own the selection while making the switch
1172          * since a SelectionClear event will be sent to the last owner.
1173          * If there is no owner X11DRV_CLIPBOARD_ReleaseSelection will do nothing.
1174          */
1175         int saveSelectionState = selectionAcquired;
1176         selectionAcquired = False;
1177
1178         TRACE("\tswitching selection from %08x to %08x\n",
1179                     (unsigned)selectionPrevWindow, (unsigned)selectionWindow);
1180
1181         /* Assume ownership for the PRIMARY and CLIPBOARD selection */
1182         if ( saveSelectionState & S_PRIMARY )
1183             TSXSetSelectionOwner(display, XA_PRIMARY, selectionWindow, CurrentTime);
1184
1185         TSXSetSelectionOwner(display, xaClipboard, selectionWindow, CurrentTime);
1186
1187         /* Restore the selection masks */
1188         selectionAcquired = saveSelectionState;
1189
1190         /* Lose the selection if something went wrong */
1191         if ( ( (saveSelectionState & S_PRIMARY) &&
1192                (TSXGetSelectionOwner(display, XA_PRIMARY) != selectionWindow) )
1193              || (TSXGetSelectionOwner(display, xaClipboard) != selectionWindow) )
1194         {
1195             bLostSelection = TRUE;
1196             goto END;
1197         }
1198         else
1199         {
1200             /* Update selection state */
1201             if (saveSelectionState & S_PRIMARY)
1202                PrimarySelectionOwner = selectionWindow;
1203
1204             ClipboardSelectionOwner = selectionWindow;
1205         }
1206     }
1207     else
1208     {
1209         bLostSelection = TRUE;
1210         goto END;
1211     }
1212
1213 END:
1214     if (bLostSelection)
1215     {
1216       /* Launch the clipboard server if the selection can no longer be recyled
1217        * to another top level window. */
1218
1219       if ( !X11DRV_CLIPBOARD_LaunchServer() )
1220       {
1221          /* Empty the windows clipboard if the server was not launched.
1222           * We should pretend that we still own the selection BEFORE calling
1223           * EmptyClipboard() since otherwise this has the side effect of
1224           * triggering X11DRV_CLIPBOARD_Acquire() and causing the X selection
1225           * to be re-acquired by us!
1226           */
1227
1228          TRACE("\tLost the selection! Emptying the clipboard...\n");
1229
1230          OpenClipboard( 0 );
1231          selectionAcquired = (S_PRIMARY | S_CLIPBOARD);
1232          EmptyClipboard();
1233
1234          CloseClipboard();
1235
1236          /* Give up ownership of the windows clipboard */
1237          CLIPBOARD_ReleaseOwner();
1238       }
1239
1240       selectionAcquired = S_NOSELECTION;
1241       ClipboardSelectionOwner = PrimarySelectionOwner = 0;
1242       selectionWindow = 0;
1243     }
1244 }
1245
1246 /**************************************************************************
1247  *              X11DRV_CLIPBOARD_RegisterPixmapResource
1248  * Registers a Pixmap resource which is to be associated with a property Atom.
1249  * When the property is destroyed we also destroy the Pixmap through the
1250  * PropertyNotify event.
1251  */
1252 BOOL X11DRV_CLIPBOARD_RegisterPixmapResource( Atom property, Pixmap pixmap )
1253 {
1254     PROPERTY *prop = HeapAlloc( GetProcessHeap(), 0, sizeof(*prop) );
1255     if (!prop) return FALSE;
1256     prop->atom = property;
1257     prop->pixmap = pixmap;
1258     prop->next = prop_head;
1259     prop_head = prop;
1260     return TRUE;
1261 }
1262
1263 /**************************************************************************
1264  *              X11DRV_CLIPBOARD_FreeResources
1265  *
1266  * Called from EVENT_PropertyNotify() to give us a chance to destroy
1267  * any resources associated with this property.
1268  */
1269 void X11DRV_CLIPBOARD_FreeResources( Atom property )
1270 {
1271     /* Do a simple linear search to see if we have a Pixmap resource
1272      * associated with this property and release it.
1273      */
1274     PROPERTY **prop = &prop_head;
1275
1276     while (*prop)
1277     {
1278         if ((*prop)->atom == property)
1279         {
1280             PROPERTY *next = (*prop)->next;
1281             XFreePixmap( gdi_display, (*prop)->pixmap );
1282             HeapFree( GetProcessHeap(), 0, *prop );
1283             *prop = next;
1284         }
1285         else prop = &(*prop)->next;
1286     }
1287 }