home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / evbl0627.zip / everblue_20010627.zip / x11 / XKBUse.c < prev    next >
C/C++ Source or Header  |  1999-11-02  |  23KB  |  710 lines
  1. /* $XConsortium: XKBUse.c /main/15 1996/09/28 16:34:51 rws $ */
  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. #include <ctype.h>
  30. #define NEED_REPLIES
  31. #define NEED_EVENTS
  32. #include "Xlib_private.h"
  33. #include <X11/extensions/XKBproto.h>
  34. #include "XKBlibint.h"
  35.  
  36. #ifdef X_NOT_STDC_ENV
  37. extern char *getenv();
  38. #endif
  39.  
  40. static Bool    _XkbIgnoreExtension = False;
  41.  
  42. void
  43. #if NeedFunctionPrototypes
  44. XkbNoteMapChanges(XkbMapChangesPtr old,XkbMapNotifyEvent *new,unsigned wanted)
  45. #else
  46. XkbNoteMapChanges(old,new,wanted)
  47.     XkbMapChangesPtr    old;
  48.     XkbMapNotifyEvent *    new;
  49.     unsigned int    wanted;
  50. #endif
  51. {
  52.     DBUG_ENTER("XkbNoteMapChanges")
  53.     int first,oldLast,newLast;
  54.     wanted&= new->changed;
  55.  
  56.     if (wanted&XkbKeyTypesMask) {
  57.     if (old->changed&XkbKeyTypesMask) {
  58.         first = old->first_type;
  59.         oldLast = old->first_type+old->num_types-1;
  60.         newLast = new->first_type+new->num_types-1;
  61.  
  62.         if (new->first_type<first)
  63.         first = new->first_type;
  64.         if (oldLast>newLast)
  65.         newLast= oldLast;
  66.         old->first_type = first;
  67.         old->num_types = newLast-first+1;
  68.     }
  69.     else {
  70.         old->first_type= new->first_type;
  71.         old->num_types = new->num_types;
  72.     }
  73.     }
  74.     if (wanted&XkbKeySymsMask) {
  75.     if (old->changed&XkbKeySymsMask) {
  76.         first = old->first_key_sym;
  77.         oldLast = old->first_key_sym+old->num_key_syms-1;
  78.         newLast = new->first_key_sym+new->num_key_syms-1;
  79.  
  80.         if (new->first_key_sym<first)
  81.         first = new->first_key_sym;
  82.         if (oldLast>newLast)
  83.         newLast= oldLast;
  84.         old->first_key_sym = first;
  85.         old->num_key_syms = newLast-first+1;
  86.     }
  87.     else {
  88.         old->first_key_sym = new->first_key_sym;
  89.         old->num_key_syms = new->num_key_syms;
  90.     }
  91.     }
  92.     if (wanted&XkbKeyActionsMask) {
  93.     if (old->changed&XkbKeyActionsMask) {
  94.         first = old->first_key_act;
  95.         oldLast = old->first_key_act+old->num_key_acts-1;
  96.         newLast = new->first_key_act+new->num_key_acts-1;
  97.  
  98.         if (new->first_key_act<first)
  99.         first = new->first_key_act;
  100.         if (oldLast>newLast)
  101.         newLast= oldLast;
  102.         old->first_key_act = first;
  103.         old->num_key_acts = newLast-first+1;
  104.     }
  105.     else {
  106.         old->first_key_act = new->first_key_act;
  107.         old->num_key_acts = new->num_key_acts;
  108.     }
  109.     }
  110.     if (wanted&XkbKeyBehaviorsMask) {
  111.     if (old->changed&XkbKeyBehaviorsMask) {
  112.         first = old->first_key_behavior;
  113.         oldLast = old->first_key_behavior+old->num_key_behaviors-1;
  114.         newLast = new->first_key_behavior+new->num_key_behaviors-1;
  115.  
  116.         if (new->first_key_behavior<first)
  117.         first = new->first_key_behavior;
  118.         if (oldLast>newLast)
  119.         newLast= oldLast;
  120.         old->first_key_behavior = first;
  121.         old->num_key_behaviors = newLast-first+1;
  122.     }
  123.     else {
  124.         old->first_key_behavior = new->first_key_behavior;
  125.         old->num_key_behaviors = new->num_key_behaviors;
  126.     }
  127.     }
  128.     if (wanted&XkbVirtualModsMask) {
  129.     old->vmods|= new->vmods;
  130.     }
  131.     if (wanted&XkbExplicitComponentsMask) {
  132.     if (old->changed&XkbExplicitComponentsMask) {
  133.         first = old->first_key_explicit;
  134.         oldLast = old->first_key_explicit+old->num_key_explicit-1;
  135.         newLast = new->first_key_explicit+new->num_key_explicit-1;
  136.  
  137.         if (new->first_key_explicit<first)
  138.         first = new->first_key_explicit;
  139.         if (oldLast>newLast)
  140.         newLast= oldLast;
  141.         old->first_key_explicit = first;
  142.         old->num_key_explicit = newLast-first+1;
  143.     }
  144.     else {
  145.         old->first_key_explicit = new->first_key_explicit;
  146.         old->num_key_explicit = new->num_key_explicit;
  147.     }
  148.     }
  149.     if (wanted&XkbModifierMapMask) {
  150.     if (old->changed&XkbModifierMapMask) {
  151.         first = old->first_modmap_key;
  152.         oldLast = old->first_modmap_key+old->num_modmap_keys-1;
  153.         newLast = new->first_modmap_key+new->num_modmap_keys-1;
  154.  
  155.         if (new->first_modmap_key<first)
  156.         first = new->first_modmap_key;
  157.         if (oldLast>newLast)
  158.         newLast= oldLast;
  159.         old->first_modmap_key = first;
  160.         old->num_modmap_keys = newLast-first+1;
  161.     }
  162.     else {
  163.         old->first_modmap_key = new->first_modmap_key;
  164.         old->num_modmap_keys = new->num_modmap_keys;
  165.     }
  166.     }
  167.     if (wanted&XkbVirtualModMapMask) {
  168.     if (old->changed&XkbVirtualModMapMask) {
  169.         first = old->first_vmodmap_key;
  170.         oldLast = old->first_vmodmap_key+old->num_vmodmap_keys-1;
  171.         newLast = new->first_vmodmap_key+new->num_vmodmap_keys-1;
  172.  
  173.         if (new->first_vmodmap_key<first)
  174.         first = new->first_vmodmap_key;
  175.         if (oldLast>newLast)
  176.         newLast= oldLast;
  177.         old->first_vmodmap_key = first;
  178.         old->num_vmodmap_keys = newLast-first+1;
  179.     }
  180.     else {
  181.         old->first_vmodmap_key = new->first_vmodmap_key;
  182.         old->num_vmodmap_keys = new->num_vmodmap_keys;
  183.     }
  184.     }
  185.     old->changed|= wanted;
  186.     DBUG_VOID_RETURN;
  187. }
  188.  
  189. void
  190. #if NeedFunctionPrototypes
  191. _XkbNoteCoreMapChanges(    XkbMapChangesPtr     old,
  192.             XMappingEvent *     new,
  193.             unsigned int         wanted)
  194. #else
  195. _XkbNoteCoreMapChanges(old,new,wanted)
  196.     XkbMapChangesPtr    old;
  197.     XMappingEvent *    new;
  198.     unsigned int    wanted;
  199. #endif
  200. {
  201.     DBUG_ENTER("_XkbNoteCoreMapChanges")
  202.     int first,oldLast,newLast;
  203.  
  204.     if ((new->request==MappingKeyboard)&&(wanted&XkbKeySymsMask)) {
  205.     if (old->changed&XkbKeySymsMask) {
  206.         first = old->first_key_sym;
  207.         oldLast = old->first_key_sym+old->num_key_syms-1;
  208.         newLast = new->first_keycode+new->count-1;
  209.  
  210.         if (new->first_keycode<first)
  211.         first = new->first_keycode;
  212.         if (oldLast>newLast)
  213.         newLast= oldLast;
  214.         old->first_key_sym = first;
  215.         old->num_key_syms = newLast-first+1;
  216.     }
  217.     else {
  218.         old->changed|= XkbKeySymsMask;
  219.         old->first_key_sym = new->first_keycode;
  220.         old->num_key_syms = new->count;
  221.     }
  222.     }
  223.     DBUG_VOID_RETURN;
  224. }
  225.  
  226. static Bool
  227. #if NeedFunctionPrototypes
  228. wire_to_event(Display *dpy,XEvent *re,xEvent *event)
  229. #else
  230. wire_to_event(dpy,re,event)
  231.     Display *dpy;
  232.     XEvent *re;
  233.     xEvent *event;
  234. #endif
  235. {
  236.     DBUG_ENTER("wire_to_event")
  237.     xkbEvent *xkbevent= (xkbEvent *)event;
  238.     XkbInfoPtr xkbi;
  239.  
  240.     if ((dpy->flags & XlibDisplayNoXkb) ||
  241.     (!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
  242.     DBUG_RETURN(False);
  243.     xkbi = dpy->xkb_info;
  244.     if (((event->u.u.type&0x7f)-xkbi->codes->first_event)!=XkbEventCode)
  245.     DBUG_RETURN(False);
  246.  
  247.     switch (xkbevent->u.any.xkbType) {
  248.     case XkbStateNotify:
  249.         {
  250.         xkbStateNotify *sn = (xkbStateNotify *)event;
  251.         if ( xkbi->selected_events&XkbStateNotifyMask ) {
  252.             XkbStateNotifyEvent *sev=(XkbStateNotifyEvent *)re;
  253.             sev->type = XkbEventCode+xkbi->codes->first_event;
  254.             sev->xkb_type = XkbStateNotify;
  255.             sev->serial = _XSetLastRequestRead(dpy,
  256.                     (xGenericReply *)event);
  257.             sev->send_event = ((event->u.u.type & 0x80) != 0);
  258.             sev->display = dpy;
  259.             sev->time = sn->time; 
  260.             sev->device = sn->deviceID;
  261.             sev->keycode = sn->keycode;
  262.             sev->event_type = sn->eventType;
  263.             sev->req_major = sn->requestMajor;
  264.             sev->req_minor = sn->requestMinor;
  265.             sev->changed = sn->changed;
  266.             sev->group = sn->group;
  267.             sev->base_group = sn->baseGroup;
  268.             sev->latched_group = sn->latchedGroup;
  269.             sev->locked_group = sn->lockedGroup;
  270.             sev->mods = sn->mods;
  271.             sev->base_mods = sn->baseMods;
  272.             sev->latched_mods = sn->latchedMods;
  273.             sev->locked_mods = sn->lockedMods;
  274.             sev->compat_state = sn->compatState;
  275.             sev->grab_mods = sn->grabMods;
  276.             sev->compat_grab_mods = sn->compatGrabMods;
  277.             sev->lookup_mods = sn->lookupMods;
  278.             sev->compat_lookup_mods = sn->compatLookupMods;
  279.             sev->ptr_buttons = sn->ptrBtnState;
  280.             DBUG_RETURN(True);
  281.         }
  282.         }
  283.         break;
  284.     case XkbMapNotify:
  285.         {
  286.         xkbMapNotify *mn = (xkbMapNotify *)event;
  287.         if ((xkbi->selected_events&XkbMapNotifyMask)&&
  288.                 (xkbi->selected_map_details&mn->changed)) {
  289.             XkbMapNotifyEvent *mev;
  290.             mev =(XkbMapNotifyEvent *)re;
  291.             mev->type = XkbEventCode+xkbi->codes->first_event;
  292.             mev->xkb_type = XkbMapNotify;
  293.             mev->serial = _XSetLastRequestRead(dpy,
  294.                         (xGenericReply *)event);
  295.             mev->send_event = ((event->u.u.type&0x80)!=0);
  296.             mev->display = dpy;
  297.             mev->time = mn->time;
  298.             mev->device = mn->deviceID;
  299.             mev->changed =  mn->changed;
  300.             mev->min_key_code = mn->minKeyCode;
  301.             mev->max_key_code = mn->maxKeyCode;
  302.             mev->first_type = mn->firstType;
  303.             mev->num_types = mn->nTypes;
  304.             mev->first_key_sym = mn->firstKeySym;
  305.             mev->num_key_syms = mn->nKeySyms;
  306.             mev->first_key_act = mn->firstKeyAct;
  307.             mev->num_key_acts = mn->nKeyActs;
  308.             mev->first_key_behavior = mn->firstKeyBehavior;
  309.             mev->num_key_behaviors = mn->nKeyBehaviors;
  310.             mev->vmods = mn->virtualMods;
  311.             mev->first_key_explicit = mn->firstKeyExplicit;
  312.             mev->num_key_explicit = mn->nKeyExplicit;
  313.             mev->first_modmap_key = mn->firstModMapKey;
  314.             mev->num_modmap_keys = mn->nModMapKeys;
  315.             mev->first_vmodmap_key = mn->firstVModMapKey;
  316.             mev->num_vmodmap_keys = mn->nVModMapKeys;
  317.             XkbNoteMapChanges(&xkbi->changes,mev,XKB_XLIB_MAP_MASK);
  318.             if (xkbi->changes.changed)
  319.             xkbi->flags|= XkbMapPending;
  320.             DBUG_RETURN(True);
  321.         }
  322.         else if (mn->nKeySyms>0) {
  323.             register XMappingEvent *ev = (XMappingEvent *)re;
  324.             ev->type = MappingNotify;
  325.             ev->serial = _XSetLastRequestRead(dpy,
  326.                         (xGenericReply *)event);
  327.             ev->send_event = ((event->u.u.type&0x80)!=0);
  328.             ev->display = dpy;
  329.             ev->window = 0;
  330.             ev->first_keycode = mn->firstKeySym;
  331.             ev->request = MappingKeyboard;
  332.             ev->count = mn->nKeySyms;
  333.             _XkbNoteCoreMapChanges(&xkbi->changes,ev,XKB_XLIB_MAP_MASK);
  334.             if (xkbi->changes.changed)
  335.             xkbi->flags|= XkbMapPending;
  336.             DBUG_RETURN(True);
  337.         }
  338.         }
  339.         break;
  340.     case XkbControlsNotify:
  341.         {
  342.         if (xkbi->selected_events&XkbControlsNotifyMask) {
  343.             xkbControlsNotify *cn =(xkbControlsNotify *)event;
  344.             XkbControlsNotifyEvent *cev;
  345.             cev =(XkbControlsNotifyEvent *)re;
  346.             cev->type = XkbEventCode+xkbi->codes->first_event;
  347.             cev->xkb_type = XkbControlsNotify;
  348.             cev->serial = _XSetLastRequestRead(dpy,
  349.                         (xGenericReply *)event);
  350.             cev->send_event = ((event->u.u.type&0x80)!=0);
  351.             cev->display = dpy;
  352.             cev->time = cn->time;
  353.             cev->device = cn->deviceID;
  354.             cev->changed_ctrls =  cn->changedControls;
  355.             cev->enabled_ctrls =  cn->enabledControls;
  356.             cev->enabled_ctrl_changes = cn->enabledControlChanges;
  357.             cev->keycode = cn->keycode;
  358.             cev->num_groups = cn->numGroups;
  359.             cev->event_type = cn->eventType;
  360.             cev->req_major = cn->requestMajor;
  361.             cev->req_minor = cn->requestMinor;
  362.             DBUG_RETURN(True);
  363.         }
  364.         }
  365.         break;
  366.     case XkbIndicatorMapNotify:
  367.         {
  368.         if (xkbi->selected_events&XkbIndicatorMapNotifyMask) {
  369.             xkbIndicatorNotify *in =(xkbIndicatorNotify *)event;
  370.             XkbIndicatorNotifyEvent *iev;
  371.             iev =(XkbIndicatorNotifyEvent *)re;
  372.             iev->type = XkbEventCode+xkbi->codes->first_event;
  373.             iev->xkb_type = XkbIndicatorMapNotify;
  374.             iev->serial = _XSetLastRequestRead(dpy,
  375.                         (xGenericReply *)event);
  376.             iev->send_event = ((event->u.u.type&0x80)!=0);
  377.             iev->display = dpy;
  378.             iev->time = in->time;
  379.             iev->device = in->deviceID;
  380.             iev->changed =  in->changed;
  381.             iev->state=  in->state;
  382.             DBUG_RETURN(True);
  383.         }
  384.         }
  385.         break;
  386.     case XkbIndicatorStateNotify:
  387.         {
  388.         if (xkbi->selected_events&XkbIndicatorStateNotifyMask) {
  389.             xkbIndicatorNotify *in =(xkbIndicatorNotify *)event;
  390.             XkbIndicatorNotifyEvent *iev;
  391.             iev =(XkbIndicatorNotifyEvent *)re;
  392.             iev->type = XkbEventCode+xkbi->codes->first_event;
  393.             iev->xkb_type = XkbIndicatorStateNotify;
  394.             iev->serial = _XSetLastRequestRead(dpy,
  395.                         (xGenericReply *)event);
  396.             iev->send_event = ((event->u.u.type&0x80)!=0);
  397.             iev->display = dpy;
  398.             iev->time = in->time;
  399.             iev->device = in->deviceID;
  400.             iev->changed =  in->changed;
  401.             iev->state=  in->state;
  402.             DBUG_RETURN(True);
  403.         }
  404.         }
  405.         break;
  406.     case XkbBellNotify:
  407.         {
  408.         if (xkbi->selected_events&XkbBellNotifyMask) {
  409.             xkbBellNotify *bn =(xkbBellNotify *)event;
  410.             XkbBellNotifyEvent *bev;
  411.             bev =(XkbBellNotifyEvent *)re;
  412.             bev->type = XkbEventCode+xkbi->codes->first_event;
  413.             bev->xkb_type = XkbBellNotify;
  414.             bev->serial = _XSetLastRequestRead(dpy,
  415.                         (xGenericReply *)event);
  416.             bev->send_event = ((event->u.u.type&0x80)!=0);
  417.             bev->display = dpy;
  418.             bev->time = bn->time;
  419.             bev->device = bn->deviceID;
  420.             bev->percent = bn->percent;
  421.             bev->pitch = bn->pitch;
  422.             bev->duration = bn->duration;
  423.             bev->bell_class = bn->bellClass;
  424.             bev->bell_id = bn->bellID;
  425.             bev->name = bn->name;
  426.             bev->window = bn->window;
  427.             bev->event_only = bn->eventOnly;
  428.             DBUG_RETURN(True);
  429.         }
  430.         }
  431.         break;
  432.     case XkbAccessXNotify:
  433.         {
  434.         if (xkbi->selected_events&XkbAccessXNotifyMask) {
  435.             xkbAccessXNotify *axn =(xkbAccessXNotify *)event;
  436.             XkbAccessXNotifyEvent *axev;
  437.             axev =(XkbAccessXNotifyEvent *)re;
  438.             axev->type = XkbEventCode+xkbi->codes->first_event;
  439.             axev->xkb_type = XkbAccessXNotify;
  440.             axev->serial = _XSetLastRequestRead(dpy,
  441.                         (xGenericReply *)event);
  442.             axev->send_event = ((event->u.u.type&0x80)!=0);
  443.             axev->display = dpy;
  444.             axev->time = axn->time;
  445.             axev->device = axn->deviceID;
  446.             axev->detail = axn->detail;
  447.             axev->keycode = axn->keycode;
  448.             axev->sk_delay = axn->slowKeysDelay;
  449.             axev->debounce_delay = axn->debounceDelay;
  450.             DBUG_RETURN(True);
  451.         }
  452.         }
  453.         break;
  454.     case XkbNamesNotify:
  455.         {
  456.         if (xkbi->selected_events&XkbNamesNotifyMask) {
  457.             xkbNamesNotify *nn =(xkbNamesNotify *)event;
  458.             XkbNamesNotifyEvent *nev;
  459.             nev =(XkbNamesNotifyEvent *)re;
  460.             nev->type = XkbEventCode+xkbi->codes->first_event;
  461.             nev->xkb_type = XkbNamesNotify;
  462.             nev->serial = _XSetLastRequestRead(dpy,
  463.                         (xGenericReply *)event);
  464.             nev->send_event = ((event->u.u.type&0x80)!=0);
  465.             nev->display = dpy;
  466.             nev->time = nn->time;
  467.             nev->device = nn->deviceID;
  468.             nev->changed = nn->changed;
  469.             nev->first_type = nn->firstType;
  470.             nev->num_types = nn->nTypes;
  471.             nev->first_lvl = nn->firstLevelName;
  472.             nev->num_lvls = nn->nLevelNames;
  473.             nev->num_aliases = nn->nAliases;
  474.             nev->num_radio_groups = nn->nRadioGroups;
  475.             nev->changed_vmods = nn->changedVirtualMods;
  476.             nev->changed_groups = nn->changedGroupNames;
  477.             nev->changed_indicators = nn->changedIndicators;
  478.             nev->first_key = nn->firstKey;
  479.             nev->num_keys = nn->nKeys;
  480.             DBUG_RETURN(True);
  481.         }
  482.         }
  483.         break;
  484.     case XkbCompatMapNotify:
  485.         {
  486.         if (xkbi->selected_events&XkbCompatMapNotifyMask) {
  487.             xkbCompatMapNotify *cmn =(xkbCompatMapNotify *)event;
  488.             XkbCompatMapNotifyEvent *cmev;
  489.             cmev =(XkbCompatMapNotifyEvent *)re;
  490.             cmev->type = XkbEventCode+xkbi->codes->first_event;
  491.             cmev->xkb_type = XkbCompatMapNotify;
  492.             cmev->serial = _XSetLastRequestRead(dpy,
  493.                         (xGenericReply *)event);
  494.             cmev->send_event = ((event->u.u.type&0x80)!=0);
  495.             cmev->display = dpy;
  496.             cmev->time = cmn->time;
  497.             cmev->device = cmn->deviceID;
  498.             cmev->changed_groups = cmn->changedGroups;
  499.             cmev->first_si = cmn->firstSI;
  500.             cmev->num_si = cmn->nSI;
  501.             cmev->num_total_si = cmn->nTotalSI;
  502.             DBUG_RETURN(True);
  503.         }
  504.         }
  505.         break;
  506.     case XkbActionMessage:
  507.         {
  508.         if (xkbi->selected_events&XkbActionMessageMask) {
  509.             xkbActionMessage *am= (xkbActionMessage *)event;
  510.             XkbActionMessageEvent *amev;
  511.             amev= (XkbActionMessageEvent *)re;
  512.             amev->type = XkbEventCode+xkbi->codes->first_event;
  513.             amev->xkb_type = XkbActionMessage;
  514.             amev->serial = _XSetLastRequestRead(dpy,
  515.                         (xGenericReply *)event);
  516.             amev->send_event = ((event->u.u.type&0x80)!=0);
  517.             amev->display = dpy;
  518.             amev->time = am->time;
  519.             amev->device = am->deviceID;
  520.             amev->keycode = am->keycode;
  521.             amev->press = am->press;
  522.             amev->key_event_follows = am->keyEventFollows;
  523.             amev->group = am->group;
  524.             amev->mods = am->mods;
  525.             memcpy(amev->message,am->message,XkbActionMessageLength);
  526.             amev->message[XkbActionMessageLength]= '\0';
  527.             DBUG_RETURN(True);
  528.         }
  529.         }
  530.         break;
  531.     case XkbExtensionDeviceNotify:
  532.         {
  533.         if (xkbi->selected_events&XkbExtensionDeviceNotifyMask) {
  534.             xkbExtensionDeviceNotify *ed=
  535.                     (xkbExtensionDeviceNotify *)event;
  536.             XkbExtensionDeviceNotifyEvent *edev;
  537.             edev= (XkbExtensionDeviceNotifyEvent *)re;
  538.             edev->type= XkbEventCode+xkbi->codes->first_event;
  539.             edev->xkb_type= XkbExtensionDeviceNotify;
  540.             edev->serial= _XSetLastRequestRead(dpy,
  541.                         (xGenericReply *)event);
  542.             edev->send_event= ((event->u.u.type&0x80)!=0);
  543.             edev->display= dpy;
  544.             edev->time= ed->time;
  545.             edev->device= ed->deviceID;
  546.             edev->led_class= ed->ledClass;
  547.             edev->led_id= ed->ledID;
  548.             edev->reason= ed->reason;
  549.             edev->supported= ed->supported;
  550.             edev->leds_defined= ed->ledsDefined;
  551.             edev->led_state= ed->ledState;
  552.             edev->first_btn= ed->firstBtn;
  553.             edev->num_btns= ed->nBtns;
  554.             edev->unsupported= ed->unsupported;
  555.             DBUG_RETURN(True);
  556.         }
  557.         }
  558.         break;
  559.     case XkbNewKeyboardNotify:
  560.         {
  561.         xkbNewKeyboardNotify *nkn = (xkbNewKeyboardNotify *)event;
  562.         if ((xkbi->selected_events&XkbNewKeyboardNotifyMask)&&
  563.                     (xkbi->selected_nkn_details&nkn->changed)) {
  564.             XkbNewKeyboardNotifyEvent *nkev;
  565.             nkev =(XkbNewKeyboardNotifyEvent *)re;
  566.             nkev->type = XkbEventCode+xkbi->codes->first_event;
  567.             nkev->xkb_type = XkbNewKeyboardNotify;
  568.             nkev->serial = _XSetLastRequestRead(dpy,
  569.                         (xGenericReply *)event);
  570.             nkev->send_event = ((event->u.u.type&0x80)!=0);
  571.             nkev->display = dpy;
  572.             nkev->time = nkn->time;
  573.             nkev->device = nkn->deviceID;
  574.             nkev->old_device = nkn->oldDeviceID;
  575.             nkev->min_key_code = nkn->minKeyCode;
  576.             nkev->max_key_code = nkn->maxKeyCode;
  577.             nkev->old_min_key_code = nkn->oldMinKeyCode;
  578.             nkev->old_max_key_code = nkn->oldMaxKeyCode;
  579.             nkev->req_major = nkn->requestMajor;
  580.             nkev->req_minor = nkn->requestMinor;
  581.             nkev->changed = nkn->changed;
  582.             if ((xkbi->desc)&&(nkev->send_event==0)&&
  583.             ((xkbi->desc->device_spec==nkev->old_device)||
  584.              (nkev->device!=nkev->old_device))) {
  585.             xkbi->flags= XkbMapPending|XkbXlibNewKeyboard;
  586.             }
  587.             DBUG_RETURN(True);
  588.         }
  589.         else if(nkn->changed&(XkbNKN_KeycodesMask|XkbNKN_DeviceIDMask)){
  590.             register XMappingEvent *ev = (XMappingEvent *)re;
  591.             ev->type = MappingNotify;
  592.             ev->serial = _XSetLastRequestRead(dpy,
  593.                         (xGenericReply *)event);
  594.             ev->send_event = ((event->u.u.type&0x80)!=0);
  595.             ev->display = dpy;
  596.             ev->window = 0;
  597.             ev->first_keycode = dpy->min_keycode;
  598.             ev->request = MappingKeyboard;
  599.             ev->count = (dpy->max_keycode-dpy->min_keycode)+1;
  600.             if ((xkbi->desc)&&(ev->send_event==0)&&
  601.             ((xkbi->desc->device_spec==nkn->oldDeviceID)||
  602.              (nkn->deviceID!=nkn->oldDeviceID))) {
  603.             xkbi->flags|= XkbMapPending|XkbXlibNewKeyboard;
  604.             }
  605.             DBUG_RETURN(True);
  606.         }
  607.         }
  608.         break;
  609.     default:
  610. #ifdef DEBUG
  611.         fprintf(stderr,"Got unknown XKEYBOARD event (%d, base=%d)\n",
  612.                         re->type,
  613.                         xkbi->codes->first_event);
  614. #endif
  615.         break;
  616.     }
  617.     DBUG_RETURN(False);
  618. }
  619.  
  620. Bool
  621. #if NeedFunctionPrototypes
  622. XkbIgnoreExtension(Bool ignore)
  623. #else
  624. XkbIgnoreExtension(ignore)
  625.     Bool ignore;
  626. #endif
  627. {
  628.     DBUG_ENTER("XkbIgnoreExtension")
  629.     if (getenv("XKB_FORCE")!=NULL) {
  630. #ifdef DEBUG
  631.     fprintf(stderr,"Forcing use of XKEYBOARD (overriding an IgnoreExtensions)\n");
  632. #endif
  633.     DBUG_RETURN(False);
  634.     }
  635. #ifdef DEBUG
  636.     else if (getenv("XKB_DEBUG")!=NULL) {
  637.     fprintf(stderr,"Explicitly %signoring XKEYBOARD\n",ignore?"":"not ");
  638.     }
  639. #endif
  640.     _XkbIgnoreExtension = ignore;
  641.     DBUG_RETURN(True);
  642. }
  643.  
  644. static void
  645. #if NeedFunctionPrototypes
  646. _XkbFreeInfo(Display *dpy)
  647. #else
  648. _XkbFreeInfo(dpy)
  649.     Display *dpy;
  650. #endif
  651. {
  652.     DBUG_ENTER("_XkbFreeInfo")
  653.     XkbInfoPtr xkbi = dpy->xkb_info;
  654.     if (xkbi) {
  655.     if (xkbi->desc)
  656.         XkbFreeKeyboard(xkbi->desc,XkbAllComponentsMask,True);
  657.     Xfree(xkbi);
  658.       }
  659.     DBUG_VOID_RETURN;
  660. }
  661.  
  662. Bool
  663. #if NeedFunctionPrototypes
  664. XkbUseExtension(Display *dpy,int *major_rtrn,int *minor_rtrn)
  665. #else
  666. XkbUseExtension(dpy,major_rtrn,minor_rtrn)
  667.     Display *    dpy;
  668.     int *    major_rtrn;
  669.     int *    minor_rtrn;
  670. #endif
  671. {
  672.     DBUG_ENTER("XkbUseExtension")
  673.     xkbUseExtensionReply rep;
  674.     register xkbUseExtensionReq *req;
  675.     XExtCodes        *codes;
  676.     int    ev_base,forceIgnore;
  677.     XkbInfoPtr xkbi;
  678.     char *    str;
  679.     static int debugMsg;
  680.     static int been_here= 0;
  681.  
  682.     if ( dpy->xkb_info ) {
  683.     if (major_rtrn)    *major_rtrn= dpy->xkb_info->srv_major;
  684.     if (minor_rtrn)    *minor_rtrn= dpy->xkb_info->srv_minor;
  685.     DBUG_RETURN(True);
  686.     }
  687.     if (!been_here) {
  688.     debugMsg= (getenv("XKB_DEBUG")!=NULL);
  689.     been_here= 1;
  690.     }
  691.  
  692.     if (major_rtrn)    *major_rtrn= 0;
  693.     if (minor_rtrn)    *minor_rtrn= 0;
  694.  
  695.     forceIgnore= (dpy->flags&XlibDisplayNoXkb)||dpy->keysyms;
  696.     forceIgnore= forceIgnore&(major_rtrn==NULL)&&(minor_rtrn==NULL);
  697.     if ( forceIgnore || _XkbIgnoreExtension || getenv("XKB_DISABLE")) {
  698.     LockDisplay(dpy);
  699.     dpy->flags |= XlibDisplayNoXkb;
  700.     UnlockDisplay(dpy);
  701.     if (debugMsg)
  702.         fprintf(stderr,"XKEYBOARD extension disabled or missing\n");
  703.     DBUG_RETURN(False);
  704.     }
  705.  
  706.     fprintf(stderr,"XKEYBOARD extension not implemented\n");
  707.     DBUG_RETURN(False);
  708.  
  709. }
  710.