Added clipboard server.

Makefile.in

@@ -258,6 +258,8 @@ install_lib: dummy
 	    $(INSTALL_DATA) $(LIB_TARGET) $(libdir); \
 	    if [ $(LIB_TARGET) = libwine.so.1.0 ]; then $(LDCONFIG); fi \
 	fi
+	[ -d $(bindir) ] || $(MKDIR) $(bindir)
+	$(INSTALL_PROGRAM) windows/x11drv/wineclipsrv $(bindir)/wineclipsrv
 
 uninstall_lib: dummy
 	cd $(libdir); $(RM) $(LIB_TARGET) libwine.a libwine.so wine.sym

windows/x11drv/.cvsignore

 Makefile
+wineclipsrv

windows/x11drv/Makefile.in

@@ -16,6 +16,13 @@ C_SRCS = \
 	mouse.c \
 	wnd.c
 
+PROGRAMS = wineclipsrv
+
+all: $(MODULE).o $(PROGRAMS)
+
+wineclipsrv: wineclipsrv.c
+	$(CC) $(ALLCFLAGS) -o wineclipsrv $(SRCDIR)/wineclipsrv.c $(X_LIBS) $(XLIB) $(LIBS)
+
 all: $(MODULE).o
 
 @MAKE_RULES@

windows/x11drv/wineclipsrv.c

+/*
+ *  Wine Clipboard Server
+ *
+ *      Copyright 1999  Noel Borthwick
+ *
+ * NOTES:
+ *    This file contains the implementation for the Clipboard server
+ *
+ * TODO:
+ *
+ */
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/Xos.h>
+#include <X11/Xatom.h>
+#include <stdio.h>
+
+/*  Lightweight debug definitions */
+
+#define __DPRINTF(dbname) (printf("%s:%s:%s ", dbname, progname, __FUNCTION__),0) ? 0 : printf
+#define __DUMMY_DPRINTF 1 ? (void)0 : (void)((int (*)(char *, ...)) NULL)
+
+#ifndef NO_TRACE_MSGS
+  #define TRACE        __DPRINTF("TRACE")
+#else
+  #define TRACE        __DUMMY_DPRINTF
+#endif /* NO_TRACE_MSGS */
+
+#ifndef NO_DEBUG_MSGS
+  #define WARN         __DPRINTF("WARN")
+  #define FIXME        __DPRINTF("FIXME")
+#else
+  #define WARN         __DUMMY_DPRINTF
+  #define FIXME        __DUMMY_DPRINTF
+#endif /* NO_DEBUG_MSGS */
+
+#define ERR        __DPRINTF("ERROR")
+
+
+#define TRUE 1
+#define FALSE 0
+typedef int BOOL;
+
+/* Selection masks */
+
+#define S_NOSELECTION    0
+#define S_PRIMARY        1
+#define S_CLIPBOARD      2
+
+
+/*
+ * 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 char FMT_PREFIX[] = "<WCF>";            /* Prefix for windows specific formats */
+static int  g_selectionToAcquire = 0;          /* Masks for the selection to be acquired */
+static int  g_selectionAcquired = 0;           /* Contains the current selection masks */
+
+/* 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 
+ */
+
+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);
+
+
+void main(int argc, char **argv)
+{
+    XEvent event;
+    unsigned int width, height;	/* window size */
+
+    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);
+    
+    /* Start an X event loop */
+    while (1)
+    {
+        XNextEvent(g_display, &event);
+        
+        EVENT_ProcessEvent( &event );
+    }
+}
+
+
+/**************************************************************************
+ *		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;
+        
+    TRACE("Clipboard server running...\n");
+}
+
+
+/**************************************************************************
+ *		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 );
+        if (g_cPrimaryTargets)
+            XSetSelectionOwner(g_display, XA_PRIMARY, g_win, CurrentTime);
+        else
+            TRACE("No PRIMARY targets - ownership not acquired.\n");
+    }
+    if (g_selectionToAcquire & S_CLIPBOARD)
+    {
+        TRACE("Acquiring CLIPBOARD selection...\n");
+        g_cClipboardTargets = CacheDataFormats( xaClipboard, &g_pClipboardCache );
+        
+        if (g_cClipboardTargets)
+            XSetSelectionOwner(g_display, xaClipboard, g_win, CurrentTime);
+        else
+            TRACE("No CLIPBOARD targets - ownership not acquired.\n");
+    }
+
+    /* Remember the acquired selections */
+    if( XGetSelectionOwner(g_display,XA_PRIMARY) == g_win )
+        g_selectionAcquired |= S_PRIMARY;
+    if( XGetSelectionOwner(g_display,xaClipboard) == g_win )
+        g_selectionAcquired |= S_CLIPBOARD;
+
+    return g_selectionAcquired;
+}
+
+/**************************************************************************
+ *		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
+     */
+    while( TRUE )
+    {
+       if( XCheckTypedWindowEvent(g_display, g_win, SelectionNotify, &xe) )
+           if( xe.xselection.selection == SelectionSrc )
+               break;
+    }
+
+    /* 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!");
+
+              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 */
+    while( TRUE )
+    {
+       if( XCheckTypedWindowEvent(g_display, g_win, SelectionNotify, &xe) )
+           if( xe.xselection.selection == SelectionSrc )
+               break;
+    }
+
+    /* 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)
+        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 (0x%x)...\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:
+          EVENT_PropertyNotify( (XPropertyEvent *)event );
+          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!", 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;
+  BOOL            couldOpen = FALSE;
+  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...", 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 (event->selection == XA_PRIMARY)
+  {
+      g_selectionAcquired &= ~S_PRIMARY;     /* Clear the PRIMARY flag */
+      TRACE("Lost PRIMARY selection...\n");
+  }
+  else if (event->selection == xaClipboard)
+  {
+      g_selectionAcquired &= ~S_CLIPBOARD;   /* Clear the CLIPBOARD flag */
+      TRACE("Lost CLIPBOARD selection...\n");
+  }
+  
+  /* 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=%ul\n", 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=%ul\n", 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));
+}