/* * X11 clipboard windows driver * * Copyright 1994 Martin Ayotte * 1996 Alex Korobka * 1999 Noel Borthwick * * NOTES: * This file contains the X specific implementation for the windows * Clipboard API. * * Wine's internal clipboard is exposed to external apps via the X * selection mechanism. * Currently the driver asserts ownership via two selection atoms: * 1. PRIMARY(XA_PRIMARY) * 2. CLIPBOARD * * In our implementation, the CLIPBOARD selection takes precedence over PRIMARY, * i.e. if a CLIPBOARD selection is available, it is used instead of PRIMARY. * When Wine takes ownership of the clipboard, it takes ownership of BOTH selections. * While giving up selection ownership, if the CLIPBOARD selection is lost, * it will lose both PRIMARY and CLIPBOARD and empty the clipboard. * However if only PRIMARY is lost, it will continue to hold the CLIPBOARD selection * (leaving the clipboard cache content unaffected). * * Every format exposed via a windows clipboard format is also exposed through * a corresponding X selection target. A selection target atom is synthesized * whenever a new Windows clipboard format is registered via RegisterClipboardFormat, * or when a built-in format is used for the first time. * Windows native format are exposed by prefixing the format name with "" * This allows us to uniquely identify windows native formats exposed by other * running WINE apps. * * In order to allow external applications to query WINE for supported formats, * we respond to the "TARGETS" selection target. (See EVENT_SelectionRequest * for implementation) We use the same mechanism to query external clients for * availability of a particular format, by caching the list of available targets * by using the clipboard cache's "delayed render" mechanism. If a selection client * does not support the "TARGETS" selection target, we actually attempt to retrieve * the format requested as a fallback mechanism. * * Certain Windows native formats are automatically converted to X native formats * and vice versa. If a native format is available in the selection, it takes * precedence, in order to avoid unnecessary conversions. * */ #include "ts_xlib.h" #include #include #include #include #include #include "winreg.h" #include "clipboard.h" #include "win.h" #include "x11drv.h" #include "debugtools.h" DEFAULT_DEBUG_CHANNEL(clipboard); /* Selection masks */ #define S_NOSELECTION 0 #define S_PRIMARY 1 #define S_CLIPBOARD 2 /* X selection context info */ static char _CLIPBOARD[] = "CLIPBOARD"; /* CLIPBOARD atom name */ static char FMT_PREFIX[] = ""; /* Prefix for windows specific formats */ static int selectionAcquired = 0; /* Contains the current selection masks */ static Window selectionWindow = None; /* The top level X window which owns the selection */ static Window selectionPrevWindow = None; /* The last X window that owned the selection */ static Window PrimarySelectionOwner = None; /* The window which owns the primary selection */ static Window ClipboardSelectionOwner = None; /* The window which owns the clipboard selection */ static unsigned long cSelectionTargets = 0; /* Number of target formats reported by TARGETS selection */ static Atom selectionCacheSrc = XA_PRIMARY; /* The selection source from which the clipboard cache was filled */ static HANDLE selectionClearEvent = 0;/* Synchronization object used to block until server is started */ typedef struct tagPROPERTY { struct tagPROPERTY *next; Atom atom; Pixmap pixmap; } PROPERTY; static PROPERTY *prop_head; /************************************************************************** * X11DRV_CLIPBOARD_MapPropertyToFormat * * Map an X selection property type atom name to a windows clipboard format ID */ UINT X11DRV_CLIPBOARD_MapPropertyToFormat(char *itemFmtName) { /* * If the property name starts with FMT_PREFIX strip this off and * get the ID for a custom Windows registered format with this name. * We can also understand STRING, PIXMAP and BITMAP. */ if ( NULL == itemFmtName ) return 0; else if ( 0 == strncmp(itemFmtName, FMT_PREFIX, strlen(FMT_PREFIX)) ) return RegisterClipboardFormatA(itemFmtName + strlen(FMT_PREFIX)); else if ( 0 == strcmp(itemFmtName, "STRING") ) return CF_UNICODETEXT; else if ( 0 == strcmp(itemFmtName, "PIXMAP") || 0 == strcmp(itemFmtName, "BITMAP") ) { /* * Return CF_DIB as first preference, if WINE is the selection owner * and if CF_DIB exists in the cache. * If wine dowsn't own the selection we always return CF_DIB */ if ( !X11DRV_IsSelectionOwner() ) return CF_DIB; else if ( CLIPBOARD_IsPresent(CF_DIB) ) return CF_DIB; else return CF_BITMAP; } WARN("\tNo mapping to Windows clipboard format for property %s\n", itemFmtName); return 0; } /************************************************************************** * X11DRV_CLIPBOARD_MapFormatToProperty * * Map a windows clipboard format ID to an X selection property atom */ Atom X11DRV_CLIPBOARD_MapFormatToProperty(UINT wFormat) { Atom prop = None; switch (wFormat) { /* We support only CF_UNICODETEXT, other formats are synthesized */ case CF_OEMTEXT: case CF_TEXT: return None; case CF_UNICODETEXT: prop = XA_STRING; break; case CF_DIB: case CF_BITMAP: { /* * Request a PIXMAP, only if WINE is NOT the selection owner, * AND the requested format is not in the cache. */ if ( !X11DRV_IsSelectionOwner() && !CLIPBOARD_IsPresent(wFormat) ) { prop = XA_PIXMAP; break; } /* Fall thru to the default case in order to use the native format */ } default: { /* * If an X atom is registered for this format, return that * Otherwise register a new atom. */ char str[256]; char *fmtName = CLIPBOARD_GetFormatName(wFormat); strcpy(str, FMT_PREFIX); if (fmtName) { strncat(str, fmtName, sizeof(str) - strlen(FMT_PREFIX)); prop = TSXInternAtom(thread_display(), str, False); } break; } } if (prop == None) TRACE("\tNo mapping to X property for Windows clipboard format %d(%s)\n", wFormat, CLIPBOARD_GetFormatName(wFormat)); return prop; } /************************************************************************** * X11DRV_CLIPBOARD_IsNativeProperty * * Checks if a property is a native Wine property type */ BOOL X11DRV_CLIPBOARD_IsNativeProperty(Atom prop) { char *itemFmtName = TSXGetAtomName(thread_display(), prop); BOOL bRet = FALSE; if ( 0 == strncmp(itemFmtName, FMT_PREFIX, strlen(FMT_PREFIX)) ) bRet = TRUE; TSXFree(itemFmtName); return bRet; } /************************************************************************** * X11DRV_CLIPBOARD_LaunchServer * Launches the clipboard server. This is called from X11DRV_CLIPBOARD_ResetOwner * when the selection can no longer be recyled to another top level window. * In order to make the selection persist after Wine shuts down a server * process is launched which services subsequent selection requests. */ BOOL X11DRV_CLIPBOARD_LaunchServer() { int iWndsLocks; char clearSelection[8] = "0"; int persistent_selection = 1; HKEY hkey; /* If persistant selection has been disabled in the .winerc Clipboard section, * don't launch the server */ if(!RegOpenKeyA(HKEY_LOCAL_MACHINE, "Software\\Wine\\Wine\\Config\\Clipboard", &hkey)) { char buffer[20]; DWORD type, count = sizeof(buffer); if(!RegQueryValueExA(hkey, "PersistentSelection", 0, &type, buffer, &count)) persistent_selection = atoi(buffer); /* Get the clear selection preference */ count = sizeof(clearSelection); RegQueryValueExA(hkey, "ClearAllSelections", 0, &type, clearSelection, &count); RegCloseKey(hkey); } if ( !persistent_selection ) return FALSE; /* Start up persistant WINE X clipboard server process which will * take ownership of the X selection and continue to service selection * requests from other apps. */ selectionWindow = selectionPrevWindow; if ( !fork() ) { /* NOTE: This code only executes in the context of the child process * Do note make any Wine specific calls here. */ int dbgClasses = 0; char selMask[8], dbgClassMask[8]; sprintf(selMask, "%d", selectionAcquired); /* Build the debug class mask to pass to the server, by inheriting * the settings for the clipboard debug channel. */ dbgClasses |= FIXME_ON(clipboard) ? 1 : 0; dbgClasses |= ERR_ON(clipboard) ? 2 : 0; dbgClasses |= WARN_ON(clipboard) ? 4 : 0; dbgClasses |= TRACE_ON(clipboard) ? 8 : 0; sprintf(dbgClassMask, "%d", dbgClasses); /* Exec the clipboard server passing it the selection and debug class masks */ execl( BINDIR "/wineclipsrv", "wineclipsrv", selMask, dbgClassMask, clearSelection, NULL ); execlp( "wineclipsrv", "wineclipsrv", selMask, dbgClassMask, clearSelection, NULL ); execl( "./windows/x11drv/wineclipsrv", "wineclipsrv", selMask, dbgClassMask, clearSelection, NULL ); /* Exec Failed! */ perror("Could not start Wine clipboard server"); exit( 1 ); /* Exit the child process */ } /* Wait until the clipboard server acquires the selection. * We must release the windows lock to enable Wine to process * selection messages in response to the servers requests. */ iWndsLocks = WIN_SuspendWndsLock(); /* We must wait until the server finishes acquiring the selection, * before proceeding, otherwise the window which owns the selection * will be destroyed prematurely! * Create a non-signalled, auto-reset event which will be set by * X11DRV_CLIPBOARD_ReleaseSelection, and wait until this gets * signalled before proceeding. */ if ( !(selectionClearEvent = CreateEventA(NULL, FALSE, FALSE, NULL)) ) ERR("Could not create wait object. Clipboard server won't start!\n"); else { /* Wait until we lose the selection, timing out after a minute */ TRACE("Waiting for clipboard server to acquire selection\n"); if ( MsgWaitForMultipleObjects( 1, &selectionClearEvent, FALSE, 60000, QS_ALLINPUT ) != WAIT_OBJECT_0 ) TRACE("Server could not acquire selection, or a timeout occurred!\n"); else TRACE("Server successfully acquired selection\n"); /* Release the event */ CloseHandle(selectionClearEvent); selectionClearEvent = 0; } WIN_RestoreWndsLock(iWndsLocks); return TRUE; } /************************************************************************** * X11DRV_CLIPBOARD_CacheDataFormats * * Caches the list of data formats available from the current selection. * This queries the selection owner for the TARGETS property and saves all * reported property types. */ int X11DRV_CLIPBOARD_CacheDataFormats( Atom SelectionName ) { Display *display = thread_display(); HWND hWnd = 0; HWND hWndClipWindow = GetOpenClipboardWindow(); XEvent xe; Atom aTargets; Atom atype=AnyPropertyType; int aformat; unsigned long remain; Atom* targetList=NULL; Window w; Window ownerSelection = 0; TRACE("enter\n"); /* * Empty the clipboard cache */ CLIPBOARD_EmptyCache(TRUE); cSelectionTargets = 0; selectionCacheSrc = SelectionName; hWnd = (hWndClipWindow) ? hWndClipWindow : GetActiveWindow(); ownerSelection = TSXGetSelectionOwner(display, SelectionName); if ( !hWnd || (ownerSelection == None) ) return cSelectionTargets; /* * Query the selection owner for the TARGETS property */ w = X11DRV_get_top_window(hWnd); aTargets = TSXInternAtom(display, "TARGETS", False); TRACE("Requesting TARGETS selection for '%s' (owner=%08x)...\n", TSXGetAtomName(display, selectionCacheSrc), (unsigned)ownerSelection ); wine_tsx11_lock(); XConvertSelection(display, selectionCacheSrc, aTargets, TSXInternAtom(display, "SELECTION_DATA", False), w, CurrentTime); /* * Wait until SelectionNotify is received */ while( TRUE ) { if( XCheckTypedWindowEvent(display, w, SelectionNotify, &xe) ) if( xe.xselection.selection == selectionCacheSrc ) break; } wine_tsx11_unlock(); /* Verify that the selection returned a valid TARGETS property */ if ( (xe.xselection.target != aTargets) || (xe.xselection.property == None) ) { TRACE("\tExit, could not retrieve TARGETS\n"); return cSelectionTargets; } /* Read the TARGETS property contents */ if(TSXGetWindowProperty(display, xe.xselection.requestor, xe.xselection.property, 0, 0x3FFF, True, AnyPropertyType/*XA_ATOM*/, &atype, &aformat, &cSelectionTargets, &remain, (unsigned char**)&targetList) != Success) TRACE("\tCouldn't read TARGETS property\n"); else { TRACE("\tType %s,Format %d,nItems %ld, Remain %ld\n", TSXGetAtomName(display,atype),aformat,cSelectionTargets, remain); /* * The TARGETS property should have returned us a list of atoms * corresponding to each selection target format supported. */ if( (atype == XA_ATOM || atype == aTargets) && aformat == 32 ) { int i; LPWINE_CLIPFORMAT lpFormat; /* Cache these formats in the clipboard cache */ for (i = 0; i < cSelectionTargets; i++) { char *itemFmtName = TSXGetAtomName(display, targetList[i]); UINT wFormat = X11DRV_CLIPBOARD_MapPropertyToFormat(itemFmtName); /* * If the clipboard format maps to a Windows format, simply store * the atom identifier and record its availablity status * in the clipboard cache. */ if (wFormat) { lpFormat = CLIPBOARD_LookupFormat( wFormat ); /* Don't replace if the property already cached is a native format, * or if a PIXMAP is being replaced by a BITMAP. */ if (lpFormat->wDataPresent && ( X11DRV_CLIPBOARD_IsNativeProperty(lpFormat->drvData) || (lpFormat->drvData == XA_PIXMAP && targetList[i] == XA_BITMAP) ) ) { TRACE("\tAtom# %d: '%s' --> FormatID(%d) %s (Skipped)\n", i, itemFmtName, wFormat, lpFormat->Name); } else { lpFormat->wDataPresent = 1; lpFormat->drvData = targetList[i]; TRACE("\tAtom# %d: '%s' --> FormatID(%d) %s\n", i, itemFmtName, wFormat, lpFormat->Name); } } TSXFree(itemFmtName); } } /* Free the list of targets */ TSXFree(targetList); } return cSelectionTargets; } /************************************************************************** * X11DRV_CLIPBOARD_ReadSelection * Reads the contents of the X selection property into the WINE clipboard cache * converting the selection into a format compatible with the windows clipboard * if possible. * This method is invoked only to read the contents of a the selection owned * by an external application. i.e. when we do not own the X selection. */ static BOOL X11DRV_CLIPBOARD_ReadSelection(UINT wFormat, Window w, Atom prop, Atom reqType) { Display *display = thread_display(); Atom atype=AnyPropertyType; int aformat; unsigned long total,nitems,remain,itemSize,val_cnt; long lRequestLength,bwc; unsigned char* val; unsigned char* buffer; LPWINE_CLIPFORMAT lpFormat; BOOL bRet = FALSE; HWND hWndClipWindow = GetOpenClipboardWindow(); if(prop == None) return bRet; TRACE("Reading X selection...\n"); TRACE("\tretrieving property %s from window %ld into %s\n", TSXGetAtomName(display,reqType), (long)w, TSXGetAtomName(display,prop) ); /* * First request a zero length in order to figure out the request size. */ if(TSXGetWindowProperty(display,w,prop,0,0,False, AnyPropertyType/*reqType*/, &atype, &aformat, &nitems, &itemSize, &val) != Success) { WARN("\tcouldn't get property size\n"); return bRet; } /* Free zero length return data if any */ if ( val ) { TSXFree(val); val = NULL; } TRACE("\tretrieving %ld bytes...\n", itemSize * aformat/8); lRequestLength = (itemSize * aformat/8)/4 + 1; bwc = aformat/8; /* we want to read the property, but not it too large of chunks or we could hang the cause problems. Lets go for 4k blocks */ if(TSXGetWindowProperty(display,w,prop,0,4096,False, AnyPropertyType/*reqType*/, &atype, &aformat, &nitems, &remain, &buffer) != Success) { WARN("\tcouldn't read property\n"); return bRet; } val = (char*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY, nitems*bwc); memcpy(val,buffer,nitems*bwc); TSXFree(buffer); for (total = nitems*bwc,val_cnt=0; remain;) { val_cnt +=nitems*bwc; TSXGetWindowProperty(display, w, prop, (total / 4), 4096, False, AnyPropertyType, &atype, &aformat, &nitems, &remain, &buffer); total += nitems*bwc; HeapReAlloc(GetProcessHeap(),0,val, total); memcpy(&val[val_cnt], buffer, nitems*(aformat/8)); TSXFree(buffer); } nitems = total; /* * Translate the X property into the appropriate Windows clipboard * format, if possible. */ if ( (reqType == XA_STRING) && (atype == XA_STRING) && (aformat == 8) ) /* convert Unix text to CF_UNICODETEXT */ { int i,inlcount = 0; char* lpstr; for(i=0; i <= nitems; i++) if( val[i] == '\n' ) inlcount++; if( (lpstr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, nitems + inlcount + 1)) ) { static UINT text_cp = (UINT)-1; UINT count; HANDLE hUnicodeText; for(i=0,inlcount=0; i <= nitems; i++) { if( val[i] == '\n' ) lpstr[inlcount++]='\r'; lpstr[inlcount++]=val[i]; } if(text_cp == (UINT)-1) { HKEY hkey; /* default value */ text_cp = CP_ACP; if(!RegOpenKeyA(HKEY_LOCAL_MACHINE, "Software\\Wine\\Wine\\Config\\x11drv", &hkey)) { char buf[20]; DWORD type, count = sizeof(buf); if(!RegQueryValueExA(hkey, "TextCP", 0, &type, buf, &count)) text_cp = atoi(buf); RegCloseKey(hkey); } } count = MultiByteToWideChar(text_cp, 0, lpstr, -1, NULL, 0); hUnicodeText = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, count * sizeof(WCHAR)); if(hUnicodeText) { WCHAR *textW = GlobalLock(hUnicodeText); MultiByteToWideChar(text_cp, 0, lpstr, -1, textW, count); GlobalUnlock(hUnicodeText); if (!SetClipboardData(CF_UNICODETEXT, hUnicodeText)) { ERR("Not SET! Need to free our own block\n"); GlobalFree(hUnicodeText); } bRet = TRUE; } HeapFree(GetProcessHeap(), 0, lpstr); } } else if ( reqType == XA_PIXMAP || reqType == XA_BITMAP ) /* treat PIXMAP as CF_DIB or CF_BITMAP */ { /* Get the first pixmap handle passed to us */ Pixmap *pPixmap = (Pixmap *)val; HANDLE hTargetImage = 0; /* Handle to store the converted bitmap or DIB */ if (aformat != 32 || nitems < 1 || atype != XA_PIXMAP || (wFormat != CF_BITMAP && wFormat != CF_DIB)) { WARN("\tUnimplemented format conversion request\n"); goto END; } if ( wFormat == CF_BITMAP ) { /* For CF_BITMAP requests we must return an HBITMAP */ hTargetImage = X11DRV_BITMAP_CreateBitmapFromPixmap(*pPixmap, TRUE); } else if (wFormat == CF_DIB) { HWND hwnd = GetOpenClipboardWindow(); HDC hdc = GetDC(hwnd); /* For CF_DIB requests we must return an HGLOBAL storing a packed DIB */ hTargetImage = X11DRV_DIB_CreateDIBFromPixmap(*pPixmap, hdc, TRUE); ReleaseDC(hdc, hwnd); } if (!hTargetImage) { WARN("PIXMAP conversion failed!\n" ); goto END; } /* Delete previous clipboard data */ lpFormat = CLIPBOARD_LookupFormat(wFormat); if (lpFormat->wDataPresent && (lpFormat->hData16 || lpFormat->hData32)) CLIPBOARD_DeleteRecord(lpFormat, !(hWndClipWindow)); /* Update the clipboard record */ lpFormat->wDataPresent = 1; lpFormat->hData32 = hTargetImage; lpFormat->hData16 = 0; bRet = TRUE; } /* For native properties simply copy the X data without conversion */ else if (X11DRV_CLIPBOARD_IsNativeProperty(reqType)) /* * */ { HANDLE hClipData = 0; void* lpClipData; int cBytes = nitems * aformat/8; if( cBytes ) { /* Turn on the DDESHARE flag to enable shared 32 bit memory */ hClipData = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, cBytes ); if( (lpClipData = GlobalLock(hClipData)) ) { memcpy(lpClipData, val, cBytes); GlobalUnlock(hClipData); } else hClipData = 0; } if( hClipData ) { /* delete previous clipboard record if any */ lpFormat = CLIPBOARD_LookupFormat(wFormat); if (lpFormat->wDataPresent || lpFormat->hData16 || lpFormat->hData32) CLIPBOARD_DeleteRecord(lpFormat, !(hWndClipWindow)); /* Update the clipboard record */ lpFormat->wDataPresent = 1; lpFormat->hData32 = hClipData; lpFormat->hData16 = 0; bRet = TRUE; } } else { WARN("\tUnimplemented format conversion request\n"); goto END; } END: /* Delete the property on the window now that we are done * This will send a PropertyNotify event to the selection owner. */ TSXDeleteProperty(display,w,prop); /* Free the retrieved property data */ HeapFree(GetProcessHeap(),0,val); return bRet; } /************************************************************************** * X11DRV_CLIPBOARD_ReleaseSelection * * Release an XA_PRIMARY or XA_CLIPBOARD selection that we own, in response * to a SelectionClear event. * This can occur in response to another client grabbing the X selection. * If the XA_CLIPBOARD selection is lost, we relinquish XA_PRIMARY as well. */ void X11DRV_CLIPBOARD_ReleaseSelection(Atom selType, Window w, HWND hwnd) { Display *display = thread_display(); Atom xaClipboard = TSXInternAtom(display, "CLIPBOARD", False); int clearAllSelections = 0; HKEY hkey; if(!RegOpenKeyA(HKEY_LOCAL_MACHINE, "Software\\Wine\\Wine\\Config\\Clipboard", &hkey)) { char buffer[20]; DWORD type, count = sizeof(buffer); if(!RegQueryValueExA(hkey, "ClearAllSelections", 0, &type, buffer, &count)) clearAllSelections = atoi(buffer); RegCloseKey(hkey); } /* w is the window that lost the selection * selectionPrevWindow is nonzero if CheckSelection() was called. */ TRACE("\tevent->window = %08x (sw = %08x, spw=%08x)\n", (unsigned)w, (unsigned)selectionWindow, (unsigned)selectionPrevWindow ); if( selectionAcquired ) { if( w == selectionWindow || selectionPrevWindow == None) { /* If we're losing the CLIPBOARD selection, or if the preferences in .winerc * dictate that *all* selections should be cleared on loss of a selection, * we must give up all the selections we own. */ if ( clearAllSelections || (selType == xaClipboard) ) { /* completely give up the selection */ TRACE("Lost CLIPBOARD (+PRIMARY) selection\n"); /* We are completely giving up the selection. * Make sure we can open the windows clipboard first. */ if ( !OpenClipboard(hwnd) ) { /* * We can't empty the clipboard if we cant open it so abandon. * Wine will think that it still owns the selection but this is * safer than losing the selection without properly emptying * the clipboard. Perhaps we should forcibly re-assert ownership * of the CLIPBOARD selection in this case... */ ERR("\tClipboard is busy. Could not give up selection!\n"); return; } /* We really lost CLIPBOARD but want to voluntarily lose PRIMARY */ if ( (selType == xaClipboard) && (selectionAcquired & S_PRIMARY) ) { XSetSelectionOwner(display, XA_PRIMARY, None, CurrentTime); } /* We really lost PRIMARY but want to voluntarily lose CLIPBOARD */ if ( (selType == XA_PRIMARY) && (selectionAcquired & S_CLIPBOARD) ) { XSetSelectionOwner(display, xaClipboard, None, CurrentTime); } selectionWindow = None; PrimarySelectionOwner = ClipboardSelectionOwner = 0; /* Empty the windows clipboard. * We should pretend that we still own the selection BEFORE calling * EmptyClipboard() since otherwise this has the side effect of * triggering X11DRV_CLIPBOARD_Acquire() and causing the X selection * to be re-acquired by us! */ selectionAcquired = (S_PRIMARY | S_CLIPBOARD); EmptyClipboard(); CloseClipboard(); /* Give up ownership of the windows clipboard */ CLIPBOARD_ReleaseOwner(); /* Reset the selection flags now that we are done */ selectionAcquired = S_NOSELECTION; } else if ( selType == XA_PRIMARY ) /* Give up only PRIMARY selection */ { TRACE("Lost PRIMARY selection\n"); PrimarySelectionOwner = 0; selectionAcquired &= ~S_PRIMARY; /* clear S_PRIMARY mask */ } cSelectionTargets = 0; } /* but we'll keep existing data for internal use */ else if( w == selectionPrevWindow ) { Atom xaClipboard = TSXInternAtom(display, _CLIPBOARD, False); w = TSXGetSelectionOwner(display, XA_PRIMARY); if( w == None ) TSXSetSelectionOwner(display, XA_PRIMARY, selectionWindow, CurrentTime); w = TSXGetSelectionOwner(display, xaClipboard); if( w == None ) TSXSetSelectionOwner(display, xaClipboard, selectionWindow, CurrentTime); } } /* Signal to a selectionClearEvent listener if the selection is completely lost */ if (selectionClearEvent && !selectionAcquired) { TRACE("Lost all selections, signalling to selectionClearEvent listener\n"); SetEvent(selectionClearEvent); } selectionPrevWindow = None; } /************************************************************************** * ReleaseClipboard (X11DRV.@) * Voluntarily release all currently owned X selections */ void X11DRV_ReleaseClipboard(void) { Display *display = thread_display(); if( selectionAcquired ) { XEvent xe; Window savePrevWindow = selectionWindow; Atom xaClipboard = TSXInternAtom(display, _CLIPBOARD, False); BOOL bHasPrimarySelection = selectionAcquired & S_PRIMARY; selectionAcquired = S_NOSELECTION; selectionPrevWindow = selectionWindow; selectionWindow = None; TRACE("\tgiving up selection (spw = %08x)\n", (unsigned)selectionPrevWindow); wine_tsx11_lock(); TRACE("Releasing CLIPBOARD selection\n"); XSetSelectionOwner(display, xaClipboard, None, CurrentTime); if( selectionPrevWindow ) while( !XCheckTypedWindowEvent( display, selectionPrevWindow, SelectionClear, &xe ) ); if ( bHasPrimarySelection ) { TRACE("Releasing XA_PRIMARY selection\n"); selectionPrevWindow = savePrevWindow; /* May be cleared in X11DRV_CLIPBOARD_ReleaseSelection */ XSetSelectionOwner(display, XA_PRIMARY, None, CurrentTime); if( selectionPrevWindow ) while( !XCheckTypedWindowEvent( display, selectionPrevWindow, SelectionClear, &xe ) ); } wine_tsx11_unlock(); } /* Get rid of any Pixmap resources we may still have */ while (prop_head) { PROPERTY *prop = prop_head; prop_head = prop->next; XFreePixmap( gdi_display, prop->pixmap ); HeapFree( GetProcessHeap(), 0, prop ); } } /************************************************************************** * AcquireClipboard (X11DRV.@) */ void X11DRV_AcquireClipboard(void) { Display *display = thread_display(); Window owner; HWND hWndClipWindow = GetOpenClipboardWindow(); /* * Acquire X selection if we don't already own it. * Note that we only acquire the selection if it hasn't been already * acquired by us, and ignore the fact that another X window may be * asserting ownership. The reason for this is we need *any* top level * X window to hold selection ownership. The actual clipboard data requests * are made via GetClipboardData from EVENT_SelectionRequest and this * ensures that the real HWND owner services the request. * If the owning X window gets destroyed the selection ownership is * re-cycled to another top level X window in X11DRV_CLIPBOARD_ResetOwner. * */ if ( !(selectionAcquired == (S_PRIMARY | S_CLIPBOARD)) ) { Atom xaClipboard = TSXInternAtom(display, _CLIPBOARD, False); owner = X11DRV_get_top_window( hWndClipWindow ? hWndClipWindow : AnyPopup() ); /* Grab PRIMARY selection if not owned */ if ( !(selectionAcquired & S_PRIMARY) ) TSXSetSelectionOwner(display, XA_PRIMARY, owner, CurrentTime); /* Grab CLIPBOARD selection if not owned */ if ( !(selectionAcquired & S_CLIPBOARD) ) TSXSetSelectionOwner(display, xaClipboard, owner, CurrentTime); if( TSXGetSelectionOwner(display,XA_PRIMARY) == owner ) selectionAcquired |= S_PRIMARY; if( TSXGetSelectionOwner(display,xaClipboard) == owner) selectionAcquired |= S_CLIPBOARD; if (selectionAcquired) { selectionWindow = owner; TRACE("Grabbed X selection, owner=(%08x)\n", (unsigned) owner); } } } /************************************************************************** * IsClipboardFormatAvailable (X11DRV.@) * * Checks if the specified format is available in the current selection * Only invoked when WINE is not the selection owner */ BOOL X11DRV_IsClipboardFormatAvailable(UINT wFormat) { Display *display = thread_display(); Atom xaClipboard = TSXInternAtom(display, _CLIPBOARD, False); Window ownerPrimary = TSXGetSelectionOwner(display,XA_PRIMARY); Window ownerClipboard = TSXGetSelectionOwner(display,xaClipboard); TRACE("enter for %d\n", wFormat); /* * If the selection has not been previously cached, or the selection has changed, * try and cache the list of available selection targets from the current selection. */ if ( !cSelectionTargets || (PrimarySelectionOwner != ownerPrimary) || (ClipboardSelectionOwner != ownerClipboard) ) { /* * First try caching the CLIPBOARD selection. * If unavailable try PRIMARY. */ if ( X11DRV_CLIPBOARD_CacheDataFormats(xaClipboard) == 0 ) { X11DRV_CLIPBOARD_CacheDataFormats(XA_PRIMARY); } ClipboardSelectionOwner = ownerClipboard; PrimarySelectionOwner = ownerPrimary; } /* Exit if there is no selection */ if ( !ownerClipboard && !ownerPrimary ) { TRACE("There is no selection owner\n"); return FALSE; } /* Check if the format is available in the clipboard cache */ if ( CLIPBOARD_IsPresent(wFormat) ) return TRUE; /* * Many X client apps (such as XTerminal) don't support being queried * for the "TARGETS" target atom. To handle such clients we must actually * try to convert the selection to the requested type. */ if ( !cSelectionTargets ) return X11DRV_GetClipboardData( wFormat ); TRACE("There is no selection\n"); return FALSE; } /************************************************************************** * RegisterClipboardFormat (X11DRV.@) * * Registers a custom X clipboard format * Returns: TRUE - success, FALSE - failure */ BOOL X11DRV_RegisterClipboardFormat( LPCSTR FormatName ) { Display *display = thread_display(); Atom prop = None; char str[256]; /* * If an X atom is registered for this format, return that * Otherwise register a new atom. */ if (FormatName) { /* Add a WINE specific prefix to the format */ strcpy(str, FMT_PREFIX); strncat(str, FormatName, sizeof(str) - strlen(FMT_PREFIX)); prop = TSXInternAtom(display, str, False); } return (prop) ? TRUE : FALSE; } /************************************************************************** * IsSelectionOwner (X11DRV.@) * * Returns: TRUE - We(WINE) own the selection, FALSE - Selection not owned by us */ BOOL X11DRV_IsSelectionOwner(void) { return selectionAcquired; } /************************************************************************** * SetClipboardData (X11DRV.@) * * We don't need to do anything special here since the clipboard code * maintains the cache. * */ void X11DRV_SetClipboardData(UINT wFormat) { /* Make sure we have acquired the X selection */ X11DRV_AcquireClipboard(); } /************************************************************************** * GetClipboardData (X11DRV.@) * * This method is invoked only when we DO NOT own the X selection * * NOTE: Clipboard driver get requests only for CF_UNICODETEXT data. * We always get the data from the selection client each time, * since we have no way of determining if the data in our cache is stale. */ BOOL X11DRV_GetClipboardData(UINT wFormat) { Display *display = thread_display(); BOOL bRet = selectionAcquired; HWND hWndClipWindow = GetOpenClipboardWindow(); HWND hWnd = (hWndClipWindow) ? hWndClipWindow : GetActiveWindow(); LPWINE_CLIPFORMAT lpFormat; TRACE("%d\n", wFormat); if (!selectionAcquired) { XEvent xe; Atom propRequest; Window w = X11DRV_get_top_window(hWnd); /* Map the format ID requested to an X selection property. * If the format is in the cache, use the atom associated * with it. */ lpFormat = CLIPBOARD_LookupFormat( wFormat ); if (lpFormat && lpFormat->wDataPresent && lpFormat->drvData) propRequest = (Atom)lpFormat->drvData; else propRequest = X11DRV_CLIPBOARD_MapFormatToProperty(wFormat); if (propRequest) { TRACE("Requesting %s selection from %s...\n", TSXGetAtomName(display, propRequest), TSXGetAtomName(display, selectionCacheSrc) ); wine_tsx11_lock(); XConvertSelection(display, selectionCacheSrc, propRequest, TSXInternAtom(display, "SELECTION_DATA", False), w, CurrentTime); /* wait until SelectionNotify is received */ while( TRUE ) { if( XCheckTypedWindowEvent(display, w, SelectionNotify, &xe) ) if( xe.xselection.selection == selectionCacheSrc ) break; } wine_tsx11_unlock(); /* * Read the contents of the X selection property into WINE's * clipboard cache converting the selection to be compatible if possible. */ bRet = X11DRV_CLIPBOARD_ReadSelection( wFormat, xe.xselection.requestor, xe.xselection.property, xe.xselection.target); } else bRet = FALSE; TRACE("\tpresent %s = %i\n", CLIPBOARD_GetFormatName(wFormat), bRet ); } TRACE("Returning %d\n", bRet); return bRet; } /************************************************************************** * ResetSelectionOwner (X11DRV.@) * * Called from DestroyWindow() to prevent X selection from being lost when * a top level window is destroyed, by switching ownership to another top * level window. * Any top level window can own the selection. See X11DRV_CLIPBOARD_Acquire * for a more detailed description of this. */ void X11DRV_ResetSelectionOwner(WND *pWnd, BOOL bFooBar) { Display *display = thread_display(); HWND hWndClipOwner = 0; Window XWnd = get_whole_window(pWnd); Atom xaClipboard; BOOL bLostSelection = FALSE; /* There is nothing to do if we don't own the selection, * or if the X window which currently owns the selecion is different * from the one passed in. */ if ( !selectionAcquired || XWnd != selectionWindow || selectionWindow == None ) return; if ( (bFooBar && XWnd) || (!bFooBar && !XWnd) ) return; hWndClipOwner = GetClipboardOwner(); xaClipboard = TSXInternAtom(display, _CLIPBOARD, False); TRACE("clipboard owner = %04x, selection window = %08x\n", hWndClipOwner, (unsigned)selectionWindow); /* now try to salvage current selection from being destroyed by X */ TRACE("\tchecking %08x\n", (unsigned) XWnd); selectionPrevWindow = selectionWindow; selectionWindow = None; if( pWnd->next ) selectionWindow = get_whole_window(pWnd->next); else if( pWnd->parent ) if( pWnd->parent->child != pWnd ) selectionWindow = get_whole_window(pWnd->parent->child); if( selectionWindow != None ) { /* We must pretend that we don't own the selection while making the switch * since a SelectionClear event will be sent to the last owner. * If there is no owner X11DRV_CLIPBOARD_ReleaseSelection will do nothing. */ int saveSelectionState = selectionAcquired; selectionAcquired = False; TRACE("\tswitching selection from %08x to %08x\n", (unsigned)selectionPrevWindow, (unsigned)selectionWindow); /* Assume ownership for the PRIMARY and CLIPBOARD selection */ if ( saveSelectionState & S_PRIMARY ) TSXSetSelectionOwner(display, XA_PRIMARY, selectionWindow, CurrentTime); TSXSetSelectionOwner(display, xaClipboard, selectionWindow, CurrentTime); /* Restore the selection masks */ selectionAcquired = saveSelectionState; /* Lose the selection if something went wrong */ if ( ( (saveSelectionState & S_PRIMARY) && (TSXGetSelectionOwner(display, XA_PRIMARY) != selectionWindow) ) || (TSXGetSelectionOwner(display, xaClipboard) != selectionWindow) ) { bLostSelection = TRUE; goto END; } else { /* Update selection state */ if (saveSelectionState & S_PRIMARY) PrimarySelectionOwner = selectionWindow; ClipboardSelectionOwner = selectionWindow; } } else { bLostSelection = TRUE; goto END; } END: if (bLostSelection) { /* Launch the clipboard server if the selection can no longer be recyled * to another top level window. */ if ( !X11DRV_CLIPBOARD_LaunchServer() ) { /* Empty the windows clipboard if the server was not launched. * We should pretend that we still own the selection BEFORE calling * EmptyClipboard() since otherwise this has the side effect of * triggering X11DRV_CLIPBOARD_Acquire() and causing the X selection * to be re-acquired by us! */ TRACE("\tLost the selection! Emptying the clipboard...\n"); OpenClipboard( 0 ); selectionAcquired = (S_PRIMARY | S_CLIPBOARD); EmptyClipboard(); CloseClipboard(); /* Give up ownership of the windows clipboard */ CLIPBOARD_ReleaseOwner(); } selectionAcquired = S_NOSELECTION; ClipboardSelectionOwner = PrimarySelectionOwner = 0; selectionWindow = 0; } } /************************************************************************** * X11DRV_CLIPBOARD_RegisterPixmapResource * Registers a Pixmap resource which is to be associated with a property Atom. * When the property is destroyed we also destroy the Pixmap through the * PropertyNotify event. */ BOOL X11DRV_CLIPBOARD_RegisterPixmapResource( Atom property, Pixmap pixmap ) { PROPERTY *prop = HeapAlloc( GetProcessHeap(), 0, sizeof(*prop) ); if (!prop) return FALSE; prop->atom = property; prop->pixmap = pixmap; prop->next = prop_head; prop_head = prop; return TRUE; } /************************************************************************** * X11DRV_CLIPBOARD_FreeResources * * Called from EVENT_PropertyNotify() to give us a chance to destroy * any resources associated with this property. */ void X11DRV_CLIPBOARD_FreeResources( Atom property ) { /* Do a simple linear search to see if we have a Pixmap resource * associated with this property and release it. */ PROPERTY **prop = &prop_head; while (*prop) { if ((*prop)->atom == property) { PROPERTY *next = (*prop)->next; XFreePixmap( gdi_display, (*prop)->pixmap ); HeapFree( GetProcessHeap(), 0, *prop ); *prop = next; } else prop = &(*prop)->next; } }