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

Added stubs for WINTAB{,32}.DLL (used by many important drawing 

applications for supporting tablets).
This commit is contained in:
Patrik Stridvall 2002-12-17 01:49:16 +00:00 committed by Alexandre Julliard
parent a80e051a71
commit 5caddc7863
14 changed files with 2446 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
configure vendored
View File

File diff suppressed because one or more lines are too long

1
configure.ac
View File

@ -1466,6 +1466,7 @@ dlls/winnls/Makefile
dlls/winsock/Makefile
dlls/winsock/tests/Makefile
dlls/winspool/Makefile
dlls/wintab32/Makefile
dlls/wintrust/Makefile
dlls/wow32/Makefile
dlls/wsock32/Makefile

15
dlls/Makefile.in
View File

@ -105,6 +105,7 @@ BASEDIRS = \
winnls \
winsock \
winspool \
wintab32 \
wintrust \
wow32 \
wsock32
@ -171,6 +172,7 @@ WIN16_FILES = \
wing.dll$(DLLEXT) \
winnls.dll$(DLLEXT) \
winsock.dll$(DLLEXT) \
wintab.dll$(DLLEXT) \
wprocs.dll$(DLLEXT)
all: \
@ -264,6 +266,7 @@ all: \
winmm.dll$(DLLEXT) \
winnls32.dll$(DLLEXT) \
winspool.drv$(DLLEXT) \
wintab32.dll$(DLLEXT) \
wintrust.dll$(DLLEXT) \
wnaspi32.dll$(DLLEXT) \
wow32.dll$(DLLEXT) \
@ -557,6 +560,9 @@ winnls32.dll$(DLLEXT) winnls.dll$(DLLEXT): winnls/winnls32.dll$(DLLEXT)
winspool.drv$(DLLEXT): winspool/winspool.drv$(DLLEXT)
$(RM) $@ && $(LN_S) winspool/winspool.drv$(DLLEXT) $@
wintab32.dll$(DLLEXT) wintab.dll$(DLLEXT): wintab32/wintab32.dll$(DLLEXT)
$(RM) $@ && $(LN_S) wintab32/wintab32.dll$(DLLEXT) $@
wintrust.dll$(DLLEXT): wintrust/wintrust.dll$(DLLEXT)
$(RM) $@ && $(LN_S) wintrust/wintrust.dll$(DLLEXT) $@
@ -653,6 +659,7 @@ IMPORT_LIBS = \
libwinmm \
libwinnls32 \
libwinspool \
libwintab32 \
libwintrust \
libwnaspi32 \
libwow32 \
@ -1030,6 +1037,11 @@ libwinspool.def: winspool/winspool.drv.spec.def
libwinspool.a: winspool/winspool.drv.spec.def
$(DLLTOOL) -k -l $@ -d winspool/winspool.drv.spec.def
libwintab32.def: wintab32/wintab32.spec.def
$(RM) $@ && $(LN_S) wintab32/wintab32.spec.def $@
libwintab32.a: wintab32/wintab32.spec.def
$(DLLTOOL) -k -l $@ -d wintab32/wintab32.spec.def
libwintrust.def: wintrust/wintrust.spec.def
$(RM) $@ && $(LN_S) wintrust/wintrust.spec.def $@
libwintrust.a: wintrust/wintrust.spec.def
@ -1134,6 +1146,7 @@ wininet/wininet.spec.def: $(WINEBUILD)
winmm/winmm.spec.def: $(WINEBUILD)
winnls/winnls32.spec.def: $(WINEBUILD)
winspool/winspool.drv.spec.def: $(WINEBUILD)
wintab32/wintab32.spec.def: $(WINEBUILD)
wintrust/wintrust.spec.def: $(WINEBUILD)
winaspi/wnaspi32.spec.def: $(WINEBUILD)
wow32/wow32.spec.def: $(WINEBUILD)
@ -1239,6 +1252,7 @@ wininet/wininet.dll$(DLLEXT): wininet
winmm/winmm.dll$(DLLEXT): winmm
winnls/winnls32.dll$(DLLEXT): winnls
winspool/winspool.drv$(DLLEXT): winspool
wintab32/wintab32.dll$(DLLEXT): wintab32
wintrust/wintrust.dll$(DLLEXT): wintrust
winaspi/wnaspi32.dll$(DLLEXT): winaspi
wow32/wow32.dll$(DLLEXT): wow32
@ -1341,6 +1355,7 @@ wininet/__install__: wininet.dll$(DLLEXT)
winmm/__install__: winmm.dll$(DLLEXT)
winnls/__install__: winnls32.dll$(DLLEXT)
winspool/__install__: winspool.drv$(DLLEXT)
wintab32/__install__: wintab32.dll$(DLLEXT)
wintrust/__install__: wintrust.dll$(DLLEXT)
winaspi/__install__: wnaspi32.dll$(DLLEXT)
wow32/__install__: wow32.dll$(DLLEXT)

5
dlls/wintab32/.cvsignore Normal file
View File

@ -0,0 +1,5 @@
Makefile
wintab.spec.c
wintab32.dll.dbg.c
wintab32.spec.c
wintab32.spec.def

21
dlls/wintab32/Makefile.in Normal file
View File

@ -0,0 +1,21 @@
TOPSRCDIR = @top_srcdir@
TOPOBJDIR = ../..
SRCDIR = @srcdir@
VPATH = @srcdir@
MODULE = wintab32.dll
IMPORTS = kernel32
ALTNAMES = wintab.dll
LDDLLFLAGS = @LDDLLFLAGS@
SYMBOLFILE = $(MODULE).tmp.o
C_SRCS = \
context.c \
manager.c
C_SRCS16 = \
wintab16.c
@MAKE_DLL_RULES@
### Dependencies:

323
dlls/wintab32/context.c Normal file
View File

@ -0,0 +1,323 @@
/*
* Tablet Context
*
* Copyright 2002 Patrik Stridvall
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include "config.h"
#include "windef.h"
#include "winbase.h"
#include "winerror.h"
#include "wintab.h"
#include "wine/debug.h"
WINE_DEFAULT_DEBUG_CHANNEL(wintab32);
/***********************************************************************
* WTInfoA (WINTAB32.20)
*/
UINT WINAPI WTInfoA(UINT wCategory, UINT nIndex, LPVOID lpOutput)
{
FIXME("(%u, %u, %p): stub\n", wCategory, nIndex, lpOutput);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return 0;
}
/***********************************************************************
* WTInfoW (WINTAB32.1020)
*/
UINT WINAPI WTInfoW(UINT wCategory, UINT nIndex, LPVOID lpOutput)
{
FIXME("(%u, %u, %p): stub\n", wCategory, nIndex, lpOutput);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return 0;
}
/***********************************************************************
* WTOpenA (WINTAB32.21)
*/
HCTX WINAPI WTOpenA(HWND hWnd, LPLOGCONTEXTA lpLogCtx, BOOL fEnable)
{
FIXME("(%p, %p, %u): stub\n", hWnd, lpLogCtx, fEnable);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return NULL;
}
/***********************************************************************
* WTOpenW (WINTAB32.1021)
*/
HCTX WINAPI WTOpenW(HWND hWnd, LPLOGCONTEXTW lpLogCtx, BOOL fEnable)
{
FIXME("(%p, %p, %u): stub\n", hWnd, lpLogCtx, fEnable);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return NULL;
}
/***********************************************************************
* WTClose (WINTAB32.22)
*/
BOOL WINAPI WTClose(HCTX hCtx)
{
FIXME("(%p): stub\n", hCtx);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return TRUE;
}
/***********************************************************************
* WTPacketsGet (WINTAB32.23)
*/
int WINAPI WTPacketsGet(HCTX hCtx, int cMaxPkts, LPVOID lpPkts)
{
FIXME("(%p, %d, %p): stub\n", hCtx, cMaxPkts, lpPkts);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return 0;
}
/***********************************************************************
* WTPacket (WINTAB32.24)
*/
BOOL WINAPI WTPacket(HCTX hCtx, UINT wSerial, LPVOID lpPkt)
{
FIXME("(%p, %d, %p): stub\n", hCtx, wSerial, lpPkt);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
/***********************************************************************
* WTEnable (WINTAB32.40)
*/
BOOL WINAPI WTEnable(HCTX hCtx, BOOL fEnable)
{
FIXME("(%p, %u): stub\n", hCtx, fEnable);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
/***********************************************************************
* WTOverlap (WINTAB32.41)
*/
BOOL WINAPI WTOverlap(HCTX hCtx, BOOL fToTop)
{
FIXME("(%p, %u): stub\n", hCtx, fToTop);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
/***********************************************************************
* WTConfig (WINTAB32.61)
*/
BOOL WINAPI WTConfig(HCTX hCtx, HWND hWnd)
{
FIXME("(%p, %p): stub\n", hCtx, hWnd);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
/***********************************************************************
* WTGetA (WINTAB32.61)
*/
BOOL WINAPI WTGetA(HCTX hCtx, LPLOGCONTEXTA lpLogCtx)
{
FIXME("(%p, %p): stub\n", hCtx, lpLogCtx);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
/***********************************************************************
* WTGetW (WINTAB32.1061)
*/
BOOL WINAPI WTGetW(HCTX hCtx, LPLOGCONTEXTW lpLogCtx)
{
FIXME("(%p, %p): stub\n", hCtx, lpLogCtx);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
/***********************************************************************
* WTSetA (WINTAB32.62)
*/
BOOL WINAPI WTSetA(HCTX hCtx, LPLOGCONTEXTA lpLogCtx)
{
FIXME("(%p, %p): stub\n", hCtx, lpLogCtx);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
/***********************************************************************
* WTSetW (WINTAB32.1062)
*/
BOOL WINAPI WTSetW(HCTX hCtx, LPLOGCONTEXTW lpLogCtx)
{
FIXME("(%p, %p): stub\n", hCtx, lpLogCtx);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
/***********************************************************************
* WTExtGet (WINTAB32.63)
*/
BOOL WINAPI WTExtGet(HCTX hCtx, UINT wExt, LPVOID lpData)
{
FIXME("(%p, %u, %p): stub\n", hCtx, wExt, lpData);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
/***********************************************************************
* WTExtSet (WINTAB32.64)
*/
BOOL WINAPI WTExtSet(HCTX hCtx, UINT wExt, LPVOID lpData)
{
FIXME("(%p, %u, %p): stub\n", hCtx, wExt, lpData);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
/***********************************************************************
* WTSave (WINTAB32.65)
*/
BOOL WINAPI WTSave(HCTX hCtx, LPVOID lpSaveInfo)
{
FIXME("(%p, %p): stub\n", hCtx, lpSaveInfo);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
/***********************************************************************
* WTRestore (WINTAB32.66)
*/
HCTX WINAPI WTRestore(HWND hWnd, LPVOID lpSaveInfo, BOOL fEnable)
{
FIXME("(%p, %p, %u): stub\n", hWnd, lpSaveInfo, fEnable);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return 0;
}
/***********************************************************************
* WTPacketsPeek (WINTAB32.80)
*/
int WINAPI WTPacketsPeek(HCTX hCtx, int cMaxPkts, LPVOID lpPkts)
{
FIXME("(%p, %d, %p): stub\n", hCtx, cMaxPkts, lpPkts);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return 0;
}
/***********************************************************************
* WTDataGet (WINTAB32.81)
*/
int WINAPI WTDataGet(HCTX hCtx, UINT wBegin, UINT wEnd,
int cMaxPkts, LPVOID lpPkts, LPINT lpNPkts)
{
FIXME("(%p, %u, %u, %d, %p, %p): stub\n",
hCtx, wBegin, wEnd, cMaxPkts, lpPkts, lpNPkts);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return 0;
}
/***********************************************************************
* WTDataPeek (WINTAB32.82)
*/
int WINAPI WTDataPeek(HCTX hCtx, UINT wBegin, UINT wEnd,
int cMaxPkts, LPVOID lpPkts, LPINT lpNPkts)
{
FIXME("(%p, %u, %u, %d, %p, %p): stub\n",
hCtx, wBegin, wEnd, cMaxPkts, lpPkts, lpNPkts);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return 0;
}
/***********************************************************************
* WTQueuePacketsEx (WINTAB32.200)
*/
BOOL WINAPI WTQueuePacketsEx(HCTX hCtx, UINT *lpOld, UINT *lpNew)
{
FIXME("(%p, %p, %p): stub\n", hCtx, lpOld, lpNew);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return TRUE;
}
/***********************************************************************
* WTQueueSizeGet (WINTAB32.84)
*/
int WINAPI WTQueueSizeGet(HCTX hCtx)
{
FIXME("(%p): stub\n", hCtx);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return 0;
}
/***********************************************************************
* WTQueueSizeSet (WINTAB32.85)
*/
BOOL WINAPI WTQueueSizeSet(HCTX hCtx, int nPkts)
{
FIXME("(%p, %d): stub\n", hCtx, nPkts);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return 0;
}

289
dlls/wintab32/manager.c Normal file
View File

@ -0,0 +1,289 @@
/*
* Tablet Manager
*
* Copyright 2002 Patrik Stridvall
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include "config.h"
#include "windef.h"
#include "winbase.h"
#include "winerror.h"
#include "wintab.h"
#include "wine/debug.h"
WINE_DEFAULT_DEBUG_CHANNEL(wintab32);
/***********************************************************************
* WTMgrOpen (WINTAB32.100)
*/
HMGR WINAPI WTMgrOpen(HWND hWnd, UINT wMsgBase)
{
FIXME("(%p, %u): stub\n", hWnd, wMsgBase);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return NULL;
}
/***********************************************************************
* WTMgrClose (WINTAB32.101)
*/
BOOL WINAPI WTMgrClose(HMGR hMgr)
{
FIXME("(%p): stub\n", hMgr);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
/***********************************************************************
* WTMgrContextEnum (WINTAB32.120)
*/
BOOL WINAPI WTMgrContextEnum(HMGR hMgr, WTENUMPROC lpEnumFunc, LPARAM lParam)
{
FIXME("(%p, %p, %ld): stub\n", hMgr, lpEnumFunc, lParam);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
/***********************************************************************
* WTMgrContextOwner (WINTAB32.121)
*/
HWND WINAPI WTMgrContextOwner(HMGR hMgr, HCTX hCtx)
{
FIXME("(%p, %p): stub\n", hMgr, hCtx);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return NULL;
}
/***********************************************************************
* WTMgrDefContext (WINTAB32.122)
*/
HCTX WINAPI WTMgrDefContext(HMGR hMgr, BOOL fSystem)
{
FIXME("(%p, %u): stub\n", hMgr, fSystem);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return NULL;
}
/***********************************************************************
* WTMgrDefContextEx (WINTAB32.206)
*
* 1.1
*/
HCTX WINAPI WTMgrDefContextEx(HMGR hMgr, UINT wDevice, BOOL fSystem)
{
FIXME("(%p, %hu, %hu): stub\n", hMgr, wDevice, fSystem);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return NULL;
}
/***********************************************************************
* WTMgrDeviceConfig (WINTAB32.140)
*/
UINT WINAPI WTMgrDeviceConfig(HMGR hMgr, UINT wDevice, HWND hWnd)
{
FIXME("(%p, %u, %p): stub\n", hMgr, wDevice, hWnd);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return 0;
}
/***********************************************************************
* WTMgrConfigReplaceExA (WINTAB32.202)
*/
BOOL WINAPI WTMgrConfigReplaceExA(HMGR hMgr, BOOL fInstall,
LPSTR lpszModule, LPSTR lpszCfgProc)
{
FIXME("(%p, %u, %s, %s): stub\n", hMgr, fInstall,
debugstr_a(lpszModule), debugstr_a(lpszCfgProc));
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
/***********************************************************************
* WTMgrConfigReplaceExW (WINTAB32.1202)
*/
BOOL WINAPI WTMgrConfigReplaceExW(HMGR hMgr, BOOL fInstall,
LPWSTR lpszModule, LPSTR lpszCfgProc)
{
FIXME("(%p, %u, %s, %s): stub\n", hMgr, fInstall,
debugstr_w(lpszModule), debugstr_a(lpszCfgProc));
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
/***********************************************************************
* WTMgrPacketHookExA (WINTAB32.203)
*/
HWTHOOK WINAPI WTMgrPacketHookExA(HMGR hMgr, int nType,
LPSTR lpszModule, LPSTR lpszHookProc)
{
FIXME("(%p, %d, %s, %s): stub\n", hMgr, nType,
debugstr_a(lpszModule), debugstr_a(lpszHookProc));
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return NULL;
}
/***********************************************************************
* WTMgrPacketHookExW (WINTAB32.1203)
*/
HWTHOOK WINAPI WTMgrPacketHookExW(HMGR hMgr, int nType,
LPWSTR lpszModule, LPSTR lpszHookProc)
{
FIXME("(%p, %d, %s, %s): stub\n", hMgr, nType,
debugstr_w(lpszModule), debugstr_a(lpszHookProc));
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return NULL;
}
/***********************************************************************
* WTMgrPacketUnhook (WINTAB32.204)
*/
BOOL WINAPI WTMgrPacketUnhook(HWTHOOK hHook)
{
FIXME("(%p): stub\n", hHook);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
/***********************************************************************
* WTMgrPacketHookNext (WINTAB32.205)
*/
LRESULT WINAPI WTMgrPacketHookNext(HWTHOOK hHook, int nCode,
WPARAM wParam, LPARAM lParam)
{
FIXME("(%p, %d, %u, %lu): stub\n", hHook, nCode, wParam, lParam);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return 0;
}
/***********************************************************************
* WTMgrExt (WINTAB32.180)
*/
BOOL WINAPI WTMgrExt(HMGR hMgr, UINT wExt, LPVOID lpData)
{
FIXME("(%p, %u, %p): stub\n", hMgr, wExt, lpData);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
/***********************************************************************
* WTMgrCsrEnable (WINTAB32.181)
*/
BOOL WINAPI WTMgrCsrEnable(HMGR hMgr, UINT wCursor, BOOL fEnable)
{
FIXME("(%p, %u, %u): stub\n", hMgr, wCursor, fEnable);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
/***********************************************************************
* WTMgrCsrButtonMap (WINTAB32.182)
*/
BOOL WINAPI WTMgrCsrButtonMap(HMGR hMgr, UINT wCursor,
LPBYTE lpLogBtns, LPBYTE lpSysBtns)
{
FIXME("(%p, %u, %p, %p): stub\n", hMgr, wCursor, lpLogBtns, lpSysBtns);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
/***********************************************************************
* WTMgrCsrPressureBtnMarks (WINTAB32.183)
*
* OBSOLETE IN WIN32! (But only according to documentation)
*/
BOOL WINAPI WTMgrCsrPressureBtnMarks(HMGR hMgr, UINT wCsr,
DWORD dwNMarks, DWORD dwTMarks)
{
FIXME("(%p, %u, %lu, %lu): stub\n", hMgr, wCsr, dwNMarks, dwTMarks);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
/***********************************************************************
* WTMgrCsrPressureBtnMarksEx (WINTAB32.201)
*/
BOOL WINAPI WTMgrCsrPressureBtnMarksEx(HMGR hMgr, UINT wCsr,
UINT *lpNMarks, UINT *lpTMarks)
{
FIXME("(%p, %u, %p, %p): stub\n", hMgr, wCsr, lpNMarks, lpTMarks);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
/***********************************************************************
* WTMgrCsrPressureResponse (WINTAB32.184)
*/
BOOL WINAPI WTMgrCsrPressureResponse(HMGR hMgr, UINT wCsr,
UINT *lpNResp, UINT *lpTResp)
{
FIXME("(%p, %u, %p, %p): stub\n", hMgr, wCsr, lpNResp, lpTResp);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
/***********************************************************************
* WTMgrCsrExt (WINTAB32.185)
*/
BOOL WINAPI WTMgrCsrExt(HMGR hMgr, UINT wCsr, UINT wExt, LPVOID lpData)
{
FIXME("(%p, %u, %u, %p): stub\n", hMgr, wCsr, wExt, lpData);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}

42
dlls/wintab32/wintab.spec Normal file
View File

@ -0,0 +1,42 @@
20 pascal16 WTInfo(word word ptr) WTInfo16
21 pascal16 WTOpen(word ptr word) WTOpen16
22 pascal16 WTClose(word) WTClose16
23 pascal16 WTPacketsGet(word s_word ptr) WTPacketsGet16
24 pascal16 WTPacket(word word ptr) WTPacket16
40 pascal16 WTEnable(word word) WTEnable16
41 pascal16 WTOverlap(word word) WTOverlap16
60 pascal16 WTConfig(word word) WTConfig16
61 pascal16 WTGet(word ptr) WTGet16
62 pascal16 WTSet(word ptr) WTSet16
63 pascal16 WTExtGet(word word ptr) WTExtGet16
64 pascal16 WTExtSet(word word ptr) WTExtSet16
65 pascal16 WTSave(word ptr) WTSave16
66 pascal16 WTRestore(word ptr word) WTRestore16
80 pascal16 WTPacketsPeek(word s_word ptr) WTPacketsPeek16
81 pascal16 WTDataGet(word word word s_word ptr ptr) WTDataGet16
82 pascal16 WTDataPeek(word word word s_word ptr ptr) WTDataPeek16
83 pascal WTQueuePackets(word) WTQueuePackets16
84 pascal16 WTQueueSizeGet(word) WTQueueSizeGet16
85 pascal16 WTQueueSizeSet(word s_word) WTQueueSizeSet16
100 pascal16 WTMgrOpen(word word) WTMgrOpen16
101 pascal16 WTMgrClose(word) WTMgrClose16
120 pascal16 WTMgrContextEnum(word ptr long) WTMgrContextEnum16
121 pascal16 WTMgrContextOwner(word word) WTMgrContextOwner16
122 pascal16 WTMgrDefContext(word word) WTMgrDefContext16
140 pascal16 WTMgrDeviceConfig(word word word) WTMgrDeviceConfig16
141 pascal16 WTMgrConfigReplace(word word ptr) WTMgrConfigReplace16
160 pascal WTMgrPacketHook(word word s_word ptr) WTMgrPacketHook16
161 pascal WTMgrPacketHookDefProc(s_word word long ptr) WTMgrPacketHookDefProc16
180 pascal16 WTMgrExt(word word ptr) WTMgrExt16
181 pascal16 WTMgrCsrEnable(word word word) WTMgrCsrEnable16
182 pascal16 WTMgrCsrButtonMap(word word ptr ptr) WTMgrCsrButtonMap16
183 pascal16 WTMgrCsrPressureBtnMarks(word word long long) WTMgrCsrPressureBtnMarks16
184 pascal16 WTMgrCsrPressureResponse(word word ptr ptr) WTMgrCsrPressureResponse16
185 pascal16 WTMgrCsrExt(word word word ptr) WTMgrCsrExt16
200 pascal16 WTQueuePacketsEx(word ptr ptr) WTQueuePacketsEx16
201 pascal16 WTMgrCsrPressureBtnMarksEx(word word ptr ptr) WTMgrCsrPressureBtnMarksEx16
202 pascal16 WTMgrConfigReplaceEx(word word str str) WTMgrConfigReplaceEx16
203 pascal16 WTMgrPacketHookEx(word s_word str str) WTMgrPacketHookEx16
204 pascal16 WTMgrPacketUnhook(word) WTMgrPacketUnhook16
205 pascal16 WTMgrPacketHookNext(word s_word word long) WTMgrPacketHookNext16
206 pascal16 WTMgrDefContextEx(word word word) WTMgrDefContextEx16

537
dlls/wintab32/wintab16.c Normal file
View File

@ -0,0 +1,537 @@
/*
* Tablet Win16
*
* Copyright 2002 Patrik Stridvall
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include "config.h"
#include "windef.h"
#include "wintab.h"
#include "wine/windef16.h"
#include "wine/debug.h"
WINE_DEFAULT_DEBUG_CHANNEL(wintab);
/**********************************************************************/
#define DECLARE_HANDLE16(a) \
typedef HANDLE16 a##16; \
typedef a##16 *P##a##16; \
typedef a##16 *NP##a##16; \
typedef a##16 *LP##a##16
DECLARE_HANDLE16(HMGR); /* manager handle */
DECLARE_HANDLE16(HCTX); /* context handle */
DECLARE_HANDLE16(HWTHOOK); /* hook handle */
/**********************************************************************/
typedef struct tagLOGCONTEXT16 {
char lcName[LCNAMELEN];
UINT16 lcOptions;
UINT16 lcStatus;
UINT16 lcLocks;
UINT16 lcMsgBase;
UINT16 lcDevice;
UINT16 lcPktRate;
WTPKT lcPktData;
WTPKT lcPktMode;
WTPKT lcMoveMask;
DWORD lcBtnDnMask;
DWORD lcBtnUpMask;
LONG lcInOrgX;
LONG lcInOrgY;
LONG lcInOrgZ;
LONG lcInExtX;
LONG lcInExtY;
LONG lcInExtZ;
LONG lcOutOrgX;
LONG lcOutOrgY;
LONG lcOutOrgZ;
LONG lcOutExtX;
LONG lcOutExtY;
LONG lcOutExtZ;
FIX32 lcSensX;
FIX32 lcSensY;
FIX32 lcSensZ;
BOOL16 lcSysMode;
INT16 lcSysOrgX;
INT16 lcSysOrgY;
INT16 lcSysExtX;
INT16 lcSysExtY;
FIX32 lcSysSensX;
FIX32 lcSysSensY;
} LOGCONTEXT16, *PLOGCONTEXT16, *NPLOGCONTEXT16, *LPLOGCONTEXT16;
/**********************************************************************/
typedef BOOL16 (WINAPI * WTENUMPROC16)(HCTX16, LPARAM); /* changed CALLBACK->WINAPI, 1.1 */
typedef BOOL16 (WINAPI * WTCONFIGPROC16)(HCTX16, HWND16);
typedef LRESULT (WINAPI * WTHOOKPROC16)(INT16, WPARAM16, LPARAM);
typedef WTHOOKPROC16 *LPWTHOOKPROC16;
/***********************************************************************
* WTInfo (WINTAB.20)
*/
UINT16 WINAPI WTInfo16(UINT16 wCategory, UINT16 nIndex, LPVOID lpOutput)
{
FIXME("(%hu, %hu, %p): stub\n", wCategory, nIndex, lpOutput);
return 0;
}
/***********************************************************************
* WTOpen (WINTAB.21)
*/
HCTX16 WINAPI WTOpen16(HWND16 hWnd, LPLOGCONTEXT16 lpLogCtx, BOOL16 fEnable)
{
FIXME("(0x%04hx, %p, %hu): stub\n", hWnd, lpLogCtx, fEnable);
return 0;
}
/***********************************************************************
* WTClose (WINTAB.22)
*/
BOOL16 WINAPI WTClose16(HCTX16 hCtx)
{
FIXME("(0x%04hx): stub\n", hCtx);
return TRUE;
}
/***********************************************************************
* WTPacketsGet (WINTAB.23)
*/
INT16 WINAPI WTPacketsGet16(HCTX16 hCtx, INT16 cMaxPkts, LPVOID lpPkts)
{
FIXME("(0x%04hx, %hd, %p): stub\n", hCtx, cMaxPkts, lpPkts);
return 0;
}
/***********************************************************************
* WTPacket (WINTAB.24)
*/
BOOL16 WINAPI WTPacket16(HCTX16 hCtx, UINT16 wSerial, LPVOID lpPkt)
{
FIXME("(0x%04hx, %hd, %p): stub\n", hCtx, wSerial, lpPkt);
return FALSE;
}
/***********************************************************************
* WTEnable (WINTAB.40)
*/
BOOL16 WINAPI WTEnable16(HCTX16 hCtx, BOOL16 fEnable)
{
FIXME("(0x%04hx, %hu): stub\n", hCtx, fEnable);
return FALSE;
}
/***********************************************************************
* WTOverlap (WINTAB.41)
*/
BOOL16 WINAPI WTOverlap16(HCTX16 hCtx, BOOL16 fToTop)
{
FIXME("(0x%04hx, %hu): stub\n", hCtx, fToTop);
return FALSE;
}
/***********************************************************************
* WTConfig (WINTAB.60)
*/
BOOL16 WINAPI WTConfig16(HCTX16 hCtx, HWND16 hWnd)
{
FIXME("(0x%04hx, 0x%04hx): stub\n", hCtx, hWnd);
return FALSE;
}
/***********************************************************************
* WTGet (WINTAB.61)
*/
BOOL16 WINAPI WTGet16(HCTX16 hCtx, LPLOGCONTEXT16 lpLogCtx)
{
FIXME("(0x%04hx, %p): stub\n", hCtx, lpLogCtx);
return FALSE;
}
/***********************************************************************
* WTSet (WINTAB.62)
*/
BOOL16 WINAPI WTSet16(HCTX16 hCtx, LPLOGCONTEXT16 lpLogCtx)
{
FIXME("(0x%04hx, %p): stub\n", hCtx, lpLogCtx);
return FALSE;
}
/***********************************************************************
* WTExtGet (WINTAB.63)
*/
BOOL16 WINAPI WTExtGet16(HCTX16 hCtx, UINT16 wExt, LPVOID lpData)
{
FIXME("(0x%04hx, %hu, %p): stub\n", hCtx, wExt, lpData);
return FALSE;
}
/***********************************************************************
* WTExtSet (WINTAB.64)
*/
BOOL16 WINAPI WTExtSet16(HCTX16 hCtx, UINT16 wExt, LPVOID lpData)
{
FIXME("(0x%04hx, %hu, %p): stub\n", hCtx, wExt, lpData);
return FALSE;
}
/***********************************************************************
* WTSave (WINTAB.65)
*/
BOOL16 WINAPI WTSave16(HCTX16 hCtx, LPVOID lpSaveInfo)
{
FIXME("(0x%04hx, %p): stub\n", hCtx, lpSaveInfo);
return FALSE;
}
/***********************************************************************
* WTRestore (WINTAB.66)
*/
HCTX16 WINAPI WTRestore16(HWND16 hWnd, LPVOID lpSaveInfo, BOOL16 fEnable)
{
FIXME("(0x%04hx, %p, %hu): stub\n", hWnd, lpSaveInfo, fEnable);
return 0;
}
/***********************************************************************
* WTPacketsPeek (WINTAB.80)
*/
INT16 WINAPI WTPacketsPeek16(HCTX16 hCtx, INT16 cMaxPkts, LPVOID lpPkts)
{
FIXME("(0x%04hx, %hd, %p): stub\n", hCtx, cMaxPkts, lpPkts);
return 0;
}
/***********************************************************************
* WTDataGet (WINTAB.81)
*/
INT16 WINAPI WTDataGet16(HCTX16 hCtx, UINT16 wBegin, UINT16 wEnd,
INT16 cMaxPkts, LPVOID lpPkts, LPINT16 lpNPkts)
{
FIXME("(0x%04hx, %hu, %hu, %hd, %p, %p): stub\n",
hCtx, wBegin, wEnd, cMaxPkts, lpPkts, lpNPkts);
return 0;
}
/***********************************************************************
* WTDataPeek (WINTAB.82)
*/
INT16 WINAPI WTDataPeek16(HCTX16 hCtx, UINT16 wBegin, UINT16 wEnd,
INT16 cMaxPkts, LPVOID lpPkts, LPINT16 lpNPkts)
{
FIXME("(0x%04hx, %hu, %hu, %hd, %p, %p): stub\n",
hCtx, wBegin, wEnd, cMaxPkts, lpPkts, lpNPkts);
return 0;
}
/***********************************************************************
* WTQueuePackets (WINTAB.83)
*
* OBSOLETE IN WIN32!
*/
DWORD WINAPI WTQueuePackets16(HCTX16 hCtx)
{
FIXME("(0x%04hx): stub\n", hCtx);
return 0;
}
/***********************************************************************
* WTQueuePacketsEx (WINTAB.200)
*/
BOOL16 WINAPI WTQueuePacketsEx16(HCTX16 hCtx, UINT16 *lpOld, UINT16 *lpNew)
{
FIXME("(0x%04hx, %p, %p): stub\n", hCtx, lpOld, lpNew);
return TRUE;
}
/***********************************************************************
* WTQueueSizeGet (WINTAB.84)
*/
INT16 WINAPI WTQueueSizeGet16(HCTX16 hCtx)
{
FIXME("(0x%04hx): stub\n", hCtx);
return 0;
}
/***********************************************************************
* WTQueueSizeSet (WINTAB.85)
*/
BOOL16 WINAPI WTQueueSizeSet16(HCTX16 hCtx, INT16 nPkts)
{
FIXME("(0x%04hx, %hd): stub\n", hCtx, nPkts);
return FALSE;
}
/***********************************************************************
* WTMgrOpen (WINTAB.100)
*/
HMGR16 WINAPI WTMgrOpen16(HWND16 hWnd, UINT16 wMsgBase)
{
FIXME("(0x%04hx, %hu): stub\n", hWnd, wMsgBase);
return 0;
}
/***********************************************************************
* WTMgrClose (WINTAB.101)
*/
BOOL16 WINAPI WTMgrClose16(HMGR16 hMgr)
{
FIXME("(0x%04hx): stub\n", hMgr);
return FALSE;
}
/***********************************************************************
* WTMgrContextEnum (WINTAB.120)
*/
BOOL16 WINAPI WTMgrContextEnum16(HMGR16 hMgr, WTENUMPROC16 lpEnumFunc, LPARAM lParam)
{
FIXME("(0x%04hx, %p, %ld): stub\n", hMgr, lpEnumFunc, lParam);
return FALSE;
}
/***********************************************************************
* WTMgrContextOwner (WINTAB.121)
*/
HWND16 WINAPI WTMgrContextOwner16(HMGR16 hMgr, HCTX16 hCtx)
{
FIXME("(0x%04hx, 0x%04hx): stub\n", hMgr, hCtx);
return 0;
}
/***********************************************************************
* WTMgrDefContext (WINTAB.122)
*/
HCTX16 WINAPI WTMgrDefContext16(HMGR16 hMgr, BOOL16 fSystem)
{
FIXME("(0x%04hx, %hu): stub\n", hMgr, fSystem);
return 0;
}
/***********************************************************************
* WTMgrDefContextEx (WINTAB.206)
*
* 1.1
*/
HCTX16 WINAPI WTMgrDefContextEx16(HMGR16 hMgr, UINT16 wDevice, BOOL16 fSystem)
{
FIXME("(0x%04hx, %hu, %hu): stub\n", hMgr, wDevice, fSystem);
return 0;
}
/***********************************************************************
* WTMgrDeviceConfig (WINTAB.140)
*/
UINT16 WINAPI WTMgrDeviceConfig16(HMGR16 hMgr, UINT16 wDevice, HWND16 hWnd)
{
FIXME("(0x%04hx, %hu, 0x%04hx): stub\n", hMgr, wDevice, hWnd);
return 0;
}
/***********************************************************************
* WTMgrConfigReplace (WINTAB.141)
*
* OBSOLETE IN WIN32!
*/
BOOL16 WINAPI WTMgrConfigReplace16(HMGR16 hMgr, BOOL16 fInstall,
WTCONFIGPROC16 lpConfigProc)
{
FIXME("(0x%04hx, %hu, %p): stub\n", hMgr, fInstall, lpConfigProc);
return FALSE;
}
/***********************************************************************
* WTMgrConfigReplaceEx (WINTAB.202)
*/
BOOL16 WINAPI WTMgrConfigReplaceEx16(HMGR16 hMgr, BOOL16 fInstall,
LPSTR lpszModule, LPSTR lpszCfgProc)
{
FIXME("(0x%04hx, %hu, %s, %s): stub\n", hMgr, fInstall,
debugstr_a(lpszModule), debugstr_a(lpszCfgProc));
return FALSE;
}
/***********************************************************************
* WTMgrPacketHook (WINTAB.160)
*
* OBSOLETE IN WIN32!
*/
WTHOOKPROC16 WINAPI WTMgrPacketHook16(HMGR16 hMgr, BOOL16 fInstall,
INT16 nType, WTHOOKPROC16 lpFunc)
{
FIXME("(0x%04hx, %hu, %hd, %p): stub\n", hMgr, fInstall, nType, lpFunc);
return 0;
}
/***********************************************************************
* WTMgrPacketHookEx (WINTAB.203)
*/
HWTHOOK16 WINAPI WTMgrPacketHookEx16(HMGR16 hMgr, INT16 nType,
LPSTR lpszModule, LPSTR lpszHookProc)
{
FIXME("(0x%04hx, %hd, %s, %s): stub\n", hMgr, nType,
debugstr_a(lpszModule), debugstr_a(lpszHookProc));
return 0;
}
/***********************************************************************
* WTMgrPacketUnhook (WINTAB.204)
*/
BOOL16 WINAPI WTMgrPacketUnhook16(HWTHOOK16 hHook)
{
FIXME("(0x%04hx): stub\n", hHook);
return FALSE;
}
/***********************************************************************
* WTMgrPacketHookDefProc (WINTAB.161)
*
* OBSOLETE IN WIN32!
*/
LRESULT WINAPI WTMgrPacketHookDefProc16(INT16 nCode, WPARAM16 wParam,
LPARAM lParam, LPWTHOOKPROC16 lplpFunc)
{
FIXME("(%hd, %hu, %lu, %p): stub\n", nCode, wParam, lParam, lplpFunc);
return 0;
}
/***********************************************************************
* WTMgrPacketHookNext (WINTAB.205)
*/
LRESULT WINAPI WTMgrPacketHookNext16(HWTHOOK16 hHook, INT16 nCode,
WPARAM16 wParam, LPARAM lParam)
{
FIXME("(0x%04hx, %hd, %hu, %lu): stub\n", hHook, nCode, wParam, lParam);
return 0;
}
/***********************************************************************
* WTMgrExt (WINTAB.180)
*/
BOOL16 WINAPI WTMgrExt16(HMGR16 hMgr, UINT16 wExt, LPVOID lpData)
{
FIXME("(0x%04hx, %hu, %p): stub\n", hMgr, wExt, lpData);
return FALSE;
}
/***********************************************************************
* WTMgrCsrEnable (WINTAB.181)
*/
BOOL16 WINAPI WTMgrCsrEnable16(HMGR16 hMgr, UINT16 wCursor, BOOL16 fEnable)
{
FIXME("(0x%04hx, %hu, %hu): stub\n", hMgr, wCursor, fEnable);
return FALSE;
}
/***********************************************************************
* WTMgrCsrButtonMap (WINTAB.182)
*/
BOOL16 WINAPI WTMgrCsrButtonMap16(HMGR16 hMgr, UINT16 wCursor,
LPBYTE lpLogBtns, LPBYTE lpSysBtns)
{
FIXME("(0x%04hx, %hu, %p, %p): stub\n", hMgr, wCursor, lpLogBtns, lpSysBtns);
return FALSE;
}
/***********************************************************************
* WTMgrCsrPressureBtnMarks (WINTAB.183)
*
* OBSOLETE IN WIN32! (But only according to documentation)
*/
BOOL16 WINAPI WTMgrCsrPressureBtnMarks16(HMGR16 hMgr, UINT16 wCsr,
DWORD dwNMarks, DWORD dwTMarks)
{
FIXME("(0x%04hx, %hu, %lu, %lu): stub\n", hMgr, wCsr, dwNMarks, dwTMarks);
return FALSE;
}
/***********************************************************************
* WTMgrCsrPressureBtnMarksEx (WINTAB.201)
*/
BOOL16 WINAPI WTMgrCsrPressureBtnMarksEx16(HMGR16 hMgr, UINT16 wCsr,
UINT16 *lpNMarks, UINT16 *lpTMarks)
{
FIXME("(0x%04hx, %hu, %p, %p): stub\n", hMgr, wCsr, lpNMarks, lpTMarks);
return FALSE;
}
/***********************************************************************
* WTMgrCsrPressureResponse (WINTAB.184)
*/
BOOL16 WINAPI WTMgrCsrPressureResponse16(HMGR16 hMgr, UINT16 wCsr,
UINT16 *lpNResp, UINT16 *lpTResp)
{
FIXME("(0x%04hx, %hu, %p, %p): stub\n", hMgr, wCsr, lpNResp, lpTResp);
return FALSE;
}
/***********************************************************************
* WTMgrCsrExt (WINTAB.185)
*/
BOOL16 WINAPI WTMgrCsrExt16(HMGR16 hMgr, UINT16 wCsr, UINT16 wExt, LPVOID lpData)
{
FIXME("(0x%04hx, %hu, %hu, %p): stub\n", hMgr, wCsr, wExt, lpData);
return FALSE;
}

44
dlls/wintab32/wintab32.spec Normal file
View File

@ -0,0 +1,44 @@
20 stdcall WTInfoA(long long ptr) WTInfoA
21 stdcall WTOpenA(long ptr long) WTOpenA
22 stdcall WTClose(long) WTClose
23 stdcall WTPacketsGet(long long ptr) WTPacketsGet
24 stdcall WTPacket(long long ptr) WTPacket
40 stdcall WTEnable(long long) WTEnable
41 stdcall WTOverlap(long long) WTOverlap
60 stdcall WTConfig(long long) WTConfig
61 stdcall WTGetA(long ptr) WTGetA
62 stdcall WTSetA(long ptr) WTSetA
63 stdcall WTExtGet(long long ptr) WTExtGet
64 stdcall WTExtSet(long long ptr) WTExtSet
65 stdcall WTSave(long ptr) WTSave
66 stdcall WTRestore(long ptr long) WTRestore
80 stdcall WTPacketsPeek(long long ptr) WTPacketsPeek
81 stdcall WTDataGet(long long long long ptr ptr) WTDataGet
82 stdcall WTDataPeek(long long long long ptr ptr) WTDataPeek
84 stdcall WTQueueSizeGet(long) WTQueueSizeGet
85 stdcall WTQueueSizeSet(long long) WTQueueSizeSet
100 stdcall WTMgrOpen(long long) WTMgrOpen
101 stdcall WTMgrClose(long) WTMgrClose
120 stdcall WTMgrContextEnum(long ptr long) WTMgrContextEnum
121 stdcall WTMgrContextOwner(long long) WTMgrContextOwner
122 stdcall WTMgrDefContext(long long) WTMgrDefContext
140 stdcall WTMgrDeviceConfig(long long long) WTMgrDeviceConfig
180 stdcall WTMgrExt(long long ptr) WTMgrExt
181 stdcall WTMgrCsrEnable(long long long) WTMgrCsrEnable
182 stdcall WTMgrCsrButtonMap(long long ptr ptr) WTMgrCsrButtonMap
183 stdcall WTMgrCsrPressureBtnMarks(long long long long) WTMgrCsrPressureBtnMarks
184 stdcall WTMgrCsrPressureResponse(long long ptr ptr) WTMgrCsrPressureResponse
185 stdcall WTMgrCsrExt(long long long ptr) WTMgrCsrExt
200 stdcall WTQueuePacketsEx(long ptr ptr) WTQueuePacketsEx
201 stdcall WTMgrCsrPressureBtnMarksEx(long long ptr ptr) WTMgrCsrPressureBtnMarksEx
202 stdcall WTMgrConfigReplaceExA(long long str str) WTMgrConfigReplaceExA
203 stdcall WTMgrPacketHookExA(long long str str) WTMgrPacketHookExA
204 stdcall WTMgrPacketUnhook(long) WTMgrPacketUnhook
205 stdcall WTMgrPacketHookNext(long long long long) WTMgrPacketHookNext
206 stdcall WTMgrDefContextEx(long long long) WTMgrDefContextEx
1020 stdcall WTInfoW(long long ptr) WTInfoW
1021 stdcall WTOpenW(long ptr long) WTOpenW
1061 stdcall WTGetW(long ptr) WTGetW
1062 stdcall WTSetW(long ptr) WTSetW
1202 stdcall WTMgrConfigReplaceExW(long long wstr str) WTMgrConfigReplaceExW
1203 stdcall WTMgrPacketHookExW(long long wstr str) WTMgrPacketHookExW

3
include/Makefile.in
View File

@ -96,6 +96,7 @@ WINDOWS_INCLUDES = \
olectl.h \
oledlg.h \
oleidl.h \
pktdef.h \
poppack.h \
prsht.h \
psapi.h \
@ -152,6 +153,8 @@ WINDOWS_INCLUDES = \
winsock2.h \
winspool.h \
winsvc.h \
wintab.h \
wintabx.h \
winternl.h \
winuser.h \
winver.h \

248
include/pktdef.h Normal file
View File

@ -0,0 +1,248 @@
/*
* Copyright (C) 1991-1998 by LCS/Telegraphics
* Copyright (C) 2002 Patrik Stridvall
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __WINE_PKTDEF_H
#define __WINE_PKTDEF_H
/***********************************************************************
* How to use pktdef.h:
*
* 1. Include wintab.h
* 2. if using just one packet format:
* a. Define PACKETDATA and PACKETMODE as or'ed combinations of WTPKT bits
* (use the PK_* identifiers).
* b. Include pktdef.h.
* c. The generated structure typedef will be called PACKET. Use PACKETDATA
* and PACKETMODE to fill in the LOGCONTEXT structure.
* 3. If using multiple packet formats, for each one:
* a. Define PACKETNAME. Its text value will be a prefix for this packet's
* parameters and names.
* b. Define <PACKETNAME>PACKETDATA and <PACKETNAME>PACKETMODE similar to
* 2.a. above.
* c. Include pktdef.h.
* d. The generated structure typedef will be called
* <PACKETNAME>PACKET. Compare with 2.c. above and example #2 below.
* 4. If using extension packet data, do the following additional steps
* for each extension:
* a. Before including pktdef.h, define <PACKETNAME>PACKET<EXTENSION>
* as either PKEXT_ABSOLUTE or PKEXT_RELATIVE.
* b. The generated structure typedef will contain a field for the
* extension data.
* c. Scan the WTI_EXTENSION categories to find the extension's
* packet mask bit.
* d. OR the packet mask bit with <PACKETNAME>PACKETDATA and use the
* result in the lcPktData field of the LOGCONTEXT structure.
* e. If <PACKETNAME>PACKET<EXTENSION> was PKEXT_RELATIVE, OR the
* packet mask bit with <PACKETNAME>PACKETMODE and use the result
* in the lcPktMode field of the LOGCONTEXT structure.
*
*
* Example #1. -- single packet format
*
* #include <wintab.h>
* #define PACKETDATA PK_X | PK_Y | PK_BUTTONS /@ x, y, buttons @/
* #define PACKETMODE PK_BUTTONS /@ buttons relative mode @/
* #include <pktdef.h>
* ...
* lc.lcPktData = PACKETDATA;
* lc.lcPktMode = PACKETMODE;
*
* Example #2. -- multiple formats
*
* #include <wintab.h>
* #define PACKETNAME MOE
* #define MOEPACKETDATA PK_X | PK_Y | PK_BUTTONS /@ x, y, buttons @/
* #define MOEPACKETMODE PK_BUTTONS /@ buttons relative mode @/
* #include <pktdef.h>
* #define PACKETNAME LARRY
* #define LARRYPACKETDATA PK_Y | PK_Z | PK_BUTTONS /@ y, z, buttons @/
* #define LARRYPACKETMODE PK_BUTTONS /@ buttons relative mode @/
* #include <pktdef.h>
* #define PACKETNAME CURLY
* #define CURLYPACKETDATA PK_X | PK_Z | PK_BUTTONS /@ x, z, buttons @/
* #define CURLYPACKETMODE PK_BUTTONS /@ buttons relative mode @/
* #include <pktdef.h>
* ...
* lcMOE.lcPktData = MOEPACKETDATA;
* lcMOE.lcPktMode = MOEPACKETMODE;
* ...
* lcLARRY.lcPktData = LARRYPACKETDATA;
* lcLARRY.lcPktMode = LARRYPACKETMODE;
* ...
* lcCURLY.lcPktData = CURLYPACKETDATA;
* lcCURLY.lcPktMode = CURLYPACKETMODE;
*
* Example #3. -- extension packet data "XFOO".
*
* #include <wintab.h>
* #define PACKETDATA PK_X | PK_Y | PK_BUTTONS /@ x, y, buttons @/
* #define PACKETMODE PK_BUTTONS /@ buttons relative mode @/
* #define PACKETXFOO PKEXT_ABSOLUTE /@ XFOO absolute mode @/
* #include <pktdef.h>
* ...
* UINT ScanExts(UINT wTag)
* {
* UINT i;
* UINT wScanTag;
*
* /@ scan for wTag's info category. @/
* for (i = 0; WTInfo(WTI_EXTENSIONS + i, EXT_TAG, &wScanTag); i++) {
* if (wTag == wScanTag) {
* /@ return category offset from WTI_EXTENSIONS. @/
* return i;
* }
* }
* /@ return error code. @/
* return 0xFFFF;
* }
* ...
* lc.lcPktData = PACKETDATA;
* lc.lcPktMode = PACKETMODE;
* #ifdef PACKETXFOO
* categoryXFOO = ScanExts(WTX_XFOO);
* WTInfo(WTI_EXTENSIONS + categoryXFOO, EXT_MASK, &maskXFOO);
* lc.lcPktData |= maskXFOO;
* #if PACKETXFOO == PKEXT_RELATIVE
* lc.lcPktMode |= maskXFOO;
* #endif
* #endif
* WTOpen(hWnd, &lc, TRUE);
*/
#ifdef __cplusplus
extern "C" {
#endif /* defined(__cplusplus) */
#ifndef PACKETNAME
/* if no packet name prefix */
# define __PFX(x) x
# define __IFX(x,y) x ## y
#else
/* add prefixes and infixes to packet format names */
# define __PFX(x) __PFX2(PACKETNAME,x)
# define __PFX2(p,x) __PFX3(p,x)
# define __PFX3(p,x) p ## x
# define __IFX(x,y) __IFX2(x,PACKETNAME,y)
# define __IFX2(x,i,y) __IFX3(x,i,y)
# define __IFX3(x,i,y) x ## i ## y
#endif
#define __SFX2(x,s) __SFX3(x,s)
#define __SFX3(x,s) x ## s
#define __TAG __IFX(tag,PACKET)
#define __TYPES \
__PFX(PACKET), * __IFX(P,PACKET), \
* __IFX(NP,PACKET), * __IFX(LP,PACKET)
#define __DATA (__PFX(PACKETDATA))
#define __MODE (__PFX(PACKETMODE))
#define __EXT(x) __SFX2(__PFX(PACKET),x)
typedef struct __TAG {
#if (__DATA & PK_CONTEXT)
HCTX pkContext;
#endif
#if (__DATA & PK_STATUS)
UINT pkStatus;
#endif
#if (__DATA & PK_TIME)
DWORD pkTime;
#endif
#if (__DATA & PK_CHANGED)
WTPKT pkChanged;
#endif
#if (__DATA & PK_SERIAL_NUMBER)
UINT pkSerialNumber;
#endif
#if (__DATA & PK_CURSOR)
UINT pkCursor;
#endif
#if (__DATA & PK_BUTTONS)
DWORD pkButtons;
#endif
#if (__DATA & PK_X)
LONG pkX;
#endif
#if (__DATA & PK_Y)
LONG pkY;
#endif
#if (__DATA & PK_Z)
LONG pkZ;
#endif
#if (__DATA & PK_NORMAL_PRESSURE)
# if (__MODE & PK_NORMAL_PRESSURE)
/* relative */
int pkNormalPressure;
# else
/* absolute */
UINT pkNormalPressure;
# endif
#endif
#if (__DATA & PK_TANGENT_PRESSURE)
# if (__MODE & PK_TANGENT_PRESSURE)
/* relative */
int pkTangentPressure;
# else
/* absolute */
UINT pkTangentPressure;
# endif
#endif
#if (__DATA & PK_ORIENTATION)
ORIENTATION pkOrientation;
#endif
#if (__DATA & PK_ROTATION)
ROTATION pkRotation; /* 1.1 */
#endif
#ifndef NOWTEXTENSIONS
/* extensions begin here. */
#if (__EXT(FKEYS) == PKEXT_RELATIVE) || (__EXT(FKEYS) == PKEXT_ABSOLUTE)
UINT pkFKeys;
#endif
#if (__EXT(TILT) == PKEXT_RELATIVE) || (__EXT(TILT) == PKEXT_ABSOLUTE)
TILT pkTilt;
#endif
#endif
} __TYPES;
#undef PACKETNAME
#undef __TAG
#undef __TAG2
#undef __TYPES
#undef __TYPES2
#undef __DATA
#undef __MODE
#undef __PFX
#undef __PFX2
#undef __PFX3
#undef __IFX
#undef __IFX2
#undef __IFX3
#undef __SFX2
#undef __SFX3
#ifdef __cplusplus
} /* extern "C" */
#endif /* defined(__cplusplus) */
#endif /* defined(__WINE_PKTDEF_H */

786
include/wintab.h Normal file
View File

@ -0,0 +1,786 @@
/*
* Copyright (C) 1991-1998 by LCS/Telegraphics
* Copyright (C) 2002 Patrik Stridvall
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __WINE_WINTAB_H
#define __WINE_WINTAB_H
#ifdef __cplusplus
extern "C" {
#endif /* defined(__cplusplus) */
/***********************************************************************
* Messages
*/
#ifndef NOWTMESSAGES
#define WT_DEFBASE 0x7FF0
#define WT_MAXOFFSET 0xF
#define _WT_PACKET(b) ((b)+0)
#define _WT_CTXOPEN(b) ((b)+1)
#define _WT_CTXCLOSE(b) ((b)+2)
#define _WT_CTXUPDATE(b) ((b)+3)
#define _WT_CTXOVERLAP(b) ((b)+4)
#define _WT_PROXIMITY(b) ((b)+5)
#define _WT_INFOCHANGE(b) ((b)+6)
#define _WT_CSRCHANGE(b) ((b)+7) /* 1.1 */
#define _WT_MAX(b) ((b)+WT_MAXOFFSET)
#define WT_PACKET _WT_PACKET(WT_DEFBASE)
#define WT_CTXOPEN _WT_CTXOPEN(WT_DEFBASE)
#define WT_CTXCLOSE _WT_CTXCLOSE(WT_DEFBASE)
#define WT_CTXUPDATE _WT_CTXUPDATE(WT_DEFBASE)
#define WT_CTXOVERLAP _WT_CTXOVERLAP(WT_DEFBASE)
#define WT_PROXIMITY _WT_PROXIMITY(WT_DEFBASE)
#define WT_INFOCHANGE _WT_INFOCHANGE(WT_DEFBASE)
#define WT_CSRCHANGE _WT_CSRCHANGE(WT_DEFBASE) /* 1.1 */
#define WT_MAX _WT_MAX(WT_DEFBASE)
#endif
/***********************************************************************
* COMMON DATA DEFS
*/
DECLARE_HANDLE(HMGR); /* manager handle */
DECLARE_HANDLE(HCTX); /* context handle */
DECLARE_HANDLE(HWTHOOK); /* hook handle */
typedef DWORD WTPKT; /* packet mask */
#ifndef NOWTPKT
/* WTPKT bits */
#define PK_CONTEXT 0x0001 /* reporting context */
#define PK_STATUS 0x0002 /* status bits */
#define PK_TIME 0x0004 /* time stamp */
#define PK_CHANGED 0x0008 /* change bit vector */
#define PK_SERIAL_NUMBER 0x0010 /* packet serial number */
#define PK_CURSOR 0x0020 /* reporting cursor */
#define PK_BUTTONS 0x0040 /* button information */
#define PK_X 0x0080 /* x axis */
#define PK_Y 0x0100 /* y axis */
#define PK_Z 0x0200 /* z axis */
#define PK_NORMAL_PRESSURE 0x0400 /* normal or tip pressure */
#define PK_TANGENT_PRESSURE 0x0800 /* tangential or barrel pressure */
#define PK_ORIENTATION 0x1000 /* orientation info: tilts */
#define PK_ROTATION 0x2000 /* rotation info; 1.1 */
#endif
typedef DWORD FIX32; /* fixed-point arithmetic type */
#ifndef NOFIX32
#define INT(x) HIWORD(x)
#define FRAC(x) LOWORD(x)
#define CASTFIX32(x) ((FIX32)((x)*65536L))
#define ROUND(x) (INT(x) + (FRAC(x) > (WORD)0x8000))
#define FIX_MUL(c, a, b) \
(c = (((DWORD)FRAC(a) * FRAC(b)) >> 16) + \
(DWORD)INT(a) * FRAC(b) + \
(DWORD)INT(b) * FRAC(a) + \
((DWORD)INT(a) * INT(b) << 16))
#ifdef _WINDLL
# define FIX_DIV_SC static
#else
# define FIX_DIV_SC
# endif
#define FIX_DIV(c, a, b) \
{ \
FIX_DIV_SC DWORD temp, rem, btemp; \
\
/* fraction done bytewise */ \
temp = ((a / b) << 16); \
rem = a % b; \
btemp = b; \
if (INT(btemp) < 256) { \
rem <<= 8; \
} else { \
btemp >>= 8; \
} \
temp += ((rem / btemp) << 8); \
rem %= btemp; \
rem <<= 8; \
temp += rem / btemp; \
c = temp; \
}
#endif
/***********************************************************************
* INFO DATA DEFS
*/
#ifndef NOWTINFO
#ifndef NOWTAXIS
typedef struct tagAXIS {
LONG axMin;
LONG axMax;
UINT axUnits;
FIX32 axResolution;
} AXIS, *PAXIS, *NPAXIS, *LPAXIS;
/* unit specifiers */
#define TU_NONE 0
#define TU_INCHES 1
#define TU_CENTIMETERS 2
#define TU_CIRCLE 3
#endif
#ifndef NOWTSYSBUTTONS
/* system button assignment values */
#define SBN_NONE 0x00
#define SBN_LCLICK 0x01
#define SBN_LDBLCLICK 0x02
#define SBN_LDRAG 0x03
#define SBN_RCLICK 0x04
#define SBN_RDBLCLICK 0x05
#define SBN_RDRAG 0x06
#define SBN_MCLICK 0x07
#define SBN_MDBLCLICK 0x08
#define SBN_MDRAG 0x09
/* for Pen Windows */
#define SBN_PTCLICK 0x10
#define SBN_PTDBLCLICK 0x20
#define SBN_PTDRAG 0x30
#define SBN_PNCLICK 0x40
#define SBN_PNDBLCLICK 0x50
#define SBN_PNDRAG 0x60
#define SBN_P1CLICK 0x70
#define SBN_P1DBLCLICK 0x80
#define SBN_P1DRAG 0x90
#define SBN_P2CLICK 0xA0
#define SBN_P2DBLCLICK 0xB0
#define SBN_P2DRAG 0xC0
#define SBN_P3CLICK 0xD0
#define SBN_P3DBLCLICK 0xE0
#define SBN_P3DRAG 0xF0
#endif
#ifndef NOWTCAPABILITIES
/* hardware capabilities */
#define HWC_INTEGRATED 0x0001
#define HWC_TOUCH 0x0002
#define HWC_HARDPROX 0x0004
#define HWC_PHYSID_CURSORS 0x0008 /* 1.1 */
#endif
#ifndef NOWTIFC
#ifndef NOWTCURSORS
/* cursor capabilities */
#define CRC_MULTIMODE 0x0001 /* 1.1 */
#define CRC_AGGREGATE 0x0002 /* 1.1 */
#define CRC_INVERT 0x0004 /* 1.1 */
#endif
/* info categories */
#define WTI_INTERFACE 1
#define IFC_WINTABID 1
#define IFC_SPECVERSION 2
#define IFC_IMPLVERSION 3
#define IFC_NDEVICES 4
#define IFC_NCURSORS 5
#define IFC_NCONTEXTS 6
#define IFC_CTXOPTIONS 7
#define IFC_CTXSAVESIZE 8
#define IFC_NEXTENSIONS 9
#define IFC_NMANAGERS 10
#define IFC_MAX 10
#endif
#ifndef NOWTSTATUS
#define WTI_STATUS 2
#define STA_CONTEXTS 1
#define STA_SYSCTXS 2
#define STA_PKTRATE 3
#define STA_PKTDATA 4
#define STA_MANAGERS 5
#define STA_SYSTEM 6
#define STA_BUTTONUSE 7
#define STA_SYSBTNUSE 8
#define STA_MAX 8
#endif
#ifndef NOWTDEFCONTEXT
#define WTI_DEFCONTEXT 3
#define WTI_DEFSYSCTX 4
#define WTI_DDCTXS 400 /* 1.1 */
#define WTI_DSCTXS 500 /* 1.1 */
#define CTX_NAME 1
#define CTX_OPTIONS 2
#define CTX_STATUS 3
#define CTX_LOCKS 4
#define CTX_MSGBASE 5
#define CTX_DEVICE 6
#define CTX_PKTRATE 7
#define CTX_PKTDATA 8
#define CTX_PKTMODE 9
#define CTX_MOVEMASK 10
#define CTX_BTNDNMASK 11
#define CTX_BTNUPMASK 12
#define CTX_INORGX 13
#define CTX_INORGY 14
#define CTX_INORGZ 15
#define CTX_INEXTX 16
#define CTX_INEXTY 17
#define CTX_INEXTZ 18
#define CTX_OUTORGX 19
#define CTX_OUTORGY 20
#define CTX_OUTORGZ 21
#define CTX_OUTEXTX 22
#define CTX_OUTEXTY 23
#define CTX_OUTEXTZ 24
#define CTX_SENSX 25
#define CTX_SENSY 26
#define CTX_SENSZ 27
#define CTX_SYSMODE 28
#define CTX_SYSORGX 29
#define CTX_SYSORGY 30
#define CTX_SYSEXTX 31
#define CTX_SYSEXTY 32
#define CTX_SYSSENSX 33
#define CTX_SYSSENSY 34
#define CTX_MAX 34
#endif
#ifndef NOWTDEVICES
#define WTI_DEVICES 100
#define DVC_NAME 1
#define DVC_HARDWARE 2
#define DVC_NCSRTYPES 3
#define DVC_FIRSTCSR 4
#define DVC_PKTRATE 5
#define DVC_PKTDATA 6
#define DVC_PKTMODE 7
#define DVC_CSRDATA 8
#define DVC_XMARGIN 9
#define DVC_YMARGIN 10
#define DVC_ZMARGIN 11
#define DVC_X 12
#define DVC_Y 13
#define DVC_Z 14
#define DVC_NPRESSURE 15
#define DVC_TPRESSURE 16
#define DVC_ORIENTATION 17
#define DVC_ROTATION 18 /* 1.1 */
#define DVC_PNPID 19 /* 1.1 */
#define DVC_MAX 19
#endif
#ifndef NOWTCURSORS
#define WTI_CURSORS 200
#define CSR_NAME 1
#define CSR_ACTIVE 2
#define CSR_PKTDATA 3
#define CSR_BUTTONS 4
#define CSR_BUTTONBITS 5
#define CSR_BTNNAMES 6
#define CSR_BUTTONMAP 7
#define CSR_SYSBTNMAP 8
#define CSR_NPBUTTON 9
#define CSR_NPBTNMARKS 10
#define CSR_NPRESPONSE 11
#define CSR_TPBUTTON 12
#define CSR_TPBTNMARKS 13
#define CSR_TPRESPONSE 14
#define CSR_PHYSID 15 /* 1.1 */
#define CSR_MODE 16 /* 1.1 */
#define CSR_MINPKTDATA 17 /* 1.1 */
#define CSR_MINBUTTONS 18 /* 1.1 */
#define CSR_CAPABILITIES 19 /* 1.1 */
#define CSR_MAX 19
#endif
#ifndef NOWTEXTENSIONS
#define WTI_EXTENSIONS 300
#define EXT_NAME 1
#define EXT_TAG 2
#define EXT_MASK 3
#define EXT_SIZE 4
#define EXT_AXES 5
#define EXT_DEFAULT 6
#define EXT_DEFCONTEXT 7
#define EXT_DEFSYSCTX 8
#define EXT_CURSORS 9
#define EXT_MAX 109 /* Allow 100 cursors */
#endif
#endif
/***********************************************************************
* CONTEXT DATA DEFS
*/
#define LCNAMELEN 40
#define LC_NAMELEN 40
typedef struct tagLOGCONTEXTA {
char lcName[LCNAMELEN];
UINT lcOptions;
UINT lcStatus;
UINT lcLocks;
UINT lcMsgBase;
UINT lcDevice;
UINT lcPktRate;
WTPKT lcPktData;
WTPKT lcPktMode;
WTPKT lcMoveMask;
DWORD lcBtnDnMask;
DWORD lcBtnUpMask;
LONG lcInOrgX;
LONG lcInOrgY;
LONG lcInOrgZ;
LONG lcInExtX;
LONG lcInExtY;
LONG lcInExtZ;
LONG lcOutOrgX;
LONG lcOutOrgY;
LONG lcOutOrgZ;
LONG lcOutExtX;
LONG lcOutExtY;
LONG lcOutExtZ;
FIX32 lcSensX;
FIX32 lcSensY;
FIX32 lcSensZ;
BOOL lcSysMode;
int lcSysOrgX;
int lcSysOrgY;
int lcSysExtX;
int lcSysExtY;
FIX32 lcSysSensX;
FIX32 lcSysSensY;
} LOGCONTEXTA, *PLOGCONTEXTA, *NPLOGCONTEXTA, *LPLOGCONTEXTA;
typedef struct tagLOGCONTEXTW {
WCHAR lcName[LCNAMELEN];
UINT lcOptions;
UINT lcStatus;
UINT lcLocks;
UINT lcMsgBase;
UINT lcDevice;
UINT lcPktRate;
WTPKT lcPktData;
WTPKT lcPktMode;
WTPKT lcMoveMask;
DWORD lcBtnDnMask;
DWORD lcBtnUpMask;
LONG lcInOrgX;
LONG lcInOrgY;
LONG lcInOrgZ;
LONG lcInExtX;
LONG lcInExtY;
LONG lcInExtZ;
LONG lcOutOrgX;
LONG lcOutOrgY;
LONG lcOutOrgZ;
LONG lcOutExtX;
LONG lcOutExtY;
LONG lcOutExtZ;
FIX32 lcSensX;
FIX32 lcSensY;
FIX32 lcSensZ;
BOOL lcSysMode;
int lcSysOrgX;
int lcSysOrgY;
int lcSysExtX;
int lcSysExtY;
FIX32 lcSysSensX;
FIX32 lcSysSensY;
} LOGCONTEXTW, *PLOGCONTEXTW, *NPLOGCONTEXTW, *LPLOGCONTEXTW;
DECL_WINELIB_TYPE_AW(LOGCONTEXT)
DECL_WINELIB_TYPE_AW(PLOGCONTEXT)
DECL_WINELIB_TYPE_AW(NPLOGCONTEXT)
DECL_WINELIB_TYPE_AW(LPLOGCONTEXT)
/* context option values */
#define CXO_SYSTEM 0x0001
#define CXO_PEN 0x0002
#define CXO_MESSAGES 0x0004
#define CXO_MARGIN 0x8000
#define CXO_MGNINSIDE 0x4000
#define CXO_CSRMESSAGES 0x0008 /* 1.1 */
/* context status values */
#define CXS_DISABLED 0x0001
#define CXS_OBSCURED 0x0002
#define CXS_ONTOP 0x0004
/* context lock values */
#define CXL_INSIZE 0x0001
#define CXL_INASPECT 0x0002
#define CXL_SENSITIVITY 0x0004
#define CXL_MARGIN 0x0008
#define CXL_SYSOUT 0x0010
/***********************************************************************
* EVENT DATA DEFS
*/
/* For packet structure definition, see pktdef.h */
/* packet status values */
#define TPS_PROXIMITY 0x0001
#define TPS_QUEUE_ERR 0x0002
#define TPS_MARGIN 0x0004
#define TPS_GRAB 0x0008
#define TPS_INVERT 0x0010 /* 1.1 */
typedef struct tagORIENTATION {
int orAzimuth;
int orAltitude;
int orTwist;
} ORIENTATION, *PORIENTATION, *NPORIENTATION, *LPORIENTATION;
typedef struct tagROTATION { /* 1.1 */
int roPitch;
int roRoll;
int roYaw;
} ROTATION, *PROTATION, *NPROTATION, *LPROTATION;
/* grandfather in obsolete member names. */
#define rotPitch roPitch
#define rotRoll roRoll
#define rotYaw roYaw
/* relative buttons */
#define TBN_NONE 0
#define TBN_UP 1
#define TBN_DOWN 2
/***********************************************************************
* DEVICE CONFIG CONSTANTS
*/
#ifndef NOWTDEVCFG
#define WTDC_NONE 0
#define WTDC_CANCEL 1
#define WTDC_OK 2
#define WTDC_RESTART 3
#endif
/***********************************************************************
* HOOK CONSTANTS
*/
#ifndef NOWTHOOKS
#define WTH_PLAYBACK 1
#define WTH_RECORD 2
#define WTHC_GETLPLPFN (-3)
#define WTHC_LPLPFNNEXT (-2)
#define WTHC_LPFNNEXT (-1)
#define WTHC_ACTION 0
#define WTHC_GETNEXT 1
#define WTHC_SKIP 2
#endif
/***********************************************************************
* PREFERENCE FUNCTION CONSTANTS
*/
#ifndef NOWTPREF
#define WTP_LPDEFAULT ((LPVOID)-1L)
#define WTP_DWDEFAULT ((DWORD)-1L)
#endif
/***********************************************************************
* EXTENSION TAGS AND CONSTANTS
*/
#ifndef NOWTEXTENSIONS
/* constants for use with pktdef.h */
#define PKEXT_ABSOLUTE 1
#define PKEXT_RELATIVE 2
/* Extension tags. */
#define WTX_OBT 0 /* Out of bounds tracking */
#define WTX_FKEYS 1 /* Function keys */
#define WTX_TILT 2 /* Raw Cartesian tilt; 1.1 */
#define WTX_CSRMASK 3 /* select input by cursor type; 1.1 */
#define WTX_XBTNMASK 4 /* Extended button mask; 1.1 */
typedef struct tagXBTNMASK {
BYTE xBtnDnMask[32];
BYTE xBtnUpMask[32];
} XBTNMASK;
typedef struct tagTILT { /* 1.1 */
int tiltX;
int tiltY;
} TILT;
#endif
/***********************************************************************
* Functions
*/
#ifndef NOWTCALLBACKS
#ifndef NOWTMANAGERFXNS
/* callback function types */
typedef BOOL (WINAPI * WTENUMPROC)(HCTX, LPARAM); /* changed CALLBACK->WINAPI, 1.1 */
typedef BOOL (WINAPI * WTCONFIGPROC)(HCTX, HWND);
typedef LRESULT (WINAPI * WTHOOKPROC)(int, WPARAM, LPARAM);
typedef WTHOOKPROC *LPWTHOOKPROC;
#endif
#endif
#ifndef NOWTFUNCTIONS
#ifndef NOWTBASICFXNS
/* BASIC FUNCTIONS */
#define ORD_WTInfoA 20
#define ORD_WTInfoW 1020
#define ORD_WTInfo WINELIB_NAME_AW(ORD_WTInfo)
#define ORD_WTOpenA 21
#define ORD_WTOpenW 1021
#define ORD_WTOpen WINELIB_NAME_AW(ORD_WTOpen)
#define ORD_WTClose 22
#define ORD_WTPacketsGet 23
#define ORD_WTPacket 24
UINT WINAPI WTInfoA(UINT, UINT, LPVOID);
UINT WINAPI WTInfoW(UINT, UINT, LPVOID);
#define WTInfo WINELIB_NAME_AW(WTInfo)
HCTX WINAPI WTOpenA(HWND, LPLOGCONTEXTA, BOOL);
HCTX WINAPI WTOpenW(HWND, LPLOGCONTEXTW, BOOL);
#define WTOpen WINELIB_NAME_AW(WTOpen)
BOOL WINAPI WTClose(HCTX);
int WINAPI WTPacketsGet(HCTX, int, LPVOID);
BOOL WINAPI WTPacket(HCTX, UINT, LPVOID);
#endif
#ifndef NOWTVISIBILITYFXNS
/* VISIBILITY FUNCTIONS */
#define ORD_WTEnable 40
#define ORD_WTOverlap 41
BOOL WINAPI WTEnable(HCTX, BOOL);
BOOL WINAPI WTOverlap(HCTX, BOOL);
#endif
#ifndef NOWTCTXEDITFXNS
/* CONTEXT EDITING FUNCTIONS */
#define ORD_WTConfig 60
#define ORD_WTGetA 61
#define ORD_WTGetW 1061
#define ORD_WTGet WINELIB_NAME_AW(ORD_WTGet)
#define ORD_WTSetA 62
#define ORD_WTSetW 1062
#define ORD_WTSet WINELIB_NAME_AW(ORD_WTSet)
#define ORD_WTExtGet 63
#define ORD_WTExtSet 64
#define ORD_WTSave 65
#define ORD_WTRestore 66
BOOL WINAPI WTConfig(HCTX, HWND);
BOOL WINAPI WTGetA(HCTX, LPLOGCONTEXTA);
BOOL WINAPI WTGetW(HCTX, LPLOGCONTEXTW);
#define WTGet WINELIB_NAME_AW(WTGet)
BOOL WINAPI WTSetA(HCTX, LPLOGCONTEXTA);
BOOL WINAPI WTSetW(HCTX, LPLOGCONTEXTW);
#define WTSet WINELIB_NAME_AW(WTSet)
BOOL WINAPI WTExtGet(HCTX, UINT, LPVOID);
BOOL WINAPI WTExtSet(HCTX, UINT, LPVOID);
BOOL WINAPI WTSave(HCTX, LPVOID);
HCTX WINAPI WTRestore(HWND, LPVOID, BOOL);
#endif
#ifndef NOWTQUEUEFXNS
/* ADVANCED PACKET AND QUEUE FUNCTIONS */
#define ORD_WTPacketsPeek 80
#define ORD_WTDataGet 81
#define ORD_WTDataPeek 82
#define ORD_WTQueueSizeGet 84
#define ORD_WTQueueSizeSet 85
int WINAPI WTPacketsPeek(HCTX, int, LPVOID);
int WINAPI WTDataGet(HCTX, UINT, UINT, int, LPVOID, LPINT);
int WINAPI WTDataPeek(HCTX, UINT, UINT, int, LPVOID, LPINT);
int WINAPI WTQueueSizeGet(HCTX);
BOOL WINAPI WTQueueSizeSet(HCTX, int);
#endif
#ifndef NOWTHMGRFXNS
/* MANAGER HANDLE FUNCTIONS */
#define ORD_WTMgrOpen 100
#define ORD_WTMgrClose 101
HMGR WINAPI WTMgrOpen(HWND, UINT);
BOOL WINAPI WTMgrClose(HMGR);
#endif
#ifndef NOWTMGRCTXFXNS
/* MANAGER CONTEXT FUNCTIONS */
#define ORD_WTMgrContextEnum 120
#define ORD_WTMgrContextOwner 121
#define ORD_WTMgrDefContext 122
#define ORD_WTMgrDefContextEx 206
BOOL WINAPI WTMgrContextEnum(HMGR, WTENUMPROC, LPARAM);
HWND WINAPI WTMgrContextOwner(HMGR, HCTX);
HCTX WINAPI WTMgrDefContext(HMGR, BOOL);
HCTX WINAPI WTMgrDefContextEx(HMGR, UINT, BOOL); /* 1.1 */
#endif
#ifndef NOWTMGRCONFIGFXNS
/* MANAGER CONFIG BOX FUNCTIONS */
#define ORD_WTMgrDeviceConfig 140
UINT WINAPI WTMgrDeviceConfig(HMGR, UINT, HWND);
#endif
#ifndef NOWTMGRHOOKFXNS
/* MANAGER PACKET HOOK FUNCTIONS */
/* OBSOLETE IN WIN32! */
#endif
#ifndef NOWTMGRPREFFXNS
/* MANAGER PREFERENCE DATA FUNCTIONS */
#define ORD_WTMgrExt 180
#define ORD_WTMgrCsrEnable 181
#define ORD_WTMgrCsrButtonMap 182
#define ORD_WTMgrCsrPressureBtnMarks 183
#define ORD_WTMgrCsrPressureResponse 184
#define ORD_WTMgrCsrExt 185
BOOL WINAPI WTMgrExt(HMGR, UINT, LPVOID);
BOOL WINAPI WTMgrCsrEnable(HMGR, UINT, BOOL);
BOOL WINAPI WTMgrCsrButtonMap(HMGR, UINT, LPBYTE, LPBYTE);
BOOL WINAPI WTMgrCsrPressureBtnMarks(HMGR, UINT, DWORD, DWORD);
BOOL WINAPI WTMgrCsrPressureResponse(HMGR, UINT, UINT *, UINT *);
BOOL WINAPI WTMgrCsrExt(HMGR, UINT, UINT, LPVOID);
#endif
/***********************************************************************
* Win32 replacements for non-portable functions.
*/
#ifndef NOWTQUEUEFXNS
/* ADVANCED PACKET AND QUEUE FUNCTIONS */
#define ORD_WTQueuePacketsEx 200
BOOL WINAPI WTQueuePacketsEx(HCTX, UINT *, UINT *);
#endif
#ifndef NOWTMGRCONFIGFXNS
/* MANAGER CONFIG BOX FUNCTIONS */
#define ORD_WTMgrConfigReplaceExA 202
#define ORD_WTMgrConfigReplaceExW 1202
#define ORD_WTMgrConfigReplaceEx WINELIB_NAME_AW(ORD_WTMgrConfigReplaceEx)
BOOL WINAPI WTMgrConfigReplaceExA(HMGR, BOOL, LPSTR, LPSTR);
BOOL WINAPI WTMgrConfigReplaceExW(HMGR, BOOL, LPWSTR, LPSTR);
#define WTMgrConfigReplaceEx WINELIB_NAME_AW(WTMgrConfigReplaceEx)
#endif
#ifndef NOWTMGRHOOKFXNS
/* MANAGER PACKET HOOK FUNCTIONS */
#define ORD_WTMgrPacketHookExA 203
#define ORD_WTMgrPacketHookExW 1203
#define ORD_WTMgrPacketHookEx WINELIB_NAME_AW(ORD_WTMgrPacketHookEx)
#define ORD_WTMgrPacketUnhook 204
#define ORD_WTMgrPacketHookNext 205
HWTHOOK WINAPI WTMgrPacketHookExA(HMGR, int, LPSTR, LPSTR);
HWTHOOK WINAPI WTMgrPacketHookExW(HMGR, int, LPWSTR, LPSTR);
#define WTMgrPacketHookEx WINELIB_NAME_AW(WTMgrPacketHookEx)
BOOL WINAPI WTMgrPacketUnhook(HWTHOOK);
LRESULT WINAPI WTMgrPacketHookNext(HWTHOOK, int, WPARAM, LPARAM);
#endif
#ifndef NOWTMGRPREFFXNS
/* MANAGER PREFERENCE DATA FUNCTIONS */
#define ORD_WTMgrCsrPressureBtnMarksEx 201
BOOL WINAPI WTMgrCsrPressureBtnMarksEx(HMGR, UINT, UINT *, UINT *);
#endif
#endif
#ifdef __cplusplus
} /* extern "C" */
#endif /* defined(__cplusplus) */
#endif /* defined(__WINE_WINTAB_H */

130
include/wintabx.h Normal file
View File

@ -0,0 +1,130 @@
/*
* Copyright (C) 1991-1998 by LCS/Telegraphics
* Copyright (C) 2002 Patrik Stridvall
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __WINE_WINTABX_H
#define __WINE_WINTABX_H
#ifdef __cplusplus
extern "C" {
#endif /* defined(__cplusplus) */
/***********************************************************************
* Wintab message crackers
*/
#ifndef HANDLE_MSG
# define HANDLE_MSG(hwnd, message, fn) \
case (message): return HANDLE_##message((hwnd), (wParam), (lParam), (fn))
#endif
/* void Cls_OnWintabPacket(HWND hwnd, HCTX hCtx, UINT sn) */
#define HANDLE_WT_PACKET(hwnd, wParam, lParam, fn) \
((fn)((hwnd), (HCTX)(lParam), (UINT)(wParam)), 0L)
#define FORWARD__WT_PACKET(hwnd, bs, hCtx, sn, fn) \
(void)(fn)((hwnd), _WT_PACKET(bs), (WPARAM)(UINT)(sn), (LPARAM)(HCTX)(hCtx))
#define FORWARD_WT_PACKET(hwnd, hCtx, sn, fn) \
FORWARD__WT_PACKET(hwnd, WT_DEFBASE, hCtx, sn, fn)
/* void Cls_OnWintabCtxOpen(HWND hwnd, HCTX hCtx, UINT sf) */
#define HANDLE_WT_CTXOPEN(hwnd, wParam, lParam, fn) \
((fn)((hwnd), (HCTX)(wParam), (UINT)(lParam)), 0L)
#define FORWARD__WT_CTXOPEN(hwnd, bs, hCtx, sf, fn) \
(void)(fn)((hwnd), _WT_CTXOPEN(bs), (WPARAM)(HCTX)(hCtx), (LPARAM)(UINT)(sf))
#define FORWARD_WT_CTXOPEN(hwnd, hCtx, sf, fn) \
FORWARD__WT_CTXOPEN(hwnd, WT_DEFBASE, hCtx, sf, fn)
/* void Cls_OnWintabCtxClose(HWND hwnd, HCTX hCtx, UINT sf) */
#define HANDLE_WT_CTXCLOSE(hwnd, wParam, lParam, fn) \
((fn)((hwnd), (HCTX)(wParam), (UINT)(lParam)), 0L)
#define FORWARD__WT_CTXCLOSE(hwnd, bs, hCtx, sf, fn) \
(void)(fn)((hwnd), _WT_CTXCLOSE(bs), (WPARAM)(HCTX)(hCtx), (LPARAM)(UINT)(sf))
#define FORWARD_WT_CTXCLOSE(hwnd, hCtx, sf, fn) \
FORWARD__WT_CTXCLOSE(hwnd, WT_DEFBASE, hCtx, sf, fn)
/* void Cls_OnWintabCtxUpdate(HWND hwnd, HCTX hCtx, UINT sf) */
#define HANDLE_WT_CTXUPDATE(hwnd, wParam, lParam, fn) \
((fn)((hwnd), (HCTX)(wParam), (UINT)(lParam)), 0L)
#define FORWARD__WT_CTXUPDATE(hwnd, bs, hCtx, sf, fn) \
(void)(fn)((hwnd), _WT_CTXUPDATE(bs), (WPARAM)(HCTX)(hCtx), (LPARAM)(UINT)(sf))
#define FORWARD_WT_CTXUPDATE(hwnd, hCtx, sf, fn) \
FORWARD__WT_CTXUPDATE(hwnd, WT_DEFBASE, hCtx, sf, fn)
/* void Cls_OnWintabCtxOverlap(HWND hwnd, HCTX hCtx, UINT sf) */
#define HANDLE_WT_CTXOVERLAP(hwnd, wParam, lParam, fn) \
((fn)((hwnd), (HCTX)(wParam), (UINT)(lParam)), 0L)
#define FORWARD__WT_CTXOVERLAP(hwnd, bs, hCtx, sf, fn) \
(void)(fn)((hwnd), _WT_CTXOVERLAP(bs), (WPARAM)(HCTX)(hCtx), (LPARAM)(UINT)(sf))
#define FORWARD_WT_CTXOVERLAP(hwnd, hCtx, sf, fn) \
FORWARD__WT_CTXOVERLAP(hwnd, WT_DEFBASE, hCtx, sf, fn)
/* void Cls_OnWintabProximity(HWND hwnd, HCTX hCtx, BOOL cp, BOOL hp) */
#define HANDLE_WT_PROXIMITY(hwnd, wParam, lParam, fn) \
((fn)((hwnd), (HCTX)(wParam), (BOOL)LOWORD(lParam), (BOOL)HIWORD(lParam)), 0L)
#define FORWARD__WT_PROXIMITY(hwnd, bs, hCtx, cp, hp, fn) \
(void)(fn)((hwnd), _WT_PROXIMITY(bs), (WPARAM)(HCTX)(hCtx), MAKELPARAM((cp), (hp))
#define FORWARD_WT_PROXIMITY(hwnd, hCtx, sf, fn) \
FORWARD__WT_PROXIMITY(hwnd, WT_DEFBASE, hCtx, cp, hp, fn)
/* void Cls_OnWintabInfoChange(HWND hwnd, HMGR hMgr, UINT c, UINT i) */
#define HANDLE_WT_INFOCHANGE(hwnd, wParam, lParam, fn) \
((fn)((hwnd), (HMGR)(wParam), (UINT)LOWORD(lParam), (UINT)HIWORD(lParam)), 0L)
#define FORWARD__WT_INFOCHANGE(hwnd, bs, hMgr, cp, hp, fn) \
(void)(fn)((hwnd), _WT_INFOCHANGE(bs), (WPARAM)(HMGR)(hMgr), MAKELPARAM((c), (i))
#define FORWARD_WT_INFOCHANGE(hwnd, hMgr, sf, fn) \
FORWARD__WT_INFOCHANGE(hwnd, WT_DEFBASE, hMgr, cp, hp, fn)
/***********************************************************************
* Alternate porting layer macros
*/
#define GET_WT_PACKET_HCTX(wp, lp) ((HCTX)lp)
#define GET_WT_PACKET_SERIAL(wp, lp) (wp)
#define GET_WT_PACKET_MPS(h, s) (s), (LPARAM)(h)
#define GET_WT_CTXOPEN_HCTX(wp, lp) ((HCTX)wp)
#define GET_WT_CTXOPEN_STATUS(wp, lp) ((UINT)lp)
#define GET_WT_CTXOPEN_MPS(h, s) (WPARAM)(h), (LPARAM)(s)
#define GET_WT_CTXCLOSE_HCTX(wp, lp) ((HCTX)wp)
#define GET_WT_CTXCLOSE_STATUS(wp, lp) ((UINT)lp)
#define GET_WT_CTXCLOSE_MPS(h, s) (WPARAM)(h), (LPARAM)(s)
#define GET_WT_CTXUPDATE_HCTX(wp, lp) ((HCTX)wp)
#define GET_WT_CTXUPDATE_STATUS(wp, lp) ((UINT)lp)
#define GET_WT_CTXUPDATE_MPS(h, s) (WPARAM)(h), (LPARAM)(s)
#define GET_WT_CTXOVERLAP_HCTX(wp, lp) ((HCTX)wp)
#define GET_WT_CTXOVERLAP_STATUS(wp, lp) ((UINT)lp)
#define GET_WT_CTXOVERLAP_MPS(h, s) (WPARAM)(h), (LPARAM)(s)
#define GET_WT_PROXIMITY_HCTX(wp, lp) ((HCTX)wp)
#define GET_WT_PROXIMITY_CTXPROX(wp, lp) LOWORD(lp)
#define GET_WT_PROXIMITY_HARDPROX(wp, lp) HIWORD(lp)
#define GET_WT_PROXIMITY_MPS(h, fc, fh) (WPARAM)(h), MAKELONG(fc, fh)
#define GET_WT_INFOCHANGE_HMGR(wp, lp) ((HMGR)wp)
#define GET_WT_INFOCHANGE_CATEGORY(wp, lp) LOWORD(lp)
#define GET_WT_INFOCHANGE_INDEX(wp, lp) HIWORD(lp)
#define GET_WT_INFOCHANGE_MPS(h, c, i) (WPARAM)(h), MAKELONG(c, i)
#ifdef __cplusplus
} /* extern "C" */
#endif /* defined(__cplusplus) */
#endif /* defined(__WINE_WINTABX_H */