dlls/wintab32/context.c

   1 /*
   2  * Tablet Context
   3  *
   4  * Copyright 2002 Patrik Stridvall
   5  * Copyright 2003 CodeWeavers, Aric Stewart
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include "config.h"
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <stdarg.h>
  26
  27 #include "windef.h"
  28 #include "winerror.h"
  29 #include "winbase.h"
  30 #include "winuser.h"
  31 #include "winnls.h"
  32
  33 #include "wintab.h"
  34 #include "wintab_internal.h"
  35
  36 #include "wine/debug.h"
  37
  38 WINE_DEFAULT_DEBUG_CHANNEL(wintab32);
  39
  40 /*
  41  * Documentation found at
  42  * http://www.csl.sony.co.jp/projects/ar/restricted/wintabl.html
  43  */
  44
  45 static BOOL gLoaded;
  46 static LPOPENCONTEXT gOpenContexts;
  47 static HCTX gTopContext = (HCTX)0xc00;
  48
  49 static void LOGCONTEXTAtoW(const LOGCONTEXTA *in, LOGCONTEXTW *out)
  50 {
  51     MultiByteToWideChar(CP_ACP, 0, in->lcName, -1, out->lcName, LCNAMELEN);
  52     out->lcName[LCNAMELEN - 1] = 0;
  53     /* we use the fact that the fields after lcName are the same in LOGCONTEXTA and W */
  54     memcpy(&out->lcOptions, &in->lcOptions, sizeof(LOGCONTEXTA) - FIELD_OFFSET(LOGCONTEXTA, lcOptions));
  55 }
  56
  57 static void LOGCONTEXTWtoA(const LOGCONTEXTW *in, LOGCONTEXTA *out)
  58 {
  59     WideCharToMultiByte(CP_ACP, 0, in->lcName, LCNAMELEN, out->lcName, LCNAMELEN, NULL, NULL);
  60     out->lcName[LCNAMELEN - 1] = 0;
  61     /* we use the fact that the fields after lcName are the same in LOGCONTEXTA and W */
  62     memcpy(&out->lcOptions, &in->lcOptions, sizeof(LOGCONTEXTW) - FIELD_OFFSET(LOGCONTEXTW, lcOptions));
  63 }
  64
  65 static BOOL is_logcontext_category(UINT wCategory)
  66 {
  67     return wCategory == WTI_DEFSYSCTX || wCategory == WTI_DEFCONTEXT || wCategory == WTI_DDCTXS;
  68 }
  69
  70 static BOOL is_string_field(UINT wCategory, UINT nIndex)
  71 {
  72     if (wCategory == WTI_INTERFACE && nIndex == IFC_WINTABID)
  73         return TRUE;
  74     if (is_logcontext_category(wCategory) && nIndex == CTX_NAME)
  75         return TRUE;
  76     if ((wCategory >= WTI_CURSORS && wCategory <= WTI_CURSORS + 9) &&
  77             (nIndex == CSR_NAME || nIndex == CSR_BTNNAMES))
  78         return TRUE;
  79     if (wCategory == WTI_DEVICES && (nIndex == DVC_NAME || nIndex == DVC_PNPID))
  80         return TRUE;
  81     return FALSE;
  82 }
  83
  84 static const char* DUMPBITS(int x)
  85 {
  86     char buf[200];
  87     buf[0] = 0;
  88     if (x&PK_CONTEXT) strcat(buf,"PK_CONTEXT ");
  89     if (x&PK_STATUS) strcat(buf, "PK_STATUS ");
  90     if (x&PK_TIME) strcat(buf, "PK_TIME ");
  91     if (x&PK_CHANGED) strcat(buf, "PK_CHANGED ");
  92     if (x&PK_SERIAL_NUMBER) strcat(buf, "PK_SERIAL_NUMBER ");
  93     if (x&PK_CURSOR) strcat(buf, "PK_CURSOR ");
  94     if (x&PK_BUTTONS) strcat(buf, "PK_BUTTONS ");
  95     if (x&PK_X) strcat(buf, "PK_X ");
  96     if (x&PK_Y) strcat(buf, "PK_Y ");
  97     if (x&PK_Z) strcat(buf, "PK_Z ");
  98     if (x&PK_NORMAL_PRESSURE) strcat(buf, "PK_NORMAL_PRESSURE ");
  99     if (x&PK_TANGENT_PRESSURE) strcat(buf, "PK_TANGENT_PRESSURE ");
 100     if (x&PK_ORIENTATION) strcat(buf, "PK_ORIENTATION ");
 101     if (x&PK_ROTATION) strcat(buf, "PK_ROTATION ");
 102     return wine_dbg_sprintf("{%s}",buf);
 103 }
 104
 105 static inline void DUMPPACKET(WTPACKET packet)
 106 {
 107     TRACE("pkContext: %p pkStatus: 0x%x pkTime : 0x%x pkChanged: 0x%x pkSerialNumber: 0x%x pkCursor : %i pkButtons: %x pkX: %i pkY: %i pkZ: %i pkNormalPressure: %i pkTangentPressure: %i pkOrientation: (%i,%i,%i) pkRotation: (%i,%i,%i)\n",
 108           packet.pkContext, packet.pkStatus, packet.pkTime, packet.pkChanged, packet.pkSerialNumber,
 109           packet.pkCursor, packet.pkButtons, packet.pkX, packet.pkY, packet.pkZ,
 110           packet.pkNormalPressure, packet.pkTangentPressure,
 111           packet.pkOrientation.orAzimuth, packet.pkOrientation.orAltitude, packet.pkOrientation.orTwist,
 112           packet.pkRotation.roPitch, packet.pkRotation.roRoll, packet.pkRotation.roYaw);
 113 }
 114
 115 static inline void DUMPCONTEXT(LOGCONTEXTW lc)
 116 {
 117     TRACE("Name: %s, Options: %x, Status: %x, Locks: %x, MsgBase: %x, "
 118           "Device: %x, PktRate: %x, "
 119           "%x%s, %x%s, %x%s, "
 120           "BtnDnMask: %x, BtnUpMask: %x, "
 121           "InOrgX: %i, InOrgY: %i, InOrgZ: %i, "
 122           "InExtX: %i, InExtY: %i, InExtZ: %i, "
 123           "OutOrgX: %i, OutOrgY: %i, OutOrgZ: %i, "
 124           "OutExtX: %i, OutExtY: %i, OutExtZ: %i, "
 125           "SensX: %i, SensY: %i, SensZ: %i, "
 126           "SysMode: %i, "
 127           "SysOrgX: %i, SysOrgY: %i, "
 128           "SysExtX: %i, SysExtY: %i, "
 129           "SysSensX: %i, SysSensY: %i\n",
 130           wine_dbgstr_w(lc.lcName), lc.lcOptions, lc.lcStatus, lc.lcLocks, lc.lcMsgBase,
 131           lc.lcDevice, lc.lcPktRate, lc.lcPktData, DUMPBITS(lc.lcPktData),
 132           lc.lcPktMode, DUMPBITS(lc.lcPktMode), lc.lcMoveMask,
 133           DUMPBITS(lc.lcMoveMask), lc.lcBtnDnMask, lc.lcBtnUpMask,
 134           lc.lcInOrgX, lc.lcInOrgY, lc.lcInOrgZ, lc.lcInExtX, lc.lcInExtY,
 135           lc.lcInExtZ, lc.lcOutOrgX, lc.lcOutOrgY, lc.lcOutOrgZ, lc.lcOutExtX,
 136           lc.lcOutExtY, lc.lcOutExtZ, lc.lcSensX, lc.lcSensY, lc.lcSensZ, lc.lcSysMode,
 137           lc.lcSysOrgX, lc.lcSysOrgY, lc.lcSysExtX, lc.lcSysExtY, lc.lcSysSensX,
 138           lc.lcSysSensY);
 139 }
 140
 141
 142 /* Find an open context given the handle */
 143 static LPOPENCONTEXT TABLET_FindOpenContext(HCTX hCtx)
 144 {
 145     LPOPENCONTEXT ptr = gOpenContexts;
 146     while (ptr)
 147     {
 148         if (ptr->handle == hCtx) return ptr;
 149         ptr = ptr->next;
 150     }
 151     return NULL;
 152 }
 153
 154 static void LoadTablet(void)
 155 {
 156     TRACE("Initializing the tablet to hwnd %p\n",hwndDefault);
 157     gLoaded= TRUE;
 158     pLoadTabletInfo(hwndDefault);
 159 }
 160
 161 int TABLET_PostTabletMessage(LPOPENCONTEXT newcontext, UINT msg, WPARAM wParam,
 162                              LPARAM lParam, BOOL send_always)
 163 {
 164     if ((send_always) || (newcontext->context.lcOptions & CXO_MESSAGES))
 165     {
 166         TRACE("Posting message %x to %p\n",msg, newcontext->hwndOwner);
 167         return PostMessageA(newcontext->hwndOwner, msg, wParam, lParam);
 168     }
 169     return 0;
 170 }
 171
 172 static inline DWORD ScaleForContext(DWORD In, LONG InOrg, LONG InExt, LONG OutOrg, LONG OutExt)
 173 {
 174     if (((InExt > 0 )&&(OutExt > 0)) || ((InExt<0) && (OutExt < 0)))
 175         return ((In - InOrg) * abs(OutExt) / abs(InExt)) + OutOrg;
 176     else
 177         return ((abs(InExt) - (In - InOrg))*abs(OutExt) / abs(InExt)) + OutOrg;
 178 }
 179
 180 LPOPENCONTEXT AddPacketToContextQueue(LPWTPACKET packet, HWND hwnd)
 181 {
 182     LPOPENCONTEXT ptr=NULL;
 183
 184     EnterCriticalSection(&csTablet);
 185
 186     ptr = gOpenContexts;
 187     while (ptr)
 188     {
 189         TRACE("Trying Queue %p (%p %p)\n", ptr->handle, hwnd, ptr->hwndOwner);
 190
 191         if (ptr->hwndOwner == hwnd)
 192         {
 193             int tgt;
 194             if (!ptr->enabled)
 195             {
 196                 ptr = ptr->next;
 197                 continue;
 198             }
 199
 200             tgt = ptr->PacketsQueued;
 201
 202             packet->pkContext = ptr->handle;
 203
 204             /* translate packet data to the context */
 205
 206             /* Scale  as per documentation */
 207             packet->pkY = ScaleForContext(packet->pkY, ptr->context.lcInOrgY,
 208                                 ptr->context.lcInExtY, ptr->context.lcOutOrgY,
 209                                 ptr->context.lcOutExtY);
 210
 211             packet->pkX = ScaleForContext(packet->pkX, ptr->context.lcInOrgX,
 212                                 ptr->context.lcInExtX, ptr->context.lcOutOrgX,
 213                                 ptr->context.lcOutExtX);
 214
 215             /* flip the Y axis */
 216             if (ptr->context.lcOutExtY > 0)
 217                 packet->pkY = ptr->context.lcOutExtY - packet->pkY;
 218
 219             DUMPPACKET(*packet);
 220
 221             if (tgt == ptr->QueueSize)
 222             {
 223                 TRACE("Queue Overflow %p\n",ptr->handle);
 224                 ptr->PacketQueue[tgt-1].pkStatus |= TPS_QUEUE_ERR;
 225             }
 226             else
 227             {
 228                 TRACE("Placed in queue %p index %i\n",ptr->handle,tgt);
 229                 ptr->PacketQueue[tgt] = *packet;
 230                 ptr->PacketsQueued++;
 231
 232                 if (ptr->ActiveCursor != packet->pkCursor)
 233                 {
 234                     ptr->ActiveCursor = packet->pkCursor;
 235                     if (ptr->context.lcOptions & CXO_CSRMESSAGES)
 236                         TABLET_PostTabletMessage(ptr, _WT_CSRCHANGE(ptr->context.lcMsgBase),
 237                           (WPARAM)packet->pkSerialNumber, (LPARAM)ptr->handle,
 238                             FALSE);
 239                 }
 240             }
 241             break;
 242          }
 243         ptr = ptr->next;
 244     }
 245     LeaveCriticalSection(&csTablet);
 246     TRACE("Done (%p)\n",ptr);
 247     return ptr;
 248 }
 249
 250 /*
 251  * Flushes all packets from the queue.
 252  */
 253 static inline void TABLET_FlushQueue(LPOPENCONTEXT context)
 254 {
 255     context->PacketsQueued = 0;
 256 }
 257
 258 static inline int CopyTabletData(LPVOID target, LPVOID src, INT size)
 259 {
 260     memcpy(target,src,size);
 261     return(size);
 262 }
 263
 264 static INT TABLET_FindPacket(LPOPENCONTEXT context, UINT wSerial,
 265                                 LPWTPACKET *pkt)
 266 {
 267     int loop;
 268     int index  = -1;
 269     for (loop = 0; loop < context->PacketsQueued; loop++)
 270         if (context->PacketQueue[loop].pkSerialNumber == wSerial)
 271         {
 272             index = loop;
 273             *pkt = &context->PacketQueue[loop];
 274             break;
 275         }
 276
 277     TRACE("%i .. %i\n",context->PacketsQueued,index);
 278
 279     return index;
 280 }
 281
 282
 283 static LPVOID TABLET_CopyPacketData(LPOPENCONTEXT context, LPVOID lpPkt,
 284                                     LPWTPACKET wtp)
 285 {
 286     LPBYTE ptr;
 287
 288     ptr = lpPkt;
 289     TRACE("Packet Bits %s\n",DUMPBITS(context->context.lcPktData));
 290
 291     if (context->context.lcPktData & PK_CONTEXT)
 292         ptr+=CopyTabletData(ptr,&wtp->pkContext,sizeof(HCTX));
 293     if (context->context.lcPktData & PK_STATUS)
 294         ptr+=CopyTabletData(ptr,&wtp->pkStatus,sizeof(UINT));
 295     if (context->context.lcPktData & PK_TIME)
 296         ptr+=CopyTabletData(ptr,&wtp->pkTime,sizeof(LONG));
 297     if (context->context.lcPktData & PK_CHANGED)
 298         ptr+=CopyTabletData(ptr,&wtp->pkChanged,sizeof(WTPKT));
 299     if (context->context.lcPktData & PK_SERIAL_NUMBER)
 300         ptr+=CopyTabletData(ptr,&wtp->pkChanged,sizeof(UINT));
 301     if (context->context.lcPktData & PK_CURSOR)
 302         ptr+=CopyTabletData(ptr,&wtp->pkCursor,sizeof(UINT));
 303     if (context->context.lcPktData & PK_BUTTONS)
 304         ptr+=CopyTabletData(ptr,&wtp->pkButtons,sizeof(DWORD));
 305     if (context->context.lcPktData & PK_X)
 306         ptr+=CopyTabletData(ptr,&wtp->pkX,sizeof(DWORD));
 307     if (context->context.lcPktData & PK_Y)
 308         ptr+=CopyTabletData(ptr,&wtp->pkY,sizeof(DWORD));
 309     if (context->context.lcPktData & PK_Z)
 310         ptr+=CopyTabletData(ptr,&wtp->pkZ,sizeof(DWORD));
 311     if (context->context.lcPktData & PK_NORMAL_PRESSURE)
 312         ptr+=CopyTabletData(ptr,&wtp->pkNormalPressure,sizeof(UINT));
 313     if (context->context.lcPktData & PK_TANGENT_PRESSURE)
 314         ptr+=CopyTabletData(ptr,&wtp->pkTangentPressure,sizeof(UINT));
 315     if (context->context.lcPktData & PK_ORIENTATION)
 316         ptr+=CopyTabletData(ptr,&wtp->pkOrientation,sizeof(ORIENTATION));
 317     if (context->context.lcPktData & PK_ROTATION)
 318         ptr+=CopyTabletData(ptr,&wtp->pkRotation,sizeof(ROTATION));
 319
 320     /*TRACE("Copied %i bytes\n",(INT)ptr - (INT)lpPkt); */
 321     return ptr;
 322 }
 323
 324 static VOID TABLET_BlankPacketData(LPOPENCONTEXT context, LPVOID lpPkt, INT n)
 325 {
 326     int rc = 0;
 327
 328     if (context->context.lcPktData & PK_CONTEXT)
 329         rc +=sizeof(HCTX);
 330     if (context->context.lcPktData & PK_STATUS)
 331         rc +=sizeof(UINT);
 332     if (context->context.lcPktData & PK_TIME)
 333         rc += sizeof(LONG);
 334     if (context->context.lcPktData & PK_CHANGED)
 335         rc += sizeof(WTPKT);
 336     if (context->context.lcPktData & PK_SERIAL_NUMBER)
 337         rc += sizeof(UINT);
 338     if (context->context.lcPktData & PK_CURSOR)
 339         rc += sizeof(UINT);
 340     if (context->context.lcPktData & PK_BUTTONS)
 341         rc += sizeof(DWORD);
 342     if (context->context.lcPktData & PK_X)
 343         rc += sizeof(DWORD);
 344     if (context->context.lcPktData & PK_Y)
 345         rc += sizeof(DWORD);
 346     if (context->context.lcPktData & PK_Z)
 347         rc += sizeof(DWORD);
 348     if (context->context.lcPktData & PK_NORMAL_PRESSURE)
 349         rc += sizeof(UINT);
 350     if (context->context.lcPktData & PK_TANGENT_PRESSURE)
 351         rc += sizeof(UINT);
 352     if (context->context.lcPktData & PK_ORIENTATION)
 353         rc += sizeof(ORIENTATION);
 354     if (context->context.lcPktData & PK_ROTATION)
 355         rc += sizeof(ROTATION);
 356
 357     rc *= n;
 358     memset(lpPkt,0,rc);
 359 }
 360
 361
 362 UINT WINAPI WTInfoT(UINT wCategory, UINT nIndex, LPVOID lpOutput, BOOL bUnicode)
 363 {
 364     UINT result;
 365
 366     TRACE("(%d, %d, %p, %d)\n", wCategory, nIndex, lpOutput, bUnicode);
 367     if (gLoaded == FALSE)
 368          LoadTablet();
 369
 370     /*
 371      *  Handle system extents here, as we can use user32.dll code to set them.
 372      */
 373     if(wCategory == WTI_DEFSYSCTX)
 374     {
 375         switch(nIndex)
 376         {
 377             case CTX_SYSEXTX:
 378                 if(lpOutput != NULL)
 379                     *(LONG*)lpOutput = GetSystemMetrics(SM_CXSCREEN);
 380                 return sizeof(LONG);
 381             case CTX_SYSEXTY:
 382                 if(lpOutput != NULL)
 383                     *(LONG*)lpOutput = GetSystemMetrics(SM_CYSCREEN);
 384                 return sizeof(LONG);
 385            /* No action, delegate to X11Drv */
 386         }
 387     }
 388
 389     if (is_logcontext_category(wCategory) && nIndex == 0)
 390     {
 391         if (lpOutput)
 392         {
 393             LOGCONTEXTW buf;
 394             pWTInfoW(wCategory, nIndex, &buf);
 395
 396             /*  Handle system extents here, as we can use user32.dll code to set them */
 397             if(wCategory == WTI_DEFSYSCTX && nIndex == 0)
 398             {
 399                 buf.lcSysExtX = GetSystemMetrics(SM_CXSCREEN);
 400                 buf.lcSysExtY = GetSystemMetrics(SM_CYSCREEN);
 401             }
 402
 403             if (bUnicode)
 404                 memcpy(lpOutput, &buf, sizeof(buf));
 405             else
 406                 LOGCONTEXTWtoA(&buf, lpOutput);
 407         }
 408
 409         result = bUnicode ? sizeof(LOGCONTEXTW) : sizeof(LOGCONTEXTA);
 410     }
 411     else if (is_string_field(wCategory, nIndex) && !bUnicode)
 412     {
 413         int size = pWTInfoW(wCategory, nIndex, NULL);
 414         WCHAR *buf = HeapAlloc(GetProcessHeap(), 0, size);
 415         pWTInfoW(wCategory, nIndex, buf);
 416         result = WideCharToMultiByte(CP_ACP, 0, buf, size/sizeof(WCHAR), lpOutput, lpOutput ? 2*size : 0, NULL, NULL);
 417         HeapFree(GetProcessHeap(), 0, buf);
 418     }
 419     else
 420         result =  pWTInfoW(wCategory, nIndex, lpOutput);
 421
 422     TRACE("returns %d\n", result);
 423     return result;
 424 }
 425
 426 /***********************************************************************
 427  *              WTInfoA (WINTAB32.20)
 428  */
 429 UINT WINAPI WTInfoA(UINT wCategory, UINT nIndex, LPVOID lpOutput)
 430 {
 431     return WTInfoT(wCategory, nIndex, lpOutput, FALSE);
 432 }
 433
 434
 435 /***********************************************************************
 436  *              WTInfoW (WINTAB32.1020)
 437  */
 438 UINT WINAPI WTInfoW(UINT wCategory, UINT nIndex, LPVOID lpOutput)
 439 {
 440     return WTInfoT(wCategory, nIndex, lpOutput, TRUE);
 441 }
 442
 443 /***********************************************************************
 444  *              WTOpenW (WINTAB32.2021)
 445  */
 446 HCTX WINAPI WTOpenW(HWND hWnd, LPLOGCONTEXTW lpLogCtx, BOOL fEnable)
 447 {
 448     LPOPENCONTEXT newcontext;
 449
 450     TRACE("hWnd=%p, lpLogCtx=%p, fEnable=%u\n", hWnd, lpLogCtx, fEnable);
 451     DUMPCONTEXT(*lpLogCtx);
 452
 453     newcontext = HeapAlloc(GetProcessHeap(), 0 , sizeof(OPENCONTEXT));
 454     newcontext->context = *lpLogCtx;
 455     newcontext->hwndOwner = hWnd;
 456     newcontext->ActiveCursor = -1;
 457     newcontext->QueueSize = 10;
 458     newcontext->PacketsQueued = 0;
 459     newcontext->PacketQueue=HeapAlloc(GetProcessHeap(),0,sizeof(WTPACKET)*10);
 460
 461     EnterCriticalSection(&csTablet);
 462     newcontext->handle = gTopContext++;
 463     newcontext->next = gOpenContexts;
 464     gOpenContexts = newcontext;
 465     LeaveCriticalSection(&csTablet);
 466
 467     pAttachEventQueueToTablet(hWnd);
 468
 469     TABLET_PostTabletMessage(newcontext, _WT_CTXOPEN(newcontext->context.lcMsgBase), (WPARAM)newcontext->handle,
 470                       newcontext->context.lcStatus, TRUE);
 471
 472     if (fEnable)
 473     {
 474         newcontext->enabled = TRUE;
 475         /* TODO: Add to top of overlap order */
 476         newcontext->context.lcStatus = CXS_ONTOP;
 477     }
 478     else
 479     {
 480         newcontext->enabled = FALSE;
 481         newcontext->context.lcStatus = CXS_DISABLED;
 482     }
 483
 484     TABLET_PostTabletMessage(newcontext, _WT_CTXOVERLAP(newcontext->context.lcMsgBase),
 485                             (WPARAM)newcontext->handle,
 486                             newcontext->context.lcStatus, TRUE);
 487
 488     return newcontext->handle;
 489 }
 490
 491 /***********************************************************************
 492  *              WTOpenA (WINTAB32.21)
 493  */
 494 HCTX WINAPI WTOpenA(HWND hWnd, LPLOGCONTEXTA lpLogCtx, BOOL fEnable)
 495 {
 496     LOGCONTEXTW logCtxW;
 497
 498     LOGCONTEXTAtoW(lpLogCtx, &logCtxW);
 499     return WTOpenW(hWnd, &logCtxW, fEnable);
 500 }
 501
 502 /***********************************************************************
 503  *              WTClose (WINTAB32.22)
 504  */
 505 BOOL WINAPI WTClose(HCTX hCtx)
 506 {
 507     LPOPENCONTEXT context,ptr;
 508
 509     TRACE("(%p)\n", hCtx);
 510
 511     EnterCriticalSection(&csTablet);
 512
 513     ptr = context = gOpenContexts;
 514
 515     while (context && (context->handle != hCtx))
 516     {
 517         ptr = context;
 518         context = context->next;
 519     }
 520     if (!context)
 521     {
 522         LeaveCriticalSection(&csTablet);
 523         return TRUE;
 524     }
 525
 526     if (context == gOpenContexts)
 527         gOpenContexts = context->next;
 528     else
 529         ptr->next = context->next;
 530
 531     LeaveCriticalSection(&csTablet);
 532
 533     TABLET_PostTabletMessage(context, _WT_CTXCLOSE(context->context.lcMsgBase), (WPARAM)context->handle,
 534                       context->context.lcStatus,TRUE);
 535
 536     HeapFree(GetProcessHeap(),0,context->PacketQueue);
 537     HeapFree(GetProcessHeap(),0,context);
 538
 539     return TRUE;
 540 }
 541
 542 /***********************************************************************
 543  *              WTPacketsGet (WINTAB32.23)
 544  */
 545 int WINAPI WTPacketsGet(HCTX hCtx, int cMaxPkts, LPVOID lpPkts)
 546 {
 547     int limit;
 548     LPOPENCONTEXT context;
 549     LPVOID ptr = lpPkts;
 550
 551     TRACE("(%p, %d, %p)\n", hCtx, cMaxPkts, lpPkts);
 552
 553     if (!hCtx)
 554         return 0;
 555
 556     EnterCriticalSection(&csTablet);
 557
 558     context = TABLET_FindOpenContext(hCtx);
 559
 560     if (lpPkts != NULL)
 561         TABLET_BlankPacketData(context,lpPkts,cMaxPkts);
 562
 563     if (context->PacketsQueued == 0)
 564     {
 565         LeaveCriticalSection(&csTablet);
 566         return 0;
 567     }
 568
 569     limit = min(cMaxPkts,context->PacketsQueued);
 570
 571     if(ptr != NULL)
 572     {
 573         int i = 0;
 574         for(i = 0; i < limit; i++)
 575             ptr=TABLET_CopyPacketData(context ,ptr, &context->PacketQueue[i]);
 576     }
 577
 578
 579     if (limit < context->PacketsQueued)
 580     {
 581         memmove(context->PacketQueue, &context->PacketQueue[limit],
 582             (context->PacketsQueued - (limit))*sizeof(WTPACKET));
 583     }
 584     context->PacketsQueued -= limit;
 585     LeaveCriticalSection(&csTablet);
 586
 587     TRACE("Copied %i packets\n",limit);
 588
 589     return limit;
 590 }
 591
 592 /***********************************************************************
 593  *              WTPacket (WINTAB32.24)
 594  */
 595 BOOL WINAPI WTPacket(HCTX hCtx, UINT wSerial, LPVOID lpPkt)
 596 {
 597     int rc = 0;
 598     LPOPENCONTEXT context;
 599     LPWTPACKET wtp = NULL;
 600
 601     TRACE("(%p, %d, %p)\n", hCtx, wSerial, lpPkt);
 602
 603     if (!hCtx)
 604         return 0;
 605
 606     EnterCriticalSection(&csTablet);
 607
 608     context = TABLET_FindOpenContext(hCtx);
 609
 610     rc = TABLET_FindPacket(context ,wSerial, &wtp);
 611
 612     if (rc >= 0)
 613     {
 614         if (lpPkt)
 615            TABLET_CopyPacketData(context ,lpPkt, wtp);
 616
 617         if ((rc+1) < context->QueueSize)
 618         {
 619             memmove(context->PacketQueue, &context->PacketQueue[rc+1],
 620                 (context->PacketsQueued - (rc+1))*sizeof(WTPACKET));
 621         }
 622         context->PacketsQueued -= (rc+1);
 623     }
 624     LeaveCriticalSection(&csTablet);
 625
 626     TRACE("Returning %i\n",rc+1);
 627     return rc+1;
 628 }
 629
 630 /***********************************************************************
 631  *              WTEnable (WINTAB32.40)
 632  */
 633 BOOL WINAPI WTEnable(HCTX hCtx, BOOL fEnable)
 634 {
 635     LPOPENCONTEXT context;
 636
 637     TRACE("hCtx=%p, fEnable=%u\n", hCtx, fEnable);
 638
 639     if (!hCtx) return FALSE;
 640
 641     EnterCriticalSection(&csTablet);
 642     context = TABLET_FindOpenContext(hCtx);
 643     /* if we want to enable and it is not enabled then */
 644     if(fEnable && !context->enabled)
 645     {
 646         context->enabled = TRUE;
 647         /* TODO: Add to top of overlap order */
 648         context->context.lcStatus = CXS_ONTOP;
 649     }
 650     /* if we want to disable and it is not disabled then */
 651     else if (!fEnable && context->enabled)
 652     {
 653         context->enabled = FALSE;
 654         /* TODO: Remove from overlap order?? needs a test */
 655         context->context.lcStatus = CXS_DISABLED;
 656         TABLET_FlushQueue(context);
 657     }
 658     LeaveCriticalSection(&csTablet);
 659
 660     return TRUE;
 661 }
 662
 663 /***********************************************************************
 664  *              WTOverlap (WINTAB32.41)
 665  *
 666  *              Move context to top or bottom of overlap order
 667  */
 668 BOOL WINAPI WTOverlap(HCTX hCtx, BOOL fToTop)
 669 {
 670     LPOPENCONTEXT context;
 671
 672     TRACE("hCtx=%p, fToTop=%u\n", hCtx, fToTop);
 673
 674     if (!hCtx) return FALSE;
 675
 676     EnterCriticalSection(&csTablet);
 677     context = TABLET_FindOpenContext(hCtx);
 678     if (fToTop)
 679     {
 680         /* TODO: Move context to top of overlap order */
 681         FIXME("Not moving context to top of overlap order\n");
 682         context->context.lcStatus = CXS_ONTOP;
 683     }
 684     else
 685     {
 686         /* TODO: Move context to bottom of overlap order */
 687         FIXME("Not moving context to bottom of overlap order\n");
 688         context->context.lcStatus = CXS_OBSCURED;
 689     }
 690     LeaveCriticalSection(&csTablet);
 691
 692     return TRUE;
 693 }
 694
 695 /***********************************************************************
 696  *              WTConfig (WINTAB32.61)
 697  */
 698 BOOL WINAPI WTConfig(HCTX hCtx, HWND hWnd)
 699 {
 700     FIXME("(%p, %p): stub\n", hCtx, hWnd);
 701
 702     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 703
 704     return FALSE;
 705 }
 706
 707 /***********************************************************************
 708  *              WTGetA (WINTAB32.61)
 709  */
 710 BOOL WINAPI WTGetA(HCTX hCtx, LPLOGCONTEXTA lpLogCtx)
 711 {
 712     LPOPENCONTEXT context;
 713
 714     TRACE("(%p, %p)\n", hCtx, lpLogCtx);
 715
 716     if (!hCtx) return 0;
 717
 718     EnterCriticalSection(&csTablet);
 719     context = TABLET_FindOpenContext(hCtx);
 720     LOGCONTEXTWtoA(&context->context, lpLogCtx);
 721     LeaveCriticalSection(&csTablet);
 722
 723     return TRUE;
 724 }
 725
 726 /***********************************************************************
 727  *              WTGetW (WINTAB32.1061)
 728  */
 729 BOOL WINAPI WTGetW(HCTX hCtx, LPLOGCONTEXTW lpLogCtx)
 730 {
 731     LPOPENCONTEXT context;
 732
 733     TRACE("(%p, %p)\n", hCtx, lpLogCtx);
 734
 735     if (!hCtx) return 0;
 736
 737     EnterCriticalSection(&csTablet);
 738     context = TABLET_FindOpenContext(hCtx);
 739     memmove(lpLogCtx,&context->context,sizeof(LOGCONTEXTW));
 740     LeaveCriticalSection(&csTablet);
 741
 742     return TRUE;
 743 }
 744
 745 /***********************************************************************
 746  *              WTSetA (WINTAB32.62)
 747  */
 748 BOOL WINAPI WTSetA(HCTX hCtx, LPLOGCONTEXTA lpLogCtx)
 749 {
 750     LPOPENCONTEXT context;
 751
 752     TRACE("hCtx=%p, lpLogCtx=%p\n", hCtx, lpLogCtx);
 753
 754     if (!hCtx || !lpLogCtx) return FALSE;
 755
 756     /* TODO: if cur process not owner of hCtx only modify
 757      * attribs not locked by owner */
 758
 759     EnterCriticalSection(&csTablet);
 760     context = TABLET_FindOpenContext(hCtx);
 761     LOGCONTEXTAtoW(lpLogCtx, &context->context);
 762     LeaveCriticalSection(&csTablet);
 763
 764     return TRUE;
 765 }
 766
 767 /***********************************************************************
 768  *              WTSetW (WINTAB32.1062)
 769  */
 770 BOOL WINAPI WTSetW(HCTX hCtx, LPLOGCONTEXTW lpLogCtx)
 771 {
 772     LPOPENCONTEXT context;
 773
 774     TRACE("hCtx=%p, lpLogCtx=%p\n", hCtx, lpLogCtx);
 775
 776     if (!hCtx || !lpLogCtx) return FALSE;
 777
 778     /* TODO: if cur process not hCtx owner only modify
 779      * attribs not locked by owner */
 780
 781     EnterCriticalSection(&csTablet);
 782     context = TABLET_FindOpenContext(hCtx);
 783     memmove(&context->context, lpLogCtx, sizeof(LOGCONTEXTW));
 784     LeaveCriticalSection(&csTablet);
 785
 786     return TRUE;
 787 }
 788
 789 /***********************************************************************
 790  *              WTExtGet (WINTAB32.63)
 791  */
 792 BOOL WINAPI WTExtGet(HCTX hCtx, UINT wExt, LPVOID lpData)
 793 {
 794     FIXME("(%p, %u, %p): stub\n", hCtx, wExt, lpData);
 795
 796     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 797
 798     return FALSE;
 799 }
 800
 801 /***********************************************************************
 802  *              WTExtSet (WINTAB32.64)
 803  */
 804 BOOL WINAPI WTExtSet(HCTX hCtx, UINT wExt, LPVOID lpData)
 805 {
 806     FIXME("(%p, %u, %p): stub\n", hCtx, wExt, lpData);
 807
 808     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 809
 810     return FALSE;
 811 }
 812
 813 /***********************************************************************
 814  *              WTSave (WINTAB32.65)
 815  */
 816 BOOL WINAPI WTSave(HCTX hCtx, LPVOID lpSaveInfo)
 817 {
 818     FIXME("(%p, %p): stub\n", hCtx, lpSaveInfo);
 819
 820     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 821
 822     return FALSE;
 823 }
 824
 825 /***********************************************************************
 826  *              WTRestore (WINTAB32.66)
 827  */
 828 HCTX WINAPI WTRestore(HWND hWnd, LPVOID lpSaveInfo, BOOL fEnable)
 829 {
 830     FIXME("(%p, %p, %u): stub\n", hWnd, lpSaveInfo, fEnable);
 831
 832     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 833
 834     return 0;
 835 }
 836
 837 /***********************************************************************
 838  *              WTPacketsPeek (WINTAB32.80)
 839  */
 840 int WINAPI WTPacketsPeek(HCTX hCtx, int cMaxPkts, LPVOID lpPkts)
 841 {
 842     int limit;
 843     LPOPENCONTEXT context;
 844     LPVOID ptr = lpPkts;
 845
 846     TRACE("(%p, %d, %p)\n", hCtx, cMaxPkts, lpPkts);
 847
 848     if (!hCtx || !lpPkts) return 0;
 849
 850     EnterCriticalSection(&csTablet);
 851
 852     context = TABLET_FindOpenContext(hCtx);
 853
 854     if (context->PacketsQueued == 0)
 855     {
 856         LeaveCriticalSection(&csTablet);
 857         return 0;
 858     }
 859
 860     for (limit = 0; limit < cMaxPkts && limit < context->PacketsQueued; limit++)
 861         ptr = TABLET_CopyPacketData(context ,ptr, &context->PacketQueue[limit]);
 862
 863     LeaveCriticalSection(&csTablet);
 864     TRACE("Copied %i packets\n",limit);
 865     return limit;
 866 }
 867
 868 /***********************************************************************
 869  *              WTDataGet (WINTAB32.81)
 870  */
 871 int WINAPI WTDataGet(HCTX hCtx, UINT wBegin, UINT wEnd,
 872                      int cMaxPkts, LPVOID lpPkts, LPINT lpNPkts)
 873 {
 874     LPOPENCONTEXT context;
 875     LPVOID ptr = lpPkts;
 876     INT bgn = 0;
 877     INT end = 0;
 878     INT num = 0;
 879
 880     TRACE("(%p, %u, %u, %d, %p, %p)\n",
 881           hCtx, wBegin, wEnd, cMaxPkts, lpPkts, lpNPkts);
 882
 883     if (!hCtx) return 0;
 884
 885     EnterCriticalSection(&csTablet);
 886
 887     context = TABLET_FindOpenContext(hCtx);
 888
 889     if (context->PacketsQueued == 0)
 890     {
 891         LeaveCriticalSection(&csTablet);
 892         return 0;
 893     }
 894
 895     while (bgn < context->PacketsQueued &&
 896            context->PacketQueue[bgn].pkSerialNumber != wBegin)
 897         bgn++;
 898
 899     end = bgn;
 900     while (end < context->PacketsQueued &&
 901            context->PacketQueue[end].pkSerialNumber != wEnd)
 902         end++;
 903
 904     if ((bgn == end) && (end == context->PacketsQueued))
 905     {
 906         LeaveCriticalSection(&csTablet);
 907         return 0;
 908     }
 909
 910     for (num = bgn; num <= end; num++)
 911         ptr = TABLET_CopyPacketData(context ,ptr, &context->PacketQueue[num]);
 912
 913     /* remove read packets */
 914     if ((end+1) < context->PacketsQueued)
 915         memmove( &context->PacketQueue[bgn], &context->PacketQueue[end+1],
 916                 (context->PacketsQueued - (end+1)) * sizeof (WTPACKET));
 917
 918     context->PacketsQueued -= ((end-bgn)+1);
 919     *lpNPkts = ((end-bgn)+1);
 920
 921     LeaveCriticalSection(&csTablet);
 922     TRACE("Copied %i packets\n",*lpNPkts);
 923     return (end - bgn)+1;
 924 }
 925
 926 /***********************************************************************
 927  *              WTDataPeek (WINTAB32.82)
 928  */
 929 int WINAPI WTDataPeek(HCTX hCtx, UINT wBegin, UINT wEnd,
 930                       int cMaxPkts, LPVOID lpPkts, LPINT lpNPkts)
 931 {
 932     LPOPENCONTEXT context;
 933     LPVOID ptr = lpPkts;
 934     INT bgn = 0;
 935     INT end = 0;
 936     INT num = 0;
 937
 938     TRACE("(%p, %u, %u, %d, %p, %p)\n",
 939           hCtx, wBegin, wEnd, cMaxPkts, lpPkts, lpNPkts);
 940
 941     if (!hCtx || !lpPkts) return 0;
 942
 943     EnterCriticalSection(&csTablet);
 944
 945     context = TABLET_FindOpenContext(hCtx);
 946
 947     if (context->PacketsQueued == 0)
 948     {
 949         LeaveCriticalSection(&csTablet);
 950         return 0;
 951     }
 952
 953     while (bgn < context->PacketsQueued &&
 954            context->PacketQueue[bgn].pkSerialNumber != wBegin)
 955         bgn++;
 956
 957     end = bgn;
 958     while (end < context->PacketsQueued &&
 959            context->PacketQueue[end].pkSerialNumber != wEnd)
 960         end++;
 961
 962     if (bgn == context->PacketsQueued ||  end == context->PacketsQueued)
 963     {
 964         TRACE("%i %i %i\n", bgn, end, context->PacketsQueued);
 965         LeaveCriticalSection(&csTablet);
 966         return 0;
 967     }
 968
 969     for (num = bgn; num <= end; num++)
 970         ptr = TABLET_CopyPacketData(context ,ptr, &context->PacketQueue[num]);
 971
 972     *lpNPkts = ((end-bgn)+1);
 973     LeaveCriticalSection(&csTablet);
 974
 975     TRACE("Copied %i packets\n",*lpNPkts);
 976     return (end - bgn)+1;
 977 }
 978
 979 /***********************************************************************
 980  *              WTQueuePacketsEx (WINTAB32.200)
 981  */
 982 BOOL WINAPI WTQueuePacketsEx(HCTX hCtx, UINT *lpOld, UINT *lpNew)
 983 {
 984     LPOPENCONTEXT context;
 985
 986     TRACE("(%p, %p, %p)\n", hCtx, lpOld, lpNew);
 987
 988     if (!hCtx) return 0;
 989
 990     EnterCriticalSection(&csTablet);
 991
 992     context = TABLET_FindOpenContext(hCtx);
 993
 994     if (context->PacketsQueued)
 995     {
 996         *lpOld = context->PacketQueue[0].pkSerialNumber;
 997         *lpNew = context->PacketQueue[context->PacketsQueued-1].pkSerialNumber;
 998     }
 999     else
1000     {
1001         TRACE("No packets\n");
1002         LeaveCriticalSection(&csTablet);
1003         return FALSE;
1004     }
1005     LeaveCriticalSection(&csTablet);
1006
1007     return TRUE;
1008 }
1009
1010 /***********************************************************************
1011  *              WTQueueSizeGet (WINTAB32.84)
1012  */
1013 int WINAPI WTQueueSizeGet(HCTX hCtx)
1014 {
1015     LPOPENCONTEXT context;
1016     TRACE("(%p)\n", hCtx);
1017
1018     if (!hCtx) return 0;
1019
1020     EnterCriticalSection(&csTablet);
1021     context = TABLET_FindOpenContext(hCtx);
1022     LeaveCriticalSection(&csTablet);
1023     return context->QueueSize;
1024 }
1025
1026 /***********************************************************************
1027  *              WTQueueSizeSet (WINTAB32.85)
1028  */
1029 BOOL WINAPI WTQueueSizeSet(HCTX hCtx, int nPkts)
1030 {
1031     LPOPENCONTEXT context;
1032
1033     TRACE("(%p, %d)\n", hCtx, nPkts);
1034
1035     if (!hCtx) return 0;
1036
1037     EnterCriticalSection(&csTablet);
1038
1039     context = TABLET_FindOpenContext(hCtx);
1040
1041     context->PacketQueue = HeapReAlloc(GetProcessHeap(), 0,
1042                         context->PacketQueue, sizeof(WTPACKET)*nPkts);
1043
1044     context->QueueSize = nPkts;
1045     LeaveCriticalSection(&csTablet);
1046
1047     return nPkts;
1048 }