home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / evbl0627.zip / everblue_20010627.zip / x11 / XKBCtrls.c < prev    next >
C/C++ Source or Header  |  1999-11-02  |  13KB  |  428 lines
  1. /* $XConsortium: XKBCtrls.c /main/7 1996/02/02 14:09:20 kaleb $ */
  2. /************************************************************
  3. Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc.
  4.  
  5. Permission to use, copy, modify, and distribute this
  6. software and its documentation for any purpose and without
  7. fee is hereby granted, provided that the above copyright
  8. notice appear in all copies and that both that copyright
  9. notice and this permission notice appear in supporting
  10. documentation, and that the name of Silicon Graphics not be 
  11. used in advertising or publicity pertaining to distribution 
  12. of the software without specific prior written permission.
  13. Silicon Graphics makes no representation about the suitability 
  14. of this software for any purpose. It is provided "as is"
  15. without any express or implied warranty.
  16.  
  17. SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS 
  18. SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY 
  19. AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
  20. GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL 
  21. DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, 
  22. DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE 
  23. OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION  WITH
  24. THE USE OR PERFORMANCE OF THIS SOFTWARE.
  25.  
  26. ********************************************************/
  27.  
  28. #include <stdio.h>
  29. #define NEED_REPLIES
  30. #define NEED_EVENTS
  31. #include "Xlib_private.h"
  32. #include <X11/extensions/XKBproto.h>
  33. #include "XKBlibint.h"
  34.  
  35. #if 0
  36. static xkbSetControlsReq *
  37. #if NeedFunctionPrototypes
  38. _XkbGetSetControlsReq(Display *dpy,XkbInfoPtr xkbi,unsigned int deviceSpec)
  39. #else
  40. _XkbGetSetControlsReq(dpy,xkbi,deviceSpec)
  41.     Display *        dpy;
  42.     XkbInfoPtr        xkbi;
  43.     unsigned int    deviceSpec;
  44. #endif
  45. {
  46.     DBUG_ENTER("_XkbGetSetControlsReq")
  47.     xkbSetControlsReq *req;
  48.  
  49.     GetReq(kbSetControls,req);
  50.     bzero(req,SIZEOF(xkbSetControlsReq));
  51.     req->reqType = xkbi->codes->major_opcode;
  52.     req->length = (SIZEOF(xkbSetControlsReq)>>2);
  53.     req->xkbReqType = X_kbSetControls;
  54.     req->deviceSpec = deviceSpec;
  55.     DBUG_RETURN(req);
  56. }
  57.  
  58. Bool 
  59. #if NeedFunctionPrototypes
  60. XkbSetAutoRepeatRate(    Display *dpy,
  61.             unsigned int deviceSpec, 
  62.             unsigned int timeout, 
  63.             unsigned int interval)
  64. #else
  65. XkbSetAutoRepeatRate(dpy, deviceSpec, timeout, interval)
  66.     Display *dpy;
  67.     unsigned int deviceSpec;
  68.     unsigned int timeout;
  69.     unsigned int interval;
  70. #endif
  71. {
  72.     DBUG_ENTER("XkbSetAutoRepeatRate")
  73.     register xkbSetControlsReq *req;
  74.  
  75.     if ((dpy->flags & XlibDisplayNoXkb) ||
  76.     (!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
  77.     DBUG_RETURN(False);
  78.     LockDisplay(dpy);
  79.     req= _XkbGetSetControlsReq(dpy,dpy->xkb_info,deviceSpec);
  80.     req->changeCtrls = XkbRepeatKeysMask;
  81.     req->repeatDelay = timeout;
  82.     req->repeatInterval = interval;
  83.     UnlockDisplay(dpy);
  84.     SyncHandle();
  85.     DBUG_RETURN(True);
  86. }
  87.  
  88. Bool 
  89. #if NeedFunctionPrototypes
  90. XkbGetAutoRepeatRate(    Display *    dpy,
  91.             unsigned int     deviceSpec,
  92.             unsigned int *    timeoutp,
  93.             unsigned int *    intervalp)
  94. #else
  95. XkbGetAutoRepeatRate(dpy, deviceSpec, timeoutp, intervalp)
  96.     Display *dpy;
  97.     unsigned int deviceSpec;
  98.     unsigned int *timeoutp;
  99.     unsigned int *intervalp;
  100. #endif
  101. {
  102.     DBUG_ENTER("XkbGetAutoRepeatRate")
  103.     register xkbGetControlsReq *req;
  104.     xkbGetControlsReply rep;
  105.     XkbInfoPtr xkbi;
  106.  
  107.     if ((dpy->flags & XlibDisplayNoXkb) ||
  108.     (!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
  109.     DBUG_RETURN(False);
  110.     LockDisplay(dpy);
  111.     xkbi = dpy->xkb_info;
  112.     GetReq(kbGetControls, req);
  113.     req->reqType = xkbi->codes->major_opcode;
  114.     req->xkbReqType = X_kbGetControls;
  115.     req->deviceSpec = deviceSpec;
  116.     if (!_XReply(dpy, (xReply *)&rep, 
  117.         (SIZEOF(xkbGetControlsReply)-SIZEOF(xReply))>>2, xFalse)) {
  118.     UnlockDisplay(dpy);
  119.     SyncHandle();
  120.     DBUG_RETURN(False);
  121.     }
  122.     UnlockDisplay(dpy);
  123.     SyncHandle();
  124.     *timeoutp = rep.repeatDelay;
  125.     *intervalp = rep.repeatInterval;
  126.     DBUG_RETURN(True);
  127. }
  128.  
  129. Bool
  130. #if NeedFunctionPrototypes
  131. XkbSetServerInternalMods(    Display *    dpy,
  132.                 unsigned     deviceSpec,
  133.                 unsigned     affectReal,
  134.                 unsigned     realValues,
  135.                 unsigned     affectVirtual,
  136.                 unsigned     virtualValues)
  137. #else
  138. XkbSetServerInternalMods(dpy,deviceSpec,
  139.                  affectReal,realValues,affectVirtual,virtualValues)
  140.     Display *dpy;
  141.     unsigned deviceSpec;
  142.     unsigned affectReal;
  143.     unsigned realValues;
  144.     unsigned affectVirtual;
  145.     unsigned virtualValues;
  146. #endif
  147. {
  148.     DBUG_ENTER("XkbSetServerInternalMods")
  149.     register xkbSetControlsReq *req;
  150.  
  151.     if ((dpy->flags & XlibDisplayNoXkb) ||
  152.     (!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
  153.     DBUG_RETURN(False);
  154.     LockDisplay(dpy);
  155.     req= _XkbGetSetControlsReq(dpy,dpy->xkb_info,deviceSpec);
  156.     req->affectInternalMods = affectReal;
  157.     req->internalMods = realValues;
  158.     req->affectInternalVMods= affectVirtual;
  159.     req->internalVMods= virtualValues;
  160.     req->changeCtrls = XkbInternalModsMask;
  161.     UnlockDisplay(dpy);
  162.     SyncHandle();
  163.     DBUG_RETURN(True);
  164. }
  165.  
  166. Bool
  167. #if NeedFunctionPrototypes
  168. XkbSetIgnoreLockMods(    Display *    dpy,
  169.             unsigned int     deviceSpec,
  170.             unsigned     affectReal,
  171.             unsigned     realValues,
  172.             unsigned     affectVirtual,
  173.             unsigned     virtualValues)
  174. #else
  175. XkbSetIgnoreLockMods(dpy,deviceSpec,
  176.              affectReal,realValues,affectVirtual,virtualValues)
  177.     Display *dpy;
  178.     unsigned int deviceSpec;
  179.     unsigned affectReal;
  180.     unsigned realValues;
  181.     unsigned affectVirtual;
  182.     unsigned virtualValues;
  183. #endif
  184. {
  185.     DBUG_ENTER("XkbSetIgnoreLockMods")
  186.     register xkbSetControlsReq *req;
  187.  
  188.     if ((dpy->flags & XlibDisplayNoXkb) ||
  189.     (!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
  190.     DBUG_RETURN(False);
  191.     LockDisplay(dpy);
  192.     req= _XkbGetSetControlsReq(dpy,dpy->xkb_info,deviceSpec);
  193.     req->affectIgnoreLockMods= affectReal;
  194.     req->ignoreLockMods = realValues;
  195.     req->affectIgnoreLockVMods= affectVirtual;
  196.     req->ignoreLockVMods= virtualValues;
  197.     req->changeCtrls = XkbIgnoreLockModsMask;
  198.     UnlockDisplay(dpy);
  199.     SyncHandle();
  200.     DBUG_RETURN(True);
  201. }
  202.  
  203. Bool
  204. #if NeedFunctionPrototypes
  205. XkbChangeEnabledControls(    Display *    dpy,
  206.                 unsigned    deviceSpec,
  207.                 unsigned    affect,
  208.                 unsigned    values)
  209. #else
  210. XkbChangeEnabledControls(dpy,deviceSpec,affect,values)
  211.     Display *    dpy;
  212.     unsigned    deviceSpec;
  213.     unsigned    affect;
  214.     unsigned    values;
  215. #endif
  216. {
  217.     DBUG_ENTER("XkbChangeEnabledControls")
  218.     register xkbSetControlsReq *req;
  219.  
  220.     if ((dpy->flags & XlibDisplayNoXkb) ||
  221.     (!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
  222.     DBUG_RETURN(False);
  223.     LockDisplay(dpy);
  224.     req= _XkbGetSetControlsReq(dpy,dpy->xkb_info,deviceSpec);
  225.     req->affectEnabledCtrls= affect;
  226.     req->enabledCtrls= (affect&values);
  227.     req->changeCtrls = XkbControlsEnabledMask;
  228.     UnlockDisplay(dpy);
  229.     SyncHandle();
  230.     DBUG_RETURN(True);
  231. }
  232.  
  233. Status 
  234. #if NeedFunctionPrototypes
  235. XkbGetControls(Display *dpy, unsigned long which, XkbDescPtr xkb)
  236. #else
  237. XkbGetControls(dpy, which, xkb)
  238.     Display *dpy;
  239.     unsigned long which;
  240.     XkbDescPtr xkb;
  241. #endif
  242. {
  243.     DBUG_ENTER("XkbGetControls")
  244.     register xkbGetControlsReq *req;
  245.     xkbGetControlsReply rep;
  246.     XkbControlsPtr    ctrls;
  247.     XkbInfoPtr xkbi;
  248.  
  249.     if ((dpy->flags & XlibDisplayNoXkb) ||
  250.     (!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
  251.     DBUG_RETURN(BadAccess);
  252.     if ((!xkb) || (!which))
  253.     DBUG_RETURN(BadMatch);
  254.  
  255.     LockDisplay(dpy);
  256.     xkbi = dpy->xkb_info;
  257.     GetReq(kbGetControls, req);
  258.     if (!xkb->ctrls)  {
  259.     xkb->ctrls = _XkbTypedCalloc(1,XkbControlsRec);
  260.     if (!xkb->ctrls) {
  261.         UnlockDisplay(dpy);
  262.         SyncHandle();
  263.         DBUG_RETURN(BadAlloc);
  264.     } 
  265.     }
  266.     req->reqType = xkbi->codes->major_opcode;
  267.     req->xkbReqType = X_kbGetControls;
  268.     req->deviceSpec = xkb->device_spec;
  269.     if (!_XReply(dpy, (xReply *)&rep, 
  270.         (SIZEOF(xkbGetControlsReply)-SIZEOF(xReply))>>2, xFalse)) {
  271.     UnlockDisplay(dpy);
  272.     SyncHandle();
  273.     DBUG_RETURN(BadImplementation);
  274.     }
  275.     if (xkb->device_spec==XkbUseCoreKbd)
  276.     xkb->device_spec= rep.deviceID;
  277.     ctrls= xkb->ctrls;
  278.     if (which&XkbControlsEnabledMask)
  279.     ctrls->enabled_ctrls = rep.enabledCtrls;
  280.     ctrls->num_groups= rep.numGroups;
  281.     if (which&XkbGroupsWrapMask)
  282.     ctrls->groups_wrap= rep.groupsWrap;
  283.     if (which&XkbInternalModsMask) {
  284.     ctrls->internal.mask = rep.internalMods;
  285.     ctrls->internal.real_mods = rep.internalRealMods;
  286.     ctrls->internal.vmods = rep.internalVMods;
  287.     }
  288.     if (which&XkbIgnoreLockModsMask) {
  289.     ctrls->ignore_lock.mask = rep.ignoreLockMods;
  290.     ctrls->ignore_lock.real_mods = rep.ignoreLockRealMods;
  291.     ctrls->ignore_lock.vmods = rep.ignoreLockVMods;
  292.     }
  293.     if (which&XkbRepeatKeysMask) {
  294.     ctrls->repeat_delay = rep.repeatDelay;
  295.     ctrls->repeat_interval = rep.repeatInterval;
  296.     }
  297.     if (which&XkbSlowKeysMask)
  298.     ctrls->slow_keys_delay = rep.slowKeysDelay;
  299.     if (which&XkbBounceKeysMask)
  300.     ctrls->debounce_delay = rep.debounceDelay;
  301.     if (which&XkbMouseKeysMask) {
  302.     ctrls->mk_dflt_btn = rep.mkDfltBtn;
  303.     }
  304.     if (which&XkbMouseKeysAccelMask) {
  305.     ctrls->mk_delay = rep.mkDelay;
  306.     ctrls->mk_interval = rep.mkInterval;
  307.     ctrls->mk_time_to_max = rep.mkTimeToMax;
  308.     ctrls->mk_max_speed = rep.mkMaxSpeed;
  309.     ctrls->mk_curve = rep.mkCurve;
  310.     }
  311.     if (which&XkbAccessXKeysMask)
  312.     ctrls->ax_options= rep.axOptions;
  313.     if (which&XkbAccessXTimeoutMask) {
  314.     ctrls->ax_timeout = rep.axTimeout;
  315.     ctrls->axt_ctrls_mask = rep.axtCtrlsMask;
  316.     ctrls->axt_ctrls_values = rep.axtCtrlsValues;
  317.     ctrls->axt_opts_mask = rep.axtOptsMask;
  318.     ctrls->axt_opts_values= rep.axtOptsValues;
  319.     }
  320.     if (which&XkbPerKeyRepeatMask) {
  321.        memcpy(ctrls->per_key_repeat,rep.perKeyRepeat,
  322.                       XkbPerKeyBitArraySize); 
  323.     }
  324.     UnlockDisplay(dpy);
  325.     SyncHandle();
  326.     DBUG_RETURN(Success);
  327. }
  328.  
  329. Bool 
  330. #if NeedFunctionPrototypes
  331. XkbSetControls(Display *dpy, unsigned long which, XkbDescPtr xkb)
  332. #else
  333. XkbSetControls(dpy, which, xkb)
  334.     Display *        dpy;
  335.     unsigned long     which;
  336.     XkbDescPtr        xkb;
  337. #endif
  338. {
  339.     DBUG_ENTER("XkbSetControls")
  340.     register xkbSetControlsReq *req;
  341.     XkbControlsPtr    ctrls;
  342.  
  343.     if ((dpy->flags & XlibDisplayNoXkb) ||
  344.     (!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
  345.     DBUG_RETURN(False);
  346.     if ((!xkb)||(!xkb->ctrls))
  347.     DBUG_RETURN(False);
  348.  
  349.     ctrls= xkb->ctrls;
  350.     LockDisplay(dpy);
  351.     req= _XkbGetSetControlsReq(dpy,dpy->xkb_info,xkb->device_spec);
  352.     req->changeCtrls = (CARD32)which;
  353.     if (which&XkbInternalModsMask) {
  354.     req->affectInternalMods= ~0;
  355.     req->internalMods= ctrls->internal.real_mods;
  356.     req->affectInternalVMods = ~0;
  357.     req->internalVMods= ctrls->internal.vmods;
  358.     }
  359.     if (which&XkbIgnoreLockModsMask) {
  360.     req->affectIgnoreLockMods= ~0;
  361.     req->ignoreLockMods= ctrls->ignore_lock.real_mods;
  362.     req->affectIgnoreLockVMods= ~0;
  363.     req->ignoreLockVMods= ctrls->ignore_lock.vmods;
  364.     }
  365.     if (which&XkbControlsEnabledMask) {
  366.     req->affectEnabledCtrls= XkbAllBooleanCtrlsMask;
  367.     req->enabledCtrls= ctrls->enabled_ctrls;
  368.     }
  369.     if (which&XkbRepeatKeysMask) {
  370.     req->repeatDelay = ctrls->repeat_delay;
  371.     req->repeatInterval = ctrls->repeat_interval;
  372.     }
  373.     if (which&XkbSlowKeysMask)
  374.      req->slowKeysDelay = ctrls->slow_keys_delay;
  375.     if (which&XkbBounceKeysMask)
  376.      req->debounceDelay = ctrls->debounce_delay;
  377.     if (which&XkbMouseKeysMask) {
  378.     req->mkDfltBtn = ctrls->mk_dflt_btn;
  379.     }
  380.     if (which&XkbGroupsWrapMask)
  381.     req->groupsWrap= ctrls->groups_wrap;
  382.     if (which&(XkbAccessXKeysMask|XkbStickyKeysMask|XkbAccessXFeedbackMask))
  383.     req->axOptions= ctrls->ax_options;
  384.     if (which&XkbMouseKeysAccelMask) {
  385.     req->mkDelay = ctrls->mk_delay;
  386.     req->mkInterval = ctrls->mk_interval;
  387.     req->mkTimeToMax = ctrls->mk_time_to_max;
  388.     req->mkMaxSpeed = ctrls->mk_max_speed;
  389.     req->mkCurve = ctrls->mk_curve;
  390.     }
  391.     if (which&XkbAccessXTimeoutMask) {
  392.      req->axTimeout = ctrls->ax_timeout;
  393.      req->axtCtrlsMask = ctrls->axt_ctrls_mask;
  394.      req->axtCtrlsValues = ctrls->axt_ctrls_values;
  395.      req->axtOptsMask = ctrls->axt_opts_mask;
  396.      req->axtOptsValues=ctrls->axt_opts_values;
  397.     }
  398.     if (which&XkbPerKeyRepeatMask) {
  399.     memcpy(req->perKeyRepeat,ctrls->per_key_repeat,
  400.                     XkbPerKeyBitArraySize);
  401.     }
  402.     UnlockDisplay(dpy);
  403.     SyncHandle();
  404.     DBUG_RETURN(False);
  405. }
  406. #endif
  407. /***====================================================================***/
  408.  
  409. void
  410. #if NeedFunctionPrototypes
  411. XkbNoteControlsChanges(    XkbControlsChangesPtr        old,
  412.             XkbControlsNotifyEvent *    new,
  413.             unsigned int             wanted)
  414. #else
  415. XkbNoteControlsChanges(old,new,wanted)
  416.     XkbControlsChangesPtr    old;
  417.     XkbControlsNotifyEvent *    new;
  418.     unsigned int         wanted;
  419. #endif
  420. {
  421.     DBUG_ENTER("XkbNoteControlsChanges")
  422.     old->changed_ctrls|= (new->changed_ctrls&wanted);
  423.     if (new->changed_ctrls&XkbControlsEnabledMask&wanted)
  424.     old->enabled_ctrls_changes^= new->enabled_ctrl_changes;
  425.     /* num_groups_changed?? */
  426.     DBUG_VOID_RETURN;
  427. }
  428.