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

applications for supporting tablets).

configure.ac

@@ -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

dlls/Makefile.in

@@ -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)

dlls/wintab32/.cvsignore

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

dlls/wintab32/Makefile.in

@@ -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:

dlls/wintab32/context.c

@@ -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;
+}

dlls/wintab32/manager.c

@@ -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;
+}

dlls/wintab32/wintab.spec

@@ -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

dlls/wintab32/wintab16.c

@@ -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;
+}

dlls/wintab32/wintab32.spec

@@ -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

include/Makefile.in

@@ -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 \

include/pktdef.h

@@ -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 */

include/wintab.h

@@ -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 */

include/wintabx.h

@@ -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 */