diff --git a/configure b/configure
index aeff6d6..eb039b4 100755
--- a/configure
+++ b/configure
@@ -7410,9 +7410,11 @@
 
 
 
+
 for ac_header in X11/XKBlib.h \
                           X11/Xutil.h \
                           X11/extensions/shape.h \
+                          X11/extensions/XInput.h \
                           X11/extensions/XShm.h \
                           X11/extensions/Xrandr.h \
                           X11/extensions/Xrender.h \
@@ -14333,6 +14335,80 @@
 _ACEOF
 fi
 
+echo "$as_me:$LINENO: checking for -lXi soname" >&5
+echo $ECHO_N "checking for -lXi soname... $ECHO_C" >&6
+if test "${ac_cv_lib_soname_Xi+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  ac_get_soname_save_LIBS=$LIBS
+LIBS="-lXi $X_LIBS -lXext -lX11 $X_EXTRA_LIBS $LIBS"
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+
+/* Override any gcc2 internal prototype to avoid an error.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+/* We use char because int might match the return type of a gcc2
+   builtin and then its argument prototype would still apply.  */
+char XOpenDevice ();
+int
+main ()
+{
+XOpenDevice ();
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext conftest$ac_exeext
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+  (eval $ac_link) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest$ac_exeext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  ac_cv_lib_soname_Xi=`$ac_cv_path_LDD conftest$ac_exeext | grep libXi\\.so | sed 's/^.*\(libXi\.so[^	 ]*\).*$/\1/'`
+  if test "x$ac_cv_lib_soname_Xi" = "x"
+  then
+     ac_cv_lib_soname_Xi="libXi.so"
+  fi
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+ac_cv_lib_soname_Xi="libXi.so"
+fi
+rm -f conftest.err conftest.$ac_objext \
+      conftest$ac_exeext conftest.$ac_ext
+  LIBS=$ac_get_soname_save_LIBS
+fi
+echo "$as_me:$LINENO: result: $ac_cv_lib_soname_Xi" >&5
+echo "${ECHO_T}$ac_cv_lib_soname_Xi" >&6
+if test "x$ac_cv_lib_soname_Xi" != xNONE
+then
+cat >>confdefs.h <<_ACEOF
+#define SONAME_LIBXI "$ac_cv_lib_soname_Xi"
+_ACEOF
+fi
+
 echo "$as_me:$LINENO: checking for -lXrender soname" >&5
 echo $ECHO_N "checking for -lXrender soname... $ECHO_C" >&6
 if test "${ac_cv_lib_soname_Xrender+set}" = set; then
diff --git a/configure.ac b/configure.ac
index b641220..ed5167f 100644
--- a/configure.ac
+++ b/configure.ac
@@ -181,6 +181,7 @@
         AC_CHECK_HEADERS([X11/XKBlib.h \
                           X11/Xutil.h \
                           X11/extensions/shape.h \
+                          X11/extensions/XInput.h \
                           X11/extensions/XShm.h \
                           X11/extensions/Xrandr.h \
                           X11/extensions/Xrender.h \
@@ -989,6 +990,7 @@
 then
   WINE_GET_SONAME(X11,XCreateWindow,[$X_LIBS $X_EXTRA_LIBS])
   WINE_GET_SONAME(Xext,XextCreateExtension,[$X_LIBS -lX11 $X_EXTRA_LIBS])
+  WINE_GET_SONAME(Xi,XOpenDevice,[$X_LIBS -lXext -lX11 $X_EXTRA_LIBS])
   WINE_GET_SONAME(Xrender,XRenderQueryExtension,[$X_LIBS -lXext -lX11 $X_EXTRA_LIBS])
   WINE_GET_SONAME(freetype,FT_Init_FreeType,[$X_LIBS])
   WINE_GET_SONAME(GL,glXQueryExtension,[$X_LIBS $X_EXTRA_LIBS])
diff --git a/dlls/wintab32/Makefile.in b/dlls/wintab32/Makefile.in
index dc76768..2276728 100644
--- a/dlls/wintab32/Makefile.in
+++ b/dlls/wintab32/Makefile.in
@@ -3,14 +3,15 @@
 SRCDIR    = @srcdir@
 VPATH     = @srcdir@
 MODULE    = wintab32.dll
-IMPORTS   = kernel32
+IMPORTS   = user32 kernel32
 ALTNAMES  = wintab.dll
 
 SPEC_SRCS16 = $(ALTNAMES:.dll=.spec)
 
 C_SRCS = \
 	context.c \
-	manager.c
+	manager.c \
+	wintab32.c
 
 C_SRCS16 = \
 	wintab16.c
diff --git a/dlls/wintab32/context.c b/dlls/wintab32/context.c
index 9071837..7e41396 100644
--- a/dlls/wintab32/context.c
+++ b/dlls/wintab32/context.c
@@ -2,6 +2,7 @@
  * Tablet Context
  *
  * Copyright 2002 Patrik Stridvall
+ * Copyright 2003 CodeWeavers, Aric Stewart
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -19,29 +20,333 @@
  */
 
 #include "config.h"
-
+#include <stdio.h>
+#include <stdlib.h>
 #include <stdarg.h>
 
 #include "windef.h"
-#include "winbase.h"
 #include "winerror.h"
+#include "winbase.h"
+#include "winuser.h"
 
 #include "wintab.h"
+#include "wintab_internal.h"
 
 #include "wine/debug.h"
 
 WINE_DEFAULT_DEBUG_CHANNEL(wintab32);
 
+/*
+ * Documentation found at
+ * http://www.csl.sony.co.jp/projects/ar/restricted/wintabl.html
+ */
+
+static BOOL gLoaded;
+static LPOPENCONTEXT gOpenContexts;
+static HCTX gTopContext = (HCTX)0xc00;
+
+static char* DUMPBITS(int x, char* buf)
+{
+    strcpy(buf,"{");
+   if (x&PK_CONTEXT) strcat(buf,"PK_CONTEXT ");
+   if (x&PK_STATUS) strcat(buf, "PK_STATUS ");
+   if (x&PK_TIME) strcat(buf, "PK_TIME ");
+   if (x&PK_CHANGED) strcat(buf, "PK_CHANGED ");
+   if (x&PK_SERIAL_NUMBER) strcat(buf, "PK_SERIAL_NUMBER ");
+   if (x&PK_CURSOR) strcat(buf, "PK_CURSOR ");
+   if (x&PK_BUTTONS) strcat(buf, "PK_BUTTONS ");
+   if (x&PK_X) strcat(buf, "PK_X ");
+   if (x&PK_Y) strcat(buf, "PK_Y ");
+   if (x&PK_Z) strcat(buf, "PK_Z ");
+   if (x&PK_NORMAL_PRESSURE) strcat(buf, "PK_NORMAL_PRESSURE ");
+   if (x&PK_TANGENT_PRESSURE) strcat(buf, "PK_TANGENT_PRESSURE ");
+   if (x&PK_ORIENTATION) strcat(buf, "PK_ORIENTATION ");
+   if (x&PK_ROTATION) strcat(buf, "PK_ROTATION ");
+    strcat(buf, "}");
+    return buf;
+}
+
+static inline void DUMPPACKET(WTPACKET packet)
+{
+    TRACE("pkContext: 0x%x pkStatus: 0x%x pkTime : 0x%x pkChanged: 0x%x pkSerialNumber: 0x%x pkCursor : %i pkButtons: %x pkX: %li pkY: %li pkZ: %li pkNormalPressure: %i pkTangentPressure: %i pkOrientation: (%i,%i,%i) pkRotation: (%i,%i,%i)\n"
+,(UINT)packet.pkContext,
+    (UINT)packet.pkStatus,
+    (UINT)packet.pkTime,
+    (UINT)packet.pkChanged,
+    packet.pkSerialNumber,
+    packet.pkCursor,
+    (UINT)packet.pkButtons,
+    packet.pkX,
+    packet.pkY,
+    packet.pkZ,
+    packet.pkNormalPressure,
+    packet.pkTangentPressure,
+    packet.pkOrientation.orAzimuth,
+        packet.pkOrientation.orAltitude, packet.pkOrientation.orTwist,
+    packet.pkRotation.roPitch,
+        packet.pkRotation.roRoll, packet.pkRotation.roYaw);
+}
+
+static inline void DUMPCONTEXT(LOGCONTEXTA lc)
+{
+        CHAR mmsg[4000];
+        CHAR bits[100];
+        CHAR bits1[100];
+        CHAR bits2[100];
+
+        sprintf(mmsg,"%s, %x, %x, %x, %x, %x, %x, %x%s, %x%s, %x%s, %x, %x, %i, %i, %i, %li ,%li, %li, %li, %li, %li,%li, %li, %li, %li, %li, %li, %i, %i, %i, %i, %i %li %li\n",
+    debugstr_a(lc.lcName), lc.lcOptions, lc.lcStatus, lc.lcLocks, lc.lcMsgBase,
+lc.lcDevice, lc.lcPktRate, (UINT)lc.lcPktData, DUMPBITS(lc.lcPktData,bits),
+(UINT)lc.lcPktMode, DUMPBITS(lc.lcPktMode,bits1), (UINT)lc.lcMoveMask,
+DUMPBITS(lc.lcMoveMask,bits2), (INT)lc.lcBtnDnMask, (INT)lc.lcBtnUpMask,
+(INT)lc.lcInOrgX, (INT)lc.lcInOrgY, (INT)lc.lcInOrgZ, lc.lcInExtX, lc.lcInExtY,
+lc.lcInExtZ, lc.lcOutOrgX, lc.lcOutOrgY, lc.lcOutOrgZ, lc.lcOutExtX,
+lc.lcOutExtY, lc.lcOutExtZ, lc.lcSensX, lc.lcSensY, lc.lcSensZ, lc.lcSysMode,
+lc.lcSysOrgX, lc.lcSysOrgY, lc.lcSysExtX, lc.lcSysExtY, lc.lcSysSensX,
+lc.lcSysSensY);
+        TRACE("context: %s",mmsg);
+}
+
+
+/* Find an open context given the handle */
+static LPOPENCONTEXT TABLET_FindOpenContext(HCTX hCtx)
+{
+    LPOPENCONTEXT ptr = gOpenContexts;
+    while (ptr)
+    {
+        if (ptr->handle == hCtx) return ptr;
+        ptr = ptr->next;
+    }
+    return NULL;
+}
+
+static void LoadTablet()
+{
+    TRACE("Initilizing the tablet to hwnd %p\n",hwndDefault);
+    gLoaded= TRUE;
+    pLoadTabletInfo(hwndDefault);
+}
+
+int TABLET_PostTabletMessage(LPOPENCONTEXT newcontext, UINT msg, WPARAM wParam,
+                             LPARAM lParam, BOOL send_always)
+{
+    if ((send_always) || (newcontext->context.lcOptions & CXO_MESSAGES))
+    {
+        TRACE("Posting message %x to %x\n",msg, (UINT)newcontext->hwndOwner);
+        return PostMessageA(newcontext->hwndOwner, msg, wParam, lParam);
+    }
+    return 0;
+}
+
+static inline DWORD ScaleForContext(DWORD In, DWORD InOrg, DWORD InExt, DWORD
+                                    OutOrg, DWORD OutExt)
+{
+    if (((InExt > 0 )&&(OutExt > 0)) || ((InExt<0) && (OutExt < 0)))
+        return ((In - InOrg) * abs(OutExt) / abs(InExt)) + OutOrg;
+    else
+        return ((abs(InExt) - (In - InOrg))*abs(OutExt) / abs(InExt)) + OutOrg;
+}
+
+LPOPENCONTEXT FindOpenContext(HWND hwnd)
+{
+    LPOPENCONTEXT ptr;
+
+    EnterCriticalSection(&csTablet);
+    ptr = gOpenContexts;
+    while (ptr)
+    {
+        TRACE("Trying Context %p (%p %p)\n",ptr->handle,hwnd,ptr->hwndOwner);
+        if (ptr->hwndOwner == hwnd) break;
+    }
+    LeaveCriticalSection(&csTablet);
+    return ptr;
+}
+
+LPOPENCONTEXT AddPacketToContextQueue(LPWTPACKET packet, HWND hwnd)
+{
+    LPOPENCONTEXT ptr=NULL;
+
+    EnterCriticalSection(&csTablet);
+
+    ptr = gOpenContexts;
+    while (ptr)
+    {
+        TRACE("Trying Queue %p (%p %p)\n", ptr->handle, hwnd, ptr->hwndOwner);
+
+        if (ptr->hwndOwner == hwnd)
+        {
+            int tgt;
+            if (!ptr->enabled)
+            {
+                ptr = ptr->next;
+                continue;
+            }
+
+            tgt = ptr->PacketsQueued;
+
+            packet->pkContext = ptr->handle;
+
+            /* translate packet data to the context */
+
+            /* Scale  as per documentation */
+            packet->pkY = ScaleForContext(packet->pkY, ptr->context.lcInOrgY,
+                                ptr->context.lcInExtY, ptr->context.lcOutOrgY,
+                                ptr->context.lcOutExtY);
+
+            packet->pkX = ScaleForContext(packet->pkX, ptr->context.lcInOrgX,
+                                ptr->context.lcInExtX, ptr->context.lcOutOrgX,
+                                ptr->context.lcOutExtX);
+
+            /* flip the Y axis */
+            if (ptr->context.lcOutExtY > 0)
+                packet->pkY = ptr->context.lcOutExtY - packet->pkY;
+
+            DUMPPACKET(*packet);
+
+            if (tgt + 1 == ptr->QueueSize)
+            {
+                TRACE("Queue Overflow %p\n",ptr->handle);
+                packet->pkStatus = TPS_QUEUE_ERR;
+            }
+            else
+            {
+                TRACE("Placed in queue %p index %i\n",ptr->handle,tgt);
+                memcpy(&ptr->PacketQueue[tgt], packet, sizeof
+                        (WTPACKET));
+                ptr->PacketsQueued++;
+
+                if (ptr->ActiveCursor != packet->pkCursor)
+                {
+                    ptr->ActiveCursor = packet->pkCursor;
+                    if (ptr->context.lcOptions & CXO_CSRMESSAGES)
+                        TABLET_PostTabletMessage(ptr, WT_CSRCHANGE,
+                          (WPARAM)packet->pkSerialNumber, (LPARAM)ptr->handle,
+                            FALSE);
+                }
+            }
+            break;
+         }
+        ptr = ptr->next;
+    }
+    LeaveCriticalSection(&csTablet);
+    TRACE("Done (%p)\n",ptr);
+    return ptr;
+}
+
+int static inline CopyTabletData(LPVOID target, LPVOID src, INT size)
+{
+    memcpy(target,src,size);
+    return(size);
+}
+
+static INT TABLET_FindPacket(LPOPENCONTEXT context, UINT wSerial,
+                                LPWTPACKET *pkt)
+{
+    int loop;
+    int index  = -1;
+    for (loop = 0; loop < context->PacketsQueued; loop++)
+        if (context->PacketQueue[loop].pkSerialNumber == wSerial)
+        {
+            index = loop;
+            *pkt = &context->PacketQueue[loop];
+            break;
+        }
+
+    TRACE("%i .. %i\n",context->PacketsQueued,index);
+
+    return index;
+}
+
+
+static LPVOID TABLET_CopyPacketData(LPOPENCONTEXT context, LPVOID lpPkt,
+                                    LPWTPACKET wtp)
+{
+    LPBYTE ptr;
+    CHAR bits[100];
+
+    ptr = lpPkt;
+    TRACE("Packet Bits %s\n",DUMPBITS(context->context.lcPktData,bits));
+
+    if (context->context.lcPktData & PK_CONTEXT)
+        ptr+=CopyTabletData(ptr,&wtp->pkContext,sizeof(HCTX));
+    if (context->context.lcPktData & PK_STATUS)
+        ptr+=CopyTabletData(ptr,&wtp->pkStatus,sizeof(UINT));
+    if (context->context.lcPktData & PK_TIME)
+        ptr+=CopyTabletData(ptr,&wtp->pkTime,sizeof(LONG));
+    if (context->context.lcPktData & PK_CHANGED)
+        ptr+=CopyTabletData(ptr,&wtp->pkChanged,sizeof(WTPKT));
+    if (context->context.lcPktData & PK_SERIAL_NUMBER)
+        ptr+=CopyTabletData(ptr,&wtp->pkChanged,sizeof(UINT));
+    if (context->context.lcPktData & PK_CURSOR)
+        ptr+=CopyTabletData(ptr,&wtp->pkCursor,sizeof(UINT));
+    if (context->context.lcPktData & PK_BUTTONS)
+        ptr+=CopyTabletData(ptr,&wtp->pkButtons,sizeof(DWORD));
+    if (context->context.lcPktData & PK_X)
+        ptr+=CopyTabletData(ptr,&wtp->pkX,sizeof(DWORD));
+    if (context->context.lcPktData & PK_Y)
+        ptr+=CopyTabletData(ptr,&wtp->pkY,sizeof(DWORD));
+    if (context->context.lcPktData & PK_Z)
+        ptr+=CopyTabletData(ptr,&wtp->pkZ,sizeof(DWORD));
+    if (context->context.lcPktData & PK_NORMAL_PRESSURE)
+        ptr+=CopyTabletData(ptr,&wtp->pkNormalPressure,sizeof(UINT));
+    if (context->context.lcPktData & PK_TANGENT_PRESSURE)
+        ptr+=CopyTabletData(ptr,&wtp->pkTangentPressure,sizeof(UINT));
+    if (context->context.lcPktData & PK_ORIENTATION)
+        ptr+=CopyTabletData(ptr,&wtp->pkOrientation,sizeof(ORIENTATION));
+    if (context->context.lcPktData & PK_ROTATION)
+        ptr+=CopyTabletData(ptr,&wtp->pkRotation,sizeof(ROTATION));
+
+    /*TRACE("Copied %i bytes\n",(INT)ptr - (INT)lpPkt); */
+    return ptr;
+}
+
+static VOID TABLET_BlankPacketData(LPOPENCONTEXT context, LPVOID lpPkt, INT n)
+{
+    int rc = 0;
+
+    if (context->context.lcPktData & PK_CONTEXT)
+        rc +=sizeof(HCTX);
+    if (context->context.lcPktData & PK_STATUS)
+        rc +=sizeof(UINT);
+    if (context->context.lcPktData & PK_TIME)
+        rc += sizeof(LONG);
+    if (context->context.lcPktData & PK_CHANGED)
+        rc += sizeof(WTPKT);
+    if (context->context.lcPktData & PK_SERIAL_NUMBER)
+        rc += sizeof(UINT);
+    if (context->context.lcPktData & PK_CURSOR)
+        rc += sizeof(UINT);
+    if (context->context.lcPktData & PK_BUTTONS)
+        rc += sizeof(DWORD);
+    if (context->context.lcPktData & PK_X)
+        rc += sizeof(DWORD);
+    if (context->context.lcPktData & PK_Y)
+        rc += sizeof(DWORD);
+    if (context->context.lcPktData & PK_Z)
+        rc += sizeof(DWORD);
+    if (context->context.lcPktData & PK_NORMAL_PRESSURE)
+        rc += sizeof(UINT);
+    if (context->context.lcPktData & PK_TANGENT_PRESSURE)
+        rc += sizeof(UINT);
+    if (context->context.lcPktData & PK_ORIENTATION)
+        rc += sizeof(ORIENTATION);
+    if (context->context.lcPktData & PK_ROTATION)
+        rc += sizeof(ROTATION);
+
+    rc *= n;
+    memset(lpPkt,0,rc);
+}
+
+
 /***********************************************************************
  *		WTInfoA (WINTAB32.20)
  */
 UINT WINAPI WTInfoA(UINT wCategory, UINT nIndex, LPVOID lpOutput)
 {
-    FIXME("(%u, %u, %p): stub\n", wCategory, nIndex, lpOutput);
+    if (gLoaded == FALSE)
+         LoadTablet();
 
-    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
-
-    return 0;
+    return pWTInfoA( wCategory, nIndex, lpOutput );
 }
 
 /***********************************************************************
@@ -61,11 +366,38 @@
  */
 HCTX WINAPI WTOpenA(HWND hWnd, LPLOGCONTEXTA lpLogCtx, BOOL fEnable)
 {
-    FIXME("(%p, %p, %u): stub\n", hWnd, lpLogCtx, fEnable);
+    LPOPENCONTEXT newcontext;
 
-    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+    TRACE("(%p, %p, %u)\n", hWnd, lpLogCtx, fEnable);
+    DUMPCONTEXT(*lpLogCtx);
 
-    return NULL;
+    newcontext = HeapAlloc(GetProcessHeap(), 0 , sizeof(OPENCONTEXT));
+    memcpy(&(newcontext->context),lpLogCtx,sizeof(LOGCONTEXTA));
+    newcontext->hwndOwner = hWnd;
+    newcontext->enabled = fEnable;
+    newcontext->ActiveCursor = -1;
+    newcontext->QueueSize = 10;
+    newcontext->PacketsQueued = 0;
+    newcontext->PacketQueue=HeapAlloc(GetProcessHeap(),0,sizeof(WTPACKET)*10);
+
+    EnterCriticalSection(&csTablet);
+    newcontext->handle = gTopContext++;
+    newcontext->next = gOpenContexts;
+    gOpenContexts = newcontext;
+    LeaveCriticalSection(&csTablet);
+
+    pAttachEventQueueToTablet(hWnd);
+
+    TABLET_PostTabletMessage(newcontext, WT_CTXOPEN, (WPARAM)newcontext->handle,
+                      newcontext->context.lcStatus, TRUE);
+
+    newcontext->context.lcStatus = CXS_ONTOP;
+
+    TABLET_PostTabletMessage(newcontext, WT_CTXOVERLAP,
+                            (WPARAM)newcontext->handle,
+                            newcontext->context.lcStatus, TRUE);
+
+    return newcontext->handle;
 }
 
 /***********************************************************************
@@ -85,9 +417,37 @@
  */
 BOOL WINAPI WTClose(HCTX hCtx)
 {
-    FIXME("(%p): stub\n", hCtx);
+    LPOPENCONTEXT context,ptr;
 
-    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+    TRACE("(%p)\n", hCtx);
+
+    EnterCriticalSection(&csTablet);
+
+    ptr = context = gOpenContexts;
+
+    while (context && (context->handle != hCtx))
+    {
+        ptr = context;
+        context = context->next;
+    }
+    if (!context)
+    {
+        LeaveCriticalSection(&csTablet);
+        return TRUE;
+    }
+
+    if (context == gOpenContexts)
+        gOpenContexts = context->next;
+    else
+        ptr->next = context->next;
+
+    LeaveCriticalSection(&csTablet);
+
+    TABLET_PostTabletMessage(context, WT_CTXCLOSE, (WPARAM)context->handle,
+                      context->context.lcStatus,TRUE);
+
+    HeapFree(GetProcessHeap(),0,context->PacketQueue);
+    HeapFree(GetProcessHeap(),0,context);
 
     return TRUE;
 }
@@ -97,11 +457,39 @@
  */
 int WINAPI WTPacketsGet(HCTX hCtx, int cMaxPkts, LPVOID lpPkts)
 {
-    FIXME("(%p, %d, %p): stub\n", hCtx, cMaxPkts, lpPkts);
+    int limit;
+    LPOPENCONTEXT context;
+    LPVOID ptr = lpPkts;
 
-    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+    TRACE("(%p, %d, %p)\n", hCtx, cMaxPkts, lpPkts);
 
-    return 0;
+    if (!hCtx || !lpPkts) return 0;
+
+    EnterCriticalSection(&csTablet);
+
+    context = TABLET_FindOpenContext(hCtx);
+    TABLET_BlankPacketData(context,lpPkts,cMaxPkts);
+
+    if (context->PacketsQueued == 0)
+    {
+        LeaveCriticalSection(&csTablet);
+        return 0;
+    }
+
+    for(limit = 0; limit < cMaxPkts && limit < context->PacketsQueued; limit++)
+        ptr=TABLET_CopyPacketData(context ,ptr, &context->PacketQueue[limit]);
+
+    if (limit < context->PacketsQueued)
+    {
+        memcpy(context->PacketQueue, &context->PacketQueue[limit],
+            (context->QueueSize - (limit))*sizeof(WTPACKET));
+    }
+    context->PacketsQueued -= limit;
+    LeaveCriticalSection(&csTablet);
+
+    TRACE("Copied %i packets\n",limit);
+
+    return limit;
 }
 
 /***********************************************************************
@@ -109,11 +497,36 @@
  */
 BOOL WINAPI WTPacket(HCTX hCtx, UINT wSerial, LPVOID lpPkt)
 {
-    FIXME("(%p, %d, %p): stub\n", hCtx, wSerial, lpPkt);
+    int rc = 0;
+    LPOPENCONTEXT context;
+    LPWTPACKET    wtp;
 
-    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+    TRACE("(%p, %d, %p)\n", hCtx, wSerial, lpPkt);
 
-    return FALSE;
+    if (!hCtx) return 0;
+
+    EnterCriticalSection(&csTablet);
+
+    context = TABLET_FindOpenContext(hCtx);
+
+    rc = TABLET_FindPacket(context ,wSerial, &wtp);
+
+    if (rc >= 0)
+    {
+        if (lpPkt)
+           TABLET_CopyPacketData(context ,lpPkt, wtp);
+
+        if ((rc+1) < context->QueueSize)
+        {
+            memcpy(context->PacketQueue, &context->PacketQueue[rc+1],
+                (context->QueueSize - (rc+1))*sizeof(WTPACKET));
+        }
+        context->PacketsQueued -= (rc+1);
+    }
+    LeaveCriticalSection(&csTablet);
+
+    TRACE("Returning %i\n",rc+1);
+    return rc+1;
 }
 
 /***********************************************************************
@@ -121,11 +534,18 @@
  */
 BOOL WINAPI WTEnable(HCTX hCtx, BOOL fEnable)
 {
-    FIXME("(%p, %u): stub\n", hCtx, fEnable);
+    LPOPENCONTEXT context;
 
-    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+    TRACE("(%p, %u)\n", hCtx, fEnable);
 
-    return FALSE;
+    if (!hCtx) return 0;
+
+    EnterCriticalSection(&csTablet);
+    context = TABLET_FindOpenContext(hCtx);
+    context->enabled = fEnable;
+    LeaveCriticalSection(&csTablet);
+
+    return TRUE;
 }
 
 /***********************************************************************
@@ -135,9 +555,7 @@
 {
     FIXME("(%p, %u): stub\n", hCtx, fToTop);
 
-    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
-
-    return FALSE;
+    return TRUE;
 }
 
 /***********************************************************************
@@ -157,11 +575,18 @@
  */
 BOOL WINAPI WTGetA(HCTX hCtx, LPLOGCONTEXTA lpLogCtx)
 {
-    FIXME("(%p, %p): stub\n", hCtx, lpLogCtx);
+    LPOPENCONTEXT context;
 
-    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+    TRACE("(%p, %p)\n", hCtx, lpLogCtx);
 
-    return FALSE;
+    if (!hCtx) return 0;
+
+    EnterCriticalSection(&csTablet);
+    context = TABLET_FindOpenContext(hCtx);
+    memcpy(lpLogCtx,&context->context,sizeof(LOGCONTEXTA));
+    LeaveCriticalSection(&csTablet);
+
+    return TRUE;
 }
 
 /***********************************************************************
@@ -253,11 +678,30 @@
  */
 int WINAPI WTPacketsPeek(HCTX hCtx, int cMaxPkts, LPVOID lpPkts)
 {
-    FIXME("(%p, %d, %p): stub\n", hCtx, cMaxPkts, lpPkts);
+    int limit;
+    LPOPENCONTEXT context;
+    LPVOID ptr = lpPkts;
 
-    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+    TRACE("(%p, %d, %p)\n", hCtx, cMaxPkts, lpPkts);
 
-    return 0;
+    if (!hCtx || !lpPkts) return 0;
+
+    EnterCriticalSection(&csTablet);
+
+    context = TABLET_FindOpenContext(hCtx);
+
+    if (context->PacketsQueued == 0)
+    {
+        LeaveCriticalSection(&csTablet);
+        return 0;
+    }
+
+    for (limit = 0; limit < cMaxPkts && limit < context->PacketsQueued; limit++)
+        ptr = TABLET_CopyPacketData(context ,ptr, &context->PacketQueue[limit]);
+
+    LeaveCriticalSection(&csTablet);
+    TRACE("Copied %i packets\n",limit);
+    return limit;
 }
 
 /***********************************************************************
@@ -266,12 +710,56 @@
 int WINAPI WTDataGet(HCTX hCtx, UINT wBegin, UINT wEnd,
 		     int cMaxPkts, LPVOID lpPkts, LPINT lpNPkts)
 {
-    FIXME("(%p, %u, %u, %d, %p, %p): stub\n",
+    LPOPENCONTEXT context;
+    LPVOID ptr = lpPkts;
+    UINT bgn = 0;
+    UINT end = 0;
+    UINT num = 0;
+
+    TRACE("(%p, %u, %u, %d, %p, %p)\n",
 	  hCtx, wBegin, wEnd, cMaxPkts, lpPkts, lpNPkts);
 
-    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+    if (!hCtx) return 0;
 
-    return 0;
+    EnterCriticalSection(&csTablet);
+
+    context = TABLET_FindOpenContext(hCtx);
+
+    if (context->PacketsQueued == 0)
+    {
+        LeaveCriticalSection(&csTablet);
+        return 0;
+    }
+
+    while (bgn < context->PacketsQueued &&
+           context->PacketQueue[bgn].pkSerialNumber != wBegin)
+        bgn++;
+
+    end = bgn;
+    while (end < context->PacketsQueued &&
+           context->PacketQueue[end].pkSerialNumber != wEnd)
+        end++;
+
+    if (bgn == end == context->PacketsQueued)
+    {
+        LeaveCriticalSection(&csTablet);
+        return 0;
+    }
+
+    for (num = bgn; num <= end; num++)
+        ptr = TABLET_CopyPacketData(context ,ptr, &context->PacketQueue[end]);
+
+    /* remove read packets */
+    if ((end+1) < context->PacketsQueued)
+        memcpy( &context->PacketQueue[bgn], &context->PacketQueue[end+1],
+                (context->PacketsQueued - ((end-bgn)+1)) * sizeof (WTPACKET));
+
+    context->PacketsQueued -= ((end-bgn)+1);
+    *lpNPkts = ((end-bgn)+1);
+
+    LeaveCriticalSection(&csTablet);
+    TRACE("Copied %i packets\n",*lpNPkts);
+    return (end - bgn)+1;
 }
 
 /***********************************************************************
@@ -280,12 +768,51 @@
 int WINAPI WTDataPeek(HCTX hCtx, UINT wBegin, UINT wEnd,
 		      int cMaxPkts, LPVOID lpPkts, LPINT lpNPkts)
 {
-    FIXME("(%p, %u, %u, %d, %p, %p): stub\n",
+    LPOPENCONTEXT context;
+    LPVOID ptr = lpPkts;
+    UINT bgn = 0;
+    UINT end = 0;
+    UINT num = 0;
+
+    TRACE("(%p, %u, %u, %d, %p, %p)\n",
 	  hCtx, wBegin, wEnd, cMaxPkts, lpPkts, lpNPkts);
 
-    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+    if (!hCtx) return 0;
 
-    return 0;
+    EnterCriticalSection(&csTablet);
+
+    context = TABLET_FindOpenContext(hCtx);
+
+    if (context->PacketsQueued == 0)
+    {
+        LeaveCriticalSection(&csTablet);
+        return 0;
+    }
+
+    while (bgn < context->PacketsQueued &&
+           context->PacketQueue[bgn].pkSerialNumber != wBegin)
+        bgn++;
+
+    end = bgn;
+    while (end < context->PacketsQueued &&
+           context->PacketQueue[end].pkSerialNumber != wEnd)
+        end++;
+
+    if (bgn == context->PacketsQueued ||  end == context->PacketsQueued)
+    {
+        TRACE("%i %i %i \n", bgn, end, context->PacketsQueued);
+        LeaveCriticalSection(&csTablet);
+        return 0;
+    }
+
+    for (num = bgn; num <= end; num++)
+        ptr = TABLET_CopyPacketData(context ,ptr, &context->PacketQueue[end]);
+
+    *lpNPkts = ((end-bgn)+1);
+    LeaveCriticalSection(&csTablet);
+
+    TRACE("Copied %i packets\n",*lpNPkts);
+    return (end - bgn)+1;
 }
 
 /***********************************************************************
@@ -293,9 +820,28 @@
  */
 BOOL WINAPI WTQueuePacketsEx(HCTX hCtx, UINT *lpOld, UINT *lpNew)
 {
-    FIXME("(%p, %p, %p): stub\n", hCtx, lpOld, lpNew);
+    LPOPENCONTEXT context;
 
-    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+    TRACE("(%p, %p, %p)\n", hCtx, lpOld, lpNew);
+
+    if (!hCtx) return 0;
+
+    EnterCriticalSection(&csTablet);
+
+    context = TABLET_FindOpenContext(hCtx);
+
+    if (context->PacketsQueued)
+    {
+        *lpOld = context->PacketQueue[0].pkSerialNumber;
+        *lpNew = context->PacketQueue[context->PacketsQueued-1].pkSerialNumber;
+    }
+    else
+    {
+        TRACE("No packets\n");
+        LeaveCriticalSection(&csTablet);
+        return FALSE;
+    }
+    LeaveCriticalSection(&csTablet);
 
     return TRUE;
 }
@@ -305,11 +851,15 @@
  */
 int WINAPI WTQueueSizeGet(HCTX hCtx)
 {
-    FIXME("(%p): stub\n", hCtx);
+    LPOPENCONTEXT context;
+    TRACE("(%p)\n", hCtx);
 
-    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+    if (!hCtx) return 0;
 
-    return 0;
+    EnterCriticalSection(&csTablet);
+    context = TABLET_FindOpenContext(hCtx);
+    LeaveCriticalSection(&csTablet);
+    return context->QueueSize;
 }
 
 /***********************************************************************
@@ -317,9 +867,21 @@
  */
 BOOL WINAPI WTQueueSizeSet(HCTX hCtx, int nPkts)
 {
-    FIXME("(%p, %d): stub\n", hCtx, nPkts);
+    LPOPENCONTEXT context;
 
-    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+    TRACE("(%p, %d)\n", hCtx, nPkts);
 
-    return 0;
+    if (!hCtx) return 0;
+
+    EnterCriticalSection(&csTablet);
+
+    context = TABLET_FindOpenContext(hCtx);
+
+    context->PacketQueue = HeapReAlloc(GetProcessHeap(), 0,
+                        context->PacketQueue, sizeof(WTPACKET)*nPkts);
+
+    context->QueueSize = nPkts;
+    LeaveCriticalSection(&csTablet);
+
+    return nPkts;
 }
diff --git a/dlls/wintab32/wintab32.c b/dlls/wintab32/wintab32.c
new file mode 100644
index 0000000..7df0b87
--- /dev/null
+++ b/dlls/wintab32/wintab32.c
@@ -0,0 +1,148 @@
+/*
+ * WinTab32 library
+ *
+ * Copyright 2003 CodeWeavers, Aric Stewart
+ *
+ * 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 <stdarg.h>
+
+#include "windef.h"
+#include "winbase.h"
+#include "wingdi.h"
+#include "winuser.h"
+#include "winerror.h"
+#include "wintab.h"
+#include "wintab_internal.h"
+#include "wine/debug.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(wintab32);
+
+HWND hwndDefault = NULL;
+static const WCHAR
+  WC_TABLETCLASSNAME[] = {'W','i','n','e','T','a','b','l','e','t','C','l','a','s','s',0};
+CRITICAL_SECTION csTablet;
+
+int (*pLoadTabletInfo)(HWND hwnddefault) = NULL;
+int (*pGetCurrentPacket)(LPWTPACKET packet) = NULL;
+int (*pAttachEventQueueToTablet)(HWND hOwner) = NULL;
+UINT (*pWTInfoA)(UINT wCategory, UINT nIndex, LPVOID lpOutput) = NULL;
+
+static LRESULT WINAPI TABLET_WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam,
+                                          LPARAM lParam);
+
+static VOID TABLET_Register()
+{
+    WNDCLASSW wndClass;
+    ZeroMemory(&wndClass, sizeof(WNDCLASSW));
+    wndClass.style = CS_GLOBALCLASS;
+    wndClass.lpfnWndProc = TABLET_WindowProc;
+    wndClass.cbClsExtra = 0;
+    wndClass.cbWndExtra = 0;
+    wndClass.hCursor = (HCURSOR)NULL;
+    wndClass.hbrBackground = (HBRUSH)(COLOR_WINDOW +1);
+    wndClass.lpszClassName = WC_TABLETCLASSNAME;
+    RegisterClassW(&wndClass);
+}
+
+static VOID TABLET_Unregister()
+{
+    UnregisterClassW(WC_TABLETCLASSNAME, (HINSTANCE)NULL);
+}
+
+BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpReserved)
+{
+    static const WCHAR name[] = {'T','a','b','l','e','t',0};
+    HMODULE hx11drv;
+
+    TRACE("%p, %lx, %p\n",hInstDLL,fdwReason,lpReserved);
+    switch (fdwReason)
+    {
+        case DLL_PROCESS_ATTACH:
+            TRACE("Initialization\n");
+            InitializeCriticalSection(&csTablet);
+            hx11drv = GetModuleHandleA("x11drv.dll");
+            if (hx11drv)
+            {
+                pLoadTabletInfo = (void *)GetProcAddress(hx11drv, "LoadTabletInfo");
+                pAttachEventQueueToTablet = (void *)GetProcAddress(hx11drv, "AttachEventQueueToTablet");
+                pGetCurrentPacket = (void *)GetProcAddress(hx11drv, "GetCurrentPacket");
+                pWTInfoA = (void *)GetProcAddress(hx11drv, "WTInfoA");
+                TABLET_Register();
+                hwndDefault = CreateWindowW(WC_TABLETCLASSNAME, name,
+                                WS_POPUPWINDOW,0,0,0,0,0,0,hInstDLL,0);
+            }
+            else
+                return FALSE;
+            break;
+        case DLL_PROCESS_DETACH:
+            TRACE("Detaching\n");
+            if (hwndDefault)
+            {
+                DestroyWindow(hwndDefault);
+                hwndDefault = 0;
+            }
+            TABLET_Unregister();
+            DeleteCriticalSection(&csTablet);
+            break;
+    }
+    return TRUE;
+}
+
+
+/*
+ * The window proc for the default TABLET window
+ */
+static LRESULT WINAPI TABLET_WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam,
+                                          LPARAM lParam)
+{
+    TRACE("Incomming Message 0x%x  (0x%08x, 0x%08x)\n", uMsg, (UINT)wParam,
+           (UINT)lParam);
+
+    switch(uMsg)
+    {
+        case WM_NCCREATE:
+            return TRUE;
+
+        case WT_PACKET:
+            {
+                WTPACKET packet;
+                LPOPENCONTEXT handler;
+                pGetCurrentPacket(&packet);
+                handler = AddPacketToContextQueue(&packet,(HWND)lParam);
+                if (handler)
+                    TABLET_PostTabletMessage(handler, WT_PACKET,
+                                (WPARAM)packet.pkSerialNumber,
+                                (LPARAM)handler->handle, FALSE);
+                break;
+            }
+        case WT_PROXIMITY:
+            {
+                LPOPENCONTEXT handler;
+                LPARAM prox;
+                handler = FindOpenContext((HWND)lParam);
+                if (handler)
+                {
+                    prox = MAKELPARAM( wParam, 1 );
+                    TABLET_PostTabletMessage(handler, WT_PROXIMITY,
+                                        (WPARAM)handler->handle, (LPARAM)prox,
+                                        TRUE);
+                }
+                break;
+            }
+    }
+    return 0;
+}
diff --git a/dlls/wintab32/wintab_internal.h b/dlls/wintab32/wintab_internal.h
new file mode 100644
index 0000000..c8511b1
--- /dev/null
+++ b/dlls/wintab32/wintab_internal.h
@@ -0,0 +1,163 @@
+/*
+ * Tablet header
+ *
+ * Copyright 2003 CodeWeavers (Aric Stewart)
+ *
+ * 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_INTERNAL_H
+#define __WINE_WINTAB_INTERNAL_H
+
+typedef struct tagWTI_INTERFACE_INFO {
+    CHAR  WINTABID[1024];
+        /* a copy of the null-terminated tablet hardware identification string
+         * in the user buffer. This string should include make, model, and
+         * revision information in user-readable format.
+         */
+    WORD    SPECVERSION;
+        /* the specification version number. The high-order byte contains the
+         * major version number; the low-order byte contains the minor version
+         * number.
+         */
+    WORD    IMPLVERSION;
+        /* the implementation version number. The high-order byte contains the
+         * major version number; the low-order byte contains the minor version
+         * number.
+         */
+    UINT    NDEVICES;
+        /* the number of devices supported. */
+    UINT    NCURSORS;
+        /* the total number of cursor types supported. */
+    UINT    NCONTEXTS;
+        /* the number of contexts supported. */
+    UINT    CTXOPTIONS;
+        /* flags indicating which context options are supported */
+    UINT    CTXSAVESIZE;
+        /* the size of the save information returned from WTSave.*/
+    UINT    NEXTENSIONS;
+        /* the number of extension data items supported.*/
+    UINT    NMANAGERS;
+        /* the number of manager handles supported.*/
+    }WTI_INTERFACE_INFO, *LPWTI_INTERFACE_INFO;
+
+typedef struct tagWTI_STATUS_INFO{
+    UINT    CONTEXTS;
+        /* the number of contexts currently open.*/
+    UINT    SYSCTXS;
+        /* the number of system contexts currently open.*/
+    UINT    PKTRATE;
+        /* the maximum packet report rate currently being received by any
+         * context, in Hertz.
+         */
+    WTPKT   PKTDATA;
+        /* a mask indicating which packet data items are requested by at
+         * least one context.
+         */
+    UINT    MANAGERS;
+        /* the number of manager handles currently open.*/
+    BOOL    SYSTEM;
+        /* a non-zero value if system pointing is available to the whole
+         * screen; zero otherwise.
+         */
+    DWORD   BUTTONUSE;
+        /* a button mask indicating the logical buttons whose events are
+         * requested by at least one context.
+         */
+    DWORD   SYSBTNUSE;
+        /* a button mask indicating which logical buttons are assigned a system
+         * button function by the current cursor's system button map.
+         */
+} WTI_STATUS_INFO, *LPWTI_STATUS_INFO;
+
+typedef struct tagWTI_EXTENSIONS_INFO
+{
+    CHAR   NAME[256];
+        /* a unique, null-terminated string describing the extension.*/
+    UINT    TAG;
+        /* a unique identifier for the extension. */
+    WTPKT   MASK;
+        /* a mask that can be bitwise OR'ed with WTPKT-type variables to select
+         * the extension.
+         */
+    UINT    SIZE[2];
+        /* an array of two UINTs specifying the extension's size within a packet
+         * (in bytes). The first is for absolute mode; the second is for
+         * relative mode.
+         */
+    AXIS    *AXES;
+        /* an array of axis descriptions, as needed for the extension. */
+    BYTE    *DEFAULT;
+        /* the current global default data, as needed for the extension.  This
+         * data is modified via the WTMgrExt function.
+         */
+    BYTE    *DEFCONTEXT;
+    BYTE    *DEFSYSCTX;
+        /* the current default context-specific data, as needed for the
+         * extension. The indices identify the digitizing- and system-context
+         * defaults, respectively.
+         */
+    BYTE    *CURSORS;
+        /* Is the first of one or more consecutive indices, one per cursor type.
+         * Each returns the current default cursor-specific data, as need for
+         * the extension. This data is modified via the WTMgrCsrExt function.
+         */
+} WTI_EXTENSIONS_INFO, *LPWTI_EXTENSIONS_INFO;
+
+typedef struct tagWTPACKET {
+        HCTX pkContext;
+        UINT pkStatus;
+        LONG pkTime;
+        WTPKT pkChanged;
+        UINT pkSerialNumber;
+        UINT pkCursor;
+        DWORD pkButtons;
+        DWORD pkX;
+        DWORD pkY;
+        DWORD pkZ;
+        UINT pkNormalPressure;
+        UINT pkTangentPressure;
+        ORIENTATION pkOrientation;
+        ROTATION pkRotation; /* 1.1 */
+} WTPACKET, *LPWTPACKET;
+
+typedef struct tagOPENCONTEXT
+{
+    HCTX        handle;
+    LOGCONTEXTA context;
+    HWND        hwndOwner;
+    BOOL        enabled;
+    INT         ActiveCursor;
+    INT         QueueSize;
+    INT         PacketsQueued;
+    LPWTPACKET  PacketQueue;
+    struct tagOPENCONTEXT *next;
+} OPENCONTEXT, *LPOPENCONTEXT;
+
+int TABLET_PostTabletMessage(LPOPENCONTEXT newcontext, UINT msg, WPARAM wParam,
+                             LPARAM lParam, BOOL send_always);
+LPOPENCONTEXT AddPacketToContextQueue(LPWTPACKET packet, HWND hwnd);
+LPOPENCONTEXT FindOpenContext(HWND hwnd);
+
+/* X11drv functions */
+extern int (*pLoadTabletInfo)(HWND hwnddefault);
+extern int (*pGetCurrentPacket)(LPWTPACKET packet);
+extern int (*pAttachEventQueueToTablet)(HWND hOwner);
+extern UINT (*pWTInfoA)(UINT wCategory, UINT nIndex, LPVOID lpOutput);
+
+extern HWND hwndDefault;
+extern CRITICAL_SECTION csTablet;
+
+#endif /* __WINE_WINTAB_INTERNAL_H */
diff --git a/dlls/x11drv/Makefile.in b/dlls/x11drv/Makefile.in
index 240f18f..87fc20e 100644
--- a/dlls/x11drv/Makefile.in
+++ b/dlls/x11drv/Makefile.in
@@ -34,6 +34,7 @@
 	text.c \
 	window.c \
 	winpos.c \
+	wintab.c \
 	x11ddraw.c \
 	x11drv_main.c \
 	xdnd.c \
diff --git a/dlls/x11drv/event.c b/dlls/x11drv/event.c
index eea433f..c1eef95 100644
--- a/dlls/x11drv/event.c
+++ b/dlls/x11drv/event.c
@@ -274,9 +274,18 @@
   if (!hWnd && event->type != PropertyNotify && event->type != MappingNotify)
       WARN( "Got event %s for unknown Window %08lx\n",
             event_names[event->type], event->xany.window );
+  else if (event->type <= MappingNotify)
+      TRACE("Got event %s for hwnd/window %p/%lx, GetFocus()=%p\n",
+            event_names[event->type], hWnd, event->xany.window, GetFocus() );
   else
-      TRACE("Got event %s for hwnd %p\n",
-            event_names[event->type], hWnd );
+      TRACE("Got extension event for hwnd/window %p/%lx, GetFocus()=%p\n",
+            hWnd, event->xany.window, GetFocus() );
+
+  if (X11DRV_ProcessTabletEvent(hWnd, event))
+  {
+        TRACE("Return: filtered by tablet\n");
+        return;
+  }
 
   switch(event->type)
     {
diff --git a/dlls/x11drv/wintab.c b/dlls/x11drv/wintab.c
new file mode 100644
index 0000000..71fe01f
--- /dev/null
+++ b/dlls/x11drv/wintab.c
@@ -0,0 +1,1161 @@
+/*
+ * X11 tablet driver
+ *
+ * Copyright 2003 CodeWeavers (Aric Stewart)
+ *
+ * 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 "wine/port.h"
+
+#include <stdlib.h>
+
+#include "windef.h"
+#include "x11drv.h"
+#include "wine/debug.h"
+#include "wintab.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(wintab32);
+WINE_DECLARE_DEBUG_CHANNEL(event);
+
+typedef struct tagWTI_CURSORS_INFO
+{
+    CHAR   NAME[256];
+        /* a displayable zero-terminated string containing the name of the
+         * cursor.
+         */
+    BOOL    ACTIVE;
+        /* whether the cursor is currently connected. */
+    WTPKT   PKTDATA;
+        /* a bit mask indicating the packet data items supported when this
+         * cursor is connected.
+         */
+    BYTE    BUTTONS;
+        /* the number of buttons on this cursor. */
+    BYTE    BUTTONBITS;
+        /* the number of bits of raw button data returned by the hardware.*/
+    CHAR   BTNNAMES[1024]; /* FIXME: make this dynamic */
+        /* a list of zero-terminated strings containing the names of the
+         * cursor's buttons. The number of names in the list is the same as the
+         * number of buttons on the cursor. The names are separated by a single
+         * zero character; the list is terminated by two zero characters.
+         */
+    BYTE    BUTTONMAP[32];
+        /* a 32 byte array of logical button numbers, one for each physical
+         * button.
+         */
+    BYTE    SYSBTNMAP[32];
+        /* a 32 byte array of button action codes, one for each logical
+         * button.
+         */
+    BYTE    NPBUTTON;
+        /* the physical button number of the button that is controlled by normal
+         * pressure.
+         */
+    UINT    NPBTNMARKS[2];
+        /* an array of two UINTs, specifying the button marks for the normal
+         * pressure button. The first UINT contains the release mark; the second
+         * contains the press mark.
+         */
+    UINT    *NPRESPONSE;
+        /* an array of UINTs describing the pressure response curve for normal
+         * pressure.
+         */
+    BYTE    TPBUTTON;
+        /* the physical button number of the button that is controlled by
+         * tangential pressure.
+         */
+    UINT    TPBTNMARKS[2];
+        /* an array of two UINTs, specifying the button marks for the tangential
+         * pressure button. The first UINT contains the release mark; the second
+         * contains the press mark.
+         */
+    UINT    *TPRESPONSE;
+        /* an array of UINTs describing the pressure response curve for
+         * tangential pressure.
+         */
+    DWORD   PHYSID;
+         /* a manufacturer-specific physical identifier for the cursor. This
+          * value will distinguish the physical cursor from others on the same
+          * device. This physical identifier allows applications to bind
+          * functions to specific physical cursors, even if category numbers
+          * change and multiple, otherwise identical, physical cursors are
+          * present.
+          */
+    UINT    MODE;
+        /* the cursor mode number of this cursor type, if this cursor type has
+         * the CRC_MULTIMODE capability.
+         */
+    UINT    MINPKTDATA;
+        /* the minimum set of data available from a physical cursor in this
+         * cursor type, if this cursor type has the CRC_AGGREGATE capability.
+         */
+    UINT    MINBUTTONS;
+        /* the minimum number of buttons of physical cursors in the cursor type,
+         * if this cursor type has the CRC_AGGREGATE capability.
+         */
+    UINT    CAPABILITIES;
+        /* flags indicating cursor capabilities, as defined below:
+            CRC_MULTIMODE
+                Indicates this cursor type describes one of several modes of a
+                single physical cursor. Consecutive cursor type categories
+                describe the modes; the CSR_MODE data item gives the mode number
+                of each cursor type.
+            CRC_AGGREGATE
+                Indicates this cursor type describes several physical cursors
+                that cannot be distinguished by software.
+            CRC_INVERT
+                Indicates this cursor type describes the physical cursor in its
+                inverted orientation; the previous consecutive cursor type
+                category describes the normal orientation.
+         */
+    UINT    TYPE;
+        /* Manufacturer Unique id for the item type */
+} WTI_CURSORS_INFO, *LPWTI_CURSORS_INFO;
+
+
+typedef struct tagWTI_DEVICES_INFO
+{
+    CHAR   NAME[256];
+        /* a displayable null- terminated string describing the device,
+         * manufacturer, and revision level.
+         */
+    UINT    HARDWARE;
+        /* flags indicating hardware and driver capabilities, as defined
+         * below:
+            HWC_INTEGRATED:
+                Indicates that the display and digitizer share the same surface.
+            HWC_TOUCH
+                Indicates that the cursor must be in physical contact with the
+                device to report position.
+            HWC_HARDPROX
+                Indicates that device can generate events when the cursor is
+                entering and leaving the physical detection range.
+            HWC_PHYSID_CURSORS
+                Indicates that device can uniquely identify the active cursor in
+                hardware.
+         */
+    UINT    NCSRTYPES;
+        /* the number of supported cursor types.*/
+    UINT    FIRSTCSR;
+        /* the first cursor type number for the device. */
+    UINT    PKTRATE;
+        /* the maximum packet report rate in Hertz. */
+    WTPKT   PKTDATA;
+        /* a bit mask indicating which packet data items are always available.*/
+    WTPKT   PKTMODE;
+        /* a bit mask indicating which packet data items are physically
+         * relative, i.e., items for which the hardware can only report change,
+         * not absolute measurement.
+         */
+    WTPKT   CSRDATA;
+        /* a bit mask indicating which packet data items are only available when
+         * certain cursors are connected. The individual cursor descriptions
+         * must be consulted to determine which cursors return which data.
+         */
+    INT     XMARGIN;
+    INT     YMARGIN;
+    INT     ZMARGIN;
+        /* the size of tablet context margins in tablet native coordinates, in
+         * the x, y, and z directions, respectively.
+         */
+    AXIS    X;
+    AXIS    Y;
+    AXIS    Z;
+        /* the tablet's range and resolution capabilities, in the x, y, and z
+         * axes, respectively.
+         */
+    AXIS    NPRESSURE;
+    AXIS    TPRESSURE;
+        /* the tablet's range and resolution capabilities, for the normal and
+         * tangential pressure inputs, respectively.
+         */
+    AXIS    ORIENTATION[3];
+        /* a 3-element array describing the tablet's orientation range and
+         * resolution capabilities.
+         */
+    AXIS    ROTATION[3];
+        /* a 3-element array describing the tablet's rotation range and
+         * resolution capabilities.
+         */
+    CHAR   PNPID[256];
+        /* a null-terminated string containing the devices Plug and Play ID.*/
+}   WTI_DEVICES_INFO, *LPWTI_DEVICES_INFO;
+
+typedef struct tagWTPACKET {
+        HCTX pkContext;
+        UINT pkStatus;
+        LONG pkTime;
+        WTPKT pkChanged;
+        UINT pkSerialNumber;
+        UINT pkCursor;
+        DWORD pkButtons;
+        DWORD pkX;
+        DWORD pkY;
+        DWORD pkZ;
+        UINT pkNormalPressure;
+        UINT pkTangentPressure;
+        ORIENTATION pkOrientation;
+        ROTATION pkRotation; /* 1.1 */
+} WTPACKET, *LPWTPACKET;
+
+
+#ifdef HAVE_X11_EXTENSIONS_XINPUT_H
+
+#include <X11/Xlib.h>
+#include <X11/extensions/XInput.h>
+
+static int           motion_type = -1;
+static int           button_press_type = -1;
+static int           button_release_type = -1;
+static int           key_press_type = -1;
+static int           key_release_type = -1;
+static int           proximity_in_type = -1;
+static int           proximity_out_type = -1;
+
+static HWND          hwndTabletDefault;
+static WTPACKET      gMsgPacket;
+static DWORD         gSerial;
+static INT           button_state[10];
+
+#define             CURSORMAX 10
+
+static LOGCONTEXTA      gSysContext;
+static WTI_DEVICES_INFO gSysDevice;
+static WTI_CURSORS_INFO gSysCursor[CURSORMAX];
+static INT              gNumCursors;
+
+
+#ifndef SONAME_LIBXI
+#define SONAME_LIBXI "libXi.so"
+#endif
+
+/* XInput stuff */
+static void *xinput_handle;
+
+#define MAKE_FUNCPTR(f) static typeof(f) * p##f;
+MAKE_FUNCPTR(XListInputDevices)
+MAKE_FUNCPTR(XOpenDevice)
+MAKE_FUNCPTR(XQueryDeviceState)
+MAKE_FUNCPTR(XGetDeviceButtonMapping)
+MAKE_FUNCPTR(XCloseDevice)
+MAKE_FUNCPTR(XSelectExtensionEvent)
+MAKE_FUNCPTR(XFreeDeviceState)
+#undef MAKE_FUNCPTR
+
+static INT X11DRV_XInput_Init(void)
+{
+    xinput_handle = wine_dlopen(SONAME_LIBXI, RTLD_NOW, NULL, 0);
+    if (xinput_handle)
+    {
+#define LOAD_FUNCPTR(f) if((p##f = wine_dlsym(xinput_handle, #f, NULL, 0)) == NULL) goto sym_not_found;
+        LOAD_FUNCPTR(XListInputDevices)
+        LOAD_FUNCPTR(XOpenDevice)
+        LOAD_FUNCPTR(XGetDeviceButtonMapping)
+        LOAD_FUNCPTR(XCloseDevice)
+        LOAD_FUNCPTR(XSelectExtensionEvent)
+        LOAD_FUNCPTR(XQueryDeviceState)
+        LOAD_FUNCPTR(XFreeDeviceState)
+#undef LOAD_FUNCPTR
+        return 1;
+    }
+sym_not_found:
+    return 0;
+}
+
+void X11DRV_LoadTabletInfo(HWND hwnddefault)
+{
+    struct x11drv_thread_data *data = x11drv_thread_data();
+    int num_devices;
+    int loop;
+    int cursor_target;
+    XDeviceInfo *devices;
+    XDeviceInfo *target = NULL;
+    BOOL    axis_read_complete= FALSE;
+
+    XAnyClassPtr        any;
+    XButtonInfoPtr      Button;
+    XValuatorInfoPtr    Val;
+    XAxisInfoPtr        Axis;
+
+    XDevice *opendevice;
+
+    if (!X11DRV_XInput_Init())
+    {
+        ERR("Unable to initialized the XInput library.\n");
+        return;
+    }
+
+    hwndTabletDefault = hwnddefault;
+
+    /* Do base initializaion */
+    strcpy(gSysContext.lcName, "Wine Tablet Context");
+    strcpy(gSysDevice.NAME,"Wine Tablet Device");
+
+    gSysContext.lcOptions = CXO_SYSTEM | CXO_MESSAGES | CXO_CSRMESSAGES;
+    gSysContext.lcLocks = CXL_INSIZE | CXL_INASPECT | CXL_MARGIN |
+                               CXL_SENSITIVITY | CXL_SYSOUT;
+
+    gSysContext.lcMsgBase= WT_DEFBASE;
+    gSysContext.lcDevice = 0;
+    gSysContext.lcPktData =
+        PK_CONTEXT | PK_STATUS | PK_SERIAL_NUMBER| PK_TIME | PK_CURSOR |
+        PK_BUTTONS |  PK_X | PK_Y | PK_NORMAL_PRESSURE | PK_ORIENTATION;
+    gSysContext.lcMoveMask=
+        PK_BUTTONS |  PK_X | PK_Y | PK_NORMAL_PRESSURE | PK_ORIENTATION;
+    gSysContext.lcStatus = CXS_ONTOP;
+    gSysContext.lcPktRate = 100;
+    gSysContext.lcBtnDnMask = 0xffffffff;
+    gSysContext.lcBtnUpMask = 0xffffffff;
+    gSysContext.lcSensX = 65536;
+    gSysContext.lcSensY = 65536;
+    gSysContext.lcSensX = 65536;
+    gSysContext.lcSensZ = 65536;
+    gSysContext.lcSysSensX= 65536;
+    gSysContext.lcSysSensY= 65536;
+
+    /* Device Defaults */
+    gSysDevice.HARDWARE = HWC_HARDPROX|HWC_PHYSID_CURSORS;
+    gSysDevice.FIRSTCSR= 0;
+    gSysDevice.PKTRATE = 100;
+    gSysDevice.PKTDATA =
+        PK_CONTEXT | PK_STATUS | PK_SERIAL_NUMBER| PK_TIME | PK_CURSOR |
+        PK_BUTTONS |  PK_X | PK_Y | PK_NORMAL_PRESSURE | PK_ORIENTATION;
+    strcpy(gSysDevice.PNPID,"non-pluginplay");
+
+    wine_tsx11_lock();
+
+    cursor_target = -1;
+    devices = pXListInputDevices(data->display, &num_devices);
+    if (!devices)
+    {
+        WARN("XInput Extenstions reported as not avalable\n");
+        wine_tsx11_unlock();
+        return;
+    }
+    for (loop=0; loop < num_devices; loop++)
+    {
+        int class_loop;
+
+        TRACE("Trying device %i(%s)\n",loop,devices[loop].name);
+        if (devices[loop].use == IsXExtensionDevice)
+        {
+            LPWTI_CURSORS_INFO cursor;
+
+            TRACE("Is Extension Device\n");
+            cursor_target++;
+            target = &devices[loop];
+            cursor = &gSysCursor[cursor_target];
+
+            opendevice = pXOpenDevice(data->display,target->id);
+            if (opendevice)
+            {
+                unsigned char map[32];
+                int i;
+                int shft = 0;
+
+                pXGetDeviceButtonMapping(data->display, opendevice, map, 32);
+
+                for (i=0; i< cursor->BUTTONS; i++,shft++)
+                {
+                    cursor->BUTTONMAP[i] = map[i];
+                    cursor->SYSBTNMAP[i] = (1<<shft);
+                }
+                pXCloseDevice(data->display, opendevice);
+            }
+            else
+            {
+                WARN("Unable to open device %s\n",target->name);
+                cursor_target --;
+                continue;
+            }
+
+            strcpy(cursor->NAME,target->name);
+
+            cursor->ACTIVE = 1;
+            cursor->PKTDATA = PK_TIME | PK_CURSOR | PK_BUTTONS |  PK_X | PK_Y |
+                              PK_NORMAL_PRESSURE | PK_TANGENT_PRESSURE |
+                              PK_ORIENTATION;
+
+            cursor->PHYSID = cursor_target;
+            cursor->NPBUTTON = 1;
+            cursor->NPBTNMARKS[0] = 0 ;
+            cursor->NPBTNMARKS[1] = 1 ;
+            cursor->CAPABILITIES = 1;
+            if (strcasecmp(cursor->NAME,"stylus")==0)
+                cursor->TYPE = 0x4825;
+            if (strcasecmp(cursor->NAME,"eraser")==0)
+                cursor->TYPE = 0xc85a;
+
+
+            any = (XAnyClassPtr) (target->inputclassinfo);
+
+            for (class_loop = 0; class_loop < target->num_classes; class_loop++)
+            {
+                switch (any->class)
+                {
+                    case ValuatorClass:
+                        if (!axis_read_complete)
+                        {
+                            Val = (XValuatorInfoPtr) any;
+                            Axis = (XAxisInfoPtr) ((char *) Val + sizeof
+                                (XValuatorInfo));
+
+                            if (Val->num_axes>=1)
+                            {
+                                /* Axis 1 is X */
+                                gSysDevice.X.axMin = Axis->min_value;
+                                gSysDevice.X.axMax= Axis->max_value;
+                                gSysDevice.X.axUnits = 1;
+                                gSysDevice.X.axResolution = Axis->resolution;
+                                gSysContext.lcInOrgX = Axis->min_value;
+                                gSysContext.lcSysOrgX = Axis->min_value;
+                                gSysContext.lcInExtX = Axis->max_value;
+                                gSysContext.lcSysExtX = Axis->max_value;
+                                Axis++;
+                            }
+                            if (Val->num_axes>=2)
+                            {
+                                /* Axis 2 is Y */
+                                gSysDevice.Y.axMin = Axis->min_value;
+                                gSysDevice.Y.axMax= Axis->max_value;
+                                gSysDevice.Y.axUnits = 1;
+                                gSysDevice.Y.axResolution = Axis->resolution;
+                                gSysContext.lcInOrgY = Axis->min_value;
+                                gSysContext.lcSysOrgY = Axis->min_value;
+                                gSysContext.lcInExtY = Axis->max_value;
+                                gSysContext.lcSysExtY = Axis->max_value;
+                                Axis++;
+                            }
+                            if (Val->num_axes>=3)
+                            {
+                                /* Axis 3 is Normal Pressure */
+                                gSysDevice.NPRESSURE.axMin = Axis->min_value;
+                                gSysDevice.NPRESSURE.axMax= Axis->max_value;
+                                gSysDevice.NPRESSURE.axUnits = 1;
+                                gSysDevice.NPRESSURE.axResolution =
+                                                        Axis->resolution;
+                                Axis++;
+                            }
+                            if (Val->num_axes >= 5)
+                            {
+                                /* Axis 4 and 5 are X and Y tilt */
+                                XAxisInfoPtr        XAxis = Axis;
+                                Axis++;
+                                if (max (abs(Axis->max_value),
+                                         abs(XAxis->max_value)))
+                                {
+                                    gSysDevice.ORIENTATION[0].axMin = 0;
+                                    gSysDevice.ORIENTATION[0].axMax = 3600;
+                                    gSysDevice.ORIENTATION[0].axUnits = 1;
+                                    gSysDevice.ORIENTATION[0].axResolution =
+                                                                     235929600;
+                                    gSysDevice.ORIENTATION[1].axMin = -1000;
+                                    gSysDevice.ORIENTATION[1].axMax = 1000;
+                                    gSysDevice.ORIENTATION[1].axUnits = 1;
+                                    gSysDevice.ORIENTATION[1].axResolution =
+                                                                     235929600;
+                                    Axis++;
+                                }
+                            }
+                            axis_read_complete = TRUE;
+                        }
+                        break;
+                    case ButtonClass:
+                    {
+                        CHAR *ptr = cursor->BTNNAMES;
+                        int i;
+
+                        Button = (XButtonInfoPtr) any;
+                        cursor->BUTTONS = Button->num_buttons;
+                        for (i = 0; i < cursor->BUTTONS; i++)
+                        {
+                            strcpy(ptr,cursor->NAME);
+                            ptr+=8;
+                        }
+                    }
+                    break;
+                }
+                any = (XAnyClassPtr) ((char*) any + any->length);
+            }
+        }
+    }
+    wine_tsx11_unlock();
+    gSysDevice.NCSRTYPES = cursor_target+1;
+    gNumCursors = cursor_target+1;
+}
+
+static int figure_deg(int x, int y)
+{
+    int rc;
+
+    if (y != 0)
+    {
+        rc = (int) 10 * (atan( (FLOAT)abs(y) / (FLOAT)abs(x)) / (3.1415 / 180));
+        if (y>0)
+        {
+            if (x>0)
+                rc += 900;
+            else
+                rc = 2700 - rc;
+        }
+        else
+        {
+            if (x>0)
+                rc = 900 - rc;
+            else
+                rc += 2700;
+        }
+    }
+    else
+    {
+        if (x >= 0)
+            rc = 900;
+        else
+            rc = 2700;
+    }
+
+    return rc;
+}
+
+static int get_button_state(int deviceid)
+{
+    return button_state[deviceid];
+}
+
+static void set_button_state(XID deviceid)
+{
+    struct x11drv_thread_data *data = x11drv_thread_data();
+    XDevice *device;
+    XDeviceState *state;
+    XInputClass  *class;
+    int loop;
+    int rc = 0;
+
+    wine_tsx11_lock();
+    device = pXOpenDevice(data->display,deviceid);
+    state = pXQueryDeviceState(data->display,device);
+
+    if (state)
+    {
+        class = state->data;
+        for (loop = 0; loop < state->num_classes; loop++)
+        {
+            if (class->class == ButtonClass)
+            {
+                int loop2;
+                XButtonState *button_state =  (XButtonState*)class;
+                for (loop2 = 1; loop2 <= button_state->num_buttons; loop2++)
+                {
+                    if (button_state->buttons[loop2 / 8] & (1 << (loop2 % 8)))
+                    {
+                        rc |= (1<<(loop2-1));
+                    }
+                }
+            }
+            class = (XInputClass *) ((char *) class + class->length);
+        }
+    }
+    pXFreeDeviceState(state);
+    wine_tsx11_unlock();
+    button_state[deviceid] = rc;
+}
+
+int X11DRV_ProcessTabletEvent(HWND hwnd, XEvent *event)
+{
+    memset(&gMsgPacket,0,sizeof(WTPACKET));
+
+    if(event->type ==  motion_type)
+    {
+        XDeviceMotionEvent *motion = (XDeviceMotionEvent *)event;
+
+        TRACE_(event)("Received tablet motion event (%p)\n",hwnd);
+        TRACE("Received tablet motion event (%p)\n",hwnd);
+        gMsgPacket.pkTime = motion->time;
+        gMsgPacket.pkSerialNumber = gSerial++;
+        gMsgPacket.pkCursor = motion->deviceid;
+        gMsgPacket.pkX = motion->axis_data[0];
+        gMsgPacket.pkY = motion->axis_data[1];
+        gMsgPacket.pkOrientation.orAzimuth =
+                    figure_deg(motion->axis_data[3],motion->axis_data[4]);
+        gMsgPacket.pkOrientation.orAltitude = 1000 - 15 * max
+                    (abs(motion->axis_data[3]),abs(motion->axis_data[4]));
+        gMsgPacket.pkNormalPressure = motion->axis_data[2];
+        gMsgPacket.pkButtons = get_button_state(motion->deviceid);
+        SendMessageW(hwndTabletDefault,WT_PACKET,0,(LPARAM)hwnd);
+    }
+    else if ((event->type == button_press_type)||(event->type ==
+              button_release_type))
+    {
+        XDeviceButtonEvent *button = (XDeviceButtonEvent *) event;
+
+        TRACE_(event)("Received tablet button event\n");
+        TRACE("Received tablet button %s event\n", (event->type ==
+                                button_press_type)?"press":"release");
+
+        set_button_state(button->deviceid);
+    }
+    else if (event->type == key_press_type)
+    {
+        TRACE_(event)("Received tablet key press event\n");
+        FIXME("Received tablet key press event\n");
+    }
+    else if (event->type == key_release_type)
+    {
+        TRACE_(event)("Received tablet key release event\n");
+        FIXME("Received tablet key release event\n");
+    }
+    else if ((event->type == proximity_in_type) ||
+             (event->type == proximity_out_type))
+    {
+        TRACE_(event)("Received tablet proximity event\n");
+        TRACE("Received tablet proximity event\n");
+        gMsgPacket.pkStatus = (event->type==proximity_out_type)?TPS_PROXIMITY:0;
+        SendMessageW(hwndTabletDefault, WT_PROXIMITY,
+                     (event->type==proximity_out_type)?0:1, (LPARAM)hwnd);
+    }
+    else
+        return 0;
+
+    return 1;
+}
+
+int X11DRV_AttachEventQueueToTablet(HWND hOwner)
+{
+    struct x11drv_thread_data *data = x11drv_thread_data();
+    int             num_devices;
+    int             loop;
+    int             cur_loop;
+    XDeviceInfo     *devices;
+    XDeviceInfo     *target = NULL;
+    XDevice         *the_device;
+    XInputClassInfo *ip;
+    XEventClass     event_list[7];
+    Window          win = X11DRV_get_whole_window( hOwner );
+
+    if (!win) return 0;
+
+    TRACE("Creating context for window %p (%lx)  %i cursors\n", hOwner, win, gNumCursors);
+
+    wine_tsx11_lock();
+    devices = pXListInputDevices(data->display, &num_devices);
+
+    for (cur_loop=0; cur_loop < gNumCursors; cur_loop++)
+    {
+        int    event_number=0;
+
+        for (loop=0; loop < num_devices; loop ++)
+            if (strcmp(devices[loop].name,gSysCursor[cur_loop].NAME)==0)
+                target = &devices[loop];
+
+        TRACE("Opening cursor %i id %i\n",cur_loop,(INT)target->id);
+
+        the_device = pXOpenDevice(data->display, target->id);
+
+        if (!the_device)
+        {
+            WARN("Unable to Open device\n");
+            continue;
+        }
+
+        if (the_device->num_classes > 0)
+        {
+            for (ip = the_device->classes, loop=0; loop < target->num_classes;
+                 ip++, loop++)
+            {
+                switch(ip->input_class)
+                {
+                    case KeyClass:
+                        DeviceKeyPress(the_device, key_press_type,
+                                       event_list[event_number]);
+                        event_number++;
+                        DeviceKeyRelease(the_device, key_release_type,
+                                          event_list[event_number]);
+                        event_number++;
+                        break;
+                    case ButtonClass:
+                        DeviceButtonPress(the_device, button_press_type,
+                                       event_list[event_number]);
+                        event_number++;
+                        DeviceButtonRelease(the_device, button_release_type,
+                                            event_list[event_number]);
+                        event_number++;
+                        break;
+                    case ValuatorClass:
+                        DeviceMotionNotify(the_device, motion_type,
+                                           event_list[event_number]);
+                        event_number++;
+                        ProximityIn(the_device, proximity_in_type,
+                                 event_list[event_number]);
+                        event_number++;
+                        ProximityOut(the_device, proximity_out_type,
+                                     event_list[event_number]);
+                        event_number++;
+                        break;
+                    default:
+                        ERR("unknown class\n");
+                        break;
+                }
+            }
+            if (pXSelectExtensionEvent(data->display, win, event_list, event_number))
+            {
+                ERR( "error selecting extended events\n");
+                goto end;
+            }
+        }
+    }
+
+end:
+    wine_tsx11_unlock();
+    return 0;
+}
+
+int X11DRV_GetCurrentPacket(LPWTPACKET *packet)
+{
+    memcpy(packet,&gMsgPacket,sizeof(WTPACKET));
+    return 1;
+}
+
+
+int static inline CopyTabletData(LPVOID target, LPVOID src, INT size)
+{
+    memcpy(target,src,size);
+    return(size);
+}
+
+/***********************************************************************
+ *		X11DRV_WTInfoA (X11DRV.@)
+ */
+UINT X11DRV_WTInfoA(UINT wCategory, UINT nIndex, LPVOID lpOutput)
+{
+    int rc = 0;
+    LPWTI_CURSORS_INFO  tgtcursor;
+    TRACE("(%u, %u, %p)\n", wCategory, nIndex, lpOutput);
+
+    switch(wCategory)
+    {
+        case 0:
+            /* return largest necessary buffer */
+            TRACE("%i cursors\n",gNumCursors);
+            if (gNumCursors>0)
+            {
+                FIXME("Return proper size\n");
+                return 200;
+            }
+            else
+                return 0;
+            break;
+        case WTI_INTERFACE:
+            switch (nIndex)
+            {
+                WORD version;
+                case IFC_WINTABID:
+                    strcpy(lpOutput,"Wine Wintab 1.1");
+                    rc = 16;
+                    break;
+                case IFC_SPECVERSION:
+                    version = (0x01) | (0x01 << 8);
+                    rc = CopyTabletData(lpOutput, &version,sizeof(WORD));
+                    break;
+                case IFC_IMPLVERSION:
+                    version = (0x00) | (0x01 << 8);
+                    rc = CopyTabletData(lpOutput, &version,sizeof(WORD));
+                    break;
+                default:
+                    FIXME("WTI_INTERFACE unhandled index %i\n",nIndex);
+                    rc = 0;
+
+            }
+        case WTI_DEFSYSCTX:
+        case WTI_DDCTXS:
+        case WTI_DEFCONTEXT:
+            switch (nIndex)
+            {
+                case 0:
+                    memcpy(lpOutput, &gSysContext,
+                            sizeof(LOGCONTEXTA));
+                    rc = sizeof(LOGCONTEXTA);
+                    break;
+                case CTX_NAME:
+                    rc = CopyTabletData(lpOutput, &gSysContext.lcName,
+                         strlen(gSysContext.lcName)+1);
+                    break;
+                case CTX_OPTIONS:
+                    rc = CopyTabletData(lpOutput, &gSysContext.lcOptions,
+                                        sizeof(UINT));
+                    break;
+                case CTX_STATUS:
+                    rc = CopyTabletData(lpOutput, &gSysContext.lcStatus,
+                                        sizeof(UINT));
+                    break;
+                case CTX_LOCKS:
+                    rc= CopyTabletData (lpOutput, &gSysContext.lcLocks,
+                                        sizeof(UINT));
+                    break;
+                case CTX_MSGBASE:
+                    rc = CopyTabletData(lpOutput, &gSysContext.lcMsgBase,
+                                        sizeof(UINT));
+                    break;
+                case CTX_DEVICE:
+                    rc = CopyTabletData(lpOutput, &gSysContext.lcDevice,
+                                        sizeof(UINT));
+                    break;
+                case CTX_PKTRATE:
+                    rc = CopyTabletData(lpOutput, &gSysContext.lcPktRate,
+                                        sizeof(UINT));
+                    break;
+                case CTX_PKTMODE:
+                    rc = CopyTabletData(lpOutput, &gSysContext.lcPktMode,
+                                        sizeof(WTPKT));
+                    break;
+                case CTX_MOVEMASK:
+                    rc = CopyTabletData(lpOutput, &gSysContext.lcMoveMask,
+                                        sizeof(WTPKT));
+                    break;
+                case CTX_BTNDNMASK:
+                    rc = CopyTabletData(lpOutput, &gSysContext.lcBtnDnMask,
+                                        sizeof(DWORD));
+                    break;
+                case CTX_BTNUPMASK:
+                    rc = CopyTabletData(lpOutput, &gSysContext.lcBtnUpMask,
+                                        sizeof(DWORD));
+                    break;
+                case CTX_INORGX:
+                    rc = CopyTabletData(lpOutput, &gSysContext.lcInOrgX,
+                                        sizeof(LONG));
+                    break;
+                case CTX_INORGY:
+                    rc = CopyTabletData(lpOutput, &gSysContext.lcInOrgY,
+                                        sizeof(LONG));
+                    break;
+                case CTX_INORGZ:
+                    rc = CopyTabletData(lpOutput, &gSysContext.lcInOrgZ,
+                                        sizeof(LONG));
+                    break;
+                case CTX_INEXTX:
+                    rc = CopyTabletData(lpOutput, &gSysContext.lcInExtX,
+                                        sizeof(LONG));
+                    break;
+                case CTX_INEXTY:
+                     rc = CopyTabletData(lpOutput, &gSysContext.lcInExtY,
+                                        sizeof(LONG));
+                    break;
+                case CTX_INEXTZ:
+                     rc = CopyTabletData(lpOutput, &gSysContext.lcInExtZ,
+                                        sizeof(LONG));
+                    break;
+                case CTX_OUTORGX:
+                     rc = CopyTabletData(lpOutput, &gSysContext.lcOutOrgX,
+                                        sizeof(LONG));
+                    break;
+                case CTX_OUTORGY:
+                      rc = CopyTabletData(lpOutput, &gSysContext.lcOutOrgY,
+                                        sizeof(LONG));
+                    break;
+                case CTX_OUTORGZ:
+                       rc = CopyTabletData(lpOutput, &gSysContext.lcOutOrgZ,
+                                        sizeof(LONG));
+                    break;
+               case CTX_OUTEXTX:
+                      rc = CopyTabletData(lpOutput, &gSysContext.lcOutExtX,
+                                        sizeof(LONG));
+                    break;
+                case CTX_OUTEXTY:
+                       rc = CopyTabletData(lpOutput, &gSysContext.lcOutExtY,
+                                        sizeof(LONG));
+                    break;
+                case CTX_OUTEXTZ:
+                       rc = CopyTabletData(lpOutput, &gSysContext.lcOutExtZ,
+                                        sizeof(LONG));
+                    break;
+                case CTX_SENSX:
+                        rc = CopyTabletData(lpOutput, &gSysContext.lcSensX,
+                                        sizeof(LONG));
+                    break;
+                case CTX_SENSY:
+                        rc = CopyTabletData(lpOutput, &gSysContext.lcSensY,
+                                        sizeof(LONG));
+                    break;
+                case CTX_SENSZ:
+                        rc = CopyTabletData(lpOutput, &gSysContext.lcSensZ,
+                                        sizeof(LONG));
+                    break;
+                case CTX_SYSMODE:
+                        rc = CopyTabletData(lpOutput, &gSysContext.lcSysMode,
+                                        sizeof(LONG));
+                    break;
+                case CTX_SYSORGX:
+                        rc = CopyTabletData(lpOutput, &gSysContext.lcSysOrgX,
+                                        sizeof(LONG));
+                    break;
+                case CTX_SYSORGY:
+                        rc = CopyTabletData(lpOutput, &gSysContext.lcSysOrgY,
+                                        sizeof(LONG));
+                    break;
+                case CTX_SYSEXTX:
+                        rc = CopyTabletData(lpOutput, &gSysContext.lcSysExtX,
+                                        sizeof(LONG));
+                    break;
+                case CTX_SYSEXTY:
+                        rc = CopyTabletData(lpOutput, &gSysContext.lcSysExtY,
+                                        sizeof(LONG));
+                    break;
+                case CTX_SYSSENSX:
+                        rc = CopyTabletData(lpOutput, &gSysContext.lcSysSensX,
+                                        sizeof(LONG));
+                    break;
+                case CTX_SYSSENSY:
+                       rc = CopyTabletData(lpOutput, &gSysContext.lcSysSensY,
+                                        sizeof(LONG));
+                    break;
+                default:
+                    FIXME("WTI_DEFSYSCTX unhandled index %i\n",nIndex);
+                    rc = 0;
+            }
+            break;
+        case WTI_CURSORS:
+        case WTI_CURSORS+1:
+        case WTI_CURSORS+2:
+        case WTI_CURSORS+3:
+        case WTI_CURSORS+4:
+        case WTI_CURSORS+5:
+        case WTI_CURSORS+6:
+        case WTI_CURSORS+7:
+        case WTI_CURSORS+8:
+        case WTI_CURSORS+9:
+        case WTI_CURSORS+10:
+            tgtcursor = &gSysCursor[wCategory - WTI_CURSORS];
+            switch (nIndex)
+            {
+                case CSR_NAME:
+                    rc = CopyTabletData(lpOutput, &tgtcursor->NAME,
+                                        strlen(tgtcursor->NAME)+1);
+                    break;
+                case CSR_ACTIVE:
+                    rc = CopyTabletData(lpOutput,&tgtcursor->ACTIVE,
+                                        sizeof(BOOL));
+                    break;
+                case CSR_PKTDATA:
+                    rc = CopyTabletData(lpOutput,&tgtcursor->PKTDATA,
+                                        sizeof(WTPKT));
+                    break;
+                case CSR_BUTTONS:
+                    rc = CopyTabletData(lpOutput,&tgtcursor->BUTTONS,
+                                        sizeof(BYTE));
+                    break;
+                case CSR_BUTTONBITS:
+                    rc = CopyTabletData(lpOutput,&tgtcursor->BUTTONBITS,
+                                        sizeof(BYTE));
+                    break;
+                case CSR_BTNNAMES:
+                    FIXME("Button Names not returned correctly\n");
+                    rc = CopyTabletData(lpOutput,&tgtcursor->BTNNAMES,
+                                        strlen(tgtcursor->BTNNAMES)+1);
+                    break;
+                case CSR_BUTTONMAP:
+                    rc = CopyTabletData(lpOutput,&tgtcursor->BUTTONMAP,
+                                        sizeof(BYTE)*32);
+                    break;
+                case CSR_SYSBTNMAP:
+                    rc = CopyTabletData(lpOutput,&tgtcursor->SYSBTNMAP,
+                                        sizeof(BYTE)*32);
+                    break;
+                case CSR_NPBTNMARKS:
+                    memcpy(lpOutput,&tgtcursor->NPBTNMARKS,sizeof(UINT)*2);
+                    rc = sizeof(UINT)*2;
+                    break;
+                case CSR_NPBUTTON:
+                    rc = CopyTabletData(lpOutput,&tgtcursor->NPBUTTON,
+                                        sizeof(BYTE));
+                    break;
+                case CSR_NPRESPONSE:
+                    FIXME("Not returning CSR_NPRESPONSE correctly\n");
+                    rc = 0;
+                    break;
+                case CSR_TPBUTTON:
+                    rc = CopyTabletData(lpOutput,&tgtcursor->TPBUTTON,
+                                        sizeof(BYTE));
+                    break;
+                case CSR_TPBTNMARKS:
+                    memcpy(lpOutput,&tgtcursor->TPBTNMARKS,sizeof(UINT)*2);
+                    rc = sizeof(UINT)*2;
+                    break;
+                case CSR_TPRESPONSE:
+                    FIXME("Not returning CSR_TPRESPONSE correctly\n");
+                    rc = 0;
+                    break;
+                case CSR_PHYSID:
+                {
+                    DWORD id;
+                    rc = CopyTabletData(&id,&tgtcursor->PHYSID,
+                                        sizeof(DWORD));
+                    id += (wCategory - WTI_CURSORS);
+                    memcpy(lpOutput,&id,sizeof(DWORD));
+                }
+                    break;
+                case CSR_MODE:
+                    rc = CopyTabletData(lpOutput,&tgtcursor->MODE,sizeof(UINT));
+                    break;
+                case CSR_MINPKTDATA:
+                    rc = CopyTabletData(lpOutput,&tgtcursor->MINPKTDATA,
+                        sizeof(UINT));
+                    break;
+                case CSR_MINBUTTONS:
+                    rc = CopyTabletData(lpOutput,&tgtcursor->MINBUTTONS,
+                        sizeof(UINT));
+                    break;
+                case CSR_CAPABILITIES:
+                    rc = CopyTabletData(lpOutput,&tgtcursor->CAPABILITIES,
+                        sizeof(UINT));
+                    break;
+                case CSR_TYPE:
+                    rc = CopyTabletData(lpOutput,&tgtcursor->TYPE,
+                        sizeof(UINT));
+                    break;
+                default:
+                    FIXME("WTI_CURSORS unhandled index %i\n",nIndex);
+                    rc = 0;
+            }
+            break;
+        case WTI_DEVICES:
+            switch (nIndex)
+            {
+                case DVC_NAME:
+                    rc = CopyTabletData(lpOutput,gSysDevice.NAME,
+                                        strlen(gSysDevice.NAME)+1);
+                    break;
+                case DVC_HARDWARE:
+                    rc = CopyTabletData(lpOutput,&gSysDevice.HARDWARE,
+                                        sizeof(UINT));
+                    break;
+                case DVC_NCSRTYPES:
+                    rc = CopyTabletData(lpOutput,&gSysDevice.NCSRTYPES,
+                                        sizeof(UINT));
+                    break;
+                case DVC_FIRSTCSR:
+                    rc = CopyTabletData(lpOutput,&gSysDevice.FIRSTCSR,
+                                        sizeof(UINT));
+                    break;
+                case DVC_PKTRATE:
+                    rc = CopyTabletData(lpOutput,&gSysDevice.PKTRATE,
+                                        sizeof(UINT));
+                    break;
+                case DVC_PKTDATA:
+                    rc = CopyTabletData(lpOutput,&gSysDevice.PKTDATA,
+                                        sizeof(WTPKT));
+                    break;
+                case DVC_PKTMODE:
+                    rc = CopyTabletData(lpOutput,&gSysDevice.PKTMODE,
+                                        sizeof(WTPKT));
+                    break;
+                case DVC_CSRDATA:
+                    rc = CopyTabletData(lpOutput,&gSysDevice.CSRDATA,
+                                        sizeof(WTPKT));
+                    break;
+                case DVC_XMARGIN:
+                    rc = CopyTabletData(lpOutput,&gSysDevice.XMARGIN,
+                                        sizeof(INT));
+                    break;
+                case DVC_YMARGIN:
+                    rc = CopyTabletData(lpOutput,&gSysDevice.YMARGIN,
+                                        sizeof(INT));
+                    break;
+                case DVC_ZMARGIN:
+                    rc = 0; /* unsupported */
+                    /*
+                    rc = CopyTabletData(lpOutput,&gSysDevice.ZMARGIN,
+                                        sizeof(INT));
+                    */
+                    break;
+                case DVC_X:
+                    rc = CopyTabletData(lpOutput,&gSysDevice.X,
+                                        sizeof(AXIS));
+                    break;
+                case DVC_Y:
+                    rc = CopyTabletData(lpOutput,&gSysDevice.Y,
+                                        sizeof(AXIS));
+                    break;
+                case DVC_Z:
+                    rc = 0; /* unsupported */
+                    /*
+                    rc = CopyTabletData(lpOutput,&gSysDevice.Z,
+                                        sizeof(AXIS));
+                    */
+                    break;
+                case DVC_NPRESSURE:
+                    rc = CopyTabletData(lpOutput,&gSysDevice.NPRESSURE,
+                                        sizeof(AXIS));
+                    break;
+                case DVC_TPRESSURE:
+                    rc = 0; /* unsupported */
+                    /*
+                    rc = CopyTabletData(lpOutput,&gSysDevice.TPRESSURE,
+                                        sizeof(AXIS));
+                    */
+                    break;
+                case DVC_ORIENTATION:
+                    memcpy(lpOutput,&gSysDevice.ORIENTATION,sizeof(AXIS)*3);
+                    rc = sizeof(AXIS)*3;
+                    break;
+                case DVC_ROTATION:
+                    rc = 0; /* unsupported */
+                    /*
+                    memcpy(lpOutput,&gSysDevice.ROTATION,sizeof(AXIS)*3);
+                    rc = sizeof(AXIS)*3;
+                    */
+                    break;
+                case DVC_PNPID:
+                    rc = CopyTabletData(lpOutput,gSysDevice.PNPID,
+                                        strlen(gSysDevice.PNPID)+1);
+                    break;
+                default:
+                    FIXME("WTI_DEVICES unhandled index %i\n",nIndex);
+                    rc = 0;
+            }
+            break;
+        default:
+            FIXME("Unhandled Category %i\n",wCategory);
+    }
+    return rc;
+}
+
+#else /* HAVE_X11_EXTENSIONS_XINPUT_H */
+
+int X11DRV_ProcessTabletEvent(HWND hwnd, XEvent *event)
+{
+    return 0;
+}
+
+int X11DRV_AttachEventQueueToTablet(HWND hOwner)
+{
+    return 0;
+}
+
+int X11DRV_GetCurrentPacket(LPWTPACKET *packet)
+{
+    return 0;
+}
+
+void X11DRV_LoadTabletInfo(HWND hwnddefault)
+{
+}
+
+UINT X11DRV_WTInfoA(UINT wCategory, UINT nIndex, LPVOID lpOutput)
+{
+    return 0;
+}
+
+#endif /* HAVE_X11_EXTENSIONS_XINPUT_H */
diff --git a/dlls/x11drv/x11drv.h b/dlls/x11drv/x11drv.h
index b09bc49..f7c117f 100644
--- a/dlls/x11drv/x11drv.h
+++ b/dlls/x11drv/x11drv.h
@@ -475,6 +475,8 @@
 void X11DRV_EVENT_SetDGAStatus(HWND hwnd, int event_base) ;
 #endif
 
+extern int X11DRV_ProcessTabletEvent(HWND hwnd, XEvent *event);
+
 /* x11drv private window data */
 struct x11drv_win_data
 {
diff --git a/dlls/x11drv/x11drv.spec b/dlls/x11drv/x11drv.spec
index ae68b95..3a22b0d 100644
--- a/dlls/x11drv/x11drv.spec
+++ b/dlls/x11drv/x11drv.spec
@@ -111,6 +111,12 @@
 @ cdecl ShowWindow(long long) X11DRV_ShowWindow
 @ cdecl SysCommandSizeMove(long long) X11DRV_SysCommandSizeMove
 
+# WinTab32
+@ cdecl AttachEventQueueToTablet(long) X11DRV_AttachEventQueueToTablet
+@ cdecl GetCurrentPacket(ptr) X11DRV_GetCurrentPacket
+@ cdecl LoadTabletInfo(long) X11DRV_LoadTabletInfo
+@ cdecl WTInfoA(long long ptr) X11DRV_WTInfoA
+
 # X11 locks
 @ cdecl -norelay wine_tsx11_lock()
 @ cdecl -norelay wine_tsx11_unlock()
diff --git a/include/config.h.in b/include/config.h.in
index 4685930..c4318c6 100644
--- a/include/config.h.in
+++ b/include/config.h.in
@@ -1195,6 +1195,11 @@
 #undef HAVE_X11_EXTENSIONS_XF86VMODE_H
 
 /* 
+   Define to 1 if you have the <X11/extensions/XInput.h>
+   header file. */
+#undef HAVE_X11_EXTENSIONS_XINPUT_H
+
+/* 
    Define to 1 if you have the <X11/extensions/Xrandr.h>
    header file. */
 #undef HAVE_X11_EXTENSIONS_XRANDR_H
@@ -1379,6 +1384,11 @@
 #undef SONAME_LIBXEXT
 
 /* 
+   Define to the soname of the libXi library.
+   */
+#undef SONAME_LIBXI
+
+/* 
    Define to the soname of the libXrender library.
    */
 #undef SONAME_LIBXRENDER
diff --git a/include/wintab.h b/include/wintab.h
index e8161b6..e9cb5fa 100644
--- a/include/wintab.h
+++ b/include/wintab.h
@@ -328,7 +328,9 @@
 #define CSR_MINPKTDATA   17  /* 1.1 */
 #define CSR_MINBUTTONS   18  /* 1.1 */
 #define CSR_CAPABILITIES 19  /* 1.1 */
-#define CSR_MAX          19
+/* from http://www.wacomeng.com/devsupport/ibmpc/wacomwindevfaq.html */
+#define CSR_TYPE        20
+#define CSR_MAX         20
 
 #endif