glut_input.c

Go to the documentation of this file.

/* Copyright (c) Mark J. Kilgard, 1994, 1997, 1998. */

/* This program is freely distributable without licensing fees
   and is provided without guarantee or warrantee expressed or
   implied. This program is -not- in the public domain. */

#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#if !defined(_WIN32)
#include <X11/Xlib.h>
#if defined(__vms)
#include <X11/XInput.h>
#else
#include <X11/extensions/XInput.h>
#endif
#include <X11/Xutil.h>
#else
#include <windows.h>
#include <mmsystem.h>  /* Win32 Multimedia API header. */
#endif /* !_WIN32 */

#include "glutint.h"
#include "wacom.h"

int __glutNumDials = 0;
int __glutNumSpaceballButtons = 0;
int __glutNumButtonBoxButtons = 0;
int __glutNumTabletButtons = 0;
int __glutNumWacomTabletButtons = 0;
int __glutNumWacomStylusButtons = 0;
int __glutNumWacomEraserButtons = 0;
int __glutNumWacomCursorButtons = 0;
int __glutNumMouseButtons = 3;  /* Good guess. */
XDevice *__glutTablet = NULL;
XDevice *__glutWacomTablet = NULL;
XDevice *__glutWacomStylus = NULL;
XDevice *__glutWacomEraser = NULL;
XDevice *__glutWacomCursor = NULL;
XDevice *__glutDials = NULL;
XDevice *__glutSpaceball = NULL;

int __glutHasJoystick = 0;
int __glutNumJoystickButtons = 0;
int __glutNumJoystickAxes = 0;

#if !defined(_WIN32)
typedef struct _Range {
  int min;
  int range;
} Range;

typedef enum _WacomEventType {
  WACOM_MOTION_EVENT,
  WACOM_BUTTON_EVENT
} WacomEventType;

#define WACOM_NO_STATE_INFO   -1

typedef enum _WacomProximityType {
  WACOM_NO_PROXIMITY_INFO = -1,
  WACOM_PROXIMITY_OUT,
  WACOM_PROXIMITY_IN
} WacomProximityType;

#define NUM_SPACEBALL_AXIS 6
#define NUM_TABLET_AXIS    2
#define NUM_WACOM_TABLET_AXIS WACOM_NUM_VALUATORS
#define NUM_WACOM_STYLUS_AXIS WACOM_STYLUS_NUM_VALUATORS
#define NUM_WACOM_ERASER_AXIS WACOM_ERASER_NUM_VALUATORS
#define NUM_WACOM_CURSOR_AXIS WACOM_CURSOR_NUM_VALUATORS
#define NUM_DIALS_AXIS     8

Range __glutSpaceballRange[NUM_SPACEBALL_AXIS];
Range __glutTabletRange[NUM_TABLET_AXIS];
Range __glutWacomTabletRange[NUM_WACOM_TABLET_AXIS];
Range __glutWacomStylusRange[NUM_WACOM_STYLUS_AXIS];
Range __glutWacomEraserRange[NUM_WACOM_ERASER_AXIS];
Range __glutWacomCursorRange[NUM_WACOM_CURSOR_AXIS];
int *__glutDialsResolution;

/* Safely assumes 0 is an illegal event type for X Input
   extension events. */
int __glutDeviceMotionNotify = 0;
int __glutDeviceButtonPress = 0;
int __glutDeviceButtonPressGrab = 0;
int __glutDeviceButtonRelease = 0;
int __glutDeviceStateNotify = 0;
int __glutProximityIn = 0;
int __glutProximityOut = 0;

static int
normalizeTabletPos(int axis, int rawValue)
{
  assert(rawValue >= __glutTabletRange[axis].min);
  assert(rawValue <= __glutTabletRange[axis].min
    + __glutTabletRange[axis].range);
  /* Normalize rawValue to between 0 and 4000. */
  return ((rawValue - __glutTabletRange[axis].min) * 4000) /
    __glutTabletRange[axis].range;
}

static int
normalizeDialAngle(int axis, int rawValue)
{
  /* XXX Assumption made that the resolution of the device is
     number of clicks for one complete dial revolution.  This
     is true for SGI's dial & button box. */
  return (rawValue * 360.0) / __glutDialsResolution[axis];
}

static int
normalizeSpaceballAngle(int axis, int rawValue)
{
  assert(rawValue >= __glutSpaceballRange[axis].min);
  assert(rawValue <= __glutSpaceballRange[axis].min +
    __glutSpaceballRange[axis].range);
  /* Normalize rawValue to between -1800 and 1800. */
  return ((rawValue - __glutSpaceballRange[axis].min) * 3600) /
    __glutSpaceballRange[axis].range - 1800;
}

static int
normalizeSpaceballDelta(int axis, int rawValue)
{
  assert(rawValue >= __glutSpaceballRange[axis].min);
  assert(rawValue <= __glutSpaceballRange[axis].min +
    __glutSpaceballRange[axis].range);
  /* Normalize rawValue to between -1000 and 1000. */
  return ((rawValue - __glutSpaceballRange[axis].min) * 2000) /
    __glutSpaceballRange[axis].range - 1000;
}

static void
queryTabletPos(GLUTwindow * window)
{
  XDeviceState *state;
  XInputClass *any;
  XValuatorState *v;
  int i;

  state = XQueryDeviceState(__glutDisplay, __glutTablet);
  any = state->data;
  for (i = 0; i < state->num_classes; i++) {
#if defined(__cplusplus) || defined(c_plusplus)
    switch (any->c_class) {
#else
    switch (any->class) {
#endif
    case ValuatorClass:
      v = (XValuatorState *) any;
      if (v->num_valuators < 2)
        goto end;
      if (window->tabletPos[0] == -1)
        window->tabletPos[0] = normalizeTabletPos(0, v->valuators[0]);
      if (window->tabletPos[1] == -1)
        window->tabletPos[1] = normalizeTabletPos(1, v->valuators[1]);
    }
    any = (XInputClass *) ((char *) any + any->length);
  }
end:
  XFreeDeviceState(state);
}

static void
tabletPosChange(GLUTwindow * window, int first, int count, int *data)
{
  int i, value, genEvent = 0;

  for (i = first; i < first + count; i++) {
    switch (i) {
    case 0:            /* X axis */
    case 1:            /* Y axis */
      value = normalizeTabletPos(i, data[i - first]);
      if (value != window->tabletPos[i]) {
        window->tabletPos[i] = value;
        genEvent = 1;
      }
      break;
    }
  }
  if (window->tabletPos[0] == -1 || window->tabletPos[1] == -1)
    queryTabletPos(window);
  if (genEvent)
    window->tabletMotion(window->tabletPos[0], window->tabletPos[1]);
}

static void
wacomTabletChange(GLUTwindow * window, WacomEventType wacomEvent)
{
  XDeviceState *state;
  XInputClass *any;
  XValuatorState *v;
  int i;
  int transducer, device, button, x, y, pressure, xtilt, ytilt, proximity;
  
  state = XQueryDeviceState(__glutDisplay, __glutWacomTablet);
  any = state->data;
  for (i = 0; i < state->num_classes; i++) {
#if defined(__cplusplus) || defined(c_plusplus)
    if (any->c_class == ValuatorClass) {
#else
    if (any->class == ValuatorClass) {
#endif
      v = (XValuatorState *) any;
      transducer = v->valuators[WAC_TRANSDUCER_I];
      if (transducer & WAC_MENU_ID) {
   device = GLUT_WACOM_MENU;
   button = WAC_MENU_BUTTONS(v->valuators[WAC_BUTTON_I]);
   x = 0;
   y = 0;
   pressure = 0;
   xtilt = 0;
   ytilt = 0;
   proximity = 1;
   /* FIXME: Generate a Keyboard Pressed event! */
      } else {
   switch (transducer & WAC_TRANSDUCER_MSK) {
   case WAC_PUCK_ID:
     device = GLUT_WACOM_CURSOR;
     button = WAC_PUCK_BUTTONS(v->valuators[WAC_BUTTON_I]);
     /* FIXME: No puck button number generated! */
     x = v->valuators[WAC_XCOORD_I];
     y = v->valuators[WAC_YCOORD_I];
     pressure = 0;
     xtilt = v->valuators[WAC_ROTATION_I];
     xtilt = 5 * WAC_ROTATION_INTG(xtilt) + WAC_ROTATION_FRAC(xtilt);
     ytilt = 0;
     proximity = (short) v->valuators[WAC_ZCOORD_I];
     break;
   case WAC_STYLUS_ID:
     device = GLUT_WACOM_STYLUS;
     button = WAC_STYLUS_BUTTONS(v->valuators[WAC_BUTTON_I]);
     x = v->valuators[WAC_XCOORD_I];
     y = v->valuators[WAC_YCOORD_I];
     pressure = v->valuators[WAC_PRESSURE_I];
     xtilt = (short) v->valuators[WAC_XTILT_I];
     ytilt = (short) v->valuators[WAC_YTILT_I];
     proximity = ((transducer & WAC_TRANSDUCER_PROX_MSK) != 0x0);
     break;
   case WAC_ERASER_ID:
     device = GLUT_WACOM_ERASER;
     button = WAC_STYLUS_BUTTONS(v->valuators[WAC_BUTTON_I]);
     x = v->valuators[WAC_XCOORD_I];
     y = v->valuators[WAC_YCOORD_I];
     pressure = v->valuators[WAC_PRESSURE_I];
     xtilt = (short) v->valuators[WAC_XTILT_I];
     ytilt = (short) v->valuators[WAC_YTILT_I];
     proximity = ((transducer & WAC_TRANSDUCER_PROX_MSK) != 0x0);
     break;
   }
      }
      switch (wacomEvent) {
      case WACOM_MOTION_EVENT:
   if (device == GLUT_WACOM_CURSOR) {
     __glutWacomUpdate(x, y, 0, 0, 0);
     window->wacomMotion(device,
               WACOM_NO_STATE_INFO,
               __glutWacomX,
               __glutWacomY,
               pressure,
               WAC_CURSOR_ROTATION(xtilt),
               ytilt,
               proximity);
   } else {
     __glutWacomUpdate(x, y, pressure, xtilt, ytilt);
     window->wacomMotion(device,
               WAC_STYLUS_BUTTON_STATE(button),
               __glutWacomX,
               __glutWacomY,
               __glutWacomPressure,
               __glutWacomXTilt,
               __glutWacomYTilt,
               proximity);
   }
   break;
      case WACOM_BUTTON_EVENT:
   if (device == GLUT_WACOM_CURSOR) {
     __glutWacomSetButton(device, button);
     __glutWacomUpdate(x, y, 0, 0, 0);
     window->wacomButton(device,
               __glutWacomButton,
               __glutWacomState,
               WACOM_NO_STATE_INFO,
               __glutWacomX,
               __glutWacomY,
               pressure,
               WAC_CURSOR_ROTATION(xtilt),
               ytilt,
               proximity);
   } else {
     __glutWacomSetButton(device, WAC_STYLUS_BUTTON_ID(button));
     __glutWacomUpdate(x, y, pressure, xtilt, ytilt);
     window->wacomButton(device,
               __glutWacomButton,
               __glutWacomState,
               WAC_STYLUS_BUTTON_STATE(button),
               __glutWacomX,
               __glutWacomY,
               __glutWacomPressure,
               __glutWacomXTilt,
               __glutWacomYTilt,
               proximity);
   }
   break;
      }
      break;
    }
    any = (XInputClass *) ((char *) any + any->length);
  }
  XFreeDeviceState(state);
}

static void
wacomStylusChange(GLUTwindow * window,
        WacomEventType wacomEvent, WacomProximityType wacomProximity)
{
  XDeviceState *state;
  XInputClass *any;
  XValuatorState *v;
  XButtonState *b;
  int i;
  int button;
  
  state = XQueryDeviceState(__glutDisplay, __glutWacomStylus);
  any = state->data;
  for (i = 0; i < state->num_classes; i++) {
#if defined(__cplusplus) || defined(c_plusplus)
    switch (any->c_class) {
#else
    switch (any->class) {
#endif
    case ButtonClass:
      b = (XButtonState *) any;
      break;
    case ValuatorClass:
      v = (XValuatorState *) any;
      break;
    }
    any = (XInputClass *) ((char *) any + any->length);
  }
  button = b->buttons[0];
  switch (wacomEvent) {
  case WACOM_MOTION_EVENT:
    __glutWacomUpdate(v->valuators[WACOM_XCOORD_I],
            v->valuators[WACOM_YCOORD_I],
            v->valuators[WACOM_PRESSURE_I],
            (short) v->valuators[WACOM_XTILT_I],
            (short) v->valuators[WACOM_YTILT_I]);
    window->wacomMotion(GLUT_WACOM_STYLUS,
         WACOM_STYLUS_BUTTON_STATE(button),
         __glutWacomX,
         __glutWacomY,
         __glutWacomPressure,
         __glutWacomXTilt,
         __glutWacomYTilt,
         WACOM_NO_PROXIMITY_INFO);
    break;
  case WACOM_BUTTON_EVENT:
    __glutWacomSetButton(GLUT_WACOM_STYLUS, WACOM_STYLUS_BUTTON_ID(button));
    __glutWacomUpdate(v->valuators[WACOM_XCOORD_I],
            v->valuators[WACOM_YCOORD_I],
            v->valuators[WACOM_PRESSURE_I],
            (short) v->valuators[WACOM_XTILT_I],
            (short) v->valuators[WACOM_YTILT_I]);
    window->wacomButton(GLUT_WACOM_STYLUS,
         __glutWacomButton,
         __glutWacomState,
         WACOM_STYLUS_BUTTON_STATE(button),
              __glutWacomX,
         __glutWacomY,
         __glutWacomPressure,
         __glutWacomXTilt,
         __glutWacomYTilt,
         wacomProximity);
    break;
  }
  XFreeDeviceState(state);
}

static void
wacomEraserChange(GLUTwindow * window,
        WacomEventType wacomEvent, WacomProximityType wacomProximity)
{
  XDeviceState *state;
  XInputClass *any;
  XValuatorState *v;
  XButtonState *b;
  int i;
  int button;
  
  state = XQueryDeviceState(__glutDisplay, __glutWacomEraser);
  any = state->data;
  for (i = 0; i < state->num_classes; i++) {
#if defined(__cplusplus) || defined(c_plusplus)
    switch (any->c_class) {
#else
    switch (any->class) {
#endif
    case ButtonClass:
      b = (XButtonState *) any;
      break;
    case ValuatorClass:
      v = (XValuatorState *) any;
      break;
    }
    any = (XInputClass *) ((char *) any + any->length);
  }
  button = b->buttons[0];
  switch (wacomEvent) {
  case WACOM_MOTION_EVENT:
    __glutWacomUpdate(v->valuators[WACOM_XCOORD_I],
            v->valuators[WACOM_YCOORD_I],
            v->valuators[WACOM_PRESSURE_I],
            (short) v->valuators[WACOM_XTILT_I],
            (short) v->valuators[WACOM_YTILT_I]);
    window->wacomMotion(GLUT_WACOM_ERASER,
         WACOM_STYLUS_BUTTON_STATE(button),
         __glutWacomX,
         __glutWacomY,
         __glutWacomPressure,
         __glutWacomXTilt,
         __glutWacomYTilt,
         WACOM_NO_PROXIMITY_INFO);
    break;
  case WACOM_BUTTON_EVENT:
    __glutWacomSetButton(GLUT_WACOM_ERASER, WACOM_STYLUS_BUTTON_ID(button));
    __glutWacomUpdate(v->valuators[WACOM_XCOORD_I],
            v->valuators[WACOM_YCOORD_I],
            v->valuators[WACOM_PRESSURE_I],
            (short) v->valuators[WACOM_XTILT_I],
            (short) v->valuators[WACOM_YTILT_I]);
    window->wacomButton(GLUT_WACOM_ERASER,
         __glutWacomButton,
         __glutWacomState,
         WACOM_STYLUS_BUTTON_STATE(button),
              __glutWacomX,
         __glutWacomY,
         __glutWacomPressure,
         __glutWacomXTilt,
         __glutWacomYTilt,
         wacomProximity);
    break;
  }
  XFreeDeviceState(state);
}

static void
wacomCursorChange(GLUTwindow * window, WacomEventType wacomEvent)
{
  XDeviceState *state;
  XInputClass *any;
  XValuatorState *v;
  XButtonState *b;
  int i;
  
  state = XQueryDeviceState(__glutDisplay, __glutWacomCursor);
  any = state->data;
  for (i = 0; i < state->num_classes; i++) {
#if defined(__cplusplus) || defined(c_plusplus)
    switch (any->c_class) {
#else
    switch (any->class) {
#endif
    case ButtonClass:
      b = (XButtonState *) any;
      break;
    case ValuatorClass:
      v = (XValuatorState *) any;
      break;
    }
    any = (XInputClass *) ((char *) any + any->length);
  }
  switch (wacomEvent) {
  case WACOM_MOTION_EVENT:
    __glutWacomUpdate(v->valuators[WACOM_XCOORD_I],
            v->valuators[WACOM_YCOORD_I],
            0, 0, 0);
    window->wacomMotion(GLUT_WACOM_CURSOR,
         WACOM_NO_STATE_INFO,
         __glutWacomX,
         __glutWacomY,
         /* No pressure info */
              0.0,
         /* 4D mouse rotation */
              WACOM_CURSOR_ROTATION((short)
                     v->valuators[WACOM_ROTATION_I]),
              /* No ytilt info */
         0.0,
                        /* 4D mouse wheel */
              (short) v->valuators[WACOM_WHEEL_I]);
    break;
  case WACOM_BUTTON_EVENT:
    __glutWacomSetButton(GLUT_WACOM_CURSOR, b->buttons[0]);
    __glutWacomUpdate(v->valuators[WACOM_XCOORD_I],
            v->valuators[WACOM_YCOORD_I],
            0, 0, 0);
    window->wacomButton(GLUT_WACOM_CURSOR,
         __glutWacomButton,
         __glutWacomState,
         WACOM_NO_STATE_INFO,
              __glutWacomX,
         __glutWacomY,
         /* No pressure info */
              0.0,
         /* 4D mouse rotation */
              WACOM_CURSOR_ROTATION((short)
                     v->valuators[WACOM_ROTATION_I]),
              /* No ytilt info */
         0.0,
         /* 4D mouse wheel */
              (short) v->valuators[WACOM_WHEEL_I]);
    break;
  }
  XFreeDeviceState(state);
}
#endif /* !_WIN32 */

int
__glutProcessDeviceEvents(XEvent * event)
{
#if !defined(_WIN32)
  GLUTwindow *window;

  /* XXX Ugly code fan out. */

  /* Can't use switch/case since X Input event types are
     dynamic. */

  if (__glutDeviceMotionNotify && event->type == __glutDeviceMotionNotify) {
    XDeviceMotionEvent *devmot = (XDeviceMotionEvent *) event;

    window = __glutGetWindow(devmot->window);
    if (window) {
      if (__glutTablet
        && devmot->deviceid == __glutTablet->device_id
        && window->tabletMotion) {
        tabletPosChange(window, devmot->first_axis, devmot->axes_count,
          devmot->axis_data);
      } else if (__glutWacomTablet
       && devmot->deviceid == __glutWacomTablet->device_id
       && window->wacomMotion) {
   wacomTabletChange(window, WACOM_MOTION_EVENT);
      } else if (__glutWacomStylus
       && devmot->deviceid == __glutWacomStylus->device_id
       && window->wacomMotion) {
   wacomStylusChange(window, WACOM_MOTION_EVENT, WACOM_NO_PROXIMITY_INFO);
      } else if (__glutWacomEraser
       && devmot->deviceid == __glutWacomEraser->device_id
       && window->wacomMotion) {
   wacomEraserChange(window, WACOM_MOTION_EVENT, WACOM_NO_PROXIMITY_INFO);
      } else if (__glutWacomCursor
       && devmot->deviceid == __glutWacomCursor->device_id
       && window->wacomMotion) {
   wacomCursorChange(window, WACOM_MOTION_EVENT);
      } else if (__glutDials
          && devmot->deviceid == __glutDials->device_id
        && window->dials) {
        int i, first = devmot->first_axis, count = devmot->axes_count;

        for (i = first; i < first + count; i++)
          window->dials(i + 1,
            normalizeDialAngle(i, devmot->axis_data[i - first]));
      } else if (__glutSpaceball
        && devmot->deviceid == __glutSpaceball->device_id) {
        /* XXX Assume that space ball motion events come in as
           all the first 6 axes.  Assume first 3 axes are XYZ
           translations; second 3 axes are XYZ rotations. */
        if (devmot->first_axis == 0 && devmot->axes_count == 6) {
          if (window->spaceMotion)
            window->spaceMotion(
              normalizeSpaceballDelta(0, devmot->axis_data[0]),
              normalizeSpaceballDelta(1, devmot->axis_data[1]),
              normalizeSpaceballDelta(2, devmot->axis_data[2]));
          if (window->spaceRotate)
            window->spaceRotate(
              normalizeSpaceballAngle(3, devmot->axis_data[3]),
              normalizeSpaceballAngle(4, devmot->axis_data[4]),
              normalizeSpaceballAngle(5, devmot->axis_data[5]));
        }
      }
      return 1;
    }
  } else if (__glutDeviceButtonPress
    && event->type == __glutDeviceButtonPress) {
    XDeviceButtonEvent *devbtn = (XDeviceButtonEvent *) event;

    window = __glutGetWindow(devbtn->window);
    if (window) {
      if (__glutTablet
        && devbtn->deviceid == __glutTablet->device_id
        && window->tabletButton
        && devbtn->first_axis == 0
        && devbtn->axes_count == 2) {
        tabletPosChange(window, devbtn->first_axis, devbtn->axes_count,
          devbtn->axis_data);
        window->tabletButton(devbtn->button, GLUT_DOWN,
          window->tabletPos[0], window->tabletPos[1]);
      } else if (__glutWacomTablet
       && devbtn->deviceid == __glutWacomTablet->device_id
       && window->wacomButton) {
   __glutSetWindow(window);
   __glutModifierMask = devbtn->state;
   wacomTabletChange(window, WACOM_BUTTON_EVENT);
   __glutModifierMask = ~0;
      } else if (__glutWacomStylus
       && devbtn->deviceid == __glutWacomStylus->device_id
       && window->wacomButton) {
   __glutSetWindow(window);
   __glutModifierMask = devbtn->state;
   wacomStylusChange(window, WACOM_BUTTON_EVENT, WACOM_NO_PROXIMITY_INFO);
   __glutModifierMask = ~0;
      } else if (__glutWacomEraser
       && devbtn->deviceid == __glutWacomEraser->device_id
       && window->wacomButton) {
   __glutSetWindow(window);
   __glutModifierMask = devbtn->state;
   wacomEraserChange(window, WACOM_BUTTON_EVENT, WACOM_NO_PROXIMITY_INFO);
   __glutModifierMask = ~0;
      } else if (__glutWacomCursor
       && devbtn->deviceid == __glutWacomCursor->device_id
       && window->wacomButton) {
   __glutSetWindow(window);
   __glutModifierMask = devbtn->state;
   wacomCursorChange(window, WACOM_BUTTON_EVENT);
   __glutModifierMask = ~0;
      } else if (__glutDials
          && devbtn->deviceid == __glutDials->device_id
        && window->buttonBox) {
        window->buttonBox(devbtn->button, GLUT_DOWN);
      } else if (__glutSpaceball
          && devbtn->deviceid == __glutSpaceball->device_id
        && window->spaceButton) {
        window->spaceButton(devbtn->button, GLUT_DOWN);
      }
      return 1;
    }
  } else if (__glutDeviceButtonRelease
    && event->type == __glutDeviceButtonRelease) {
    XDeviceButtonEvent *devbtn = (XDeviceButtonEvent *) event;

    window = __glutGetWindow(devbtn->window);
    if (window) {
      if (__glutTablet
        && devbtn->deviceid == __glutTablet->device_id
        && window->tabletButton
        && devbtn->first_axis == 0
        && devbtn->axes_count == 2) {
        tabletPosChange(window, devbtn->first_axis, devbtn->axes_count,
          devbtn->axis_data);
        window->tabletButton(devbtn->button, GLUT_UP,
          window->tabletPos[0], window->tabletPos[1]);
      } else if (__glutWacomTablet
       && devbtn->deviceid == __glutWacomTablet->device_id
       && window->wacomButton) {
   __glutSetWindow(window);
   __glutModifierMask = devbtn->state;
   wacomTabletChange(window, WACOM_BUTTON_EVENT);
   __glutModifierMask = ~0;
      } else if (__glutWacomStylus
       && devbtn->deviceid == __glutWacomStylus->device_id
       && window->wacomButton) {
   __glutSetWindow(window);
   __glutModifierMask = devbtn->state;
   wacomStylusChange(window, WACOM_BUTTON_EVENT, WACOM_NO_PROXIMITY_INFO);
   __glutModifierMask = ~0;
      } else if (__glutWacomEraser
       && devbtn->deviceid == __glutWacomEraser->device_id
       && window->wacomButton) {
   __glutSetWindow(window);
   __glutModifierMask = devbtn->state;
   wacomEraserChange(window, WACOM_BUTTON_EVENT, WACOM_NO_PROXIMITY_INFO);
   __glutModifierMask = ~0;
      } else if (__glutWacomCursor
       && devbtn->deviceid == __glutWacomCursor->device_id
       && window->wacomButton) {
   __glutSetWindow(window);
   __glutModifierMask = devbtn->state;
   wacomCursorChange(window, WACOM_BUTTON_EVENT);
   __glutModifierMask = ~0;
      } else if (__glutDials
          && devbtn->deviceid == __glutDials->device_id
        && window->buttonBox) {
        window->buttonBox(devbtn->button, GLUT_UP);
      } else if (__glutSpaceball
          && devbtn->deviceid == __glutSpaceball->device_id
        && window->spaceButton) {
        window->spaceButton(devbtn->button, GLUT_UP);
      }
      return 1;
    }
  } else if (__glutProximityIn && event->type == __glutProximityIn) {
    XProximityNotifyEvent *prxnot = (XProximityNotifyEvent *) event;

    window = __glutGetWindow(prxnot->window);
    if (window) {
      if (__glutWacomTablet
     && prxnot->deviceid == __glutWacomTablet->device_id
     && window->wacomButton) {
   __glutSetWindow(window);
   __glutModifierMask = prxnot->state;
   wacomTabletChange(window, WACOM_BUTTON_EVENT);
   __glutModifierMask = ~0;
      } else if (__glutWacomStylus
       && prxnot->deviceid == __glutWacomStylus->device_id
       && window->wacomButton) {
   __glutSetWindow(window);
   __glutModifierMask = prxnot->state;
   wacomStylusChange(window, WACOM_BUTTON_EVENT, WACOM_PROXIMITY_IN);
   __glutModifierMask = ~0;
      } else if (__glutWacomEraser
       && prxnot->deviceid == __glutWacomEraser->device_id
       && window->wacomButton) {
   __glutSetWindow(window);
   __glutModifierMask = prxnot->state;
   wacomEraserChange(window, WACOM_BUTTON_EVENT, WACOM_PROXIMITY_IN);
   __glutModifierMask = ~0;
      }
      return 1;
    }
  } else if (__glutProximityOut && event->type == __glutProximityOut) {
    XProximityNotifyEvent *prxnot = (XProximityNotifyEvent *) event;

    window = __glutGetWindow(prxnot->window);
    if (window) {
      if (__glutWacomTablet
     && prxnot->deviceid == __glutWacomTablet->device_id
     && window->wacomButton) {
   __glutSetWindow(window);
   __glutModifierMask = prxnot->state;
   wacomTabletChange(window, WACOM_BUTTON_EVENT);
   __glutModifierMask = ~0;
      } else if (__glutWacomStylus
       && prxnot->deviceid == __glutWacomStylus->device_id
       && window->wacomButton) {
   __glutSetWindow(window);
   __glutModifierMask = prxnot->state;
   wacomStylusChange(window, WACOM_BUTTON_EVENT, WACOM_PROXIMITY_OUT);
   __glutModifierMask = ~0;
      } else if (__glutWacomEraser
       && prxnot->deviceid == __glutWacomEraser->device_id
       && window->wacomButton) {
   __glutSetWindow(window);
   __glutModifierMask = prxnot->state;
   wacomEraserChange(window, WACOM_BUTTON_EVENT, WACOM_PROXIMITY_OUT);
   __glutModifierMask = ~0;
      }
      return 1;
    }
  }
#else
  {
    JOYINFOEX info;
    int njoyId = 0;
    int nConnected = 0;
    MMRESULT result;

    /* Loop through all possible joystick IDs until we get the error
       JOYERR_PARMS. Count the number of times we get JOYERR_NOERROR
       indicating an installed joystick driver with a joystick currently
       attached to the port. */
    while ((result = joyGetPosEx(njoyId++,&info)) != JOYERR_PARMS) {
      if (result == JOYERR_NOERROR) {
        ++nConnected;  /* The count of connected joysticks. */
      }
    }
  }
#endif /* !_WIN32 */
  return 0;
}

static GLUTeventParser eventParser =
{__glutProcessDeviceEvents, NULL};

static void
addDeviceEventParser(void)
{
  static Bool been_here = False;

  if (been_here)
    return;
  been_here = True;
  __glutRegisterEventParser(&eventParser);
}

static int
probeDevices(void)
{
  static Bool been_here = False;
  static int support;
#if !defined(_WIN32)
  XExtensionVersion *version;
  XDeviceInfoPtr device_info, device;
  XAnyClassPtr any;
  XButtonInfoPtr b;
  XValuatorInfoPtr v;
  XAxisInfoPtr a;
  int num_dev, btns, dials;
  int i, j, k;
#endif /* !_WIN32 */

  if (been_here) {
    return support;
  }
  been_here = True;

#if !defined(_WIN32)
  version = XGetExtensionVersion(__glutDisplay, "XInputExtension");
  /* Ugh.  XInput extension API forces annoying cast of a pointer
     to a long so it can be compared with the NoSuchExtension
     value (#defined to 1). */
  if (version == NULL || ((long) version) == NoSuchExtension) {
    support = 0;
    return support;
  }
  XFree(version);
  device_info = XListInputDevices(__glutDisplay, &num_dev);
  if (device_info) {
    for (i = 0; i < num_dev; i++) {
      /* XXX These are SGI names for these devices;
         unfortunately, no good standard exists for standard
         types of X input extension devices. */

      device = &device_info[i];
      any = (XAnyClassPtr) device->inputclassinfo;

      if (!__glutSpaceball && !strcmp(device->name, "spaceball")) {
        v = NULL;
        b = NULL;
        for (j = 0; j < device->num_classes; j++) {
#if defined(__cplusplus) || defined(c_plusplus)
          switch (any->c_class) {
#else
          switch (any->class) {
#endif
          case ButtonClass:
            b = (XButtonInfoPtr) any;
            btns = b->num_buttons;
            break;
          case ValuatorClass:
            v = (XValuatorInfoPtr) any;
            /* Sanity check: at least 6 valuators? */
            if (v->num_axes < NUM_SPACEBALL_AXIS)
              goto skip_device;
            a = (XAxisInfoPtr) ((char *) v + sizeof(XValuatorInfo));
            for (k = 0; k < NUM_SPACEBALL_AXIS; k++, a++) {
              __glutSpaceballRange[k].min = a->min_value;
              __glutSpaceballRange[k].range = a->max_value - a->min_value;
            }
            break;
          }
          any = (XAnyClassPtr) ((char *) any + any->length);
        }
        if (v) {
          __glutSpaceball = XOpenDevice(__glutDisplay, device->id);
          if (__glutSpaceball) {
            __glutNumSpaceballButtons = btns;
            addDeviceEventParser();
          }
        }
      } else if (!__glutDials && !strcmp(device->name, "dial+buttons")) {
        v = NULL;
        b = NULL;
        for (j = 0; j < device->num_classes; j++) {
#if defined(__cplusplus) || defined(c_plusplus)
          switch (any->c_class) {
#else
          switch (any->class) {
#endif
          case ButtonClass:
            b = (XButtonInfoPtr) any;
            btns = b->num_buttons;
            break;
          case ValuatorClass:
            v = (XValuatorInfoPtr) any;
            /* Sanity check: at least 8 valuators? */
            if (v->num_axes < NUM_DIALS_AXIS)
              goto skip_device;
            dials = v->num_axes;
            __glutDialsResolution = (int *) malloc(sizeof(int) * dials);
            a = (XAxisInfoPtr) ((char *) v + sizeof(XValuatorInfo));
            for (k = 0; k < dials; k++, a++) {
              __glutDialsResolution[k] = a->resolution;
            }
            break;
          }
          any = (XAnyClassPtr) ((char *) any + any->length);
        }
        if (v) {
          __glutDials = XOpenDevice(__glutDisplay, device->id);
          if (__glutDials) {
            __glutNumButtonBoxButtons = btns;
            __glutNumDials = dials;
            addDeviceEventParser();
          }
        }
      } else if (!__glutTablet && !strcmp(device->name, "tablet")) {
        v = NULL;
        b = NULL;
        for (j = 0; j < device->num_classes; j++) {
#if defined(__cplusplus) || defined(c_plusplus)
          switch (any->c_class) {
#else
          switch (any->class) {
#endif
          case ButtonClass:
            b = (XButtonInfoPtr) any;
            btns = b->num_buttons;
            break;
          case ValuatorClass:
            v = (XValuatorInfoPtr) any;
            /* Sanity check: exactly 2 valuators? */
            if (v->num_axes != NUM_TABLET_AXIS)
              goto skip_device;
            a = (XAxisInfoPtr) ((char *) v + sizeof(XValuatorInfo));
            for (k = 0; k < NUM_TABLET_AXIS; k++, a++) {
              __glutTabletRange[k].min = a->min_value;
              __glutTabletRange[k].range = a->max_value - a->min_value;
            }
            break;
          }
          any = (XAnyClassPtr) ((char *) any + any->length);
        }
        if (v) {
          __glutTablet = XOpenDevice(__glutDisplay, device->id);
          if (__glutTablet) {
            __glutNumTabletButtons = btns;
            addDeviceEventParser();
          }
        }
      } else if (!__glutWacomTablet && !strcmp(device->name, WACOM_NAME)) {
        v = NULL;
        b = NULL;
        for (j = 0; j < device->num_classes; j++) {
#if defined(__cplusplus) || defined(c_plusplus)
          switch (any->c_class) {
#else
          switch (any->class) {
#endif
          case ButtonClass:
            b = (XButtonInfoPtr) any;
            btns = b->num_buttons;
            break;
          case ValuatorClass:
            v = (XValuatorInfoPtr) any;
            /* Sanity check */
            if (v->num_axes != NUM_WACOM_TABLET_AXIS)
              goto skip_device;
            a = (XAxisInfoPtr) ((char *) v + sizeof(XValuatorInfo));
            for (k = 0; k < NUM_WACOM_TABLET_AXIS; k++, a++) {
              __glutWacomTabletRange[k].min = a->min_value;
              __glutWacomTabletRange[k].range = a->max_value - a->min_value;
            }
            break;
          }
          any = (XAnyClassPtr) ((char *) any + any->length);
        }
        if (v) {
          __glutWacomTablet = XOpenDevice(__glutDisplay, device->id);
          if (__glutWacomTablet) {
            __glutNumWacomTabletButtons = btns;
            addDeviceEventParser();
          }
        }
      } else if (!__glutWacomStylus
       && !strcmp(device->name, WACOM_STYLUS_NAME)) {
        v = NULL;
        b = NULL;
        for (j = 0; j < device->num_classes; j++) {
#if defined(__cplusplus) || defined(c_plusplus)
          switch (any->c_class) {
#else
          switch (any->class) {
#endif
          case ButtonClass:
            b = (XButtonInfoPtr) any;
            btns = b->num_buttons;
            break;
          case ValuatorClass:
            v = (XValuatorInfoPtr) any;
            /* Sanity check */
            if (v->num_axes != NUM_WACOM_STYLUS_AXIS)
              goto skip_device;
            a = (XAxisInfoPtr) ((char *) v + sizeof(XValuatorInfo));
            for (k = 0; k < NUM_WACOM_STYLUS_AXIS; k++, a++) {
              __glutWacomStylusRange[k].min = a->min_value;
              __glutWacomStylusRange[k].range = a->max_value - a->min_value;
            }
            break;
          }
          any = (XAnyClassPtr) ((char *) any + any->length);
        }
        if (v) {
          __glutWacomStylus = XOpenDevice(__glutDisplay, device->id);
          if (__glutWacomStylus) {
            __glutNumWacomStylusButtons = btns;
            addDeviceEventParser();
          }
        }
      } else if (!__glutWacomEraser
       && !strcmp(device->name, WACOM_ERASER_NAME)) {
        v = NULL;
        b = NULL;
        for (j = 0; j < device->num_classes; j++) {
#if defined(__cplusplus) || defined(c_plusplus)
          switch (any->c_class) {
#else
          switch (any->class) {
#endif
          case ButtonClass:
            b = (XButtonInfoPtr) any;
            btns = b->num_buttons;
            break;
          case ValuatorClass:
            v = (XValuatorInfoPtr) any;
            /* Sanity check */
            if (v->num_axes != NUM_WACOM_ERASER_AXIS)
              goto skip_device;
            a = (XAxisInfoPtr) ((char *) v + sizeof(XValuatorInfo));
            for (k = 0; k < NUM_WACOM_ERASER_AXIS; k++, a++) {
              __glutWacomEraserRange[k].min = a->min_value;
              __glutWacomEraserRange[k].range = a->max_value - a->min_value;
            }
            break;
          }
          any = (XAnyClassPtr) ((char *) any + any->length);
        }
        if (v) {
          __glutWacomEraser = XOpenDevice(__glutDisplay, device->id);
          if (__glutWacomEraser) {
            __glutNumWacomEraserButtons = btns;
            addDeviceEventParser();
          }
        }
      } else if (!__glutWacomCursor
       && !strcmp(device->name, WACOM_CURSOR_NAME)) {
        v = NULL;
        b = NULL;
        for (j = 0; j < device->num_classes; j++) {
#if defined(__cplusplus) || defined(c_plusplus)
          switch (any->c_class) {
#else
          switch (any->class) {
#endif
          case ButtonClass:
            b = (XButtonInfoPtr) any;
            btns = b->num_buttons;
            break;
          case ValuatorClass:
            v = (XValuatorInfoPtr) any;
            /* Sanity check */
            if (v->num_axes != NUM_WACOM_CURSOR_AXIS)
              goto skip_device;
            a = (XAxisInfoPtr) ((char *) v + sizeof(XValuatorInfo));
            for (k = 0; k < NUM_WACOM_CURSOR_AXIS; k++, a++) {
              __glutWacomCursorRange[k].min = a->min_value;
              __glutWacomCursorRange[k].range = a->max_value - a->min_value;
            }
            break;
          }
          any = (XAnyClassPtr) ((char *) any + any->length);
        }
        if (v) {
          __glutWacomCursor = XOpenDevice(__glutDisplay, device->id);
          if (__glutWacomCursor) {
            __glutNumWacomCursorButtons = btns;
            addDeviceEventParser();
          }
        }
      } else if (!strcmp(device->name, "mouse")) {
        for (j = 0; j < device->num_classes; j++) {
#if defined(__cplusplus) || defined(c_plusplus)
          if (any->c_class == ButtonClass) {
#else
          if (any->class == ButtonClass) {
#endif
            b = (XButtonInfoPtr) any;
            __glutNumMouseButtons = b->num_buttons;
          }
          any = (XAnyClassPtr) ((char *) any + any->length);
        }
      }
    skip_device:;
    }
    XFreeDeviceList(device_info);
  }
#else /* _WIN32 */
  __glutNumMouseButtons = GetSystemMetrics(SM_CMOUSEBUTTONS);
#endif /* !_WIN32 */
  /* X Input extension might be supported, but only if there is
     a tablet, wacom tablet, wacom stylus, wacom eraser, wacom cursor,
     dials, or spaceball do we claim devices are supported. */
  support = __glutTablet || __glutWacomTablet ||
            __glutWacomStylus || __glutWacomEraser || __glutWacomCursor ||
            __glutDials || __glutSpaceball;
  return support;
}

void
__glutUpdateInputDeviceMask(GLUTwindow * window)
{
#if !defined(_WIN32)
  /* 5 (dial and buttons) +
     5 (tablet locator and buttons) +
     7 (wacom tablet) +
     7 (wacom stylus) +
     7 (wacom eraser) +
     5 (wacom cursor) +
     5 (Spaceball buttons and axis)
     = 41
  */
  XEventClass eventList[41];
  int rc, numEvents;

  rc = probeDevices();
  if (rc) {
    numEvents = 0;
    if (__glutTablet) {
      if (window->tabletMotion) {
        DeviceMotionNotify(__glutTablet, __glutDeviceMotionNotify,
          eventList[numEvents]);
        numEvents++;
      }
      if (window->tabletButton) {
        DeviceButtonPress(__glutTablet, __glutDeviceButtonPress,
          eventList[numEvents]);
        numEvents++;
        DeviceButtonPressGrab(__glutTablet, __glutDeviceButtonPressGrab,
          eventList[numEvents]);
        numEvents++;
        DeviceButtonRelease(__glutTablet, __glutDeviceButtonRelease,
          eventList[numEvents]);
        numEvents++;
      }
      if (window->tabletMotion || window->tabletButton) {
        DeviceStateNotify(__glutTablet, __glutDeviceStateNotify,
          eventList[numEvents]);
        numEvents++;
      }
    }
    if (__glutWacomTablet) {
      if (window->wacomMotion) {
        DeviceMotionNotify(__glutWacomTablet, __glutDeviceMotionNotify,
          eventList[numEvents]);
        numEvents++;
      }
      if (window->wacomButton) {
        DeviceButtonPress(__glutWacomTablet, __glutDeviceButtonPress,
          eventList[numEvents]);
        numEvents++;
        DeviceButtonPressGrab(__glutWacomTablet, __glutDeviceButtonPressGrab,
          eventList[numEvents]);
        numEvents++;
        DeviceButtonRelease(__glutWacomTablet, __glutDeviceButtonRelease,
          eventList[numEvents]);
        numEvents++;
   ProximityIn(__glutWacomTablet, __glutProximityIn,
     eventList[numEvents]);
   numEvents++;
   ProximityOut(__glutWacomTablet, __glutProximityOut,
     eventList[numEvents]);
   numEvents++;
      }
      if (window->wacomMotion || window->wacomButton) {
        DeviceStateNotify(__glutWacomTablet, __glutDeviceStateNotify,
          eventList[numEvents]);
        numEvents++;
      }
    }
    if (__glutWacomStylus) {
      if (window->wacomMotion) {
        DeviceMotionNotify(__glutWacomStylus, __glutDeviceMotionNotify,
          eventList[numEvents]);
        numEvents++;
      }
      if (window->wacomButton) {
        DeviceButtonPress(__glutWacomStylus, __glutDeviceButtonPress,
          eventList[numEvents]);
        numEvents++;
        DeviceButtonPressGrab(__glutWacomStylus, __glutDeviceButtonPressGrab,
          eventList[numEvents]);
        numEvents++;
        DeviceButtonRelease(__glutWacomStylus, __glutDeviceButtonRelease,
          eventList[numEvents]);
        numEvents++;
   ProximityIn(__glutWacomStylus, __glutProximityIn,
     eventList[numEvents]);
   numEvents++;
   ProximityOut(__glutWacomStylus, __glutProximityOut,
     eventList[numEvents]);
   numEvents++;
      }
      if (window->wacomMotion || window->wacomButton) {
        DeviceStateNotify(__glutWacomStylus, __glutDeviceStateNotify,
          eventList[numEvents]);
        numEvents++;
      }
    }
    if (__glutWacomEraser) {
      if (window->wacomMotion) {
        DeviceMotionNotify(__glutWacomEraser, __glutDeviceMotionNotify,
          eventList[numEvents]);
        numEvents++;
      }
      if (window->wacomButton) {
        DeviceButtonPress(__glutWacomEraser, __glutDeviceButtonPress,
          eventList[numEvents]);
        numEvents++;
        DeviceButtonPressGrab(__glutWacomEraser, __glutDeviceButtonPressGrab,
          eventList[numEvents]);
        numEvents++;
        DeviceButtonRelease(__glutWacomEraser, __glutDeviceButtonRelease,
          eventList[numEvents]);
        numEvents++;
   ProximityIn(__glutWacomEraser, __glutProximityIn,
     eventList[numEvents]);
   numEvents++;
   ProximityOut(__glutWacomEraser, __glutProximityOut,
     eventList[numEvents]);
   numEvents++;
      }
      if (window->wacomMotion || window->wacomButton) {
        DeviceStateNotify(__glutWacomEraser, __glutDeviceStateNotify,
          eventList[numEvents]);
        numEvents++;
      }
    }
    if (__glutWacomCursor) {
      if (window->wacomMotion) {
        DeviceMotionNotify(__glutWacomCursor, __glutDeviceMotionNotify,
          eventList[numEvents]);
        numEvents++;
      }
      if (window->wacomButton) {
        DeviceButtonPress(__glutWacomCursor, __glutDeviceButtonPress,
          eventList[numEvents]);
        numEvents++;
        DeviceButtonPressGrab(__glutWacomCursor, __glutDeviceButtonPressGrab,
          eventList[numEvents]);
        numEvents++;
        DeviceButtonRelease(__glutWacomCursor, __glutDeviceButtonRelease,
          eventList[numEvents]);
        numEvents++;
      }
      if (window->wacomMotion || window->wacomButton) {
        DeviceStateNotify(__glutWacomCursor, __glutDeviceStateNotify,
          eventList[numEvents]);
        numEvents++;
      }
    }
    if (__glutDials) {
      if (window->dials) {
        DeviceMotionNotify(__glutDials, __glutDeviceMotionNotify,
          eventList[numEvents]);
        numEvents++;
      }
      if (window->buttonBox) {
        DeviceButtonPress(__glutDials, __glutDeviceButtonPress,
          eventList[numEvents]);
        numEvents++;
        DeviceButtonPressGrab(__glutDials, __glutDeviceButtonPressGrab,
          eventList[numEvents]);
        numEvents++;
        DeviceButtonRelease(__glutDials, __glutDeviceButtonRelease,
          eventList[numEvents]);
        numEvents++;
      }
      if (window->dials || window->buttonBox) {
        DeviceStateNotify(__glutDials, __glutDeviceStateNotify,
          eventList[numEvents]);
        numEvents++;
      }
    }
    if (__glutSpaceball) {
      if (window->spaceMotion || window->spaceRotate) {
        DeviceMotionNotify(__glutSpaceball, __glutDeviceMotionNotify,
          eventList[numEvents]);
        numEvents++;
      }
      if (window->spaceButton) {
        DeviceButtonPress(__glutSpaceball, __glutDeviceButtonPress,
          eventList[numEvents]);
        numEvents++;
        DeviceButtonPressGrab(__glutSpaceball, __glutDeviceButtonPressGrab,
          eventList[numEvents]);
        numEvents++;
        DeviceButtonRelease(__glutSpaceball, __glutDeviceButtonRelease,
          eventList[numEvents]);
        numEvents++;
      }
      if (window->spaceMotion || window->spaceRotate || window->spaceButton) {
        DeviceStateNotify(__glutSpaceball, __glutDeviceStateNotify,
          eventList[numEvents]);
        numEvents++;
      }
    }
#if 0
    if (window->children) {
      GLUTwindow *child = window->children;

      do {
        XChangeDeviceDontPropagateList(__glutDisplay, child->win,
          numEvents, eventList, AddToList);
        child = child->siblings;
      } while (child);
    }
#endif
    XSelectExtensionEvent(__glutDisplay, window->win,
      eventList, numEvents);
    if (window->overlay) {
      XSelectExtensionEvent(__glutDisplay, window->overlay->win,
        eventList, numEvents);
    }
  } else {
    /* X Input extension not supported; no chance for exotic
       input devices. */
  }
#endif /* !_WIN32 */
}

/* CENTRY */
int APIENTRY
glutDeviceGet(GLenum param)
{
  probeDevices();
  switch (param) {
  case GLUT_HAS_KEYBOARD:
  case GLUT_HAS_MOUSE:
    /* Assume window system always has mouse and keyboard. */
    return 1;
  case GLUT_HAS_SPACEBALL:
    return __glutSpaceball != NULL;
  case GLUT_HAS_DIAL_AND_BUTTON_BOX:
    return __glutDials != NULL;
  case GLUT_HAS_TABLET:
    return __glutTablet != NULL;
  case GLUT_HAS_WACOM_TABLET:
#if defined(__sgi)
    return __glutWacomTablet != NULL;
#elif defined(__linux__)
    return __glutWacomStylus != NULL;
#endif
  case GLUT_HAS_WACOM_STYLUS:
    return __glutWacomStylus != NULL;
  case GLUT_HAS_WACOM_ERASER:
    return __glutWacomEraser != NULL;
  case GLUT_HAS_WACOM_CURSOR:
    return __glutWacomCursor != NULL;
  case GLUT_NUM_MOUSE_BUTTONS:
    return __glutNumMouseButtons;
  case GLUT_NUM_SPACEBALL_BUTTONS:
    return __glutNumSpaceballButtons;
  case GLUT_NUM_BUTTON_BOX_BUTTONS:
    return __glutNumButtonBoxButtons;
  case GLUT_NUM_DIALS:
    return __glutNumDials;
  case GLUT_NUM_TABLET_BUTTONS:
    return __glutNumTabletButtons;
  case GLUT_NUM_WACOM_TABLET_BUTTONS:
    return __glutNumWacomTabletButtons;
  case GLUT_NUM_WACOM_STYLUS_BUTTONS:
    return __glutNumWacomStylusButtons;
  case GLUT_NUM_WACOM_ERASER_BUTTONS:
    return __glutNumWacomEraserButtons;
  case GLUT_NUM_WACOM_CURSOR_BUTTONS:
    return __glutNumWacomCursorButtons;
  case GLUT_WACOM_TABLET_XCOORD_MIN:
    return __glutWacomTabletRange[WAC_XCOORD_I].min;
  case GLUT_WACOM_TABLET_XCOORD_RANGE:
    return __glutWacomTabletRange[WAC_XCOORD_I].range;
  case GLUT_WACOM_TABLET_YCOORD_MIN:
    return __glutWacomTabletRange[WAC_YCOORD_I].min;
  case GLUT_WACOM_TABLET_YCOORD_RANGE:
    return __glutWacomTabletRange[WAC_YCOORD_I].range;
  case GLUT_WACOM_TABLET_PRESSURE_MIN:
    return __glutWacomTabletRange[WAC_PRESSURE_I].min;
  case GLUT_WACOM_TABLET_PRESSURE_RANGE:
    return __glutWacomTabletRange[WAC_PRESSURE_I].range;
  /* wacom sgi driver gives tilt value varying
     between -60 and +60 (not -64 and +63) degrees... */
  case GLUT_WACOM_TABLET_XTILT_MIN:
    return -60; /*__glutWacomTabletRange[WAC_XTILT_I].min;*/
  case GLUT_WACOM_TABLET_XTILT_RANGE:
    return 120; /*__glutWacomTabletRange[WAC_XTILT_I].range;*/
  case GLUT_WACOM_TABLET_YTILT_MIN:
    return -60; /*__glutWacomTabletRange[WAC_YTILT_I].min;*/
  case GLUT_WACOM_TABLET_YTILT_RANGE:
    return 120; /*__glutWacomTabletRange[WAC_YTILT_I].range;*/
  case GLUT_WACOM_STYLUS_XCOORD_MIN:
    return __glutWacomStylusRange[WACOM_XCOORD_I].min;
  case GLUT_WACOM_STYLUS_XCOORD_RANGE:
    return __glutWacomStylusRange[WACOM_XCOORD_I].range;
  case GLUT_WACOM_STYLUS_YCOORD_MIN:
    return __glutWacomStylusRange[WACOM_YCOORD_I].min;
  case GLUT_WACOM_STYLUS_YCOORD_RANGE:
    return __glutWacomStylusRange[WACOM_YCOORD_I].range;
  case GLUT_WACOM_STYLUS_PRESSURE_MIN:
    return __glutWacomStylusRange[WACOM_PRESSURE_I].min;
  case GLUT_WACOM_STYLUS_PRESSURE_RANGE:
    return __glutWacomStylusRange[WACOM_PRESSURE_I].range;
  case GLUT_WACOM_STYLUS_XTILT_MIN:
    return __glutWacomStylusRange[WACOM_XTILT_I].min;
  case GLUT_WACOM_STYLUS_XTILT_RANGE:
    return __glutWacomStylusRange[WACOM_XTILT_I].range;
  case GLUT_WACOM_STYLUS_YTILT_MIN:
    return __glutWacomStylusRange[WACOM_YTILT_I].min;
  case GLUT_WACOM_STYLUS_YTILT_RANGE:
    return __glutWacomStylusRange[WACOM_YTILT_I].range;
  case GLUT_WACOM_ERASER_XCOORD_MIN:
    return __glutWacomEraserRange[WACOM_XCOORD_I].min;
  case GLUT_WACOM_ERASER_XCOORD_RANGE:
    return __glutWacomEraserRange[WACOM_XCOORD_I].range;
  case GLUT_WACOM_ERASER_YCOORD_MIN:
    return __glutWacomEraserRange[WACOM_YCOORD_I].min;
  case GLUT_WACOM_ERASER_YCOORD_RANGE:
    return __glutWacomEraserRange[WACOM_YCOORD_I].range;
  case GLUT_WACOM_ERASER_PRESSURE_MIN:
    return __glutWacomEraserRange[WACOM_PRESSURE_I].min;
  case GLUT_WACOM_ERASER_PRESSURE_RANGE:
    return __glutWacomEraserRange[WACOM_PRESSURE_I].range;
  case GLUT_WACOM_ERASER_XTILT_MIN:
    return __glutWacomEraserRange[WACOM_XTILT_I].min;
  case GLUT_WACOM_ERASER_XTILT_RANGE:
    return __glutWacomEraserRange[WACOM_XTILT_I].range;
  case GLUT_WACOM_ERASER_YTILT_MIN:
    return __glutWacomEraserRange[WACOM_YTILT_I].min;
  case GLUT_WACOM_ERASER_YTILT_RANGE:
    return __glutWacomEraserRange[WACOM_YTILT_I].range;
  case GLUT_WACOM_CURSOR_XCOORD_MIN:
    return __glutWacomCursorRange[WACOM_XCOORD_I].min;
  case GLUT_WACOM_CURSOR_XCOORD_RANGE:
    return __glutWacomCursorRange[WACOM_XCOORD_I].range;
  case GLUT_WACOM_CURSOR_YCOORD_MIN:
    return __glutWacomCursorRange[WACOM_YCOORD_I].min;
  case GLUT_WACOM_CURSOR_YCOORD_RANGE:
    return __glutWacomCursorRange[WACOM_YCOORD_I].range;
  case GLUT_WACOM_CURSOR_PRESSURE_MIN:
    return __glutWacomCursorRange[WACOM_PRESSURE_I].min;
  case GLUT_WACOM_CURSOR_PRESSURE_RANGE:
    return __glutWacomCursorRange[WACOM_PRESSURE_I].range;
  case GLUT_WACOM_CURSOR_XTILT_MIN:
    return __glutWacomCursorRange[WACOM_XTILT_I].min;
  case GLUT_WACOM_CURSOR_XTILT_RANGE:
    return __glutWacomCursorRange[WACOM_XTILT_I].range;
  case GLUT_WACOM_CURSOR_YTILT_MIN:
    return __glutWacomCursorRange[WACOM_YTILT_I].min;
  case GLUT_WACOM_CURSOR_YTILT_RANGE:
    return __glutWacomCursorRange[WACOM_YTILT_I].range;
  case GLUT_DEVICE_IGNORE_KEY_REPEAT:
    return __glutCurrentWindow->ignoreKeyRepeat;
#ifndef _WIN32
  case GLUT_DEVICE_KEY_REPEAT:
    {
      XKeyboardState state;

      XGetKeyboardControl(__glutDisplay, &state);
      return state.global_auto_repeat;
    }
  case GLUT_JOYSTICK_POLL_RATE:
    return 0;
#else
  case GLUT_DEVICE_KEY_REPEAT:
    /* Win32 cannot globally disable key repeat. */
    return GLUT_KEY_REPEAT_ON;
  case GLUT_JOYSTICK_POLL_RATE:
    return __glutCurrentWindow->joyPollInterval;
#endif
  case GLUT_HAS_JOYSTICK:
    return __glutHasJoystick;
  case GLUT_JOYSTICK_BUTTONS:
    return __glutNumJoystickButtons;
  case GLUT_JOYSTICK_AXES:
    return __glutNumJoystickAxes;
  default:
    __glutWarning("invalid glutDeviceGet parameter: %d", param);
    return -1;
  }
}
/* ENDCENTRY */

---