GNU.WIKI: The GNU/Linux Knowledge Base

  [HOME] [PHP Manual] [HowTo] [ABS] [MAN1] [MAN2] [MAN3] [MAN4] [MAN5] [MAN6] [MAN7] [MAN8] [MAN9]

  [0-9] [Aa] [Bb] [Cc] [Dd] [Ee] [Ff] [Gg] [Hh] [Ii] [Jj] [Kk] [Ll] [Mm] [Nn] [Oo] [Pp] [Qq] [Rr] [Ss] [Tt] [Uu] [Vv] [Ww] [Xx] [Yy] [Zz]


NAME

       XkbKeyTypesForCoreSymbols - Determine the Xkb key types appropriate for
       the symbols bound to a key in a core keyboard mapping

SYNOPSIS

       int XkbKeyTypesForCoreSymbols (XkbDescPtr xkb,  int  map_width,  KeySym
              *core_syms,  unsigned  int  protected,  int *types_inout, KeySym
              *xkb_syms_rtrn);

ARGUMENTS

       - xkb  keyboard description in which to place symbols

       - map_width
              width of core protocol keymap in xkb_syms_rtrn

       - core_syms
              core protocol format array of KeySyms

       - protected
              explicit key types

       - types_inout
              backfilled with the canonical types bound to groups one and  two
              for the key

       - xkb_syms_rtrn
              backfilled with symbols bound to the key in the Xkb mapping

DESCRIPTION

       XkbKeyTypesForCoreSymbols expands the symbols in core_syms and types in
       types_inout, then chooses canonical key types (canonical key types  are
       defined  The  Canonical  Key  Types) for groups 1 and 2 using the rules
       specified by the Xkb protocol and places them in  xkb_syms_rtrn,  which
       will be non-NULL.

       The Canonical Key Types

       Xkb  allows  up  to  XkbMaxKeyTypes  (255) key types to be defined, but
       requires at least XkbNumRequiredTypes (4) predefined types to be  in  a
       key  map.  These  predefined key types are referred to as the canonical
       key types and describe the types of keys available on  most  keyboards.
       The  definitions  for  the  canonical  key  types are held in the first
       XkbNumRequiredTypes entries of the types field of the  client  map  and
       are indexed using the following constants:

           XkbOneLevelIndex
           XkbTwoLevelIndex
           XkbAlphabeticIndex
           XkbKeypadIndex

       ONE_LEVEL

       The  ONE_LEVEL key type describes groups that have only one symbol. The
       default ONE_LEVEL key  type  has  no  map  entries  and  does  not  pay
       attention  to any modifiers. A symbolic representation of this key type
       could look like the following:

           type "ONE_LEVEL" {
                modifiers = None;
                map[None]= Level1;
                level_name[Level1]= "Any";
           };

       The  description  of  the  ONE_LEVEL  key  type  is   stored   in   the
       types[XkbOneLevelIndex] entry of the client key map.

       TWO_LEVEL

       The TWO_LEVEL key type describes groups that consist of two symbols but
       are neither alphabetic nor numeric keypad keys. The  default  TWO_LEVEL
       type  uses only the Shift modifier. It returns shift level two if Shift
       is set, and level one if it is not. A symbolic representation  of  this
       key type could look like the following:

           type "TWO_LEVEL" {
               modifiers = Shift;
               map[Shift]= Level2;
               level_name[Level1]= "Base";
               level_name[Level2]= "Shift";
           };

       The   description   of   the  TWO_LEVEL  key  type  is  stored  in  the
       types[XkbTwoLevelIndex] entry of the client key map.

       ALPHABETIC

       The ALPHABETIC key type describes groups consisting of two symbols: the
       lowercase  form  of a symbol followed by the uppercase form of the same
       symbol.  The default ALPHABETIC type implements locale-sensitive "Shift
       cancels  CapsLock"  behavior using both the Shift and Lock modifiers as
       follows:

       ·    If Shift and Lock are both set, the default ALPHABETIC type yields
            level one.

       ·    If Shift alone is set, it yields level two.

       ·    If  Lock alone is set, it yields level one, but preserves the Lock
            modifier   so   Xlib   notices   and   applies   the   appropriate
            capitalization  rules. The Xlib functions are locale-sensitive and
            apply different capitalization rules for different locales.

       ·    If neither Shift nor Lock is set, it yields level one.

            A symbolic representation of this key type  could  look  like  the
            following:

                type "ALPHABETIC" {
                    modifiers = Shift+Lock;
                    map[Shift]= Level2;
                    preserve[Lock]= Lock;
                    level_name[Level1]= "Base";
                    level_name[Level2]= "Caps";
                };

            The  description  of  the  ALPHABETIC  key  type  is stored in the
            types[XkbAlphabeticIndex] entry of the client key map.

            KEYPAD

            The KEYPAD key type describes groups that consist of two  symbols,
            at  least  one  of  which  is a numeric keypad symbol. The numeric
            keypad symbol is assumed to  reside  at  level  two.  The  default
            KEYPAD  key type implements "Shift cancels NumLock" behavior using
            the Shift modifier and the real  modifier  bound  to  the  virtual
            modifier  named  "NumLock,"  known  as  the  NumLock  modifier, as
            follows:

       ·    If Shift and NumLock are both set, the default KEYPAD type  yields
            level one.

       ·    If Shift alone is set, it yields level two.

       ·    If NumLock alone is set, it yields level two.

       ·    If neither Shift nor NumLock is set, it yields level one.

            A  symbolic  representation  of  this key type could look like the
            following:

                type "KEYPAD" {
                    modifiers = Shift+NumLock;
                    map[None]= Level1;
                    map[Shift]= Level2;
                    map[NumLock]= Level2;
                    map[Shift+NumLock]= Level1;
                    level_name[Level1]= "Base";
                    level_name[Level2]= "Caps";
                };

            The  description  of  the  KEYPAD  key  type  is  stored  in   the
            types[XkbKeypadIndex] entry of the client key map.

            A  core  keymap  is  a  two-dimensional  array  of keysyms. It has
            map_width       columns       and        max_key_code        rows.
            XkbKeyTypesForCoreSymbols  takes  a single row from a core keymap,
            determines the number of groups associated with it,  the  type  of
            each group, and the symbols bound to each group.  The return value
            is the number of groups, types_inout has the types for each group,
            and  xkb_syms_rtrn  has  the symbols in Xkb order (that is, groups
            are contiguous, regardless of size).

            protected contains the explicitly protected key  types.  There  is
            one   explicit  override  control associated with each of the four
            possible  groups  for  each  Xkb  key,  ExplicitKeyType1   through
            ExplicitKeyType4;  protected is an inclusive OR of these controls.
            map_width is the width of the core keymap and is not dependent  on
            any  Xkb  definitions.   types_inout  is  an  array  of  four type
            indices. On input, types_inout contains the indices of  any  types
            already assigned to the key, in case they are explicitly protected
            from change.

            Upon return, types_inout contains any automatically selected (that
            is, canonical) types plus any protected types. Canonical types are
            assigned to all four groups if there are enough symbols to do  so.
            The  four entries in types_inout correspond to the four groups for
            the key in question.



  All copyrights belong to their respective owners. Other content (c) 2014-2018, GNU.WIKI. Please report site errors to webmaster@gnu.wiki.
Page load time: 0.113 seconds. Last modified: November 04 2018 12:49:43.