• Show log

    Commit

  • Hash : b0b11c4e
    Author : Ran Benita
    Date : 2012-08-02T00:29:07

    types: don't use canonical/required types
    
    Xkb required every keymap to have at least the four following canonical
    types: ONE_LEVEL, TWO_LEVEL, ALPHABETIC, KEYPAD. This is specified in
    e.g. the kbproto spec and XkbKeyTypesForCoreSymbols(3) man page.
    
    If these types are not specified in the keymap, the code specifically
    checks for them and adds them to the 4 first places in the types array,
    such that they exist in every keymap. These are also the types (along
    with some non-required 4-level ones) that are automatically assigned to
    keys which do not explicitly declare a type (see FindAutomaticType in
    symbols.c, this commit doesn't touch these heuristics, whcih are also not
    very nice but necessary).
    
    The xkeyboard-config does not rely on the builtin xkbcomp definitions of
    these types and does specify them explicitly, in types/basic and
    types/numpad, which are virtually always included.
    
    This commit removes the special behavior:
    - The code is ugly and makes keytypes.c harder to read.
    - The code practically never gets run - everyone who uses
      xkeyboard-config or a keymap based upon it (i.e. everyone) doesn't need
      it. So it doesn't get tested.
    - It mixes policy with implementation for not very good reasons, it
      seems mostly for default compatibility with X11 core.
    - And of course we don't need to remain compatible with Xkb ABI neither.
    
    Instead, if we read a keymap with no types specified at all, we simply
    assign all keys a default one-level type (like ONE_LEVEL), and issue
    plenty of warnings to make it clear (with verbosity >= 3). Note that
    this default can actually be changed from within the keymap, by writing
    something like
        type.modifier = Shift
        type.whatever_field = value
    in the top level of the xkb_types section. (This functionality is
    completely unused as well today, BTW, but makes some sense).
    
    This change means that if someone writes a keymap from scratch and
    doesn't add say ALPHABETIC, then something like <AE11> = { [ q Q ]; }; will
    ignore the second level. But as stated above this should never happen.
    
    Signed-off-by: Ran Benita <ran234@gmail.com>
    

  • Properties

  • Git HTTP https://git.kmx.io/kc3-lang/libxkbcommon.git
    Git SSH git@git.kmx.io:kc3-lang/libxkbcommon.git
    Public access ? public
    Description

    keymap handling library for toolkits and window systems

    Users
    thodg_m kc3_lang_org thodg_w www_kmx_io thodg thodg_l
    Tags

  • README

  • xkbcommon
    =========
    
    libxkbcommon is a keymap compiler and support library which processes a
    reduced subset of keymaps as defined by the XKB specification.  Primarily,
    a keymap is created from a set of Rules/Model/Layout/Variant/Options names,
    processed through an XKB ruleset, and compiled into a struct xkb_keymap,
    which is the base type for all xkbcommon operations.
    
    From an xkb_keymap, an xkb_state object is created which holds the current
    state of all modifiers, groups, LEDs, etc, relating to that keymap.  All
    key events must be fed into the xkb_state object using xkb_state_update_key.
    Once this is done, the xkb_state object will be properly updated, and the
    keysyms to use can be obtained with xkb_key_get_syms.
    
    libxkbcommon does not distribute a dataset itself, other than for testing
    purposes.  The most common dataset is xkeyboard-config, as used by all
    current distributions for their X11 XKB data.  More information on
    xkeyboard-config is available here:
        http://www.freedesktop.org/wiki/Software/XKeyboardConfig
    
    
    API
    ===
    
    While xkbcommon's API is somewhat derived from the classic XKB API as found
    in <X11/extensions/XKB.h> and friends, it has been substantially reworked to
    expose fewer internal details to clients.  The only supported API is available
    in <xkbcommon/xkbcommon.h>.  Any definition not in this header (including
    accessing internal structures through the old macros previously available)
    should be regarded as an implementation detail and is liable to change at any
    time.
    
    During its early development, xkbcommon does not promise API or ABI stability.
    Regardless, we will attempt to not break ABI during a minor release series,
    so applications written against 0.1.0 should be completely compatible with
    0.1.3, but not necessarily with 0.2.0.  However, new symbols may be introduced
    in any release.  Thus, anyone packaging xkbcommon should make sure any package
    depending on it depends on a release greater than or equal to the version it
    was built against (or earlier, if it doesn't use any newly-introduced
    symbols), but less than the next major release.
    
    xkbcommon 1.x will offer full API and ABI stability for its lifetime, with a
    soname of libxkbcommon.so.1.  Any ABI breaks will wait until xkbcommon 2.0,
    which will be libxkbcommon.so.2.
    
    The xkbcomp command-line tool has also been removed, although this will
    likely reappear in a later release.
    
    
    Relation to X11
    ===============
    
    Relative to the XKB 1.1 specification implemented in current X servers,
    xkbcommon has removed support for some parts of the specification which
    introduced unnecessary complications.  Many of these removals were in fact
    not implemented, or half-implemented at best, as well as being totally
    unused in the standard dataset.
    
    Notable removals:
        - geometry support
          + there were very few geometry definitions available, and while
            xkbcommon was responsible for parsing this insanely complex format,
            it never actually did anything with it
          + hopefully someone will develop a companion library which supports
            keyboard geometries in a more useful format
        - KcCGST (keycodes/compat/geometry/symbols/types) API
          + use RMLVO instead; KcCGST is now an implementation detail
          + including pre-defined keymap files
        - XKM support
          + may come in an optional X11 support/compatibility library
        - around half of the interpret actions
          + pointer device, message and redirect actions in particular
        - non-virtual modifiers
          + core and virtual modifiers have been collapsed into the same
            namespace, with a 'significant' flag that largely parallels the
            core/virtual split
        - radio groups
          + completely unused in current keymaps, never fully implemented
        - overlays
          + almost completely unused in current keymaps
        - key behaviors
          + used to implement radio groups and overlays, and to deal with things
            like keys that physically lock; unused in current keymaps
        - indicator behaviours such as LED-controls-key
          + the only supported LED behaviour is key-controls-LED; again this
            was never really used in current keymaps
    
    Notable additions:
        - 32-bit keycodes
        - extended number of modifiers
        - extended number of groups
        - multiple keysyms per level
          + this requires incompatible dataset changes, such that X11 would
            not be able to parse these
    
    
    Development
    ===========
    
    xkbcommon is maintained in git at freedesktop.org:
        git://anongit.freedesktop.org/git/xorg/lib/libxkbcommon
    
    Patches are always welcome, and may be sent to either xorg-devel@lists.x.org,
    or wayland-devel@lists.freedesktop.org.  Bugs are tracked in Bugzilla at:
        http://bugs.freedesktop.org
    
    The primary author and maintainer is Daniel Stone, who can be reached at:
        <daniel@fooishbar.org>
    
    
    Credits
    =======
    
    Many thanks are due to Dan Nicholson for his heroic work in getting xkbcommon
    off the ground initially, as well as to Ran Benita for subsequent development.