diff --git a/dlls/x11drv/clipboard.c b/dlls/x11drv/clipboard.c
index ae3bc85..7797c9b 100644
--- a/dlls/x11drv/clipboard.c
+++ b/dlls/x11drv/clipboard.c
@@ -107,6 +107,35 @@
     UINT flags;
 } CLIPBOARDINFO, *LPCLIPBOARDINFO;
 
+typedef struct tagWINE_CLIPDATA {
+    UINT        wFormatID;
+    HANDLE16    hData16;
+    HANDLE      hData32;
+    UINT        drvData;
+    UINT        wFlags;
+    struct tagWINE_CLIPDATA *PrevData;
+    struct tagWINE_CLIPDATA *NextData;
+} WINE_CLIPDATA, *LPWINE_CLIPDATA;
+
+typedef HANDLE (*DRVEXPORTFUNC)(Window requestor, Atom aTarget, Atom rprop,
+    LPWINE_CLIPDATA lpData, LPDWORD lpBytes);
+typedef HANDLE (*DRVIMPORTFUNC)(LPBYTE hData, UINT cBytes);
+
+typedef struct tagWINE_CLIPFORMAT {
+    UINT        wFormatID;
+    LPCWSTR     Name;
+    UINT        drvData;
+    UINT        wFlags;
+    DRVIMPORTFUNC  lpDrvImportFunc;
+    DRVEXPORTFUNC  lpDrvExportFunc;
+    struct tagWINE_CLIPFORMAT *PrevFormat;
+    struct tagWINE_CLIPFORMAT *NextFormat;
+} WINE_CLIPFORMAT, *LPWINE_CLIPFORMAT;
+
+#define CF_FLAG_BUILTINFMT   1 /* Built-in windows format */
+#define CF_FLAG_UNOWNED      2 /* cached data is not owned */
+#define CF_FLAG_SYNTHESIZED  8 /* Implicitly converted data */
+
 static int selectionAcquired = 0;              /* Contains the current selection masks */
 static Window selectionWindow = None;          /* The top level X window which owns the selection */
 static BOOL usePrimary = FALSE;                /* Use primary selection in additon to the clipboard selection */
@@ -115,20 +144,20 @@
 INT X11DRV_RegisterClipboardFormat(LPCWSTR FormatName);
 void X11DRV_EmptyClipboard(BOOL keepunowned);
 void X11DRV_EndClipboardUpdate(void);
-HANDLE X11DRV_CLIPBOARD_ImportClipboardData(LPBYTE lpdata, UINT cBytes);
-HANDLE X11DRV_CLIPBOARD_ImportEnhMetaFile(LPBYTE lpdata, UINT cBytes);
-HANDLE X11DRV_CLIPBOARD_ImportMetaFilePict(LPBYTE lpdata, UINT cBytes);
-HANDLE X11DRV_CLIPBOARD_ImportXAPIXMAP(LPBYTE lpdata, UINT cBytes);
-HANDLE X11DRV_CLIPBOARD_ImportXAString(LPBYTE lpdata, UINT cBytes);
-HANDLE X11DRV_CLIPBOARD_ExportClipboardData(Window requestor, Atom aTarget,
+static HANDLE X11DRV_CLIPBOARD_ImportClipboardData(LPBYTE lpdata, UINT cBytes);
+static HANDLE X11DRV_CLIPBOARD_ImportEnhMetaFile(LPBYTE lpdata, UINT cBytes);
+static HANDLE X11DRV_CLIPBOARD_ImportMetaFilePict(LPBYTE lpdata, UINT cBytes);
+static HANDLE X11DRV_CLIPBOARD_ImportXAPIXMAP(LPBYTE lpdata, UINT cBytes);
+static HANDLE X11DRV_CLIPBOARD_ImportXAString(LPBYTE lpdata, UINT cBytes);
+static HANDLE X11DRV_CLIPBOARD_ExportClipboardData(Window requestor, Atom aTarget,
     Atom rprop, LPWINE_CLIPDATA lpData, LPDWORD lpBytes);
-HANDLE X11DRV_CLIPBOARD_ExportString(Window requestor, Atom aTarget,
+static HANDLE X11DRV_CLIPBOARD_ExportString(Window requestor, Atom aTarget,
     Atom rprop, LPWINE_CLIPDATA lpData, LPDWORD lpBytes);
-HANDLE X11DRV_CLIPBOARD_ExportXAPIXMAP(Window requestor, Atom aTarget,
+static HANDLE X11DRV_CLIPBOARD_ExportXAPIXMAP(Window requestor, Atom aTarget,
     Atom rprop, LPWINE_CLIPDATA lpdata, LPDWORD lpBytes);
-HANDLE X11DRV_CLIPBOARD_ExportMetaFilePict(Window requestor, Atom aTarget,
+static HANDLE X11DRV_CLIPBOARD_ExportMetaFilePict(Window requestor, Atom aTarget,
     Atom rprop, LPWINE_CLIPDATA lpdata, LPDWORD lpBytes);
-HANDLE X11DRV_CLIPBOARD_ExportEnhMetaFile(Window requestor, Atom aTarget,
+static HANDLE X11DRV_CLIPBOARD_ExportEnhMetaFile(Window requestor, Atom aTarget,
     Atom rprop, LPWINE_CLIPDATA lpdata, LPDWORD lpBytes);
 static WINE_CLIPFORMAT *X11DRV_CLIPBOARD_InsertClipboardFormat(LPCWSTR FormatName, Atom prop);
 static BOOL X11DRV_CLIPBOARD_ReadSelection(LPWINE_CLIPFORMAT lpData, Window w, Atom prop);
@@ -143,6 +172,7 @@
 static BOOL X11DRV_CLIPBOARD_RenderSynthesizedFormat(LPWINE_CLIPDATA lpData);
 static BOOL X11DRV_CLIPBOARD_RenderSynthesizedDIB(void);
 static BOOL X11DRV_CLIPBOARD_RenderSynthesizedBitmap(void);
+static void X11DRV_HandleSelectionRequest( HWND hWnd, XSelectionRequestEvent *event, BOOL bIsMultiple );
 
 /* Clipboard formats
  * WARNING: This data ordering is dependent on the WINE_CLIPFORMAT structure
@@ -2574,3 +2604,355 @@
 
     TRACE("%d formats added to cached data\n", ClipDataCount - count);
 }
+
+
+/***********************************************************************
+ *           add_targets
+ *
+ * Utility function for X11DRV_SelectionRequest_TARGETS.
+ */
+static BOOL add_targets(Atom* targets, unsigned long cTargets, Atom prop)
+{
+    unsigned int i;
+    BOOL bExists;
+
+    /* Scan through what we have so far to avoid duplicates */
+    for (i = 0, bExists = FALSE; i < cTargets; i++)
+    {
+        if (targets[i] == prop)
+        {
+            bExists = TRUE;
+            break;
+        }
+    }
+
+    if (!bExists)
+        targets[cTargets] = prop;
+
+    return !bExists;
+}
+
+
+/***********************************************************************
+ *           X11DRV_SelectionRequest_TARGETS
+ *  Service a TARGETS selection request event
+ */
+static Atom X11DRV_SelectionRequest_TARGETS( Display *display, Window requestor,
+                                             Atom target, Atom rprop )
+{
+    Atom* targets;
+    UINT wFormat;
+    UINT alias;
+    ULONG cTargets;
+    LPWINE_CLIPFORMAT lpFormat;
+
+    /*
+     * Count the number of items we wish to expose as selection targets.
+     * We include the TARGETS item, and property aliases
+     */
+    cTargets = X11DRV_CountClipboardFormats() + 1;
+
+    for (wFormat = 0; (wFormat = X11DRV_EnumClipboardFormats(wFormat));)
+    {
+        lpFormat = X11DRV_CLIPBOARD_LookupFormat(wFormat);
+
+        if (lpFormat)
+        {
+            if (!lpFormat->lpDrvExportFunc)
+                cTargets--;
+
+            if (X11DRV_CLIPBOARD_LookupPropertyAlias(lpFormat->drvData))
+                cTargets++;
+        }
+        /* else most likely unregistered format such as CF_PRIVATE or CF_GDIOBJ */
+    }
+
+    TRACE(" found %ld formats\n", cTargets);
+
+    /* Allocate temp buffer */
+    targets = (Atom*)HeapAlloc( GetProcessHeap(), 0, cTargets * sizeof(Atom));
+    if(targets == NULL)
+        return None;
+
+    /* Create TARGETS property list (First item in list is TARGETS itself) */
+    for (targets[0] = x11drv_atom(TARGETS), cTargets = 1, wFormat = 0;
+         (wFormat = X11DRV_EnumClipboardFormats(wFormat));)
+    {
+        lpFormat = X11DRV_CLIPBOARD_LookupFormat(wFormat);
+
+        if (lpFormat)
+        {
+            if (lpFormat->lpDrvExportFunc)
+            {
+                if (add_targets(targets, cTargets, lpFormat->drvData))
+                    cTargets++;
+            }
+
+            /* Check if any alias should be listed */
+            alias = X11DRV_CLIPBOARD_LookupPropertyAlias(lpFormat->drvData);
+            if (alias)
+            {
+                if (add_targets(targets, cTargets, alias))
+                    cTargets++;
+            }
+        }
+    }
+
+    wine_tsx11_lock();
+
+    if (TRACE_ON(clipboard))
+    {
+        unsigned int i;
+        for ( i = 0; i < cTargets; i++)
+        {
+            if (targets[i])
+            {
+                char *itemFmtName = XGetAtomName(display, targets[i]);
+                TRACE("\tAtom# %d:  Property %ld Type %s\n", i, targets[i], itemFmtName);
+                XFree(itemFmtName);
+            }
+        }
+    }
+
+    /* We may want to consider setting the type to xaTargets instead,
+     * in case some apps expect this instead of XA_ATOM */
+    XChangeProperty(display, requestor, rprop, XA_ATOM, 32,
+                    PropModeReplace, (unsigned char *)targets, cTargets);
+    wine_tsx11_unlock();
+
+    HeapFree(GetProcessHeap(), 0, targets);
+
+    return rprop;
+}
+
+
+/***********************************************************************
+ *           X11DRV_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.
+ */
+static Atom X11DRV_SelectionRequest_MULTIPLE( HWND hWnd, XSelectionRequestEvent *pevent )
+{
+    Display *display = pevent->display;
+    Atom           rprop;
+    Atom           atype=AnyPropertyType;
+    int            aformat;
+    unsigned long  remain;
+    Atom*          targetPropList=NULL;
+    unsigned long  cTargetPropList = 0;
+
+    /* 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)
+        return 0;
+
+    /* Read the MULTIPLE property contents. This should contain a list of
+     * (target,property) atom pairs.
+     */
+    wine_tsx11_lock();
+    if(XGetWindowProperty(display, pevent->requestor, rprop,
+                          0, 0x3FFF, False, AnyPropertyType, &atype,&aformat,
+                          &cTargetPropList, &remain,
+                          (unsigned char**)&targetPropList) != Success)
+    {
+        wine_tsx11_unlock();
+        TRACE("\tCouldn't read MULTIPLE property\n");
+    }
+    else
+    {
+        TRACE("\tType %s,Format %d,nItems %ld, Remain %ld\n",
+              XGetAtomName(display, atype), aformat, cTargetPropList, remain);
+        wine_tsx11_unlock();
+
+        /*
+         * 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 */ )
+        {
+            unsigned int i;
+
+            /* Iterate through the ATOM_PAIR list and execute a SelectionRequest
+             * for each (target,property) pair */
+
+            for (i = 0; i < cTargetPropList; i+=2)
+            {
+                XSelectionRequestEvent event;
+
+                if (TRACE_ON(clipboard))
+                {
+                    char *targetName, *propName;
+                    wine_tsx11_lock();
+                    targetName = XGetAtomName(display, targetPropList[i]);
+                    propName = XGetAtomName(display, targetPropList[i+1]);
+                    TRACE("MULTIPLE(%d): Target='%s' Prop='%s'\n",
+                          i/2, targetName, propName);
+                    XFree(targetName);
+                    XFree(propName);
+                    wine_tsx11_unlock();
+                }
+
+                /* 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.
+                 */
+                X11DRV_HandleSelectionRequest( hWnd, &event, TRUE );
+            }
+        }
+
+        /* Free the list of targets/properties */
+        wine_tsx11_lock();
+        XFree(targetPropList);
+        wine_tsx11_unlock();
+    }
+
+    return rprop;
+}
+
+
+/***********************************************************************
+ *           X11DRV_HandleSelectionRequest
+ *  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.
+ *
+ *  Note: We only receive this event when WINE owns the X selection
+ */
+static void X11DRV_HandleSelectionRequest( HWND hWnd, XSelectionRequestEvent *event, BOOL bIsMultiple )
+{
+    Display *display = event->display;
+    XSelectionEvent result;
+    Atom rprop = None;
+    Window request = event->requestor;
+
+    TRACE("\n");
+
+    /*
+     * We can only handle the selection request if :
+     * The selection is PRIMARY or CLIPBOARD, AND we can successfully open the clipboard.
+     * Don't do these checks or open the clipboard while recursively processing MULTIPLE,
+     * since this has been already done.
+     */
+    if ( !bIsMultiple )
+    {
+        if (((event->selection != XA_PRIMARY) && (event->selection != x11drv_atom(CLIPBOARD))))
+            goto END;
+    }
+
+    /* 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;
+
+    if(event->target == x11drv_atom(TARGETS))  /*  Return a list of all supported targets */
+    {
+        /* TARGETS selection request */
+        rprop = X11DRV_SelectionRequest_TARGETS( display, request, event->target, rprop );
+    }
+    else if(event->target == x11drv_atom(MULTIPLE))  /*  rprop contains a list of (target, property) atom pairs */
+    {
+        /* MULTIPLE selection request */
+        rprop = X11DRV_SelectionRequest_MULTIPLE( hWnd, event );
+    }
+    else
+    {
+        LPWINE_CLIPFORMAT lpFormat = X11DRV_CLIPBOARD_LookupProperty(event->target);
+
+        if (!lpFormat)
+            lpFormat = X11DRV_CLIPBOARD_LookupAliasProperty(event->target);
+
+        if (lpFormat && lpFormat->lpDrvExportFunc)
+        {
+            LPWINE_CLIPDATA lpData = X11DRV_CLIPBOARD_LookupData(lpFormat->wFormatID);
+
+            if (lpData)
+            {
+                unsigned char* lpClipData;
+                DWORD cBytes;
+                HANDLE hClipData = lpFormat->lpDrvExportFunc(request, event->target,
+                                                             rprop, lpData, &cBytes);
+
+                if (hClipData && (lpClipData = GlobalLock(hClipData)))
+                {
+                    TRACE("\tUpdating property %s, %ld bytes\n", debugstr_w(lpFormat->Name), cBytes);
+
+                    wine_tsx11_lock();
+                    XChangeProperty(display, request, rprop, event->target,
+                                    8, PropModeReplace, (unsigned char *)lpClipData, cBytes);
+                    wine_tsx11_unlock();
+
+                    GlobalUnlock(hClipData);
+                    GlobalFree(hClipData);
+                }
+            }
+        }
+    }
+
+END:
+    /* reply to sender
+     * SelectionNotify should be sent only at the end of a MULTIPLE request
+     */
+    if ( !bIsMultiple )
+    {
+        result.type = SelectionNotify;
+        result.display = display;
+        result.requestor = request;
+        result.selection = event->selection;
+        result.property = rprop;
+        result.target = event->target;
+        result.time = event->time;
+        TRACE("Sending SelectionNotify event...\n");
+        wine_tsx11_lock();
+        XSendEvent(display,event->requestor,False,NoEventMask,(XEvent*)&result);
+        wine_tsx11_unlock();
+    }
+}
+
+
+/***********************************************************************
+ *           X11DRV_SelectionRequest
+ */
+void X11DRV_SelectionRequest( HWND hWnd, XSelectionRequestEvent *event )
+{
+    if (!hWnd) return;
+    X11DRV_HandleSelectionRequest( hWnd, event, FALSE );
+}
+
+
+/***********************************************************************
+ *           X11DRV_SelectionClear
+ */
+void X11DRV_SelectionClear( HWND hWnd, XSelectionClearEvent *event )
+{
+    if (!hWnd) return;
+    if (event->selection == XA_PRIMARY || event->selection == x11drv_atom(CLIPBOARD))
+        X11DRV_CLIPBOARD_ReleaseSelection( event->selection, event->window, hWnd, event->time );
+}