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("context: %s, %x, %x, %x, %x, %x, %x, %x%s, %x%s, %x%s, %x, %x, %i, %i, %i, %i ,%i, %i, %i, %i, %i,%i, %i, %i, %i, %i, %i, %i, %i, %i, %i, %i %i %i",
 118           wine_dbgstr_w(lc.lcName), lc.lcOptions, lc.lcStatus, lc.lcLocks, lc.lcMsgBase,
 119           lc.lcDevice, lc.lcPktRate, lc.lcPktData, DUMPBITS(lc.lcPktData),
 120           lc.lcPktMode, DUMPBITS(lc.lcPktMode), lc.lcMoveMask,
 121           DUMPBITS(lc.lcMoveMask), lc.lcBtnDnMask, lc.lcBtnUpMask,
 122           lc.lcInOrgX, lc.lcInOrgY, lc.lcInOrgZ, lc.lcInExtX, lc.lcInExtY,
 123           lc.lcInExtZ, lc.lcOutOrgX, lc.lcOutOrgY, lc.lcOutOrgZ, lc.lcOutExtX,
 124           lc.lcOutExtY, lc.lcOutExtZ, lc.lcSensX, lc.lcSensY, lc.lcSensZ, lc.lcSysMode,
 125           lc.lcSysOrgX, lc.lcSysOrgY, lc.lcSysExtX, lc.lcSysExtY, lc.lcSysSensX,
 126           lc.lcSysSensY);
 127 }
 128
 129
 130 /* Find an open context given the handle */
 131 static LPOPENCONTEXT TABLET_FindOpenContext(HCTX hCtx)
 132 {
 133     LPOPENCONTEXT ptr = gOpenContexts;
 134     while (ptr)
 135     {
 136         if (ptr->handle == hCtx) return ptr;
 137         ptr = ptr->next;
 138     }
 139     return NULL;
 140 }
 141
 142 static void LoadTablet(void)
 143 {
 144     TRACE("Initializing the tablet to hwnd %p\n",hwndDefault);
 145     gLoaded= TRUE;
 146     pLoadTabletInfo(hwndDefault);
 147 }
 148
 149 int TABLET_PostTabletMessage(LPOPENCONTEXT newcontext, UINT msg, WPARAM wParam,
 150                              LPARAM lParam, BOOL send_always)
 151 {
 152     if ((send_always) || (newcontext->context.lcOptions & CXO_MESSAGES))
 153     {
 154         TRACE("Posting message %x to %p\n",msg, newcontext->hwndOwner);
 155         return PostMessageA(newcontext->hwndOwner, msg, wParam, lParam);
 156     }
 157     return 0;
 158 }
 159
 160 static inline DWORD ScaleForContext(DWORD In, DWORD InOrg, DWORD InExt, DWORD
 161                                     OutOrg, DWORD OutExt)
 162 {
 163     if (((InExt > 0 )&&(OutExt > 0)) || ((InExt<0) && (OutExt < 0)))
 164         return ((In - InOrg) * abs(OutExt) / abs(InExt)) + OutOrg;
 165     else
 166         return ((abs(InExt) - (In - InOrg))*abs(OutExt) / abs(InExt)) + OutOrg;
 167 }
 168
 169 LPOPENCONTEXT FindOpenContext(HWND hwnd)
 170 {
 171     LPOPENCONTEXT ptr;
 172
 173     EnterCriticalSection(&csTablet);
 174     ptr = gOpenContexts;
 175     while (ptr)
 176     {
 177         TRACE("Trying Context %p (%p %p)\n",ptr->handle,hwnd,ptr->hwndOwner);
 178         if (ptr->hwndOwner == hwnd) break;
 179     }
 180     LeaveCriticalSection(&csTablet);
 181     return ptr;
 182 }
 183
 184 LPOPENCONTEXT AddPacketToContextQueue(LPWTPACKET packet, HWND hwnd)
 185 {
 186     LPOPENCONTEXT ptr=NULL;
 187
 188     EnterCriticalSection(&csTablet);
 189
 190     ptr = gOpenContexts;
 191     while (ptr)
 192     {
 193         TRACE("Trying Queue %p (%p %p)\n", ptr->handle, hwnd, ptr->hwndOwner);
 194
 195         if (ptr->hwndOwner == hwnd)
 196         {
 197             int tgt;
 198             if (!ptr->enabled)
 199             {
 200                 ptr = ptr->next;
 201                 continue;
 202             }
 203
 204             tgt = ptr->PacketsQueued;
 205
 206             packet->pkContext = ptr->handle;
 207
 208             /* translate packet data to the context */
 209
 210             /* Scale  as per documentation */
 211             packet->pkY = ScaleForContext(packet->pkY, ptr->context.lcInOrgY,
 212                                 ptr->context.lcInExtY, ptr->context.lcOutOrgY,
 213                                 ptr->context.lcOutExtY);
 214
 215             packet->pkX = ScaleForContext(packet->pkX, ptr->context.lcInOrgX,
 216                                 ptr->context.lcInExtX, ptr->context.lcOutOrgX,
 217                                 ptr->context.lcOutExtX);
 218
 219             /* flip the Y axis */
 220             if (ptr->context.lcOutExtY > 0)
 221                 packet->pkY = ptr->context.lcOutExtY - packet->pkY;
 222
 223             DUMPPACKET(*packet);
 224
 225             if (tgt == ptr->QueueSize)
 226             {
 227                 TRACE("Queue Overflow %p\n",ptr->handle);
 228                 ptr->PacketQueue[tgt-1].pkStatus |= TPS_QUEUE_ERR;
 229             }
 230             else
 231             {
 232                 TRACE("Placed in queue %p index %i\n",ptr->handle,tgt);
 233                 memcpy(&ptr->PacketQueue[tgt], packet, sizeof
 234                         (WTPACKET));
 235                 ptr->PacketsQueued++;
 236
 237                 if (ptr->ActiveCursor != packet->pkCursor)
 238                 {
 239                     ptr->ActiveCursor = packet->pkCursor;
 240                     if (ptr->context.lcOptions & CXO_CSRMESSAGES)
 241                         TABLET_PostTabletMessage(ptr, _WT_CSRCHANGE(ptr->context.lcMsgBase),
 242                           (WPARAM)packet->pkSerialNumber, (LPARAM)ptr->handle,
 243                             FALSE);
 244                 }
 245             }
 246             break;
 247          }
 248         ptr = ptr->next;
 249     }
 250     LeaveCriticalSection(&csTablet);
 251     TRACE("Done (%p)\n",ptr);
 252     return ptr;
 253 }
 254
 255 /*
 256  * Flushes all packets from the queue.
 257  */
 258 static inline void TABLET_FlushQueue(LPOPENCONTEXT context)
 259 {
 260     context->PacketsQueued = 0;
 261 }
 262
 263 static inline int CopyTabletData(LPVOID target, LPVOID src, INT size)
 264 {
 265     memcpy(target,src,size);
 266     return(size);
 267 }
 268
 269 static INT TABLET_FindPacket(LPOPENCONTEXT context, UINT wSerial,
 270                                 LPWTPACKET *pkt)
 271 {
 272     int loop;
 273     int index  = -1;
 274     for (loop = 0; loop < context->PacketsQueued; loop++)
 275         if (context->PacketQueue[loop].pkSerialNumber == wSerial)
 276         {
 277             index = loop;
 278             *pkt = &context->PacketQueue[loop];
 279             break;
 280         }
 281
 282     TRACE("%i .. %i\n",context->PacketsQueued,index);
 283
 284     return index;
 285 }
 286
 287
 288 static LPVOID TABLET_CopyPacketData(LPOPENCONTEXT context, LPVOID lpPkt,
 289                                     LPWTPACKET wtp)
 290 {
 291     LPBYTE ptr;
 292
 293     ptr = lpPkt;
 294     TRACE("Packet Bits %s\n",DUMPBITS(context->context.lcPktData));
 295
 296     if (context->context.lcPktData & PK_CONTEXT)
 297         ptr+=CopyTabletData(ptr,&wtp->pkContext,sizeof(HCTX));
 298     if (context->context.lcPktData & PK_STATUS)
 299         ptr+=CopyTabletData(ptr,&wtp->pkStatus,sizeof(UINT));
 300     if (context->context.lcPktData & PK_TIME)
 301         ptr+=CopyTabletData(ptr,&wtp->pkTime,sizeof(LONG));
 302     if (context->context.lcPktData & PK_CHANGED)
 303         ptr+=CopyTabletData(ptr,&wtp->pkChanged,sizeof(WTPKT));
 304     if (context->context.lcPktData & PK_SERIAL_NUMBER)
 305         ptr+=CopyTabletData(ptr,&wtp->pkChanged,sizeof(UINT));
 306     if (context->context.lcPktData & PK_CURSOR)
 307         ptr+=CopyTabletData(ptr,&wtp->pkCursor,sizeof(UINT));
 308     if (context->context.lcPktData & PK_BUTTONS)
 309         ptr+=CopyTabletData(ptr,&wtp->pkButtons,sizeof(DWORD));
 310     if (context->context.lcPktData & PK_X)
 311         ptr+=CopyTabletData(ptr,&wtp->pkX,sizeof(DWORD));
 312     if (context->context.lcPktData & PK_Y)
 313         ptr+=CopyTabletData(ptr,&wtp->pkY,sizeof(DWORD));
 314     if (context->context.lcPktData & PK_Z)
 315         ptr+=CopyTabletData(ptr,&wtp->pkZ,sizeof(DWORD));
 316     if (context->context.lcPktData & PK_NORMAL_PRESSURE)
 317         ptr+=CopyTabletData(ptr,&wtp->pkNormalPressure,sizeof(UINT));
 318     if (context->context.lcPktData & PK_TANGENT_PRESSURE)
 319         ptr+=CopyTabletData(ptr,&wtp->pkTangentPressure,sizeof(UINT));
 320     if (context->context.lcPktData & PK_ORIENTATION)
 321         ptr+=CopyTabletData(ptr,&wtp->pkOrientation,sizeof(ORIENTATION));
 322     if (context->context.lcPktData & PK_ROTATION)
 323         ptr+=CopyTabletData(ptr,&wtp->pkRotation,sizeof(ROTATION));
 324
 325     /*TRACE("Copied %i bytes\n",(INT)ptr - (INT)lpPkt); */
 326     return ptr;
 327 }
 328
 329 static VOID TABLET_BlankPacketData(LPOPENCONTEXT context, LPVOID lpPkt, INT n)
 330 {
 331     int rc = 0;
 332
 333     if (context->context.lcPktData & PK_CONTEXT)
 334         rc +=sizeof(HCTX);
 335     if (context->context.lcPktData & PK_STATUS)
 336         rc +=sizeof(UINT);
 337     if (context->context.lcPktData & PK_TIME)
 338         rc += sizeof(LONG);
 339     if (context->context.lcPktData & PK_CHANGED)
 340         rc += sizeof(WTPKT);
 341     if (context->context.lcPktData & PK_SERIAL_NUMBER)
 342         rc += sizeof(UINT);
 343     if (context->context.lcPktData & PK_CURSOR)
 344         rc += sizeof(UINT);
 345     if (context->context.lcPktData & PK_BUTTONS)
 346         rc += sizeof(DWORD);
 347     if (context->context.lcPktData & PK_X)
 348         rc += sizeof(DWORD);
 349     if (context->context.lcPktData & PK_Y)
 350         rc += sizeof(DWORD);
 351     if (context->context.lcPktData & PK_Z)
 352         rc += sizeof(DWORD);
 353     if (context->context.lcPktData & PK_NORMAL_PRESSURE)
 354         rc += sizeof(UINT);
 355     if (context->context.lcPktData & PK_TANGENT_PRESSURE)
 356         rc += sizeof(UINT);
 357     if (context->context.lcPktData & PK_ORIENTATION)
 358         rc += sizeof(ORIENTATION);
 359     if (context->context.lcPktData & PK_ROTATION)
 360         rc += sizeof(ROTATION);
 361
 362     rc *= n;
 363     memset(lpPkt,0,rc);
 364 }
 365
 366
 367 UINT WINAPI WTInfoT(UINT wCategory, UINT nIndex, LPVOID lpOutput, BOOL bUnicode)
 368 {
 369     UINT result;
 370     if (gLoaded == FALSE)
 371          LoadTablet();
 372
 373     /*
 374      *  Handle system extents here, as we can use user32.dll code to set them.
 375      */
 376     if(wCategory == WTI_DEFSYSCTX)
 377     {
 378         switch(nIndex)
 379         {
 380             case CTX_SYSEXTX:
 381                 if(lpOutput != NULL)
 382                     *(LONG*)lpOutput = GetSystemMetrics(SM_CXSCREEN);
 383                 return sizeof(LONG);
 384             case CTX_SYSEXTY:
 385                 if(lpOutput != NULL)
 386                     *(LONG*)lpOutput = GetSystemMetrics(SM_CYSCREEN);
 387                 return sizeof(LONG);
 388            /* No action, delegate to X11Drv */
 389         }
 390     }
 391
 392     if (is_logcontext_category(wCategory) && nIndex == 0)
 393     {
 394         if (lpOutput)
 395         {
 396             LOGCONTEXTW buf;
 397             pWTInfoW(wCategory, nIndex, &buf);
 398
 399             /*  Handle system extents here, as we can use user32.dll code to set them */
 400             if(wCategory == WTI_DEFSYSCTX && nIndex == 0)
 401             {
 402                 buf.lcSysExtX = GetSystemMetrics(SM_CXSCREEN);
 403                 buf.lcSysExtY = GetSystemMetrics(SM_CYSCREEN);
 404             }
 405
 406             if (bUnicode)
 407                 memcpy(lpOutput, &buf, sizeof(buf));
 408             else
 409                 LOGCONTEXTWtoA(&buf, lpOutput);
 410         }
 411
 412         return bUnicode ? sizeof(LOGCONTEXTW) : sizeof(LOGCONTEXTA);
 413     }
 414     else if (is_string_field(wCategory, nIndex) && !bUnicode)
 415     {
 416         int size = pWTInfoW(wCategory, nIndex, NULL);
 417         WCHAR *buf = HeapAlloc(GetProcessHeap(), 0, size);
 418         pWTInfoW(wCategory, nIndex, buf);
 419         result = WideCharToMultiByte(CP_ACP, 0, buf, size/sizeof(WCHAR), lpOutput, lpOutput ? 2*size : 0, NULL, NULL);
 420         HeapFree(GetProcessHeap(), 0, buf);
 421     }
 422     else
 423         result =  pWTInfoW(wCategory, nIndex, lpOutput);
 424
 425     return result;
 426 }
 427
 428 /***********************************************************************
 429  *              WTInfoA (WINTAB32.20)
 430  */
 431 UINT WINAPI WTInfoA(UINT wCategory, UINT nIndex, LPVOID lpOutput)
 432 {
 433     return WTInfoT(wCategory, nIndex, lpOutput, FALSE);
 434 }
 435
 436
 437 /***********************************************************************
 438  *              WTInfoW (WINTAB32.1020)
 439  */
 440 UINT WINAPI WTInfoW(UINT wCategory, UINT nIndex, LPVOID lpOutput)
 441 {
 442     return WTInfoT(wCategory, nIndex, lpOutput, TRUE);
 443 }
 444
 445 /***********************************************************************
 446  *              WTOpenW (WINTAB32.2021)
 447  */
 448 HCTX WINAPI WTOpenW(HWND hWnd, LPLOGCONTEXTW lpLogCtx, BOOL fEnable)
 449 {
 450     LPOPENCONTEXT newcontext;
 451
 452     TRACE("(%p, %p, %u)\n", hWnd, lpLogCtx, fEnable);
 453     DUMPCONTEXT(*lpLogCtx);
 454
 455     newcontext = HeapAlloc(GetProcessHeap(), 0 , sizeof(OPENCONTEXT));
 456     memcpy(&(newcontext->context),lpLogCtx,sizeof(LOGCONTEXTW));
 457     newcontext->hwndOwner = hWnd;
 458     newcontext->enabled = fEnable;
 459     newcontext->ActiveCursor = -1;
 460     newcontext->QueueSize = 10;
 461     newcontext->PacketsQueued = 0;
 462     newcontext->PacketQueue=HeapAlloc(GetProcessHeap(),0,sizeof(WTPACKET)*10);
 463
 464     EnterCriticalSection(&csTablet);
 465     newcontext->handle = gTopContext++;
 466     newcontext->next = gOpenContexts;
 467     gOpenContexts = newcontext;
 468     LeaveCriticalSection(&csTablet);
 469
 470     pAttachEventQueueToTablet(hWnd);
 471
 472     TABLET_PostTabletMessage(newcontext, _WT_CTXOPEN(newcontext->context.lcMsgBase), (WPARAM)newcontext->handle,
 473                       newcontext->context.lcStatus, TRUE);
 474
 475     newcontext->context.lcStatus = CXS_ONTOP;
 476
 477     TABLET_PostTabletMessage(newcontext, _WT_CTXOVERLAP(newcontext->context.lcMsgBase),
 478                             (WPARAM)newcontext->handle,
 479                             newcontext->context.lcStatus, TRUE);
 480
 481     return newcontext->handle;
 482 }
 483
 484 /***********************************************************************
 485  *              WTOpenA (WINTAB32.21)
 486  */
 487 HCTX WINAPI WTOpenA(HWND hWnd, LPLOGCONTEXTA lpLogCtx, BOOL fEnable)
 488 {
 489     LOGCONTEXTW logCtxW;
 490
 491     LOGCONTEXTAtoW(lpLogCtx, &logCtxW);
 492     return WTOpenW(hWnd, &logCtxW, fEnable);
 493 }
 494
 495 /***********************************************************************
 496  *              WTClose (WINTAB32.22)
 497  */
 498 BOOL WINAPI WTClose(HCTX hCtx)
 499 {
 500     LPOPENCONTEXT context,ptr;
 501
 502     TRACE("(%p)\n", hCtx);
 503
 504     EnterCriticalSection(&csTablet);
 505
 506     ptr = context = gOpenContexts;
 507
 508     while (context && (context->handle != hCtx))
 509     {
 510         ptr = context;
 511         context = context->next;
 512     }
 513     if (!context)
 514     {
 515         LeaveCriticalSection(&csTablet);
 516         return TRUE;
 517     }
 518
 519     if (context == gOpenContexts)
 520         gOpenContexts = context->next;
 521     else
 522         ptr->next = context->next;
 523
 524     LeaveCriticalSection(&csTablet);
 525
 526     TABLET_PostTabletMessage(context, _WT_CTXCLOSE(context->context.lcMsgBase), (WPARAM)context->handle,
 527                       context->context.lcStatus,TRUE);
 528
 529     HeapFree(GetProcessHeap(),0,context->PacketQueue);
 530     HeapFree(GetProcessHeap(),0,context);
 531
 532     return TRUE;
 533 }
 534
 535 /***********************************************************************
 536  *              WTPacketsGet (WINTAB32.23)
 537  */
 538 int WINAPI WTPacketsGet(HCTX hCtx, int cMaxPkts, LPVOID lpPkts)
 539 {
 540     int limit;
 541     LPOPENCONTEXT context;
 542     LPVOID ptr = lpPkts;
 543
 544     TRACE("(%p, %d, %p)\n", hCtx, cMaxPkts, lpPkts);
 545
 546     if (!hCtx)
 547         return 0;
 548
 549     EnterCriticalSection(&csTablet);
 550
 551     context = TABLET_FindOpenContext(hCtx);
 552
 553     if (lpPkts != NULL)
 554         TABLET_BlankPacketData(context,lpPkts,cMaxPkts);
 555
 556     if (context->PacketsQueued == 0)
 557     {
 558         LeaveCriticalSection(&csTablet);
 559         return 0;
 560     }
 561
 562     limit = min(cMaxPkts,context->PacketsQueued);
 563
 564     if(ptr != NULL)
 565     {
 566         int i = 0;
 567         for(i = 0; i < limit; i++)
 568             ptr=TABLET_CopyPacketData(context ,ptr, &context->PacketQueue[i]);
 569     }
 570
 571
 572     if (limit < context->PacketsQueued)
 573     {
 574         memmove(context->PacketQueue, &context->PacketQueue[limit],
 575             (context->PacketsQueued - (limit))*sizeof(WTPACKET));
 576     }
 577     context->PacketsQueued -= limit;
 578     LeaveCriticalSection(&csTablet);
 579
 580     TRACE("Copied %i packets\n",limit);
 581
 582     return limit;
 583 }
 584
 585 /***********************************************************************
 586  *              WTPacket (WINTAB32.24)
 587  */
 588 BOOL WINAPI WTPacket(HCTX hCtx, UINT wSerial, LPVOID lpPkt)
 589 {
 590     int rc = 0;
 591     LPOPENCONTEXT context;
 592     LPWTPACKET wtp = NULL;
 593
 594     TRACE("(%p, %d, %p)\n", hCtx, wSerial, lpPkt);
 595
 596     if (!hCtx)
 597         return 0;
 598
 599     EnterCriticalSection(&csTablet);
 600
 601     context = TABLET_FindOpenContext(hCtx);
 602
 603     rc = TABLET_FindPacket(context ,wSerial, &wtp);
 604
 605     if (rc >= 0)
 606     {
 607         if (lpPkt)
 608            TABLET_CopyPacketData(context ,lpPkt, wtp);
 609
 610         if ((rc+1) < context->QueueSize)
 611         {
 612             memmove(context->PacketQueue, &context->PacketQueue[rc+1],
 613                 (context->PacketsQueued - (rc+1))*sizeof(WTPACKET));
 614         }
 615         context->PacketsQueued -= (rc+1);
 616     }
 617     LeaveCriticalSection(&csTablet);
 618
 619     TRACE("Returning %i\n",rc+1);
 620     return rc+1;
 621 }
 622
 623 /***********************************************************************
 624  *              WTEnable (WINTAB32.40)
 625  */
 626 BOOL WINAPI WTEnable(HCTX hCtx, BOOL fEnable)
 627 {
 628     LPOPENCONTEXT context;
 629
 630     TRACE("(%p, %u)\n", hCtx, fEnable);
 631
 632     if (!hCtx) return 0;
 633
 634     EnterCriticalSection(&csTablet);
 635     context = TABLET_FindOpenContext(hCtx);
 636     if(!fEnable)
 637         TABLET_FlushQueue(context);
 638     context->enabled = fEnable;
 639     LeaveCriticalSection(&csTablet);
 640
 641     return TRUE;
 642 }
 643
 644 /***********************************************************************
 645  *              WTOverlap (WINTAB32.41)
 646  */
 647 BOOL WINAPI WTOverlap(HCTX hCtx, BOOL fToTop)
 648 {
 649     FIXME("(%p, %u): stub\n", hCtx, fToTop);
 650
 651     return TRUE;
 652 }
 653
 654 /***********************************************************************
 655  *              WTConfig (WINTAB32.61)
 656  */
 657 BOOL WINAPI WTConfig(HCTX hCtx, HWND hWnd)
 658 {
 659     FIXME("(%p, %p): stub\n", hCtx, hWnd);
 660
 661     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 662
 663     return FALSE;
 664 }
 665
 666 /***********************************************************************
 667  *              WTGetA (WINTAB32.61)
 668  */
 669 BOOL WINAPI WTGetA(HCTX hCtx, LPLOGCONTEXTA lpLogCtx)
 670 {
 671     LPOPENCONTEXT context;
 672
 673     TRACE("(%p, %p)\n", hCtx, lpLogCtx);
 674
 675     if (!hCtx) return 0;
 676
 677     EnterCriticalSection(&csTablet);
 678     context = TABLET_FindOpenContext(hCtx);
 679     LOGCONTEXTWtoA(&context->context, lpLogCtx);
 680     LeaveCriticalSection(&csTablet);
 681
 682     return TRUE;
 683 }
 684
 685 /***********************************************************************
 686  *              WTGetW (WINTAB32.1061)
 687  */
 688 BOOL WINAPI WTGetW(HCTX hCtx, LPLOGCONTEXTW lpLogCtx)
 689 {
 690     LPOPENCONTEXT context;
 691
 692     TRACE("(%p, %p)\n", hCtx, lpLogCtx);
 693
 694     if (!hCtx) return 0;
 695
 696     EnterCriticalSection(&csTablet);
 697     context = TABLET_FindOpenContext(hCtx);
 698     memmove(lpLogCtx,&context->context,sizeof(LOGCONTEXTW));
 699     LeaveCriticalSection(&csTablet);
 700
 701     return TRUE;
 702 }
 703
 704 /***********************************************************************
 705  *              WTSetA (WINTAB32.62)
 706  */
 707 BOOL WINAPI WTSetA(HCTX hCtx, LPLOGCONTEXTA lpLogCtx)
 708 {
 709     FIXME("(%p, %p): stub\n", hCtx, lpLogCtx);
 710
 711     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 712
 713     return FALSE;
 714 }
 715
 716 /***********************************************************************
 717  *              WTSetW (WINTAB32.1062)
 718  */
 719 BOOL WINAPI WTSetW(HCTX hCtx, LPLOGCONTEXTW lpLogCtx)
 720 {
 721     FIXME("(%p, %p): stub\n", hCtx, lpLogCtx);
 722
 723     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 724
 725     return FALSE;
 726 }
 727
 728 /***********************************************************************
 729  *              WTExtGet (WINTAB32.63)
 730  */
 731 BOOL WINAPI WTExtGet(HCTX hCtx, UINT wExt, LPVOID lpData)
 732 {
 733     FIXME("(%p, %u, %p): stub\n", hCtx, wExt, lpData);
 734
 735     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 736
 737     return FALSE;
 738 }
 739
 740 /***********************************************************************
 741  *              WTExtSet (WINTAB32.64)
 742  */
 743 BOOL WINAPI WTExtSet(HCTX hCtx, UINT wExt, LPVOID lpData)
 744 {
 745     FIXME("(%p, %u, %p): stub\n", hCtx, wExt, lpData);
 746
 747     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 748
 749     return FALSE;
 750 }
 751
 752 /***********************************************************************
 753  *              WTSave (WINTAB32.65)
 754  */
 755 BOOL WINAPI WTSave(HCTX hCtx, LPVOID lpSaveInfo)
 756 {
 757     FIXME("(%p, %p): stub\n", hCtx, lpSaveInfo);
 758
 759     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 760
 761     return FALSE;
 762 }
 763
 764 /***********************************************************************
 765  *              WTRestore (WINTAB32.66)
 766  */
 767 HCTX WINAPI WTRestore(HWND hWnd, LPVOID lpSaveInfo, BOOL fEnable)
 768 {
 769     FIXME("(%p, %p, %u): stub\n", hWnd, lpSaveInfo, fEnable);
 770
 771     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 772
 773     return 0;
 774 }
 775
 776 /***********************************************************************
 777  *              WTPacketsPeek (WINTAB32.80)
 778  */
 779 int WINAPI WTPacketsPeek(HCTX hCtx, int cMaxPkts, LPVOID lpPkts)
 780 {
 781     int limit;
 782     LPOPENCONTEXT context;
 783     LPVOID ptr = lpPkts;
 784
 785     TRACE("(%p, %d, %p)\n", hCtx, cMaxPkts, lpPkts);
 786
 787     if (!hCtx || !lpPkts) return 0;
 788
 789     EnterCriticalSection(&csTablet);
 790
 791     context = TABLET_FindOpenContext(hCtx);
 792
 793     if (context->PacketsQueued == 0)
 794     {
 795         LeaveCriticalSection(&csTablet);
 796         return 0;
 797     }
 798
 799     for (limit = 0; limit < cMaxPkts && limit < context->PacketsQueued; limit++)
 800         ptr = TABLET_CopyPacketData(context ,ptr, &context->PacketQueue[limit]);
 801
 802     LeaveCriticalSection(&csTablet);
 803     TRACE("Copied %i packets\n",limit);
 804     return limit;
 805 }
 806
 807 /***********************************************************************
 808  *              WTDataGet (WINTAB32.81)
 809  */
 810 int WINAPI WTDataGet(HCTX hCtx, UINT wBegin, UINT wEnd,
 811                      int cMaxPkts, LPVOID lpPkts, LPINT lpNPkts)
 812 {
 813     LPOPENCONTEXT context;
 814     LPVOID ptr = lpPkts;
 815     INT bgn = 0;
 816     INT end = 0;
 817     INT num = 0;
 818
 819     TRACE("(%p, %u, %u, %d, %p, %p)\n",
 820           hCtx, wBegin, wEnd, cMaxPkts, lpPkts, lpNPkts);
 821
 822     if (!hCtx) return 0;
 823
 824     EnterCriticalSection(&csTablet);
 825
 826     context = TABLET_FindOpenContext(hCtx);
 827
 828     if (context->PacketsQueued == 0)
 829     {
 830         LeaveCriticalSection(&csTablet);
 831         return 0;
 832     }
 833
 834     while (bgn < context->PacketsQueued &&
 835            context->PacketQueue[bgn].pkSerialNumber != wBegin)
 836         bgn++;
 837
 838     end = bgn;
 839     while (end < context->PacketsQueued &&
 840            context->PacketQueue[end].pkSerialNumber != wEnd)
 841         end++;
 842
 843     if ((bgn == end) && (end == context->PacketsQueued))
 844     {
 845         LeaveCriticalSection(&csTablet);
 846         return 0;
 847     }
 848
 849     for (num = bgn; num <= end; num++)
 850         ptr = TABLET_CopyPacketData(context ,ptr, &context->PacketQueue[num]);
 851
 852     /* remove read packets */
 853     if ((end+1) < context->PacketsQueued)
 854         memmove( &context->PacketQueue[bgn], &context->PacketQueue[end+1],
 855                 (context->PacketsQueued - (end+1)) * sizeof (WTPACKET));
 856
 857     context->PacketsQueued -= ((end-bgn)+1);
 858     *lpNPkts = ((end-bgn)+1);
 859
 860     LeaveCriticalSection(&csTablet);
 861     TRACE("Copied %i packets\n",*lpNPkts);
 862     return (end - bgn)+1;
 863 }
 864
 865 /***********************************************************************
 866  *              WTDataPeek (WINTAB32.82)
 867  */
 868 int WINAPI WTDataPeek(HCTX hCtx, UINT wBegin, UINT wEnd,
 869                       int cMaxPkts, LPVOID lpPkts, LPINT lpNPkts)
 870 {
 871     LPOPENCONTEXT context;
 872     LPVOID ptr = lpPkts;
 873     INT bgn = 0;
 874     INT end = 0;
 875     INT num = 0;
 876
 877     TRACE("(%p, %u, %u, %d, %p, %p)\n",
 878           hCtx, wBegin, wEnd, cMaxPkts, lpPkts, lpNPkts);
 879
 880     if (!hCtx || !lpPkts) return 0;
 881
 882     EnterCriticalSection(&csTablet);
 883
 884     context = TABLET_FindOpenContext(hCtx);
 885
 886     if (context->PacketsQueued == 0)
 887     {
 888         LeaveCriticalSection(&csTablet);
 889         return 0;
 890     }
 891
 892     while (bgn < context->PacketsQueued &&
 893            context->PacketQueue[bgn].pkSerialNumber != wBegin)
 894         bgn++;
 895
 896     end = bgn;
 897     while (end < context->PacketsQueued &&
 898            context->PacketQueue[end].pkSerialNumber != wEnd)
 899         end++;
 900
 901     if (bgn == context->PacketsQueued ||  end == context->PacketsQueued)
 902     {
 903         TRACE("%i %i %i\n", bgn, end, context->PacketsQueued);
 904         LeaveCriticalSection(&csTablet);
 905         return 0;
 906     }
 907
 908     for (num = bgn; num <= end; num++)
 909         ptr = TABLET_CopyPacketData(context ,ptr, &context->PacketQueue[num]);
 910
 911     *lpNPkts = ((end-bgn)+1);
 912     LeaveCriticalSection(&csTablet);
 913
 914     TRACE("Copied %i packets\n",*lpNPkts);
 915     return (end - bgn)+1;
 916 }
 917
 918 /***********************************************************************
 919  *              WTQueuePacketsEx (WINTAB32.200)
 920  */
 921 BOOL WINAPI WTQueuePacketsEx(HCTX hCtx, UINT *lpOld, UINT *lpNew)
 922 {
 923     LPOPENCONTEXT context;
 924
 925     TRACE("(%p, %p, %p)\n", hCtx, lpOld, lpNew);
 926
 927     if (!hCtx) return 0;
 928
 929     EnterCriticalSection(&csTablet);
 930
 931     context = TABLET_FindOpenContext(hCtx);
 932
 933     if (context->PacketsQueued)
 934     {
 935         *lpOld = context->PacketQueue[0].pkSerialNumber;
 936         *lpNew = context->PacketQueue[context->PacketsQueued-1].pkSerialNumber;
 937     }
 938     else
 939     {
 940         TRACE("No packets\n");
 941         LeaveCriticalSection(&csTablet);
 942         return FALSE;
 943     }
 944     LeaveCriticalSection(&csTablet);
 945
 946     return TRUE;
 947 }
 948
 949 /***********************************************************************
 950  *              WTQueueSizeGet (WINTAB32.84)
 951  */
 952 int WINAPI WTQueueSizeGet(HCTX hCtx)
 953 {
 954     LPOPENCONTEXT context;
 955     TRACE("(%p)\n", hCtx);
 956
 957     if (!hCtx) return 0;
 958
 959     EnterCriticalSection(&csTablet);
 960     context = TABLET_FindOpenContext(hCtx);
 961     LeaveCriticalSection(&csTablet);
 962     return context->QueueSize;
 963 }
 964
 965 /***********************************************************************
 966  *              WTQueueSizeSet (WINTAB32.85)
 967  */
 968 BOOL WINAPI WTQueueSizeSet(HCTX hCtx, int nPkts)
 969 {
 970     LPOPENCONTEXT context;
 971
 972     TRACE("(%p, %d)\n", hCtx, nPkts);
 973
 974     if (!hCtx) return 0;
 975
 976     EnterCriticalSection(&csTablet);
 977
 978     context = TABLET_FindOpenContext(hCtx);
 979
 980     context->PacketQueue = HeapReAlloc(GetProcessHeap(), 0,
 981                         context->PacketQueue, sizeof(WTPACKET)*nPkts);
 982
 983     context->QueueSize = nPkts;
 984     LeaveCriticalSection(&csTablet);
 985
 986     return nPkts;
 987 }