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