开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > GIS编程 > 查看源码
glut_input.c
资源名称：glut23-src.zip　[点击查看]
上传用户：xk288cn
上传日期：2007-05-28
资源大小：4876k
文件大小：20k
源码类别：

GIS编程

开发平台：

Visual C++

glut_input.c：源码内容
  2. /* Copyright (c) Mark J. Kilgard, 1994, 1997, 1998. */
  4. /* This program is freely distributable without licensing fees
  5.    and is provided without guarantee or warrantee expressed or
  6.    implied. This program is -not- in the public domain. */
  8. #include <assert.h>
  9. #include <stdio.h>
  10. #include <stdlib.h>
  11. #include <string.h>
  13. #if !defined(_WIN32)
  14. #include <X11/Xlib.h>
  15. #if defined(__vms)
  16. #include <X11/XInput.h>
  17. #else
  18. #include <X11/extensions/XInput.h>
  19. #endif
  20. #include <X11/Xutil.h>
  21. #else
  22. #include <windows.h>
  23. #include <mmsystem.h>  /* Win32 Multimedia API header. */
  24. #endif /* !_WIN32 */
  26. #include "glutint.h"
  28. int __glutNumDials = 0;
  29. int __glutNumSpaceballButtons = 0;
  30. int __glutNumButtonBoxButtons = 0;
  31. int __glutNumTabletButtons = 0;
  32. int __glutNumMouseButtons = 3;  /* Good guess. */
  33. XDevice *__glutTablet = NULL;
  34. XDevice *__glutDials = NULL;
  35. XDevice *__glutSpaceball = NULL;
  37. int __glutHasJoystick = 0;
  38. int __glutNumJoystickButtons = 0;
  39. int __glutNumJoystickAxes = 0;
  41. #if !defined(_WIN32)
  42. typedef struct _Range {
  43.   int min;
  44.   int range;
  45. } Range;
  47. #define NUM_SPACEBALL_AXIS 6
  48. #define NUM_TABLET_AXIS 2
  49. #define NUM_DIALS_AXIS 8
  51. Range __glutSpaceballRange[NUM_SPACEBALL_AXIS];
  52. Range __glutTabletRange[NUM_TABLET_AXIS];
  53. int *__glutDialsResolution;
  55. /* Safely assumes 0 is an illegal event type for X Input
  56.    extension events. */
  57. int __glutDeviceMotionNotify = 0;
  58. int __glutDeviceButtonPress = 0;
  59. int __glutDeviceButtonPressGrab = 0;
  60. int __glutDeviceButtonRelease = 0;
  61. int __glutDeviceStateNotify = 0;
  63. static int
  64. normalizeTabletPos(int axis, int rawValue)
  65. {
  66.   assert(rawValue >= __glutTabletRange[axis].min);
  67.   assert(rawValue <= __glutTabletRange[axis].min
  68.     + __glutTabletRange[axis].range);
  69.   /* Normalize rawValue to between 0 and 4000. */
  70.   return ((rawValue - __glutTabletRange[axis].min) * 4000) /
  71.     __glutTabletRange[axis].range;
  72. }
  74. static int
  75. normalizeDialAngle(int axis, int rawValue)
  76. {
  77.   /* XXX Assumption made that the resolution of the device is
  78.      number of clicks for one complete dial revolution.  This
  79.      is true for SGI's dial & button box. */
  80.   return (rawValue * 360.0) / __glutDialsResolution[axis];
  81. }
  83. static int
  84. normalizeSpaceballAngle(int axis, int rawValue)
  85. {
  86.   assert(rawValue >= __glutSpaceballRange[axis].min);
  87.   assert(rawValue <= __glutSpaceballRange[axis].min +
  88.     __glutSpaceballRange[axis].range);
  89.   /* Normalize rawValue to between -1800 and 1800. */
  90.   return ((rawValue - __glutSpaceballRange[axis].min) * 3600) /
  91.     __glutSpaceballRange[axis].range - 1800;
  92. }
  94. static int
  95. normalizeSpaceballDelta(int axis, int rawValue)
  96. {
  97.   assert(rawValue >= __glutSpaceballRange[axis].min);
  98.   assert(rawValue <= __glutSpaceballRange[axis].min +
  99.     __glutSpaceballRange[axis].range);
  100.   /* Normalize rawValue to between -1000 and 1000. */
  101.   return ((rawValue - __glutSpaceballRange[axis].min) * 2000) /
  102.     __glutSpaceballRange[axis].range - 1000;
  103. }
  105. static void
  106. queryTabletPos(GLUTwindow * window)
  107. {
  108.   XDeviceState *state;
  109.   XInputClass *any;
  110.   XValuatorState *v;
  111.   int i;
  113.   state = XQueryDeviceState(__glutDisplay, __glutTablet);
  114.   any = state->data;
  115.   for (i = 0; i < state->num_classes; i++) {
  116. #if defined(__cplusplus) || defined(c_plusplus)
  117.     switch (any->c_class) {
  118. #else
  119.     switch (any->class) {
  120. #endif
  121.     case ValuatorClass:
  122.       v = (XValuatorState *) any;
  123.       if (v->num_valuators < 2)
  124.         goto end;
  125.       if (window->tabletPos[0] == -1)
  126.         window->tabletPos[0] = normalizeTabletPos(0, v->valuators[0]);
  127.       if (window->tabletPos[1] == -1)
  128.         window->tabletPos[1] = normalizeTabletPos(1, v->valuators[1]);
  129.     }
  130.     any = (XInputClass *) ((char *) any + any->length);
  131.   }
  132. end:
  133.   XFreeDeviceState(state);
  134. }
  136. static void
  137. tabletPosChange(GLUTwindow * window, int first, int count, int *data)
  138. {
  139.   int i, value, genEvent = 0;
  141.   for (i = first; i < first + count; i++) {
  142.     switch (i) {
  143.     case 0:            /* X axis */
  144.     case 1:            /* Y axis */
  145.       value = normalizeTabletPos(i, data[i - first]);
  146.       if (value != window->tabletPos[i]) {
  147.         window->tabletPos[i] = value;
  148.         genEvent = 1;
  149.       }
  150.       break;
  151.     }
  152.   }
  153.   if (window->tabletPos[0] == -1 || window->tabletPos[1] == -1)
  154.     queryTabletPos(window);
  155.   if (genEvent)
  156.     window->tabletMotion(window->tabletPos[0], window->tabletPos[1]);
  157. }
  158. #endif /* !_WIN32 */
  160. int
  161. __glutProcessDeviceEvents(XEvent * event)
  162. {
  163. #if !defined(_WIN32)
  164.   GLUTwindow *window;
  166.   /* XXX Ugly code fan out. */
  168.   /* Can't use switch/case since X Input event types are
  169.      dynamic. */
  171.   if (__glutDeviceMotionNotify && event->type == __glutDeviceMotionNotify) {
  172.     XDeviceMotionEvent *devmot = (XDeviceMotionEvent *) event;
  174.     window = __glutGetWindow(devmot->window);
  175.     if (window) {
  176.       if (__glutTablet
  177.         && devmot->deviceid == __glutTablet->device_id
  178.         && window->tabletMotion) {
  179.         tabletPosChange(window, devmot->first_axis, devmot->axes_count,
  180.           devmot->axis_data);
  181.       } else if (__glutDials
  182.           && devmot->deviceid == __glutDials->device_id
  183.         && window->dials) {
  184.         int i, first = devmot->first_axis, count = devmot->axes_count;
  186.         for (i = first; i < first + count; i++)
  187.           window->dials(i + 1,
  188.             normalizeDialAngle(i, devmot->axis_data[i - first]));
  189.       } else if (__glutSpaceball
  190.         && devmot->deviceid == __glutSpaceball->device_id) {
  191.         /* XXX Assume that space ball motion events come in as
  192.            all the first 6 axes.  Assume first 3 axes are XYZ
  193.            translations; second 3 axes are XYZ rotations. */
  194.         if (devmot->first_axis == 0 && devmot->axes_count == 6) {
  195.           if (window->spaceMotion)
  196.             window->spaceMotion(
  197.               normalizeSpaceballDelta(0, devmot->axis_data[0]),
  198.               normalizeSpaceballDelta(1, devmot->axis_data[1]),
  199.               normalizeSpaceballDelta(2, devmot->axis_data[2]));
  200.           if (window->spaceRotate)
  201.             window->spaceRotate(
  202.               normalizeSpaceballAngle(3, devmot->axis_data[3]),
  203.               normalizeSpaceballAngle(4, devmot->axis_data[4]),
  204.               normalizeSpaceballAngle(5, devmot->axis_data[5]));
  205.         }
  206.       }
  207.       return 1;
  208.     }
  209.   } else if (__glutDeviceButtonPress
  210.     && event->type == __glutDeviceButtonPress) {
  211.     XDeviceButtonEvent *devbtn = (XDeviceButtonEvent *) event;
  213.     window = __glutGetWindow(devbtn->window);
  214.     if (window) {
  215.       if (__glutTablet
  216.         && devbtn->deviceid == __glutTablet->device_id
  217.         && window->tabletButton
  218.         && devbtn->first_axis == 0
  219.         && devbtn->axes_count == 2) {
  220.         tabletPosChange(window, devbtn->first_axis, devbtn->axes_count,
  221.           devbtn->axis_data);
  222.         window->tabletButton(devbtn->button, GLUT_DOWN,
  223.           window->tabletPos[0], window->tabletPos[1]);
  224.       } else if (__glutDials
  225.           && devbtn->deviceid == __glutDials->device_id
  226.         && window->buttonBox) {
  227.         window->buttonBox(devbtn->button, GLUT_DOWN);
  228.       } else if (__glutSpaceball
  229.           && devbtn->deviceid == __glutSpaceball->device_id
  230.         && window->spaceButton) {
  231.         window->spaceButton(devbtn->button, GLUT_DOWN);
  232.       }
  233.       return 1;
  234.     }
  235.   } else if (__glutDeviceButtonRelease
  236.     && event->type == __glutDeviceButtonRelease) {
  237.     XDeviceButtonEvent *devbtn = (XDeviceButtonEvent *) event;
  239.     window = __glutGetWindow(devbtn->window);
  240.     if (window) {
  241.       if (__glutTablet
  242.         && devbtn->deviceid == __glutTablet->device_id
  243.         && window->tabletButton
  244.         && devbtn->first_axis == 0
  245.         && devbtn->axes_count == 2) {
  246.         tabletPosChange(window, devbtn->first_axis, devbtn->axes_count,
  247.           devbtn->axis_data);
  248.         window->tabletButton(devbtn->button, GLUT_UP,
  249.           window->tabletPos[0], window->tabletPos[1]);
  250.       } else if (__glutDials
  251.           && devbtn->deviceid == __glutDials->device_id
  252.         && window->buttonBox) {
  253.         window->buttonBox(devbtn->button, GLUT_UP);
  254.       } else if (__glutSpaceball
  255.           && devbtn->deviceid == __glutSpaceball->device_id
  256.         && window->spaceButton) {
  257.         window->spaceButton(devbtn->button, GLUT_UP);
  258.       }
  259.       return 1;
  260.     }
  261.   }
  262. #else
  263.   {
  264.     JOYINFOEX info; 
  265.     JOYCAPS joyCaps; 
  267.     if (joyGetPosEx(JOYSTICKID1,&info) != JOYERR_NOERROR) { 
  268.       __glutHasJoystick = 1; 
  269.       joyGetDevCaps(JOYSTICKID1, &joyCaps, sizeof(joyCaps)); 
  270.       __glutNumJoystickButtons = joyCaps.wNumButtons; 
  271.       __glutNumJoystickAxes = joyCaps.wNumAxes; 
  272.     } else { 
  273.       __glutHasJoystick = 0; 
  274.       __glutNumJoystickButtons = 0; 
  275.       __glutNumJoystickAxes = 0; 
  276.     } 
  277. #if 0
  278.     JOYINFOEX info;
  279.     int njoyId = 0;
  280.     int nConnected = 0;
  281.     MMRESULT result;
  283.     /* Loop through all possible joystick IDs until we get the error
  284.        JOYERR_PARMS. Count the number of times we get JOYERR_NOERROR
  285.        indicating an installed joystick driver with a joystick currently
  286.        attached to the port. */
  287.     while ((result = joyGetPosEx(njoyId++,&info)) != JOYERR_PARMS) {
  288.       if (result == JOYERR_NOERROR) {
  289.         ++nConnected;  /* The count of connected joysticks. */
  290.       }
  291.     }
  292. #endif
  293.   }
  294. #endif /* !_WIN32 */
  295.   return 0;
  296. }
  298. static GLUTeventParser eventParser =
  299. {__glutProcessDeviceEvents, NULL};
  301. static void
  302. addDeviceEventParser(void)
  303. {
  304.   static Bool been_here = False;
  306.   if (been_here)
  307.     return;
  308.   been_here = True;
  309.   __glutRegisterEventParser(&eventParser);
  310. }
  312. static int
  313. probeDevices(void)
  314. {
  315.   static Bool been_here = False;
  316.   static int support;
  317. #if !defined(_WIN32)
  318.   XExtensionVersion *version;
  319.   XDeviceInfoPtr device_info, device;
  320.   XAnyClassPtr any;
  321.   XButtonInfoPtr b;
  322.   XValuatorInfoPtr v;
  323.   XAxisInfoPtr a;
  324.   int num_dev, btns, dials;
  325.   int i, j, k;
  326. #endif /* !_WIN32 */
  328.   if (been_here) {
  329.     return support;
  330.   }
  331.   been_here = True;
  333. #if !defined(_WIN32)
  334.   version = XGetExtensionVersion(__glutDisplay, "XInputExtension");
  335.   /* Ugh.  XInput extension API forces annoying cast of a pointer
  336.      to a long so it can be compared with the NoSuchExtension
  337.      value (#defined to 1). */
  338.   if (version == NULL || ((long) version) == NoSuchExtension) {
  339.     support = 0;
  340.     return support;
  341.   }
  342.   XFree(version);
  343.   device_info = XListInputDevices(__glutDisplay, &num_dev);
  344.   if (device_info) {
  345.     for (i = 0; i < num_dev; i++) {
  346.       /* XXX These are SGI names for these devices;
  347.          unfortunately, no good standard exists for standard
  348.          types of X input extension devices. */
  350.       device = &device_info[i];
  351.       any = (XAnyClassPtr) device->inputclassinfo;
  353.       if (!__glutSpaceball && !strcmp(device->name, "spaceball")) {
  354.         v = NULL;
  355.         b = NULL;
  356.         for (j = 0; j < device->num_classes; j++) {
  357. #if defined(__cplusplus) || defined(c_plusplus)
  358.           switch (any->c_class) {
  359. #else
  360.           switch (any->class) {
  361. #endif
  362.           case ButtonClass:
  363.             b = (XButtonInfoPtr) any;
  364.             btns = b->num_buttons;
  365.             break;
  366.           case ValuatorClass:
  367.             v = (XValuatorInfoPtr) any;
  368.             /* Sanity check: at least 6 valuators? */
  369.             if (v->num_axes < NUM_SPACEBALL_AXIS)
  370.               goto skip_device;
  371.             a = (XAxisInfoPtr) ((char *) v + sizeof(XValuatorInfo));
  372.             for (k = 0; k < NUM_SPACEBALL_AXIS; k++, a++) {
  373.               __glutSpaceballRange[k].min = a->min_value;
  374.               __glutSpaceballRange[k].range = a->max_value - a->min_value;
  375.             }
  376.             break;
  377.           }
  378.           any = (XAnyClassPtr) ((char *) any + any->length);
  379.         }
  380.         if (v) {
  381.           __glutSpaceball = XOpenDevice(__glutDisplay, device->id);
  382.           if (__glutSpaceball) {
  383.             __glutNumSpaceballButtons = btns;
  384.             addDeviceEventParser();
  385.           }
  386.         }
  387.       } else if (!__glutDials && !strcmp(device->name, "dial+buttons")) {
  388.         v = NULL;
  389.         b = NULL;
  390.         for (j = 0; j < device->num_classes; j++) {
  391. #if defined(__cplusplus) || defined(c_plusplus)
  392.           switch (any->c_class) {
  393. #else
  394.           switch (any->class) {
  395. #endif
  396.           case ButtonClass:
  397.             b = (XButtonInfoPtr) any;
  398.             btns = b->num_buttons;
  399.             break;
  400.           case ValuatorClass:
  401.             v = (XValuatorInfoPtr) any;
  402.             /* Sanity check: at least 8 valuators? */
  403.             if (v->num_axes < NUM_DIALS_AXIS)
  404.               goto skip_device;
  405.             dials = v->num_axes;
  406.             __glutDialsResolution = (int *) malloc(sizeof(int) * dials);
  407.             a = (XAxisInfoPtr) ((char *) v + sizeof(XValuatorInfo));
  408.             for (k = 0; k < dials; k++, a++) {
  409.               __glutDialsResolution[k] = a->resolution;
  410.             }
  411.             break;
  412.           }
  413.           any = (XAnyClassPtr) ((char *) any + any->length);
  414.         }
  415.         if (v) {
  416.           __glutDials = XOpenDevice(__glutDisplay, device->id);
  417.           if (__glutDials) {
  418.             __glutNumButtonBoxButtons = btns;
  419.             __glutNumDials = dials;
  420.             addDeviceEventParser();
  421.           }
  422.         }
  423.       } else if (!__glutTablet && !strcmp(device->name, "tablet")) {
  424.         v = NULL;
  425.         b = NULL;
  426.         for (j = 0; j < device->num_classes; j++) {
  427. #if defined(__cplusplus) || defined(c_plusplus)
  428.           switch (any->c_class) {
  429. #else
  430.           switch (any->class) {
  431. #endif
  432.           case ButtonClass:
  433.             b = (XButtonInfoPtr) any;
  434.             btns = b->num_buttons;
  435.             break;
  436.           case ValuatorClass:
  437.             v = (XValuatorInfoPtr) any;
  438.             /* Sanity check: exactly 2 valuators? */
  439.             if (v->num_axes != NUM_TABLET_AXIS)
  440.               goto skip_device;
  441.             a = (XAxisInfoPtr) ((char *) v + sizeof(XValuatorInfo));
  442.             for (k = 0; k < NUM_TABLET_AXIS; k++, a++) {
  443.               __glutTabletRange[k].min = a->min_value;
  444.               __glutTabletRange[k].range = a->max_value - a->min_value;
  445.             }
  446.             break;
  447.           }
  448.           any = (XAnyClassPtr) ((char *) any + any->length);
  449.         }
  450.         if (v) {
  451.           __glutTablet = XOpenDevice(__glutDisplay, device->id);
  452.           if (__glutTablet) {
  453.             __glutNumTabletButtons = btns;
  454.             addDeviceEventParser();
  455.           }
  456.         }
  457.       } else if (!strcmp(device->name, "mouse")) {
  458.         for (j = 0; j < device->num_classes; j++) {
  459. #if defined(__cplusplus) || defined(c_plusplus)
  460.           if (any->c_class == ButtonClass) {
  461. #else
  462.           if (any->class == ButtonClass) {
  463. #endif
  464.             b = (XButtonInfoPtr) any;
  465.             __glutNumMouseButtons = b->num_buttons;
  466.           }
  467.           any = (XAnyClassPtr) ((char *) any + any->length);
  468.         }
  469.       }
  470.     skip_device:;
  471.     }
  472.     XFreeDeviceList(device_info);
  473.   }
  474. #else /* _WIN32 */
  475.   __glutNumMouseButtons = GetSystemMetrics(SM_CMOUSEBUTTONS);
  476. #endif /* !_WIN32 */
  477.   /* X Input extension might be supported, but only if there is
  478.      a tablet, dials, or spaceball do we claim devices are
  479.      supported. */
  480.   support = __glutTablet || __glutDials || __glutSpaceball;
  481.   return support;
  482. }
  484. void
  485. __glutUpdateInputDeviceMask(GLUTwindow * window)
  486. {
  487. #if !defined(_WIN32)
  488.   /* 5 (dial and buttons) + 5 (tablet locator and buttons) + 5
  489.      (Spaceball buttons and axis) = 15 */
  490.   XEventClass eventList[15];
  491.   int rc, numEvents;
  493.   rc = probeDevices();
  494.   if (rc) {
  495.     numEvents = 0;
  496.     if (__glutTablet) {
  497.       if (window->tabletMotion) {
  498.         DeviceMotionNotify(__glutTablet, __glutDeviceMotionNotify,
  499.           eventList[numEvents]);
  500.         numEvents++;
  501.       }
  502.       if (window->tabletButton) {
  503.         DeviceButtonPress(__glutTablet, __glutDeviceButtonPress,
  504.           eventList[numEvents]);
  505.         numEvents++;
  506.         DeviceButtonPressGrab(__glutTablet, __glutDeviceButtonPressGrab,
  507.           eventList[numEvents]);
  508.         numEvents++;
  509.         DeviceButtonRelease(__glutTablet, __glutDeviceButtonRelease,
  510.           eventList[numEvents]);
  511.         numEvents++;
  512.       }
  513.       if (window->tabletMotion || window->tabletButton) {
  514.         DeviceStateNotify(__glutTablet, __glutDeviceStateNotify,
  515.           eventList[numEvents]);
  516.         numEvents++;
  517.       }
  518.     }
  519.     if (__glutDials) {
  520.       if (window->dials) {
  521.         DeviceMotionNotify(__glutDials, __glutDeviceMotionNotify,
  522.           eventList[numEvents]);
  523.         numEvents++;
  524.       }
  525.       if (window->buttonBox) {
  526.         DeviceButtonPress(__glutDials, __glutDeviceButtonPress,
  527.           eventList[numEvents]);
  528.         numEvents++;
  529.         DeviceButtonPressGrab(__glutDials, __glutDeviceButtonPressGrab,
  530.           eventList[numEvents]);
  531.         numEvents++;
  532.         DeviceButtonRelease(__glutDials, __glutDeviceButtonRelease,
  533.           eventList[numEvents]);
  534.         numEvents++;
  535.       }
  536.       if (window->dials || window->buttonBox) {
  537.         DeviceStateNotify(__glutDials, __glutDeviceStateNotify,
  538.           eventList[numEvents]);
  539.         numEvents++;
  540.       }
  541.     }
  542.     if (__glutSpaceball) {
  543.       if (window->spaceMotion || window->spaceRotate) {
  544.         DeviceMotionNotify(__glutSpaceball, __glutDeviceMotionNotify,
  545.           eventList[numEvents]);
  546.         numEvents++;
  547.       }
  548.       if (window->spaceButton) {
  549.         DeviceButtonPress(__glutSpaceball, __glutDeviceButtonPress,
  550.           eventList[numEvents]);
  551.         numEvents++;
  552.         DeviceButtonPressGrab(__glutSpaceball, __glutDeviceButtonPressGrab,
  553.           eventList[numEvents]);
  554.         numEvents++;
  555.         DeviceButtonRelease(__glutSpaceball, __glutDeviceButtonRelease,
  556.           eventList[numEvents]);
  557.         numEvents++;
  558.       }
  559.       if (window->spaceMotion || window->spaceRotate || window->spaceButton) {
  560.         DeviceStateNotify(__glutSpaceball, __glutDeviceStateNotify,
  561.           eventList[numEvents]);
  562.         numEvents++;
  563.       }
  564.     }
  565. #if 0
  566.     if (window->children) {
  567.       GLUTwindow *child = window->children;
  569.       do {
  570.         XChangeDeviceDontPropagateList(__glutDisplay, child->win,
  571.           numEvents, eventList, AddToList);
  572.         child = child->siblings;
  573.       } while (child);
  574.     }
  575. #endif
  576.     XSelectExtensionEvent(__glutDisplay, window->win,
  577.       eventList, numEvents);
  578.     if (window->overlay) {
  579.       XSelectExtensionEvent(__glutDisplay, window->overlay->win,
  580.         eventList, numEvents);
  581.     }
  582.   } else {
  583.     /* X Input extension not supported; no chance for exotic
  584.        input devices. */
  585.   }
  586. #endif /* !_WIN32 */
  587. }
  589. /* CENTRY */
  590. int APIENTRY
  591. glutDeviceGet(GLenum param)
  592. {
  593.   probeDevices();
  594.   switch (param) {
  595.   case GLUT_HAS_KEYBOARD:
  596.   case GLUT_HAS_MOUSE:
  597.     /* Assume window system always has mouse and keyboard. */
  598.     return 1;
  599.   case GLUT_HAS_SPACEBALL:
  600.     return __glutSpaceball != NULL;
  601.   case GLUT_HAS_DIAL_AND_BUTTON_BOX:
  602.     return __glutDials != NULL;
  603.   case GLUT_HAS_TABLET:
  604.     return __glutTablet != NULL;
  605.   case GLUT_NUM_MOUSE_BUTTONS:
  606.     return __glutNumMouseButtons;
  607.   case GLUT_NUM_SPACEBALL_BUTTONS:
  608.     return __glutNumSpaceballButtons;
  609.   case GLUT_NUM_BUTTON_BOX_BUTTONS:
  610.     return __glutNumButtonBoxButtons;
  611.   case GLUT_NUM_DIALS:
  612.     return __glutNumDials;
  613.   case GLUT_NUM_TABLET_BUTTONS:
  614.     return __glutNumTabletButtons;
  615.   case GLUT_DEVICE_IGNORE_KEY_REPEAT:
  616.     return __glutCurrentWindow->ignoreKeyRepeat;
  617. #ifndef _WIN32
  618.   case GLUT_DEVICE_KEY_REPEAT:
  619.     {
  620.       XKeyboardState state;
  622.       XGetKeyboardControl(__glutDisplay, &state);
  623.       return state.global_auto_repeat;
  624.     }
  625.   case GLUT_JOYSTICK_POLL_RATE:
  626.     return 0;
  627. #else
  628.   case GLUT_DEVICE_KEY_REPEAT:
  629.     /* Win32 cannot globally disable key repeat. */
  630.     return GLUT_KEY_REPEAT_ON;
  631.   case GLUT_JOYSTICK_POLL_RATE:
  632.     return __glutCurrentWindow->joyPollInterval;
  633. #endif
  634.   case GLUT_HAS_JOYSTICK:
  635.     return __glutHasJoystick;
  636.   case GLUT_JOYSTICK_BUTTONS:
  637.     return __glutNumJoystickButtons;
  638.   case GLUT_JOYSTICK_AXES:
  639.     return __glutNumJoystickAxes;
  640.   default:
  641.     __glutWarning("invalid glutDeviceGet parameter: %d", param);
  642.     return -1;
  643.   }
  644. }
  645. /* ENDCENTRY */