home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / X / mit / extensions / test / xinput / XPErrors.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-02-19  |  54.9 KB  |  2,002 lines
  1. /* $XConsortium: XPErrors.c,v 1.2 91/02/20 09:17:37 rws Exp $ */
  2. /************************************************************************
  3.  *
  4.  * XProtoErrors.c - attempt to force all of the protocol errors defined
  5.  *     by the input extension.
  6.  *
  7.  */
  8.  
  9. #include <X11/X.h>
  10. #include <X11/Xlib.h>
  11. #include <X11/extensions/XInput.h>
  12. #include <X11/Xutil.h>
  13. #include "stdio.h"
  14.  
  15. #define PRINT                    0
  16. #define NOPRINT                    1
  17.  
  18. #define XGetExtensionVersion_code        1
  19. #define XListInputDevices_code            2
  20. #define XOpenDevice_code            3
  21. #define XCloseDevice_code            4
  22. #define XSetDeviceMode_code            5
  23. #define XSelectExtensionEvent_code          6
  24. #define XGetSelectedExtensionEvents_code    7
  25. #define XChangeDeviceDontPropagateList_code     8
  26. #define XGetDeviceDontPropagateList_code     9
  27. #define XGetDeviceMotionEvents_code         10
  28. #define XChangeKeyboardDevice_code        11
  29. #define XChangePointerDevice_code        12
  30. #define XGrabDevice_code             13
  31. #define XUngrabDevice_code              14
  32. #define XGrabDeviceKey_code            15
  33. #define XUngrabDeviceKey_code            16
  34. #define XGrabDeviceButton_code            17
  35. #define XUngrabDeviceButton_code        18
  36. #define XAllowDeviceEvents_code            19
  37. #define XGetDeviceFocus_code            20
  38. #define XSetDeviceFocus_code            21
  39. #define XGetFeedbackControl_code        22
  40. #define XChangeFeedbackControl_code        23
  41. #define XGetDeviceKeyMapping_code        24
  42. #define XChangeDeviceKeyMapping_code        25
  43. #define XGetDeviceModifierMapping_code        26
  44. #define XSetDeviceModifierMapping_code        27
  45. #define XGetDeviceButtonMapping_code        28
  46. #define XSetDeviceButtonMapping_code        29
  47. #define XQueryDeviceState_code             30
  48. #define XSendExtensionEvent_code         31
  49.  
  50. char *ext_errors[] = {"BadDevice","BadEvent","BadMode","DeviceBusy","BadClass"};
  51.  
  52. char *std_errors[] = {"Success","BadRequest","BadValue","BadWindow","BadPixmap",
  53.         "BadAtom","BadCursor","BadFont","BadMatch","BadDrawable",
  54.         "BadAccess","BadAlloc","BadColor","BadGC","BadIDChoice",
  55.         "BadName","BadLength","BadImplementation"};
  56.  
  57. char *extfuncs[] = {"undefined", "GetExtensionVersion","ListInputDevices",
  58. "OpenDevice", "CloseDevice","SetDeviceMode","SelectExtensionEvent",
  59. "GetSelectedExtensionEvents", "ChangeDeviceDontPropagateList",
  60. "GetDeviceDontPropagateList","GetDeviceMotionEvents", "ChangeKeyboardDevice",
  61. "ChangePointerDevice","GrabDevice","UngrabDevice", "GrabDeviceKey",
  62. "UngrabDeviceKey","GrabDeviceButton","UngrabDeviceButton", "AllowDeviceEvents",
  63. "GetDeviceFocus","SetDeviceFocus", "GetFeedbackControl",
  64. "ChangeFeedbackControl","GetDeviceKeyMapping","ChangeDeviceKeyMapping",
  65. "GetDeviceModifierMapping","SetDeviceModifierMapping","GetDeviceButtonMapping",
  66. "SetDeviceButtonMapping","QueryDeviceState","SendExtensionEvent"};
  67.  
  68. int    Dflag = 0;
  69.  
  70. int    gstatus;
  71. int    expect = Success;
  72. int    error_code;
  73. int    major_code;
  74. int    first_err;
  75.  
  76. int    devicekeypress;
  77. int    devicekeyrelease;
  78. int    devicebuttonpress;
  79. int    devicebuttonrelease;
  80. int    devicemotionnotify;
  81. int    devicefocusin;
  82. int    devicefocusout;
  83. int    proximityin;
  84. int    proximityout;
  85. int    devicemappingnotify;
  86. int    devicestatenotify;
  87. int    changedevicenotify;
  88.  
  89. struct    classes
  90.     {
  91.     int valid;
  92.     XEventClass class[15];
  93.     } class[256];
  94.  
  95. XDeviceInfoPtr    savlist[256];
  96. XDeviceInfoPtr    xkeyboard;
  97. XDeviceInfoPtr    xpointer;
  98. XDevice        *keydevice;
  99. XDevice        *sdev[256];
  100. XEventClass    bogusclass[] = {(unsigned long)~0L,(unsigned long)~0L,(unsigned long)~0L};
  101.  
  102. int    baddevice;
  103. int    badclass;
  104. int    badmode;
  105. Window    root;
  106.  
  107. main(argc,argv)
  108.     int argc;
  109.     char *argv[];
  110.     {
  111.     int         i,j;
  112.     int         ndevices;
  113.     char        *name;
  114.     Display        *display;
  115.     Window        my, my2, my3;
  116.     XDeviceInfoPtr     list_input_devices ();
  117.     XDeviceInfoPtr    list, slist;
  118.     XInputClassInfo    *ip;
  119.     XEvent        event;
  120.  
  121.     printf ("This test attempts to force protocol errors defined by the input extension.\n");
  122.     printf ("A status message is printed when the test finishes.\n");
  123.     name = argv[0];
  124.     display = XOpenDisplay ("");
  125.     if (display == NULL)
  126.     {
  127.     printf ("No connection to server - aborting test.\n");
  128.     exit(1);
  129.     }
  130.     root = RootWindow (display,0);
  131.     init_error_handler (display);
  132.     BadDevice(display,baddevice);
  133.     BadClass(display,badclass);
  134.     BadMode(display,badmode);
  135.     query_extension_version (display);
  136.     create_two_windows (display, root, &my, &my2, &my3);
  137.     slist = list_input_devices (display, &ndevices);
  138.     list = slist;
  139.     open_all_devices (display, list, ndevices);
  140.  
  141.     for (i=0; i<ndevices; i++, list++)
  142.     if (list->use != IsXKeyboard && list->use != IsXPointer)
  143.         {
  144.         select_all_input (display, root, list->name, sdev[i]);
  145.         select_all_input (display, my2, list->name, sdev[i]);
  146.         for (ip= sdev[i]->classes, j=0; j<sdev[i]->num_classes; j++, ip++)
  147.             {
  148.         if (ip->input_class == KeyClass)
  149.             {
  150.             create_button_errors (display, sdev[i], savlist[i]);
  151.             create_valuator_errors (display, sdev[i], savlist[i]);
  152.             do_key_mapping (display, list->name, sdev[i], savlist[i]);
  153.             do_modifier_mapping (display, list->name, sdev[i]);
  154.                 grab_device_key (display, list->name, sdev[i], my, my2);
  155.             change_keyboard_device (display, list->name, sdev[i], 
  156.             savlist[i]);
  157.             }
  158.         else if (ip->input_class == ButtonClass)
  159.             {
  160.             create_key_errors (display, sdev[i], savlist[i]);
  161.             do_button_mapping (display, sdev[i], savlist[i]);
  162.                 grab_device_button (display, list->name, sdev[i], my, my2);
  163.             }
  164.         else if (ip->input_class == ValuatorClass)
  165.             {
  166.             get_motion_history (display, list->name, sdev[i]);
  167.             change_pointer_device (display, list->name, sdev[i]);
  168.             set_device_mode (display, name, sdev[i]);
  169.             }
  170.         else if (ip->input_class == FeedbackClass)
  171.             {
  172.             do_feedback_control (display, name, sdev[i]);
  173.             }
  174.         }
  175.         do_propagate_list (display, my2, list->name, sdev[i]);
  176.         focus_input_device (display, list->name, sdev[i], my3);
  177.         grab_input_device (display, list->name, sdev[i], my, my2, my3);
  178.         allow_device_event (display, list->name, sdev[i]);
  179.         query_device_state (display, list->name, sdev[i]);
  180.         send_extension_event (display, list->name, sdev[i],my2);
  181.         }
  182.  
  183.     for (i=0,list=slist; i<ndevices; i++, list++)
  184.     if (list->use != IsXKeyboard && list->use != IsXPointer)
  185.     {
  186.     ungrab_input_device (display, list->name, sdev[i]);
  187.     for (ip= sdev[i]->classes, j=0; j<sdev[i]->num_classes; 
  188.         j++, ip++)
  189.         if (ip->input_class == KeyClass)
  190.         ungrab_device_key (display, list->name, sdev[i], my, my2);
  191.         else if (ip->input_class == ButtonClass)
  192.         ungrab_device_button (display, list->name, sdev[i], my, my2);
  193.     }
  194.     close_input_devices (display, sdev, ndevices);
  195.     if (gstatus == 0)
  196.     printf ("Test XProtoErrrors succeeeded.\n");
  197.     else
  198.     printf ("Test XProtoErrrors failed.\n");
  199.     }
  200.  
  201. /******************************************************************
  202.  *
  203.  * This function closes all open input devices.
  204.  * X Errors:
  205.  *    1). BadDevice
  206.  *
  207.  */
  208.  
  209. close_input_devices (display, devices, count)
  210.     Display    *display;
  211.     XDevice    *devices[];
  212.     int        count;
  213.     {
  214.     int        i;
  215.     int        saveid;
  216.  
  217.     expect = baddevice;
  218.     error_code = XCloseDevice_code;
  219.  
  220.     for (i=0; i<count; i++)
  221.     {
  222.     if (!devices[i])
  223.         continue;
  224.     devices[i]->device_id = -1;
  225.     XCloseDevice (display, devices[i]);
  226.     XSync (display, 0);
  227.     }
  228.     }
  229.  
  230. /******************************************************************
  231.  *
  232.  * This function creates two test windows.
  233.  *
  234.  */
  235.  
  236. create_two_windows (display, root, my, my2, my3)
  237.     Display *display;
  238.     Window root, *my, *my2, *my3;
  239.     {   
  240.     XSetWindowAttributes attributes;
  241.     unsigned long     attribute_mask;
  242.     int         status;
  243.     XSizeHints         hints;
  244.     Screen        *screen = XDefaultScreenOfDisplay (display);
  245.  
  246.     attribute_mask = CWBackPixmap; 
  247.     attribute_mask = CWBackPixel; 
  248.     attribute_mask |= CWEventMask; 
  249.     attribute_mask |= CWDontPropagate; 
  250.     attributes.do_not_propagate_mask = 0;
  251.     attributes.background_pixmap = None;
  252.     attributes.background_pixel = WhitePixel(display, 0);
  253.     attributes.event_mask = ExposureMask;
  254.     
  255.     *my = XCreateWindow (display, root, 100,100, 400,200,1,
  256.     DefaultDepthOfScreen (screen),
  257.     InputOutput, CopyFromParent, attribute_mask, &attributes);
  258.  
  259.     if (*my == 0) {
  260.     fprintf (stderr, "can't create window!\n");
  261.     exit (1);
  262.     }
  263.     status = XGetNormalHints (display, *my, &hints);
  264.     hints.x = 100;
  265.     hints.y = 100;
  266.     hints.width = 400;
  267.     hints.height = 200;
  268.     hints.min_width = 400;
  269.     hints.min_height = 200;
  270.     hints.flags |= (PPosition | PSize | PMinSize);
  271.     XSetNormalHints (display, *my, &hints);
  272.     XMapWindow (display, *my);
  273.     XFlush(display);
  274.  
  275.     attribute_mask = CWBackPixmap;
  276.     attribute_mask = CWBackPixel; 
  277.     attribute_mask |= CWEventMask; 
  278.     attributes.background_pixmap = None;
  279.     attributes.background_pixel = BlackPixel(display, 0);
  280.     attributes.event_mask = ExposureMask;
  281.  
  282.     *my2 = XCreateWindow (display, *my, 50,50, 300,100,1,
  283.     DefaultDepthOfScreen (screen),
  284.     InputOutput, CopyFromParent, attribute_mask, &attributes);
  285.     if (my2 == 0) {
  286.     fprintf (stderr, "can't create window!\n");
  287.     exit (1);
  288.     }
  289.     status = XGetNormalHints (display, *my2, &hints);
  290.     hints.x = 50;
  291.     hints.y = 50;
  292.     hints.width = 300;
  293.     hints.height = 100;
  294.     hints.min_width = 300;
  295.     hints.min_height = 100;
  296.     hints.flags |= (PPosition | PSize | PMinSize);
  297.     XSetNormalHints (display, *my2, &hints);
  298.     XMapWindow (display, *my2);
  299.  
  300.     attribute_mask = CWBackPixmap;
  301.     attribute_mask = CWBackPixel; 
  302.     attribute_mask |= CWEventMask; 
  303.     attributes.background_pixmap = None;
  304.     attributes.background_pixel = BlackPixel(display, 0);
  305.     attributes.event_mask = ExposureMask;
  306.  
  307.     *my3 = XCreateWindow (display, *my2, 50,50, 200,50,1,
  308.     DefaultDepthOfScreen (screen),
  309.     InputOutput, CopyFromParent, attribute_mask, &attributes);
  310.     if (my3 == 0) {
  311.     fprintf (stderr, "can't create window!\n");
  312.     exit (1);
  313.     }
  314.     status = XGetNormalHints (display, *my3, &hints);
  315.     hints.flags |= (USPosition | USSize | PPosition | PSize);
  316.     XSetNormalHints (display, *my3, &hints);
  317.     XFlush(display);
  318.  
  319.     }
  320.  
  321. /******************************************************************
  322.  *
  323.  * This function lists all available input devices.
  324.  *
  325.  */
  326.  
  327. XDeviceInfoPtr
  328. list_input_devices (display, ndevices)
  329.     Display *display;
  330.     int        *ndevices;
  331.     {
  332.     int            i,j,k;
  333.     XDeviceInfoPtr    list, slist;
  334.     XAnyClassPtr    any;
  335.     XKeyInfoPtr        K;
  336.     XButtonInfoPtr    b;
  337.     XValuatorInfoPtr    v;
  338.     XAxisInfoPtr    a;
  339.  
  340.     list = (XDeviceInfoPtr) XListInputDevices (display, ndevices);
  341.     slist = list;
  342.     if (Dflag)
  343.     printf ("The number of available input devices is %d\n",*ndevices);
  344.     for (i=0; i<*ndevices; i++, list++)
  345.     {
  346.     savlist[i] = list;
  347.     if (Dflag)
  348.         {
  349.         printf ("\nid is %d\n",list->id);
  350.         printf ("type is %d\n",list->type);
  351.         printf ("name is %s\n",list->name);
  352.         printf ("use is %s\n",list->use);
  353.         printf ("num_classes is %d\n\n",list->num_classes);
  354.         }
  355.     if (list->num_classes > 0)
  356.         {
  357.         any = (XAnyClassPtr) (list->inputclassinfo);
  358.         for (j=0; j<list->num_classes; j++)
  359.         {
  360.         if (Dflag)
  361.             {
  362.             printf ("input class is %d\n", any->class);
  363.             printf ("length is %d\n", any->length);
  364.             }
  365.         switch (any->class)
  366.             {
  367.             case KeyClass:
  368.             K = (XKeyInfoPtr) any;
  369.             if (Dflag)
  370.                 {
  371.                 printf ("num_keys is %d\n",K->num_keys);
  372.                 printf ("min_keycode is %d\n",K->min_keycode);
  373.                 printf ("max_keycode is %d\n\n",K->max_keycode);
  374.                 }
  375.             break;
  376.             case ButtonClass:
  377.             b = (XButtonInfoPtr) any;
  378.             if (Dflag)
  379.                 printf ("num_buttons is %d\n\n",b->num_buttons);
  380.             break;
  381.             case ValuatorClass:
  382.             v = (XValuatorInfoPtr) any;
  383.             a = (XAxisInfoPtr) ((char *) v + 
  384.                 sizeof (XValuatorInfo));
  385.             if (Dflag)
  386.                 printf ("num_axes is %d\n\n",v->num_axes);
  387.             for (k=0; k<v->num_axes; k++,a++)
  388.                 {
  389.                 if (Dflag)
  390.                 {
  391.                 printf ("min_value is %d\n",a->min_value);
  392.                 printf ("max_value is %d\n",a->max_value);
  393.                 printf ("resolution is %d\n\n",a->resolution);
  394.                 }
  395.                 }
  396.             break;
  397.             default:
  398.             printf ("unknown class\n");
  399.             }
  400.         any = (XAnyClassPtr) ((char *) any + any->length);
  401.         }
  402.         }
  403.     }
  404.     return (slist);
  405.     }
  406.  
  407.  
  408. /******************************************************************
  409.  *
  410.  * This function finds input class information of a given class.
  411.  *
  412.  */
  413.  
  414. XAnyClassPtr
  415. FindInputClass (list, class)
  416.     XDeviceInfoPtr    list;
  417.     int            class;
  418.     {
  419.     int            i;
  420.     XAnyClassPtr       any;
  421.  
  422.     any = (XAnyClassPtr) (list->inputclassinfo);
  423.     for (i=0; i<list->num_classes; i++)
  424.     {
  425.     if (any->class == class)
  426.         return (any);
  427.     any = (XAnyClassPtr) ((char *) any + any->length);
  428.     }
  429.     }
  430.  
  431. /******************************************************************
  432.  *
  433.  * This function opens all extension input devices.
  434.  * X Errors:
  435.  *    1). BadDevice
  436.  *
  437.  */
  438.  
  439. open_all_devices (display, list, ndevices)
  440.     Display        *display;
  441.     XDeviceInfoPtr     list;
  442.     int            ndevices;
  443.     {
  444.     int            valid;
  445.     int            i,j;
  446.     XDevice        *dev;
  447.     XDevice        *XOpenDevice();
  448.     XInputClassInfo    *ip;
  449.  
  450.     expect = baddevice;
  451.     error_code = XOpenDevice_code;
  452.  
  453.     XOpenDevice (display, -1);
  454.     XOpenDevice (display, xpointer->id);
  455.     XOpenDevice (display, xkeyboard->id);
  456.     XSync (display, 0);
  457.  
  458.     for (i=0; i<ndevices; i++, list++)
  459.     if (list->use == IsXKeyboard ||
  460.         list->use == IsXPointer)
  461.         continue;
  462.     else
  463.         {
  464.         dev = XOpenDevice (display, list->id);
  465.         sdev[i] = dev;
  466.         if (Dflag)
  467.         printf ("\nOpened device %s id is %d\n",
  468.             list->name, dev->device_id);
  469.         for (ip= dev->classes, j=0; j<dev->num_classes; j++, ip++)
  470.         {
  471.         if (Dflag)
  472.             {
  473.             printf ("class is %d\n",ip->input_class);
  474.             printf ("event type base is %x\n\n",ip->event_type_base);
  475.             }
  476.         if (ip->input_class == KeyClass)
  477.             {
  478.             keydevice = dev;
  479.             valid = class[dev->device_id].valid++;
  480.                 DeviceKeyPress (dev, devicekeypress, 
  481.             class[dev->device_id].class[valid]);
  482.             valid = class[dev->device_id].valid++;
  483.                 DeviceKeyRelease (dev, devicekeyrelease, 
  484.             class[dev->device_id].class[valid]);
  485.             if (Dflag)
  486.             {
  487.             printf ("DeviceKeyPress reports: type=%x class=%x\n",
  488.                 devicekeypress, 
  489.                 class[dev->device_id].class[valid]);
  490.             printf ("DeviceKeyRelease reports: type=%x class=%x\n",
  491.                 devicekeyrelease, 
  492.                 class[dev->device_id].class[valid]);
  493.                     printf("\n");
  494.             }
  495.             }
  496.         else if (ip->input_class == ButtonClass)
  497.             {
  498.             valid = class[dev->device_id].valid++;
  499.                 DeviceButtonPress (dev, devicebuttonpress, 
  500.             class[dev->device_id].class[valid]);
  501.             valid = class[dev->device_id].valid++;
  502.                 DeviceButtonRelease (dev, devicebuttonrelease, 
  503.             class[dev->device_id].class[valid]);
  504.             if (Dflag)
  505.             {
  506.             printf ("DeviceButtonPress reports: type=%x class=%x\n",
  507.                 devicebuttonpress, 
  508.                 class[dev->device_id].class[valid-1]);
  509.             printf ("DeviceButtonRelease: type=%x class=%x\n",
  510.                 devicebuttonrelease, 
  511.                 class[dev->device_id].class[valid]);
  512.             printf("\n");
  513.             }
  514.             }
  515.         else if (ip->input_class == ValuatorClass)
  516.             {
  517.             valid = class[dev->device_id].valid++;
  518.                 DeviceMotionNotify (dev, devicemotionnotify, 
  519.             class[dev->device_id].class[valid]);
  520.             if (Dflag)
  521.             printf ("DeviceMotionNotify: type=%x class=%x\n",
  522.                 devicemotionnotify, 
  523.                 class[dev->device_id].class[valid]);
  524.             }
  525.         else if (ip->input_class == FocusClass)
  526.             {
  527.             valid = class[dev->device_id].valid++;
  528.                 DeviceFocusIn (dev, devicefocusin, 
  529.             class[dev->device_id].class[valid]);
  530.             valid = class[dev->device_id].valid++;
  531.                 DeviceFocusOut (dev, devicefocusout, 
  532.             class[dev->device_id].class[valid]);
  533.             if (Dflag)
  534.             {
  535.             printf ("DeviceFocusIn: type=%x class=%x\n",
  536.                 devicefocusin, 
  537.                 class[dev->device_id].class[valid-1]);
  538.             printf ("DeviceFocusOut: type=%x class=%x\n",
  539.                 devicefocusout, class[dev->device_id].class[valid]);
  540.             }
  541.             }
  542.         else if (ip->input_class == ProximityClass)
  543.             {
  544.             valid = class[dev->device_id].valid++;
  545.                 ProximityIn (dev, proximityin, 
  546.             class[dev->device_id].class[valid]);
  547.             valid = class[dev->device_id].valid++;
  548.                 ProximityOut (dev, proximityout, 
  549.             class[dev->device_id].class[valid]);
  550.             if (Dflag)
  551.             {
  552.             printf ("ProximityIn: type=%x class=%x\n",
  553.                 proximityin, class[dev->device_id].class[valid-1]);
  554.             printf ("ProximityOut: type=%x class=%x\n",
  555.                 proximityout, class[dev->device_id].class[valid]);
  556.             }
  557.             }
  558.         else if (ip->input_class == OtherClass)
  559.             {
  560.             valid = class[dev->device_id].valid++;
  561.                 DeviceMappingNotify (dev, devicemappingnotify, 
  562.             class[dev->device_id].class[valid]);
  563.             valid = class[dev->device_id].valid++;
  564.                 DeviceStateNotify (dev, devicestatenotify, 
  565.             class[dev->device_id].class[valid]);
  566.             valid = class[dev->device_id].valid++;
  567.                 ChangeDeviceNotify (dev, changedevicenotify, 
  568.             class[dev->device_id].class[valid]);
  569.             if (Dflag)
  570.             {
  571.             printf ("DeviceMappingNotify: type=%x class=%x\n",
  572.                 devicemappingnotify, 
  573.                 class[dev->device_id].class[valid-2]);
  574.             printf ("DeviceStateNotify: type=%x class=%x\n",
  575.                 devicestatenotify, 
  576.                 class[dev->device_id].class[valid-1]);
  577.             printf ("ChangeDeviceNotify: type=%x class=%x\n",
  578.                 changedevicenotify, 
  579.                 class[dev->device_id].class[valid]);
  580.                 }
  581.             }
  582.         }
  583.         }
  584.     }
  585.  
  586. /******************************************************************
  587.  *
  588.  * This function creates errors caused by invoking functions that 
  589.  * require the input device to support class Buttons.
  590.  *
  591.  */
  592.  
  593. create_button_errors (display, dev, list)
  594.     Display        *display;
  595.     XDevice        *dev;
  596.     XDeviceInfoPtr    *list;
  597.     {
  598.     unsigned char    smap[256];
  599.     int         len;
  600.     XButtonInfoPtr     b;
  601.     Window        root = RootWindow (display,0);
  602.  
  603.  
  604.     b = (XButtonInfoPtr) FindInputClass (list, ButtonClass);
  605.     if (b != NULL)
  606.     return;
  607.  
  608.     expect = BadMatch;
  609.     error_code = XGetDeviceButtonMapping_code;
  610.     len = XGetDeviceButtonMapping (display, dev, smap, 1);
  611.  
  612.     error_code = XSetDeviceButtonMapping_code;
  613.     XSetDeviceButtonMapping (display, dev, smap, 1);
  614.     XSync (display, 0);
  615.  
  616.     error_code = XUngrabDeviceButton_code;
  617.     XUngrabDeviceButton (display, dev, AnyButton, AnyModifier, keydevice, root);
  618.     XSync (display, 0);
  619.     expect = Success;
  620.     error_code = 0;
  621.     }
  622.  
  623. /******************************************************************
  624.  *
  625.  * This function creates errors caused by invoking functions that 
  626.  * require the input device to support class Valuators.
  627.  *
  628.  */
  629.  
  630. create_valuator_errors (display, dev, list)
  631.     Display        *display;
  632.     XDevice        *dev;
  633.     XDeviceInfoPtr    *list;
  634.     {
  635.     Time        start = CurrentTime;
  636.     Time        stop = CurrentTime;
  637.     int            nevents;
  638.     int            mode;
  639.     int         axis_count;
  640.     XDeviceTimeCoord    *events;
  641.     XValuatorInfoPtr     v;
  642.     Window        root = RootWindow (display,0);
  643.  
  644.  
  645.     v = (XValuatorInfoPtr) FindInputClass (list, ValuatorClass);
  646.     if (v != NULL)
  647.     return;
  648.  
  649.     expect = BadMatch;
  650.     error_code = XGetDeviceMotionEvents_code;
  651.     events = XGetDeviceMotionEvents (display, dev, start, stop, &nevents,
  652.     &mode, &axis_count);
  653.     XSync (display, 0);
  654.  
  655.     error_code = XChangePointerDevice_code;
  656.     XChangePointerDevice (display, dev, 0, 1);
  657.     XSync (display, 0);
  658.  
  659.     expect = Success;
  660.     error_code = 0;
  661.     }
  662.  
  663. /******************************************************************
  664.  *
  665.  * This function creates errors caused by invoking functions that 
  666.  * require the input device to support class Keys.
  667.  *
  668.  */
  669.  
  670. create_key_errors (display, dev, list)
  671.     Display        *display;
  672.     XDevice        *dev;
  673.     XDeviceInfoPtr    *list;
  674.     {
  675.     int         iret;
  676.     int         ksyms_per_code;
  677.     XKeyInfoPtr     k;
  678.     KeySym        *sret = NULL;
  679.     XModifierKeymap    *ret = NULL;
  680.     unsigned long    kvaluemask;
  681.     Window        root = RootWindow (display,0);
  682.  
  683.  
  684.     k = (XKeyInfoPtr) FindInputClass (list, KeyClass);
  685.     if (k != NULL)
  686.     return;
  687.  
  688.     expect = BadMatch;
  689.     error_code = XGetDeviceKeyMapping_code;
  690.     sret = XGetDeviceKeyMapping (display, dev, 0, 1, &ksyms_per_code);
  691.     XSync (display, 0);
  692.  
  693.     error_code = XChangeDeviceKeyMapping_code;
  694.     iret = XChangeDeviceKeyMapping (display, dev, 0, 1, sret, 1); 
  695.     XSync (display, 0);
  696.  
  697.     error_code = XGetDeviceModifierMapping_code;
  698.     ret = XGetDeviceModifierMapping (display, dev);
  699.     XSync (display, 0);
  700.  
  701.     error_code = XSetDeviceModifierMapping_code;
  702.     iret = XSetDeviceModifierMapping (display, dev, ret);
  703.     XSync (display, 0);
  704.  
  705.     error_code = XGrabDeviceKey_code;
  706.     XGrabDeviceKey (display, dev, AnyKey, AnyModifier, dev, root, True, 
  707.     class[dev->device_id].valid, 
  708.     &class[dev->device_id].class[0], GrabModeAsync, GrabModeAsync);
  709.  
  710.     error_code = XUngrabDeviceKey_code;
  711.     XUngrabDeviceKey (display, dev, AnyButton, AnyModifier, dev, root);
  712.     XSync (display, 0);
  713.  
  714.     expect = Success;
  715.     error_code = 0;
  716.     }
  717.  
  718. /******************************************************************
  719.  *
  720.  * This function manipulates the button mapping of an extension
  721.  * device that supports input class buttons.
  722.  * X Errors:
  723.  *    XGetDeviceButtonMapping
  724.  *        1). BadDevice
  725.  *        2). BadMatch - see create_button_errors
  726.  *    XSetDeviceButtonMapping
  727.  *        1). BadDevice
  728.  *        2). BadMatch - see create_button_errors
  729.  *
  730.  */
  731.  
  732. do_button_mapping (display, dev, list)
  733.     Display        *display;
  734.     XDevice        *dev;
  735.     XDeviceInfoPtr    *list;
  736.     {
  737.     int            saveid;
  738.     int            status = 0;
  739.     int            i;
  740.     int         len;
  741.     unsigned char    map[256];
  742.     unsigned char    map2[256];
  743.     unsigned char    smap[256];
  744.     XButtonInfoPtr     b;
  745.  
  746.  
  747.     for (i=0; i<256; i++)
  748.     map2[i] = 255-i;
  749.     b = (XButtonInfoPtr) FindInputClass (list, ButtonClass);
  750.     if (b == NULL)
  751.     return;
  752.  
  753.     expect = baddevice;
  754.     error_code = XGetDeviceButtonMapping_code;
  755.     saveid = dev->device_id;
  756.     dev->device_id = -1;
  757.  
  758.     len = XGetDeviceButtonMapping (display, dev, smap, b->num_buttons);
  759.     dev->device_id = xpointer->id;
  760.     len = XGetDeviceButtonMapping (display, dev, smap, b->num_buttons);
  761.     dev->device_id = xkeyboard->id;
  762.     len = XGetDeviceButtonMapping (display, dev, smap, b->num_buttons);
  763.     XSync (display, 0);
  764.  
  765.     error_code = XSetDeviceButtonMapping_code;
  766.     XSetDeviceButtonMapping (display, dev, smap, b->num_buttons);
  767.     dev->device_id = xpointer->id;
  768.     XSetDeviceButtonMapping (display, dev, smap, b->num_buttons);
  769.     dev->device_id = xkeyboard->id;
  770.     XSetDeviceButtonMapping (display, dev, smap, b->num_buttons);
  771.     dev->device_id = saveid;
  772.     XSync (display, 0);
  773.  
  774.     expect = BadValue;
  775.     XSetDeviceButtonMapping (display, dev, smap, b->num_buttons+1);
  776.     XSync (display, 0);
  777.     }
  778.  
  779. /******************************************************************
  780.  *
  781.  * This function selects all available input from an extension device.
  782.  *
  783.  * X Errors:
  784.  *     XSelectExtensionEvent
  785.  *         1). BadWindow
  786.  *         2). BadLength - require bogus library.
  787.  *         3). BadClass
  788.  *     XGetSelectedExtensionEvent
  789.  *         1). BadWindow
  790.  *
  791.  */
  792.  
  793. select_all_input (display, win, name, dev)
  794.     Display    *display;
  795.     Window    win;
  796.     char    *name;
  797.     XDevice    *dev;
  798.     {
  799.     int            i, j;
  800.     XEventClass        tlist[2];
  801.     int            status = 0;
  802.     int            this_client_count;
  803.     int            all_clients_count;
  804.     XEventClass        *this_client;
  805.     XEventClass        *all_clients;
  806.  
  807.     tlist[0] = -1;
  808.  
  809.     expect = BadWindow;
  810.     error_code = XSelectExtensionEvent_code;
  811.     XSelectExtensionEvent (display, -1, 
  812.     &(class[dev->device_id].class[0]), 
  813.     class[dev->device_id].valid);
  814.     XSync (display, 0);
  815.  
  816.     expect = badclass;
  817.     XSelectExtensionEvent (display, win, tlist, 1);
  818.     XSync (display, 0);
  819.  
  820.     expect = BadWindow;
  821.     error_code = XGetSelectedExtensionEvents_code;
  822.     XGetSelectedExtensionEvents (display, -1, &this_client_count,
  823.     &this_client, &all_clients_count, &all_clients);
  824.     XSync (display, 0);
  825.     }
  826.  
  827. /******************************************************************
  828.  *
  829.  * This function manipulates the do_not_propagate list for a window.
  830.  *
  831.  * X Errors:
  832.  *    XGetDeviceDontPropagateList
  833.  *        1). BadWindow
  834.  *    XChangeDeviceDontPropagateList
  835.  *        1). BadWindow
  836.  *        2). BadMode
  837.  *        3). BadClass
  838.  *        4). BadLength - requires bogus library.
  839.  */
  840.  
  841. do_propagate_list (display, win, name, dev)
  842.     Display    *display;
  843.     Window    win;
  844.     char    *name;
  845.     XDevice    *dev;
  846.     {
  847.     int        i;
  848.     int        status = 0;
  849.     int        count, scount;
  850.     XEventClass    tlist[2];
  851.     XEventClass    *list, *slist;
  852.  
  853.     tlist[0] = -1;
  854.     error_code = XGetDeviceDontPropagateList_code;
  855.     expect = BadWindow;
  856.     slist = (XEventClass *) 
  857.     XGetDeviceDontPropagateList (display, -1, &count);
  858.  
  859.     error_code = XChangeDeviceDontPropagateList_code;
  860.     XChangeDeviceDontPropagateList (display, -1, 0, NULL, 
  861.     DeleteFromList);
  862.     XSync (display, 0);
  863.  
  864.     expect = badmode;
  865.     XChangeDeviceDontPropagateList (display, win, 0, NULL, 
  866.     -1);
  867.     XSync (display, 0);
  868.  
  869.     expect = badclass;
  870.     XChangeDeviceDontPropagateList (display, win, 1, tlist, 
  871.     AddToList);
  872.     XSync (display, 0);
  873.  
  874.     }
  875.  
  876. /******************************************************************
  877.  *
  878.  * This function gets and sets the focus for extension input devices.
  879.  *
  880.  * X Errors:
  881.  *    XGetDeviceFocus
  882.  *        1). BadDevice
  883.  *    XSetDeviceFocus
  884.  *        1). BadDevice
  885.  *        2). BadValue
  886.  *        3). BadMatch
  887.  *        4). BadMatch
  888.  * Valid cases:
  889.  *    1). focus = None
  890.  *    2). focus = PointerRoot
  891.  *    3). focus = FollowKeyboard
  892.  *    4). focus = window id
  893.  *    5). time invalid
  894.  *    6). while grabbed & not grabbed.
  895.  */
  896.  
  897. focus_input_device (display, name, dev, win)
  898.     Display    *display;
  899.     char    *name;
  900.     XDevice    *dev;
  901.     {
  902.     int        saveid = dev->device_id;
  903.     int            status = 0;
  904.     Window        sfocus;
  905.     Window        focus;
  906.     int            revert_to;
  907.     int            focus_time;
  908.     Window        root = RootWindow (display, 0);
  909.  
  910.     expect = baddevice;
  911.     error_code = XGetDeviceFocus_code;
  912.     saveid = dev->device_id;
  913.  
  914.     dev->device_id = -1;
  915.     XGetDeviceFocus (display, dev, &sfocus, &revert_to, &focus_time);
  916.     dev->device_id = xpointer->id;
  917.     XGetDeviceFocus (display, dev, &sfocus, &revert_to, &focus_time);
  918.     dev->device_id = xkeyboard->id;
  919.     XGetDeviceFocus (display, dev, &sfocus, &revert_to, &focus_time);
  920.     XSync (display, 0);
  921.  
  922.     error_code = XSetDeviceFocus_code;
  923.     expect = baddevice;
  924.     dev->device_id = -1;
  925.     XSetDeviceFocus (display, dev, None, RevertToNone, CurrentTime);
  926.     dev->device_id = xpointer->id;
  927.     XSetDeviceFocus (display, dev, None, RevertToNone, CurrentTime);
  928.     dev->device_id = xkeyboard->id;
  929.     XSetDeviceFocus (display, dev, None, RevertToNone, CurrentTime);
  930.     XSync (display, 0);
  931.  
  932.     dev->device_id = saveid;
  933.     expect = BadWindow;
  934.     XSetDeviceFocus (display, dev, -1, RevertToNone, CurrentTime);
  935.     XSync (display, 0);
  936.  
  937.     expect = BadValue;
  938.     XSetDeviceFocus (display, dev, None, -1, CurrentTime);
  939.     XSync (display, 0);
  940.  
  941.     expect = BadMatch;
  942.     XSetDeviceFocus (display, dev, win, RevertToPointerRoot, CurrentTime);
  943.     XSync (display, 0);
  944.  
  945.     }
  946.  
  947. /******************************************************************
  948.  *
  949.  * This function grabs extension input devices.
  950.  *
  951.  * X Errors:
  952.  *    1). BadDevice
  953.  *    2). BadWindow
  954.  *    3). BadValue (each of the two modes)
  955.  *    4). BadClass
  956.  *    5). BadLength (requires bogus library).
  957.  * Valid cases:
  958.  *    1). AlreadyGrabbed.
  959.  *    2). GrabInvalidTime.
  960.  *    3). GrabFrozen.
  961.  *    4). GrabNotViewable.
  962.  *    5). focus state was FollowKeyboard.
  963.  *
  964.  */
  965.  
  966. grab_input_device (display, name, dev, win1, win2, win3)
  967.     Display    *display;
  968.     char    *name;
  969.     XDevice    *dev;
  970.     Window    win1, win2, win3;
  971.     {
  972.     int        i;
  973.     char    *p1, *p2;
  974.     XEvent     event;
  975.     XDeviceKeyEvent     *k = (XDeviceKeyEvent *) &event;
  976.     int        saveid = dev->device_id;
  977.     int        status = -1;
  978.     int        tstatus = -1;
  979.     int        ret = -1;
  980.     XEvent    saveevent;
  981.     XDeviceFocusChangeEvent *f = (XDeviceFocusChangeEvent *) &event;
  982.     Time    time;
  983.  
  984.     event.type = 0;
  985.     expect = baddevice;
  986.     error_code = XGrabDevice_code;
  987.     saveid = dev->device_id;
  988.  
  989.     dev->device_id = -1;
  990.     status = XGrabDevice (display, dev, win1, True, 
  991.     class[saveid].valid, 
  992.     &class[saveid].class[0], GrabModeAsync, GrabModeAsync, CurrentTime);
  993.     dev->device_id = xpointer->id;
  994.     status = XGrabDevice (display, dev, win1, True, 
  995.     class[saveid].valid, 
  996.     &class[saveid].class[0], GrabModeAsync, GrabModeAsync, CurrentTime);
  997.     dev->device_id = xkeyboard->id;
  998.     status = XGrabDevice (display, dev, win1, True,
  999.     class[saveid].valid, 
  1000.     &class[saveid].class[0], GrabModeAsync, GrabModeAsync, CurrentTime);
  1001.     XSync (display, 0);
  1002.  
  1003.     dev->device_id = saveid;
  1004.     expect = BadWindow;
  1005.     status = XGrabDevice (display, dev, -1, True,
  1006.     class[saveid].valid, 
  1007.     &class[dev->device_id].class[0], 
  1008.     GrabModeAsync, GrabModeAsync, CurrentTime);
  1009.     XSync (display, 0);
  1010.  
  1011.     expect = BadValue;
  1012.     status = XGrabDevice (display, dev, win1, True,
  1013.     class[saveid].valid, 
  1014.     &class[dev->device_id].class[0], -1, GrabModeAsync, CurrentTime);
  1015.     status = XGrabDevice (display, dev, win1, True,
  1016.     class[saveid].valid, 
  1017.     &class[dev->device_id].class[0], GrabModeAsync, -1, CurrentTime);
  1018.     XSync (display, 0);
  1019.  
  1020.     expect = badclass;
  1021.     status = XGrabDevice (display, dev, win1, True, 2,
  1022.     bogusclass, GrabModeAsync, GrabModeAsync, CurrentTime);
  1023.     XSync (display, 0);
  1024.  
  1025.     tstatus = XGrabDevice (display, dev, win1, True, class[saveid].valid, 
  1026.     &class[dev->device_id].class[0], GrabModeAsync, GrabModeAsync, 
  1027.     CurrentTime);
  1028.     if (tstatus == Success)
  1029.     {
  1030.     status = -1;
  1031.     while (XPending (display) > 0)
  1032.         {
  1033.         XNextEvent (display,&event);
  1034.         if (f->type == devicefocusin)
  1035.         {
  1036.         time = f->time;
  1037.         status = 0;
  1038.         }
  1039.         }
  1040.     }
  1041.     else
  1042.     printf ("GrabDevice failed.\n");
  1043.  
  1044.     tstatus = XGrabDevice (display, dev, win1, True, class[saveid].valid, 
  1045.     &class[dev->device_id].class[0], GrabModeAsync, GrabModeAsync, 
  1046.     time - 1);
  1047.     if (tstatus != GrabInvalidTime)
  1048.     {
  1049.     printf ("GrabDevice did not return Invalidtime as it should have.\n");
  1050.     status = tstatus;
  1051.     }
  1052.  
  1053.     tstatus = XGrabDevice (display, dev, win3, True,
  1054.     class[saveid].valid, 
  1055.     &class[dev->device_id].class[0], 
  1056.     GrabModeAsync, GrabModeAsync, CurrentTime);
  1057.     if (tstatus != GrabNotViewable)
  1058.     {
  1059.     printf ("GrabDevice didn't return GrabNotViewable as it should.\n");
  1060.     status = tstatus;
  1061.     }
  1062.  
  1063.     }
  1064.  
  1065. /******************************************************************
  1066.  *
  1067.  * This function grabs keys on extension input devices.
  1068.  *
  1069.  * X Errors:
  1070.  *    1). BadDevice
  1071.  *    2). BadWindow
  1072.  *    3). BadValue (each of the two modes)
  1073.  *    4). BadClass
  1074.  *    5). BadLength (requires bogus library).
  1075.  *
  1076.  */
  1077.  
  1078. grab_device_key (display, name, dev, win1, win2)
  1079.     Display    *display;
  1080.     char    *name;
  1081.     XDevice    *dev;
  1082.     Window    win1, win2;
  1083.     {
  1084.     int        saveid = dev->device_id;
  1085.     int        status = -1;
  1086.     XDevice    dev2;
  1087.  
  1088.     dev2 = *dev;
  1089.     expect = baddevice;
  1090.     error_code = XGrabDeviceKey_code;
  1091.     saveid = dev->device_id;
  1092.  
  1093.     dev->device_id = -1;
  1094.     XGrabDeviceKey (display, &dev2, AnyKey, AnyModifier, dev, win1, True, 
  1095.     class[saveid].valid,
  1096.     &class[saveid].class[0], GrabModeAsync, GrabModeAsync);
  1097.     dev->device_id = xpointer->id;
  1098.     XGrabDeviceKey (display, &dev2, AnyKey, AnyModifier, dev, win1, True, 
  1099.     class[saveid].valid,
  1100.     &class[saveid].class[0], GrabModeAsync, GrabModeAsync);
  1101.     dev->device_id = xkeyboard->id;
  1102.     XGrabDeviceKey (display, &dev2, AnyKey, AnyModifier, dev, win1, True, 
  1103.     class[saveid].valid,
  1104.     &class[saveid].class[0], GrabModeAsync, GrabModeAsync);
  1105.     dev->device_id = -1;
  1106.     XGrabDeviceKey (display, dev, AnyKey, AnyModifier, &dev2, win1, True, 
  1107.     class[saveid].valid,
  1108.     &class[saveid].class[0], GrabModeAsync, GrabModeAsync);
  1109.     dev->device_id = xpointer->id;
  1110.     XGrabDeviceKey (display, dev, AnyKey, AnyModifier, &dev2, win1, True, 
  1111.     class[saveid].valid,
  1112.     &class[saveid].class[0], GrabModeAsync, GrabModeAsync);
  1113.     dev->device_id = xkeyboard->id;
  1114.     XGrabDeviceKey (display, dev, AnyKey, AnyModifier, &dev2, win1, True, 
  1115.     class[saveid].valid,
  1116.     &class[saveid].class[0], GrabModeAsync, GrabModeAsync);
  1117.     XSync (display, 0);
  1118.  
  1119.     dev->device_id = saveid;
  1120.     expect = BadWindow;
  1121.     XGrabDeviceKey (display, dev, AnyKey, AnyModifier, dev, -1, True, 
  1122.     class[dev->device_id].valid,
  1123.     &class[dev->device_id].class[0], GrabModeAsync, GrabModeAsync);
  1124.     XSync (display, 0);
  1125.  
  1126.     expect = BadValue;
  1127.     XGrabDeviceKey (display, dev, AnyKey, AnyModifier, dev, win1, True, 
  1128.     class[dev->device_id].valid,
  1129.     &class[dev->device_id].class[0], -1, GrabModeAsync);
  1130.     XGrabDeviceKey (display, dev, AnyKey, AnyModifier, dev, win1, True, 
  1131.     class[dev->device_id].valid,
  1132.     &class[dev->device_id].class[0], GrabModeAsync, -1);
  1133.     XSync (display, 0);
  1134.  
  1135.     expect = badclass;
  1136.     XGrabDeviceKey (display, dev, AnyKey, AnyModifier, dev, win1, True, 
  1137.     2,
  1138.     bogusclass, GrabModeAsync, GrabModeAsync);
  1139.     XSync (display, 0);
  1140.  
  1141.     }
  1142.  
  1143. /******************************************************************
  1144.  *
  1145.  * This function ungrabs keys on extension input devices.
  1146.  *
  1147.  */
  1148.  
  1149. ungrab_device_key (display, name, dev, win1, win2)
  1150.     Display    *display;
  1151.     char    *name;
  1152.     XDevice    *dev;
  1153.     Window    win1, win2;
  1154.     {
  1155.     int        saveid;
  1156.     XDevice    dev2;
  1157.  
  1158.     dev2 = *dev;
  1159.     expect = baddevice;
  1160.     error_code = XUngrabDeviceKey_code;
  1161.     saveid = dev->device_id;
  1162.  
  1163.     dev->device_id = -1;
  1164.     XUngrabDeviceKey (display, dev, AnyButton, AnyModifier, &dev2, win1);
  1165.     dev->device_id = xpointer->id;
  1166.     XUngrabDeviceKey (display, dev, AnyButton, AnyModifier, &dev2, win1);
  1167.     dev->device_id = xkeyboard->id;
  1168.     XUngrabDeviceKey (display, dev, AnyButton, AnyModifier, &dev2, win1);
  1169.     dev->device_id = -1;
  1170.     XUngrabDeviceKey (display, &dev2, AnyButton, AnyModifier, dev, win1);
  1171.     dev->device_id = xpointer->id;
  1172.     XUngrabDeviceKey (display, &dev2, AnyButton, AnyModifier, dev, win1);
  1173.     dev->device_id = xkeyboard->id;
  1174.     XUngrabDeviceKey (display, &dev2, AnyButton, AnyModifier, dev, win1);
  1175.     XSync (display, 0);
  1176.  
  1177.     dev->device_id = saveid;
  1178.     expect = BadWindow;
  1179.     XUngrabDeviceKey (display, dev, AnyButton, AnyModifier, dev, -1);
  1180.     XSync (display, 0);
  1181.  
  1182.     }
  1183.  
  1184. /******************************************************************
  1185.  *
  1186.  * This function grabs buttons on extension input devices.
  1187.  *
  1188.  * X Errors:
  1189.  *    1). BadDevice
  1190.  *    2). BadWindow
  1191.  *    3). BadValue (each of the two modes)
  1192.  *    4). BadClass
  1193.  *    5). BadLength (requires bogus library).
  1194.  *
  1195.  */
  1196.  
  1197. grab_device_button (display, name, dev, win1, win2)
  1198.     Display    *display;
  1199.     char    *name;
  1200.     XDevice    *dev;
  1201.     Window    win1, win2;
  1202.     {
  1203.     int        saveid = dev->device_id;
  1204.     int        status = -1;
  1205.     XDevice    dev2;
  1206.  
  1207.     dev2 = *keydevice;
  1208.     expect = baddevice;
  1209.     error_code = XGrabDeviceButton_code;
  1210.     saveid = dev->device_id;
  1211.  
  1212.     dev->device_id = -1;
  1213.     XGrabDeviceButton (display, dev, AnyButton, AnyModifier, &dev2, win1, 
  1214.     True, 
  1215.     class[saveid].valid,
  1216.     &class[saveid].class[0], GrabModeAsync, GrabModeAsync);
  1217.     dev->device_id = xpointer->id;
  1218.     XGrabDeviceButton (display, dev, AnyButton, AnyModifier, &dev2, win1, 
  1219.     True, 
  1220.     class[saveid].valid,
  1221.     &class[saveid].class[0], GrabModeAsync, GrabModeAsync);
  1222.     dev->device_id = xkeyboard->id;
  1223.     XGrabDeviceButton (display, dev, AnyButton, AnyModifier, &dev2, win1, 
  1224.     True, 
  1225.     class[saveid].valid,
  1226.     &class[saveid].class[0], GrabModeAsync, GrabModeAsync);
  1227.     dev->device_id = -1;
  1228.     XGrabDeviceButton (display, &dev2, AnyButton, AnyModifier, dev, win1, 
  1229.     True, 
  1230.     class[saveid].valid,
  1231.     &class[saveid].class[0], GrabModeAsync, GrabModeAsync);
  1232.     dev->device_id = xpointer->id;
  1233.     XGrabDeviceButton (display, &dev2, AnyButton, AnyModifier, dev, win1, 
  1234.     True, 
  1235.     class[saveid].valid,
  1236.     &class[saveid].class[0], GrabModeAsync, GrabModeAsync);
  1237.     dev->device_id = xkeyboard->id;
  1238.     XGrabDeviceButton (display, &dev2, AnyButton, AnyModifier, dev, win1, 
  1239.     True, 
  1240.     class[saveid].valid,
  1241.     &class[saveid].class[0], GrabModeAsync, GrabModeAsync);
  1242.     XSync (display, 0);
  1243.  
  1244.     dev->device_id = saveid;
  1245.     expect = BadWindow;
  1246.     XGrabDeviceButton (display, dev, AnyButton, AnyModifier, keydevice, -1, 
  1247.     True, 
  1248.     class[saveid].valid,
  1249.     &class[dev->device_id].class[0], GrabModeAsync, GrabModeAsync);
  1250.     XSync (display, 0);
  1251.  
  1252.     expect = BadValue;
  1253.     XGrabDeviceButton (display, dev, AnyButton, AnyModifier, keydevice, win1, 
  1254.     True, 
  1255.     class[saveid].valid,
  1256.     &class[dev->device_id].class[0], -1, GrabModeAsync);
  1257.     XGrabDeviceButton (display, dev, AnyButton, AnyModifier, keydevice, win1, 
  1258.     True, 
  1259.     class[saveid].valid,
  1260.     &class[dev->device_id].class[0], GrabModeAsync, -1);
  1261.     XSync (display, 0);
  1262.  
  1263.     expect = badclass;
  1264.     XGrabDeviceButton (display, dev, AnyButton, AnyModifier, keydevice, win1, 
  1265.     True, 2,
  1266.     bogusclass, GrabModeAsync, GrabModeAsync);
  1267.     XSync (display, 0);
  1268.  
  1269.     }
  1270.  
  1271. /******************************************************************
  1272.  *
  1273.  * This function ungrabs buttons on extension input devices.
  1274.  * X Errors:
  1275.  *    1). BadDevice
  1276.  *    2). BadWindow
  1277.  *    3). BadLength - requires bogus library.
  1278.  *
  1279.  */
  1280.  
  1281. ungrab_device_button (display, name, dev, win1, win2)
  1282.     Display    *display;
  1283.     char    *name;
  1284.     XDevice    *dev;
  1285.     Window    win1, win2;
  1286.     {
  1287.     XDevice    dev2;
  1288.     int        saveid;
  1289.  
  1290.     dev2 = *dev;
  1291.     expect = baddevice;
  1292.     error_code = XUngrabDeviceButton_code;
  1293.     saveid = dev->device_id;
  1294.  
  1295.     dev->device_id = -1;
  1296.     XUngrabDeviceButton (display, dev, AnyButton, AnyModifier, &dev2, win1);
  1297.     dev->device_id = xpointer->id;
  1298.     XUngrabDeviceButton (display, dev, AnyButton, AnyModifier, &dev2, win1);
  1299.     dev->device_id = xkeyboard->id;
  1300.     XUngrabDeviceButton (display, dev, AnyButton, AnyModifier, &dev2, win1);
  1301.     dev->device_id = -1;
  1302.     XUngrabDeviceButton (display, &dev2, AnyButton, AnyModifier, dev, win1);
  1303.     dev->device_id = xpointer->id;
  1304.     XUngrabDeviceButton (display, &dev2, AnyButton, AnyModifier, dev, win1);
  1305.     dev->device_id = xkeyboard->id;
  1306.     XUngrabDeviceButton (display, &dev2, AnyButton, AnyModifier, dev, win1);
  1307.     XSync (display, 0);
  1308.  
  1309.     dev->device_id = saveid;
  1310.     expect = BadWindow;
  1311.     XUngrabDeviceButton (display, dev, AnyButton, AnyModifier, keydevice, -1);
  1312.     XSync (display, 0);
  1313.     }
  1314.  
  1315. /******************************************************************
  1316.  *
  1317.  * This function ungrabs extension input devices.
  1318.  * X Errors:
  1319.  *    1). BadDevice
  1320.  *
  1321.  */
  1322.  
  1323. ungrab_input_device (display, name, dev)
  1324.     Display    *display;
  1325.     char    *name;
  1326.     XDevice    *dev;
  1327.     {
  1328.     int        ret;
  1329.     int        saveid;
  1330.  
  1331.     expect = baddevice;
  1332.     error_code = XUngrabDevice_code;
  1333.     saveid = dev->device_id;
  1334.  
  1335.     dev->device_id = -1;
  1336.     XUngrabDevice (display, dev, CurrentTime);
  1337.     dev->device_id = xpointer->id;
  1338.     XUngrabDevice (display, dev, CurrentTime);
  1339.     dev->device_id = xkeyboard->id;
  1340.     XUngrabDevice (display, dev, CurrentTime);
  1341.     XSync (display, 0);
  1342.     dev->device_id = saveid;
  1343.  
  1344.     }
  1345.  
  1346. /******************************************************************
  1347.  *
  1348.  * This function exercises the device key mapping functions.
  1349.  * X Errors:
  1350.  *    XGetDeviceKeyMapping
  1351.  *        1). BadDevice
  1352.  *        2). BadValue
  1353.  *        3). BadMatch - see create_key_errors
  1354.  *    XChangeDeviceKeyMapping
  1355.  *        1). BadDevice
  1356.  *        2). BadValue
  1357.  *        3). BadMatch - see create_key_errors
  1358.  *
  1359.  */
  1360.  
  1361. do_key_mapping (display, name, dev, list)
  1362.     Display        *display;
  1363.     char        *name;
  1364.     XDevice        *dev;
  1365.     XDeviceInfoPtr    list;
  1366.     {
  1367.     int        saveid;
  1368.     int        status = 0;
  1369.     int        l=0;
  1370.     int        i, j, iret;
  1371.     int        ksyms_per_code = 2;
  1372.     XKeyInfoPtr k;
  1373.     KeySym    save[1024];
  1374.     KeySym    *ret = NULL;
  1375.     KeySym    *sret = NULL;
  1376.  
  1377.     k = (XKeyInfoPtr) FindInputClass (list, KeyClass);
  1378.     if (k == NULL)
  1379.     return;
  1380.  
  1381.     ret = XGetDeviceKeyMapping (display, dev, k->min_keycode, 
  1382.     k->num_keys, &ksyms_per_code);
  1383.  
  1384.     expect = baddevice;
  1385.     error_code = XGetDeviceKeyMapping_code;
  1386.     saveid = dev->device_id;
  1387.  
  1388.     dev->device_id = -1;
  1389.     ret = XGetDeviceKeyMapping (display, dev, k->min_keycode, 
  1390.     k->num_keys, &ksyms_per_code);
  1391.     dev->device_id = xpointer->id;
  1392.     ret = XGetDeviceKeyMapping (display, dev, k->min_keycode, 
  1393.     k->num_keys, &ksyms_per_code);
  1394.     dev->device_id = xkeyboard->id;
  1395.     ret = XGetDeviceKeyMapping (display, dev, k->min_keycode, 
  1396.     k->num_keys, &ksyms_per_code);
  1397.     XSync (display, 0);
  1398.  
  1399.     dev->device_id = saveid;
  1400.     expect = BadValue;
  1401.     ret = XGetDeviceKeyMapping (display, dev, k->min_keycode-1, 
  1402.     k->num_keys, &ksyms_per_code);
  1403.     ret = XGetDeviceKeyMapping (display, dev, k->max_keycode+1, 
  1404.     k->num_keys, &ksyms_per_code);
  1405.     ret = XGetDeviceKeyMapping (display, dev, k->min_keycode, 
  1406.     k->max_keycode - k->min_keycode + 2, &ksyms_per_code);
  1407.     XSync (display, 0);
  1408.  
  1409.     expect = baddevice;
  1410.     error_code = XChangeDeviceKeyMapping_code;
  1411.     dev->device_id = -1;
  1412.     iret = XChangeDeviceKeyMapping (display, dev, k->min_keycode, 
  1413.     ksyms_per_code, sret, k->num_keys);
  1414.     dev->device_id = xpointer->id;
  1415.     iret = XChangeDeviceKeyMapping (display, dev, k->min_keycode, 
  1416.     ksyms_per_code, sret, k->num_keys);
  1417.     dev->device_id = xkeyboard->id;
  1418.     iret = XChangeDeviceKeyMapping (display, dev, k->min_keycode, 
  1419.     ksyms_per_code, sret, k->num_keys);
  1420.     dev->device_id = saveid;
  1421.     XSync (display, 0);
  1422.  
  1423.     expect = BadValue;
  1424.     iret = XChangeDeviceKeyMapping (display, dev, k->min_keycode-1, 
  1425.     ksyms_per_code, sret, k->num_keys);
  1426.     iret = XChangeDeviceKeyMapping (display, dev, k->min_keycode, 
  1427.     ksyms_per_code, sret, k->max_keycode - k->min_keycode + 2);
  1428.     iret = XChangeDeviceKeyMapping (display, dev, k->min_keycode, 
  1429.     0, sret, k->num_keys);
  1430.     XSync (display, 0);
  1431.  
  1432.     }
  1433.  
  1434. /******************************************************************
  1435.  *
  1436.  * This function exercises the device modifier mapping functions.
  1437.  * X Errors:
  1438.  *    XGetDeviceModifierMapping
  1439.  *        1). BadDevice
  1440.  *    XSetDeviceModifierMapping
  1441.  *        1). BadDevice
  1442.  *        2). BadValue
  1443.  *        3). BadLength - requires bogus library.
  1444.  *
  1445.  */
  1446.  
  1447. do_modifier_mapping (display, name, dev)
  1448.     Display    *display;
  1449.     char    *name;
  1450.     XDevice    *dev;
  1451.     {
  1452.     int            saveid = 0;
  1453.     int            status = 0;
  1454.     int            i,j;
  1455.     int            k=0;
  1456.     int            iret;
  1457.     XModifierKeymap    *ret = NULL;
  1458.     KeyCode        *first;
  1459.     KeyCode        savcodes[256];
  1460.  
  1461.     expect = baddevice;
  1462.     error_code = XGetDeviceModifierMapping_code;
  1463.     saveid = dev->device_id;
  1464.  
  1465.     dev->device_id = -1;
  1466.     ret = XGetDeviceModifierMapping (display, dev);
  1467.     dev->device_id = xpointer->id;
  1468.     ret = XGetDeviceModifierMapping (display, dev);
  1469.     dev->device_id = xkeyboard->id;
  1470.     ret = XGetDeviceModifierMapping (display, dev);
  1471.     XSync (display, 0);
  1472.  
  1473.     dev->device_id = -1;
  1474.     error_code = XSetDeviceModifierMapping_code;
  1475.     iret = XSetDeviceModifierMapping (display, dev, ret);
  1476.     dev->device_id = xpointer->id;
  1477.     iret = XSetDeviceModifierMapping (display, dev, ret);
  1478.     dev->device_id = xkeyboard->id;
  1479.     iret = XSetDeviceModifierMapping (display, dev, ret);
  1480.     XSync (display, 0);
  1481.     dev->device_id = saveid;
  1482.  
  1483.     expect = BadValue;
  1484.     ret = XGetDeviceModifierMapping (display, dev);
  1485.     ret->modifiermap[0] = 7;
  1486.     iret = XSetDeviceModifierMapping (display, dev, ret);
  1487.     XSync (display, 0);
  1488.     }
  1489.  
  1490. /******************************************************************
  1491.  *
  1492.  * This function gets the motion history for a device that supports
  1493.  * input class Valuators.
  1494.  * X Errors:
  1495.  *    1). BadDevice
  1496.  *    2). BadMatch - see create_valuator_errors.
  1497.  *
  1498.  */
  1499.  
  1500. get_motion_history (display, name, dev)
  1501.     Display    *display;
  1502.     char    *name;
  1503.     XDevice    *dev;
  1504.     {
  1505.     int            saveid;
  1506.     Time        start = CurrentTime;
  1507.     Time        stop = CurrentTime;
  1508.     int            nevents;
  1509.     int            mode;
  1510.     int            axis_count;
  1511.     XDeviceTimeCoord    *events;
  1512.  
  1513.     expect = baddevice;
  1514.     error_code = XGetDeviceMotionEvents_code;
  1515.     saveid = dev->device_id;
  1516.  
  1517.     dev->device_id = -1;
  1518.     events = XGetDeviceMotionEvents (display, dev, start, stop, &nevents,
  1519.     &mode, &axis_count);
  1520.     dev->device_id = xpointer->id;
  1521.     events = XGetDeviceMotionEvents (display, dev, start, stop, &nevents,
  1522.     &mode, &axis_count);
  1523.     dev->device_id = xkeyboard->id;
  1524.     events = XGetDeviceMotionEvents (display, dev, start, stop, &nevents,
  1525.     &mode, &axis_count);
  1526.     XSync (display, 0);
  1527.     dev->device_id = saveid;
  1528.     }
  1529.  
  1530. /******************************************************************
  1531.  *
  1532.  * This function changes the X pointer to the specified device.
  1533.  * X Errors:
  1534.  *    1). BadDevice
  1535.  *    2). BadMatch - see also create_valuator_errors.
  1536.  *
  1537.  */
  1538.  
  1539. change_pointer_device (display, name, dev)
  1540.     Display    *display;
  1541.     char    *name;
  1542.     XDevice    *dev;
  1543.     {
  1544.     int    saveid;
  1545.  
  1546.     expect = baddevice;
  1547.     error_code = XChangePointerDevice_code;
  1548.     saveid = dev->device_id;
  1549.  
  1550.     dev->device_id = -1;
  1551.     XChangePointerDevice (display, dev, 0, 1);
  1552.     dev->device_id = xpointer->id;
  1553.     XChangePointerDevice (display, dev, 0, 1);
  1554.     dev->device_id = xkeyboard->id;
  1555.     XChangePointerDevice (display, dev, 0, 1);
  1556.     XSync (display, 0);
  1557.     dev->device_id = saveid;
  1558.  
  1559.     expect = BadMatch;
  1560.     XChangePointerDevice (display, dev, -1, 1);
  1561.     XChangePointerDevice (display, dev, 0, -1);
  1562.     XChangePointerDevice (display, dev, 999, 1);
  1563.     XChangePointerDevice (display, dev, 0, 999);
  1564.     XSync (display, 0);
  1565.     }
  1566.  
  1567. /******************************************************************
  1568.  *
  1569.  * This function changes the X keyboard to the specified device.
  1570.  * X Errors:
  1571.  *    1). BadDevice
  1572.  *    2). BadMatch - see also create_valuator_errors.
  1573.  *
  1574.  */
  1575.  
  1576. change_keyboard_device (display, name, dev, list)
  1577.     Display        *display;
  1578.     char        *name;
  1579.     XDevice        *dev;
  1580.     XDeviceInfoPtr    list;
  1581.     {
  1582.     int            saveid;
  1583.     int            i;
  1584.     int            ndevices;
  1585.     XKeyInfoPtr     k;
  1586.     XDeviceInfoPtr    list2;
  1587.     XDevice        *dev2;
  1588.  
  1589.     expect = baddevice;
  1590.     error_code = XChangeKeyboardDevice_code;
  1591.     saveid = dev->device_id;
  1592.  
  1593.     dev->device_id = -1;
  1594.     XChangeKeyboardDevice (display, dev, -1, 1);
  1595.     dev->device_id = xpointer->id;
  1596.     XChangeKeyboardDevice (display, dev, -1, 1);
  1597.     dev->device_id = xkeyboard->id;
  1598.     XChangeKeyboardDevice (display, dev, -1, 1);
  1599.     XSync (display, 0);
  1600.     dev->device_id = saveid;
  1601.  
  1602.     }
  1603.  
  1604. /******************************************************************
  1605.  *
  1606.  * This function queries the extension version.
  1607.  * X Errors:
  1608.  *    none.
  1609.  *
  1610.  */
  1611.  
  1612. query_extension_version (display)
  1613.     {
  1614.     int            status = 0;
  1615.     XExtensionVersion     *ext;
  1616.  
  1617.     ext = XGetExtensionVersion(display, "");
  1618.     if (ext->present)
  1619.     status = -1;
  1620.  
  1621.     ext = XGetExtensionVersion(display, "XInputExtension");
  1622.  
  1623.     }
  1624.  
  1625. /******************************************************************
  1626.  *
  1627.  * This function queries the state of a device.
  1628.  * X Errors:
  1629.  *    BadDevice.
  1630.  *
  1631.  */
  1632.  
  1633. query_device_state (display, name, dev)
  1634.     Display    *display;
  1635.     char    *name;
  1636.     XDevice    *dev;
  1637.     {
  1638.     int            saveid;
  1639.     XDeviceState     *state;
  1640.  
  1641.     expect = baddevice;
  1642.     error_code = XQueryDeviceState_code;
  1643.     saveid = dev->device_id;
  1644.  
  1645.     dev->device_id = -1;
  1646.     state = XQueryDeviceState (display, dev);
  1647.     dev->device_id = xpointer->id;
  1648.     state = XQueryDeviceState (display, dev);
  1649.     dev->device_id = xkeyboard->id;
  1650.     state = XQueryDeviceState (display, dev);
  1651.     XSync (display, 0);
  1652.     dev->device_id = saveid;
  1653.  
  1654.     }
  1655.  
  1656. /******************************************************************
  1657.  *
  1658.  * This function allows a frozen device to be thawed.
  1659.  * X Errors:
  1660.  *    BadDevice.
  1661.  *    BadValue.
  1662.  *
  1663.  */
  1664.  
  1665. allow_device_event (display, name, dev)
  1666.     Display    *display;
  1667.     char    *name;
  1668.     XDevice    *dev;
  1669.     {
  1670.     int        saveid;
  1671.  
  1672.     expect = baddevice;
  1673.     error_code = XAllowDeviceEvents_code;
  1674.     saveid = dev->device_id;
  1675.  
  1676.     dev->device_id = -1;
  1677.     XAllowDeviceEvents (display, dev, AsyncThisDevice, CurrentTime);
  1678.     dev->device_id = xpointer->id;
  1679.     XAllowDeviceEvents (display, dev, AsyncThisDevice, CurrentTime);
  1680.     dev->device_id = xkeyboard->id;
  1681.     XAllowDeviceEvents (display, dev, AsyncThisDevice, CurrentTime);
  1682.     XSync (display, 0);
  1683.     dev->device_id = saveid;
  1684.  
  1685.     expect = BadValue;
  1686.     XAllowDeviceEvents (display, dev, -1, CurrentTime);
  1687.     XSync (display, 0);
  1688.     }
  1689.  
  1690. /******************************************************************
  1691.  *
  1692.  * This function gets the feedback control values of a device.
  1693.  * X Errors:
  1694.  *    XGetFeedbackControl
  1695.  *    1). BadDevice.
  1696.  *    XChangeFeedbackControl
  1697.  *    1). BadDevice.
  1698.  *    2). BadMatch.
  1699.  *    3). BadValue.
  1700.  *
  1701.  */
  1702.  
  1703. do_feedback_control (display, name, dev)
  1704.     Display    *display;
  1705.     char    *name;
  1706.     XDevice    *dev;
  1707.     {
  1708.     int            saveid;
  1709.     int            i,j;
  1710.     int            num_feedbacks;
  1711.     int            mask=0;
  1712.     XFeedbackState    *state, *sav;
  1713.     XKbdFeedbackState    *kbd;
  1714.     XPtrFeedbackState    *ptr;
  1715.     XKbdFeedbackControl    kbdf;
  1716.     XPtrFeedbackControl    ptrf;
  1717.  
  1718.     expect = baddevice;
  1719.     error_code = XGetFeedbackControl_code;
  1720.     saveid = dev->device_id;
  1721.  
  1722.     dev->device_id = -1;
  1723.     state = XGetFeedbackControl (display, dev, &num_feedbacks);
  1724.     dev->device_id = xpointer->id;
  1725.     state = XGetFeedbackControl (display, dev, &num_feedbacks);
  1726.     dev->device_id = xkeyboard->id;
  1727.     state = XGetFeedbackControl (display, dev, &num_feedbacks);
  1728.     XSync (display, 0);
  1729.     dev->device_id = saveid;
  1730.  
  1731.     state = XGetFeedbackControl (display, dev, &num_feedbacks);
  1732.     sav = state;
  1733.  
  1734.     for (i=0; i<num_feedbacks; i++)
  1735.     {
  1736.     state = sav;
  1737.     if (state->class == KbdFeedbackClass)
  1738.         {
  1739.         mask = DvPercent | DvPitch | DvDuration;
  1740.         mask |= DvLed | DvKeyClickPercent | DvKey | DvAutoRepeatMode;
  1741.         kbdf.class = KbdFeedbackClass;
  1742.         kbdf.length = sizeof (XKbdFeedbackControl);
  1743.         kbdf.pitch = 33;
  1744.         kbdf.percent = 55;
  1745.         kbdf.duration = 44;
  1746.         kbdf.click = 99;
  1747.         kbdf.led_mask = 0xf0f0; 
  1748.         kbdf.led_value = 0xcf3f; 
  1749.         kbdf.key = 0x81; 
  1750.         kbdf.auto_repeat_mode = AutoRepeatModeOff; 
  1751.  
  1752.         expect = baddevice;
  1753.             error_code = XChangeFeedbackControl_code;
  1754.         dev->device_id = -1;
  1755.         XChangeFeedbackControl (display, dev, mask, &kbdf);
  1756.         dev->device_id = xpointer->id;
  1757.         XChangeFeedbackControl (display, dev, mask, &kbdf);
  1758.         dev->device_id = xkeyboard->id;
  1759.         XChangeFeedbackControl (display, dev, mask, &kbdf);
  1760.         XSync (display, 0);
  1761.         dev->device_id = saveid;
  1762.  
  1763.         expect = BadValue;
  1764.         kbdf.pitch = -1;
  1765.         XChangeFeedbackControl (display, dev, mask, &kbdf);
  1766.         kbdf.pitch = 1;
  1767.         kbdf.percent = -2;
  1768.         XChangeFeedbackControl (display, dev, mask, &kbdf);
  1769.         kbdf.percent = 1;
  1770.         kbdf.duration = -2;
  1771.         XChangeFeedbackControl (display, dev, mask, &kbdf);
  1772.         kbdf.duration = 1;
  1773.         kbdf.click = 101;
  1774.         XChangeFeedbackControl (display, dev, mask, &kbdf);
  1775.         kbdf.click = 100;
  1776.         kbdf.key = 7;
  1777.         XChangeFeedbackControl (display, dev, mask, &kbdf);
  1778.         kbdf.key = 8;
  1779.         kbdf.auto_repeat_mode = -2;
  1780.         XChangeFeedbackControl (display, dev, mask, &kbdf);
  1781.         XSync (display,0);
  1782.  
  1783.         expect = BadMatch;
  1784.         mask &= ~DvAutoRepeatMode;
  1785.         XChangeFeedbackControl (display, dev, mask, &kbdf);
  1786.         XSync (display,0);
  1787.         }
  1788.     else if (state->class == PtrFeedbackClass)
  1789.         {
  1790.         mask = DvAccelNum | DvAccelDenom | DvThreshold;
  1791.         ptrf.class = PtrFeedbackClass;
  1792.         ptrf.length = sizeof (XPtrFeedbackControl);
  1793.         ptrf.accelNum = 10;
  1794.         ptrf.accelDenom = 2;
  1795.         ptrf.threshold = 6;
  1796.  
  1797.         expect = baddevice;
  1798.             error_code = XChangeFeedbackControl_code;
  1799.         dev->device_id = -1;
  1800.         XChangeFeedbackControl (display, dev, mask, &ptrf);
  1801.         dev->device_id = xpointer->id;
  1802.         XChangeFeedbackControl (display, dev, mask, &ptrf);
  1803.         dev->device_id = xkeyboard->id;
  1804.         XChangeFeedbackControl (display, dev, mask, &ptrf);
  1805.         XSync (display, 0);
  1806.         dev->device_id = saveid;
  1807.  
  1808.         expect = BadValue;
  1809.         ptrf.accelNum = -2;
  1810.         XChangeFeedbackControl (display, dev, mask, &ptrf);
  1811.         ptrf.accelNum = 1;
  1812.         ptrf.accelDenom = -2;
  1813.         XChangeFeedbackControl (display, dev, mask, &ptrf);
  1814.         ptrf.threshold = -2;
  1815.         XChangeFeedbackControl (display, dev, mask, &ptrf);
  1816.         XSync (display, 0);
  1817.         }
  1818.     }
  1819.     }
  1820.  
  1821. /******************************************************************
  1822.  *
  1823.  * This function changes the mode of a device.
  1824.  * X Errors:
  1825.  *    1). BadDevice.
  1826.  *    2). BadMode.
  1827.  *
  1828.  */
  1829.  
  1830. set_device_mode (display, name, dev)
  1831.     Display    *display;
  1832.     char    *name;
  1833.     XDevice    *dev;
  1834.     {
  1835.     int        saveid;
  1836.  
  1837.     expect = baddevice;
  1838.     error_code = XSetDeviceMode_code;
  1839.     saveid = dev->device_id;
  1840.  
  1841.     dev->device_id = -1;
  1842.     XSetDeviceMode (display, dev, Absolute);
  1843.     dev->device_id = xpointer->id;
  1844.     XSetDeviceMode (display, dev, Absolute);
  1845.     dev->device_id = xkeyboard->id;
  1846.     XSetDeviceMode (display, dev, Absolute);
  1847.     XSync (display, 0);
  1848.     dev->device_id = saveid;
  1849.  
  1850.     expect = badmode;
  1851.     XSetDeviceMode (display, dev, -1);
  1852.     XSync (display, 0);
  1853.     }
  1854.  
  1855. /******************************************************************
  1856.  *
  1857.  * This function sends an extension event to a client.
  1858.  * X Errors:
  1859.  *    1). BadDevice.
  1860.  *    2). BadMode.
  1861.  *
  1862.  */
  1863.  
  1864. send_extension_event (display, name, dev, win)
  1865.     Display    *display;
  1866.     char    *name;
  1867.     XDevice    *dev;
  1868.     Window    win;
  1869.     {
  1870.     int            i;
  1871.     int            saveid;
  1872.     XEvent        event;
  1873.     XDeviceKeyEvent    kev;
  1874.  
  1875.     kev.type = devicekeypress;
  1876.     kev.serial =  1;
  1877.     kev.send_event = 0;
  1878.     kev.display = display;
  1879.     kev.root = root;
  1880.     kev.x = 10;
  1881.     kev.y = 10;
  1882.     kev.same_screen = 1;
  1883.     kev.subwindow = win;
  1884.     kev.deviceid = dev->device_id;
  1885.     kev.state = 0;
  1886.     kev.keycode = 0xd;
  1887.     kev.axes_count = 0;
  1888.     kev.window = win;
  1889.     kev.x_root = 160;
  1890.     kev.y_root = 160;
  1891.     kev.time = 0xf5f5f5f5;
  1892.     kev.axes_count = 6;
  1893.     kev.first_axis = 0;
  1894.     for (i=0; i<6; i++)
  1895.         kev.axis_data[i] = i;
  1896.  
  1897.     expect = baddevice;
  1898.     error_code = XSendExtensionEvent_code;
  1899.     saveid = dev->device_id;
  1900.  
  1901.     dev->device_id = -1;
  1902.     XSendExtensionEvent (display, dev, win, True, 
  1903.             class[saveid].valid, 
  1904.             &class[saveid].class[0], &kev);
  1905.     dev->device_id = xpointer->id;
  1906.     XSendExtensionEvent (display, dev, win, True, 
  1907.             class[saveid].valid, 
  1908.             &class[saveid].class[0], &kev);
  1909.     dev->device_id = xkeyboard->id;
  1910.     XSendExtensionEvent (display, dev, win, True, 
  1911.             class[saveid].valid, 
  1912.             &class[saveid].class[0], &kev);
  1913.     XSync (display, 0);
  1914.  
  1915.     dev->device_id = saveid;
  1916.     expect = BadWindow;
  1917.     XSendExtensionEvent (display, dev, -1, True, 
  1918.             class[saveid].valid, 
  1919.             &class[saveid].class[0], &kev);
  1920.     XSync (display, 0);
  1921.  
  1922.     expect = badclass;
  1923.     XSendExtensionEvent (display, dev, win, True, 2,
  1924.     bogusclass, &kev);
  1925.     XSync (display, 0);
  1926.  
  1927.     kev.type = KeyPress;
  1928.     expect = BadValue;
  1929.     XSendExtensionEvent (display, dev, win, True, 
  1930.             class[saveid].valid, 
  1931.             &class[saveid].class[0], &kev);
  1932.     XSync (display, 0);
  1933.  
  1934.     }
  1935.  
  1936. /***********************************************************************
  1937.  *
  1938.  * This function initializes an X error handler.
  1939.  *
  1940.  */
  1941.  
  1942. init_error_handler (disp)
  1943.     Display    *disp;
  1944.     {
  1945.     int         event;
  1946.     int         handle_x_errors();
  1947.  
  1948.     XQueryExtension (disp, "XInputExtension", &major_code, &event, &first_err);
  1949.     XSetErrorHandler (handle_x_errors);
  1950.     }
  1951.  
  1952. /***********************************************************************
  1953.  *
  1954.  * This function handles X errors.
  1955.  *
  1956.  */
  1957.  
  1958. handle_x_errors (disp, error)
  1959.     Display    *disp;
  1960.     XErrorEvent *error;
  1961.     {
  1962.     char buf[256];
  1963.  
  1964.     if (error->request_code == major_code &&
  1965.         error->minor_code == error_code &&
  1966.         error->error_code == expect)
  1967.         if (error->error_code >= first_err &&
  1968.             error->error_code <= first_err+4)
  1969.         {
  1970.         if (Dflag)
  1971.                 printf ("%s returned %s correctly.\n",
  1972.             extfuncs[error->minor_code],
  1973.             ext_errors[error->error_code-first_err]);
  1974.         return;
  1975.         }
  1976.     else
  1977.         {
  1978.         if (Dflag)
  1979.                 printf ("%s returned %s correctly.\n",
  1980.             extfuncs[error->minor_code],
  1981.                 std_errors[error->error_code]);
  1982.         return;
  1983.         }
  1984.     gstatus = -1;
  1985.     if (error->request_code == major_code)
  1986.         printf ("    Minor code=%s.\n",extfuncs[error->minor_code]);
  1987.     else
  1988.         printf ("    Minor code=%d.\n",error->minor_code);
  1989.     
  1990.     if (error->error_code >= Success &&
  1991.         error->error_code <= BadImplementation)
  1992.         printf ("    Error code=%s.\n",std_errors[error->error_code]);
  1993.     else if (error->error_code >= first_err &&
  1994.         error->error_code <= first_err+4)
  1995.         printf ("    Error code=%s.\n",ext_errors[error->error_code-first_err]);
  1996.     else
  1997.         printf ("    Error code=%d.\n",error->error_code);
  1998.     printf ("    Resource id=%d.\n",error->resourceid);
  1999.     return (0);
  2000.     }
  2001.  
  2002.