ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merged clipboard driver into USER driver. 

Moved all ttydrv source files to dlls/ttydrv.
Load functions pointer for the USER driver from the graphics driver
dll with GetProcAddress.
This commit is contained in:
Alexandre Julliard 2000-08-10 01:16:19 +00:00
parent 5ab9d860f2
commit 42d20f9dca
55 changed files with 1010 additions and 1343 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
configure vendored
View File

@ -6405,7 +6405,6 @@ files/Makefile
graphics/Makefile
graphics/enhmetafiledrv/Makefile
graphics/metafiledrv/Makefile
graphics/ttydrv/Makefile
graphics/win16drv/Makefile
graphics/x11drv/Makefile
if1632/Makefile
@ -6450,7 +6449,6 @@ tsx11/Makefile
unicode/Makefile
win32/Makefile
windows/Makefile
windows/ttydrv/Makefile
windows/x11drv/Makefile include/config.h" | sed "s/:[^ ]*//g"` conftest*; exit 1' 1 2 15
EOF
cat >> $CONFIG_STATUS <<EOF
@ -6641,7 +6639,6 @@ files/Makefile
graphics/Makefile
graphics/enhmetafiledrv/Makefile
graphics/metafiledrv/Makefile
graphics/ttydrv/Makefile
graphics/win16drv/Makefile
graphics/x11drv/Makefile
if1632/Makefile
@ -6686,7 +6683,6 @@ tsx11/Makefile
unicode/Makefile
win32/Makefile
windows/Makefile
windows/ttydrv/Makefile
windows/x11drv/Makefile "}
EOF
cat >> $CONFIG_STATUS <<\EOF

2
configure.in
View File

@ -1074,7 +1074,6 @@ files/Makefile
graphics/Makefile
graphics/enhmetafiledrv/Makefile
graphics/metafiledrv/Makefile
graphics/ttydrv/Makefile
graphics/win16drv/Makefile
graphics/x11drv/Makefile
if1632/Makefile
@ -1119,7 +1118,6 @@ tsx11/Makefile
unicode/Makefile
win32/Makefile
windows/Makefile
windows/ttydrv/Makefile
windows/x11drv/Makefile ])
if test "$have_x" = "no"

2
controls/desktop.c
View File

@ -159,7 +159,7 @@ static inline LRESULT WINAPI DesktopWndProc_locked( WND *wndPtr, UINT message,
return 1;
case WM_ERASEBKGND:
if(!USER_Driver->pIsSingleWindow())
if(!USER_Driver.pIsSingleWindow())
return 1;
return DESKTOP_DoEraseBkgnd( hwnd, (HDC)wParam, desktopPtr );

16
dlls/dinput/dinput_main.c
View File

@ -787,7 +787,7 @@ static HRESULT WINAPI SysKeyboardAImpl_GetDeviceState(
LPDIRECTINPUTDEVICE2A iface,DWORD len,LPVOID ptr
)
{
return USER_Driver->pGetDIState(len, ptr)?DI_OK:E_FAIL;
return USER_Driver.pGetDIState(len, ptr)?DI_OK:E_FAIL;
}
static HRESULT WINAPI SysKeyboardAImpl_GetDeviceData(
@ -802,7 +802,7 @@ static HRESULT WINAPI SysKeyboardAImpl_GetDeviceData(
TRACE("(this=%p,%ld,%p,%p(%ld)),0x%08lx)\n",
This,dodsize,dod,entries,entries?*entries:0,flags);
ret=USER_Driver->pGetDIData(
ret=USER_Driver.pGetDIData(
This->keystate, dodsize, dod, entries, flags)?DI_OK:E_FAIL;
for (i=0;i<*entries;i++) {
dod[i].dwTimeStamp = GetTickCount();
@ -821,11 +821,11 @@ static HRESULT WINAPI SysKeyboardAImpl_Acquire(LPDIRECTINPUTDEVICE2A iface)
KEYBOARD_CONFIG no_auto;
/* Save the original config */
USER_Driver->pGetKeyboardConfig(&(This->initial_config));
USER_Driver.pGetKeyboardConfig(&(This->initial_config));
/* Now, remove auto-repeat */
no_auto.auto_repeat = FALSE;
USER_Driver->pSetKeyboardConfig(&no_auto, WINE_KEYBOARD_CONFIG_AUTO_REPEAT);
USER_Driver.pSetKeyboardConfig(&no_auto, WINE_KEYBOARD_CONFIG_AUTO_REPEAT);
This->acquired = 1;
}
@ -840,7 +840,7 @@ static HRESULT WINAPI SysKeyboardAImpl_Unacquire(LPDIRECTINPUTDEVICE2A iface)
if (This->acquired == 1) {
/* Restore the original configuration */
USER_Driver->pSetKeyboardConfig(&(This->initial_config), 0xFFFFFFFF);
USER_Driver.pSetKeyboardConfig(&(This->initial_config), 0xFFFFFFFF);
This->acquired = 0;
} else {
ERR("Unacquiring a not-acquired device !!!\n");
@ -1431,7 +1431,7 @@ static HRESULT WINAPI SysMouseAImpl_Acquire(LPDIRECTINPUTDEVICE2A iface)
point.x = This->win_centerX;
point.y = This->win_centerY;
MapWindowPoints(This->win, HWND_DESKTOP, &point, 1);
USER_Driver->pMoveCursor( point.x, point.y );
USER_Driver.pMoveCursor( point.x, point.y );
This->need_warp = WARP_STARTED;
}
@ -1493,7 +1493,7 @@ static HRESULT WINAPI SysMouseAImpl_GetDeviceState(
point.x = This->win_centerX;
point.y = This->win_centerY;
MapWindowPoints(This->win, HWND_DESKTOP, &point, 1);
USER_Driver->pMoveCursor( point.x, point.y );
USER_Driver.pMoveCursor( point.x, point.y );
This->need_warp = WARP_STARTED;
}
@ -1560,7 +1560,7 @@ static HRESULT WINAPI SysMouseAImpl_GetDeviceData(LPDIRECTINPUTDEVICE2A iface,
point.y = This->win_centerY;
MapWindowPoints(This->win, HWND_DESKTOP, &point, 1);
USER_Driver->pMoveCursor( point.x, point.y );
USER_Driver.pMoveCursor( point.x, point.y );
This->need_warp = WARP_STARTED;
}

20
dlls/ttydrv/Makefile.in
View File

@ -8,20 +8,16 @@ EXTRALIBS = $(LIBS)
IMPORTS = user32 gdi32 kernel32
C_SRCS = \
ttydrv_main.c
EXTRA_OBJS = \
$(TOPOBJDIR)/graphics/ttydrv/ttydrv.o \
$(TOPOBJDIR)/windows/ttydrv/ttydrv.o
SUBDIRS = \
$(TOPOBJDIR)/graphics/ttydrv \
$(TOPOBJDIR)/windows/ttydrv
bitmap.c \
dc.c \
graphics.c \
objects.c \
palette.c \
ttydrv_main.c \
user.c \
wnd.c
@MAKE_DLL_RULES@
$(EXTRA_OBJS): $(TOOLSUBDIRS) dummy
@cd `dirname $@` && $(MAKE) `basename $@`
### Dependencies:

77
graphics/ttydrv/bitmap.c → dlls/ttydrv/bitmap.c
View File

@ -10,7 +10,7 @@
#include "winbase.h"
#include "debugtools.h"
DEFAULT_DEBUG_CHANNEL(ttydrv)
DEFAULT_DEBUG_CHANNEL(ttydrv);
/**********************************************************************/
@ -169,3 +169,78 @@ static LONG TTYDRV_DC_SetBitmapBits(BITMAPOBJ *bitmap, void *bits, LONG count)
return count;
}
/***********************************************************************
* TTYDRV_BITMAP_CreateDIBSection
*/
HBITMAP TTYDRV_BITMAP_CreateDIBSection(
DC *dc, BITMAPINFO *bmi, UINT usage,
LPVOID *bits, HANDLE section, DWORD offset)
{
FIXME("(%p, %p, %u, %p, 0x%04x, %ld): stub\n",
dc, bmi, usage, bits, section, offset);
return (HBITMAP) NULL;
}
/**********************************************************************
* TTYDRV_BITMAP_CreateDIBSection16
*/
HBITMAP16 TTYDRV_DIB_CreateDIBSection16(
DC *dc, BITMAPINFO *bmi, UINT16 usage,
SEGPTR *bits, HANDLE section, DWORD offset)
{
FIXME("(%p, %p, %u, %p, 0x%04x, %ld): stub\n",
dc, bmi, usage, bits, section, offset);
return (HBITMAP16) NULL;
}
/***********************************************************************
* TTYDRV_BITMAP_DeleteDIBSection
*/
void TTYDRV_BITMAP_DeleteDIBSection(BITMAPOBJ *bmp)
{
FIXME("(%p): stub\n", bmp);
}
/***********************************************************************
* TTYDRV_BITMAP_GetDIBits
*/
INT TTYDRV_BITMAP_GetDIBits(
BITMAPOBJ *bmp, DC *dc, UINT startscan, UINT lines,
LPVOID bits, BITMAPINFO *info, UINT coloruse, HBITMAP hbitmap)
{
FIXME("(%p, %p, %u, %u, %p, %p, %u, 0x%04x): stub\n",
bmp, dc, startscan, lines, bits, info, coloruse, hbitmap);
return 0;
}
/***********************************************************************
* TTYDRV_BITMAP_SetDIBits
*/
INT TTYDRV_BITMAP_SetDIBits(
BITMAPOBJ *bmp, DC *dc, UINT startscan, UINT lines,
LPCVOID bits, const BITMAPINFO *info, UINT coloruse, HBITMAP hbitmap)
{
FIXME("(%p, %p, %u, %u, %p, %p, %u, 0x%04x): stub\n",
bmp, dc, startscan, lines, bits, info, coloruse, hbitmap);
return 0;
}
/***********************************************************************
* TTYDRV_DC_SetDIBitsToDevice
*/
INT TTYDRV_DC_SetDIBitsToDevice(DC *dc, INT xDest, INT yDest, DWORD cx,
DWORD cy, INT xSrc, INT ySrc,
UINT startscan, UINT lines, LPCVOID bits,
const BITMAPINFO *info, UINT coloruse)
{
FIXME("(%p, %d, %d, %ld, %ld, %d, %d, %u, %u, %p, %p, %u): stub\n",
dc, xDest, yDest, cx, cy, xSrc, ySrc, startscan, lines, bits, info, coloruse);
return 0;
}

99
graphics/ttydrv/init.c → dlls/ttydrv/dc.c
View File

@ -1,19 +1,22 @@
/*
* TTY driver
* TTY DC driver
*
* Copyright 1998-1999 Patrik Stridvall
* Copyright 1999 Patrik Stridvall
*/
#include "config.h"
#include "gdi.h"
#include "bitmap.h"
#include "color.h"
#include "dc.h"
#include "palette.h"
#include "ttydrv.h"
#include "winbase.h"
#include "debugtools.h"
DEFAULT_DEBUG_CHANNEL(ttydrv)
DEFAULT_DEBUG_CHANNEL(ttydrv);
/**********************************************************************/
static const DC_FUNCTIONS TTYDRV_DC_Driver =
{
@ -169,7 +172,7 @@ BOOL TTYDRV_GDI_Initialize(void)
TTYDRV_DC_DevCaps.horzRes = 640; /* FIXME: Screen width in pixel */
TTYDRV_DC_DevCaps.vertRes = 480; /* FIXME: Screen height in pixel */
TTYDRV_DC_DevCaps.bitsPixel = 1; /* FIXME: Bits per pixel */
TTYDRV_DC_DevCaps.sizePalette = 0; /* FIXME: ??? */
TTYDRV_DC_DevCaps.sizePalette = 256; /* FIXME: ??? */
/* Resolution will be adjusted during the font init */
@ -189,3 +192,89 @@ void TTYDRV_GDI_Finalize(void)
{
TTYDRV_PALETTE_Finalize();
}
/***********************************************************************
* TTYDRV_DC_CreateDC
*/
BOOL TTYDRV_DC_CreateDC(DC *dc, LPCSTR driver, LPCSTR device,
LPCSTR output, const DEVMODEA *initData)
{
TTYDRV_PDEVICE *physDev;
BITMAPOBJ *bmp;
TRACE("(%p, %s, %s, %s, %p)\n",
dc, debugstr_a(driver), debugstr_a(device),
debugstr_a(output), initData);
dc->physDev = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
sizeof(TTYDRV_PDEVICE));
if(!dc->physDev) {
ERR("Can't allocate physDev\n");
return FALSE;
}
physDev = (TTYDRV_PDEVICE *) dc->physDev;
dc->w.devCaps = &TTYDRV_DC_DevCaps;
if(dc->w.flags & DC_MEMORY){
physDev->window = NULL;
physDev->cellWidth = 1;
physDev->cellHeight = 1;
TTYDRV_DC_CreateBitmap(dc->w.hBitmap);
bmp = (BITMAPOBJ *) GDI_GetObjPtr(dc->w.hBitmap, BITMAP_MAGIC);
dc->w.bitsPerPixel = bmp->bitmap.bmBitsPixel;
dc->w.totalExtent.left = 0;
dc->w.totalExtent.top = 0;
dc->w.totalExtent.right = bmp->bitmap.bmWidth;
dc->w.totalExtent.bottom = bmp->bitmap.bmHeight;
dc->w.hVisRgn = CreateRectRgnIndirect( &dc->w.totalExtent );
GDI_HEAP_UNLOCK( dc->w.hBitmap );
} else {
physDev->window = TTYDRV_GetRootWindow();
physDev->cellWidth = cell_width;
physDev->cellHeight = cell_height;
dc->w.bitsPerPixel = 1;
dc->w.totalExtent.left = 0;
dc->w.totalExtent.top = 0;
dc->w.totalExtent.right = cell_width * screen_cols;
dc->w.totalExtent.bottom = cell_height * screen_rows;
dc->w.hVisRgn = CreateRectRgnIndirect( &dc->w.totalExtent );
}
return TRUE;
}
/***********************************************************************
* TTYDRV_DC_DeleteDC
*/
BOOL TTYDRV_DC_DeleteDC(DC *dc)
{
TRACE("(%p)\n", dc);
HeapFree( GetProcessHeap(), 0, dc->physDev );
dc->physDev = NULL;
return TRUE;
}
/***********************************************************************
* TTYDRV_DC_Escape
*/
INT TTYDRV_DC_Escape(DC *dc, INT nEscape, INT cbInput,
SEGPTR lpInData, SEGPTR lpOutData)
{
return 0;
}
/***********************************************************************
* TTYDRV_DC_SetDeviceClipping
*/
void TTYDRV_DC_SetDeviceClipping(DC *dc)
{
TRACE("(%p)\n", dc);
}

164
graphics/ttydrv/graphics.c → dlls/ttydrv/graphics.c
View File

@ -7,10 +7,11 @@
#include "config.h"
#include "dc.h"
#include "heap.h"
#include "debugtools.h"
#include "ttydrv.h"
DEFAULT_DEBUG_CHANNEL(ttydrv)
DEFAULT_DEBUG_CHANNEL(ttydrv);
/***********************************************************************
* TTYDRV_DC_Arc
@ -306,3 +307,164 @@ COLORREF TTYDRV_DC_SetTextColor(DC *dc, COLORREF color)
return oldColor;
}
/***********************************************************************
* TTYDRV_DC_BitBlt
*/
BOOL TTYDRV_DC_BitBlt(DC *dcDst, INT xDst, INT yDst,
INT width, INT height, DC *dcSrc,
INT xSrc, INT ySrc, DWORD rop)
{
FIXME("(%p, %d, %d, %d, %d, %p, %d, %d, %lu): stub\n",
dcDst, xDst, yDst, width, height,
dcSrc, xSrc, ySrc, rop
);
return TRUE;
}
/***********************************************************************
* TTYDRV_DC_PatBlt
*/
BOOL TTYDRV_DC_PatBlt(DC *dc, INT left, INT top,
INT width, INT height, DWORD rop)
{
FIXME("(%p, %d, %d, %d, %d, %lu): stub\n",
dc, left, top, width, height, rop
);
return TRUE;
}
/***********************************************************************
* TTYDRV_DC_StretchBlt
*/
BOOL TTYDRV_DC_StretchBlt(DC *dcDst, INT xDst, INT yDst,
INT widthDst, INT heightDst,
DC *dcSrc, INT xSrc, INT ySrc,
INT widthSrc, INT heightSrc, DWORD rop)
{
FIXME("(%p, %d, %d, %d, %d, %p, %d, %d, %d, %d, %lu): stub\n",
dcDst, xDst, yDst, widthDst, heightDst,
dcSrc, xSrc, ySrc, widthSrc, heightSrc, rop
);
return TRUE;
}
/***********************************************************************
* TTYDRV_DC_ExtTextOut
*/
BOOL TTYDRV_DC_ExtTextOut(DC *dc, INT x, INT y, UINT flags,
const RECT *lpRect, LPCWSTR str, UINT count,
const INT *lpDx)
{
#ifdef WINE_CURSES
TTYDRV_PDEVICE *physDev = (TTYDRV_PDEVICE *) dc->physDev;
INT row, col;
LPSTR ascii;
TRACE("(%p, %d, %d, 0x%08x, %p, %s, %d, %p)\n",
dc, x, y, flags, lpRect, debugstr_wn(str, count), count, lpDx);
if(!physDev->window)
return FALSE;
/* FIXME: Is this really correct? */
if(dc->w.textAlign & TA_UPDATECP) {
x = dc->w.CursPosX;
y = dc->w.CursPosY;
}
x = XLPTODP(dc, x);
y = YLPTODP(dc, y);
row = (dc->w.DCOrgY + y) / physDev->cellHeight;
col = (dc->w.DCOrgX + x) / physDev->cellWidth;
ascii = HeapAlloc( GetProcessHeap(), 0, count+1 );
lstrcpynWtoA(ascii, str, count+1);
mvwaddnstr(physDev->window, row, col, ascii, count);
HeapFree( GetProcessHeap(), 0, ascii );
wrefresh(physDev->window);
if(dc->w.textAlign & TA_UPDATECP) {
dc->w.CursPosX += count * physDev->cellWidth;
dc->w.CursPosY += physDev->cellHeight;
}
return TRUE;
#else /* defined(WINE_CURSES) */
FIXME("(%p, %d, %d, 0x%08x, %p, %s, %d, %p): stub\n",
dc, x, y, flags, lpRect, debugstr_wn(str,count), count, lpDx);
return TRUE;
#endif /* defined(WINE_CURSES) */
}
/***********************************************************************
* TTYDRV_DC_GetCharWidth
*/
BOOL TTYDRV_DC_GetCharWidth(DC *dc, UINT firstChar, UINT lastChar,
LPINT buffer)
{
UINT c;
TTYDRV_PDEVICE *physDev = (TTYDRV_PDEVICE *) dc->physDev;
FIXME("(%p, %u, %u, %p): semistub\n", dc, firstChar, lastChar, buffer);
for(c=firstChar; c<=lastChar; c++) {
buffer[c-firstChar] = physDev->cellWidth;
}
return TRUE;
}
/***********************************************************************
* TTYDRV_DC_GetTextExtentPoint
*/
BOOL TTYDRV_DC_GetTextExtentPoint(DC *dc, LPCWSTR str, INT count,
LPSIZE size)
{
TTYDRV_PDEVICE *physDev = (TTYDRV_PDEVICE *) dc->physDev;
TRACE("(%p, %s, %d, %p)\n", dc, debugstr_wn(str, count), count, size);
size->cx = count * physDev->cellWidth;
size->cy = physDev->cellHeight;
return TRUE;
}
/***********************************************************************
* TTYDRV_DC_GetTextMetrics
*/
BOOL TTYDRV_DC_GetTextMetrics(DC *dc, LPTEXTMETRICA lptm)
{
TTYDRV_PDEVICE *physDev = (TTYDRV_PDEVICE *) dc->physDev;
TRACE("(%p, %p)\n", dc, lptm);
lptm->tmHeight = physDev->cellHeight;
lptm->tmAscent = 0;
lptm->tmDescent = 0;
lptm->tmInternalLeading = 0;
lptm->tmExternalLeading = 0;
lptm->tmAveCharWidth = physDev->cellWidth;
lptm->tmMaxCharWidth = physDev->cellWidth;
lptm->tmWeight = FW_MEDIUM;
lptm->tmOverhang = 0;
lptm->tmDigitizedAspectX = physDev->cellWidth;
lptm->tmDigitizedAspectY = physDev->cellHeight;
lptm->tmFirstChar = 32;
lptm->tmLastChar = 255;
lptm->tmDefaultChar = 0;
lptm->tmBreakChar = 32;
lptm->tmItalic = FALSE;
lptm->tmUnderlined = FALSE;
lptm->tmStruckOut = FALSE;
lptm->tmPitchAndFamily = TMPF_FIXED_PITCH|TMPF_DEVICE;
lptm->tmCharSet = ANSI_CHARSET;
return TRUE;
}

52
graphics/ttydrv/objects.c → dlls/ttydrv/objects.c
View File

@ -13,17 +13,59 @@
#include "ttydrv.h"
#include "debugtools.h"
DEFAULT_DEBUG_CHANNEL(ttydrv)
DEFAULT_DEBUG_CHANNEL(ttydrv);
/**********************************************************************/
extern HBITMAP TTYDRV_DC_BITMAP_SelectObject(DC *dc, HBITMAP hbitmap, BITMAPOBJ *bitmap);
extern HBRUSH TTYDRV_DC_BRUSH_SelectObject(DC *dc, HBRUSH hbrush, BRUSHOBJ *brush);
extern HFONT TTYDRV_DC_FONT_SelectObject(DC* dc, HFONT hfont, FONTOBJ *font);
extern HPEN TTYDRV_DC_PEN_SelectObject(DC *dc, HBRUSH hpen, PENOBJ *pen);
extern BOOL TTYDRV_DC_BITMAP_DeleteObject(HBITMAP hbitmap, BITMAPOBJ *bitmap);
/***********************************************************************
* TTYDRV_DC_BRUSH_SelectObject
*/
static HBRUSH TTYDRV_DC_BRUSH_SelectObject(DC *dc, HBRUSH hbrush, BRUSHOBJ *brush)
{
HBRUSH hPreviousBrush;
TRACE("(%p, 0x%04x, %p)\n", dc, hbrush, brush);
hPreviousBrush = dc->w.hBrush;
dc->w.hBrush = hbrush;
return hPreviousBrush;
}
/***********************************************************************
* TTYDRV_DC_FONT_SelectObject
*/
static HFONT TTYDRV_DC_FONT_SelectObject(DC* dc, HFONT hfont, FONTOBJ *font)
{
HFONT hPreviousFont;
TRACE("(%p, 0x%04x, %p)\n", dc, hfont, font);
hPreviousFont = dc->w.hFont;
dc->w.hFont = hfont;
return hPreviousFont;
}
/***********************************************************************
* TTYDRV_DC_PEN_SelectObject
*/
static HPEN TTYDRV_DC_PEN_SelectObject(DC *dc, HBRUSH hpen, PENOBJ *pen)
{
HPEN hPreviousPen;
TRACE("(%p, 0x%04x, %p)\n", dc, hpen, pen);
hPreviousPen = dc->w.hPen;
dc->w.hPen = hpen;
return hPreviousPen;
}
/***********************************************************************
* TTYDRV_DC_SelectObject
*/

4
graphics/ttydrv/palette.c → dlls/ttydrv/palette.c
View File

@ -12,7 +12,7 @@
#include "winbase.h"
#include "ttydrv.h"
DEFAULT_DEBUG_CHANNEL(ttydrv)
DEFAULT_DEBUG_CHANNEL(ttydrv);
/**********************************************************************/
@ -35,8 +35,6 @@ BOOL TTYDRV_PALETTE_Initialize(void)
TRACE("(void)\n");
TTYDRV_DC_DevCaps.sizePalette = 256;
COLOR_sysPal = (PALETTEENTRY *) HeapAlloc(GetProcessHeap(), 0, sizeof(PALETTEENTRY) * TTYDRV_DC_DevCaps.sizePalette);
if(COLOR_sysPal == NULL) {
WARN("No memory to create system palette!");

46
include/ttydrv.h → dlls/ttydrv/ttydrv.h
View File

@ -127,52 +127,6 @@ extern int screen_cols;
extern WINDOW *root_window;
static inline WINDOW *TTYDRV_GetRootWindow(void) { return root_window; }
extern BOOL TTYDRV_GetScreenSaveActive(void);
extern void TTYDRV_SetScreenSaveActive(BOOL bActivate);
extern int TTYDRV_GetScreenSaveTimeout(void);
extern void TTYDRV_SetScreenSaveTimeout(int nTimeout);
extern BOOL TTYDRV_IsSingleWindow(void);
/* TTY clipboard driver */
extern struct tagCLIPBOARD_DRIVER TTYDRV_CLIPBOARD_Driver;
extern void TTYDRV_CLIPBOARD_Acquire(void);
extern void TTYDRV_CLIPBOARD_Release(void);
extern void TTYDRV_CLIPBOARD_SetData(UINT wFormat);
extern BOOL TTYDRV_CLIPBOARD_GetData(UINT wFormat);
extern BOOL TTYDRV_CLIPBOARD_IsFormatAvailable(UINT wFormat);
extern BOOL TTYDRV_CLIPBOARD_RegisterFormat( LPCSTR FormatName );
extern BOOL TTYDRV_CLIPBOARD_IsSelectionowner();
extern void TTYDRV_CLIPBOARD_ResetOwner(struct tagWND *pWnd, BOOL bFooBar);
/* TTY event driver */
extern void TTYDRV_EVENT_Synchronize(void);
extern BOOL TTYDRV_EVENT_CheckFocus(void);
extern void TTYDRV_EVENT_UserRepaintDisable(BOOL bDisable);
/* TTY keyboard driver */
extern void TTYDRV_KEYBOARD_Init(void);
extern WORD TTYDRV_KEYBOARD_VkKeyScan(CHAR cChar);
extern UINT16 TTYDRV_KEYBOARD_MapVirtualKey(UINT16 wCode, UINT16 wMapType);
extern INT16 TTYDRV_KEYBOARD_GetKeyNameText(LONG lParam, LPSTR lpBuffer, INT16 nSize);
extern INT16 TTYDRV_KEYBOARD_ToAscii(UINT16 virtKey, UINT16 scanCode, LPBYTE lpKeyState, LPVOID lpChar, UINT16 flags);
extern BOOL TTYDRV_KEYBOARD_GetBeepActive(void);
extern void TTYDRV_KEYBOARD_SetBeepActive(BOOL bActivate);
extern void TTYDRV_KEYBOARD_Beep(void);
extern BOOL TTYDRV_KEYBOARD_GetDIState(DWORD len, LPVOID ptr);
extern BOOL TTYDRV_KEYBOARD_GetDIData(BYTE *keystate, DWORD dodsize, struct DIDEVICEOBJECTDATA *dod, LPDWORD entries, DWORD flags);
extern void TTYDRV_KEYBOARD_GetKeyboardConfig(struct tagKEYBOARD_CONFIG *cfg);
extern void TTYDRV_KEYBOARD_SetKeyboardConfig(struct tagKEYBOARD_CONFIG *cfg, DWORD mask);
/* TTY mouse driver */
extern void TTYDRV_MOUSE_Init(LPMOUSE_EVENT_PROC);
extern void TTYDRV_MOUSE_SetCursor(struct tagCURSORICONINFO *lpCursor);
extern void TTYDRV_MOUSE_MoveCursor(WORD wAbsX, WORD wAbsY);
/* TTY windows driver */
extern struct tagWND_DRIVER TTYDRV_WND_Driver;

35
dlls/ttydrv/ttydrv.spec
View File

@ -5,3 +5,38 @@ init TTYDRV_Init
import user32.dll
import gdi32.dll
import kernel32.dll
# USER driver
@ cdecl Synchronize() TTYDRV_Synchronize
@ cdecl CheckFocus() TTYDRV_CheckFocus
@ cdecl UserRepaintDisable(long) TTYDRV_UserRepaintDisable
@ cdecl InitKeyboard() TTYDRV_InitKeyboard
@ cdecl VkKeyScan(long) TTYDRV_VkKeyScan
@ cdecl MapVirtualKey(long long) TTYDRV_MapVirtualKey
@ cdecl GetKeyNameText(long str long) TTYDRV_GetKeyNameText
@ cdecl ToAscii(long long ptr ptr long) TTYDRV_ToAscii
@ cdecl GetBeepActive() TTYDRV_GetBeepActive
@ cdecl SetBeepActive(long) TTYDRV_SetBeepActive
@ cdecl Beep() TTYDRV_Beep
@ cdecl GetDIState(long ptr) TTYDRV_GetDIState
@ cdecl GetDIData(ptr long ptr ptr long) TTYDRV_GetDIData
@ cdecl GetKeyboardConfig(ptr) TTYDRV_GetKeyboardConfig
@ cdecl SetKeyboardConfig(ptr long) TTYDRV_SetKeyboardConfig
@ cdecl InitMouse(ptr) TTYDRV_InitMouse
@ cdecl SetCursor(ptr) TTYDRV_SetCursor
@ cdecl MoveCursor(long long) TTYDRV_MoveCursor
@ cdecl GetScreenSaveActive() TTYDRV_GetScreenSaveActive
@ cdecl SetScreenSaveActive(long) TTYDRV_SetScreenSaveActive
@ cdecl GetScreenSaveTimeout() TTYDRV_GetScreenSaveTimeout
@ cdecl SetScreenSaveTimeout(long) TTYDRV_SetScreenSaveTimeout
@ cdecl LoadOEMResource(long long) TTYDRV_LoadOEMResource
@ cdecl IsSingleWindow() TTYDRV_IsSingleWindow
@ cdecl AcquireClipboard() TTYDRV_AcquireClipboard
@ cdecl ReleaseClipboard() TTYDRV_ReleaseClipboard
@ cdecl SetClipboardData(long) TTYDRV_SetClipboardData
@ cdecl GetClipboardData(long) TTYDRV_GetClipboardData
@ cdecl IsClipboardFormatAvailable(long) TTYDRV_IsClipboardFormatAvailable
@ cdecl RegisterClipboardFormat(str) TTYDRV_RegisterClipboardFormat
@ cdecl IsSelectionOwner() TTYDRV_IsSelectionOwner
@ cdecl ResetSelectionOwner(ptr long) TTYDRV_ResetSelectionOwner

88
dlls/ttydrv/ttydrv_main.c
View File

@ -8,7 +8,6 @@
#include "winbase.h"
#include "wine/winbase16.h"
#include "clipboard.h"
#include "gdi.h"
#include "message.h"
#include "user.h"
@ -18,40 +17,6 @@
DEFAULT_DEBUG_CHANNEL(ttydrv);
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,
/* screen saver functions */
TTYDRV_GetScreenSaveActive,
TTYDRV_SetScreenSaveActive,
TTYDRV_GetScreenSaveTimeout,
TTYDRV_SetScreenSaveTimeout,
/* resource functions */
TTYDRV_LoadOEMResource,
/* windowing functions */
TTYDRV_IsSingleWindow
};
int cell_width = 8;
int cell_height = 8;
int screen_rows = 50; /* default value */
@ -64,8 +29,6 @@ WINDOW *root_window;
*/
static void process_attach(void)
{
USER_Driver = &user_driver;
CLIPBOARD_Driver = &TTYDRV_CLIPBOARD_Driver;
WND_Driver = &TTYDRV_WND_Driver;
#ifdef WINE_CURSES
@ -95,8 +58,6 @@ static void process_detach(void)
if (root_window) endwin();
#endif /* WINE_CURSES */
USER_Driver = NULL;
CLIPBOARD_Driver = NULL;
WND_Driver = NULL;
}
@ -120,52 +81,3 @@ BOOL WINAPI TTYDRV_Init( HINSTANCE hinst, DWORD reason, LPVOID reserved )
}
return TRUE;
}
/***********************************************************************
* TTYDRV_GetScreenSaveActive
*
* Returns the active status of the screen saver
*/
BOOL TTYDRV_GetScreenSaveActive(void)
{
return FALSE;
}
/***********************************************************************
* TTYDRV_SetScreenSaveActive
*
* Activate/Deactivate the screen saver
*/
void TTYDRV_SetScreenSaveActive(BOOL bActivate)
{
FIXME("(%d): stub\n", bActivate);
}
/***********************************************************************
* TTYDRV_GetScreenSaveTimeout
*
* Return the screen saver timeout
*/
int TTYDRV_GetScreenSaveTimeout(void)
{
return 0;
}
/***********************************************************************
* TTYDRV_SetScreenSaveTimeout
*
* Set the screen saver timeout
*/
void TTYDRV_SetScreenSaveTimeout(int nTimeout)
{
FIXME("(%d): stub\n", nTimeout);
}
/***********************************************************************
* TTYDRV_IsSingleWindow
*/
BOOL TTYDRV_IsSingleWindow(void)
{
return TRUE;
}

287
dlls/ttydrv/user.c Normal file
View File

@ -0,0 +1,287 @@
/*
* TTYDRV USER driver functions
*
* Copyright 1998 Patrik Stridvall
*/
#include "dinput.h"
#include "gdi.h"
#include "ttydrv.h"
#include "debugtools.h"
DEFAULT_DEBUG_CHANNEL(ttydrv);
/***********************************************************************
* TTYDRV_Synchronize
*/
void TTYDRV_Synchronize( void )
{
}
/***********************************************************************
* TTYDRV_CheckFocus
*/
BOOL TTYDRV_CheckFocus(void)
{
return TRUE;
}
/***********************************************************************
* TTYDRV_UserRepaintDisable
*/
void TTYDRV_UserRepaintDisable( BOOL bDisable )
{
}
/***********************************************************************
* TTYDRV_InitKeyboard
*/
void TTYDRV_InitKeyboard(void)
{
}
/***********************************************************************
* TTYDRV_VkKeyScan
*/
WORD TTYDRV_VkKeyScan(CHAR cChar)
{
return 0;
}
/***********************************************************************
* TTYDRV_MapVirtualKey
*/
UINT16 TTYDRV_MapVirtualKey(UINT16 wCode, UINT16 wMapType)
{
return 0;
}
/***********************************************************************
* TTYDRV_GetKeyNameText
*/
INT16 TTYDRV_GetKeyNameText( LONG lParam, LPSTR lpBuffer, INT16 nSize )
{
if(lpBuffer && nSize)
{
*lpBuffer = 0;
}
return 0;
}
/***********************************************************************
* TTYDRV_ToAscii
*/
INT16 TTYDRV_ToAscii( UINT16 virtKey, UINT16 scanCode,
LPBYTE lpKeyState, LPVOID lpChar, UINT16 flags )
{
return 0;
}
/***********************************************************************
* TTYDRV_GetBeepActive
*/
BOOL TTYDRV_GetBeepActive(void)
{
return FALSE;
}
/***********************************************************************
* TTYDRV_SetBeepActive
*/
void TTYDRV_SetBeepActive(BOOL bActivate)
{
}
/***********************************************************************
* TTYDRV_Beep
*/
void TTYDRV_Beep(void)
{
}
/***********************************************************************
* TTYDRV_GetDIState
*/
BOOL TTYDRV_GetDIState(DWORD len, LPVOID ptr)
{
return TRUE;
}
/***********************************************************************
* TTYDRV_GetDIData
*/
BOOL TTYDRV_GetDIData( BYTE *keystate, DWORD dodsize, LPDIDEVICEOBJECTDATA dod,
LPDWORD entries, DWORD flags )
{
return TRUE;
}
/***********************************************************************
* TTYDRV_GetKeyboardConfig
*/
void TTYDRV_GetKeyboardConfig(KEYBOARD_CONFIG *cfg)
{
}
/***********************************************************************
* TTYDRV_SetKeyboardConfig
*/
extern void TTYDRV_SetKeyboardConfig(KEYBOARD_CONFIG *cfg, DWORD mask)
{
}
/***********************************************************************
* TTYDRV_InitMouse
*/
void TTYDRV_InitMouse(LPMOUSE_EVENT_PROC proc)
{
}
/***********************************************************************
* TTYDRV_SetCursor
*/
void TTYDRV_SetCursor( struct tagCURSORICONINFO *lpCursor )
{
}
/***********************************************************************
* TTYDRV_MoveCursor
*/
void TTYDRV_MoveCursor(WORD wAbsX, WORD wAbsY)
{
}
/***********************************************************************
* TTYDRV_GetScreenSaveActive
*
* Returns the active status of the screen saver
*/
BOOL TTYDRV_GetScreenSaveActive(void)
{
return FALSE;
}
/***********************************************************************
* TTYDRV_SetScreenSaveActive
*
* Activate/Deactivate the screen saver
*/
void TTYDRV_SetScreenSaveActive(BOOL bActivate)
{
FIXME("(%d): stub\n", bActivate);
}
/***********************************************************************
* TTYDRV_GetScreenSaveTimeout
*
* Return the screen saver timeout
*/
int TTYDRV_GetScreenSaveTimeout(void)
{
return 0;
}
/***********************************************************************
* TTYDRV_SetScreenSaveTimeout
*
* Set the screen saver timeout
*/
void TTYDRV_SetScreenSaveTimeout(int nTimeout)
{
FIXME("(%d): stub\n", nTimeout);
}
/**********************************************************************
* TTYDRV_LoadOEMResource
*/
HANDLE TTYDRV_LoadOEMResource(WORD resid, WORD type)
{
HBITMAP hbitmap;
switch(type)
{
case OEM_BITMAP:
hbitmap = CreateBitmap(1, 1, 1, 1, NULL);
TTYDRV_DC_CreateBitmap(hbitmap);
return hbitmap;
case OEM_CURSOR:
case OEM_ICON:
break;
default:
ERR("unknown type (%d)\n", type);
}
return 0;
}
/***********************************************************************
* TTYDRV_IsSingleWindow
*/
BOOL TTYDRV_IsSingleWindow(void)
{
return TRUE;
}
/***********************************************************************
* TTYDRV_AcquireClipboard
*/
void TTYDRV_AcquireClipboard(void)
{
}
/***********************************************************************
* TTYDRV_ReleaseClipboard
*/
void TTYDRV_ReleaseClipboard(void)
{
}
/***********************************************************************
* TTYDRV_SetClipboardData
*/
void TTYDRV_SetClipboardData(UINT wFormat)
{
}
/***********************************************************************
* TTYDRV_GetClipboardData
*/
BOOL TTYDRV_GetClipboardData(UINT wFormat)
{
return FALSE;
}
/***********************************************************************
* TTYDRV_IsClipboardFormatAvailable
*/
BOOL TTYDRV_IsClipboardFormatAvailable(UINT wFormat)
{
return FALSE;
}
/**************************************************************************
* TTYDRV_RegisterClipboardFormat
*
* Registers a custom clipboard format
* Returns: TRUE - new format registered, FALSE - Format already registered
*/
BOOL TTYDRV_RegisterClipboardFormat( LPCSTR FormatName )
{
return TRUE;
}
/**************************************************************************
* TTYDRV_IsSelectionOwner
*
* Returns: TRUE - We(WINE) own the selection, FALSE - Selection not owned by us
*/
BOOL TTYDRV_IsSelectionOwner(void)
{
return FALSE;
}
/***********************************************************************
* TTYDRV_ResetSelectionOwner
*/
void TTYDRV_ResetSelectionOwner(struct tagWND *pWnd, BOOL bFooBar)
{
}

24
windows/ttydrv/wnd.c → dlls/ttydrv/wnd.c
View File

@ -13,7 +13,29 @@
#include "win.h"
#include "debugtools.h"
DEFAULT_DEBUG_CHANNEL(ttydrv)
DEFAULT_DEBUG_CHANNEL(ttydrv);
WND_DRIVER TTYDRV_WND_Driver =
{
TTYDRV_WND_Initialize,
TTYDRV_WND_Finalize,
TTYDRV_WND_CreateDesktopWindow,
TTYDRV_WND_CreateWindow,
TTYDRV_WND_DestroyWindow,
TTYDRV_WND_SetParent,
TTYDRV_WND_ForceWindowRaise,
TTYDRV_WND_SetWindowPos,
TTYDRV_WND_SetText,
TTYDRV_WND_SetFocus,
TTYDRV_WND_PreSizeMove,
TTYDRV_WND_PostSizeMove,
TTYDRV_WND_ScrollWindow,
TTYDRV_WND_SetDrawable,
TTYDRV_WND_SetHostAttr,
TTYDRV_WND_IsSelfClipping,
TTYDRV_WND_SetWindowRgn
};
/***********************************************************************
* TTYDRV_WND_GetCursesWindow

6
dlls/user/display.c
View File

@ -36,7 +36,7 @@ WORD WINAPI DISPLAY_Inquire(LPCURSORINFO lpCursorInfo)
*/
VOID WINAPI DISPLAY_SetCursor( struct tagCURSORICONINFO *lpCursor )
{
USER_Driver->pSetCursor(lpCursor);
USER_Driver.pSetCursor(lpCursor);
}
/***********************************************************************
@ -44,7 +44,7 @@ VOID WINAPI DISPLAY_SetCursor( struct tagCURSORICONINFO *lpCursor )
*/
VOID WINAPI DISPLAY_MoveCursor( WORD wAbsX, WORD wAbsY )
{
USER_Driver->pMoveCursor(wAbsX, wAbsY);
USER_Driver.pMoveCursor(wAbsX, wAbsY);
}
/***********************************************************************
@ -76,6 +76,6 @@ DWORD WINAPI DISPLAY_GetDriverResourceID( WORD wQueriedResID, LPSTR lpsResName )
*/
VOID WINAPI UserRepaintDisable16( BOOL16 disable )
{
USER_Driver->pUserRepaintDisable( disable );
USER_Driver.pUserRepaintDisable( disable );
}

4
dlls/user/mouse.c
View File

@ -63,7 +63,7 @@ VOID WINAPI MOUSE_Enable(LPMOUSE_EVENT_PROC lpMouseEventProc)
{
THUNK_Free( (FARPROC)DefMouseEventProc );
DefMouseEventProc = lpMouseEventProc;
USER_Driver->pInitMouse( lpMouseEventProc );
USER_Driver.pInitMouse( lpMouseEventProc );
}
static VOID WINAPI MOUSE_CallMouseEventProc( FARPROC16 proc,
@ -100,5 +100,5 @@ VOID WINAPI MOUSE_Disable(VOID)
{
THUNK_Free( (FARPROC)DefMouseEventProc );
DefMouseEventProc = 0;
USER_Driver->pInitMouse( 0 );
USER_Driver.pInitMouse( 0 );
}

47
dlls/user/user_main.c
View File

@ -22,6 +22,15 @@
#include "win.h"
#include "debugtools.h"
DEFAULT_DEBUG_CHANNEL(graphics);
USER_DRIVER USER_Driver;
static HMODULE graphics_driver;
#define GET_USER_FUNC(name) \
if (!(USER_Driver.p##name = (void*)GetProcAddress( graphics_driver, #name ))) \
FIXME("%s not found in graphics driver\n", #name)
/* load the graphics driver */
static BOOL load_driver(void)
@ -41,11 +50,45 @@ static BOOL load_driver(void)
strcpy( buffer, "x11drv" ); /* default value */
RegCloseKey( hkey );
if (!LoadLibraryA( buffer ))
if (!(graphics_driver = LoadLibraryA( buffer )))
{
MESSAGE( "Could not load graphics driver '%s'\n", buffer );
return FALSE;
}
GET_USER_FUNC(Synchronize);
GET_USER_FUNC(CheckFocus);
GET_USER_FUNC(UserRepaintDisable);
GET_USER_FUNC(InitKeyboard);
GET_USER_FUNC(VkKeyScan);
GET_USER_FUNC(MapVirtualKey);
GET_USER_FUNC(GetKeyNameText);
GET_USER_FUNC(ToAscii);
GET_USER_FUNC(GetBeepActive);
GET_USER_FUNC(SetBeepActive);
GET_USER_FUNC(Beep);
GET_USER_FUNC(GetDIState);
GET_USER_FUNC(GetDIData);
GET_USER_FUNC(GetKeyboardConfig);
GET_USER_FUNC(SetKeyboardConfig);
GET_USER_FUNC(InitMouse);
GET_USER_FUNC(SetCursor);
GET_USER_FUNC(MoveCursor);
GET_USER_FUNC(GetScreenSaveActive);
GET_USER_FUNC(SetScreenSaveActive);
GET_USER_FUNC(GetScreenSaveTimeout);
GET_USER_FUNC(SetScreenSaveTimeout);
GET_USER_FUNC(LoadOEMResource);
GET_USER_FUNC(IsSingleWindow);
GET_USER_FUNC(AcquireClipboard);
GET_USER_FUNC(ReleaseClipboard);
GET_USER_FUNC(SetClipboardData);
GET_USER_FUNC(GetClipboardData);
GET_USER_FUNC(IsClipboardFormatAvailable);
GET_USER_FUNC(RegisterClipboardFormat);
GET_USER_FUNC(IsSelectionOwner);
GET_USER_FUNC(ResetSelectionOwner);
return TRUE;
}
@ -115,7 +158,7 @@ BOOL WINAPI USER_Init(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
MOUSE_Enable( mouse_event );
/* Start processing X events */
USER_Driver->pUserRepaintDisable( FALSE );
USER_Driver.pUserRepaintDisable( FALSE );
return TRUE;
}

35
dlls/x11drv/x11drv.spec
View File

@ -5,3 +5,38 @@ init X11DRV_Init
import user32.dll
import gdi32.dll
import kernel32.dll
# USER driver
@ cdecl Synchronize() X11DRV_Synchronize
@ cdecl CheckFocus() X11DRV_CheckFocus
@ cdecl UserRepaintDisable(long) X11DRV_UserRepaintDisable
@ cdecl InitKeyboard() X11DRV_InitKeyboard
@ cdecl VkKeyScan(long) X11DRV_VkKeyScan
@ cdecl MapVirtualKey(long long) X11DRV_MapVirtualKey
@ cdecl GetKeyNameText(long str long) X11DRV_GetKeyNameText
@ cdecl ToAscii(long long ptr ptr long) X11DRV_ToAscii
@ cdecl GetBeepActive() X11DRV_GetBeepActive
@ cdecl SetBeepActive(long) X11DRV_SetBeepActive
@ cdecl Beep() X11DRV_Beep
@ cdecl GetDIState(long ptr) X11DRV_GetDIState
@ cdecl GetDIData(ptr long ptr ptr long) X11DRV_GetDIData
@ cdecl GetKeyboardConfig(ptr) X11DRV_GetKeyboardConfig
@ cdecl SetKeyboardConfig(ptr long) X11DRV_SetKeyboardConfig
@ cdecl InitMouse(ptr) X11DRV_InitMouse
@ cdecl SetCursor(ptr) X11DRV_SetCursor
@ cdecl MoveCursor(long long) X11DRV_MoveCursor
@ cdecl GetScreenSaveActive() X11DRV_GetScreenSaveActive
@ cdecl SetScreenSaveActive(long) X11DRV_SetScreenSaveActive
@ cdecl GetScreenSaveTimeout() X11DRV_GetScreenSaveTimeout
@ cdecl SetScreenSaveTimeout(long) X11DRV_SetScreenSaveTimeout
@ cdecl LoadOEMResource(long long) X11DRV_LoadOEMResource
@ cdecl IsSingleWindow() X11DRV_IsSingleWindow
@ cdecl AcquireClipboard() X11DRV_AcquireClipboard
@ cdecl ReleaseClipboard() X11DRV_ReleaseClipboard
@ cdecl SetClipboardData(long) X11DRV_SetClipboardData
@ cdecl GetClipboardData(long) X11DRV_GetClipboardData
@ cdecl IsClipboardFormatAvailable(long) X11DRV_IsClipboardFormatAvailable
@ cdecl RegisterClipboardFormat(str) X11DRV_RegisterClipboardFormat
@ cdecl IsSelectionOwner() X11DRV_IsSelectionOwner
@ cdecl ResetSelectionOwner(ptr long) X11DRV_ResetSelectionOwner

39
dlls/x11drv/x11drv_main.c
View File

@ -20,7 +20,6 @@
#include "winreg.h"
#include "callback.h"
#include "clipboard.h"
#include "debugtools.h"
#include "gdi.h"
#include "options.h"
@ -31,40 +30,6 @@
DEFAULT_DEBUG_CHANNEL(x11drv);
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,
/* screen saver functions */
X11DRV_GetScreenSaveActive,
X11DRV_SetScreenSaveActive,
X11DRV_GetScreenSaveTimeout,
X11DRV_SetScreenSaveTimeout,
/* resource functions */
X11DRV_LoadOEMResource,
/* windowing functions */
X11DRV_IsSingleWindow
};
static XKeyboardState keyboard_state;
Display *display;
@ -249,8 +214,6 @@ static void XOpenIM_large_stack(void)
*/
static void process_attach(void)
{
USER_Driver = &user_driver;
CLIPBOARD_Driver = &X11DRV_CLIPBOARD_Driver;
WND_Driver = &X11DRV_WND_Driver;
setup_options();
@ -344,8 +307,6 @@ static void process_detach(void)
XCloseDisplay( display );
display = NULL;
USER_Driver = NULL;
CLIPBOARD_Driver = NULL;
WND_Driver = NULL;
#endif
}

1
graphics/ttydrv/.cvsignore
View File

@ -1 +0,0 @@
Makefile

28
graphics/ttydrv/Makefile.in
View File

@ -1,28 +0,0 @@
DEFS = @DLLFLAGS@ -D__WINE__
TOPSRCDIR = @top_srcdir@
TOPOBJDIR = ../..
SRCDIR = @srcdir@
VPATH = @srcdir@
MODULE = ttydrv
C_SRCS = \
bitblt.c \
bitmap.c \
brush.c \
clipping.c \
dc.c \
dib.c \
font.c \
graphics.c \
init.c \
objects.c \
oembitmap.c \
palette.c \
pen.c \
text.c
all: $(MODULE).o
@MAKE_RULES@
### Dependencies:

58
graphics/ttydrv/bitblt.c
View File

@ -1,58 +0,0 @@
/*
* TTY DC bit blit
*
* Copyright 1999 Patrik Stridvall
*/
#include "dc.h"
#include "debugtools.h"
#include "pen.h"
#include "ttydrv.h"
DEFAULT_DEBUG_CHANNEL(ttydrv)
/***********************************************************************
* TTYDRV_DC_BitBlt
*/
BOOL TTYDRV_DC_BitBlt(DC *dcDst, INT xDst, INT yDst,
INT width, INT height, DC *dcSrc,
INT xSrc, INT ySrc, DWORD rop)
{
FIXME("(%p, %d, %d, %d, %d, %p, %d, %d, %lu): stub\n",
dcDst, xDst, yDst, width, height,
dcSrc, xSrc, ySrc, rop
);
return TRUE;
}
/***********************************************************************
* TTYDRV_DC_PatBlt
*/
BOOL TTYDRV_DC_PatBlt(DC *dc, INT left, INT top,
INT width, INT height, DWORD rop)
{
FIXME("(%p, %d, %d, %d, %d, %lu): stub\n",
dc, left, top, width, height, rop
);
return TRUE;
}
/***********************************************************************
* TTYDRV_DC_StretchBlt
*/
BOOL TTYDRV_DC_StretchBlt(DC *dcDst, INT xDst, INT yDst,
INT widthDst, INT heightDst,
DC *dcSrc, INT xSrc, INT ySrc,
INT widthSrc, INT heightSrc, DWORD rop)
{
FIXME("(%p, %d, %d, %d, %d, %p, %d, %d, %d, %d, %lu): stub\n",
dcDst, xDst, yDst, widthDst, heightDst,
dcSrc, xSrc, ySrc, widthSrc, heightSrc, rop
);
return TRUE;
}

27
graphics/ttydrv/brush.c
View File

@ -1,27 +0,0 @@
/*
* TTY DC brush
*
* Copyright 1999 Patrik Stridvall
*/
#include "brush.h"
#include "dc.h"
#include "debugtools.h"
#include "ttydrv.h"
DEFAULT_DEBUG_CHANNEL(ttydrv)
/***********************************************************************
* TTYDRV_DC_BRUSH_SelectObject
*/
HBRUSH TTYDRV_DC_BRUSH_SelectObject(DC *dc, HBRUSH hbrush, BRUSHOBJ *brush)
{
HBRUSH hPreviousBrush;
TRACE("(%p, 0x%04x, %p)\n", dc, hbrush, brush);
hPreviousBrush = dc->w.hBrush;
dc->w.hBrush = hbrush;
return hPreviousBrush;
}

21
graphics/ttydrv/clipping.c
View File

@ -1,21 +0,0 @@
/*
* TTY DC clipping
*
* Copyright 1999 Patrik Stridvall
*/
#include "dc.h"
#include "debugtools.h"
#include "ttydrv.h"
DEFAULT_DEBUG_CHANNEL(ttydrv)
/***********************************************************************
* TTYDRV_DC_SetDeviceClipping
*/
void TTYDRV_DC_SetDeviceClipping(DC *dc)
{
TRACE("(%p)\n", dc);
}

99
graphics/ttydrv/dc.c
View File

@ -1,99 +0,0 @@
/*
* TTY DC driver
*
* Copyright 1999 Patrik Stridvall
*/
#include "config.h"
#include "gdi.h"
#include "bitmap.h"
#include "dc.h"
#include "ttydrv.h"
#include "winbase.h"
#include "debugtools.h"
DEFAULT_DEBUG_CHANNEL(ttydrv);
/**********************************************************************/
extern DeviceCaps TTYDRV_DC_DevCaps;
/***********************************************************************
* TTYDRV_DC_CreateDC
*/
BOOL TTYDRV_DC_CreateDC(DC *dc, LPCSTR driver, LPCSTR device,
LPCSTR output, const DEVMODEA *initData)
{
TTYDRV_PDEVICE *physDev;
BITMAPOBJ *bmp;
TRACE("(%p, %s, %s, %s, %p)\n",
dc, debugstr_a(driver), debugstr_a(device),
debugstr_a(output), initData);
dc->physDev = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
sizeof(TTYDRV_PDEVICE));
if(!dc->physDev) {
ERR("Can't allocate physDev\n");
return FALSE;
}
physDev = (TTYDRV_PDEVICE *) dc->physDev;
dc->w.devCaps = &TTYDRV_DC_DevCaps;
if(dc->w.flags & DC_MEMORY){
physDev->window = NULL;
physDev->cellWidth = 1;
physDev->cellHeight = 1;
TTYDRV_DC_CreateBitmap(dc->w.hBitmap);
bmp = (BITMAPOBJ *) GDI_GetObjPtr(dc->w.hBitmap, BITMAP_MAGIC);
dc->w.bitsPerPixel = bmp->bitmap.bmBitsPixel;
dc->w.totalExtent.left = 0;
dc->w.totalExtent.top = 0;
dc->w.totalExtent.right = bmp->bitmap.bmWidth;
dc->w.totalExtent.bottom = bmp->bitmap.bmHeight;
dc->w.hVisRgn = CreateRectRgnIndirect( &dc->w.totalExtent );
GDI_HEAP_UNLOCK( dc->w.hBitmap );
} else {
physDev->window = TTYDRV_GetRootWindow();
physDev->cellWidth = cell_width;
physDev->cellHeight = cell_height;
dc->w.bitsPerPixel = 1;
dc->w.totalExtent.left = 0;
dc->w.totalExtent.top = 0;
dc->w.totalExtent.right = cell_width * screen_cols;
dc->w.totalExtent.bottom = cell_height * screen_rows;
dc->w.hVisRgn = CreateRectRgnIndirect( &dc->w.totalExtent );
}
return TRUE;
}
/***********************************************************************
* TTYDRV_DC_DeleteDC
*/
BOOL TTYDRV_DC_DeleteDC(DC *dc)
{
TRACE("(%p)\n", dc);
HeapFree( GetProcessHeap(), 0, dc->physDev );
dc->physDev = NULL;
return TRUE;
}
/***********************************************************************
* TTYDRV_DC_Escape
*/
INT TTYDRV_DC_Escape(DC *dc, INT nEscape, INT cbInput,
SEGPTR lpInData, SEGPTR lpOutData)
{
return 0;
}

89
graphics/ttydrv/dib.c
View File

@ -1,89 +0,0 @@
/*
* TTY DC dib
*
* Copyright 1999 Patrik Stridvall
*/
#include "bitmap.h"
#include "dc.h"
#include "ttydrv.h"
#include "winbase.h"
#include "debugtools.h"
DEFAULT_DEBUG_CHANNEL(ttydrv)
/***********************************************************************
* TTYDRV_BITMAP_CreateDIBSection
*/
HBITMAP TTYDRV_BITMAP_CreateDIBSection(
DC *dc, BITMAPINFO *bmi, UINT usage,
LPVOID *bits, HANDLE section, DWORD offset)
{
FIXME("(%p, %p, %u, %p, 0x%04x, %ld): stub\n",
dc, bmi, usage, bits, section, offset);
return (HBITMAP) NULL;
}
/**********************************************************************
* TTYDRV_BITMAP_CreateDIBSection16
*/
HBITMAP16 TTYDRV_DIB_CreateDIBSection16(
DC *dc, BITMAPINFO *bmi, UINT16 usage,
SEGPTR *bits, HANDLE section, DWORD offset)
{
FIXME("(%p, %p, %u, %p, 0x%04x, %ld): stub\n",
dc, bmi, usage, bits, section, offset);
return (HBITMAP16) NULL;
}
/***********************************************************************
* TTYDRV_BITMAP_DeleteDIBSection
*/
void TTYDRV_BITMAP_DeleteDIBSection(BITMAPOBJ *bmp)
{
FIXME("(%p): stub\n", bmp);
}
/***********************************************************************
* TTYDRV_BITMAP_GetDIBits
*/
INT TTYDRV_BITMAP_GetDIBits(
BITMAPOBJ *bmp, DC *dc, UINT startscan, UINT lines,
LPVOID bits, BITMAPINFO *info, UINT coloruse, HBITMAP hbitmap)
{
FIXME("(%p, %p, %u, %u, %p, %p, %u, 0x%04x): stub\n",
bmp, dc, startscan, lines, bits, info, coloruse, hbitmap);
return 0;
}
/***********************************************************************
* TTYDRV_BITMAP_SetDIBits
*/
INT TTYDRV_BITMAP_SetDIBits(
BITMAPOBJ *bmp, DC *dc, UINT startscan, UINT lines,
LPCVOID bits, const BITMAPINFO *info, UINT coloruse, HBITMAP hbitmap)
{
FIXME("(%p, %p, %u, %u, %p, %p, %u, 0x%04x): stub\n",
bmp, dc, startscan, lines, bits, info, coloruse, hbitmap);
return 0;
}
/***********************************************************************
* TTYDRV_DC_SetDIBitsToDevice
*/
INT TTYDRV_DC_SetDIBitsToDevice(DC *dc, INT xDest, INT yDest, DWORD cx,
DWORD cy, INT xSrc, INT ySrc,
UINT startscan, UINT lines, LPCVOID bits,
const BITMAPINFO *info, UINT coloruse)
{
FIXME("(%p, %d, %d, %ld, %ld, %d, %d, %u, %u, %p, %p, %u): stub\n",
dc, xDest, yDest, cx, cy, xSrc, ySrc, startscan, lines, bits, info, coloruse);
return 0;
}

94
graphics/ttydrv/font.c
View File

@ -1,94 +0,0 @@
/*
* TTY font driver
*
* Copyright 1999 Patrik Stridvall
*/
#include "dc.h"
#include "debugtools.h"
#include "font.h"
#include "ttydrv.h"
#include "wingdi.h"
DEFAULT_DEBUG_CHANNEL(ttydrv)
/***********************************************************************
* TTYDRV_DC_GetCharWidth
*/
BOOL TTYDRV_DC_GetCharWidth(DC *dc, UINT firstChar, UINT lastChar,
LPINT buffer)
{
UINT c;
TTYDRV_PDEVICE *physDev = (TTYDRV_PDEVICE *) dc->physDev;
FIXME("(%p, %u, %u, %p): semistub\n", dc, firstChar, lastChar, buffer);
for(c=firstChar; c<=lastChar; c++) {
buffer[c-firstChar] = physDev->cellWidth;
}
return TRUE;
}
/***********************************************************************
* TTYDRV_DC_GetTextExtentPoint
*/
BOOL TTYDRV_DC_GetTextExtentPoint(DC *dc, LPCWSTR str, INT count,
LPSIZE size)
{
TTYDRV_PDEVICE *physDev = (TTYDRV_PDEVICE *) dc->physDev;
TRACE("(%p, %s, %d, %p)\n", dc, debugstr_wn(str, count), count, size);
size->cx = count * physDev->cellWidth;
size->cy = physDev->cellHeight;
return TRUE;
}
/***********************************************************************
* TTYDRV_DC_GetTextMetrics
*/
BOOL TTYDRV_DC_GetTextMetrics(DC *dc, LPTEXTMETRICA lptm)
{
TTYDRV_PDEVICE *physDev = (TTYDRV_PDEVICE *) dc->physDev;
TRACE("(%p, %p)\n", dc, lptm);
lptm->tmHeight = physDev->cellHeight;
lptm->tmAscent = 0;
lptm->tmDescent = 0;
lptm->tmInternalLeading = 0;
lptm->tmExternalLeading = 0;
lptm->tmAveCharWidth = physDev->cellWidth;
lptm->tmMaxCharWidth = physDev->cellWidth;
lptm->tmWeight = FW_MEDIUM;
lptm->tmOverhang = 0;
lptm->tmDigitizedAspectX = physDev->cellWidth;
lptm->tmDigitizedAspectY = physDev->cellHeight;
lptm->tmFirstChar = 32;
lptm->tmLastChar = 255;
lptm->tmDefaultChar = 0;
lptm->tmBreakChar = 32;
lptm->tmItalic = FALSE;
lptm->tmUnderlined = FALSE;
lptm->tmStruckOut = FALSE;
lptm->tmPitchAndFamily = TMPF_FIXED_PITCH|TMPF_DEVICE;
lptm->tmCharSet = ANSI_CHARSET;
return TRUE;
}
/***********************************************************************
* TTYDRV_DC_FONT_SelectObject
*/
HFONT TTYDRV_DC_FONT_SelectObject(DC* dc, HFONT hfont, FONTOBJ *font)
{
HFONT hPreviousFont;
TRACE("(%p, 0x%04x, %p)\n", dc, hfont, font);
hPreviousFont = dc->w.hFont;
dc->w.hFont = hfont;
return hPreviousFont;
}

54
graphics/ttydrv/oembitmap.c
View File

@ -1,54 +0,0 @@
/*
* TTY DC OEM bitmap
*
* Copyright 1999 Patrik Stridvall
*/
#include "bitmap.h"
#include "ttydrv.h"
#include "debugtools.h"
DEFAULT_DEBUG_CHANNEL(ttydrv)
/**********************************************************************
* TTYDRV_LoadOEMBitmap
*/
static HANDLE TTYDRV_LoadOEMBitmap(WORD resid)
{
HBITMAP hbitmap;
TRACE("(%d)\n", resid);
hbitmap = CreateBitmap(1, 1, 1, 1, NULL);
TTYDRV_DC_CreateBitmap(hbitmap);
return hbitmap;
}
/**********************************************************************
* TTYDRV_LoadOEMCursorIcon
*/
static HANDLE TTYDRV_LoadOEMCursorIcon(WORD resid, BOOL bCursor)
{
return (HANDLE) NULL;
}
/**********************************************************************
* TTYDRV_LoadOEMResource
*/
HANDLE TTYDRV_LoadOEMResource(WORD resid, WORD type)
{
switch(type)
{
case OEM_BITMAP:
return TTYDRV_LoadOEMBitmap(resid);
case OEM_CURSOR:
return TTYDRV_LoadOEMCursorIcon(resid, TRUE);
case OEM_ICON:
return TTYDRV_LoadOEMCursorIcon(resid, FALSE);
default:
ERR("unknown type (%d)\n", type);
}
return (HANDLE) NULL;
}

27
graphics/ttydrv/pen.c
View File

@ -1,27 +0,0 @@
/*
* TTY DC pen
*
* Copyright 1999 Patrik Stridvall
*/
#include "dc.h"
#include "debugtools.h"
#include "pen.h"
#include "ttydrv.h"
DEFAULT_DEBUG_CHANNEL(ttydrv)
/***********************************************************************
* TTYDRV_DC_PEN_SelectObject
*/
HPEN TTYDRV_DC_PEN_SelectObject(DC *dc, HBRUSH hpen, PENOBJ *pen)
{
HPEN hPreviousPen;
TRACE("(%p, 0x%04x, %p)\n", dc, hpen, pen);
hPreviousPen = dc->w.hPen;
dc->w.hPen = hpen;
return hPreviousPen;
}

66
graphics/ttydrv/text.c
View File

@ -1,66 +0,0 @@
/*
* TTY DC text
*
* Copyright 1999 Patrik Stridvall
*/
#include "config.h"
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
#include "dc.h"
#include "debugtools.h"
#include "gdi.h"
#include "ttydrv.h"
DEFAULT_DEBUG_CHANNEL(ttydrv);
/***********************************************************************
* TTYDRV_DC_ExtTextOut
*/
BOOL TTYDRV_DC_ExtTextOut(DC *dc, INT x, INT y, UINT flags,
const RECT *lpRect, LPCWSTR str, UINT count,
const INT *lpDx)
{
#ifdef WINE_CURSES
TTYDRV_PDEVICE *physDev = (TTYDRV_PDEVICE *) dc->physDev;
INT row, col;
LPSTR ascii;
TRACE("(%p, %d, %d, 0x%08x, %p, %s, %d, %p)\n",
dc, x, y, flags, lpRect, debugstr_wn(str, count), count, lpDx);
if(!physDev->window)
return FALSE;
/* FIXME: Is this really correct? */
if(dc->w.textAlign & TA_UPDATECP) {
x = dc->w.CursPosX;
y = dc->w.CursPosY;
}
x = XLPTODP(dc, x);
y = YLPTODP(dc, y);
row = (dc->w.DCOrgY + y) / physDev->cellHeight;
col = (dc->w.DCOrgX + x) / physDev->cellWidth;
ascii = HeapAlloc( GetProcessHeap(), 0, count+1 );
lstrcpynWtoA(ascii, str, count+1);
mvwaddnstr(physDev->window, row, col, ascii, count);
HeapFree( GetProcessHeap(), 0, ascii );
wrefresh(physDev->window);
if(dc->w.textAlign & TA_UPDATECP) {
dc->w.CursPosX += count * physDev->cellWidth;
dc->w.CursPosY += physDev->cellHeight;
}
return TRUE;
#else /* defined(WINE_CURSES) */
FIXME("(%p, %d, %d, 0x%08x, %p, %s, %d, %p): stub\n",
dc, x, y, flags, lpRect, debugstr_wn(str,count), count, lpDx);
return TRUE;
#endif /* defined(WINE_CURSES) */
}

15
include/clipboard.h
View File

@ -18,20 +18,6 @@ typedef struct tagWINE_CLIPFORMAT {
struct tagWINE_CLIPFORMAT *NextFormat;
} WINE_CLIPFORMAT, *LPWINE_CLIPFORMAT;
typedef struct tagCLIPBOARD_DRIVER
{
void (*pAcquire)(void); /* Acquire selection */
void (*pRelease)(void); /* Release selection */
void (*pSetData)(UINT); /* Set specified selection data */
BOOL (*pGetData)(UINT); /* Get specified selection data */
BOOL (*pIsFormatAvailable)(UINT); /* Check if specified format is available */
BOOL (*pRegisterFormat)(LPCSTR); /* Register a clipboard format */
BOOL (*pIsSelectionOwner)(void); /* Check if we own the selection */
void (*pResetOwner)(struct tagWND *, BOOL);
} CLIPBOARD_DRIVER;
extern CLIPBOARD_DRIVER *CLIPBOARD_Driver;
extern LPWINE_CLIPFORMAT CLIPBOARD_LookupFormat( WORD wID );
extern BOOL CLIPBOARD_IsCacheRendered();
extern void CLIPBOARD_DeleteRecord(LPWINE_CLIPFORMAT lpFormat, BOOL bChange);
@ -40,5 +26,4 @@ extern BOOL CLIPBOARD_IsPresent(WORD wFormat);
extern char * CLIPBOARD_GetFormatName(UINT wFormat);
extern void CLIPBOARD_ReleaseOwner();
#endif /* __WINE_CLIPBOARD_H */

13
include/user.h
View File

@ -39,6 +39,8 @@ typedef struct tagKEYBOARD_CONFIG {
typedef VOID CALLBACK (*LPMOUSE_EVENT_PROC)(DWORD,DWORD,DWORD,DWORD,DWORD);
struct tagWND;
typedef struct tagUSER_DRIVER {
/* event functions */
void (*pSynchronize)(void);
@ -70,9 +72,18 @@ typedef struct tagUSER_DRIVER {
HANDLE (*pLoadOEMResource)(WORD,WORD);
/* windowing functions */
BOOL (*pIsSingleWindow)(void);
/* clipboard functions */
void (*pAcquireClipboard)(void); /* Acquire selection */
void (*pReleaseClipboard)(void); /* Release selection */
void (*pSetClipboardData)(UINT); /* Set specified selection data */
BOOL (*pGetClipboardData)(UINT); /* Get specified selection data */
BOOL (*pIsClipboardFormatAvailable)(UINT); /* Check if specified format is available */
BOOL (*pRegisterClipboardFormat)(LPCSTR); /* Register a clipboard format */
BOOL (*pIsSelectionOwner)(void); /* Check if we own the selection */
void (*pResetSelectionOwner)(struct tagWND *, BOOL);
} USER_DRIVER;
extern USER_DRIVER *USER_Driver;
extern USER_DRIVER USER_Driver;
WORD WINAPI UserSignalProc( UINT uCode, DWORD dwThreadOrProcessID,
DWORD dwFlags, HMODULE16 hModule );

55
include/x11drv.h
View File

@ -331,41 +331,23 @@ static inline Visual *X11DRV_GetVisual(void) { return visual; }
static inline Window X11DRV_GetXRootWindow(void) { return root_window; }
static inline unsigned int X11DRV_GetDepth(void) { return screen_depth; }
extern BOOL X11DRV_GetScreenSaveActive(void);
extern void X11DRV_SetScreenSaveActive(BOOL bActivate);
extern int X11DRV_GetScreenSaveTimeout(void);
extern void X11DRV_SetScreenSaveTimeout(int nTimeout);
extern HANDLE X11DRV_LoadOEMResource( WORD id, WORD type );
extern BOOL X11DRV_IsSingleWindow(void);
/* X11 clipboard driver */
extern struct tagCLIPBOARD_DRIVER X11DRV_CLIPBOARD_Driver;
extern void X11DRV_CLIPBOARD_FreeResources( Atom property );
extern BOOL X11DRV_CLIPBOARD_RegisterPixmapResource( Atom property, Pixmap pixmap );
extern void X11DRV_CLIPBOARD_Acquire(void);
extern void X11DRV_CLIPBOARD_Release(void);
extern void X11DRV_CLIPBOARD_SetData(UINT wFormat);
extern BOOL X11DRV_CLIPBOARD_GetData(UINT wFormat);
extern BOOL X11DRV_CLIPBOARD_IsFormatAvailable(UINT wFormat);
extern BOOL X11DRV_CLIPBOARD_IsNativeProperty(Atom prop);
extern BOOL X11DRV_CLIPBOARD_RegisterFormat( LPCSTR FormatName );
extern BOOL X11DRV_CLIPBOARD_IsSelectionowner();
extern UINT X11DRV_CLIPBOARD_MapPropertyToFormat(char *itemFmtName);
extern Atom X11DRV_CLIPBOARD_MapFormatToProperty(UINT id);
extern void X11DRV_CLIPBOARD_ResetOwner(struct tagWND *pWnd, BOOL bFooBar);
extern void X11DRV_CLIPBOARD_ReleaseSelection(Atom selType, Window w, HWND hwnd);
extern BOOL X11DRV_IsSelectionOwner(void);
extern BOOL X11DRV_GetClipboardData(UINT wFormat);
/* X11 event driver */
extern WORD X11DRV_EVENT_XStateToKeyState( int state ) ;
extern BOOL X11DRV_EVENT_Init(void);
extern void X11DRV_EVENT_Synchronize( void );
extern BOOL X11DRV_EVENT_CheckFocus( void );
extern void X11DRV_EVENT_UserRepaintDisable( BOOL bDisable );
extern void X11DRV_Synchronize( void );
typedef enum {
X11DRV_INPUT_RELATIVE,
@ -380,27 +362,24 @@ void X11DRV_EVENT_SetDGAStatus(HWND hwnd, int event_base) ;
/* X11 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);
extern BOOL X11DRV_KEYBOARD_GetBeepActive(void);
extern void X11DRV_KEYBOARD_SetBeepActive(BOOL bActivate);
extern void X11DRV_KEYBOARD_Beep(void);
extern BOOL X11DRV_KEYBOARD_GetDIState(DWORD len, LPVOID ptr);
extern BOOL X11DRV_KEYBOARD_GetDIData(BYTE *keystate, DWORD dodsize, struct DIDEVICEOBJECTDATA *dod, LPDWORD entries, DWORD flags);
extern void X11DRV_KEYBOARD_GetKeyboardConfig(struct tagKEYBOARD_CONFIG *cfg);
extern void X11DRV_KEYBOARD_SetKeyboardConfig(struct tagKEYBOARD_CONFIG *cfg, DWORD mask);
extern void X11DRV_InitKeyboard(void);
extern WORD X11DRV_VkKeyScan(CHAR cChar);
extern UINT16 X11DRV_MapVirtualKey(UINT16 wCode, UINT16 wMapType);
extern INT16 X11DRV_GetKeyNameText(LONG lParam, LPSTR lpBuffer, INT16 nSize);
extern INT16 X11DRV_ToAscii(UINT16 virtKey, UINT16 scanCode, LPBYTE lpKeyState, LPVOID lpChar, UINT16 flags);
extern BOOL X11DRV_GetDIState(DWORD len, LPVOID ptr);
extern BOOL X11DRV_GetDIData(BYTE *keystate, DWORD dodsize, struct DIDEVICEOBJECTDATA *dod, LPDWORD entries, DWORD flags);
extern void X11DRV_GetKeyboardConfig(struct tagKEYBOARD_CONFIG *cfg);
extern void X11DRV_SetKeyboardConfig(struct tagKEYBOARD_CONFIG *cfg, DWORD mask);
extern void X11DRV_KEYBOARD_HandleEvent(struct tagWND *pWnd, XKeyEvent *event);
extern void X11DRV_HandleEvent(struct tagWND *pWnd, XKeyEvent *event);
/* X11 mouse driver */
extern void X11DRV_MOUSE_Init(LPMOUSE_EVENT_PROC);
extern void X11DRV_MOUSE_SetCursor(struct tagCURSORICONINFO *lpCursor);
extern void X11DRV_MOUSE_MoveCursor(WORD wAbsX, WORD wAbsY);
extern void X11DRV_MOUSE_SendEvent( DWORD mouseStatus, DWORD posX, DWORD posY,
extern void X11DRV_InitMouse(LPMOUSE_EVENT_PROC);
extern void X11DRV_SetCursor(struct tagCURSORICONINFO *lpCursor);
extern void X11DRV_MoveCursor(WORD wAbsX, WORD wAbsY);
extern void X11DRV_SendEvent( DWORD mouseStatus, DWORD posX, DWORD posY,
DWORD keyState, DWORD time, HWND hWnd );
/* X11 windows driver */

6
misc/main.c
View File

@ -25,18 +25,12 @@
#include "debugdefs.h"
#include "module.h"
#include "winnls.h"
#include "user.h"
#include "windef.h"
#include "wingdi.h"
#include "wine/winuser16.h"
#include "tweak.h"
#include "winerror.h"
/**********************************************************************/
USER_DRIVER *USER_Driver = NULL;
/***********************************************************************
* MAIN_ParseDebugOptions

67
windows/clipboard.c
View File

@ -32,10 +32,11 @@
#include "message.h"
#include "task.h"
#include "queue.h"
#include "user.h"
#include "clipboard.h"
#include "debugtools.h"
DEFAULT_DEBUG_CHANNEL(clipboard)
DEFAULT_DEBUG_CHANNEL(clipboard);
#define CF_REGFORMATBASE 0xC000
@ -43,8 +44,6 @@ DEFAULT_DEBUG_CHANNEL(clipboard)
* Clipboard context global variables
*/
CLIPBOARD_DRIVER *CLIPBOARD_Driver = NULL;
static HANDLE hClipLock = 0;
static BOOL bCBHasChanged = FALSE;
@ -60,24 +59,24 @@ static WORD LastRegFormat = CF_REGFORMATBASE;
* declared in clipboard.h
*/
WINE_CLIPFORMAT ClipFormats[17] = {
{ CF_TEXT, 1, 0, "Text", (HANDLE16)NULL, (HANDLE)NULL, (HANDLE)NULL, 0, NULL, &ClipFormats[1]},
{ CF_BITMAP, 1, 0, "Bitmap", (HANDLE16)NULL, (HANDLE)NULL, (HANDLE)NULL, 0, &ClipFormats[0], &ClipFormats[2]},
{ CF_METAFILEPICT, 1, 0, "MetaFile Picture", (HANDLE16)NULL, (HANDLE)NULL, (HANDLE)NULL, 0, &ClipFormats[1], &ClipFormats[3]},
{ CF_SYLK, 1, 0, "Sylk", (HANDLE16)NULL, (HANDLE)NULL, (HANDLE)NULL, 0, &ClipFormats[2], &ClipFormats[4]},
{ CF_DIF, 1, 0, "DIF", (HANDLE16)NULL, (HANDLE)NULL, (HANDLE)NULL, 0, &ClipFormats[3], &ClipFormats[5]},
{ CF_TIFF, 1, 0, "TIFF", (HANDLE16)NULL, (HANDLE)NULL, (HANDLE)NULL, 0, &ClipFormats[4], &ClipFormats[6]},
{ CF_OEMTEXT, 1, 0, "OEM Text", (HANDLE16)NULL, (HANDLE)NULL, (HANDLE)NULL, 0, &ClipFormats[5], &ClipFormats[7]},
{ CF_DIB, 1, 0, "DIB", (HANDLE16)NULL, (HANDLE)NULL, (HANDLE)NULL, 0, &ClipFormats[6], &ClipFormats[8]},
{ CF_PALETTE, 1, 0, "Palette", (HANDLE16)NULL, (HANDLE)NULL, (HANDLE)NULL, 0, &ClipFormats[7], &ClipFormats[9]},
{ CF_PENDATA, 1, 0, "PenData", (HANDLE16)NULL, (HANDLE)NULL, (HANDLE)NULL, 0, &ClipFormats[8], &ClipFormats[10]},
{ CF_RIFF, 1, 0, "RIFF", (HANDLE16)NULL, (HANDLE)NULL, (HANDLE)NULL, 0, &ClipFormats[9], &ClipFormats[11]},
{ CF_WAVE, 1, 0, "Wave", (HANDLE16)NULL, (HANDLE)NULL, (HANDLE)NULL, 0, &ClipFormats[10], &ClipFormats[12]},
{ CF_OWNERDISPLAY, 1, 0, "Owner Display", (HANDLE16)NULL, (HANDLE)NULL, (HANDLE)NULL, 0, &ClipFormats[11], &ClipFormats[13]},
{ CF_DSPTEXT, 1, 0, "DSPText", (HANDLE16)NULL, (HANDLE)NULL, (HANDLE)NULL, 0, &ClipFormats[12], &ClipFormats[14]},
{ CF_DSPMETAFILEPICT, 1, 0, "DSPMetaFile Picture", (HANDLE16)NULL, (HANDLE)NULL, (HANDLE)NULL, 0, &ClipFormats[13], &ClipFormats[15]},
{ CF_DSPBITMAP, 1, 0, "DSPBitmap", (HANDLE16)NULL, (HANDLE)NULL, (HANDLE)NULL, 0, &ClipFormats[14], &ClipFormats[16]},
{ CF_HDROP, 1, 0, "HDROP", (HANDLE16)NULL, (HANDLE)NULL, (HANDLE)NULL, 0, &ClipFormats[15], NULL}
};
{ CF_TEXT, 1, 0, "Text", 0, 0, 0, 0, NULL, &ClipFormats[1]},
{ CF_BITMAP, 1, 0, "Bitmap", 0, 0, 0, 0, &ClipFormats[0], &ClipFormats[2]},
{ CF_METAFILEPICT, 1, 0, "MetaFile Picture", 0, 0, 0, 0, &ClipFormats[1], &ClipFormats[3]},
{ CF_SYLK, 1, 0, "Sylk", 0, 0, 0, 0, &ClipFormats[2], &ClipFormats[4]},
{ CF_DIF, 1, 0, "DIF", 0, 0, 0, 0, &ClipFormats[3], &ClipFormats[5]},
{ CF_TIFF, 1, 0, "TIFF", 0, 0, 0, 0, &ClipFormats[4], &ClipFormats[6]},
{ CF_OEMTEXT, 1, 0, "OEM Text", 0, 0, 0, 0, &ClipFormats[5], &ClipFormats[7]},
{ CF_DIB, 1, 0, "DIB", 0, 0, 0, 0, &ClipFormats[6], &ClipFormats[8]},
{ CF_PALETTE, 1, 0, "Palette", 0, 0, 0, 0, &ClipFormats[7], &ClipFormats[9]},
{ CF_PENDATA, 1, 0, "PenData", 0, 0, 0, 0, &ClipFormats[8], &ClipFormats[10]},
{ CF_RIFF, 1, 0, "RIFF", 0, 0, 0, 0, &ClipFormats[9], &ClipFormats[11]},
{ CF_WAVE, 1, 0, "Wave", 0, 0, 0, 0, &ClipFormats[10], &ClipFormats[12]},
{ CF_OWNERDISPLAY, 1, 0, "Owner Display", 0, 0, 0, 0, &ClipFormats[11], &ClipFormats[13]},
{ CF_DSPTEXT, 1, 0, "DSPText", 0, 0, 0, 0, &ClipFormats[12], &ClipFormats[14]},
{ CF_DSPMETAFILEPICT, 1, 0, "DSPMetaFile Picture", 0, 0, 0, 0, &ClipFormats[13], &ClipFormats[15]},
{ CF_DSPBITMAP, 1, 0, "DSPBitmap", 0, 0, 0, 0, &ClipFormats[14], &ClipFormats[16]},
{ CF_HDROP, 1, 0, "HDROP", 0, 0, 0, 0, &ClipFormats[15], NULL}
};
/**************************************************************************
@ -389,10 +388,10 @@ static BOOL CLIPBOARD_RenderFormat(LPWINE_CLIPFORMAT lpFormat)
* If WINE is not the selection owner, and the format is available
* we must ask the the driver to render the data to the clipboard cache.
*/
if ( !CLIPBOARD_Driver->pIsSelectionOwner()
&& CLIPBOARD_Driver->pIsFormatAvailable( lpFormat->wFormatID ) )
if ( !USER_Driver.pIsSelectionOwner()
&& USER_Driver.pIsClipboardFormatAvailable( lpFormat->wFormatID ) )
{
if ( !CLIPBOARD_Driver->pGetData( lpFormat->wFormatID ) )
if ( !USER_Driver.pGetClipboardData( lpFormat->wFormatID ) )
return FALSE;
}
/*
@ -621,7 +620,7 @@ BOOL WINAPI EmptyClipboard(void)
hTaskClipOwner = GetCurrentTask();
/* Tell the driver to acquire the selection */
CLIPBOARD_Driver->pAcquire();
USER_Driver.pAcquireClipboard();
return TRUE;
}
@ -673,7 +672,7 @@ HANDLE16 WINAPI SetClipboardData16( UINT16 wFormat, HANDLE16 hData )
}
/* Pass on the request to the driver */
CLIPBOARD_Driver->pSetData(wFormat);
USER_Driver.pSetClipboardData(wFormat);
if ( lpFormat->wDataPresent || lpFormat->hData16 || lpFormat->hData32 )
{
@ -726,7 +725,7 @@ HANDLE WINAPI SetClipboardData( UINT wFormat, HANDLE hData )
}
/* Tell the driver to acquire the selection */
CLIPBOARD_Driver->pAcquire();
USER_Driver.pAcquireClipboard();
if ( lpFormat->wDataPresent &&
(lpFormat->hData16 || lpFormat->hData32) )
@ -927,8 +926,8 @@ INT WINAPI CountClipboardFormats(void)
* available to the clipboard driver.
*/
if ( lpFormat->wDataPresent ||
( !CLIPBOARD_Driver->pIsSelectionOwner()
&& CLIPBOARD_Driver->pIsFormatAvailable( lpFormat->wFormatID ) ) )
( !USER_Driver.pIsSelectionOwner()
&& USER_Driver.pIsClipboardFormatAvailable( lpFormat->wFormatID ) ) )
{
TRACE("\tdata found for format 0x%04x(%s)\n",
lpFormat->wFormatID, CLIPBOARD_GetFormatName(lpFormat->wFormatID));
@ -995,10 +994,10 @@ UINT WINAPI EnumClipboardFormats( UINT wFormat )
(lpFormat->wFormatID == CF_TEXT && ClipFormats[CF_OEMTEXT-1].wDataPresent) );
/* Query the driver if not yet in the cache */
if (!bFormatPresent && !CLIPBOARD_Driver->pIsSelectionOwner())
if (!bFormatPresent && !USER_Driver.pIsSelectionOwner())
{
bFormatPresent =
CLIPBOARD_Driver->pIsFormatAvailable( (lpFormat->wFormatID == CF_TEXT) ?
USER_Driver.pIsClipboardFormatAvailable( (lpFormat->wFormatID == CF_TEXT) ?
CF_OEMTEXT : lpFormat->wFormatID );
}
@ -1066,7 +1065,7 @@ UINT16 WINAPI RegisterClipboardFormat16( LPCSTR FormatName )
lpNewFormat->NextFormat = NULL;
/* Pass on the registration request to the driver */
CLIPBOARD_Driver->pRegisterFormat( FormatName );
USER_Driver.pRegisterClipboardFormat( FormatName );
return LastRegFormat++;
}
@ -1231,8 +1230,8 @@ BOOL WINAPI IsClipboardFormatAvailable( UINT wFormat )
bRet = FALSE;
/* If WINE is not the clipboard selection owner ask the clipboard driver */
else if ( !CLIPBOARD_Driver->pIsSelectionOwner() )
bRet = CLIPBOARD_Driver->pIsFormatAvailable( (wFormat == CF_TEXT) ?
else if ( !USER_Driver.pIsSelectionOwner() )
bRet = USER_Driver.pIsClipboardFormatAvailable( (wFormat == CF_TEXT) ?
CF_OEMTEXT : wFormat );
/* Check if the format is in the local cache */
else

12
windows/cursoricon.c
View File

@ -707,7 +707,7 @@ HGLOBAL CURSORICON_Load( HINSTANCE hInstance, LPCWSTR name,
}
}
else resid = LOWORD(name);
h = USER_Driver->pLoadOEMResource( resid, fCursor ? OEM_CURSOR : OEM_ICON );
h = USER_Driver.pLoadOEMResource( resid, fCursor ? OEM_CURSOR : OEM_ICON );
}
else /* Load from resource */
@ -1392,7 +1392,7 @@ HCURSOR WINAPI SetCursor(
/* Change the cursor shape only if it is visible */
if (CURSOR_ShowCount >= 0)
{
USER_Driver->pSetCursor( (CURSORICONINFO*)GlobalLock16( hActiveCursor ) );
USER_Driver.pSetCursor( (CURSORICONINFO*)GlobalLock16( hActiveCursor ) );
GlobalUnlock16( hActiveCursor );
}
return hOldCursor;
@ -1413,7 +1413,7 @@ void WINAPI SetCursorPos16( INT16 x, INT16 y )
*/
BOOL WINAPI SetCursorPos( INT x, INT y )
{
USER_Driver->pMoveCursor( x, y );
USER_Driver.pMoveCursor( x, y );
return TRUE;
}
@ -1439,14 +1439,14 @@ INT WINAPI ShowCursor( BOOL bShow )
{
if (++CURSOR_ShowCount == 0) /* Show it */
{
USER_Driver->pSetCursor( (CURSORICONINFO*)GlobalLock16( hActiveCursor ) );
USER_Driver.pSetCursor( (CURSORICONINFO*)GlobalLock16( hActiveCursor ) );
GlobalUnlock16( hActiveCursor );
}
}
else
{
if (--CURSOR_ShowCount == -1) /* Hide it */
USER_Driver->pSetCursor( NULL );
USER_Driver.pSetCursor( NULL );
}
return CURSOR_ShowCount;
}
@ -2096,7 +2096,7 @@ static HBITMAP BITMAP_Load( HINSTANCE instance,LPCWSTR name, UINT loadflags )
if (!instance) /* OEM bitmap */
{
if (HIWORD((int)name)) return 0;
return USER_Driver->pLoadOEMResource( LOWORD((int)name), OEM_BITMAP );
return USER_Driver.pLoadOEMResource( LOWORD((int)name), OEM_BITMAP );
}
if (!(hRsrc = FindResourceW( instance, name, RT_BITMAPW ))) return 0;

2
windows/dce.c
View File

@ -838,7 +838,7 @@ HDC WINAPI GetDCEx( HWND hwnd, HRGN hrgnClip, DWORD flags )
WIN_ReleaseWndPtr(parentPtr);
}
else
if ((hwnd == GetDesktopWindow()) && !USER_Driver->pIsSingleWindow())
if ((hwnd == GetDesktopWindow()) && !USER_Driver.pIsSingleWindow())
hrgnVisible = CreateRectRgn( 0, 0, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN) );
else
{

4
windows/event.c
View File

@ -20,7 +20,7 @@ DECLARE_DEBUG_CHANNEL(event);
void EVENT_Synchronize( void )
{
int iWndsLocks = WIN_SuspendWndsLock();
USER_Driver->pSynchronize();
USER_Driver.pSynchronize();
WIN_RestoreWndsLock(iWndsLocks);
}
@ -29,7 +29,7 @@ void EVENT_Synchronize( void )
*/
BOOL EVENT_CheckFocus(void)
{
return USER_Driver->pCheckFocus();
return USER_Driver.pCheckFocus();
}

16
windows/keyboard.c
View File

@ -66,7 +66,7 @@ VOID WINAPI KEYBOARD_Enable( LPKEYBD_EVENT_PROC lpKeybEventProc,
/* all states to false */
memset( lpKeyState, 0, 256 );
if (!initDone) USER_Driver->pInitKeyboard();
if (!initDone) USER_Driver.pInitKeyboard();
initDone = TRUE;
}
@ -180,7 +180,7 @@ DWORD WINAPI OemKeyScan(WORD wOemChar)
WORD WINAPI VkKeyScan16(CHAR cChar)
{
return USER_Driver->pVkKeyScan(cChar);
return USER_Driver.pVkKeyScan(cChar);
}
/******************************************************************************
@ -213,7 +213,7 @@ INT16 WINAPI GetKeyboardType16(INT16 nTypeFlag)
*/
UINT16 WINAPI MapVirtualKey16(UINT16 wCode, UINT16 wMapType)
{
return USER_Driver->pMapVirtualKey(wCode,wMapType);
return USER_Driver.pMapVirtualKey(wCode,wMapType);
}
/****************************************************************************
@ -230,7 +230,7 @@ INT16 WINAPI GetKBCodePage16(void)
*/
INT16 WINAPI GetKeyNameText16(LONG lParam, LPSTR lpBuffer, INT16 nSize)
{
return USER_Driver->pGetKeyNameText(lParam, lpBuffer, nSize);
return USER_Driver.pGetKeyNameText(lParam, lpBuffer, nSize);
}
/****************************************************************************
@ -254,7 +254,7 @@ INT16 WINAPI GetKeyNameText16(LONG lParam, LPSTR lpBuffer, INT16 nSize)
INT16 WINAPI ToAscii16(UINT16 virtKey,UINT16 scanCode, LPBYTE lpKeyState,
LPVOID lpChar, UINT16 flags)
{
return USER_Driver->pToAscii( virtKey, scanCode, lpKeyState, lpChar, flags );
return USER_Driver.pToAscii( virtKey, scanCode, lpKeyState, lpChar, flags );
}
/***********************************************************************
@ -262,7 +262,7 @@ INT16 WINAPI ToAscii16(UINT16 virtKey,UINT16 scanCode, LPBYTE lpKeyState,
*/
BOOL KEYBOARD_GetBeepActive()
{
return USER_Driver->pGetBeepActive();
return USER_Driver.pGetBeepActive();
}
/***********************************************************************
@ -270,7 +270,7 @@ BOOL KEYBOARD_GetBeepActive()
*/
void KEYBOARD_SetBeepActive(BOOL bActivate)
{
USER_Driver->pSetBeepActive(bActivate);
USER_Driver.pSetBeepActive(bActivate);
}
/***********************************************************************
@ -286,6 +286,6 @@ void WINAPI MessageBeep16( UINT16 i )
*/
BOOL WINAPI MessageBeep( UINT i )
{
USER_Driver->pBeep();
USER_Driver.pBeep();
return TRUE;
}

12
windows/sysparams.c
View File

@ -91,7 +91,7 @@ BOOL WINAPI SystemParametersInfoA( UINT uAction, UINT uParam,
break;
case SPI_GETSCREENSAVEACTIVE:
if(USER_Driver->pGetScreenSaveActive() ||
if(USER_Driver.pGetScreenSaveActive() ||
GetProfileIntA( "windows", "ScreenSaveActive", 1 ) == 1)
*(BOOL*)lpvParam = TRUE;
else
@ -99,7 +99,7 @@ BOOL WINAPI SystemParametersInfoA( UINT uAction, UINT uParam,
break;
case SPI_GETSCREENSAVETIMEOUT:
timeout = USER_Driver->pGetScreenSaveTimeout();
timeout = USER_Driver.pGetScreenSaveTimeout();
if(!timeout)
timeout = GetProfileIntA( "windows", "ScreenSaveTimeout", 300 );
*(INT *) lpvParam = timeout * 1000;
@ -328,7 +328,7 @@ BOOL16 WINAPI SystemParametersInfo16( UINT16 uAction, UINT16 uParam,
break;
case SPI_GETSCREENSAVEACTIVE:
if(USER_Driver->pGetScreenSaveActive() ||
if(USER_Driver.pGetScreenSaveActive() ||
GetProfileIntA( "windows", "ScreenSaveActive", 1 ) == 1)
*(BOOL16 *) lpvParam = TRUE;
else
@ -336,7 +336,7 @@ BOOL16 WINAPI SystemParametersInfo16( UINT16 uAction, UINT16 uParam,
break;
case SPI_GETSCREENSAVETIMEOUT:
timeout = USER_Driver->pGetScreenSaveTimeout();
timeout = USER_Driver.pGetScreenSaveTimeout();
if(!timeout)
timeout = GetProfileIntA( "windows", "ScreenSaveTimeout", 300 );
*(INT16 *) lpvParam = timeout;
@ -363,11 +363,11 @@ BOOL16 WINAPI SystemParametersInfo16( UINT16 uAction, UINT16 uParam,
break;
case SPI_SETSCREENSAVEACTIVE:
USER_Driver->pSetScreenSaveActive(uParam);
USER_Driver.pSetScreenSaveActive(uParam);
break;
case SPI_SETSCREENSAVETIMEOUT:
USER_Driver->pSetScreenSaveTimeout(uParam);
USER_Driver.pSetScreenSaveTimeout(uParam);
break;
case SPI_SETDESKWALLPAPER:

20
windows/ttydrv/Makefile.in
View File

@ -1,20 +0,0 @@
DEFS = @DLLFLAGS@ -D__WINE__
TOPSRCDIR = @top_srcdir@
TOPOBJDIR = ../..
SRCDIR = @srcdir@
VPATH = @srcdir@
MODULE = ttydrv
C_SRCS = \
clipboard.c \
event.c \
init.c \
keyboard.c \
mouse.c \
wnd.c
all: $(MODULE).o
@MAKE_RULES@
### Dependencies:

83
windows/ttydrv/clipboard.c
View File

@ -1,83 +0,0 @@
/*
* TTY clipboard driver
*
* Copyright 1998-1999 Patrik Stridvall
*/
#include "heap.h"
#include "ttydrv.h"
#include "win.h"
/**********************************************************************/
char *TTYDRV_CLIPBOARD_szSelection = NULL;
/***********************************************************************
* TTYDRV_CLIPBOARD_Acquire
*/
void TTYDRV_CLIPBOARD_Acquire()
{
}
/***********************************************************************
* TTYDRV_CLIPBOARD_Release
*/
void TTYDRV_CLIPBOARD_Release()
{
if(TTYDRV_CLIPBOARD_szSelection)
{
HeapFree(SystemHeap, 0, TTYDRV_CLIPBOARD_szSelection);
TTYDRV_CLIPBOARD_szSelection = NULL;
}
}
/***********************************************************************
* TTYDRV_CLIPBOARD_SetData
*/
void TTYDRV_CLIPBOARD_SetData(UINT wFormat)
{
}
/***********************************************************************
* TTYDRV_CLIPBOARD_GetData
*/
BOOL TTYDRV_CLIPBOARD_GetData(UINT wFormat)
{
return FALSE;
}
/***********************************************************************
* TTYDRV_CLIPBOARD_IsFormatAvailable
*/
BOOL TTYDRV_CLIPBOARD_IsFormatAvailable(UINT wFormat)
{
return FALSE;
}
/**************************************************************************
* TTYDRV_CLIPBOARD_RegisterFormat
*
* Registers a custom clipboard format
* Returns: TRUE - new format registered, FALSE - Format already registered
*/
BOOL TTYDRV_CLIPBOARD_RegisterFormat( LPCSTR FormatName )
{
return TRUE;
}
/**************************************************************************
* TTYDRV_CLIPBOARD_IsSelectionowner
*
* Returns: TRUE - We(WINE) own the selection, FALSE - Selection not owned by us
*/
BOOL TTYDRV_CLIPBOARD_IsSelectionowner()
{
return FALSE;
}
/***********************************************************************
* TTYDRV_CLIPBOARD_ResetOwner
*/
void TTYDRV_CLIPBOARD_ResetOwner(WND *pWnd, BOOL bFooBar)
{
}

30
windows/ttydrv/event.c
View File

@ -1,30 +0,0 @@
/*
* TTY event driver
*
* Copyright 1998-1999 Patrik Stridvall
*/
#include "ttydrv.h"
/***********************************************************************
* TTYDRV_EVENT_Synchronize
*/
void TTYDRV_EVENT_Synchronize( void )
{
}
/***********************************************************************
* TTYDRV_EVENT_CheckFocus
*/
BOOL TTYDRV_EVENT_CheckFocus(void)
{
return TRUE;
}
/***********************************************************************
* TTYDRV_EVENT_UserRepaintDisable
*/
void TTYDRV_EVENT_UserRepaintDisable( BOOL bDisable )
{
}

45
windows/ttydrv/init.c
View File

@ -1,45 +0,0 @@
/*
* TTY driver
*
* Copyright 1998-1999 Patrik Stridvall
*/
#include "clipboard.h"
#include "user.h"
#include "win.h"
#include "ttydrv.h"
CLIPBOARD_DRIVER TTYDRV_CLIPBOARD_Driver =
{
TTYDRV_CLIPBOARD_Acquire,
TTYDRV_CLIPBOARD_Release,
TTYDRV_CLIPBOARD_SetData,
TTYDRV_CLIPBOARD_GetData,
TTYDRV_CLIPBOARD_IsFormatAvailable,
TTYDRV_CLIPBOARD_RegisterFormat,
TTYDRV_CLIPBOARD_IsSelectionowner,
TTYDRV_CLIPBOARD_ResetOwner
};
WND_DRIVER TTYDRV_WND_Driver =
{
TTYDRV_WND_Initialize,
TTYDRV_WND_Finalize,
TTYDRV_WND_CreateDesktopWindow,
TTYDRV_WND_CreateWindow,
TTYDRV_WND_DestroyWindow,
TTYDRV_WND_SetParent,
TTYDRV_WND_ForceWindowRaise,
TTYDRV_WND_SetWindowPos,
TTYDRV_WND_SetText,
TTYDRV_WND_SetFocus,
TTYDRV_WND_PreSizeMove,
TTYDRV_WND_PostSizeMove,
TTYDRV_WND_ScrollWindow,
TTYDRV_WND_SetDrawable,
TTYDRV_WND_SetHostAttr,
TTYDRV_WND_IsSelfClipping,
TTYDRV_WND_SetWindowRgn
};

112
windows/ttydrv/keyboard.c
View File

@ -1,112 +0,0 @@
/*
* TTY keyboard driver
*
* Copyright 1998 Patrik Stridvall
*/
#include "dinput.h"
#include "user.h"
#include "keyboard.h"
#include "ttydrv.h"
/***********************************************************************
* TTYDRV_KEYBOARD_Init
*/
void TTYDRV_KEYBOARD_Init(void)
{
}
/***********************************************************************
* TTYDRV_KEYBOARD_VkKeyScan
*/
WORD TTYDRV_KEYBOARD_VkKeyScan(CHAR cChar)
{
return 0;
}
/***********************************************************************
* TTYDRV_KEYBOARD_MapVirtualKey
*/
UINT16 TTYDRV_KEYBOARD_MapVirtualKey(UINT16 wCode, UINT16 wMapType)
{
return 0;
}
/***********************************************************************
* TTYDRV_KEYBOARD_GetKeyNameText
*/
INT16 TTYDRV_KEYBOARD_GetKeyNameText(
LONG lParam, LPSTR lpBuffer, INT16 nSize)
{
if(lpBuffer && nSize)
{
*lpBuffer = 0;
}
return 0;
}
/***********************************************************************
* TTYDRV_KEYBOARD_ToAscii
*/
INT16 TTYDRV_KEYBOARD_ToAscii(
UINT16 virtKey, UINT16 scanCode,
LPBYTE lpKeyState, LPVOID lpChar, UINT16 flags)
{
return 0;
}
/***********************************************************************
* TTYDRV_KEYBOARD_GetBeepActive
*/
BOOL TTYDRV_KEYBOARD_GetBeepActive()
{
return FALSE;
}
/***********************************************************************
* TTYDRV_KEYBOARD_SetBeepActive
*/
void TTYDRV_KEYBOARD_SetBeepActive(BOOL bActivate)
{
}
/***********************************************************************
* TTYDRV_KEYBOARD_Beep
*/
void TTYDRV_KEYBOARD_Beep()
{
}
/***********************************************************************
* TTYDRV_KEYBOARD_GetDIState
*/
BOOL TTYDRV_KEYBOARD_GetDIState(DWORD len, LPVOID ptr)
{
return TRUE;
}
/***********************************************************************
* TTYDRV_KEYBOARD_GetDIData
*/
BOOL TTYDRV_KEYBOARD_GetDIData(
BYTE *keystate,
DWORD dodsize, LPDIDEVICEOBJECTDATA dod,
LPDWORD entries, DWORD flags)
{
return TRUE;
}
/***********************************************************************
* TTYDRV_KEYBOARD_GetKeyboardConfig
*/
void TTYDRV_KEYBOARD_GetKeyboardConfig(KEYBOARD_CONFIG *cfg) {
}
/***********************************************************************
* TTYDRV_KEYBOARD_SetKeyboardConfig
*/
extern void TTYDRV_KEYBOARD_SetKeyboardConfig(KEYBOARD_CONFIG *cfg, DWORD mask) {
}

28
windows/ttydrv/mouse.c
View File

@ -1,28 +0,0 @@
/*
* TTY mouse driver
*
* Copyright 1998,1999 Patrik Stridvall
*/
#include "ttydrv.h"
/***********************************************************************
* TTYDRV_MOUSE_SetCursor
*/
void TTYDRV_MOUSE_SetCursor( struct tagCURSORICONINFO *lpCursor )
{
}
/***********************************************************************
* TTYDRV_MOUSE_MoveCursor
*/
void TTYDRV_MOUSE_MoveCursor(WORD wAbsX, WORD wAbsY)
{
}
/***********************************************************************
* TTYDRV_MOUSE_Init
*/
void TTYDRV_MOUSE_Init(LPMOUSE_EVENT_PROC proc)
{
}

4
windows/win.c
View File

@ -1233,7 +1233,7 @@ static void WIN_SendDestroyMsg( WND* pWnd )
WIN_CheckFocus(pWnd);
if( CARET_GetHwnd() == pWnd->hwndSelf ) DestroyCaret();
CLIPBOARD_Driver->pResetOwner( pWnd, TRUE );
USER_Driver.pResetSelectionOwner( pWnd, TRUE );
/*
* Send the WM_DESTROY to the window.
@ -1374,7 +1374,7 @@ BOOL WINAPI DestroyWindow( HWND hwnd )
}
}
CLIPBOARD_Driver->pResetOwner( wndPtr, FALSE ); /* before the window is unmapped */
USER_Driver.pResetSelectionOwner( wndPtr, FALSE ); /* before the window is unmapped */
/* Hide the window */

1
windows/x11drv/Makefile.in
View File

@ -8,7 +8,6 @@ MODULE = x11drv
C_SRCS = \
clipboard.c \
event.c \
init.c \
keyboard.c \
mouse.c \
wnd.c

40
windows/x11drv/clipboard.c
View File

@ -126,7 +126,7 @@ UINT X11DRV_CLIPBOARD_MapPropertyToFormat(char *itemFmtName)
* and if CF_DIB exists in the cache.
* If wine dowsn't own the selection we always return CF_DIB
*/
if ( !X11DRV_CLIPBOARD_IsSelectionowner() )
if ( !X11DRV_IsSelectionOwner() )
return CF_DIB;
else if ( CLIPBOARD_IsPresent(CF_DIB) )
return CF_DIB;
@ -161,7 +161,7 @@ Atom X11DRV_CLIPBOARD_MapFormatToProperty(UINT wFormat)
* Request a PIXMAP, only if WINE is NOT the selection owner,
* AND the requested format is not in the cache.
*/
if ( !X11DRV_CLIPBOARD_IsSelectionowner() && !CLIPBOARD_IsPresent(wFormat) )
if ( !X11DRV_IsSelectionOwner() && !CLIPBOARD_IsPresent(wFormat) )
{
prop = XA_PIXMAP;
break;
@ -793,10 +793,10 @@ void X11DRV_CLIPBOARD_ReleaseSelection(Atom selType, Window w, HWND hwnd)
}
/**************************************************************************
* X11DRV_CLIPBOARD_Empty
* X11DRV_ReleaseClipboard
* Voluntarily release all currently owned X selections
*/
void X11DRV_CLIPBOARD_Release()
void X11DRV_ReleaseClipboard(void)
{
if( selectionAcquired )
{
@ -845,9 +845,9 @@ void X11DRV_CLIPBOARD_Release()
}
/**************************************************************************
* X11DRV_CLIPBOARD_Acquire()
* X11DRV_AcquireClipboard
*/
void X11DRV_CLIPBOARD_Acquire()
void X11DRV_AcquireClipboard(void)
{
Window owner;
HWND hWndClipWindow = GetOpenClipboardWindow();
@ -895,12 +895,12 @@ void X11DRV_CLIPBOARD_Acquire()
}
/**************************************************************************
* X11DRV_CLIPBOARD_IsFormatAvailable
* X11DRV_IsClipboardFormatAvailable
*
* Checks if the specified format is available in the current selection
* Only invoked when WINE is not the selection owner
*/
BOOL X11DRV_CLIPBOARD_IsFormatAvailable(UINT wFormat)
BOOL X11DRV_IsClipboardFormatAvailable(UINT wFormat)
{
Atom xaClipboard = TSXInternAtom(display, _CLIPBOARD, False);
Window ownerPrimary = TSXGetSelectionOwner(display,XA_PRIMARY);
@ -943,18 +943,18 @@ BOOL X11DRV_CLIPBOARD_IsFormatAvailable(UINT wFormat)
* try to convert the selection to the requested type.
*/
if ( !cSelectionTargets )
return X11DRV_CLIPBOARD_GetData( wFormat );
return X11DRV_GetClipboardData( wFormat );
return FALSE;
}
/**************************************************************************
* X11DRV_CLIPBOARD_RegisterFormat
* X11DRV_RegisterClipboardFormat
*
* Registers a custom X clipboard format
* Returns: TRUE - success, FALSE - failure
*/
BOOL X11DRV_CLIPBOARD_RegisterFormat( LPCSTR FormatName )
BOOL X11DRV_RegisterClipboardFormat( LPCSTR FormatName )
{
Atom prop = None;
char str[256];
@ -975,30 +975,30 @@ BOOL X11DRV_CLIPBOARD_RegisterFormat( LPCSTR FormatName )
}
/**************************************************************************
* X11DRV_CLIPBOARD_IsSelectionowner
* X11DRV_IsSelectionOwner
*
* Returns: TRUE - We(WINE) own the selection, FALSE - Selection not owned by us
*/
BOOL X11DRV_CLIPBOARD_IsSelectionowner()
BOOL X11DRV_IsSelectionOwner(void)
{
return selectionAcquired;
}
/**************************************************************************
* X11DRV_CLIPBOARD_SetData
* X11DRV_SetClipboardData
*
* We don't need to do anything special here since the clipboard code
* maintains the cache.
*
*/
void X11DRV_CLIPBOARD_SetData(UINT wFormat)
void X11DRV_SetClipboardData(UINT wFormat)
{
/* Make sure we have acquired the X selection */
X11DRV_CLIPBOARD_Acquire();
X11DRV_AcquireClipboard();
}
/**************************************************************************
* X11DRV_CLIPBOARD_GetData
* X11DRV_GetClipboardData
*
* This method is invoked only when we DO NOT own the X selection
*
@ -1007,7 +1007,7 @@ void X11DRV_CLIPBOARD_SetData(UINT wFormat)
* We always get the data from the selection client each time,
* since we have no way of determining if the data in our cache is stale.
*/
BOOL X11DRV_CLIPBOARD_GetData(UINT wFormat)
BOOL X11DRV_GetClipboardData(UINT wFormat)
{
BOOL bRet = selectionAcquired;
HWND hWndClipWindow = GetOpenClipboardWindow();
@ -1074,7 +1074,7 @@ BOOL X11DRV_CLIPBOARD_GetData(UINT wFormat)
}
/**************************************************************************
* X11DRV_CLIPBOARD_ResetOwner
* X11DRV_ResetSelectionOwner
*
* Called from DestroyWindow() to prevent X selection from being lost when
* a top level window is destroyed, by switching ownership to another top
@ -1082,7 +1082,7 @@ BOOL X11DRV_CLIPBOARD_GetData(UINT wFormat)
* Any top level window can own the selection. See X11DRV_CLIPBOARD_Acquire
* for a more detailed description of this.
*/
void X11DRV_CLIPBOARD_ResetOwner(WND *pWnd, BOOL bFooBar)
void X11DRV_ResetSelectionOwner(WND *pWnd, BOOL bFooBar)
{
HWND hWndClipOwner = 0;
Window XWnd = X11DRV_WND_GetXWindow(pWnd);

30
windows/x11drv/event.c
View File

@ -202,20 +202,20 @@ static void CALLBACK EVENT_ProcessAllEvents( ULONG_PTR arg )
}
/***********************************************************************
* EVENT_Synchronize
* X11DRV_Synchronize
*
* Synchronize with the X server. Should not be used too often.
*/
void X11DRV_EVENT_Synchronize( void )
void X11DRV_Synchronize( void )
{
TSXSync( display, False );
EVENT_ProcessAllEvents( 0 );
}
/***********************************************************************
* EVENT_UserRepaintDisable
* X11DRV_UserRepaintDisable
*/
void X11DRV_EVENT_UserRepaintDisable( BOOL bDisabled )
void X11DRV_UserRepaintDisable( BOOL bDisabled )
{
bUserRepaintDisabled = bDisabled;
}
@ -715,12 +715,12 @@ static void EVENT_MotionNotify( HWND hWnd, XMotionEvent *event )
int yOffset = pWnd? pWnd->rectWindow.top : 0;
WIN_ReleaseWndPtr(pWnd);
X11DRV_MOUSE_SendEvent( MOUSEEVENTF_MOVE | MOUSEEVENTF_ABSOLUTE,
X11DRV_SendEvent( MOUSEEVENTF_MOVE | MOUSEEVENTF_ABSOLUTE,
xOffset + event->x, yOffset + event->y,
X11DRV_EVENT_XStateToKeyState( event->state ),
event->time, hWnd);
} else {
X11DRV_MOUSE_SendEvent( MOUSEEVENTF_MOVE,
X11DRV_SendEvent( MOUSEEVENTF_MOVE,
event->x_root, event->y_root,
X11DRV_EVENT_XStateToKeyState( event->state ),
event->time, hWnd);
@ -774,7 +774,7 @@ static void EVENT_ButtonPress( HWND hWnd, XButtonEvent *event )
break;
}
X11DRV_MOUSE_SendEvent( statusCodes[buttonNum],
X11DRV_SendEvent( statusCodes[buttonNum],
xOffset + event->x, yOffset + event->y,
MAKEWPARAM(keystate,wData),
event->time, hWnd);
@ -822,7 +822,7 @@ static void EVENT_ButtonRelease( HWND hWnd, XButtonEvent *event )
return;
}
X11DRV_MOUSE_SendEvent( statusCodes[buttonNum],
X11DRV_SendEvent( statusCodes[buttonNum],
xOffset + event->x, yOffset + event->y,
keystate, event->time, hWnd);
}
@ -865,9 +865,9 @@ static void EVENT_FocusOut( HWND hWnd, XFocusChangeEvent *event )
}
/**********************************************************************
* X11DRV_EVENT_CheckFocus
* X11DRV_CheckFocus
*/
BOOL X11DRV_EVENT_CheckFocus(void)
BOOL X11DRV_CheckFocus(void)
{
HWND hWnd;
Window xW;
@ -1489,7 +1489,7 @@ static void EVENT_PropertyNotify( XPropertyEvent *event )
TRACE("\tPropertyDelete for atom %s on window %ld\n",
TSXGetAtomName(event->display, event->atom), (long)event->window);
if (X11DRV_CLIPBOARD_IsSelectionowner())
if (X11DRV_IsSelectionOwner())
X11DRV_CLIPBOARD_FreeResources( event->atom );
break;
}
@ -1899,7 +1899,7 @@ static void EVENT_MappingNotify( XMappingEvent *event )
TSXRefreshKeyboardMapping(event);
/* reinitialize Wine-X11 driver keyboard table */
X11DRV_KEYBOARD_Init();
X11DRV_InitKeyboard();
}
@ -1940,7 +1940,7 @@ void X11DRV_EVENT_SetDGAStatus(HWND hwnd, int event_base)
/* DGA2 event handlers */
static void EVENT_DGAMotionEvent( XDGAMotionEvent *event )
{
X11DRV_MOUSE_SendEvent( MOUSEEVENTF_MOVE,
X11DRV_SendEvent( MOUSEEVENTF_MOVE,
event->dx, event->dy,
X11DRV_EVENT_XStateToKeyState( event->state ),
event->time, DGAhwnd );
@ -1971,7 +1971,7 @@ static void EVENT_DGAButtonPressEvent( XDGAButtonEvent *event )
break;
}
X11DRV_MOUSE_SendEvent( statusCodes[buttonNum], 0, 0, keystate, event->time, DGAhwnd );
X11DRV_SendEvent( statusCodes[buttonNum], 0, 0, keystate, event->time, DGAhwnd );
}
static void EVENT_DGAButtonReleaseEvent( XDGAButtonEvent *event )
@ -1999,7 +1999,7 @@ static void EVENT_DGAButtonReleaseEvent( XDGAButtonEvent *event )
break;
}
X11DRV_MOUSE_SendEvent( statusCodes[buttonNum], 0, 0, keystate, event->time, DGAhwnd );
X11DRV_SendEvent( statusCodes[buttonNum], 0, 0, keystate, event->time, DGAhwnd );
}
#endif

45
windows/x11drv/init.c
View File

@ -1,45 +0,0 @@
/*
* X11 driver
*
* Copyright 1998 Patrik Stridvall
*/
#include "clipboard.h"
#include "user.h"
#include "win.h"
#include "x11drv.h"
CLIPBOARD_DRIVER X11DRV_CLIPBOARD_Driver =
{
X11DRV_CLIPBOARD_Acquire,
X11DRV_CLIPBOARD_Release,
X11DRV_CLIPBOARD_SetData,
X11DRV_CLIPBOARD_GetData,
X11DRV_CLIPBOARD_IsFormatAvailable,
X11DRV_CLIPBOARD_RegisterFormat,
X11DRV_CLIPBOARD_IsSelectionowner,
X11DRV_CLIPBOARD_ResetOwner
};
WND_DRIVER X11DRV_WND_Driver =
{
X11DRV_WND_Initialize,
X11DRV_WND_Finalize,
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,
X11DRV_WND_SurfaceCopy,
X11DRV_WND_SetDrawable,
X11DRV_WND_SetHostAttr,
X11DRV_WND_IsSelfClipping,
X11DRV_WND_SetWindowRgn
};

56
windows/x11drv/keyboard.c
View File

@ -718,7 +718,7 @@ void X11DRV_KEYBOARD_HandleEvent( WND *pWnd, XKeyEvent *event )
/**********************************************************************
* X11DRV_KEYBOARD_DetectLayout
*
* Called from X11DRV_KEYBOARD_Init
* Called from X11DRV_InitKeyboard
* This routine walks through the defined keyboard layouts and selects
* whichever matches most closely.
*/
@ -816,9 +816,9 @@ X11DRV_KEYBOARD_DetectLayout (void)
}
/**********************************************************************
* X11DRV_KEYBOARD_Init
* X11DRV_InitKeyboard
*/
void X11DRV_KEYBOARD_Init(void)
void X11DRV_InitKeyboard(void)
{
KeySym *ksp;
XModifierKeymap *mmp;
@ -1029,9 +1029,9 @@ void X11DRV_KEYBOARD_Init(void)
}
/***********************************************************************
* X11DRV_KEYBOARD_VkKeyScan
* X11DRV_VkKeyScan
*/
WORD X11DRV_KEYBOARD_VkKeyScan(CHAR cChar)
WORD X11DRV_VkKeyScan(CHAR cChar)
{
KeyCode keycode;
KeySym keysym;
@ -1077,9 +1077,9 @@ WORD X11DRV_KEYBOARD_VkKeyScan(CHAR cChar)
}
/***********************************************************************
* X11DRV_KEYBOARD_MapVirtualKey
* X11DRV_MapVirtualKey
*/
UINT16 X11DRV_KEYBOARD_MapVirtualKey(UINT16 wCode, UINT16 wMapType)
UINT16 X11DRV_MapVirtualKey(UINT16 wCode, UINT16 wMapType)
{
#define returnMVK(value) { TRACE("returning 0x%x.\n",value); return value; }
@ -1161,9 +1161,9 @@ UINT16 X11DRV_KEYBOARD_MapVirtualKey(UINT16 wCode, UINT16 wMapType)
}
/***********************************************************************
* X11DRV_KEYBOARD_GetKeyNameText
* X11DRV_GetKeyNameText
*/
INT16 X11DRV_KEYBOARD_GetKeyNameText(LONG lParam, LPSTR lpBuffer, INT16 nSize)
INT16 X11DRV_GetKeyNameText(LONG lParam, LPSTR lpBuffer, INT16 nSize)
{
int vkey, ansi, scanCode;
KeyCode keyc;
@ -1174,7 +1174,7 @@ INT16 X11DRV_KEYBOARD_GetKeyNameText(LONG lParam, LPSTR lpBuffer, INT16 nSize)
scanCode &= 0x1ff; /* keep "extended-key" flag with code */
/* FIXME: should use MVK type 3 (NT version that distinguishes right and left */
vkey = X11DRV_KEYBOARD_MapVirtualKey(scanCode, 1);
vkey = X11DRV_MapVirtualKey(scanCode, 1);
/* handle "don't care" bit (0x02000000) */
if (!(lParam & 0x02000000)) {
@ -1196,7 +1196,7 @@ INT16 X11DRV_KEYBOARD_GetKeyNameText(LONG lParam, LPSTR lpBuffer, INT16 nSize)
}
}
ansi = X11DRV_KEYBOARD_MapVirtualKey(vkey, 2);
ansi = X11DRV_MapVirtualKey(vkey, 2);
TRACE("scan 0x%04x, vkey 0x%04x, ANSI 0x%04x\n", scanCode, vkey, ansi);
/* first get the name of the "regular" keys which is the Upper case
@ -1333,7 +1333,7 @@ static char KEYBOARD_MapDeadKeysym(KeySym keysym)
}
/***********************************************************************
* X11DRV_KEYBOARD_ToAscii
* X11DRV_ToAscii
*
* The ToAscii function translates the specified virtual-key code and keyboard
* state to the corresponding Windows character or characters.
@ -1350,7 +1350,7 @@ static char KEYBOARD_MapDeadKeysym(KeySym keysym)
* FIXME : should do the above (return 2 for non matching deadchar+char combinations)
*
*/
INT16 X11DRV_KEYBOARD_ToAscii(
INT16 X11DRV_ToAscii(
UINT16 virtKey,UINT16 scanCode, LPBYTE lpKeyState,
LPVOID lpChar, UINT16 flags)
{
@ -1469,9 +1469,9 @@ INT16 X11DRV_KEYBOARD_ToAscii(
}
/***********************************************************************
* X11DRV_KEYBOARD_GetBeepActive
* X11DRV_GetBeepActive
*/
BOOL X11DRV_KEYBOARD_GetBeepActive()
BOOL X11DRV_GetBeepActive()
{
XKeyboardState keyboard_state;
@ -1481,9 +1481,9 @@ BOOL X11DRV_KEYBOARD_GetBeepActive()
}
/***********************************************************************
* X11DRV_KEYBOARD_SetBeepActive
* X11DRV_SetBeepActive
*/
void X11DRV_KEYBOARD_SetBeepActive(BOOL bActivate)
void X11DRV_SetBeepActive(BOOL bActivate)
{
XKeyboardControl keyboard_value;
@ -1496,17 +1496,17 @@ void X11DRV_KEYBOARD_SetBeepActive(BOOL bActivate)
}
/***********************************************************************
* X11DRV_KEYBOARD_Beep
* X11DRV_Beep
*/
void X11DRV_KEYBOARD_Beep()
void X11DRV_Beep()
{
TSXBell(display, 0);
}
/***********************************************************************
* X11DRV_KEYBOARD_GetDIState
* X11DRV_GetDIState
*/
BOOL X11DRV_KEYBOARD_GetDIState(DWORD len, LPVOID ptr)
BOOL X11DRV_GetDIState(DWORD len, LPVOID ptr)
{
if (len==256) {
int keyc,vkey;
@ -1524,14 +1524,14 @@ BOOL X11DRV_KEYBOARD_GetDIState(DWORD len, LPVOID ptr)
}
return TRUE;
}
WARN("whoops, X11DRV_KEYBOARD_GetState got len %ld?\n", len);
WARN("whoops, got len %ld?\n", len);
return TRUE;
}
/***********************************************************************
* X11DRV_KEYBOARD_GetDIData
* X11DRV_GetDIData
*/
BOOL X11DRV_KEYBOARD_GetDIData(
BOOL X11DRV_GetDIData(
BYTE *keystate,
DWORD dodsize, LPDIDEVICEOBJECTDATA dod,
LPDWORD entries, DWORD flags)
@ -1573,9 +1573,9 @@ BOOL X11DRV_KEYBOARD_GetDIData(
}
/***********************************************************************
* X11DRV_KEYBOARD_GetKeyboardConfig
* X11DRV_GetKeyboardConfig
*/
void X11DRV_KEYBOARD_GetKeyboardConfig(KEYBOARD_CONFIG *cfg) {
void X11DRV_GetKeyboardConfig(KEYBOARD_CONFIG *cfg) {
XKeyboardState xks;
/* For the moment, only get the auto-repeat mode */
@ -1584,9 +1584,9 @@ void X11DRV_KEYBOARD_GetKeyboardConfig(KEYBOARD_CONFIG *cfg) {
}
/***********************************************************************
* X11DRV_KEYBOARD_SetKeyboardConfig
* X11DRV_SetKeyboardConfig
*/
extern void X11DRV_KEYBOARD_SetKeyboardConfig(KEYBOARD_CONFIG *cfg, DWORD mask) {
extern void X11DRV_SetKeyboardConfig(KEYBOARD_CONFIG *cfg, DWORD mask) {
XKeyboardControl xkc;
unsigned long X_mask = 0;

18
windows/x11drv/mouse.c
View File

@ -161,9 +161,9 @@ static BOOL X11DRV_MOUSE_DoSetCursor( CURSORICONINFO *ptr )
}
/***********************************************************************
* X11DRV_MOUSE_SetCursor
* X11DRV_SetCursor
*/
void X11DRV_MOUSE_SetCursor( CURSORICONINFO *lpCursor )
void X11DRV_SetCursor( CURSORICONINFO *lpCursor )
{
BOOL success;
@ -199,9 +199,9 @@ void X11DRV_MOUSE_SetCursor( CURSORICONINFO *lpCursor )
}
/***********************************************************************
* X11DRV_MOUSE_MoveCursor
* X11DRV_MoveCursor
*/
void X11DRV_MOUSE_MoveCursor(WORD wAbsX, WORD wAbsY)
void X11DRV_MoveCursor(WORD wAbsX, WORD wAbsY)
{
/*
* We do not want the to create MotionNotify events here,
@ -241,9 +241,9 @@ void X11DRV_MOUSE_MoveCursor(WORD wAbsX, WORD wAbsY)
}
/***********************************************************************
* X11DRV_MOUSE_Init
* X11DRV_InitMouse
*/
void X11DRV_MOUSE_Init( LPMOUSE_EVENT_PROC proc )
void X11DRV_InitMouse( LPMOUSE_EVENT_PROC proc )
{
static int init_done;
@ -260,7 +260,7 @@ void X11DRV_MOUSE_Init( LPMOUSE_EVENT_PROC proc )
movement to initialize the mouse global variables */
TSXQueryPointer( display, X11DRV_GetXRootWindow(), &root, &child,
&root_x, &root_y, &child_x, &child_y, &KeyState);
X11DRV_MOUSE_SendEvent(MOUSEEVENTF_MOVE | MOUSEEVENTF_ABSOLUTE,
X11DRV_SendEvent(MOUSEEVENTF_MOVE | MOUSEEVENTF_ABSOLUTE,
root_x, root_y, X11DRV_EVENT_XStateToKeyState(KeyState),
GetTickCount(), 0 );
}
@ -268,9 +268,9 @@ void X11DRV_MOUSE_Init( LPMOUSE_EVENT_PROC proc )
/***********************************************************************
* X11DRV_MOUSE_SendEvent
* X11DRV_SendEvent
*/
void X11DRV_MOUSE_SendEvent( DWORD mouseStatus, DWORD posX, DWORD posY,
void X11DRV_SendEvent( DWORD mouseStatus, DWORD posX, DWORD posY,
DWORD keyState, DWORD time, HWND hWnd )
{
int width = GetSystemMetrics( SM_CXSCREEN );

22
windows/x11drv/wnd.c
View File

@ -46,6 +46,28 @@ extern Pixmap X11DRV_BITMAP_Pixmap( HBITMAP );
/**********************************************************************/
WND_DRIVER X11DRV_WND_Driver =
{
X11DRV_WND_Initialize,
X11DRV_WND_Finalize,
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,
X11DRV_WND_SurfaceCopy,
X11DRV_WND_SetDrawable,
X11DRV_WND_SetHostAttr,
X11DRV_WND_IsSelfClipping,
X11DRV_WND_SetWindowRgn
};
/* X context to associate a hwnd to an X window */
XContext winContext = 0;