system/wine
system/wine
1
0
Fork 0
mirror of git://source.winehq.org/git/wine.git synced 2024-11-02 12:03:45 +00:00
Code Issues Projects Releases Packages Wiki Activity

Moved graphics initialisation to the x11drv/ttydrv dll init code.

Browse source 
Merged event, keyboard and mouse drivers into USER driver.
This commit is contained in:
Alexandre Julliard 2000-03-20 18:21:19 +00:00
parent c03da6680d
commit 28c3a1baf3
34 changed files with 274 additions and 533 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
controls/desktop.c
View file

@ -16,9 +16,6 @@
#include "win.h" #include "win.h"
#include "wine/winuser16.h" #include "wine/winuser16.h"
/**********************************************************************/
DESKTOP_DRIVER *DESKTOP_Driver = NULL;
/*********************************************************************** /***********************************************************************
* DESKTOP_IsSingleWindow * DESKTOP_IsSingleWindow

12
dlls/dinput/dinput_main.c
View file

@ -43,7 +43,7 @@
#include "dinput.h" #include "dinput.h"
#include "display.h" #include "display.h"
#include "input.h" #include "input.h"
#include "keyboard.h" #include "user.h"
#include "message.h" #include "message.h"
#include "mouse.h" #include "mouse.h"
#include "sysmetrics.h" #include "sysmetrics.h"
@ -782,7 +782,7 @@ static HRESULT WINAPI SysKeyboardAImpl_GetDeviceState(
LPDIRECTINPUTDEVICE2A iface,DWORD len,LPVOID ptr LPDIRECTINPUTDEVICE2A iface,DWORD len,LPVOID ptr
) )
{ {
return KEYBOARD_Driver->pGetDIState(len, ptr)?DI_OK:E_FAIL; return USER_Driver->pGetDIState(len, ptr)?DI_OK:E_FAIL;
} }
static HRESULT WINAPI SysKeyboardAImpl_GetDeviceData( static HRESULT WINAPI SysKeyboardAImpl_GetDeviceData(
@ -797,7 +797,7 @@ static HRESULT WINAPI SysKeyboardAImpl_GetDeviceData(
TRACE("(this=%p,%ld,%p,%p(%ld)),0x%08lx)\n", TRACE("(this=%p,%ld,%p,%p(%ld)),0x%08lx)\n",
This,dodsize,dod,entries,entries?*entries:0,flags); This,dodsize,dod,entries,entries?*entries:0,flags);
ret=KEYBOARD_Driver->pGetDIData( ret=USER_Driver->pGetDIData(
This->keystate, dodsize, dod, entries, flags)?DI_OK:E_FAIL; This->keystate, dodsize, dod, entries, flags)?DI_OK:E_FAIL;
for (i=0;i<*entries;i++) { for (i=0;i<*entries;i++) {
dod[i].dwTimeStamp = GetTickCount(); dod[i].dwTimeStamp = GetTickCount();
@ -816,11 +816,11 @@ static HRESULT WINAPI SysKeyboardAImpl_Acquire(LPDIRECTINPUTDEVICE2A iface)
KEYBOARD_CONFIG no_auto; KEYBOARD_CONFIG no_auto;
/* Save the original config */ /* Save the original config */
KEYBOARD_Driver->pGetKeyboardConfig(&(This->initial_config)); USER_Driver->pGetKeyboardConfig(&(This->initial_config));
/* Now, remove auto-repeat */ /* Now, remove auto-repeat */
no_auto.auto_repeat = FALSE; no_auto.auto_repeat = FALSE;
KEYBOARD_Driver->pSetKeyboardConfig(&no_auto, WINE_KEYBOARD_CONFIG_AUTO_REPEAT); USER_Driver->pSetKeyboardConfig(&no_auto, WINE_KEYBOARD_CONFIG_AUTO_REPEAT);
This->acquired = 1; This->acquired = 1;
} }
@ -835,7 +835,7 @@ static HRESULT WINAPI SysKeyboardAImpl_Unacquire(LPDIRECTINPUTDEVICE2A iface)
if (This->acquired == 1) { if (This->acquired == 1) {
/* Restore the original configuration */ /* Restore the original configuration */
KEYBOARD_Driver->pSetKeyboardConfig(&(This->initial_config), 0xFFFFFFFF); USER_Driver->pSetKeyboardConfig(&(This->initial_config), 0xFFFFFFFF);
This->acquired = 0; This->acquired = 0;
} else { } else {
ERR("Unacquiring a not-acquired device !!!\n"); ERR("Unacquiring a not-acquired device !!!\n");

10
dlls/display/display_main.c
View file

@ -9,10 +9,10 @@
#include "display.h" #include "display.h"
#include "mouse.h" #include "mouse.h"
#include "windef.h" #include "windef.h"
#include "message.h" #include "user.h"
#include "wine/winuser16.h" #include "wine/winuser16.h"
DEFAULT_DEBUG_CHANNEL(cursor) DEFAULT_DEBUG_CHANNEL(cursor);
/*********************************************************************** /***********************************************************************
* DISPLAY_Inquire (DISPLAY.101) * DISPLAY_Inquire (DISPLAY.101)
@ -30,7 +30,7 @@ WORD WINAPI DISPLAY_Inquire(LPCURSORINFO lpCursorInfo)
*/ */
VOID WINAPI DISPLAY_SetCursor( struct tagCURSORICONINFO *lpCursor ) VOID WINAPI DISPLAY_SetCursor( struct tagCURSORICONINFO *lpCursor )
{ {
MOUSE_Driver->pSetCursor(lpCursor); USER_Driver->pSetCursor(lpCursor);
} }
/*********************************************************************** /***********************************************************************
@ -38,7 +38,7 @@ VOID WINAPI DISPLAY_SetCursor( struct tagCURSORICONINFO *lpCursor )
*/ */
VOID WINAPI DISPLAY_MoveCursor( WORD wAbsX, WORD wAbsY ) VOID WINAPI DISPLAY_MoveCursor( WORD wAbsX, WORD wAbsY )
{ {
MOUSE_Driver->pMoveCursor(wAbsX, wAbsY); USER_Driver->pMoveCursor(wAbsX, wAbsY);
} }
/*********************************************************************** /***********************************************************************
@ -70,6 +70,6 @@ DWORD WINAPI DISPLAY_GetDriverResourceID( WORD wQueriedResID, LPSTR lpsResName )
*/ */
VOID WINAPI UserRepaintDisable16( BOOL16 disable ) VOID WINAPI UserRepaintDisable16( BOOL16 disable )
{ {
EVENT_Driver->pUserRepaintDisable( disable ); USER_Driver->pUserRepaintDisable( disable );
} }

15
dlls/mouse/mouse_main.c
View file

@ -13,18 +13,17 @@
#include "module.h" #include "module.h"
#include "mouse.h" #include "mouse.h"
#include "monitor.h" #include "monitor.h"
#include "user.h"
#include "windef.h" #include "windef.h"
#include "wingdi.h" #include "wingdi.h"
#include "winuser.h" #include "winuser.h"
#include "win.h" #include "win.h"
#include "wine/winbase16.h" #include "wine/winbase16.h"
DEFAULT_DEBUG_CHANNEL(event) DEFAULT_DEBUG_CHANNEL(event);
/**********************************************************************/ /**********************************************************************/
MOUSE_DRIVER *MOUSE_Driver = NULL;
static LPMOUSE_EVENT_PROC DefMouseEventProc = NULL; static LPMOUSE_EVENT_PROC DefMouseEventProc = NULL;
/*********************************************************************** /***********************************************************************
@ -57,10 +56,10 @@ VOID WINAPI MOUSE_Enable(LPMOUSE_EVENT_PROC lpMouseEventProc)
/* Now initialize the mouse driver */ /* Now initialize the mouse driver */
if (initDone == FALSE) if (initDone == FALSE)
{ {
MOUSE_Driver->pInit(); USER_Driver->pInitMouse();
initDone = TRUE; initDone = TRUE;
} }
} }
static VOID WINAPI MOUSE_CallMouseEventProc( FARPROC16 proc, static VOID WINAPI MOUSE_CallMouseEventProc( FARPROC16 proc,
@ -127,11 +126,11 @@ void MOUSE_SendEvent( DWORD mouseStatus, DWORD posX, DWORD posY,
wme.hWnd = hWnd; wme.hWnd = hWnd;
wme.keyState = keyState; wme.keyState = keyState;
MOUSE_Driver->pEnableWarpPointer(FALSE); USER_Driver->pEnableWarpPointer(FALSE);
/* To avoid deadlocks, we have to suspend all locks on windows structures /* To avoid deadlocks, we have to suspend all locks on windows structures
before the program control is passed to the mouse driver */ before the program control is passed to the mouse driver */
iWndsLocks = WIN_SuspendWndsLock(); iWndsLocks = WIN_SuspendWndsLock();
DefMouseEventProc( mouseStatus, posX, posY, 0, (DWORD)&wme ); DefMouseEventProc( mouseStatus, posX, posY, 0, (DWORD)&wme );
WIN_RestoreWndsLock(iWndsLocks); WIN_RestoreWndsLock(iWndsLocks);
MOUSE_Driver->pEnableWarpPointer(TRUE); USER_Driver->pEnableWarpPointer(TRUE);
} }

2
dlls/ttydrv/ttydrv.spec
View file

@ -1,3 +1,5 @@
name ttydrv name ttydrv
type win32 type win32
init TTYDRV_Init init TTYDRV_Init
import gdi32.dll

57
dlls/ttydrv/ttydrv_main.c
View file

@ -4,19 +4,68 @@
#include <stdio.h> #include <stdio.h>
#include "winbase.h" #include "winbase.h"
#include "clipboard.h"
#include "gdi.h" #include "gdi.h"
#include "user.h" #include "message.h"
#include "monitor.h"
#include "mouse.h"
#include "ttydrv.h" #include "ttydrv.h"
#include "user.h"
#include "win.h"
static USER_DRIVER user_driver =
{
/* event functions */
TTYDRV_EVENT_Synchronize,
TTYDRV_EVENT_CheckFocus,
TTYDRV_EVENT_UserRepaintDisable,
/* keyboard functions */
TTYDRV_KEYBOARD_Init,
TTYDRV_KEYBOARD_VkKeyScan,
TTYDRV_KEYBOARD_MapVirtualKey,
TTYDRV_KEYBOARD_GetKeyNameText,
TTYDRV_KEYBOARD_ToAscii,
TTYDRV_KEYBOARD_GetBeepActive,
TTYDRV_KEYBOARD_SetBeepActive,
TTYDRV_KEYBOARD_Beep,
TTYDRV_KEYBOARD_GetDIState,
TTYDRV_KEYBOARD_GetDIData,
TTYDRV_KEYBOARD_GetKeyboardConfig,
TTYDRV_KEYBOARD_SetKeyboardConfig,
/* mouse functions */
TTYDRV_MOUSE_Init,
TTYDRV_MOUSE_SetCursor,
TTYDRV_MOUSE_MoveCursor,
TTYDRV_MOUSE_EnableWarpPointer
};
/*********************************************************************** /***********************************************************************
* TTYDRV initialisation routine * TTYDRV initialisation routine
*/ */
BOOL WINAPI TTYDRV_Init( HINSTANCE hinst, DWORD reason, LPVOID reserved ) BOOL WINAPI TTYDRV_Init( HINSTANCE hinst, DWORD reason, LPVOID reserved )
{ {
if (reason == DLL_PROCESS_ATTACH) switch(reason)
{ {
GDI_Driver = &TTYDRV_GDI_Driver; case DLL_PROCESS_ATTACH:
USER_Driver = &TTYDRV_USER_Driver; USER_Driver = &user_driver;
CLIPBOARD_Driver = &TTYDRV_CLIPBOARD_Driver;
MONITOR_Driver = &TTYDRV_MONITOR_Driver;
WND_Driver = &TTYDRV_WND_Driver;
TTYDRV_MONITOR_Initialize( &MONITOR_PrimaryMonitor );
TTYDRV_GDI_Initialize();
break;
case DLL_PROCESS_DETACH:
TTYDRV_GDI_Finalize();
TTYDRV_MONITOR_Finalize( &MONITOR_PrimaryMonitor );
USER_Driver = NULL;
CLIPBOARD_Driver = NULL;
MONITOR_Driver = NULL;
WND_Driver = NULL;
break;
} }
return TRUE; return TRUE;
} }

2
dlls/x11drv/x11drv.spec
View file

@ -1,3 +1,5 @@
name x11drv name x11drv
type win32 type win32
init X11DRV_Init init X11DRV_Init
import gdi32.dll

152
dlls/x11drv/x11drv_main.c
View file

@ -1,22 +1,168 @@
/* /*
* X11DRV initialization code * X11DRV initialization code
*
* Copyright 1998 Patrik Stridvall
* Copyright 2000 Alexandre Julliard
*/ */
#include <stdio.h> #include <stdio.h>
#include <stdlib.h>
#include "ts_xlib.h"
#include "winbase.h" #include "winbase.h"
#include "clipboard.h"
#include "debugtools.h"
#include "gdi.h" #include "gdi.h"
#include "monitor.h"
#include "options.h"
#include "user.h" #include "user.h"
#include "win.h"
#include "x11drv.h" #include "x11drv.h"
static USER_DRIVER user_driver =
{
/* event functions */
X11DRV_EVENT_Synchronize,
X11DRV_EVENT_CheckFocus,
X11DRV_EVENT_UserRepaintDisable,
/* keyboard functions */
X11DRV_KEYBOARD_Init,
X11DRV_KEYBOARD_VkKeyScan,
X11DRV_KEYBOARD_MapVirtualKey,
X11DRV_KEYBOARD_GetKeyNameText,
X11DRV_KEYBOARD_ToAscii,
X11DRV_KEYBOARD_GetBeepActive,
X11DRV_KEYBOARD_SetBeepActive,
X11DRV_KEYBOARD_Beep,
X11DRV_KEYBOARD_GetDIState,
X11DRV_KEYBOARD_GetDIData,
X11DRV_KEYBOARD_GetKeyboardConfig,
X11DRV_KEYBOARD_SetKeyboardConfig,
/* mouse functions */
X11DRV_MOUSE_Init,
X11DRV_MOUSE_SetCursor,
X11DRV_MOUSE_MoveCursor,
X11DRV_MOUSE_EnableWarpPointer
};
static XKeyboardState keyboard_state;
Display *display;
/***********************************************************************
* error_handler
*/
static int error_handler(Display *display, XErrorEvent *error_evt)
{
DebugBreak(); /* force an entry in the debugger */
return 0;
}
/***********************************************************************
* X11DRV process initialisation routine
*/
static void process_attach(void)
{
USER_Driver = &user_driver;
CLIPBOARD_Driver = &X11DRV_CLIPBOARD_Driver;
MONITOR_Driver = &X11DRV_MONITOR_Driver;
WND_Driver = &X11DRV_WND_Driver;
/* We need this before calling any Xlib function */
InitializeCriticalSection( &X11DRV_CritSection );
MakeCriticalSectionGlobal( &X11DRV_CritSection );
putenv("XKB_DISABLE="); /* Disable XKB extension if present. */
/* Open display */
if (!(display = TSXOpenDisplay( Options.display )))
{
MESSAGE( "%s: Can't open display: %s\n",
argv0, Options.display ? Options.display : "(none specified)" );
ExitProcess(1);
}
/* tell the libX11 that we will do input method handling ourselves
* that keep libX11 from doing anything whith dead keys, allowing Wine
* to have total control over dead keys, that is this line allows
* them to work in Wine, even whith a libX11 including the dead key
* patches from Th.Quinot (http://Web.FdN.FR/~tquinot/dead-keys.en.html)
*/
TSXOpenIM(display,NULL,NULL,NULL);
if (Options.synchronous) XSetErrorHandler( error_handler );
if (Options.desktopGeometry && Options.managed) Options.managed = FALSE;
/* initialize monitor */
X11DRV_MONITOR_Initialize( &MONITOR_PrimaryMonitor );
/* initialize GDI */
X11DRV_GDI_Initialize();
/* save keyboard setup */
TSXGetKeyboardControl(display, &keyboard_state);
/* initialize event handling */
X11DRV_EVENT_Init();
}
/***********************************************************************
* X11DRV process termination routine
*/
static void process_detach(void)
{
/* restore keyboard setup */
XKeyboardControl keyboard_value;
keyboard_value.key_click_percent = keyboard_state.key_click_percent;
keyboard_value.bell_percent = keyboard_state.bell_percent;
keyboard_value.bell_pitch = keyboard_state.bell_pitch;
keyboard_value.bell_duration = keyboard_state.bell_duration;
keyboard_value.auto_repeat_mode = keyboard_state.global_auto_repeat;
XChangeKeyboardControl(display, KBKeyClickPercent | KBBellPercent |
KBBellPitch | KBBellDuration | KBAutoRepeatMode, &keyboard_value);
/* cleanup GDI */
X11DRV_GDI_Finalize();
#if 0 /* FIXME */
/* cleanup monitor */
X11DRV_MONITOR_Finalize( &MONITOR_PrimaryMonitor );
/* close the display */
XCloseDisplay( display );
display = NULL;
USER_Driver = NULL;
CLIPBOARD_Driver = NULL;
MONITOR_Driver = NULL;
WND_Driver = NULL;
#endif
}
/*********************************************************************** /***********************************************************************
* X11DRV initialisation routine * X11DRV initialisation routine
*/ */
BOOL WINAPI X11DRV_Init( HINSTANCE hinst, DWORD reason, LPVOID reserved ) BOOL WINAPI X11DRV_Init( HINSTANCE hinst, DWORD reason, LPVOID reserved )
{ {
if (reason == DLL_PROCESS_ATTACH) static int process_count;
switch(reason)
{ {
GDI_Driver = &X11DRV_GDI_Driver; case DLL_PROCESS_ATTACH:
USER_Driver = &X11DRV_USER_Driver; if (!process_count++) process_attach();
break;
case DLL_PROCESS_DETACH:
if (!--process_count) process_detach();
break;
} }
return TRUE; return TRUE;
} }

6
graphics/ttydrv/init.c
View file

@ -112,12 +112,6 @@ static const DC_FUNCTIONS TTYDRV_DC_Driver =
}; };
GDI_DRIVER TTYDRV_GDI_Driver =
{
TTYDRV_GDI_Initialize,
TTYDRV_GDI_Finalize
};
BITMAP_DRIVER TTYDRV_BITMAP_Driver = BITMAP_DRIVER TTYDRV_BITMAP_Driver =
{ {
TTYDRV_BITMAP_SetDIBits, TTYDRV_BITMAP_SetDIBits,

6
graphics/x11drv/init.c
View file

@ -126,12 +126,6 @@ static const DC_FUNCTIONS X11DRV_Funcs =
NULL /* pWidenPath */ NULL /* pWidenPath */
}; };
GDI_DRIVER X11DRV_GDI_Driver =
{
X11DRV_GDI_Initialize,
X11DRV_GDI_Finalize
};
BITMAP_DRIVER X11DRV_BITMAP_Driver = BITMAP_DRIVER X11DRV_BITMAP_Driver =
{ {
X11DRV_DIB_SetDIBits, X11DRV_DIB_SetDIBits,

12
include/desktop.h
View file

@ -9,7 +9,6 @@
#include "windef.h" #include "windef.h"
struct tagDESKTOP_DRIVER;
struct tagMONITOR; struct tagMONITOR;
typedef struct tagDESKTOP typedef struct tagDESKTOP
@ -18,18 +17,9 @@ typedef struct tagDESKTOP
HBITMAP hbitmapWallPaper; HBITMAP hbitmapWallPaper;
SIZE bitmapSize; SIZE bitmapSize;
BOOL fTileWallPaper; BOOL fTileWallPaper;
struct tagMONITOR *pPrimaryMonitor; struct tagMONITOR *pPrimaryMonitor;
struct tagDESKTOP_DRIVER *pDriver; /* Desktop driver */
void *pDriverData; /* Desktop driver data */
} DESKTOP; } DESKTOP;
typedef struct tagDESKTOP_DRIVER {
void (*pInitialize)(struct tagDESKTOP *pDesktop);
void (*pFinalize)(struct tagDESKTOP *pDesktop);
} DESKTOP_DRIVER;
extern DESKTOP_DRIVER *DESKTOP_Driver;
extern BOOL DESKTOP_IsSingleWindow(void); extern BOOL DESKTOP_IsSingleWindow(void);
extern int DESKTOP_GetScreenWidth(void); extern int DESKTOP_GetScreenWidth(void);
extern int DESKTOP_GetScreenHeight(void); extern int DESKTOP_GetScreenHeight(void);

24
include/keyboard.h
View file

@ -9,8 +9,6 @@
#include "windef.h" #include "windef.h"
struct DIDEVICEOBJECTDATA;
#include "pshpack1.h" #include "pshpack1.h"
typedef struct _KBINFO typedef struct _KBINFO
{ {
@ -31,28 +29,6 @@ VOID WINAPI KEYBOARD_Disable(VOID);
/* Wine internals */ /* Wine internals */
#define WINE_KEYBOARD_CONFIG_AUTO_REPEAT 0x00000001
typedef struct tagKEYBOARD_CONFIG {
BOOL auto_repeat;
} KEYBOARD_CONFIG;
typedef struct tagKEYBOARD_DRIVER {
void (*pInit)(void);
WORD (*pVkKeyScan)(CHAR);
UINT16 (*pMapVirtualKey)(UINT16, UINT16);
INT16 (*pGetKeyNameText)(LONG, LPSTR, INT16);
INT16 (*pToAscii)(UINT16, UINT16, LPBYTE, LPVOID, UINT16);
BOOL (*pGetBeepActive)(void);
void (*pSetBeepActive)(BOOL);
void (*pBeep)(void);
BOOL (*pGetDIState)(DWORD, LPVOID);
BOOL (*pGetDIData)(BYTE *, DWORD, struct DIDEVICEOBJECTDATA *, LPDWORD, DWORD);
void (*pGetKeyboardConfig)(KEYBOARD_CONFIG *);
void (*pSetKeyboardConfig)(KEYBOARD_CONFIG *, DWORD);
} KEYBOARD_DRIVER;
extern KEYBOARD_DRIVER *KEYBOARD_Driver;
extern BOOL KEYBOARD_GetBeepActive(void); extern BOOL KEYBOARD_GetBeepActive(void);
extern void KEYBOARD_SetBeepActive(BOOL bActivate); extern void KEYBOARD_SetBeepActive(BOOL bActivate);
extern void KEYBOARD_Beep(void); extern void KEYBOARD_Beep(void);

10
include/message.h
View file

@ -26,16 +26,6 @@ extern BOOL TIMER_GetTimerMsg( struct tagMSG *msg, HWND hwnd,
HQUEUE16 hQueue, BOOL remove ); HQUEUE16 hQueue, BOOL remove );
/* event.c */ /* event.c */
typedef struct tagEVENT_DRIVER {
BOOL (*pInit)(void);
void (*pSynchronize)(void);
BOOL (*pCheckFocus)(void);
void (*pUserRepaintDisable)(BOOL);
} EVENT_DRIVER;
extern EVENT_DRIVER *EVENT_Driver;
extern BOOL EVENT_Init( void );
extern void EVENT_Synchronize( void ); extern void EVENT_Synchronize( void );
extern BOOL EVENT_CheckFocus( void ); extern BOOL EVENT_CheckFocus( void );

2
include/monitor.h
View file

@ -32,8 +32,6 @@ extern MONITOR_DRIVER *MONITOR_Driver;
extern MONITOR MONITOR_PrimaryMonitor; extern MONITOR MONITOR_PrimaryMonitor;
extern void MONITOR_Initialize(MONITOR *pMonitor);
extern void MONITOR_Finalize(MONITOR *pMonitor);
extern BOOL MONITOR_IsSingleWindow(MONITOR *pMonitor); extern BOOL MONITOR_IsSingleWindow(MONITOR *pMonitor);
extern int MONITOR_GetWidth(MONITOR *pMonitor); extern int MONITOR_GetWidth(MONITOR *pMonitor);
extern int MONITOR_GetHeight(MONITOR *pMonitor); extern int MONITOR_GetHeight(MONITOR *pMonitor);

9
include/mouse.h
View file

@ -34,15 +34,6 @@ VOID WINAPI MOUSE_Disable(VOID);
/* Wine internals */ /* Wine internals */
typedef struct tagMOUSE_DRIVER {
VOID (*pInit)(VOID);
VOID (*pSetCursor)(struct tagCURSORICONINFO *);
VOID (*pMoveCursor)(WORD, WORD);
LONG (*pEnableWarpPointer)(BOOL);
} MOUSE_DRIVER;
extern MOUSE_DRIVER *MOUSE_Driver;
#define WINE_MOUSEEVENT_MAGIC ( ('M'<<24)|('A'<<16)|('U'<<8)|'S' ) #define WINE_MOUSEEVENT_MAGIC ( ('M'<<24)|('A'<<16)|('U'<<8)|'S' )
typedef struct _WINE_MOUSEEVENT typedef struct _WINE_MOUSEEVENT
{ {

20
include/ttydrv.h
View file

@ -114,11 +114,6 @@ extern BOOL TTYDRV_PALETTE_IsDark(int pixel);
* TTY USER driver * TTY USER driver
*/ */
extern struct tagUSER_DRIVER TTYDRV_USER_Driver;
extern BOOL TTYDRV_USER_Initialize(void);
extern void TTYDRV_USER_Finalize(void);
/* TTY clipboard driver */ /* TTY clipboard driver */
extern struct tagCLIPBOARD_DRIVER TTYDRV_CLIPBOARD_Driver; extern struct tagCLIPBOARD_DRIVER TTYDRV_CLIPBOARD_Driver;
@ -134,31 +129,18 @@ extern void TTYDRV_CLIPBOARD_ResetOwner(struct tagWND *pWnd, BOOL bFooBar);
/* TTY desktop driver */ /* TTY desktop driver */
extern struct tagDESKTOP_DRIVER TTYDRV_DESKTOP_Driver;
#ifdef HAVE_LIBCURSES #ifdef HAVE_LIBCURSES
extern WINDOW *TTYDRV_DESKTOP_GetCursesRootWindow(struct tagDESKTOP *pDesktop); extern WINDOW *TTYDRV_DESKTOP_GetCursesRootWindow(struct tagDESKTOP *pDesktop);
#endif /* defined(HAVE_LIBCURSES) */ #endif /* defined(HAVE_LIBCURSES) */
extern void TTYDRV_DESKTOP_Initialize(struct tagDESKTOP *pDesktop);
extern void TTYDRV_DESKTOP_Finalize(struct tagDESKTOP *pDesktop);
extern int TTYDRV_DESKTOP_GetScreenWidth(struct tagDESKTOP *pDesktop);
extern int TTYDRV_DESKTOP_GetScreenHeight(struct tagDESKTOP *pDesktop);
extern int TTYDRV_DESKTOP_GetScreenDepth(struct tagDESKTOP *pDesktop);
/* TTY event driver */ /* TTY event driver */
extern struct tagEVENT_DRIVER TTYDRV_EVENT_Driver;
extern BOOL TTYDRV_EVENT_Init(void);
extern void TTYDRV_EVENT_Synchronize(void); extern void TTYDRV_EVENT_Synchronize(void);
extern BOOL TTYDRV_EVENT_CheckFocus(void); extern BOOL TTYDRV_EVENT_CheckFocus(void);
extern void TTYDRV_EVENT_UserRepaintDisable(BOOL bDisable); extern void TTYDRV_EVENT_UserRepaintDisable(BOOL bDisable);
/* TTY keyboard driver */ /* TTY keyboard driver */
extern struct tagKEYBOARD_DRIVER TTYDRV_KEYBOARD_Driver;
extern void TTYDRV_KEYBOARD_Init(void); extern void TTYDRV_KEYBOARD_Init(void);
extern WORD TTYDRV_KEYBOARD_VkKeyScan(CHAR cChar); extern WORD TTYDRV_KEYBOARD_VkKeyScan(CHAR cChar);
extern UINT16 TTYDRV_KEYBOARD_MapVirtualKey(UINT16 wCode, UINT16 wMapType); extern UINT16 TTYDRV_KEYBOARD_MapVirtualKey(UINT16 wCode, UINT16 wMapType);
@ -209,8 +191,6 @@ extern void TTYDRV_MONITOR_SetScreenSaveTimeout(struct tagMONITOR *pMonitor, int
/* TTY mouse driver */ /* TTY mouse driver */
extern struct tagMOUSE_DRIVER TTYDRV_MOUSE_Driver;
extern void TTYDRV_MOUSE_Init(); extern void TTYDRV_MOUSE_Init();
extern void TTYDRV_MOUSE_SetCursor(struct tagCURSORICONINFO *lpCursor); extern void TTYDRV_MOUSE_SetCursor(struct tagCURSORICONINFO *lpCursor);
extern void TTYDRV_MOUSE_MoveCursor(WORD wAbsX, WORD wAbsY); extern void TTYDRV_MOUSE_MoveCursor(WORD wAbsX, WORD wAbsY);

32
include/user.h
View file

@ -29,9 +29,37 @@ extern WORD USER_HeapSel;
#define USUD_LOCALHEAP 0x0004 #define USUD_LOCALHEAP 0x0004
#define USUD_FIRSTCLASS 0x0005 #define USUD_FIRSTCLASS 0x0005
struct tagCURSORICONINFO;
struct DIDEVICEOBJECTDATA;
#define WINE_KEYBOARD_CONFIG_AUTO_REPEAT 0x00000001
typedef struct tagKEYBOARD_CONFIG {
BOOL auto_repeat;
} KEYBOARD_CONFIG;
typedef struct tagUSER_DRIVER { typedef struct tagUSER_DRIVER {
BOOL (*pInitialize)(void); /* event functions */
void (*pFinalize)(void); void (*pSynchronize)(void);
BOOL (*pCheckFocus)(void);
void (*pUserRepaintDisable)(BOOL);
/* keyboard functions */
void (*pInitKeyboard)(void);
WORD (*pVkKeyScan)(CHAR);
UINT16 (*pMapVirtualKey)(UINT16, UINT16);
INT16 (*pGetKeyNameText)(LONG, LPSTR, INT16);
INT16 (*pToAscii)(UINT16, UINT16, LPBYTE, LPVOID, UINT16);
BOOL (*pGetBeepActive)(void);
void (*pSetBeepActive)(BOOL);
void (*pBeep)(void);
BOOL (*pGetDIState)(DWORD, LPVOID);
BOOL (*pGetDIData)(BYTE *, DWORD, struct DIDEVICEOBJECTDATA *, LPDWORD, DWORD);
void (*pGetKeyboardConfig)(KEYBOARD_CONFIG *);
void (*pSetKeyboardConfig)(KEYBOARD_CONFIG *, DWORD);
/* mouse functions */
void (*pInitMouse)(void);
void (*pSetCursor)(struct tagCURSORICONINFO *);
void (*pMoveCursor)(WORD, WORD);
LONG (*pEnableWarpPointer)(BOOL);
} USER_DRIVER; } USER_DRIVER;
extern USER_DRIVER *USER_Driver; extern USER_DRIVER *USER_Driver;

25
include/x11drv.h
View file

@ -275,8 +275,6 @@ extern void X11DRV_DIB_DeleteDIBSection(struct tagBITMAPOBJ *bmp);
* X11 GDI driver * X11 GDI driver
*/ */
extern struct tagGDI_DRIVER X11DRV_GDI_Driver;
BOOL X11DRV_GDI_Initialize(void); BOOL X11DRV_GDI_Initialize(void);
void X11DRV_GDI_Finalize(void); void X11DRV_GDI_Finalize(void);
@ -312,15 +310,10 @@ extern BOOL X11DRV_PALETTE_IsDark(int pixel);
* X11 USER driver * X11 USER driver
*/ */
extern struct tagUSER_DRIVER X11DRV_USER_Driver;
extern Display *display; extern Display *display;
extern Screen *X11DRV_GetXScreen(void); extern Screen *X11DRV_GetXScreen(void);
extern Window X11DRV_GetXRootWindow(void); extern Window X11DRV_GetXRootWindow(void);
extern BOOL X11DRV_USER_Initialize(void);
extern void X11DRV_USER_Finalize(void);
/* X11 clipboard driver */ /* X11 clipboard driver */
extern struct tagCLIPBOARD_DRIVER X11DRV_CLIPBOARD_Driver; extern struct tagCLIPBOARD_DRIVER X11DRV_CLIPBOARD_Driver;
@ -343,27 +336,13 @@ extern void X11DRV_CLIPBOARD_ReleaseSelection(Atom selType, Window w, HWND hwnd)
/* X11 desktop driver */ /* X11 desktop driver */
extern struct tagDESKTOP_DRIVER X11DRV_DESKTOP_Driver;
typedef struct _X11DRV_DESKTOP_DATA {
int dummy;
} X11DRV_DESKTOP_DATA;
struct tagDESKTOP; struct tagDESKTOP;
extern Screen *X11DRV_DESKTOP_GetXScreen(struct tagDESKTOP *pDesktop); extern Screen *X11DRV_DESKTOP_GetXScreen(struct tagDESKTOP *pDesktop);
extern Window X11DRV_DESKTOP_GetXRootWindow(struct tagDESKTOP *pDesktop); extern Window X11DRV_DESKTOP_GetXRootWindow(struct tagDESKTOP *pDesktop);
extern void X11DRV_DESKTOP_Initialize(struct tagDESKTOP *pDesktop);
extern void X11DRV_DESKTOP_Finalize(struct tagDESKTOP *pDesktop);
extern int X11DRV_DESKTOP_GetScreenWidth(struct tagDESKTOP *pDesktop);
extern int X11DRV_DESKTOP_GetScreenHeight(struct tagDESKTOP *pDesktop);
extern int X11DRV_DESKTOP_GetScreenDepth(struct tagDESKTOP *pDesktop);
/* X11 event driver */ /* X11 event driver */
extern struct tagEVENT_DRIVER X11DRV_EVENT_Driver;
extern WORD X11DRV_EVENT_XStateToKeyState( int state ) ; extern WORD X11DRV_EVENT_XStateToKeyState( int state ) ;
extern BOOL X11DRV_EVENT_Init(void); extern BOOL X11DRV_EVENT_Init(void);
@ -384,8 +363,6 @@ void X11DRV_EVENT_SetDGAStatus(HWND hwnd, int event_base) ;
/* X11 keyboard driver */ /* X11 keyboard driver */
extern struct tagKEYBOARD_DRIVER X11DRV_KEYBOARD_Driver;
extern void X11DRV_KEYBOARD_Init(void); extern void X11DRV_KEYBOARD_Init(void);
extern WORD X11DRV_KEYBOARD_VkKeyScan(CHAR cChar); extern WORD X11DRV_KEYBOARD_VkKeyScan(CHAR cChar);
extern UINT16 X11DRV_KEYBOARD_MapVirtualKey(UINT16 wCode, UINT16 wMapType); extern UINT16 X11DRV_KEYBOARD_MapVirtualKey(UINT16 wCode, UINT16 wMapType);
@ -431,8 +408,6 @@ extern void X11DRV_MONITOR_SetScreenSaveTimeout(struct tagMONITOR *pMonitor, int
/* X11 mouse driver */ /* X11 mouse driver */
extern struct tagMOUSE_DRIVER X11DRV_MOUSE_Driver;
extern void X11DRV_MOUSE_Init(); extern void X11DRV_MOUSE_Init();
extern void X11DRV_MOUSE_SetCursor(struct tagCURSORICONINFO *lpCursor); extern void X11DRV_MOUSE_SetCursor(struct tagCURSORICONINFO *lpCursor);
extern void X11DRV_MOUSE_MoveCursor(WORD wAbsX, WORD wAbsY); extern void X11DRV_MOUSE_MoveCursor(WORD wAbsX, WORD wAbsY);

3
loader/main.c
View file

@ -110,9 +110,6 @@ BOOL MAIN_MainInit( int argc, char *argv[], BOOL win32 )
if (!LoadLibraryA( "x11drv" )) return FALSE; if (!LoadLibraryA( "x11drv" )) return FALSE;
/* Initialize event handling */
if (!EVENT_Init()) return FALSE;
SHELL_InitRegistrySaving(); SHELL_InitRegistrySaving();
return TRUE; return TRUE;

11
misc/main.c
View file

@ -6,12 +6,6 @@
#include "config.h" #include "config.h"
#ifndef X_DISPLAY_MISSING
#include "x11drv.h"
#else /* !defined(X_DISPLAY_MISSING) */
#include "ttydrv.h"
#endif /* !defined(X_DISPLAY_MISSING) */
#include <locale.h> #include <locale.h>
#include <ctype.h> #include <ctype.h>
#include <stdlib.h> #include <stdlib.h>
@ -640,11 +634,6 @@ void MAIN_ParseLanguageOption( const char *arg )
*/ */
static void called_at_exit(void) static void called_at_exit(void)
{ {
if (GDI_Driver)
GDI_Driver->pFinalize();
if (USER_Driver)
USER_Driver->pFinalize();
CONSOLE_Close(); CONSOLE_Close();
} }

4
objects/gdiobj.c
View file

@ -338,10 +338,6 @@ BOOL GDI_Init(void)
ReadFontInformation("SystemFixed", &SystemFixedFont, 0, systemIsBold, 0, 0, 0); ReadFontInformation("SystemFixed", &SystemFixedFont, 0, systemIsBold, 0, 0, 0);
ReadFontInformation("DefaultGui", &DefaultGuiFont, 0, 0, 0, 0, 0); ReadFontInformation("DefaultGui", &DefaultGuiFont, 0, 0, 0, 0, 0);
/* Initialize drivers */
GDI_Driver->pInitialize();
/* Create default palette */ /* Create default palette */
/* DR well *this* palette can't be moveable (?) */ /* DR well *this* palette can't be moveable (?) */

28
windows/event.c
View file

@ -7,30 +7,10 @@
#include "message.h" #include "message.h"
#include "user.h" #include "user.h"
#include "x11drv.h" #include "win.h"
#include "ttydrv.h"
#include "monitor.h"
#include "debugtools.h" #include "debugtools.h"
DECLARE_DEBUG_CHANNEL(event) DECLARE_DEBUG_CHANNEL(event);
/**********************************************************************/
EVENT_DRIVER *EVENT_Driver = NULL;
/***********************************************************************
* EVENT_Init
*
* Initialize input event handling
*/
BOOL EVENT_Init(void)
{
USER_Driver->pInitialize();
MONITOR_Initialize(&MONITOR_PrimaryMonitor);
return EVENT_Driver->pInit();
}
/*********************************************************************** /***********************************************************************
* EVENT_Synchronize * EVENT_Synchronize
@ -40,7 +20,7 @@ BOOL EVENT_Init(void)
void EVENT_Synchronize( void ) void EVENT_Synchronize( void )
{ {
int iWndsLocks = WIN_SuspendWndsLock(); int iWndsLocks = WIN_SuspendWndsLock();
EVENT_Driver->pSynchronize(); USER_Driver->pSynchronize();
WIN_RestoreWndsLock(iWndsLocks); WIN_RestoreWndsLock(iWndsLocks);
} }
@ -49,7 +29,7 @@ void EVENT_Synchronize( void )
*/ */
BOOL EVENT_CheckFocus(void) BOOL EVENT_CheckFocus(void)
{ {
return EVENT_Driver->pCheckFocus(); return USER_Driver->pCheckFocus();
} }

21
windows/keyboard.c
View file

@ -20,6 +20,7 @@
#include "win.h" #include "win.h"
#include "heap.h" #include "heap.h"
#include "keyboard.h" #include "keyboard.h"
#include "user.h"
#include "message.h" #include "message.h"
#include "callback.h" #include "callback.h"
#include "builtin16.h" #include "builtin16.h"
@ -32,8 +33,6 @@ DECLARE_DEBUG_CHANNEL(event)
/**********************************************************************/ /**********************************************************************/
KEYBOARD_DRIVER *KEYBOARD_Driver = NULL;
static LPKEYBD_EVENT_PROC DefKeybEventProc = NULL; static LPKEYBD_EVENT_PROC DefKeybEventProc = NULL;
LPBYTE pKeyStateTable = NULL; LPBYTE pKeyStateTable = NULL;
@ -67,7 +66,7 @@ VOID WINAPI KEYBOARD_Enable( LPKEYBD_EVENT_PROC lpKeybEventProc,
/* all states to false */ /* all states to false */
memset( lpKeyState, 0, 256 ); memset( lpKeyState, 0, 256 );
if (!initDone) KEYBOARD_Driver->pInit(); if (!initDone) USER_Driver->pInitKeyboard();
initDone = TRUE; initDone = TRUE;
} }
@ -181,7 +180,7 @@ DWORD WINAPI OemKeyScan(WORD wOemChar)
WORD WINAPI VkKeyScan16(CHAR cChar) WORD WINAPI VkKeyScan16(CHAR cChar)
{ {
return KEYBOARD_Driver->pVkKeyScan(cChar); return USER_Driver->pVkKeyScan(cChar);
} }
/****************************************************************************** /******************************************************************************
@ -214,7 +213,7 @@ INT16 WINAPI GetKeyboardType16(INT16 nTypeFlag)
*/ */
UINT16 WINAPI MapVirtualKey16(UINT16 wCode, UINT16 wMapType) UINT16 WINAPI MapVirtualKey16(UINT16 wCode, UINT16 wMapType)
{ {
return KEYBOARD_Driver->pMapVirtualKey(wCode,wMapType); return USER_Driver->pMapVirtualKey(wCode,wMapType);
} }
/**************************************************************************** /****************************************************************************
@ -231,7 +230,7 @@ INT16 WINAPI GetKBCodePage16(void)
*/ */
INT16 WINAPI GetKeyNameText16(LONG lParam, LPSTR lpBuffer, INT16 nSize) INT16 WINAPI GetKeyNameText16(LONG lParam, LPSTR lpBuffer, INT16 nSize)
{ {
return KEYBOARD_Driver->pGetKeyNameText(lParam, lpBuffer, nSize); return USER_Driver->pGetKeyNameText(lParam, lpBuffer, nSize);
} }
/**************************************************************************** /****************************************************************************
@ -255,9 +254,7 @@ INT16 WINAPI GetKeyNameText16(LONG lParam, LPSTR lpBuffer, INT16 nSize)
INT16 WINAPI ToAscii16(UINT16 virtKey,UINT16 scanCode, LPBYTE lpKeyState, INT16 WINAPI ToAscii16(UINT16 virtKey,UINT16 scanCode, LPBYTE lpKeyState,
LPVOID lpChar, UINT16 flags) LPVOID lpChar, UINT16 flags)
{ {
return KEYBOARD_Driver->pToAscii( return USER_Driver->pToAscii( virtKey, scanCode, lpKeyState, lpChar, flags );
virtKey, scanCode, lpKeyState, lpChar, flags
);
} }
/*********************************************************************** /***********************************************************************
@ -265,7 +262,7 @@ INT16 WINAPI ToAscii16(UINT16 virtKey,UINT16 scanCode, LPBYTE lpKeyState,
*/ */
BOOL KEYBOARD_GetBeepActive() BOOL KEYBOARD_GetBeepActive()
{ {
return KEYBOARD_Driver->pGetBeepActive(); return USER_Driver->pGetBeepActive();
} }
/*********************************************************************** /***********************************************************************
@ -273,7 +270,7 @@ BOOL KEYBOARD_GetBeepActive()
*/ */
void KEYBOARD_SetBeepActive(BOOL bActivate) void KEYBOARD_SetBeepActive(BOOL bActivate)
{ {
KEYBOARD_Driver->pSetBeepActive(bActivate); USER_Driver->pSetBeepActive(bActivate);
} }
/*********************************************************************** /***********************************************************************
@ -281,6 +278,6 @@ void KEYBOARD_SetBeepActive(BOOL bActivate)
*/ */
void KEYBOARD_Beep(void) void KEYBOARD_Beep(void)
{ {
KEYBOARD_Driver->pBeep(); USER_Driver->pBeep();
} }

16
windows/multimon.c
View file

@ -37,22 +37,6 @@ static MONITOR *MONITOR_GetMonitor(HMONITOR hMonitor)
} }
#endif #endif
/***********************************************************************
* MONITOR_Initialize
*/
void MONITOR_Initialize(MONITOR *pMonitor)
{
MONITOR_Driver->pInitialize(pMonitor);
}
/***********************************************************************
* MONITOR_Finalize
*/
void MONITOR_Finalize(MONITOR *pMonitor)
{
MONITOR_Driver->pFinalize(pMonitor);
}
/*********************************************************************** /***********************************************************************
* MONITOR_IsSingleWindow * MONITOR_IsSingleWindow
*/ */

48
windows/ttydrv/desktop.c
View file

@ -25,51 +25,3 @@ WINDOW *TTYDRV_DESKTOP_GetCursesRootWindow(DESKTOP *pDesktop)
return TTYDRV_MONITOR_GetCursesRootWindow(pDesktop->pPrimaryMonitor); return TTYDRV_MONITOR_GetCursesRootWindow(pDesktop->pPrimaryMonitor);
} }
#endif /* defined(HAVE_LIBCURSES) */ #endif /* defined(HAVE_LIBCURSES) */
/***********************************************************************
* TTYDRV_DESKTOP_Initialize
*/
void TTYDRV_DESKTOP_Initialize(DESKTOP *pDesktop)
{
TRACE("(%p): stub\n", pDesktop);
pDesktop->pPrimaryMonitor = &MONITOR_PrimaryMonitor;
}
/***********************************************************************
* TTYDRV_DESKTOP_Finalize
*/
void TTYDRV_DESKTOP_Finalize(DESKTOP *pDesktop)
{
TRACE("(%p): stub\n", pDesktop);
}
/***********************************************************************
* TTYDRV_DESKTOP_GetScreenWidth
*
* Return the width of the screen associated to the desktop.
*/
int TTYDRV_DESKTOP_GetScreenWidth(DESKTOP *pDesktop)
{
return MONITOR_GetWidth(pDesktop->pPrimaryMonitor);
}
/***********************************************************************
* TTYDRV_DESKTOP_GetScreenHeight
*
* Return the width of the screen associated to the desktop.
*/
int TTYDRV_DESKTOP_GetScreenHeight(DESKTOP *pDesktop)
{
return MONITOR_GetHeight(pDesktop->pPrimaryMonitor);
}
/***********************************************************************
* TTYDRV_DESKTOP_GetScreenDepth
*
* Return the depth of the screen associated to the desktop.
*/
int TTYDRV_DESKTOP_GetScreenDepth(DESKTOP *pDesktop)
{
return MONITOR_GetDepth(pDesktop->pPrimaryMonitor);
}

8
windows/ttydrv/event.c
View file

@ -6,14 +6,6 @@
#include "ttydrv.h" #include "ttydrv.h"
/***********************************************************************
* TTYDRV_EVENT_Init
*/
BOOL TTYDRV_EVENT_Init(void)
{
return TRUE;
}
/*********************************************************************** /***********************************************************************
* TTYDRV_EVENT_Synchronize * TTYDRV_EVENT_Synchronize
*/ */

48
windows/ttydrv/init.c
View file

@ -5,21 +5,11 @@
*/ */
#include "clipboard.h" #include "clipboard.h"
#include "desktop.h"
#include "keyboard.h"
#include "message.h"
#include "monitor.h" #include "monitor.h"
#include "mouse.h"
#include "user.h" #include "user.h"
#include "win.h" #include "win.h"
#include "ttydrv.h" #include "ttydrv.h"
USER_DRIVER TTYDRV_USER_Driver =
{
TTYDRV_USER_Initialize,
TTYDRV_USER_Finalize
};
CLIPBOARD_DRIVER TTYDRV_CLIPBOARD_Driver = CLIPBOARD_DRIVER TTYDRV_CLIPBOARD_Driver =
{ {
TTYDRV_CLIPBOARD_Acquire, TTYDRV_CLIPBOARD_Acquire,
@ -32,36 +22,6 @@ CLIPBOARD_DRIVER TTYDRV_CLIPBOARD_Driver =
TTYDRV_CLIPBOARD_ResetOwner TTYDRV_CLIPBOARD_ResetOwner
}; };
DESKTOP_DRIVER TTYDRV_DESKTOP_Driver =
{
TTYDRV_DESKTOP_Initialize,
TTYDRV_DESKTOP_Finalize
};
EVENT_DRIVER TTYDRV_EVENT_Driver =
{
TTYDRV_EVENT_Init,
TTYDRV_EVENT_Synchronize,
TTYDRV_EVENT_CheckFocus,
TTYDRV_EVENT_UserRepaintDisable
};
KEYBOARD_DRIVER TTYDRV_KEYBOARD_Driver =
{
TTYDRV_KEYBOARD_Init,
TTYDRV_KEYBOARD_VkKeyScan,
TTYDRV_KEYBOARD_MapVirtualKey,
TTYDRV_KEYBOARD_GetKeyNameText,
TTYDRV_KEYBOARD_ToAscii,
TTYDRV_KEYBOARD_GetBeepActive,
TTYDRV_KEYBOARD_SetBeepActive,
TTYDRV_KEYBOARD_Beep,
TTYDRV_KEYBOARD_GetDIState,
TTYDRV_KEYBOARD_GetDIData,
TTYDRV_KEYBOARD_GetKeyboardConfig,
TTYDRV_KEYBOARD_SetKeyboardConfig
};
MONITOR_DRIVER TTYDRV_MONITOR_Driver = MONITOR_DRIVER TTYDRV_MONITOR_Driver =
{ {
TTYDRV_MONITOR_Initialize, TTYDRV_MONITOR_Initialize,
@ -76,14 +36,6 @@ MONITOR_DRIVER TTYDRV_MONITOR_Driver =
TTYDRV_MONITOR_SetScreenSaveTimeout TTYDRV_MONITOR_SetScreenSaveTimeout
}; };
MOUSE_DRIVER TTYDRV_MOUSE_Driver =
{
TTYDRV_MOUSE_Init,
TTYDRV_MOUSE_SetCursor,
TTYDRV_MOUSE_MoveCursor,
TTYDRV_MOUSE_EnableWarpPointer
};
WND_DRIVER TTYDRV_WND_Driver = WND_DRIVER TTYDRV_WND_Driver =
{ {
TTYDRV_WND_Initialize, TTYDRV_WND_Initialize,

1
windows/ttydrv/keyboard.c
View file

@ -5,6 +5,7 @@
*/ */
#include "dinput.h" #include "dinput.h"
#include "user.h"
#include "keyboard.h" #include "keyboard.h"
#include "ttydrv.h" #include "ttydrv.h"

22
windows/ttydrv/main.c
View file

@ -16,25 +16,3 @@
#include "ttydrv.h" #include "ttydrv.h"
#include "win.h" #include "win.h"
/***********************************************************************
* TTYDRV_USER_Initialize
*/
BOOL TTYDRV_USER_Initialize(void)
{
CLIPBOARD_Driver = &TTYDRV_CLIPBOARD_Driver;
DESKTOP_Driver = &TTYDRV_DESKTOP_Driver;
EVENT_Driver = &TTYDRV_EVENT_Driver;
KEYBOARD_Driver = &TTYDRV_KEYBOARD_Driver;
MONITOR_Driver = &TTYDRV_MONITOR_Driver;
MOUSE_Driver = &TTYDRV_MOUSE_Driver;
WND_Driver = &TTYDRV_WND_Driver;
return TRUE;
}
/***********************************************************************
* TTYDRV_USER_Finalize
*/
void TTYDRV_USER_Finalize(void)
{
}

6
windows/win.c
View file

@ -20,6 +20,7 @@
#include "hook.h" #include "hook.h"
#include "menu.h" #include "menu.h"
#include "message.h" #include "message.h"
#include "monitor.h"
#include "nonclient.h" #include "nonclient.h"
#include "queue.h" #include "queue.h"
#include "winpos.h" #include "winpos.h"
@ -602,10 +603,9 @@ BOOL WIN_CreateDesktopWindow(void)
pWndDesktop = (WND *) USER_HEAP_LIN_ADDR( hwndDesktop ); pWndDesktop = (WND *) USER_HEAP_LIN_ADDR( hwndDesktop );
pDesktop = (DESKTOP *) pWndDesktop->wExtra; pDesktop = (DESKTOP *) pWndDesktop->wExtra;
pDesktop->pDriver = DESKTOP_Driver; pDesktop->pPrimaryMonitor = &MONITOR_PrimaryMonitor;
pWndDesktop->pDriver = WND_Driver;
pDesktop->pDriver->pInitialize(pDesktop); pWndDesktop->pDriver = WND_Driver;
pWndDesktop->pDriver->pInitialize(pWndDesktop); pWndDesktop->pDriver->pInitialize(pWndDesktop);
pWndDesktop->next = NULL; pWndDesktop->next = NULL;

45
windows/x11drv/desktop.c
View file

@ -37,49 +37,4 @@ Window X11DRV_DESKTOP_GetXRootWindow(DESKTOP *pDesktop)
return X11DRV_MONITOR_GetXRootWindow(pDesktop->pPrimaryMonitor); return X11DRV_MONITOR_GetXRootWindow(pDesktop->pPrimaryMonitor);
} }
/***********************************************************************
* X11DRV_DESKTOP_Initialize
*/
void X11DRV_DESKTOP_Initialize(DESKTOP *pDesktop)
{
pDesktop->pPrimaryMonitor = &MONITOR_PrimaryMonitor;
}
/***********************************************************************
* X11DRV_DESKTOP_Finalize
*/
void X11DRV_DESKTOP_Finalize(DESKTOP *pDesktop)
{
}
/***********************************************************************
* X11DRV_DESKTOP_GetScreenWidth
*
* Return the width of the screen associated to the desktop.
*/
int X11DRV_DESKTOP_GetScreenWidth(DESKTOP *pDesktop)
{
return MONITOR_GetWidth(pDesktop->pPrimaryMonitor);
}
/***********************************************************************
* X11DRV_DESKTOP_GetScreenHeight
*
* Return the width of the screen associated to the desktop.
*/
int X11DRV_DESKTOP_GetScreenHeight(DESKTOP *pDesktop)
{
return MONITOR_GetHeight(pDesktop->pPrimaryMonitor);
}
/***********************************************************************
* X11DRV_DESKTOP_GetScreenDepth
*
* Return the depth of the screen associated to the desktop.
*/
int X11DRV_DESKTOP_GetScreenDepth(DESKTOP *pDesktop)
{
return MONITOR_GetDepth(pDesktop->pPrimaryMonitor);
}
#endif /* X_DISPLAY_MISSING */ #endif /* X_DISPLAY_MISSING */

48
windows/x11drv/init.c
View file

@ -9,21 +9,11 @@
#ifndef X_DISPLAY_MISSING #ifndef X_DISPLAY_MISSING
#include "clipboard.h" #include "clipboard.h"
#include "desktop.h"
#include "keyboard.h"
#include "message.h"
#include "monitor.h" #include "monitor.h"
#include "mouse.h"
#include "user.h" #include "user.h"
#include "win.h" #include "win.h"
#include "x11drv.h" #include "x11drv.h"
USER_DRIVER X11DRV_USER_Driver =
{
X11DRV_USER_Initialize,
X11DRV_USER_Finalize
};
CLIPBOARD_DRIVER X11DRV_CLIPBOARD_Driver = CLIPBOARD_DRIVER X11DRV_CLIPBOARD_Driver =
{ {
X11DRV_CLIPBOARD_Acquire, X11DRV_CLIPBOARD_Acquire,
@ -36,36 +26,6 @@ CLIPBOARD_DRIVER X11DRV_CLIPBOARD_Driver =
X11DRV_CLIPBOARD_ResetOwner X11DRV_CLIPBOARD_ResetOwner
}; };
DESKTOP_DRIVER X11DRV_DESKTOP_Driver =
{
X11DRV_DESKTOP_Initialize,
X11DRV_DESKTOP_Finalize
};
EVENT_DRIVER X11DRV_EVENT_Driver =
{
X11DRV_EVENT_Init,
X11DRV_EVENT_Synchronize,
X11DRV_EVENT_CheckFocus,
X11DRV_EVENT_UserRepaintDisable
};
KEYBOARD_DRIVER X11DRV_KEYBOARD_Driver =
{
X11DRV_KEYBOARD_Init,
X11DRV_KEYBOARD_VkKeyScan,
X11DRV_KEYBOARD_MapVirtualKey,
X11DRV_KEYBOARD_GetKeyNameText,
X11DRV_KEYBOARD_ToAscii,
X11DRV_KEYBOARD_GetBeepActive,
X11DRV_KEYBOARD_SetBeepActive,
X11DRV_KEYBOARD_Beep,
X11DRV_KEYBOARD_GetDIState,
X11DRV_KEYBOARD_GetDIData,
X11DRV_KEYBOARD_GetKeyboardConfig,
X11DRV_KEYBOARD_SetKeyboardConfig
};
MONITOR_DRIVER X11DRV_MONITOR_Driver = MONITOR_DRIVER X11DRV_MONITOR_Driver =
{ {
X11DRV_MONITOR_Initialize, X11DRV_MONITOR_Initialize,
@ -80,14 +40,6 @@ MONITOR_DRIVER X11DRV_MONITOR_Driver =
X11DRV_MONITOR_SetScreenSaveTimeout X11DRV_MONITOR_SetScreenSaveTimeout
}; };
MOUSE_DRIVER X11DRV_MOUSE_Driver =
{
X11DRV_MOUSE_Init,
X11DRV_MOUSE_SetCursor,
X11DRV_MOUSE_MoveCursor,
X11DRV_MOUSE_EnableWarpPointer
};
WND_DRIVER X11DRV_WND_Driver = WND_DRIVER X11DRV_WND_Driver =
{ {
X11DRV_WND_Initialize, X11DRV_WND_Initialize,

4
windows/x11drv/keyboard.c
View file

@ -26,6 +26,7 @@
#include "wine/winuser16.h" #include "wine/winuser16.h"
#include "dinput.h" #include "dinput.h"
#include "debugtools.h" #include "debugtools.h"
#include "user.h"
#include "keyboard.h" #include "keyboard.h"
#include "message.h" #include "message.h"
#include "winnls.h" #include "winnls.h"
@ -34,7 +35,6 @@
DEFAULT_DEBUG_CHANNEL(keyboard) DEFAULT_DEBUG_CHANNEL(keyboard)
DECLARE_DEBUG_CHANNEL(key) DECLARE_DEBUG_CHANNEL(key)
DECLARE_DEBUG_CHANNEL(x11drv)
DECLARE_DEBUG_CHANNEL(dinput) DECLARE_DEBUG_CHANNEL(dinput)
extern BYTE InputKeyStateTable[256]; extern BYTE InputKeyStateTable[256];
@ -1474,7 +1474,7 @@ BOOL X11DRV_KEYBOARD_GetDIState(DWORD len, LPVOID ptr)
} }
return TRUE; return TRUE;
} }
WARN_(x11drv)("whoops, X11DRV_KEYBOARD_GetState got len %ld?\n", len); WARN("whoops, X11DRV_KEYBOARD_GetState got len %ld?\n", len);
return TRUE; return TRUE;
} }

95
windows/x11drv/main.c
View file

@ -32,15 +32,6 @@
#include "windef.h" #include "windef.h"
#include "x11drv.h" #include "x11drv.h"
/**********************************************************************/
static void X11DRV_USER_SaveSetup(void);
static void X11DRV_USER_RestoreSetup(void);
/**********************************************************************/
static XKeyboardState X11DRV_XKeyboardState;
Display *display;
/*********************************************************************** /***********************************************************************
* X11DRV_GetXScreen * X11DRV_GetXScreen
@ -62,90 +53,4 @@ Window X11DRV_GetXRootWindow()
return X11DRV_MONITOR_GetXRootWindow(&MONITOR_PrimaryMonitor); return X11DRV_MONITOR_GetXRootWindow(&MONITOR_PrimaryMonitor);
} }
/***********************************************************************
* X11DRV_USER_ErrorHandler
*/
static int X11DRV_USER_ErrorHandler(Display *display, XErrorEvent *error_evt)
{
DebugBreak(); /* force an entry in the debugger */
return 0;
}
/***********************************************************************
* X11DRV_USER_Initialize
*/
BOOL X11DRV_USER_Initialize(void)
{
CLIPBOARD_Driver = &X11DRV_CLIPBOARD_Driver;
DESKTOP_Driver = &X11DRV_DESKTOP_Driver;
EVENT_Driver = &X11DRV_EVENT_Driver;
KEYBOARD_Driver = &X11DRV_KEYBOARD_Driver;
MONITOR_Driver = &X11DRV_MONITOR_Driver;
MOUSE_Driver = &X11DRV_MOUSE_Driver;
WND_Driver = &X11DRV_WND_Driver;
/* We need this before calling any Xlib function */
InitializeCriticalSection( &X11DRV_CritSection );
MakeCriticalSectionGlobal( &X11DRV_CritSection );
putenv("XKB_DISABLE="); /* Disable XKB extension if present. */
/* Open display */
if (!(display = TSXOpenDisplay( Options.display )))
{
MESSAGE( "%s: Can't open display: %s\n",
argv0, Options.display ? Options.display : "(none specified)" );
ExitProcess(1);
}
/* tell the libX11 that we will do input method handling ourselves
* that keep libX11 from doing anything whith dead keys, allowing Wine
* to have total control over dead keys, that is this line allows
* them to work in Wine, even whith a libX11 including the dead key
* patches from Th.Quinot (http://Web.FdN.FR/~tquinot/dead-keys.en.html)
*/
TSXOpenIM(display,NULL,NULL,NULL);
if (Options.synchronous) XSetErrorHandler( X11DRV_USER_ErrorHandler );
if (Options.desktopGeometry && Options.managed) Options.managed = FALSE;
X11DRV_USER_SaveSetup();
return TRUE;
}
/***********************************************************************
* X11DRV_USER_Finalize
*/
void X11DRV_USER_Finalize(void)
{
X11DRV_USER_RestoreSetup();
}
/***********************************************************************
* X11DRV_USER_SaveSetup
*/
static void X11DRV_USER_SaveSetup()
{
TSXGetKeyboardControl(display, &X11DRV_XKeyboardState);
}
/***********************************************************************
* X11DRV_USER_RestoreSetup
*/
static void X11DRV_USER_RestoreSetup()
{
XKeyboardControl keyboard_value;
keyboard_value.key_click_percent = X11DRV_XKeyboardState.key_click_percent;
keyboard_value.bell_percent = X11DRV_XKeyboardState.bell_percent;
keyboard_value.bell_pitch = X11DRV_XKeyboardState.bell_pitch;
keyboard_value.bell_duration = X11DRV_XKeyboardState.bell_duration;
keyboard_value.auto_repeat_mode = X11DRV_XKeyboardState.global_auto_repeat;
XChangeKeyboardControl(display, KBKeyClickPercent | KBBellPercent |
KBBellPitch | KBBellDuration | KBAutoRepeatMode, &keyboard_value);
}
#endif /* X_DISPLAY_MISSING */ #endif /* X_DISPLAY_MISSING */