git.oblomov.eu Git - wine/blob - dlls/x11drv/wintab.c

   1 /*
   2  * X11 tablet driver
   3  *
   4  * Copyright 2003 CodeWeavers (Aric Stewart)
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include "config.h"
  22 #include "wine/port.h"
  23
  24 #include <stdlib.h>
  25
  26 #include "windef.h"
  27 #include "x11drv.h"
  28 #include "wine/library.h"
  29 #include "wine/debug.h"
  30 #include "wintab.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(wintab32);
  33
  34 typedef struct tagWTI_CURSORS_INFO
  35 {
  36     CHAR   NAME[256];
  37         /* a displayable zero-terminated string containing the name of the
  38          * cursor.
  39          */
  40     BOOL    ACTIVE;
  41         /* whether the cursor is currently connected. */
  42     WTPKT   PKTDATA;
  43         /* a bit mask indicating the packet data items supported when this
  44          * cursor is connected.
  45          */
  46     BYTE    BUTTONS;
  47         /* the number of buttons on this cursor. */
  48     BYTE    BUTTONBITS;
  49         /* the number of bits of raw button data returned by the hardware.*/
  50     CHAR   BTNNAMES[1024]; /* FIXME: make this dynamic */
  51         /* a list of zero-terminated strings containing the names of the
  52          * cursor's buttons. The number of names in the list is the same as the
  53          * number of buttons on the cursor. The names are separated by a single
  54          * zero character; the list is terminated by two zero characters.
  55          */
  56     BYTE    BUTTONMAP[32];
  57         /* a 32 byte array of logical button numbers, one for each physical
  58          * button.
  59          */
  60     BYTE    SYSBTNMAP[32];
  61         /* a 32 byte array of button action codes, one for each logical
  62          * button.
  63          */
  64     BYTE    NPBUTTON;
  65         /* the physical button number of the button that is controlled by normal
  66          * pressure.
  67          */
  68     UINT    NPBTNMARKS[2];
  69         /* an array of two UINTs, specifying the button marks for the normal
  70          * pressure button. The first UINT contains the release mark; the second
  71          * contains the press mark.
  72          */
  73     UINT    *NPRESPONSE;
  74         /* an array of UINTs describing the pressure response curve for normal
  75          * pressure.
  76          */
  77     BYTE    TPBUTTON;
  78         /* the physical button number of the button that is controlled by
  79          * tangential pressure.
  80          */
  81     UINT    TPBTNMARKS[2];
  82         /* an array of two UINTs, specifying the button marks for the tangential
  83          * pressure button. The first UINT contains the release mark; the second
  84          * contains the press mark.
  85          */
  86     UINT    *TPRESPONSE;
  87         /* an array of UINTs describing the pressure response curve for
  88          * tangential pressure.
  89          */
  90     DWORD   PHYSID;
  91          /* a manufacturer-specific physical identifier for the cursor. This
  92           * value will distinguish the physical cursor from others on the same
  93           * device. This physical identifier allows applications to bind
  94           * functions to specific physical cursors, even if category numbers
  95           * change and multiple, otherwise identical, physical cursors are
  96           * present.
  97           */
  98     UINT    MODE;
  99         /* the cursor mode number of this cursor type, if this cursor type has
 100          * the CRC_MULTIMODE capability.
 101          */
 102     UINT    MINPKTDATA;
 103         /* the minimum set of data available from a physical cursor in this
 104          * cursor type, if this cursor type has the CRC_AGGREGATE capability.
 105          */
 106     UINT    MINBUTTONS;
 107         /* the minimum number of buttons of physical cursors in the cursor type,
 108          * if this cursor type has the CRC_AGGREGATE capability.
 109          */
 110     UINT    CAPABILITIES;
 111         /* flags indicating cursor capabilities, as defined below:
 112             CRC_MULTIMODE
 113                 Indicates this cursor type describes one of several modes of a
 114                 single physical cursor. Consecutive cursor type categories
 115                 describe the modes; the CSR_MODE data item gives the mode number
 116                 of each cursor type.
 117             CRC_AGGREGATE
 118                 Indicates this cursor type describes several physical cursors
 119                 that cannot be distinguished by software.
 120             CRC_INVERT
 121                 Indicates this cursor type describes the physical cursor in its
 122                 inverted orientation; the previous consecutive cursor type
 123                 category describes the normal orientation.
 124          */
 125     UINT    TYPE;
 126         /* Manufacturer Unique id for the item type */
 127 } WTI_CURSORS_INFO, *LPWTI_CURSORS_INFO;
 128
 129
 130 typedef struct tagWTI_DEVICES_INFO
 131 {
 132     CHAR   NAME[256];
 133         /* a displayable null- terminated string describing the device,
 134          * manufacturer, and revision level.
 135          */
 136     UINT    HARDWARE;
 137         /* flags indicating hardware and driver capabilities, as defined
 138          * below:
 139             HWC_INTEGRATED:
 140                 Indicates that the display and digitizer share the same surface.
 141             HWC_TOUCH
 142                 Indicates that the cursor must be in physical contact with the
 143                 device to report position.
 144             HWC_HARDPROX
 145                 Indicates that device can generate events when the cursor is
 146                 entering and leaving the physical detection range.
 147             HWC_PHYSID_CURSORS
 148                 Indicates that device can uniquely identify the active cursor in
 149                 hardware.
 150          */
 151     UINT    NCSRTYPES;
 152         /* the number of supported cursor types.*/
 153     UINT    FIRSTCSR;
 154         /* the first cursor type number for the device. */
 155     UINT    PKTRATE;
 156         /* the maximum packet report rate in Hertz. */
 157     WTPKT   PKTDATA;
 158         /* a bit mask indicating which packet data items are always available.*/
 159     WTPKT   PKTMODE;
 160         /* a bit mask indicating which packet data items are physically
 161          * relative, i.e., items for which the hardware can only report change,
 162          * not absolute measurement.
 163          */
 164     WTPKT   CSRDATA;
 165         /* a bit mask indicating which packet data items are only available when
 166          * certain cursors are connected. The individual cursor descriptions
 167          * must be consulted to determine which cursors return which data.
 168          */
 169     INT     XMARGIN;
 170     INT     YMARGIN;
 171     INT     ZMARGIN;
 172         /* the size of tablet context margins in tablet native coordinates, in
 173          * the x, y, and z directions, respectively.
 174          */
 175     AXIS    X;
 176     AXIS    Y;
 177     AXIS    Z;
 178         /* the tablet's range and resolution capabilities, in the x, y, and z
 179          * axes, respectively.
 180          */
 181     AXIS    NPRESSURE;
 182     AXIS    TPRESSURE;
 183         /* the tablet's range and resolution capabilities, for the normal and
 184          * tangential pressure inputs, respectively.
 185          */
 186     AXIS    ORIENTATION[3];
 187         /* a 3-element array describing the tablet's orientation range and
 188          * resolution capabilities.
 189          */
 190     AXIS    ROTATION[3];
 191         /* a 3-element array describing the tablet's rotation range and
 192          * resolution capabilities.
 193          */
 194     CHAR   PNPID[256];
 195         /* a null-terminated string containing the devices Plug and Play ID.*/
 196 }   WTI_DEVICES_INFO, *LPWTI_DEVICES_INFO;
 197
 198 typedef struct tagWTPACKET {
 199         HCTX pkContext;
 200         UINT pkStatus;
 201         LONG pkTime;
 202         WTPKT pkChanged;
 203         UINT pkSerialNumber;
 204         UINT pkCursor;
 205         DWORD pkButtons;
 206         DWORD pkX;
 207         DWORD pkY;
 208         DWORD pkZ;
 209         UINT pkNormalPressure;
 210         UINT pkTangentPressure;
 211         ORIENTATION pkOrientation;
 212         ROTATION pkRotation; /* 1.1 */
 213 } WTPACKET, *LPWTPACKET;
 214
 215
 216 #ifdef HAVE_X11_EXTENSIONS_XINPUT_H
 217
 218 #include <X11/Xlib.h>
 219 #include <X11/extensions/XInput.h>
 220
 221 static int           motion_type;
 222 static int           button_press_type;
 223 static int           button_release_type;
 224 static int           key_press_type;
 225 static int           key_release_type;
 226 static int           proximity_in_type;
 227 static int           proximity_out_type;
 228
 229 static HWND          hwndTabletDefault;
 230 static WTPACKET      gMsgPacket;
 231 static DWORD         gSerial;
 232 static INT           button_state[10];
 233
 234 #define             CURSORMAX 10
 235
 236 static LOGCONTEXTA      gSysContext;
 237 static WTI_DEVICES_INFO gSysDevice;
 238 static WTI_CURSORS_INFO gSysCursor[CURSORMAX];
 239 static INT              gNumCursors;
 240
 241
 242 #ifndef SONAME_LIBXI
 243 #define SONAME_LIBXI "libXi.so"
 244 #endif
 245
 246 /* XInput stuff */
 247 static void *xinput_handle;
 248
 249 #define MAKE_FUNCPTR(f) static typeof(f) * p##f;
 250 MAKE_FUNCPTR(XListInputDevices)
 251 MAKE_FUNCPTR(XFreeDeviceList)
 252 MAKE_FUNCPTR(XOpenDevice)
 253 MAKE_FUNCPTR(XQueryDeviceState)
 254 MAKE_FUNCPTR(XGetDeviceButtonMapping)
 255 MAKE_FUNCPTR(XCloseDevice)
 256 MAKE_FUNCPTR(XSelectExtensionEvent)
 257 MAKE_FUNCPTR(XFreeDeviceState)
 258 #undef MAKE_FUNCPTR
 259
 260 static INT X11DRV_XInput_Init(void)
 261 {
 262     xinput_handle = wine_dlopen(SONAME_LIBXI, RTLD_NOW, NULL, 0);
 263     if (xinput_handle)
 264     {
 265 #define LOAD_FUNCPTR(f) if((p##f = wine_dlsym(xinput_handle, #f, NULL, 0)) == NULL) goto sym_not_found;
 266         LOAD_FUNCPTR(XListInputDevices)
 267         LOAD_FUNCPTR(XFreeDeviceList)
 268         LOAD_FUNCPTR(XOpenDevice)
 269         LOAD_FUNCPTR(XGetDeviceButtonMapping)
 270         LOAD_FUNCPTR(XCloseDevice)
 271         LOAD_FUNCPTR(XSelectExtensionEvent)
 272         LOAD_FUNCPTR(XQueryDeviceState)
 273         LOAD_FUNCPTR(XFreeDeviceState)
 274 #undef LOAD_FUNCPTR
 275         return 1;
 276     }
 277 sym_not_found:
 278     return 0;
 279 }
 280
 281 static int Tablet_ErrorHandler(Display *dpy, XErrorEvent *event, void* arg)
 282 {
 283     return 1;
 284 }
 285
 286 void X11DRV_LoadTabletInfo(HWND hwnddefault)
 287 {
 288     struct x11drv_thread_data *data = x11drv_thread_data();
 289     int num_devices;
 290     int loop;
 291     int cursor_target;
 292     XDeviceInfo *devices;
 293     XDeviceInfo *target = NULL;
 294     BOOL    axis_read_complete= FALSE;
 295
 296     XAnyClassPtr        any;
 297     XButtonInfoPtr      Button;
 298     XValuatorInfoPtr    Val;
 299     XAxisInfoPtr        Axis;
 300
 301     XDevice *opendevice;
 302
 303     if (!X11DRV_XInput_Init())
 304     {
 305         ERR("Unable to initialized the XInput library.\n");
 306         return;
 307     }
 308
 309     hwndTabletDefault = hwnddefault;
 310
 311     /* Do base initializaion */
 312     strcpy(gSysContext.lcName, "Wine Tablet Context");
 313     strcpy(gSysDevice.NAME,"Wine Tablet Device");
 314
 315     gSysContext.lcOptions = CXO_SYSTEM;
 316     gSysContext.lcLocks = CXL_INSIZE | CXL_INASPECT | CXL_MARGIN |
 317                                CXL_SENSITIVITY | CXL_SYSOUT;
 318
 319     gSysContext.lcMsgBase= WT_DEFBASE;
 320     gSysContext.lcDevice = 0;
 321     gSysContext.lcPktData =
 322         PK_CONTEXT | PK_STATUS | PK_SERIAL_NUMBER| PK_TIME | PK_CURSOR |
 323         PK_BUTTONS |  PK_X | PK_Y | PK_NORMAL_PRESSURE | PK_ORIENTATION;
 324     gSysContext.lcMoveMask=
 325         PK_BUTTONS |  PK_X | PK_Y | PK_NORMAL_PRESSURE | PK_ORIENTATION;
 326     gSysContext.lcStatus = CXS_ONTOP;
 327     gSysContext.lcPktRate = 100;
 328     gSysContext.lcBtnDnMask = 0xffffffff;
 329     gSysContext.lcBtnUpMask = 0xffffffff;
 330     gSysContext.lcSensX = 65536;
 331     gSysContext.lcSensY = 65536;
 332     gSysContext.lcSensX = 65536;
 333     gSysContext.lcSensZ = 65536;
 334     gSysContext.lcSysSensX= 65536;
 335     gSysContext.lcSysSensY= 65536;
 336
 337     /* Device Defaults */
 338     gSysDevice.HARDWARE = HWC_HARDPROX|HWC_PHYSID_CURSORS;
 339     gSysDevice.FIRSTCSR= 0;
 340     gSysDevice.PKTRATE = 100;
 341     gSysDevice.PKTDATA =
 342         PK_CONTEXT | PK_STATUS | PK_SERIAL_NUMBER| PK_TIME | PK_CURSOR |
 343         PK_BUTTONS |  PK_X | PK_Y | PK_NORMAL_PRESSURE | PK_ORIENTATION;
 344     strcpy(gSysDevice.PNPID,"non-pluginplay");
 345
 346     wine_tsx11_lock();
 347
 348     cursor_target = -1;
 349     devices = pXListInputDevices(data->display, &num_devices);
 350     if (!devices)
 351     {
 352         WARN("XInput Extenstions reported as not avalable\n");
 353         wine_tsx11_unlock();
 354         return;
 355     }
 356     for (loop=0; loop < num_devices; loop++)
 357     {
 358         int class_loop;
 359
 360         TRACE("Trying device %i(%s)\n",loop,devices[loop].name);
 361         if (devices[loop].use == IsXExtensionDevice)
 362         {
 363             LPWTI_CURSORS_INFO cursor;
 364
 365             TRACE("Is Extension Device\n");
 366             cursor_target++;
 367             target = &devices[loop];
 368             cursor = &gSysCursor[cursor_target];
 369
 370             opendevice = pXOpenDevice(data->display,target->id);
 371             if (opendevice)
 372             {
 373                 unsigned char map[32];
 374                 int i;
 375                 int shft = 0;
 376
 377                 X11DRV_expect_error(data->display,Tablet_ErrorHandler,NULL);
 378                 pXGetDeviceButtonMapping(data->display, opendevice, map, 32);
 379                 if (X11DRV_check_error())
 380                 {
 381                     TRACE("No buttons, Non Tablet Device\n");
 382                     pXCloseDevice(data->display, opendevice);
 383                     cursor_target --;
 384                     continue;
 385                 }
 386
 387                 for (i=0; i< cursor->BUTTONS; i++,shft++)
 388                 {
 389                     cursor->BUTTONMAP[i] = map[i];
 390                     cursor->SYSBTNMAP[i] = (1<<shft);
 391                 }
 392                 pXCloseDevice(data->display, opendevice);
 393             }
 394             else
 395             {
 396                 WARN("Unable to open device %s\n",target->name);
 397                 cursor_target --;
 398                 continue;
 399             }
 400
 401             strcpy(cursor->NAME,target->name);
 402
 403             cursor->ACTIVE = 1;
 404             cursor->PKTDATA = PK_TIME | PK_CURSOR | PK_BUTTONS |  PK_X | PK_Y |
 405                               PK_NORMAL_PRESSURE | PK_TANGENT_PRESSURE |
 406                               PK_ORIENTATION;
 407
 408             cursor->PHYSID = cursor_target;
 409             cursor->NPBUTTON = 1;
 410             cursor->NPBTNMARKS[0] = 0 ;
 411             cursor->NPBTNMARKS[1] = 1 ;
 412             cursor->CAPABILITIES = CRC_MULTIMODE;
 413             if (strcasecmp(cursor->NAME,"stylus")==0)
 414                 cursor->TYPE = 0x4825;
 415             if (strcasecmp(cursor->NAME,"eraser")==0)
 416                 cursor->TYPE = 0xc85a;
 417
 418
 419             any = (XAnyClassPtr) (target->inputclassinfo);
 420
 421             for (class_loop = 0; class_loop < target->num_classes; class_loop++)
 422             {
 423                 switch (any->class)
 424                 {
 425                     case ValuatorClass:
 426                         if (!axis_read_complete)
 427                         {
 428                             Val = (XValuatorInfoPtr) any;
 429                             Axis = (XAxisInfoPtr) ((char *) Val + sizeof
 430                                 (XValuatorInfo));
 431
 432                             if (Val->num_axes>=1)
 433                             {
 434                                 /* Axis 1 is X */
 435                                 gSysDevice.X.axMin = Axis->min_value;
 436                                 gSysDevice.X.axMax= Axis->max_value;
 437                                 gSysDevice.X.axUnits = TU_INCHES;
 438                                 gSysDevice.X.axResolution = Axis->resolution;
 439                                 gSysContext.lcInOrgX = Axis->min_value;
 440                                 gSysContext.lcSysOrgX = Axis->min_value;
 441                                 gSysContext.lcInExtX = Axis->max_value;
 442                                 gSysContext.lcSysExtX = Axis->max_value;
 443                                 Axis++;
 444                             }
 445                             if (Val->num_axes>=2)
 446                             {
 447                                 /* Axis 2 is Y */
 448                                 gSysDevice.Y.axMin = Axis->min_value;
 449                                 gSysDevice.Y.axMax= Axis->max_value;
 450                                 gSysDevice.Y.axUnits = TU_INCHES;
 451                                 gSysDevice.Y.axResolution = Axis->resolution;
 452                                 gSysContext.lcInOrgY = Axis->min_value;
 453                                 gSysContext.lcSysOrgY = Axis->min_value;
 454                                 gSysContext.lcInExtY = Axis->max_value;
 455                                 gSysContext.lcSysExtY = Axis->max_value;
 456                                 Axis++;
 457                             }
 458                             if (Val->num_axes>=3)
 459                             {
 460                                 /* Axis 3 is Normal Pressure */
 461                                 gSysDevice.NPRESSURE.axMin = Axis->min_value;
 462                                 gSysDevice.NPRESSURE.axMax= Axis->max_value;
 463                                 gSysDevice.NPRESSURE.axUnits = TU_INCHES;
 464                                 gSysDevice.NPRESSURE.axResolution =
 465                                                         Axis->resolution;
 466                                 Axis++;
 467                             }
 468                             if (Val->num_axes >= 5)
 469                             {
 470                                 /* Axis 4 and 5 are X and Y tilt */
 471                                 XAxisInfoPtr        XAxis = Axis;
 472                                 Axis++;
 473                                 if (max (abs(Axis->max_value),
 474                                          abs(XAxis->max_value)))
 475                                 {
 476                                     gSysDevice.ORIENTATION[0].axMin = 0;
 477                                     gSysDevice.ORIENTATION[0].axMax = 3600;
 478                                     gSysDevice.ORIENTATION[0].axUnits = TU_CIRCLE;
 479                                     gSysDevice.ORIENTATION[0].axResolution
 480                                                                 = CASTFIX32(3600);
 481                                     gSysDevice.ORIENTATION[1].axMin = -1000;
 482                                     gSysDevice.ORIENTATION[1].axMax = 1000;
 483                                     gSysDevice.ORIENTATION[1].axUnits = TU_CIRCLE;
 484                                     gSysDevice.ORIENTATION[1].axResolution
 485                                                                 = CASTFIX32(3600);
 486                                     Axis++;
 487                                 }
 488                             }
 489                             axis_read_complete = TRUE;
 490                         }
 491                         break;
 492                     case ButtonClass:
 493                     {
 494                         CHAR *ptr = cursor->BTNNAMES;
 495                         int i;
 496
 497                         Button = (XButtonInfoPtr) any;
 498                         cursor->BUTTONS = Button->num_buttons;
 499                         for (i = 0; i < cursor->BUTTONS; i++)
 500                         {
 501                             strcpy(ptr,cursor->NAME);
 502                             ptr+=8;
 503                         }
 504                     }
 505                     break;
 506                 }
 507                 any = (XAnyClassPtr) ((char*) any + any->length);
 508             }
 509         }
 510     }
 511     pXFreeDeviceList(devices);
 512     wine_tsx11_unlock();
 513     gSysDevice.NCSRTYPES = cursor_target+1;
 514     gNumCursors = cursor_target+1;
 515 }
 516
 517 static int figure_deg(int x, int y)
 518 {
 519     int rc;
 520
 521     if (y != 0)
 522     {
 523         rc = (int) 10 * (atan( (FLOAT)abs(y) / (FLOAT)abs(x)) / (3.1415 / 180));
 524         if (y>0)
 525         {
 526             if (x>0)
 527                 rc += 900;
 528             else
 529                 rc = 2700 - rc;
 530         }
 531         else
 532         {
 533             if (x>0)
 534                 rc = 900 - rc;
 535             else
 536                 rc += 2700;
 537         }
 538     }
 539     else
 540     {
 541         if (x >= 0)
 542             rc = 900;
 543         else
 544             rc = 2700;
 545     }
 546
 547     return rc;
 548 }
 549
 550 static int get_button_state(int deviceid)
 551 {
 552     return button_state[deviceid];
 553 }
 554
 555 static void set_button_state(XID deviceid)
 556 {
 557     struct x11drv_thread_data *data = x11drv_thread_data();
 558     XDevice *device;
 559     XDeviceState *state;
 560     XInputClass  *class;
 561     int loop;
 562     int rc = 0;
 563
 564     wine_tsx11_lock();
 565     device = pXOpenDevice(data->display,deviceid);
 566     state = pXQueryDeviceState(data->display,device);
 567
 568     if (state)
 569     {
 570         class = state->data;
 571         for (loop = 0; loop < state->num_classes; loop++)
 572         {
 573             if (class->class == ButtonClass)
 574             {
 575                 int loop2;
 576                 XButtonState *button_state =  (XButtonState*)class;
 577                 for (loop2 = 1; loop2 <= button_state->num_buttons; loop2++)
 578                 {
 579                     if (button_state->buttons[loop2 / 8] & (1 << (loop2 % 8)))
 580                     {
 581                         rc |= (1<<(loop2-1));
 582                     }
 583                 }
 584             }
 585             class = (XInputClass *) ((char *) class + class->length);
 586         }
 587     }
 588     pXFreeDeviceState(state);
 589     wine_tsx11_unlock();
 590     button_state[deviceid] = rc;
 591 }
 592
 593 static void motion_event( HWND hwnd, XEvent *event )
 594 {
 595     XDeviceMotionEvent *motion = (XDeviceMotionEvent *)event;
 596     LPWTI_CURSORS_INFO cursor = &gSysCursor[motion->deviceid];
 597
 598     memset(&gMsgPacket,0,sizeof(WTPACKET));
 599
 600     TRACE("Received tablet motion event (%p)\n",hwnd);
 601
 602     /* Set cursor to inverted if cursor is the eraser */
 603     gMsgPacket.pkStatus = (cursor->TYPE == 0xc85a ?TPS_INVERT:0);
 604     gMsgPacket.pkTime = EVENT_x11_time_to_win32_time(motion->time);
 605     gMsgPacket.pkSerialNumber = gSerial++;
 606     gMsgPacket.pkCursor = motion->deviceid;
 607     gMsgPacket.pkX = motion->axis_data[0];
 608     gMsgPacket.pkY = motion->axis_data[1];
 609     gMsgPacket.pkOrientation.orAzimuth = figure_deg(motion->axis_data[3],motion->axis_data[4]);
 610     gMsgPacket.pkOrientation.orAltitude = ((1000 - 15 * max
 611                                             (abs(motion->axis_data[3]),
 612                                              abs(motion->axis_data[4])))
 613                                            * (gMsgPacket.pkStatus & TPS_INVERT?-1:1));
 614     gMsgPacket.pkNormalPressure = motion->axis_data[2];
 615     gMsgPacket.pkButtons = get_button_state(motion->deviceid);
 616     SendMessageW(hwndTabletDefault,WT_PACKET,0,(LPARAM)hwnd);
 617 }
 618
 619 static void button_event( HWND hwnd, XEvent *event )
 620 {
 621     XDeviceButtonEvent *button = (XDeviceButtonEvent *) event;
 622     LPWTI_CURSORS_INFO cursor = &gSysCursor[button->deviceid];
 623
 624     memset(&gMsgPacket,0,sizeof(WTPACKET));
 625
 626     TRACE("Received tablet button %s event\n", (event->type == button_press_type)?"press":"release");
 627
 628     /* Set cursor to inverted if cursor is the eraser */
 629     gMsgPacket.pkStatus = (cursor->TYPE == 0xc85a ?TPS_INVERT:0);
 630     set_button_state(button->deviceid);
 631     gMsgPacket.pkTime = EVENT_x11_time_to_win32_time(button->time);
 632     gMsgPacket.pkSerialNumber = gSerial++;
 633     gMsgPacket.pkCursor = button->deviceid;
 634     gMsgPacket.pkX = button->axis_data[0];
 635     gMsgPacket.pkY = button->axis_data[1];
 636     gMsgPacket.pkOrientation.orAzimuth = figure_deg(button->axis_data[3],button->axis_data[4]);
 637     gMsgPacket.pkOrientation.orAltitude = ((1000 - 15 * max(abs(button->axis_data[3]),
 638                                                             abs(button->axis_data[4])))
 639                                            * (gMsgPacket.pkStatus & TPS_INVERT?-1:1));
 640     gMsgPacket.pkNormalPressure = button->axis_data[2];
 641     gMsgPacket.pkButtons = get_button_state(button->deviceid);
 642     SendMessageW(hwndTabletDefault,WT_PACKET,0,(LPARAM)hwnd);
 643 }
 644
 645 static void key_event( HWND hwnd, XEvent *event )
 646 {
 647     if (event->type == key_press_type)
 648         FIXME("Received tablet key press event\n");
 649     else
 650         FIXME("Received tablet key release event\n");
 651 }
 652
 653 static void proximity_event( HWND hwnd, XEvent *event )
 654 {
 655     XProximityNotifyEvent *proximity = (XProximityNotifyEvent *) event;
 656     LPWTI_CURSORS_INFO cursor = &gSysCursor[proximity->deviceid];
 657
 658     memset(&gMsgPacket,0,sizeof(WTPACKET));
 659
 660     TRACE("Received tablet proximity event\n");
 661     /* Set cursor to inverted if cursor is the eraser */
 662     gMsgPacket.pkStatus = (cursor->TYPE == 0xc85a ?TPS_INVERT:0);
 663     gMsgPacket.pkStatus |= (event->type==proximity_out_type)?TPS_PROXIMITY:0;
 664     gMsgPacket.pkTime = EVENT_x11_time_to_win32_time(proximity->time);
 665     gMsgPacket.pkSerialNumber = gSerial++;
 666     gMsgPacket.pkCursor = proximity->deviceid;
 667     gMsgPacket.pkX = proximity->axis_data[0];
 668     gMsgPacket.pkY = proximity->axis_data[1];
 669     gMsgPacket.pkOrientation.orAzimuth = figure_deg(proximity->axis_data[3],proximity->axis_data[4]);
 670     gMsgPacket.pkOrientation.orAltitude = ((1000 - 15 * max(abs(proximity->axis_data[3]),
 671                                                             abs(proximity->axis_data[4])))
 672                                            * (gMsgPacket.pkStatus & TPS_INVERT?-1:1));
 673     gMsgPacket.pkNormalPressure = proximity->axis_data[2];
 674     gMsgPacket.pkButtons = get_button_state(proximity->deviceid);
 675
 676     SendMessageW(hwndTabletDefault, WT_PROXIMITY, (event->type == proximity_in_type), (LPARAM)hwnd);
 677 }
 678
 679 int X11DRV_AttachEventQueueToTablet(HWND hOwner)
 680 {
 681     struct x11drv_thread_data *data = x11drv_thread_data();
 682     int             num_devices;
 683     int             loop;
 684     int             cur_loop;
 685     XDeviceInfo     *devices;
 686     XDeviceInfo     *target = NULL;
 687     XDevice         *the_device;
 688     XEventClass     event_list[7];
 689     Window          win = X11DRV_get_whole_window( hOwner );
 690
 691     if (!win) return 0;
 692
 693     TRACE("Creating context for window %p (%lx)  %i cursors\n", hOwner, win, gNumCursors);
 694
 695     wine_tsx11_lock();
 696     devices = pXListInputDevices(data->display, &num_devices);
 697
 698     X11DRV_expect_error(data->display,Tablet_ErrorHandler,NULL);
 699     for (cur_loop=0; cur_loop < gNumCursors; cur_loop++)
 700     {
 701         int    event_number=0;
 702
 703         for (loop=0; loop < num_devices; loop ++)
 704             if (strcmp(devices[loop].name,gSysCursor[cur_loop].NAME)==0)
 705                 target = &devices[loop];
 706
 707         TRACE("Opening cursor %i id %i\n",cur_loop,(INT)target->id);
 708
 709         the_device = pXOpenDevice(data->display, target->id);
 710
 711         if (!the_device)
 712         {
 713             WARN("Unable to Open device\n");
 714             continue;
 715         }
 716
 717         if (the_device->num_classes > 0)
 718         {
 719             DeviceKeyPress(the_device, key_press_type, event_list[event_number]);
 720             if (event_list[event_number]) event_number++;
 721             DeviceKeyRelease(the_device, key_release_type, event_list[event_number]);
 722             if (event_list[event_number]) event_number++;
 723             DeviceButtonPress(the_device, button_press_type, event_list[event_number]);
 724             if (event_list[event_number]) event_number++;
 725             DeviceButtonRelease(the_device, button_release_type, event_list[event_number]);
 726             if (event_list[event_number]) event_number++;
 727             DeviceMotionNotify(the_device, motion_type, event_list[event_number]);
 728             if (event_list[event_number]) event_number++;
 729             ProximityIn(the_device, proximity_in_type, event_list[event_number]);
 730             if (event_list[event_number]) event_number++;
 731             ProximityOut(the_device, proximity_out_type, event_list[event_number]);
 732             if (event_list[event_number]) event_number++;
 733
 734             if (key_press_type) X11DRV_register_event_handler( key_press_type, key_event );
 735             if (key_release_type) X11DRV_register_event_handler( key_release_type, key_event );
 736             if (button_press_type) X11DRV_register_event_handler( button_press_type, button_event );
 737             if (button_release_type) X11DRV_register_event_handler( button_release_type, button_event );
 738             if (motion_type) X11DRV_register_event_handler( motion_type, motion_event );
 739             if (proximity_in_type) X11DRV_register_event_handler( proximity_in_type, proximity_event );
 740             if (proximity_out_type) X11DRV_register_event_handler( proximity_out_type, proximity_event );
 741
 742             pXSelectExtensionEvent(data->display, win, event_list, event_number);
 743         }
 744     }
 745     XSync(data->display, False);
 746     X11DRV_check_error();
 747
 748     if (NULL != devices) pXFreeDeviceList(devices);
 749     wine_tsx11_unlock();
 750     return 0;
 751 }
 752
 753 int X11DRV_GetCurrentPacket(LPWTPACKET *packet)
 754 {
 755     memcpy(packet,&gMsgPacket,sizeof(WTPACKET));
 756     return 1;
 757 }
 758
 759
 760 int static inline CopyTabletData(LPVOID target, LPVOID src, INT size)
 761 {
 762     /*
 763      * It is valid to call CopyTabletData with NULL.
 764      * This handles the WTInfo() case where lpOutput is null.
 765      */
 766     if(target != NULL)
 767         memcpy(target,src,size);
 768     return(size);
 769 }
 770
 771 /***********************************************************************
 772  *              X11DRV_WTInfoA (X11DRV.@)
 773  */
 774 UINT X11DRV_WTInfoA(UINT wCategory, UINT nIndex, LPVOID lpOutput)
 775 {
 776     /*
 777      * It is valid to call WTInfoA with lpOutput == NULL, as per standard.
 778      * lpOutput == NULL signifies the user only wishes
 779      * to find the size of the data.
 780      * NOTE:
 781      * From now on use CopyTabletData to fill lpOutput. memcpy will break
 782      * the code.
 783      */
 784     int rc = 0;
 785     LPWTI_CURSORS_INFO  tgtcursor;
 786     TRACE("(%u, %u, %p)\n", wCategory, nIndex, lpOutput);
 787
 788     switch(wCategory)
 789     {
 790         case 0:
 791             /* return largest necessary buffer */
 792             TRACE("%i cursors\n",gNumCursors);
 793             if (gNumCursors>0)
 794             {
 795                 FIXME("Return proper size\n");
 796                 rc = 200;
 797             }
 798             break;
 799         case WTI_INTERFACE:
 800             switch (nIndex)
 801             {
 802                 WORD version;
 803                 case IFC_WINTABID:
 804                     strcpy(lpOutput,"Wine Wintab 1.1");
 805                     rc = 16;
 806                     break;
 807                 case IFC_SPECVERSION:
 808                     version = (0x01) | (0x01 << 8);
 809                     rc = CopyTabletData(lpOutput, &version,sizeof(WORD));
 810                     break;
 811                 case IFC_IMPLVERSION:
 812                     version = (0x00) | (0x01 << 8);
 813                     rc = CopyTabletData(lpOutput, &version,sizeof(WORD));
 814                     break;
 815                 default:
 816                     FIXME("WTI_INTERFACE unhandled index %i\n",nIndex);
 817                     rc = 0;
 818
 819             }
 820         case WTI_DEFSYSCTX:
 821         case WTI_DDCTXS:
 822         case WTI_DEFCONTEXT:
 823             switch (nIndex)
 824             {
 825                 case 0:
 826                     rc = CopyTabletData(lpOutput, &gSysContext,
 827                             sizeof(LOGCONTEXTA));
 828                     break;
 829                 case CTX_NAME:
 830                     rc = CopyTabletData(lpOutput, &gSysContext.lcName,
 831                          strlen(gSysContext.lcName)+1);
 832                     break;
 833                 case CTX_OPTIONS:
 834                     rc = CopyTabletData(lpOutput, &gSysContext.lcOptions,
 835                                         sizeof(UINT));
 836                     break;
 837                 case CTX_STATUS:
 838                     rc = CopyTabletData(lpOutput, &gSysContext.lcStatus,
 839                                         sizeof(UINT));
 840                     break;
 841                 case CTX_LOCKS:
 842                     rc= CopyTabletData (lpOutput, &gSysContext.lcLocks,
 843                                         sizeof(UINT));
 844                     break;
 845                 case CTX_MSGBASE:
 846                     rc = CopyTabletData(lpOutput, &gSysContext.lcMsgBase,
 847                                         sizeof(UINT));
 848                     break;
 849                 case CTX_DEVICE:
 850                     rc = CopyTabletData(lpOutput, &gSysContext.lcDevice,
 851                                         sizeof(UINT));
 852                     break;
 853                 case CTX_PKTRATE:
 854                     rc = CopyTabletData(lpOutput, &gSysContext.lcPktRate,
 855                                         sizeof(UINT));
 856                     break;
 857                 case CTX_PKTMODE:
 858                     rc = CopyTabletData(lpOutput, &gSysContext.lcPktMode,
 859                                         sizeof(WTPKT));
 860                     break;
 861                 case CTX_MOVEMASK:
 862                     rc = CopyTabletData(lpOutput, &gSysContext.lcMoveMask,
 863                                         sizeof(WTPKT));
 864                     break;
 865                 case CTX_BTNDNMASK:
 866                     rc = CopyTabletData(lpOutput, &gSysContext.lcBtnDnMask,
 867                                         sizeof(DWORD));
 868                     break;
 869                 case CTX_BTNUPMASK:
 870                     rc = CopyTabletData(lpOutput, &gSysContext.lcBtnUpMask,
 871                                         sizeof(DWORD));
 872                     break;
 873                 case CTX_INORGX:
 874                     rc = CopyTabletData(lpOutput, &gSysContext.lcInOrgX,
 875                                         sizeof(LONG));
 876                     break;
 877                 case CTX_INORGY:
 878                     rc = CopyTabletData(lpOutput, &gSysContext.lcInOrgY,
 879                                         sizeof(LONG));
 880                     break;
 881                 case CTX_INORGZ:
 882                     rc = CopyTabletData(lpOutput, &gSysContext.lcInOrgZ,
 883                                         sizeof(LONG));
 884                     break;
 885                 case CTX_INEXTX:
 886                     rc = CopyTabletData(lpOutput, &gSysContext.lcInExtX,
 887                                         sizeof(LONG));
 888                     break;
 889                 case CTX_INEXTY:
 890                      rc = CopyTabletData(lpOutput, &gSysContext.lcInExtY,
 891                                         sizeof(LONG));
 892                     break;
 893                 case CTX_INEXTZ:
 894                      rc = CopyTabletData(lpOutput, &gSysContext.lcInExtZ,
 895                                         sizeof(LONG));
 896                     break;
 897                 case CTX_OUTORGX:
 898                      rc = CopyTabletData(lpOutput, &gSysContext.lcOutOrgX,
 899                                         sizeof(LONG));
 900                     break;
 901                 case CTX_OUTORGY:
 902                       rc = CopyTabletData(lpOutput, &gSysContext.lcOutOrgY,
 903                                         sizeof(LONG));
 904                     break;
 905                 case CTX_OUTORGZ:
 906                        rc = CopyTabletData(lpOutput, &gSysContext.lcOutOrgZ,
 907                                         sizeof(LONG));
 908                     break;
 909                case CTX_OUTEXTX:
 910                       rc = CopyTabletData(lpOutput, &gSysContext.lcOutExtX,
 911                                         sizeof(LONG));
 912                     break;
 913                 case CTX_OUTEXTY:
 914                        rc = CopyTabletData(lpOutput, &gSysContext.lcOutExtY,
 915                                         sizeof(LONG));
 916                     break;
 917                 case CTX_OUTEXTZ:
 918                        rc = CopyTabletData(lpOutput, &gSysContext.lcOutExtZ,
 919                                         sizeof(LONG));
 920                     break;
 921                 case CTX_SENSX:
 922                         rc = CopyTabletData(lpOutput, &gSysContext.lcSensX,
 923                                         sizeof(LONG));
 924                     break;
 925                 case CTX_SENSY:
 926                         rc = CopyTabletData(lpOutput, &gSysContext.lcSensY,
 927                                         sizeof(LONG));
 928                     break;
 929                 case CTX_SENSZ:
 930                         rc = CopyTabletData(lpOutput, &gSysContext.lcSensZ,
 931                                         sizeof(LONG));
 932                     break;
 933                 case CTX_SYSMODE:
 934                         rc = CopyTabletData(lpOutput, &gSysContext.lcSysMode,
 935                                         sizeof(LONG));
 936                     break;
 937                 case CTX_SYSORGX:
 938                         rc = CopyTabletData(lpOutput, &gSysContext.lcSysOrgX,
 939                                         sizeof(LONG));
 940                     break;
 941                 case CTX_SYSORGY:
 942                         rc = CopyTabletData(lpOutput, &gSysContext.lcSysOrgY,
 943                                         sizeof(LONG));
 944                     break;
 945                 case CTX_SYSEXTX:
 946                         rc = CopyTabletData(lpOutput, &gSysContext.lcSysExtX,
 947                                         sizeof(LONG));
 948                     break;
 949                 case CTX_SYSEXTY:
 950                         rc = CopyTabletData(lpOutput, &gSysContext.lcSysExtY,
 951                                         sizeof(LONG));
 952                     break;
 953                 case CTX_SYSSENSX:
 954                         rc = CopyTabletData(lpOutput, &gSysContext.lcSysSensX,
 955                                         sizeof(LONG));
 956                     break;
 957                 case CTX_SYSSENSY:
 958                        rc = CopyTabletData(lpOutput, &gSysContext.lcSysSensY,
 959                                         sizeof(LONG));
 960                     break;
 961                 default:
 962                     FIXME("WTI_DEFSYSCTX unhandled index %i\n",nIndex);
 963                     rc = 0;
 964             }
 965             break;
 966         case WTI_CURSORS:
 967         case WTI_CURSORS+1:
 968         case WTI_CURSORS+2:
 969         case WTI_CURSORS+3:
 970         case WTI_CURSORS+4:
 971         case WTI_CURSORS+5:
 972         case WTI_CURSORS+6:
 973         case WTI_CURSORS+7:
 974         case WTI_CURSORS+8:
 975         case WTI_CURSORS+9:
 976         case WTI_CURSORS+10:
 977             tgtcursor = &gSysCursor[wCategory - WTI_CURSORS];
 978             switch (nIndex)
 979             {
 980                 case CSR_NAME:
 981                     rc = CopyTabletData(lpOutput, &tgtcursor->NAME,
 982                                         strlen(tgtcursor->NAME)+1);
 983                     break;
 984                 case CSR_ACTIVE:
 985                     rc = CopyTabletData(lpOutput,&tgtcursor->ACTIVE,
 986                                         sizeof(BOOL));
 987                     break;
 988                 case CSR_PKTDATA:
 989                     rc = CopyTabletData(lpOutput,&tgtcursor->PKTDATA,
 990                                         sizeof(WTPKT));
 991                     break;
 992                 case CSR_BUTTONS:
 993                     rc = CopyTabletData(lpOutput,&tgtcursor->BUTTONS,
 994                                         sizeof(BYTE));
 995                     break;
 996                 case CSR_BUTTONBITS:
 997                     rc = CopyTabletData(lpOutput,&tgtcursor->BUTTONBITS,
 998                                         sizeof(BYTE));
 999                     break;
1000                 case CSR_BTNNAMES:
1001                     FIXME("Button Names not returned correctly\n");
1002                     rc = CopyTabletData(lpOutput,&tgtcursor->BTNNAMES,
1003                                         strlen(tgtcursor->BTNNAMES)+1);
1004                     break;
1005                 case CSR_BUTTONMAP:
1006                     rc = CopyTabletData(lpOutput,&tgtcursor->BUTTONMAP,
1007                                         sizeof(BYTE)*32);
1008                     break;
1009                 case CSR_SYSBTNMAP:
1010                     rc = CopyTabletData(lpOutput,&tgtcursor->SYSBTNMAP,
1011                                         sizeof(BYTE)*32);
1012                     break;
1013                 case CSR_NPBTNMARKS:
1014                     rc = CopyTabletData(lpOutput,&tgtcursor->NPBTNMARKS,
1015                                         sizeof(UINT)*2);
1016                     break;
1017                 case CSR_NPBUTTON:
1018                     rc = CopyTabletData(lpOutput,&tgtcursor->NPBUTTON,
1019                                         sizeof(BYTE));
1020                     break;
1021                 case CSR_NPRESPONSE:
1022                     FIXME("Not returning CSR_NPRESPONSE correctly\n");
1023                     rc = 0;
1024                     break;
1025                 case CSR_TPBUTTON:
1026                     rc = CopyTabletData(lpOutput,&tgtcursor->TPBUTTON,
1027                                         sizeof(BYTE));
1028                     break;
1029                 case CSR_TPBTNMARKS:
1030                     rc = CopyTabletData(lpOutput,&tgtcursor->TPBTNMARKS,
1031                                         sizeof(UINT)*2);
1032                     break;
1033                 case CSR_TPRESPONSE:
1034                     FIXME("Not returning CSR_TPRESPONSE correctly\n");
1035                     rc = 0;
1036                     break;
1037                 case CSR_PHYSID:
1038                 {
1039                     DWORD id;
1040                     id = tgtcursor->PHYSID;
1041                     id += (wCategory - WTI_CURSORS);
1042                     rc = CopyTabletData(lpOutput,&id,sizeof(DWORD));
1043                 }
1044                     break;
1045                 case CSR_MODE:
1046                     rc = CopyTabletData(lpOutput,&tgtcursor->MODE,sizeof(UINT));
1047                     break;
1048                 case CSR_MINPKTDATA:
1049                     rc = CopyTabletData(lpOutput,&tgtcursor->MINPKTDATA,
1050                         sizeof(UINT));
1051                     break;
1052                 case CSR_MINBUTTONS:
1053                     rc = CopyTabletData(lpOutput,&tgtcursor->MINBUTTONS,
1054                         sizeof(UINT));
1055                     break;
1056                 case CSR_CAPABILITIES:
1057                     rc = CopyTabletData(lpOutput,&tgtcursor->CAPABILITIES,
1058                         sizeof(UINT));
1059                     break;
1060                 case CSR_TYPE:
1061                     rc = CopyTabletData(lpOutput,&tgtcursor->TYPE,
1062                         sizeof(UINT));
1063                     break;
1064                 default:
1065                     FIXME("WTI_CURSORS unhandled index %i\n",nIndex);
1066                     rc = 0;
1067             }
1068             break;
1069         case WTI_DEVICES:
1070             switch (nIndex)
1071             {
1072                 case DVC_NAME:
1073                     rc = CopyTabletData(lpOutput,gSysDevice.NAME,
1074                                         strlen(gSysDevice.NAME)+1);
1075                     break;
1076                 case DVC_HARDWARE:
1077                     rc = CopyTabletData(lpOutput,&gSysDevice.HARDWARE,
1078                                         sizeof(UINT));
1079                     break;
1080                 case DVC_NCSRTYPES:
1081                     rc = CopyTabletData(lpOutput,&gSysDevice.NCSRTYPES,
1082                                         sizeof(UINT));
1083                     break;
1084                 case DVC_FIRSTCSR:
1085                     rc = CopyTabletData(lpOutput,&gSysDevice.FIRSTCSR,
1086                                         sizeof(UINT));
1087                     break;
1088                 case DVC_PKTRATE:
1089                     rc = CopyTabletData(lpOutput,&gSysDevice.PKTRATE,
1090                                         sizeof(UINT));
1091                     break;
1092                 case DVC_PKTDATA:
1093                     rc = CopyTabletData(lpOutput,&gSysDevice.PKTDATA,
1094                                         sizeof(WTPKT));
1095                     break;
1096                 case DVC_PKTMODE:
1097                     rc = CopyTabletData(lpOutput,&gSysDevice.PKTMODE,
1098                                         sizeof(WTPKT));
1099                     break;
1100                 case DVC_CSRDATA:
1101                     rc = CopyTabletData(lpOutput,&gSysDevice.CSRDATA,
1102                                         sizeof(WTPKT));
1103                     break;
1104                 case DVC_XMARGIN:
1105                     rc = CopyTabletData(lpOutput,&gSysDevice.XMARGIN,
1106                                         sizeof(INT));
1107                     break;
1108                 case DVC_YMARGIN:
1109                     rc = CopyTabletData(lpOutput,&gSysDevice.YMARGIN,
1110                                         sizeof(INT));
1111                     break;
1112                 case DVC_ZMARGIN:
1113                     rc = 0; /* unsupported */
1114                     /*
1115                     rc = CopyTabletData(lpOutput,&gSysDevice.ZMARGIN,
1116                                         sizeof(INT));
1117                     */
1118                     break;
1119                 case DVC_X:
1120                     rc = CopyTabletData(lpOutput,&gSysDevice.X,
1121                                         sizeof(AXIS));
1122                     break;
1123                 case DVC_Y:
1124                     rc = CopyTabletData(lpOutput,&gSysDevice.Y,
1125                                         sizeof(AXIS));
1126                     break;
1127                 case DVC_Z:
1128                     rc = 0; /* unsupported */
1129                     /*
1130                     rc = CopyTabletData(lpOutput,&gSysDevice.Z,
1131                                         sizeof(AXIS));
1132                     */
1133                     break;
1134                 case DVC_NPRESSURE:
1135                     rc = CopyTabletData(lpOutput,&gSysDevice.NPRESSURE,
1136                                         sizeof(AXIS));
1137                     break;
1138                 case DVC_TPRESSURE:
1139                     rc = 0; /* unsupported */
1140                     /*
1141                     rc = CopyTabletData(lpOutput,&gSysDevice.TPRESSURE,
1142                                         sizeof(AXIS));
1143                     */
1144                     break;
1145                 case DVC_ORIENTATION:
1146                     rc = CopyTabletData(lpOutput,&gSysDevice.ORIENTATION,
1147                                         sizeof(AXIS)*3);
1148                     break;
1149                 case DVC_ROTATION:
1150                     rc = 0; /* unsupported */
1151                     /*
1152                     rc = CopyTabletData(lpOutput,&gSysDevice.ROTATION,
1153                                         sizeof(AXIS)*3);
1154                     */
1155                     break;
1156                 case DVC_PNPID:
1157                     rc = CopyTabletData(lpOutput,gSysDevice.PNPID,
1158                                         strlen(gSysDevice.PNPID)+1);
1159                     break;
1160                 default:
1161                     FIXME("WTI_DEVICES unhandled index %i\n",nIndex);
1162                     rc = 0;
1163             }
1164             break;
1165         default:
1166             FIXME("Unhandled Category %i\n",wCategory);
1167     }
1168     return rc;
1169 }
1170
1171 #else /* HAVE_X11_EXTENSIONS_XINPUT_H */
1172
1173 /***********************************************************************
1174  *              AttachEventQueueToTablet (X11DRV.@)
1175  */
1176 int X11DRV_AttachEventQueueToTablet(HWND hOwner)
1177 {
1178     return 0;
1179 }
1180
1181 /***********************************************************************
1182  *              GetCurrentPacket (X11DRV.@)
1183  */
1184 int X11DRV_GetCurrentPacket(LPWTPACKET *packet)
1185 {
1186     return 0;
1187 }
1188
1189 /***********************************************************************
1190  *              LoadTabletInfo (X11DRV.@)
1191  */
1192 void X11DRV_LoadTabletInfo(HWND hwnddefault)
1193 {
1194 }
1195
1196 /***********************************************************************
1197  *              WTInfoA (X11DRV.@)
1198  */
1199 UINT X11DRV_WTInfoA(UINT wCategory, UINT nIndex, LPVOID lpOutput)
1200 {
1201     return 0;
1202 }
1203
1204 #endif /* HAVE_X11_EXTENSIONS_XINPUT_H */