Moved more code to the X11 driver.

include/clipboard.h

 #ifndef __WINE_CLIPBOARD_H
 #define __WINE_CLIPBOARD_H
 
-void CLIPBOARD_ResetLock(HQUEUE16 hqRef, HQUEUE16 hqNew);
-void CLIPBOARD_ResetOwner(WND* pWnd);
-void CLIPBOARD_ReadSelection(Window w, Atom prop);
-void CLIPBOARD_ReleaseSelection(Window w, HWND32 hwnd);
-BOOL32 CLIPBOARD_IsPresent(WORD wFormat);
+#include "win.h"
+#include "wintypes.h"
+
+typedef struct tagCLIPFORMAT {
+    WORD	wFormatID;
+    WORD	wRefCount;
+    WORD	wDataPresent;
+    LPSTR	Name;
+    HANDLE32	hData32;
+    DWORD	BufSize;
+    struct tagCLIPFORMAT *PrevFormat;
+    struct tagCLIPFORMAT *NextFormat;
+    HANDLE16    hData16;
+} CLIPFORMAT, *LPCLIPFORMAT;
+
+typedef struct _CLIPBOARD_DRIVER
+{
+    void (*pEmptyClipboard)();
+    void (*pSetClipboardData)(UINT32);
+    BOOL32 (*pRequestSelection)();
+    void (*pResetOwner)(WND *);
+} CLIPBOARD_DRIVER;
+
+CLIPBOARD_DRIVER *CLIPBOARD_GetDriver();
+
+extern void CLIPBOARD_ResetLock(HQUEUE16 hqRef, HQUEUE16 hqNew);
+extern void CLIPBOARD_DeleteRecord(LPCLIPFORMAT lpFormat, BOOL32 bChange);
+extern BOOL32 CLIPBOARD_IsPresent(WORD wFormat);
 
 #endif /* __WINE_CLIPBOARD_H */

include/keyboard.h

@@ -7,6 +7,8 @@
 #ifndef __WINE_KEYBOARD_H
 #define __WINE_KEYBOARD_H
 
+#include "wintypes.h"
+
 #pragma pack(1)
 typedef struct _KBINFO
 {
@@ -27,8 +29,17 @@ VOID WINAPI KEYBOARD_Disable(VOID);
 
 /* Wine internals */
 
-extern void KEYBOARD_HandleEvent( WND *pWnd, XKeyEvent *event );
-extern void KEYBOARD_UpdateState( void );
+typedef struct _KEYBOARD_DRIVER {
+  void   (*pInit)();
+  WORD   (*pVkKeyScan)(CHAR);
+  UINT16 (*pMapVirtualKey)(UINT16, UINT16);
+  INT16  (*pGetKeyNameText)(LONG, LPSTR, INT16);
+  INT16  (*pToAscii)(UINT16, UINT16, LPBYTE, LPVOID, UINT16);
+} KEYBOARD_DRIVER;
+
+extern KEYBOARD_DRIVER *KEYBOARD_GetDriver();
+
+extern void KEYBOARD_SendEvent(BYTE bVk, BYTE bScan, DWORD dwFlags, DWORD posX, DWORD posY, DWORD time);
 
 #define WINE_KEYBDEVENT_MAGIC  ( ('K'<<24)|('E'<<16)|('Y'<<8)|'B' )
 typedef struct _WINE_KEYBDEVENT

include/message.h

@@ -9,6 +9,7 @@
 
 #include "win.h"
 #include "queue.h"
+#include "wintypes.h"
 
 extern DWORD MSG_WineStartTicks;  /* Ticks at Wine startup */
 
@@ -31,16 +32,32 @@ extern BOOL32 TIMER_GetTimerMsg( MSG16 *msg, HWND32 hwnd,
 #define EVENT_IO_EXCEPT		2
 
 /* event.c */
+
+typedef struct _EVENT_DRIVER {
+  BOOL32 (*pInit)(void);
+  void   (*pAddIO)(int, unsigned);
+  void   (*pDeleteIO)(int, unsigned);
+  BOOL32 (*pWaitNetEvent)(BOOL32, BOOL32);
+  void   (*pSynchronize)(void);
+  BOOL32 (*pCheckFocus)(void);
+  BOOL32 (*pQueryPointer)(DWORD *, DWORD *, DWORD *);
+  void   (*pDummyMotionNotify)(void);
+  BOOL32 (*pPending)(void);
+  BOOL16 (*pIsUserIdle)(void);
+} EVENT_DRIVER;
+
 extern void EVENT_AddIO( int fd, unsigned flag );
-extern BOOL32 EVENT_CheckFocus( void );
 extern void EVENT_DeleteIO( int fd, unsigned flag );
 extern BOOL32 EVENT_Init( void );
 extern BOOL32 EVENT_WaitNetEvent( BOOL32 sleep, BOOL32 peek );
 extern void EVENT_Synchronize(void);
-extern void EVENT_ProcessEvent( XEvent *event );
-extern void EVENT_RegisterWindow( WND *pWnd );
-extern void EVENT_DestroyWindow( WND *pWnd );
+extern BOOL32 EVENT_CheckFocus( void );
+extern BOOL32 EVENT_QueryPointer(DWORD *posX, DWORD *posY, DWORD *state);
 extern void EVENT_DummyMotionNotify(void);
+extern BOOL32 EVENT_Pending(void);
+
+/* input.c */
+
 extern HWND32 EVENT_Capture( HWND32, INT16 );
 extern INT16 EVENT_GetCaptureInfo(void);
 extern BOOL32 EVENT_QueryPointer( DWORD *posX, DWORD *posY, DWORD *state );

include/win.h

@@ -7,7 +7,11 @@
 #ifndef __WINE_WIN_H
 #define __WINE_WIN_H
 
-#include "ts_xlib.h"
+#include "config.h"
+
+#ifndef X_DISPLAY_MISSING
+#include <X11/Xlib.h>
+#endif /* !defined(X_DISPLAY_MISSING) */
 
 #include "ldt.h"
 #include "class.h"
@@ -89,14 +93,18 @@ typedef struct tagWND
 
 typedef struct _WND_DRIVER
 {
+    BOOL32 (*pCreateDesktopWindow)(WND *, CLASS *, BOOL32);
     BOOL32 (*pCreateWindow)(WND *, CLASS *, CREATESTRUCT32A *, BOOL32);
+    BOOL32 (*pDestroyWindow)(WND *);
     WND*   (*pSetParent)(WND *, WND *);
+    void   (*pForceWindowRaise)(WND *);
+    void   (*pSetWindowPos)(WND *, const WINDOWPOS32 *, BOOL32);
+    void   (*pSetText)(WND *, LPCSTR);
+    void   (*pSetFocus)(WND *);
+    void   (*pPreSizeMove)(WND *);
+    void   (*pPostSizeMove)(WND *);
 } WND_DRIVER;
 
-/* X11 windows driver */
-/* FIXME: does not belong here */
-extern WND_DRIVER X11DRV_WND_Driver;
-
 typedef struct
 {
     RECT16	   rectNormal;
@@ -130,7 +138,6 @@ extern WND*   WIN_FindWndPtr( HWND32 hwnd );
 extern WND*   WIN_GetDesktop(void);
 extern void   WIN_DumpWindow( HWND32 hwnd );
 extern void   WIN_WalkWindows( HWND32 hwnd, int indent );
-extern Window WIN_GetXWindow( HWND32 hwnd );
 extern BOOL32 WIN_UnlinkWindow( HWND32 hwnd );
 extern BOOL32 WIN_LinkWindow( HWND32 hwnd, HWND32 hwndInsertAfter );
 extern HWND32 WIN_FindWinToRepaint( HWND32 hwnd, HQUEUE16 hQueue );
@@ -164,7 +171,6 @@ extern HWND32 ICONTITLE_Create( WND* );
 extern BOOL32 ICONTITLE_Init( void );
 
 /* windows/focus.c */
-extern void FOCUS_SetXFocus( HWND32 );
 extern void FOCUS_SwitchFocus( HWND32 , HWND32 );
 
 extern Display * display;

include/x11drv.h

@@ -5,12 +5,18 @@
 #ifndef __WINE_X11DRV_H
 #define __WINE_X11DRV_H
 
+#include "config.h"
 #include "ts_xlib.h"
 #include "ts_xutil.h"
+
 #include "winbase.h"
 #include "windows.h"
 #include "gdi.h"
 #include "xmalloc.h" /* for XCREATEIMAGE macro */
+#include "clipboard.h"
+#include "keyboard.h"
+#include "message.h"
+#include "win.h"
 
   /* X physical pen */
 typedef struct
@@ -181,7 +187,6 @@ extern void _XInitImageFuncPtrs(XImage *);
                            (width), (height), 32, width_bytes ); \
 }
 
-
 /* exported dib functions for now */
 
 /* This structure holds the arguments for DIB_SetImageBits() */
@@ -213,6 +218,63 @@ extern int *X11DRV_DIB_BuildColorMap( struct tagDC *dc, WORD coloruse,
 				      WORD depth, const BITMAPINFO *info,
 				      int *nColors );
 
+/* X11 windows driver */
+extern WND_DRIVER X11DRV_WND_Driver;
 
-#endif  /* __WINE_X11DRV_H */
+extern Window X11DRV_WND_GetXWindow(HWND32 hwnd);
+
+extern BOOL32 X11DRV_WND_CreateDesktopWindow(WND *wndPtr, CLASS *classPtr, BOOL32 bUnicode);
+extern BOOL32 X11DRV_WND_CreateWindow(WND *wndPtr, CLASS *classPtr, CREATESTRUCT32A *cs, BOOL32 bUnicode);
+extern BOOL32 X11DRV_WND_DestroyWindow(WND *pWnd);
+extern WND *X11DRV_WND_SetParent(WND *wndPtr, WND *pWndParent);
+extern void X11DRV_WND_ForceWindowRaise(WND *pWnd);
+extern void X11DRV_WND_SetWindowPos(WND *wndPtr, const WINDOWPOS32 *winpos, BOOL32 bSMC_SETXPOS);
+extern void X11DRV_WND_SetText(WND *wndPtr, LPCSTR text);
+extern void X11DRV_WND_SetFocus(WND *wndPtr);
+extern void X11DRV_WND_PreSizeMove(WND *wndPtr);
+extern void X11DRV_WND_PostSizeMove(WND *wndPtr);
+
+/* X11 clipboard driver */
+
+extern CLIPBOARD_DRIVER X11DRV_CLIPBOARD_Driver;
+
+extern void X11DRV_CLIPBOARD_EmptyClipboard();
+extern void X11DRV_CLIPBOARD_SetClipboardData(UINT32 wFormat);
+extern BOOL32 X11DRV_CLIPBOARD_RequestSelection();
+extern void X11DRV_CLIPBOARD_ResetOwner(WND *pWnd);
+
+void X11DRV_CLIPBOARD_ReadSelection(Window w, Atom prop);
+void X11DRV_CLIPBOARD_ReleaseSelection(Window w, HWND32 hwnd);
+
+/* X11 keyboard driver */
 
+extern KEYBOARD_DRIVER X11DRV_KEYBOARD_Driver;
+
+extern void X11DRV_KEYBOARD_Init(void);
+extern WORD X11DRV_KEYBOARD_VkKeyScan(CHAR cChar);
+extern UINT16 X11DRV_KEYBOARD_MapVirtualKey(UINT16 wCode, UINT16 wMapType);
+extern INT16 X11DRV_KEYBOARD_GetKeyNameText(LONG lParam, LPSTR lpBuffer, INT16 nSize);
+extern INT16 X11DRV_KEYBOARD_ToAscii(UINT16 virtKey, UINT16 scanCode, LPBYTE lpKeyState, LPVOID lpChar, UINT16 flags);
+
+/* X11 mouse driver */
+
+#if 0 
+extern MOUSE_DRIVER X11DRV_MOUSE_Driver;
+#endif
+
+/* X11 event driver */
+
+extern EVENT_DRIVER X11DRV_EVENT_Driver;
+
+extern BOOL32 X11DRV_EVENT_Init(void);
+extern void X11DRV_EVENT_AddIO(int fd, unsigned flag);
+extern void X11DRV_EVENT_DeleteIO(int fd, unsigned flag);
+extern BOOL32 X11DRV_EVENT_WaitNetEvent(BOOL32 sleep, BOOL32 peek);
+extern void X11DRV_EVENT_Synchronize(void);
+extern BOOL32 X11DRV_EVENT_CheckFocus( void );
+extern BOOL32 X11DRV_EVENT_QueryPointer(DWORD *posX, DWORD *posY, DWORD *state);
+extern void X11DRV_EVENT_DummyMotionNotify(void);
+extern BOOL32 X11DRV_EVENT_Pending(void);
+extern BOOL16 X11DRV_EVENT_IsUserIdle(void);
+
+#endif  /* __WINE_X11DRV_H */

windows/defwnd.c

@@ -60,12 +60,8 @@ void DEFWND_SetText( WND *wndPtr, LPCSTR text )
 {
     if (!text) text = "";
     if (wndPtr->text) HeapFree( SystemHeap, 0, wndPtr->text );
-    wndPtr->text = HEAP_strdupA( SystemHeap, 0, text );
-    if (wndPtr->window)
-    {
-	TSXStoreName( display, wndPtr->window, wndPtr->text );
-	TSXSetIconName( display, wndPtr->window, wndPtr->text );
-    }
+    wndPtr->text = HEAP_strdupA( SystemHeap, 0, text );    
+    wndPtr->pDriver->pSetText(wndPtr, wndPtr->text);
 }
 
 /***********************************************************************

windows/dinput.c

@@ -18,11 +18,12 @@
  *	   an utter mess.)
  */
 
+#include "ts_xlib.h"
+
 #include "config.h"
 #include <string.h>
 #include <unistd.h>
 #include <assert.h>
-#include <X11/Xlib.h>
 #include <sys/signal.h>
 
 #include "windows.h"
@@ -470,17 +471,15 @@ static HRESULT WINAPI SysMouseA_SetDataFormat(
   if (df->dwFlags == DIDF_ABSAXIS)
     mthis->absolute = 1;
   else {
-    Window rw, cr;
-    int rx, ry, cx, cy;
-    unsigned int mask;
+    DWORD rx, ry;
     
     /* We need to get the initial "previous" position to be able
        to return deltas */
     mthis->absolute = 0;
   
     /* Get the mouse position */
-    TSXQueryPointer(display, rootWindow, &rw, &cr,
-		    &rx, &ry, &cx, &cy, &mask);
+    EVENT_QueryPointer(&rx, &ry, NULL);
+
     /* Fill the initial mouse state structure */
     mthis->prevX = rx;
     mthis->prevY = ry;
@@ -498,9 +497,7 @@ static HRESULT WINAPI SysMouseA_SetDataFormat(
 static HRESULT WINAPI SysMouseA_GetDeviceState(
 	LPDIRECTINPUTDEVICE32A this,DWORD len,LPVOID ptr
 ) {
-  Window rw, cr;
-  int rx, ry, cx, cy;
-  unsigned int mask;
+  DWORD rx, ry, state;
   struct DIMOUSESTATE *mstate = (struct DIMOUSESTATE *) ptr;
   LPSYSMOUSE32A mthis = (LPSYSMOUSE32A) this;
   
@@ -513,8 +510,7 @@ static HRESULT WINAPI SysMouseA_GetDeviceState(
   }
   
   /* Get the mouse position */
-  TSXQueryPointer(display, rootWindow, &rw, &cr,
-		  &rx, &ry, &cx, &cy, &mask);
+  EVENT_QueryPointer(&rx, &ry, &state);
   TRACE(dinput,"(X:%d - Y:%d)\n", rx, ry);
 
   /* Fill the mouse state structure */
@@ -529,10 +525,10 @@ static HRESULT WINAPI SysMouseA_GetDeviceState(
     mthis->prevY = ry;
   }
   mstate->lZ = 0;
-  mstate->rgbButtons[0] = (mask & Button1Mask ? 0xFF : 0x00);
-  mstate->rgbButtons[1] = (mask & Button3Mask ? 0xFF : 0x00); /* Windows button two is X button 3 */
-  mstate->rgbButtons[2] = (mask & Button2Mask ? 0xFF : 0x00);
-  mstate->rgbButtons[3] = (mask & Button4Mask ? 0xFF : 0x00);
+  mstate->rgbButtons[0] = (state & MK_LBUTTON ? 0xFF : 0x00);
+  mstate->rgbButtons[1] = (state & MK_RBUTTON ? 0xFF : 0x00);
+  mstate->rgbButtons[2] = (state & MK_MBUTTON ? 0xFF : 0x00);
+  mstate->rgbButtons[3] = 0x00;
   
   return 0;
 }

windows/display.c

@@ -5,13 +5,13 @@
  *
  */
 
-#include <stdlib.h>
-#include <string.h>
-#include <ctype.h>
 #include "ts_xlib.h"
 #include "ts_xresource.h"
 #include "ts_xutil.h"
 
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
 #include "windows.h"
 #include "win.h"
 #include "gdi.h"
@@ -169,7 +169,7 @@ static BOOL32 DISPLAY_DoSetCursor( CURSORICONINFO *ptr )
         HWND32 hwnd = GetWindow32( GetDesktopWindow32(), GW_CHILD );
         while(hwnd)
         {
-            Window win = WIN_GetXWindow( hwnd );
+            Window win = X11DRV_WND_GetXWindow( hwnd );
             if (win && win!=DefaultRootWindow(display))
                 XDefineCursor( display, win, cursor );
             hwnd = GetWindow32( hwnd, GW_HWNDNEXT );

windows/focus.c

@@ -17,46 +17,11 @@
 static HWND32 hwndFocus = 0;
 
 /*****************************************************************
- *               FOCUS_SetXFocus
- *
- * Set the X focus.
- * Explicit colormap management seems to work only with OLVWM.
- */
-void FOCUS_SetXFocus( HWND32 hwnd )
-{
-    XWindowAttributes win_attr;
-    Window win;
-
-    /* Only mess with the X focus if there's */
-    /* no desktop window and no window manager. */
-    if ((rootWindow != DefaultRootWindow(display)) || Options.managed) return;
-
-    if (!hwnd)	/* If setting the focus to 0, uninstall the colormap */
-    {
-	if (COLOR_GetSystemPaletteFlags() & COLOR_PRIVATE)
-	    TSXUninstallColormap( display, COLOR_GetColormap() );
-	return;
-    }
-
-      /* Set X focus and install colormap */
-
-    if (!(win = WIN_GetXWindow( hwnd ))) return;
-    if (!TSXGetWindowAttributes( display, win, &win_attr ) ||
-        (win_attr.map_state != IsViewable))
-        return;  /* If window is not viewable, don't change anything */
-
-    TSXSetInputFocus( display, win, RevertToParent, CurrentTime );
-    if (COLOR_GetSystemPaletteFlags() & COLOR_PRIVATE)
-        TSXInstallColormap( display, COLOR_GetColormap() );
-
-    EVENT_Synchronize();
-}
-
-/*****************************************************************
  *	         FOCUS_SwitchFocus 
  */
 void FOCUS_SwitchFocus( HWND32 hFocusFrom, HWND32 hFocusTo )
 {
+    WND *pFocusTo = WIN_FindWndPtr( hFocusTo );
     hwndFocus = hFocusTo;
 
 #if 0
@@ -71,7 +36,8 @@ void FOCUS_SwitchFocus( HWND32 hFocusFrom, HWND32 hFocusTo )
 
     /* According to API docs, the WM_SETFOCUS message is sent AFTER the window
        has received the keyboard focus. */
-    FOCUS_SetXFocus( hFocusTo );
+
+    pFocusTo->pDriver->pSetFocus(pFocusTo);
 
 #if 0
     SendMessage32A( hFocusTo, WM_SETFOCUS, hFocusFrom, 0 );

windows/message.c

@@ -4,6 +4,8 @@
  * Copyright 1993, 1994 Alexandre Julliard
  */
 
+#include "ts_xlib.h"
+
 #include <stdlib.h>
 #include <string.h>
 #include <ctype.h>
@@ -449,7 +451,7 @@ static BOOL32 MSG_PeekHardwareMsg( MSG16 *msg, HWND16 hwnd, DWORD filter,
 
     /* If the queue is empty, attempt to fill it */
     if (!sysMsgQueue->msgCount && THREAD_IsWin16( THREAD_Current() )
-                               && TSXPending(display))
+                               && EVENT_Pending())
         EVENT_WaitNetEvent( FALSE, FALSE );
 
     for (i = kbd_msg = 0; i < sysMsgQueue->msgCount; i++, pos++)

windows/nonclient.c

@@ -2048,9 +2048,10 @@ static void NC_DoSizeMove( HWND32 hwnd, WORD wParam )
     else
     {  /* Grab the server only when moving top-level windows without desktop */
 	hdc = GetDC32( 0 );
-	if (rootWindow == DefaultRootWindow(display)) TSXGrabServer( display );
     }
 
+    wndPtr->pDriver->pPreSizeMove(wndPtr);
+
     if( iconic ) /* create a cursor for dragging */
     {
 	HICON16 hIcon = (wndPtr->class->hIcon) ? wndPtr->class->hIcon
@@ -2146,9 +2147,10 @@ static void NC_DoSizeMove( HWND32 hwnd, WORD wParam )
     else
     {
 	ReleaseDC32( 0, hdc );
-	if (rootWindow == DefaultRootWindow(display)) TSXUngrabServer( display );
     }
 
+    wndPtr->pDriver->pPostSizeMove(wndPtr);
+
     if (HOOK_IsHooked( WH_CBT ))
     {
 	RECT16* pr = SEGPTR_NEW(RECT16);

windows/win.c

@@ -31,6 +31,8 @@
 #include "winerror.h"
 #include "mdi.h"
 
+extern WND_DRIVER X11DRV_WND_Driver;
+
 /* Desktop window */
 static WND *pWndDesktop = NULL;
 
@@ -146,20 +148,6 @@ void WIN_WalkWindows( HWND32 hwnd, int indent )
     }
 }
 
-
-/***********************************************************************
- *           WIN_GetXWindow
- *
- * Return the X window associated to a window.
- */
-Window WIN_GetXWindow( HWND32 hwnd )
-{
-    WND *wndPtr = WIN_FindWndPtr( hwnd );
-    while (wndPtr && !wndPtr->window) wndPtr = wndPtr->parent;
-    return wndPtr ? wndPtr->window : 0;
-}
-
-
 /***********************************************************************
  *           WIN_UnlinkWindow
  *
@@ -325,7 +313,7 @@ static WND* WIN_DestroyWindow( WND* wndPtr )
     if (!(wndPtr->dwStyle & WS_CHILD))
        if (wndPtr->wIDmenu) DestroyMenu32( (HMENU32)wndPtr->wIDmenu );
     if (wndPtr->hSysMenu) DestroyMenu32( wndPtr->hSysMenu );
-    if (wndPtr->window) EVENT_DestroyWindow( wndPtr );
+    wndPtr->pDriver->pDestroyWindow( wndPtr );
     DCE_FreeWindowDCE( wndPtr );    /* Always do this to catch orphaned DCs */ 
     WINPROC_FreeProc( wndPtr->winproc, WIN_PROC_WINDOW );
     wndPtr->hwndSelf = 0;
@@ -433,15 +421,15 @@ BOOL32 WIN_CreateDesktopWindow(void)
     pWndDesktop->wIDmenu           = 0;
     pWndDesktop->helpContext       = 0;
     pWndDesktop->flags             = 0;
-    pWndDesktop->window            = rootWindow;
     pWndDesktop->hSysMenu          = 0;
     pWndDesktop->userdata          = 0;
     pWndDesktop->pDriver           = &X11DRV_WND_Driver;
-    pWndDesktop->expose_event      = NULL;
-
     pWndDesktop->winproc = (WNDPROC16)class->winproc;
 
-    EVENT_RegisterWindow( pWndDesktop );
+    /* FIXME: How do we know if it should be Unicode or not */
+    if(!pWndDesktop->pDriver->pCreateDesktopWindow(pWndDesktop, class, FALSE))
+      return FALSE;
+    
     SendMessage32A( hwndDesktop, WM_NCCREATE, 0, 0 );
     pWndDesktop->flags |= WIN_NEEDS_ERASEBKGND;
     return TRUE;
@@ -648,7 +636,8 @@ static HWND32 WIN_CreateWindowEx( CREATESTRUCT32A *cs, ATOM classAtom,
     wndPtr->rectWindow.bottom = cs->y + cs->cy;
     wndPtr->rectClient        = wndPtr->rectWindow;
 
-    (*wndPtr->pDriver->pCreateWindow)(wndPtr, classPtr, cs, unicode);
+    if(!wndPtr->pDriver->pCreateWindow(wndPtr, classPtr, cs, unicode))
+       return FALSE;
 
     /* Set the window menu */
 
@@ -924,7 +913,7 @@ static void WIN_SendDestroyMsg( WND* pWnd )
     WIN_CheckFocus(pWnd);
 
     if( CARET_GetHwnd() == pWnd->hwndSelf ) DestroyCaret32();
-    if( !pWnd->window ) CLIPBOARD_ResetOwner( pWnd ); 
+    if( !pWnd->window ) CLIPBOARD_GetDriver()->pResetOwner( pWnd ); 
   
     SendMessage32A( pWnd->hwndSelf, WM_DESTROY, 0, 0);
 
@@ -986,7 +975,7 @@ BOOL32 WINAPI DestroyWindow32( HWND32 hwnd )
 	    if( !IsWindow32(hwnd) ) return TRUE;
 	}
 
-    if( wndPtr->window ) CLIPBOARD_ResetOwner( wndPtr ); /* before the window is unmapped */
+    if( wndPtr->window ) CLIPBOARD_GetDriver()->pResetOwner( wndPtr ); /* before the window is unmapped */
 
       /* Hide the window */
 

windows/winpos.c

@@ -6,9 +6,6 @@
  */
 
 #include <string.h>
-#include "ts_xlib.h"
-#include "ts_xutil.h"
-#include <X11/Xatom.h>
 #include "sysmetrics.h"
 #include "heap.h"
 #include "module.h"
@@ -1435,35 +1432,6 @@ void WINAPI SetInternalWindowPos32( HWND32 hwnd, UINT32 showCmd,
     }
 }
 
-
-/***********************************************************************
- *           WINPOS_ForceXWindowRaise
- *
- * Raise a window on top of the X stacking order, while preserving 
- * the correct Windows Z order.
- */
-static void WINPOS_ForceXWindowRaise( WND* pWnd )
-{
-    XWindowChanges winChanges;
-    WND *wndPrev;
-
-    /* Raise all windows up to pWnd according to their Z order.
-     * (it would be easier with sibling-related Below but it doesn't
-     * work very well with SGI mwm for instance)
-     */
-    winChanges.stack_mode = Above;
-    while (pWnd)
-    {
-        if (pWnd->window) TSXReconfigureWMWindow( display, pWnd->window, 0,
-                                                CWStackMode, &winChanges );
-        wndPrev = WIN_GetDesktop()->child;
-        if (wndPrev == pWnd) break;
-        while (wndPrev && (wndPrev->next != pWnd)) wndPrev = wndPrev->next;
-        pWnd = wndPrev;
-    }
-}
-
-
 /*******************************************************************
  *	   WINPOS_SetActiveWindow
  *
@@ -1620,9 +1588,8 @@ BOOL32 WINPOS_SetActiveWindow( HWND32 hWnd, BOOL32 fMouse, BOOL32 fChangeFocus)
 			       hwndActive
 	    );
 
-    if( !hwndPrevActive && wndPtr && 
-	 wndPtr->window && !(wndPtr->flags & WIN_MANAGED) )
-	WINPOS_ForceXWindowRaise(wndPtr);
+    if( !hwndPrevActive && wndPtr )
+        (*wndPtr->pDriver->pForceWindowRaise)(wndPtr);
 
     /* if active wnd is minimized redraw icon title */
     if( IsIconic32(hwndActive) ) WINPOS_RedrawIconTitle(hwndActive);
@@ -2057,104 +2024,6 @@ static UINT32 WINPOS_SizeMoveClean( WND* Wnd, HRGN32 oldVisRgn,
  return uFlags;
 }
 
-
-/***********************************************************************
- *           WINPOS_FindDeskTopXWindow
- *
- * Find the actual X window which needs be restacked.
- * Used by WINPOS_SetXWindowPos().
- */
-static Window WINPOS_FindDeskTopXWindow( WND *wndPtr )
-{
-    if (!(wndPtr->flags & WIN_MANAGED))
-        return wndPtr->window;
-    else
-    {
-        Window window, root, parent, *children;
-        int nchildren;
-        window = wndPtr->window;
-        for (;;)
-        {
-            TSXQueryTree( display, window, &root, &parent,
-                        &children, &nchildren );
-            TSXFree( children );
-            if (parent == root)
-                return window;
-            window = parent;
-        }
-    }
-}
-
-/***********************************************************************
- *           WINPOS_SetXWindowPos
- *
- * SetWindowPos() for an X window. Used by the real SetWindowPos().
- */
-static void WINPOS_SetXWindowPos( const WINDOWPOS32 *winpos )
-{
-    XWindowChanges winChanges;
-    int changeMask = 0;
-    WND *wndPtr = WIN_FindWndPtr( winpos->hwnd );
-
-    if (!(winpos->flags & SWP_NOSIZE))
-    {
-        winChanges.width     = winpos->cx;
-        winChanges.height    = winpos->cy;
-        changeMask |= CWWidth | CWHeight;
-
-        /* Tweak dialog window size hints */
-
-        if ((wndPtr->flags & WIN_MANAGED) &&
-            (wndPtr->dwExStyle & WS_EX_DLGMODALFRAME))
-        {
-            XSizeHints *size_hints = TSXAllocSizeHints();
-
-            if (size_hints)
-            {
-                long supplied_return;
-
-                TSXGetWMSizeHints( display, wndPtr->window, size_hints,
-                                 &supplied_return, XA_WM_NORMAL_HINTS);
-                size_hints->min_width = size_hints->max_width = winpos->cx;
-                size_hints->min_height = size_hints->max_height = winpos->cy;
-                TSXSetWMSizeHints( display, wndPtr->window, size_hints,
-                                 XA_WM_NORMAL_HINTS );
-                TSXFree(size_hints);
-            }
-        }
-    }
-    if (!(winpos->flags & SWP_NOMOVE))
-    {
-        winChanges.x = winpos->x;
-        winChanges.y = winpos->y;
-        changeMask |= CWX | CWY;
-    }
-    if (!(winpos->flags & SWP_NOZORDER))
-    {
-	winChanges.stack_mode = Below;
-	changeMask |= CWStackMode;
-
-        if (winpos->hwndInsertAfter == HWND_TOP) winChanges.stack_mode = Above;
-        else if (winpos->hwndInsertAfter != HWND_BOTTOM)
-        {
-            WND*   insertPtr = WIN_FindWndPtr( winpos->hwndInsertAfter );
-	    Window stack[2];
-
-	    stack[0] = WINPOS_FindDeskTopXWindow( insertPtr );
-	    stack[1] = WINPOS_FindDeskTopXWindow( wndPtr );
-
-	    /* for stupid window managers (i.e. all of them) */
-
-	    TSXRestackWindows(display, stack, 2); 
-	    changeMask &= ~CWStackMode;
-	}
-    }
-    if (!changeMask) return;
-
-    TSXReconfigureWMWindow( display, wndPtr->window, 0, changeMask, &winChanges );
-}
-
-
 /***********************************************************************
  *           SetWindowPos   (USER.232)
  */
@@ -2364,7 +2233,7 @@ BOOL32 WINAPI SetWindowPos32( HWND32 hwnd, HWND32 hwndInsertAfter,
 
 	if( !(flags & (SWP_SHOWWINDOW | SWP_HIDEWINDOW)) )
 	{
-              WINPOS_SetXWindowPos( &winpos );
+              wndPtr->pDriver->pSetWindowPos(wndPtr, &winpos, TRUE);
 	      winpos.hwndInsertAfter = tempInsertAfter;
 	}
 	else  uFlags |= SMC_SETXPOS;
@@ -2459,12 +2328,12 @@ BOOL32 WINAPI SetWindowPos32( HWND32 hwnd, HWND32 hwndInsertAfter,
         {
 	    HWND32 focus, curr;
 
+	    wndPtr->pDriver->pSetWindowPos(wndPtr, &winpos, uFlags & SMC_SETXPOS );
 	    if( uFlags & SMC_SETXPOS )
 	    {
-              WINPOS_SetXWindowPos( &winpos );
               winpos.hwndInsertAfter = tempInsertAfter;
 	    }
-            TSXMapWindow( display, wndPtr->window );
+
             if (wndPtr->flags & WIN_MANAGED) resync = TRUE;
 
 	    /* If focus was set to an unmapped window, reset X focus now */
@@ -2488,19 +2357,18 @@ BOOL32 WINAPI SetWindowPos32( HWND32 hwnd, HWND32 hwndInsertAfter,
     }
     else if (flags & SWP_HIDEWINDOW)
     {
+        wndPtr->dwStyle &= ~WS_VISIBLE;
+
         if (wndPtr->window)
         {
-           if (wndPtr->dwStyle & WS_VISIBLE) TSXUnmapWindow( display, wndPtr->window );
-           wndPtr->dwStyle &= ~WS_VISIBLE;
-           if( uFlags & SMC_SETXPOS )
-           {
-               WINPOS_SetXWindowPos( &winpos );
-               winpos.hwndInsertAfter = tempInsertAfter;
-           }
+	    wndPtr->pDriver->pSetWindowPos(wndPtr, &winpos, uFlags & SMC_SETXPOS );
+	    if( uFlags & SMC_SETXPOS )
+	    {
+              winpos.hwndInsertAfter = tempInsertAfter;
+	    }
         }
         else
         {
-            wndPtr->dwStyle &= ~WS_VISIBLE;
             if (!(flags & SWP_NOREDRAW))
                 PAINT_RedrawWindow( wndPtr->parent->hwndSelf, &oldWindowRect,
                                     0, RDW_INVALIDATE | RDW_ALLCHILDREN |

windows/x11drv/Makefile.in

@@ -6,7 +6,12 @@ VPATH     = @srcdir@
 MODULE    = x11drv
 
 C_SRCS = \
-	init.c
+	clipboard.c \
+	event.c \
+	init.c \
+	keyboard.c \
+	mouse.c \
+	wnd.c
 
 all: $(MODULE).o
 

windows/x11drv/clipboard.c

+/*
+ * X11 windows driver
+ *
+ * Copyright 1994 Martin Ayotte
+ *	     1996 Alex Korobka
+ */
+
+#include "config.h"
+
+#ifndef X_DISPLAY_MISSING
+
+#include <X11/Xatom.h>
+#include "ts_xlib.h"
+
+#include "windows.h"
+#include "wintypes.h"
+
+#include "clipboard.h"
+#include "debug.h"
+#include "message.h"
+#include "win.h"
+#include "x11drv.h"
+
+extern HWND32 hWndClipOwner;
+extern HWND32 hWndClipWindow;
+extern CLIPFORMAT ClipFormats[];
+
+static Bool   selectionWait = False;
+static Bool   selectionAcquired = False;
+static Window selectionWindow = None;
+static Window selectionPrevWindow = None;
+
+/**************************************************************************
+ * 		X11DRV_CLIPBOARD_CheckSelection	[Internal]
+ *
+ * Prevent X selection from being lost when a top level window is
+ * destroyed.
+ */
+static void X11DRV_CLIPBOARD_CheckSelection(WND* pWnd)
+{
+    TRACE(clipboard,"\tchecking %08x\n", (unsigned)pWnd->window);
+
+    if( selectionAcquired && selectionWindow != None &&
+        pWnd->window == selectionWindow )
+    {
+	selectionPrevWindow = selectionWindow;
+	selectionWindow = None;
+
+	if( pWnd->next ) 
+	    selectionWindow = pWnd->next->window;
+	else if( pWnd->parent )
+             if( pWnd->parent->child != pWnd ) 
+                 selectionWindow = pWnd->parent->child->window;
+
+	TRACE(clipboard,"\tswitching selection from %08x to %08x\n", 
+                    (unsigned)selectionPrevWindow, (unsigned)selectionWindow);
+
+	if( selectionWindow != None )
+	{
+	    TSXSetSelectionOwner(display, XA_PRIMARY, selectionWindow, CurrentTime);
+	    if( TSXGetSelectionOwner(display, XA_PRIMARY) != selectionWindow )
+		selectionWindow = None;
+	}
+    }
+}
+
+/**************************************************************************
+ *		X11DRV_CLIPBOARD_ReadSelection
+ *
+ * Called from the SelectionNotify event handler. 
+ */
+void X11DRV_CLIPBOARD_ReadSelection(Window w,Atom prop)
+{
+    HANDLE32 	 hText = 0;
+    LPCLIPFORMAT lpFormat = ClipFormats; 
+
+    TRACE(clipboard,"ReadSelection callback\n");
+
+    if(prop != None)
+    {
+	Atom		atype=AnyPropertyType;
+	int		aformat;
+	unsigned long 	nitems,remain;
+	unsigned char*	val=NULL;
+
+        TRACE(clipboard,"\tgot property %s\n",TSXGetAtomName(display,prop));
+
+        /* TODO: Properties longer than 64K */
+
+	if(TSXGetWindowProperty(display,w,prop,0,0x3FFF,True,XA_STRING,
+	    &atype, &aformat, &nitems, &remain, &val) != Success)
+	    WARN(clipboard, "\tcouldn't read property\n");
+	else
+	{
+           TRACE(clipboard,"\tType %s,Format %d,nitems %ld,value %s\n",
+		             TSXGetAtomName(display,atype),aformat,nitems,val);
+
+	   if(atype == XA_STRING && aformat == 8)
+	   {
+	      int 	i,inlcount = 0;
+	      char*	lpstr;
+
+	      TRACE(clipboard,"\tselection is '%s'\n",val);
+
+	      for(i=0; i <= nitems; i++)
+		  if( val[i] == '\n' ) inlcount++;
+
+	      if( nitems )
+	      {
+	        hText=GlobalAlloc32(GMEM_MOVEABLE, nitems + inlcount + 1);
+	        if( (lpstr = (char*)GlobalLock32(hText)) )
+	          for(i=0,inlcount=0; i <= nitems; i++)
+	          {
+	  	     if( val[i] == '\n' ) lpstr[inlcount++]='\r';
+		     lpstr[inlcount++]=val[i];
+		  }
+	        else hText = 0;
+	      }
+	   }
+	   TSXFree(val);
+	}
+   }
+
+   /* delete previous CF_TEXT and CF_OEMTEXT data */
+
+   if( hText )
+   {
+     lpFormat = &ClipFormats[CF_TEXT-1];
+     if (lpFormat->wDataPresent || lpFormat->hData16 || lpFormat->hData32) 
+         CLIPBOARD_DeleteRecord(lpFormat, !(hWndClipWindow));
+     lpFormat = &ClipFormats[CF_OEMTEXT-1];
+     if (lpFormat->wDataPresent || lpFormat->hData16 || lpFormat->hData32)  
+         CLIPBOARD_DeleteRecord(lpFormat, !(hWndClipWindow));
+
+     lpFormat->wDataPresent = 1;
+     lpFormat->hData32 = hText;
+     lpFormat->hData16 = 0;
+   }
+
+   selectionWait=False;
+}
+
+/**************************************************************************
+ *		X11DRV_CLIPBOARD_ReleaseSelection
+ *
+ * Wine might have lost XA_PRIMARY selection because of
+ * EmptyClipboard() or other client. 
+ */
+void X11DRV_CLIPBOARD_ReleaseSelection(Window w, HWND32 hwnd)
+{
+    /* w is the window that lost selection,
+     * 
+     * selectionPrevWindow is nonzero if CheckSelection() was called. 
+     */
+
+    TRACE(clipboard,"\tevent->window = %08x (sw = %08x, spw=%08x)\n", 
+	  (unsigned)w, (unsigned)selectionWindow, (unsigned)selectionPrevWindow );
+
+    if( selectionAcquired )
+    {
+	if( w == selectionWindow || selectionPrevWindow == None)
+	{
+	    /* alright, we really lost it */
+
+	    selectionAcquired = False;
+	    selectionWindow = None; 
+
+	    /* but we'll keep existing data for internal use */
+	}
+	else if( w == selectionPrevWindow )
+	{
+	    w = TSXGetSelectionOwner(display, XA_PRIMARY);
+	    if( w == None )
+		TSXSetSelectionOwner(display, XA_PRIMARY, selectionWindow, CurrentTime);
+	}
+    }
+
+    selectionPrevWindow = None;
+}
+
+/**************************************************************************
+ *		X11DRV_CLIPBOARD_EmptyClipboard
+ */
+void X11DRV_CLIPBOARD_EmptyClipboard()
+{
+  if(selectionAcquired)
+    {
+      selectionAcquired	= False;
+      selectionPrevWindow 	= selectionWindow;
+      selectionWindow 	= None;
+      
+      TRACE(clipboard, "\tgiving up selection (spw = %08x)\n", 
+	    (unsigned)selectionPrevWindow);
+      
+      TSXSetSelectionOwner(display, XA_PRIMARY, None, CurrentTime);
+    }
+}
+
+/**************************************************************************
+ *		X11DRV_CLIPBOARD_SetClipboardData
+ */
+void X11DRV_CLIPBOARD_SetClipboardData(UINT32 wFormat)
+{
+    Window       owner;
+
+    /* Acquire X selection if text format */
+
+    if( !selectionAcquired && 
+	(wFormat == CF_TEXT || wFormat == CF_OEMTEXT) )
+    {
+	owner = X11DRV_WND_GetXWindow( hWndClipWindow ? hWndClipWindow : AnyPopup32() );
+
+	TSXSetSelectionOwner(display,XA_PRIMARY, owner, CurrentTime);
+	if( TSXGetSelectionOwner(display,XA_PRIMARY) == owner )
+	{
+	    selectionAcquired = True;
+	    selectionWindow = owner;
+
+	    TRACE(clipboard,"Grabbed X selection, owner=(%08x)\n", 
+						(unsigned) owner);
+	}
+    }
+}
+
+/**************************************************************************
+ *		X11DRV_CLIPBOARD_RequestSelection
+ */
+BOOL32 X11DRV_CLIPBOARD_RequestSelection()
+{
+    HWND32 hWnd = (hWndClipWindow) ? hWndClipWindow : GetActiveWindow32();
+
+    if( selectionAcquired )
+      return TRUE;
+
+    if( !hWnd ) return FALSE;
+
+    TRACE(clipboard,"Requesting selection...\n");
+
+  /* request data type XA_STRING, later
+   * CLIPBOARD_ReadSelection() will be invoked 
+   * from the SelectionNotify event handler */
+
+    TSXConvertSelection(display,XA_PRIMARY,XA_STRING,
+                      TSXInternAtom(display,"PRIMARY_TEXT",False),
+                      X11DRV_WND_GetXWindow(hWnd),CurrentTime);
+
+  /* wait until SelectionNotify is processed 
+   *
+   * FIXME: Use TSXCheckTypedWindowEvent() instead ( same in the 
+   *	    CLIPBOARD_CheckSelection() ). 
+   */
+
+    selectionWait=True;
+    while(selectionWait) EVENT_WaitNetEvent( TRUE, FALSE );
+
+  /* we treat Unix text as CF_OEMTEXT */
+    TRACE(clipboard,"\tgot CF_OEMTEXT = %i\n", 
+		      ClipFormats[CF_OEMTEXT-1].wDataPresent);
+
+    return (BOOL32)ClipFormats[CF_OEMTEXT-1].wDataPresent;
+}
+
+/**************************************************************************
+ *		X11DRV_CLIPBOARD_ResetOwner
+ *
+ * Called from DestroyWindow().
+ */
+void X11DRV_CLIPBOARD_ResetOwner(WND *pWnd)
+{
+    LPCLIPFORMAT lpFormat = ClipFormats;
+
+    TRACE(clipboard,"clipboard owner = %04x, selection = %08x\n", 
+				hWndClipOwner, (unsigned)selectionWindow);
+
+    if( pWnd->hwndSelf == hWndClipOwner)
+    {
+	SendMessage16(hWndClipOwner,WM_RENDERALLFORMATS,0,0L);
+
+	/* check if all formats were rendered */
+
+	while(lpFormat)
+	{
+	    if( lpFormat->wDataPresent && !lpFormat->hData16 && !lpFormat->hData32 )
+	    {
+		TRACE(clipboard,"\tdata missing for clipboard format %i\n", 
+				   lpFormat->wFormatID); 
+		lpFormat->wDataPresent = 0;
+	    }
+	    lpFormat = lpFormat->NextFormat;
+	}
+	hWndClipOwner = 0;
+    }
+
+    /* now try to salvage current selection from being destroyed by X */
+
+    if( pWnd->window ) X11DRV_CLIPBOARD_CheckSelection(pWnd);
+}
+
+#endif /* !defined(X_DISPLAY_MISSING) */

windows/x11drv/init.c

 /*
- * X11 windows driver
+ * X11 driver
  *
- * Copyright 1993, 1994 Alexandre Julliard
  * Copyright 1998 Patrik Stridvall
  */
 
-#include <string.h>
-#include <X11/Xatom.h>
-#include "ts_xlib.h"
-#include "color.h"
-#include "display.h"
-#include "dce.h"
-#include "options.h"
-#include "message.h"
-#include "win.h"
-#include "windows.h"
-#include "x11drv.h"
+#include "config.h"
+
+#ifndef X_DISPLAY_MISSING
 
-static BOOL32 X11DRV_WND_CreateWindow(WND *wndPtr, CLASS *classPtr, CREATESTRUCT32A *cs, BOOL32 bUnicode);
-static WND *X11DRV_WND_SetParent(WND *wndPtr, WND *pWndParent);
+#include "x11drv.h"
 
 WND_DRIVER X11DRV_WND_Driver =
 {
-    X11DRV_WND_CreateWindow,
-    X11DRV_WND_SetParent
+  X11DRV_WND_CreateDesktopWindow,
+  X11DRV_WND_CreateWindow,
+  X11DRV_WND_DestroyWindow,
+  X11DRV_WND_SetParent,
+  X11DRV_WND_ForceWindowRaise,
+  X11DRV_WND_SetWindowPos,
+  X11DRV_WND_SetText,
+  X11DRV_WND_SetFocus,
+  X11DRV_WND_PreSizeMove,
+  X11DRV_WND_PostSizeMove
 };
 
-extern Cursor DISPLAY_XCursor;  /* Current X cursor */
+CLIPBOARD_DRIVER X11DRV_CLIPBOARD_Driver =
+{
+  X11DRV_CLIPBOARD_EmptyClipboard,
+  X11DRV_CLIPBOARD_SetClipboardData,
+  X11DRV_CLIPBOARD_RequestSelection,
+  X11DRV_CLIPBOARD_ResetOwner
+};
 
-/**********************************************************************
- *		X11DRV_WND_CreateWindow	[Internal]
- */
-static BOOL32 X11DRV_WND_CreateWindow(WND *wndPtr, CLASS *classPtr, CREATESTRUCT32A *cs, BOOL32 bUnicode)
+KEYBOARD_DRIVER X11DRV_KEYBOARD_Driver =
 {
-  /* Create the X window (only for top-level windows, and then only */
-  /* when there's no desktop window) */
-  
-  if (!(cs->style & WS_CHILD) && (rootWindow == DefaultRootWindow(display)))
-    {
-      XSetWindowAttributes win_attr;
-      
-      if (Options.managed && ((cs->style & (WS_DLGFRAME | WS_THICKFRAME)) ||
-			      (cs->dwExStyle & WS_EX_DLGMODALFRAME)))
-        {
-	  win_attr.event_mask = ExposureMask | KeyPressMask |
-	    KeyReleaseMask | PointerMotionMask |
-	    ButtonPressMask | ButtonReleaseMask |
-	    FocusChangeMask | StructureNotifyMask;
-	  win_attr.override_redirect = FALSE;
-	  wndPtr->flags |= WIN_MANAGED;
-	}
-      else
-        {
-	  win_attr.event_mask = ExposureMask | KeyPressMask |
-	    KeyReleaseMask | PointerMotionMask |
-	    ButtonPressMask | ButtonReleaseMask |
-	    FocusChangeMask;
-	  win_attr.override_redirect = TRUE;
-	}
-      win_attr.colormap      = COLOR_GetColormap();
-      win_attr.backing_store = Options.backingstore ? WhenMapped : NotUseful;
-      win_attr.save_under    = ((classPtr->style & CS_SAVEBITS) != 0);
-      win_attr.cursor        = DISPLAY_XCursor;
-      wndPtr->window = TSXCreateWindow( display, rootWindow, cs->x, cs->y,
-                                        cs->cx, cs->cy, 0, CopyFromParent,
-                                        InputOutput, CopyFromParent,
-                                        CWEventMask | CWOverrideRedirect |
-                                        CWColormap | CWCursor | CWSaveUnder |
-                                        CWBackingStore, &win_attr );
+  X11DRV_KEYBOARD_Init,
+  X11DRV_KEYBOARD_VkKeyScan,
+  X11DRV_KEYBOARD_MapVirtualKey,
+  X11DRV_KEYBOARD_GetKeyNameText,
+  X11DRV_KEYBOARD_ToAscii
+};
 
-      if ((wndPtr->flags & WIN_MANAGED) &&
-	  (cs->dwExStyle & WS_EX_DLGMODALFRAME))
-        {
-	  XSizeHints* size_hints = TSXAllocSizeHints();
-	  
-	  if (size_hints)
-            {
-	      size_hints->min_width = size_hints->max_width = cs->cx;
-	      size_hints->min_height = size_hints->max_height = cs->cy;
-                size_hints->flags = (PSize | PMinSize | PMaxSize);
-                TSXSetWMSizeHints( display, wndPtr->window, size_hints,
-				   XA_WM_NORMAL_HINTS );
-                TSXFree(size_hints);
-            }
-        }
-      
-      if (cs->hwndParent)  /* Get window owner */
-	{
-	  Window win = WIN_GetXWindow( cs->hwndParent );
-	  if (win) TSXSetTransientForHint( display, wndPtr->window, win );
-	}
-      EVENT_RegisterWindow( wndPtr );
-    }
-  return TRUE;
-}
+EVENT_DRIVER X11DRV_EVENT_Driver = 
+{
+  X11DRV_EVENT_Init,
+  X11DRV_EVENT_AddIO,
+  X11DRV_EVENT_DeleteIO,
+  X11DRV_EVENT_WaitNetEvent,
+  X11DRV_EVENT_Synchronize,
+  X11DRV_EVENT_CheckFocus,
+  X11DRV_EVENT_QueryPointer,
+  X11DRV_EVENT_DummyMotionNotify,
+  X11DRV_EVENT_Pending,
+  X11DRV_EVENT_IsUserIdle
+};
 
-/*****************************************************************
- *		X11DRV_WND_SetParent	[Internal]
- */
-static WND *X11DRV_WND_SetParent(WND *wndPtr, WND *pWndParent)
+#if 0 
+MOUSE_DRIVER X11DRV_MOUSE_Driver =
 {
-    if( wndPtr && pWndParent && (wndPtr != WIN_GetDesktop()) )
-    {
-	WND* pWndPrev = wndPtr->parent;
+};
+#endif
+
+#endif /* !defined(X_DISPLAY_MISSING) */
 
-	if( pWndParent != pWndPrev )
-	{
-	    BOOL32 bFixupDCE = IsWindowVisible32(wndPtr->hwndSelf);
 
-	    if ( wndPtr->window )
-	    {
-		/* Toplevel window needs to be reparented.  Used by Tk 8.0 */
 
-		TSXDestroyWindow( display, wndPtr->window );
-		wndPtr->window = None;
-	    }
-	    else if( bFixupDCE )
-		DCE_InvalidateDCE( wndPtr, &wndPtr->rectWindow );
 
-	    WIN_UnlinkWindow(wndPtr->hwndSelf);
-	    wndPtr->parent = pWndParent;
 
-	    /* FIXME: Create an X counterpart for reparented top-level windows
-	     * when not in the desktop mode. */
-     
-	    if ( pWndParent != WIN_GetDesktop() ) wndPtr->dwStyle |= WS_CHILD;
-	    WIN_LinkWindow(wndPtr->hwndSelf, HWND_BOTTOM);
 
-	    if( bFixupDCE )
-	    {
-	        DCE_InvalidateDCE( wndPtr, &wndPtr->rectWindow );
-		UpdateWindow32(wndPtr->hwndSelf);
-	    }
-	}
-	return pWndPrev;
-    } /* failure */
-    return 0;
-}

windows/x11drv/mouse.c

+/*
+ * X11 windows driver
+ *
+ * Copyright 1998 Patrik Stridvall
+ */
+
+#include "config.h"
+
+#ifndef X_DISPLAY_MISSING
+
+#include "x11drv.h"
+
+#endif /* !defined(X_DISPLAY_MISSING) */