| /* |
| * Wine Clipboard Server |
| * |
| * Copyright 1999 Noel Borthwick |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, write to the Free Software |
| * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| * |
| * USAGE: |
| * wineclipsrv [selection_mask] [debugClass_mask] [clearAllSelections] |
| * |
| * The optional selection-mask argument is a bit mask of the selection |
| * types to be acquired. Currently two selections are supported: |
| * 1. PRIMARY (mask value 1) |
| * 2. CLIPBOARD (mask value 2). |
| * |
| * debugClass_mask is a bit mask of all debugging classes for which messages |
| * are to be output. The standard Wine debug class set FIXME(1), ERR(2), |
| * WARN(4) and TRACE(8) are supported. |
| * |
| * If clearAllSelections == 1 *all* selections are lost whenever a SelectionClear |
| * event is received. |
| * |
| * If no arguments are supplied the server aquires all selections. (mask value 3) |
| * and defaults to output of only FIXME(1) and ERR(2) messages. The default for |
| * clearAllSelections is 0. |
| * |
| * NOTES: |
| * |
| * The Wine Clipboard Server is a standalone XLib application whose |
| * purpose is to manage the X selection when Wine exits. |
| * The server itself is started automatically with the appropriate |
| * selection masks, whenever Wine exits after acquiring the PRIMARY and/or |
| * CLIPBOARD selection. (See X11DRV_CLIPBOARD_ResetOwner) |
| * When the server starts, it first proceeds to capture the selection data from |
| * Wine and then takes over the selection ownership. It does this by querying |
| * the current selection owner(of the specified selections) for the TARGETS |
| * selection target. It then proceeds to cache all the formats exposed by |
| * TARGETS. If the selection does not support the TARGETS target, or if no |
| * target formats are exposed, the server simply exits. |
| * Once the cache has been filled, the server then actually acquires ownership |
| * of the respective selection and begins fielding selection requests. |
| * Selection requests are serviced from the cache. If a selection is lost the |
| * server flushes its internal cache, destroying all data previously saved. |
| * Once ALL selections have been lost the server terminates. |
| * |
| * TODO: |
| */ |
| |
| #include "config.h" |
| |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <X11/Xlib.h> |
| #include <X11/Xutil.h> |
| #include <X11/Xos.h> |
| #include <X11/Xatom.h> |
| |
| /* |
| * Lightweight debug definitions for Wine Clipboard Server. |
| * The standard FIXME, ERR, WARN & TRACE classes are supported |
| * without debug channels. |
| * The standard defines NO_TRACE_MSGS and NO_DEBUG_MSGS will compile out |
| * TRACE, WARN and ERR and FIXME message displays. |
| */ |
| |
| /* Internal definitions (do not use these directly) */ |
| |
| #ifdef __SUNPRO_C |
| #define __FUNCTION__ __func__ |
| #endif |
| |
| enum __DEBUG_CLASS { __DBCL_FIXME, __DBCL_ERR, __DBCL_WARN, __DBCL_TRACE, __DBCL_COUNT }; |
| |
| extern char __debug_msg_enabled[__DBCL_COUNT]; |
| |
| extern const char * const debug_cl_name[__DBCL_COUNT]; |
| |
| #define DEBUG_CLASS_COUNT __DBCL_COUNT |
| |
| #define __GET_DEBUGGING(dbcl) (__debug_msg_enabled[(dbcl)]) |
| #define __SET_DEBUGGING(dbcl,on) (__debug_msg_enabled[(dbcl)] = (on)) |
| |
| |
| #define __DPRINTF(dbcl) \ |
| (!__GET_DEBUGGING(dbcl) || \ |
| (printf("%s:%s:%s ", debug_cl_name[(dbcl)], progname, __FUNCTION__),0)) \ |
| ? 0 : printf |
| |
| #define __DUMMY_DPRINTF 1 ? (void)0 : (void)((int (*)(char *, ...)) NULL) |
| |
| /* use configure to allow user to compile out debugging messages */ |
| #ifndef NO_TRACE_MSGS |
| #define TRACE __DPRINTF(__DBCL_TRACE) |
| #else |
| #define TRACE __DUMMY_DPRINTF |
| #endif /* NO_TRACE_MSGS */ |
| |
| #ifndef NO_DEBUG_MSGS |
| #define WARN __DPRINTF(__DBCL_WARN) |
| #define FIXME __DPRINTF(__DBCL_FIXME) |
| #else |
| #define WARN __DUMMY_DPRINTF |
| #define FIXME __DUMMY_DPRINTF |
| #endif /* NO_DEBUG_MSGS */ |
| |
| /* define error macro regardless of what is configured */ |
| #define ERR __DPRINTF(__DBCL_ERR) |
| |
| |
| #define TRUE 1 |
| #define FALSE 0 |
| typedef int BOOL; |
| |
| /* Internal definitions for debugging messages(do not use these directly) */ |
| const char * const debug_cl_name[] = { "fixme", "err", "warn", "trace" }; |
| char __debug_msg_enabled[DEBUG_CLASS_COUNT] = {1, 1, 0, 0}; |
| |
| |
| /* Selection masks */ |
| |
| #define S_NOSELECTION 0 |
| #define S_PRIMARY 1 |
| #define S_CLIPBOARD 2 |
| |
| /* Debugging class masks */ |
| |
| #define C_FIXME 1 |
| #define C_ERR 2 |
| #define C_WARN 4 |
| #define C_TRACE 8 |
| |
| /* |
| * Global variables |
| */ |
| |
| static Display *g_display = NULL; |
| static int screen_num; |
| static char *progname; /* name this program was invoked by */ |
| static Window g_win = 0; /* the hidden clipboard server window */ |
| static GC g_gc = 0; |
| |
| static char *g_szOutOfMemory = "Insufficient memory!\n"; |
| |
| /* X selection context info */ |
| static char _CLIPBOARD[] = "CLIPBOARD"; /* CLIPBOARD atom name */ |
| static int g_selectionToAcquire = 0; /* Masks for the selection to be acquired */ |
| static int g_selectionAcquired = 0; /* Contains the current selection masks */ |
| static int g_clearAllSelections = 0; /* If TRUE *all* selections are lost on SelectionClear */ |
| |
| /* Selection cache */ |
| typedef struct tag_CACHEENTRY |
| { |
| Atom target; |
| Atom type; |
| int nFormat; |
| int nElements; |
| void *pData; |
| } CACHEENTRY, *PCACHEENTRY; |
| |
| static PCACHEENTRY g_pPrimaryCache = NULL; /* Primary selection cache */ |
| static PCACHEENTRY g_pClipboardCache = NULL; /* Clipboard selection cache */ |
| static unsigned long g_cPrimaryTargets = 0; /* Number of TARGETS reported by PRIMARY selection */ |
| static unsigned long g_cClipboardTargets = 0; /* Number of TARGETS reported by CLIPBOARD selection */ |
| |
| /* Event names */ |
| static const char * const event_names[] = |
| { |
| "", "", "KeyPress", "KeyRelease", "ButtonPress", "ButtonRelease", |
| "MotionNotify", "EnterNotify", "LeaveNotify", "FocusIn", "FocusOut", |
| "KeymapNotify", "Expose", "GraphicsExpose", "NoExpose", "VisibilityNotify", |
| "CreateNotify", "DestroyNotify", "UnmapNotify", "MapNotify", "MapRequest", |
| "ReparentNotify", "ConfigureNotify", "ConfigureRequest", "GravityNotify", |
| "ResizeRequest", "CirculateNotify", "CirculateRequest", "PropertyNotify", |
| "SelectionClear", "SelectionRequest", "SelectionNotify", "ColormapNotify", |
| "ClientMessage", "MappingNotify" |
| }; |
| |
| |
| /* |
| * Prototypes |
| */ |
| |
| int RunAsDaemon( void ); |
| BOOL Init(int argc, char **argv); |
| void TerminateServer( int ret ); |
| int AcquireSelection(); |
| int CacheDataFormats( Atom SelectionSrc, PCACHEENTRY *ppCache ); |
| void EmptyCache(PCACHEENTRY pCache, int nItems); |
| BOOL FillCacheEntry( Atom SelectionSrc, Atom target, PCACHEENTRY pCacheEntry ); |
| BOOL LookupCacheItem( Atom selection, Atom target, PCACHEENTRY *ppCacheEntry ); |
| void EVENT_ProcessEvent( XEvent *event ); |
| Atom EVENT_SelectionRequest_MULTIPLE( XSelectionRequestEvent *pevent ); |
| void EVENT_SelectionRequest( XSelectionRequestEvent *event, BOOL bIsMultiple ); |
| void EVENT_SelectionClear( XSelectionClearEvent *event ); |
| void EVENT_PropertyNotify( XPropertyEvent *event ); |
| Pixmap DuplicatePixmap(Pixmap pixmap); |
| void TextOut(Window win, GC gc, char *pStr); |
| void getGC(Window win, GC *gc); |
| |
| |
| int main(int argc, char **argv) |
| { |
| XEvent event; |
| |
| if ( RunAsDaemon() == -1 ) |
| { |
| ERR("could not run as daemon\n"); |
| exit(1); |
| } |
| |
| if ( !Init(argc, argv) ) |
| exit(0); |
| |
| /* Acquire the selection after retrieving all clipboard data |
| * owned by the current selection owner. If we were unable to |
| * Acquire any selection, terminate right away. |
| */ |
| if ( AcquireSelection() == S_NOSELECTION ) |
| TerminateServer(0); |
| |
| TRACE("Clipboard server running...\n"); |
| |
| /* Start an X event loop */ |
| while (1) |
| { |
| XNextEvent(g_display, &event); |
| |
| EVENT_ProcessEvent( &event ); |
| } |
| } |
| |
| |
| /************************************************************************** |
| * RunAsDaemon() |
| */ |
| int RunAsDaemon( void ) |
| { |
| int i; |
| |
| /* fork child process and let parent exit ; gets rid of original PID */ |
| switch( fork() ) |
| { |
| case -1: |
| ERR("fork failed\n"); |
| return(-1); |
| case 0: |
| exit(0); |
| break; |
| } |
| |
| /* below is child process w/ new PID, set as session leader */ |
| setsid(); |
| |
| /* close stdin,stdout,stderr and file descriptors (overkill method) */ |
| for ( i = 0; i < 256 ; i++ ) |
| close(i); |
| |
| TRACE("now running as daemon...\n"); |
| return 0; |
| } |
| |
| |
| /************************************************************************** |
| * Init() |
| * Initialize the clipboard server |
| */ |
| BOOL Init(int argc, char **argv) |
| { |
| unsigned int width, height; /* window size */ |
| unsigned int border_width = 4; /* four pixels */ |
| unsigned int display_width, display_height; |
| char *window_name = "Wine Clipboard Server"; |
| XSizeHints *size_hints = NULL; |
| XWMHints *wm_hints = NULL; |
| XClassHint *class_hints = NULL; |
| XTextProperty windowName; |
| char *display_name = NULL; |
| |
| progname = argv[0]; |
| |
| if (!(size_hints = XAllocSizeHints())) |
| { |
| ERR(g_szOutOfMemory); |
| return 0; |
| } |
| if (!(wm_hints = XAllocWMHints())) |
| { |
| ERR(g_szOutOfMemory); |
| return 0; |
| } |
| if (!(class_hints = XAllocClassHint())) |
| { |
| ERR(g_szOutOfMemory); |
| return 0; |
| } |
| |
| /* connect to X server */ |
| if ( (g_display=XOpenDisplay(display_name)) == NULL ) |
| { |
| ERR( "cannot connect to X server %s\n", XDisplayName(display_name)); |
| return 0; |
| } |
| |
| /* get screen size from display structure macro */ |
| screen_num = DefaultScreen(g_display); |
| display_width = DisplayWidth(g_display, screen_num); |
| display_height = DisplayHeight(g_display, screen_num); |
| |
| /* size window with enough room for text */ |
| width = display_width/3, height = display_height/4; |
| |
| /* create opaque window */ |
| g_win = XCreateSimpleWindow(g_display, RootWindow(g_display,screen_num), |
| 0, 0, width, height, border_width, BlackPixel(g_display, |
| screen_num), WhitePixel(g_display,screen_num)); |
| |
| |
| /* Set size hints for window manager. The window manager may |
| * override these settings. */ |
| |
| /* x, y, width, and height hints are now taken from |
| * the actual settings of the window when mapped. Note |
| * that PPosition and PSize must be specified anyway. */ |
| |
| size_hints->flags = PPosition | PSize | PMinSize; |
| size_hints->min_width = 300; |
| size_hints->min_height = 200; |
| |
| /* These calls store window_name into XTextProperty structures |
| * and sets the other fields properly. */ |
| if (XStringListToTextProperty(&window_name, 1, &windowName) == 0) |
| { |
| ERR( "structure allocation for windowName failed.\n"); |
| TerminateServer(-1); |
| } |
| |
| wm_hints->initial_state = NormalState; |
| wm_hints->input = True; |
| wm_hints->flags = StateHint | InputHint; |
| |
| class_hints->res_name = progname; |
| class_hints->res_class = "WineClipSrv"; |
| |
| XSetWMProperties(g_display, g_win, &windowName, NULL, |
| argv, argc, size_hints, wm_hints, |
| class_hints); |
| |
| /* Select event types wanted */ |
| XSelectInput(g_display, g_win, ExposureMask | KeyPressMask | |
| ButtonPressMask | StructureNotifyMask | PropertyChangeMask ); |
| |
| /* create GC for text and drawing */ |
| getGC(g_win, &g_gc); |
| |
| /* Display window */ |
| /* XMapWindow(g_display, g_win); */ |
| |
| /* Set the selections to be acquired from the command line argument. |
| * If none specified, default to all selections we understand. |
| */ |
| if (argc > 1) |
| g_selectionToAcquire = atoi(argv[1]); |
| else |
| g_selectionToAcquire = S_PRIMARY | S_CLIPBOARD; |
| |
| /* Set the debugging class state from the command line argument */ |
| if (argc > 2) |
| { |
| int dbgClasses = atoi(argv[2]); |
| |
| __SET_DEBUGGING(__DBCL_FIXME, dbgClasses & C_FIXME); |
| __SET_DEBUGGING(__DBCL_ERR, dbgClasses & C_ERR); |
| __SET_DEBUGGING(__DBCL_WARN, dbgClasses & C_WARN); |
| __SET_DEBUGGING(__DBCL_TRACE, dbgClasses & C_TRACE); |
| } |
| |
| /* Set the "ClearSelections" state from the command line argument */ |
| if (argc > 3) |
| g_clearAllSelections = atoi(argv[3]); |
| |
| return TRUE; |
| } |
| |
| |
| /************************************************************************** |
| * TerminateServer() |
| */ |
| void TerminateServer( int ret ) |
| { |
| TRACE("Terminating Wine clipboard server...\n"); |
| |
| /* Free Primary and Clipboard selection caches */ |
| EmptyCache(g_pPrimaryCache, g_cPrimaryTargets); |
| EmptyCache(g_pClipboardCache, g_cClipboardTargets); |
| |
| if (g_gc) |
| XFreeGC(g_display, g_gc); |
| |
| if (g_display) |
| XCloseDisplay(g_display); |
| |
| exit(ret); |
| } |
| |
| |
| /************************************************************************** |
| * AcquireSelection() |
| * |
| * Acquire the selection after retrieving all clipboard data owned by |
| * the current selection owner. |
| */ |
| int AcquireSelection() |
| { |
| Atom xaClipboard = XInternAtom(g_display, _CLIPBOARD, False); |
| |
| /* |
| * For all selections we need to acquire, get a list of all targets |
| * supplied by the current selection owner. |
| */ |
| if (g_selectionToAcquire & S_PRIMARY) |
| { |
| TRACE("Acquiring PRIMARY selection...\n"); |
| g_cPrimaryTargets = CacheDataFormats( XA_PRIMARY, &g_pPrimaryCache ); |
| TRACE("Cached %ld formats...\n", g_cPrimaryTargets); |
| } |
| if (g_selectionToAcquire & S_CLIPBOARD) |
| { |
| TRACE("Acquiring CLIPBOARD selection...\n"); |
| g_cClipboardTargets = CacheDataFormats( xaClipboard, &g_pClipboardCache ); |
| TRACE("Cached %ld formats...\n", g_cClipboardTargets); |
| } |
| |
| /* |
| * Now that we have cached the data, we proceed to acquire the selections |
| */ |
| if (g_cPrimaryTargets) |
| { |
| /* Acquire the PRIMARY selection */ |
| while (XGetSelectionOwner(g_display,XA_PRIMARY) != g_win) |
| XSetSelectionOwner(g_display, XA_PRIMARY, g_win, CurrentTime); |
| |
| g_selectionAcquired |= S_PRIMARY; |
| } |
| else |
| TRACE("No PRIMARY targets - ownership not acquired.\n"); |
| |
| if (g_cClipboardTargets) |
| { |
| /* Acquire the CLIPBOARD selection */ |
| while (XGetSelectionOwner(g_display,xaClipboard) != g_win) |
| XSetSelectionOwner(g_display, xaClipboard, g_win, CurrentTime); |
| |
| g_selectionAcquired |= S_CLIPBOARD; |
| } |
| else |
| TRACE("No CLIPBOARD targets - ownership not acquired.\n"); |
| |
| return g_selectionAcquired; |
| } |
| |
| BOOL GetSelectionEvent(Atom SelectionSrc, XEvent *xe) |
| { |
| time_t end_time; |
| |
| /* Set up a 10 second time out */ |
| end_time=time(NULL)+10; |
| |
| do |
| { |
| struct timeval nap; |
| |
| if (XCheckTypedWindowEvent(g_display, g_win, SelectionNotify, xe)) |
| { |
| if( xe->xselection.selection == SelectionSrc ) |
| return TRUE; |
| } |
| |
| if (time(NULL)>end_time) |
| break; |
| |
| /* Sleep a bit to make this busy wait less brutal */ |
| nap.tv_sec = 0; |
| nap.tv_usec = 10; |
| select(0, NULL, NULL, NULL, &nap); |
| } |
| while (TRUE); |
| |
| return FALSE; |
| } |
| |
| /************************************************************************** |
| * CacheDataFormats |
| * |
| * Allocates and 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 CacheDataFormats( Atom SelectionSrc, PCACHEENTRY *ppCache ) |
| { |
| XEvent xe; |
| Atom aTargets; |
| Atom atype=AnyPropertyType; |
| int aformat; |
| unsigned long remain; |
| unsigned long cSelectionTargets = 0; |
| Atom* targetList=NULL; |
| Window ownerSelection = 0; |
| |
| if (!ppCache) |
| return 0; |
| *ppCache = NULL; |
| |
| /* Get the selection owner */ |
| ownerSelection = XGetSelectionOwner(g_display, SelectionSrc); |
| if ( ownerSelection == None ) |
| return cSelectionTargets; |
| |
| /* |
| * Query the selection owner for the TARGETS property |
| */ |
| aTargets = XInternAtom(g_display, "TARGETS", False); |
| |
| TRACE("Requesting TARGETS selection for '%s' (owner=%08x)...\n", |
| XGetAtomName(g_display, SelectionSrc), (unsigned)ownerSelection ); |
| |
| XConvertSelection(g_display, SelectionSrc, aTargets, |
| XInternAtom(g_display, "SELECTION_DATA", False), |
| g_win, CurrentTime); |
| |
| /* |
| * Wait until SelectionNotify is received |
| */ |
| if (!GetSelectionEvent(SelectionSrc, &xe)) |
| return 0; |
| |
| /* Verify that the selection returned a valid TARGETS property */ |
| if ( (xe.xselection.target != aTargets) |
| || (xe.xselection.property == None) ) |
| { |
| TRACE("\tCould not retrieve TARGETS\n"); |
| return cSelectionTargets; |
| } |
| |
| /* Read the TARGETS property contents */ |
| if(XGetWindowProperty(g_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", |
| XGetAtomName(g_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; |
| |
| /* Allocate the selection cache */ |
| *ppCache = (PCACHEENTRY)calloc(cSelectionTargets, sizeof(CACHEENTRY)); |
| |
| /* Cache these formats in the selection cache */ |
| for (i = 0; i < cSelectionTargets; i++) |
| { |
| char *itemFmtName = XGetAtomName(g_display, targetList[i]); |
| |
| TRACE("\tAtom# %d: '%s'\n", i, itemFmtName); |
| |
| /* Populate the cache entry */ |
| if (!FillCacheEntry( SelectionSrc, targetList[i], &((*ppCache)[i]))) |
| ERR("Failed to fill cache entry!\n"); |
| |
| XFree(itemFmtName); |
| } |
| } |
| |
| /* Free the list of targets */ |
| XFree(targetList); |
| } |
| |
| return cSelectionTargets; |
| } |
| |
| /*********************************************************************** |
| * FillCacheEntry |
| * |
| * Populates the specified cache entry |
| */ |
| BOOL FillCacheEntry( Atom SelectionSrc, Atom target, PCACHEENTRY pCacheEntry ) |
| { |
| XEvent xe; |
| Window w; |
| Atom prop, reqType; |
| Atom atype=AnyPropertyType; |
| int aformat; |
| unsigned long nitems,remain,itemSize; |
| long lRequestLength; |
| unsigned char* val=NULL; |
| BOOL bRet = FALSE; |
| |
| TRACE("Requesting %s selection from %s...\n", |
| XGetAtomName(g_display, target), |
| XGetAtomName(g_display, SelectionSrc) ); |
| |
| /* Ask the selection owner to convert the selection to the target format */ |
| XConvertSelection(g_display, SelectionSrc, target, |
| XInternAtom(g_display, "SELECTION_DATA", False), |
| g_win, CurrentTime); |
| |
| /* wait until SelectionNotify is received */ |
| if (!GetSelectionEvent(SelectionSrc,&xe)) |
| return bRet; |
| |
| /* Now proceed to retrieve the actual converted property from |
| * the SELECTION_DATA atom */ |
| |
| w = xe.xselection.requestor; |
| prop = xe.xselection.property; |
| reqType = xe.xselection.target; |
| |
| if(prop == None) |
| { |
| TRACE("\tOwner failed to convert selection!\n"); |
| return bRet; |
| } |
| |
| TRACE("\tretrieving property %s from window %ld into %s\n", |
| XGetAtomName(g_display,reqType), (long)w, XGetAtomName(g_display,prop) ); |
| |
| /* |
| * First request a zero length in order to figure out the request size. |
| */ |
| if(XGetWindowProperty(g_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 ) |
| { |
| XFree(val); |
| val = NULL; |
| } |
| |
| TRACE("\tretrieving %ld bytes...\n", itemSize * aformat/8); |
| lRequestLength = (itemSize * aformat/8)/4 + 1; |
| |
| /* |
| * Retrieve the actual property in the required X format. |
| */ |
| if(XGetWindowProperty(g_display,w,prop,0,lRequestLength,False,AnyPropertyType/*reqType*/, |
| &atype, &aformat, &nitems, &remain, &val) != Success) |
| { |
| WARN("\tcouldn't read property\n"); |
| return bRet; |
| } |
| |
| TRACE("\tType %s,Format %d,nitems %ld,remain %ld,value %s\n", |
| atype ? XGetAtomName(g_display,atype) : NULL, aformat,nitems,remain,val); |
| |
| if (remain) |
| { |
| WARN("\tCouldn't read entire property- selection may be too large! Remain=%ld\n", remain); |
| goto END; |
| } |
| |
| /* |
| * Populate the cache entry |
| */ |
| pCacheEntry->target = target; |
| pCacheEntry->type = atype; |
| pCacheEntry->nFormat = aformat; |
| pCacheEntry->nElements = nitems; |
| |
| if (atype == XA_PIXMAP) |
| { |
| Pixmap *pPixmap = (Pixmap *)val; |
| Pixmap newPixmap = DuplicatePixmap( *pPixmap ); |
| pPixmap = (Pixmap*)calloc(1, sizeof(Pixmap)); |
| *pPixmap = newPixmap; |
| pCacheEntry->pData = pPixmap; |
| } |
| else |
| pCacheEntry->pData = val; |
| |
| END: |
| /* Delete the property on the window now that we are done |
| * This will send a PropertyNotify event to the selection owner. */ |
| XDeleteProperty(g_display,w,prop); |
| |
| return TRUE; |
| } |
| |
| |
| /*********************************************************************** |
| * LookupCacheItem |
| * |
| * Lookup a target atom in the cache and get the matching cache entry |
| */ |
| BOOL LookupCacheItem( Atom selection, Atom target, PCACHEENTRY *ppCacheEntry ) |
| { |
| int i; |
| int nCachetargets = 0; |
| PCACHEENTRY pCache = NULL; |
| Atom xaClipboard = XInternAtom(g_display, _CLIPBOARD, False); |
| |
| /* Locate the cache to be used based on the selection type */ |
| if ( selection == XA_PRIMARY ) |
| { |
| pCache = g_pPrimaryCache; |
| nCachetargets = g_cPrimaryTargets; |
| } |
| else if ( selection == xaClipboard ) |
| { |
| pCache = g_pClipboardCache; |
| nCachetargets = g_cClipboardTargets; |
| } |
| |
| if (!pCache || !ppCacheEntry) |
| return FALSE; |
| |
| *ppCacheEntry = NULL; |
| |
| /* Look for the target item in the cache */ |
| for (i = 0; i < nCachetargets; i++) |
| { |
| if (pCache[i].target == target) |
| { |
| *ppCacheEntry = &pCache[i]; |
| return TRUE; |
| } |
| } |
| |
| return FALSE; |
| } |
| |
| |
| /*********************************************************************** |
| * EmptyCache |
| * |
| * Empties the specified cache |
| */ |
| void EmptyCache(PCACHEENTRY pCache, int nItems) |
| { |
| int i; |
| |
| if (!pCache) |
| return; |
| |
| /* Release all items in the cache */ |
| for (i = 0; i < nItems; i++) |
| { |
| if (pCache[i].target && pCache[i].pData) |
| { |
| /* If we have a Pixmap, free it first */ |
| if (pCache[i].target == XA_PIXMAP || pCache[i].target == XA_BITMAP) |
| { |
| Pixmap *pPixmap = (Pixmap *)pCache[i].pData; |
| |
| TRACE("Freeing %s (handle=%ld)...\n", |
| XGetAtomName(g_display, pCache[i].target), *pPixmap); |
| |
| XFreePixmap(g_display, *pPixmap); |
| |
| /* Free the cached data item (allocated by us) */ |
| free(pCache[i].pData); |
| } |
| else |
| { |
| TRACE("Freeing %s (%p)...\n", |
| XGetAtomName(g_display, pCache[i].target), pCache[i].pData); |
| |
| /* Free the cached data item (allocated by X) */ |
| XFree(pCache[i].pData); |
| } |
| } |
| } |
| |
| /* Destroy the cache */ |
| free(pCache); |
| } |
| |
| |
| /*********************************************************************** |
| * EVENT_ProcessEvent |
| * |
| * Process an X event. |
| */ |
| void EVENT_ProcessEvent( XEvent *event ) |
| { |
| /* |
| TRACE(" event %s for Window %08lx\n", event_names[event->type], event->xany.window ); |
| */ |
| |
| switch (event->type) |
| { |
| case Expose: |
| /* don't draw the window */ |
| if (event->xexpose.count != 0) |
| break; |
| |
| /* Output something */ |
| TextOut(g_win, g_gc, "Click here to terminate"); |
| break; |
| |
| case ConfigureNotify: |
| break; |
| |
| case ButtonPress: |
| /* fall into KeyPress (no break) */ |
| case KeyPress: |
| TerminateServer(1); |
| break; |
| |
| case SelectionRequest: |
| EVENT_SelectionRequest( (XSelectionRequestEvent *)event, FALSE ); |
| break; |
| |
| case SelectionClear: |
| EVENT_SelectionClear( (XSelectionClearEvent*)event ); |
| break; |
| |
| case PropertyNotify: |
| #if 0 |
| EVENT_PropertyNotify( (XPropertyEvent *)event ); |
| #endif |
| break; |
| |
| default: /* ignore all other events */ |
| break; |
| |
| } /* end switch */ |
| |
| } |
| |
| |
| /*********************************************************************** |
| * EVENT_SelectionRequest_MULTIPLE |
| * Service a MULTIPLE selection request event |
| * rprop contains a list of (target,property) atom pairs. |
| * The first atom names a target and the second names a property. |
| * The effect is as if we have received a sequence of SelectionRequest events |
| * (one for each atom pair) except that: |
| * 1. We reply with a SelectionNotify only when all the requested conversions |
| * have been performed. |
| * 2. If we fail to convert the target named by an atom in the MULTIPLE property, |
| * we replace the atom in the property by None. |
| */ |
| Atom EVENT_SelectionRequest_MULTIPLE( XSelectionRequestEvent *pevent ) |
| { |
| Atom rprop; |
| Atom atype=AnyPropertyType; |
| int aformat; |
| unsigned long remain; |
| Atom* targetPropList=NULL; |
| unsigned long cTargetPropList = 0; |
| /* Atom xAtomPair = XInternAtom(g_display, "ATOM_PAIR", False); */ |
| |
| /* If the specified property is None the requestor is an obsolete client. |
| * We support these by using the specified target atom as the reply property. |
| */ |
| rprop = pevent->property; |
| if( rprop == None ) |
| rprop = pevent->target; |
| if (!rprop) |
| goto END; |
| |
| /* Read the MULTIPLE property contents. This should contain a list of |
| * (target,property) atom pairs. |
| */ |
| if(XGetWindowProperty(g_display, pevent->requestor, rprop, |
| 0, 0x3FFF, False, AnyPropertyType, &atype, &aformat, |
| &cTargetPropList, &remain, (unsigned char**)&targetPropList) != Success) |
| TRACE("\tCouldn't read MULTIPLE property\n"); |
| else |
| { |
| TRACE("\tType %s,Format %d,nItems %ld, Remain %ld\n", |
| XGetAtomName(g_display,atype),aformat,cTargetPropList,remain); |
| |
| /* |
| * Make sure we got what we expect. |
| * NOTE: According to the X-ICCCM Version 2.0 documentation the property sent |
| * in a MULTIPLE selection request should be of type ATOM_PAIR. |
| * However some X apps(such as XPaint) are not compliant with this and return |
| * a user defined atom in atype when XGetWindowProperty is called. |
| * The data *is* an atom pair but is not denoted as such. |
| */ |
| if(aformat == 32 /* atype == xAtomPair */ ) |
| { |
| int i; |
| |
| /* Iterate through the ATOM_PAIR list and execute a SelectionRequest |
| * for each (target,property) pair */ |
| |
| for (i = 0; i < cTargetPropList; i+=2) |
| { |
| char *targetName = XGetAtomName(g_display, targetPropList[i]); |
| char *propName = XGetAtomName(g_display, targetPropList[i+1]); |
| XSelectionRequestEvent event; |
| |
| TRACE("MULTIPLE(%d): Target='%s' Prop='%s'\n", i/2, targetName, propName); |
| XFree(targetName); |
| XFree(propName); |
| |
| /* We must have a non "None" property to service a MULTIPLE target atom */ |
| if ( !targetPropList[i+1] ) |
| { |
| TRACE("\tMULTIPLE(%d): Skipping target with empty property!\n", i); |
| continue; |
| } |
| |
| /* Set up an XSelectionRequestEvent for this (target,property) pair */ |
| memcpy( &event, pevent, sizeof(XSelectionRequestEvent) ); |
| event.target = targetPropList[i]; |
| event.property = targetPropList[i+1]; |
| |
| /* Fire a SelectionRequest, informing the handler that we are processing |
| * a MULTIPLE selection request event. |
| */ |
| EVENT_SelectionRequest( &event, TRUE ); |
| } |
| } |
| |
| /* Free the list of targets/properties */ |
| XFree(targetPropList); |
| } |
| |
| END: |
| return rprop; |
| } |
| |
| |
| /*********************************************************************** |
| * EVENT_SelectionRequest |
| * Process an event selection request event. |
| * The bIsMultiple flag is used to signal when EVENT_SelectionRequest is called |
| * recursively while servicing a "MULTIPLE" selection target. |
| * |
| */ |
| void EVENT_SelectionRequest( XSelectionRequestEvent *event, BOOL bIsMultiple ) |
| { |
| XSelectionEvent result; |
| Atom rprop = None; |
| Window request = event->requestor; |
| Atom xaMultiple = XInternAtom(g_display, "MULTIPLE", False); |
| PCACHEENTRY pCacheEntry = NULL; |
| void *pData = NULL; |
| Pixmap pixmap; |
| |
| /* If the specified property is None the requestor is an obsolete client. |
| * We support these by using the specified target atom as the reply property. |
| */ |
| rprop = event->property; |
| if( rprop == None ) |
| rprop = event->target; |
| |
| TRACE("Request for %s in selection %s\n", |
| XGetAtomName(g_display, event->target), XGetAtomName(g_display, event->selection)); |
| |
| /* Handle MULTIPLE requests - rprop contains a list of (target, property) atom pairs */ |
| if(event->target == xaMultiple) |
| { |
| /* MULTIPLE selection request - will call us back recursively */ |
| rprop = EVENT_SelectionRequest_MULTIPLE( event ); |
| goto END; |
| } |
| |
| /* Lookup the requested target property in the cache */ |
| if ( !LookupCacheItem(event->selection, event->target, &pCacheEntry) ) |
| { |
| TRACE("Item not available in cache!\n"); |
| goto END; |
| } |
| |
| /* Update the X property */ |
| TRACE("\tUpdating property %s...\n", XGetAtomName(g_display, rprop)); |
| |
| /* If we have a request for a pixmap, return a duplicate */ |
| |
| if(event->target == XA_PIXMAP || event->target == XA_BITMAP) |
| { |
| Pixmap *pPixmap = (Pixmap *)pCacheEntry->pData; |
| pixmap = DuplicatePixmap( *pPixmap ); |
| pData = &pixmap; |
| } |
| else |
| pData = pCacheEntry->pData; |
| |
| XChangeProperty(g_display, request, rprop, |
| pCacheEntry->type, pCacheEntry->nFormat, PropModeReplace, |
| (unsigned char *)pData, pCacheEntry->nElements); |
| |
| END: |
| if( rprop == None) |
| TRACE("\tRequest ignored\n"); |
| |
| /* reply to sender |
| * SelectionNotify should be sent only at the end of a MULTIPLE request |
| */ |
| if ( !bIsMultiple ) |
| { |
| result.type = SelectionNotify; |
| result.display = g_display; |
| result.requestor = request; |
| result.selection = event->selection; |
| result.property = rprop; |
| result.target = event->target; |
| result.time = event->time; |
| TRACE("Sending SelectionNotify event...\n"); |
| XSendEvent(g_display,event->requestor,False,NoEventMask,(XEvent*)&result); |
| } |
| } |
| |
| |
| /*********************************************************************** |
| * EVENT_SelectionClear |
| * We receive this event when another client grabs the X selection. |
| * If we lost both PRIMARY and CLIPBOARD we must terminate. |
| */ |
| void EVENT_SelectionClear( XSelectionClearEvent *event ) |
| { |
| Atom xaClipboard = XInternAtom(g_display, _CLIPBOARD, False); |
| |
| TRACE("()\n"); |
| |
| /* 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 ( g_clearAllSelections || (event->selection == xaClipboard) ) |
| { |
| TRACE("Lost CLIPBOARD (+PRIMARY) selection\n"); |
| |
| /* We really lost CLIPBOARD but want to voluntarily lose PRIMARY */ |
| if ( (event->selection == xaClipboard) |
| && (g_selectionAcquired & S_PRIMARY) ) |
| { |
| XSetSelectionOwner(g_display, XA_PRIMARY, None, CurrentTime); |
| } |
| |
| /* We really lost PRIMARY but want to voluntarily lose CLIPBOARD */ |
| if ( (event->selection == XA_PRIMARY) |
| && (g_selectionAcquired & S_CLIPBOARD) ) |
| { |
| XSetSelectionOwner(g_display, xaClipboard, None, CurrentTime); |
| } |
| |
| g_selectionAcquired = S_NOSELECTION; /* Clear the selection masks */ |
| } |
| else if (event->selection == XA_PRIMARY) |
| { |
| TRACE("Lost PRIMARY selection...\n"); |
| g_selectionAcquired &= ~S_PRIMARY; /* Clear the PRIMARY flag */ |
| } |
| |
| /* Once we lose all our selections we have nothing more to do */ |
| if (g_selectionAcquired == S_NOSELECTION) |
| TerminateServer(1); |
| } |
| |
| /*********************************************************************** |
| * EVENT_PropertyNotify |
| * We use this to release resources like Pixmaps when a selection |
| * client no longer needs them. |
| */ |
| void EVENT_PropertyNotify( XPropertyEvent *event ) |
| { |
| TRACE("()\n"); |
| |
| /* Check if we have any resources to free */ |
| |
| switch(event->state) |
| { |
| case PropertyDelete: |
| { |
| TRACE("\tPropertyDelete for atom %s on window %ld\n", |
| XGetAtomName(event->display, event->atom), (long)event->window); |
| |
| /* FreeResources( event->atom ); */ |
| break; |
| } |
| |
| case PropertyNewValue: |
| { |
| TRACE("\tPropertyNewValue for atom %s on window %ld\n\n", |
| XGetAtomName(event->display, event->atom), (long)event->window); |
| break; |
| } |
| |
| default: |
| break; |
| } |
| } |
| |
| /*********************************************************************** |
| * DuplicatePixmap |
| */ |
| Pixmap DuplicatePixmap(Pixmap pixmap) |
| { |
| Pixmap newPixmap; |
| XImage *xi; |
| Window root; |
| int x,y; /* Unused */ |
| unsigned border_width; /* Unused */ |
| unsigned int depth, width, height; |
| |
| TRACE("\t() Pixmap=%ld\n", (long)pixmap); |
| |
| /* Get the Pixmap dimensions and bit depth */ |
| if ( 0 == XGetGeometry(g_display, pixmap, &root, &x, &y, &width, &height, |
| &border_width, &depth) ) |
| return 0; |
| |
| TRACE("\tPixmap properties: width=%d, height=%d, depth=%d\n", |
| width, height, depth); |
| |
| newPixmap = XCreatePixmap(g_display, g_win, width, height, depth); |
| |
| xi = XGetImage(g_display, pixmap, 0, 0, width, height, AllPlanes, XYPixmap); |
| |
| XPutImage(g_display, newPixmap, g_gc, xi, 0, 0, 0, 0, width, height); |
| |
| XDestroyImage(xi); |
| |
| TRACE("\t() New Pixmap=%ld\n", (long)newPixmap); |
| return newPixmap; |
| } |
| |
| /*********************************************************************** |
| * getGC |
| * Get a GC to use for drawing |
| */ |
| void getGC(Window win, GC *gc) |
| { |
| unsigned long valuemask = 0; /* ignore XGCvalues and use defaults */ |
| XGCValues values; |
| unsigned int line_width = 6; |
| int line_style = LineOnOffDash; |
| int cap_style = CapRound; |
| int join_style = JoinRound; |
| int dash_offset = 0; |
| static char dash_list[] = {12, 24}; |
| int list_length = 2; |
| |
| /* Create default Graphics Context */ |
| *gc = XCreateGC(g_display, win, valuemask, &values); |
| |
| /* specify black foreground since default window background is |
| * white and default foreground is undefined. */ |
| XSetForeground(g_display, *gc, BlackPixel(g_display,screen_num)); |
| |
| /* set line attributes */ |
| XSetLineAttributes(g_display, *gc, line_width, line_style, |
| cap_style, join_style); |
| |
| /* set dashes */ |
| XSetDashes(g_display, *gc, dash_offset, dash_list, list_length); |
| } |
| |
| |
| /*********************************************************************** |
| * TextOut |
| */ |
| void TextOut(Window win, GC gc, char *pStr) |
| { |
| int y_offset, x_offset; |
| |
| y_offset = 10; |
| x_offset = 2; |
| |
| /* output text, centered on each line */ |
| XDrawString(g_display, win, gc, x_offset, y_offset, pStr, |
| strlen(pStr)); |
| } |
