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