godot/thirdparty/linuxbsd_headers/xkbcommon/xkbcommon.h

1955 lines
65 KiB
C++
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/*
* Copyright 1985, 1987, 1990, 1998 The Open Group
* Copyright 2008 Dan Nicholson
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
* Except as contained in this notice, the names of the authors or their
* institutions shall not be used in advertising or otherwise to promote the
* sale, use or other dealings in this Software without prior written
* authorization from the authors.
*/
/************************************************************
* Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc.
*
* Permission to use, copy, modify, and distribute this
* software and its documentation for any purpose and without
* fee is hereby granted, provided that the above copyright
* notice appear in all copies and that both that copyright
* notice and this permission notice appear in supporting
* documentation, and that the name of Silicon Graphics not be
* used in advertising or publicity pertaining to distribution
* of the software without specific prior written permission.
* Silicon Graphics makes no representation about the suitability
* of this software for any purpose. It is provided "as is"
* without any express or implied warranty.
*
* SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
* SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
* AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
* GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
* OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH
* THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
********************************************************/
/*
* Copyright © 2009-2012 Daniel Stone
* Copyright © 2012 Intel Corporation
* Copyright © 2012 Ran Benita
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*
* Author: Daniel Stone <daniel@fooishbar.org>
*/
#ifndef _XKBCOMMON_H_
#define _XKBCOMMON_H_
#include <stdint.h>
#include <stdio.h>
#include <stdarg.h>
#include <xkbcommon/xkbcommon-names.h>
#include <xkbcommon/xkbcommon-keysyms.h>
#ifdef __cplusplus
extern "C" {
#endif
/**
* @file
* Main libxkbcommon API.
*/
/**
* @struct xkb_context
* Opaque top level library context object.
*
* The context contains various general library data and state, like
* logging level and include paths.
*
* Objects are created in a specific context, and multiple contexts may
* coexist simultaneously. Objects from different contexts are completely
* separated and do not share any memory or state.
*/
struct xkb_context;
/**
* @struct xkb_keymap
* Opaque compiled keymap object.
*
* The keymap object holds all of the static keyboard information obtained
* from compiling XKB files.
*
* A keymap is immutable after it is created (besides reference counts, etc.);
* if you need to change it, you must create a new one.
*/
struct xkb_keymap;
/**
* @struct xkb_state
* Opaque keyboard state object.
*
* State objects contain the active state of a keyboard (or keyboards), such
* as the currently effective layout and the active modifiers. It acts as a
* simple state machine, wherein key presses and releases are the input, and
* key symbols (keysyms) are the output.
*/
struct xkb_state;
/**
* A number used to represent a physical key on a keyboard.
*
* A standard PC-compatible keyboard might have 102 keys. An appropriate
* keymap would assign each of them a keycode, by which the user should
* refer to the key throughout the library.
*
* Historically, the X11 protocol, and consequentially the XKB protocol,
* assign only 8 bits for keycodes. This limits the number of different
* keys that can be used simultaneously in a single keymap to 256
* (disregarding other limitations). This library does not share this limit;
* keycodes beyond 255 ('extended keycodes') are not treated specially.
* Keymaps and applications which are compatible with X11 should not use
* these keycodes.
*
* The values of specific keycodes are determined by the keymap and the
* underlying input system. For example, with an X11-compatible keymap
* and Linux evdev scan codes (see linux/input.h), a fixed offset is used:
*
* The keymap defines a canonical name for each key, plus possible aliases.
* Historically, the XKB protocol restricts these names to at most 4 (ASCII)
* characters, but this library does not share this limit.
*
* @code
* xkb_keycode_t keycode_A = KEY_A + 8;
* @endcode
*
* @sa xkb_keycode_is_legal_ext() xkb_keycode_is_legal_x11()
*/
typedef uint32_t xkb_keycode_t;
/**
* A number used to represent the symbols generated from a key on a keyboard.
*
* A key, represented by a keycode, may generate different symbols according
* to keyboard state. For example, on a QWERTY keyboard, pressing the key
* labled \<A\> generates the symbol 'a'. If the Shift key is held, it
* generates the symbol 'A'. If a different layout is used, say Greek,
* it generates the symbol 'α'. And so on.
*
* Each such symbol is represented by a keysym. Note that keysyms are
* somewhat more general, in that they can also represent some "function",
* such as "Left" or "Right" for the arrow keys. For more information,
* see:
* https://www.x.org/releases/current/doc/xproto/x11protocol.html#keysym_encoding
*
* Specifically named keysyms can be found in the
* xkbcommon/xkbcommon-keysyms.h header file. Their name does not include
* the XKB_KEY_ prefix.
*
* Besides those, any Unicode/ISO 10646 character in the range U0100 to
* U10FFFF can be represented by a keysym value in the range 0x01000100 to
* 0x0110FFFF. The name of Unicode keysyms is "U<codepoint>", e.g. "UA1B2".
*
* The name of other unnamed keysyms is the hexadecimal representation of
* their value, e.g. "0xabcd1234".
*
* Keysym names are case-sensitive.
*/
typedef uint32_t xkb_keysym_t;
/**
* Index of a keyboard layout.
*
* The layout index is a state component which detemines which <em>keyboard
* layout</em> is active. These may be different alphabets, different key
* arrangements, etc.
*
* Layout indices are consecutive. The first layout has index 0.
*
* Each layout is not required to have a name, and the names are not
* guaranteed to be unique (though they are usually provided and unique).
* Therefore, it is not safe to use the name as a unique identifier for a
* layout. Layout names are case-sensitive.
*
* Layout names are specified in the layout's definition, for example
* "English (US)". These are different from the (conventionally) short names
* which are used to locate the layout, for example "us" or "us(intl)". These
* names are not present in a compiled keymap.
*
* If the user selects layouts from a list generated from the XKB registry
* (using libxkbregistry or directly), and this metadata is needed later on, it
* is recommended to store it along with the keymap.
*
* Layouts are also called "groups" by XKB.
*
* @sa xkb_keymap_num_layouts() xkb_keymap_num_layouts_for_key()
*/
typedef uint32_t xkb_layout_index_t;
/** A mask of layout indices. */
typedef uint32_t xkb_layout_mask_t;
/**
* Index of a shift level.
*
* Any key, in any layout, can have several <em>shift levels</em>. Each
* shift level can assign different keysyms to the key. The shift level
* to use is chosen according to the current keyboard state; for example,
* if no keys are pressed, the first level may be used; if the Left Shift
* key is pressed, the second; if Num Lock is pressed, the third; and
* many such combinations are possible (see xkb_mod_index_t).
*
* Level indices are consecutive. The first level has index 0.
*/
typedef uint32_t xkb_level_index_t;
/**
* Index of a modifier.
*
* A @e modifier is a state component which changes the way keys are
* interpreted. A keymap defines a set of modifiers, such as Alt, Shift,
* Num Lock or Meta, and specifies which keys may @e activate which
* modifiers (in a many-to-many relationship, i.e. a key can activate
* several modifiers, and a modifier may be activated by several keys.
* Different keymaps do this differently).
*
* When retrieving the keysyms for a key, the active modifier set is
* consulted; this detemines the correct shift level to use within the
* currently active layout (see xkb_level_index_t).
*
* Modifier indices are consecutive. The first modifier has index 0.
*
* Each modifier must have a name, and the names are unique. Therefore, it
* is safe to use the name as a unique identifier for a modifier. The names
* of some common modifiers are provided in the xkbcommon/xkbcommon-names.h
* header file. Modifier names are case-sensitive.
*
* @sa xkb_keymap_num_mods()
*/
typedef uint32_t xkb_mod_index_t;
/** A mask of modifier indices. */
typedef uint32_t xkb_mod_mask_t;
/**
* Index of a keyboard LED.
*
* LEDs are logical objects which may be @e active or @e inactive. They
* typically correspond to the lights on the keyboard. Their state is
* determined by the current keyboard state.
*
* LED indices are non-consecutive. The first LED has index 0.
*
* Each LED must have a name, and the names are unique. Therefore,
* it is safe to use the name as a unique identifier for a LED. The names
* of some common LEDs are provided in the xkbcommon/xkbcommon-names.h
* header file. LED names are case-sensitive.
*
* @warning A given keymap may specify an exact index for a given LED.
* Therefore, LED indexing is not necessarily sequential, as opposed to
* modifiers and layouts. This means that when iterating over the LEDs
* in a keymap using e.g. xkb_keymap_num_leds(), some indices might be
* invalid. Given such an index, functions like xkb_keymap_led_get_name()
* will return NULL, and xkb_state_led_index_is_active() will return -1.
*
* LEDs are also called "indicators" by XKB.
*
* @sa xkb_keymap_num_leds()
*/
typedef uint32_t xkb_led_index_t;
/** A mask of LED indices. */
typedef uint32_t xkb_led_mask_t;
#define XKB_KEYCODE_INVALID (0xffffffff)
#define XKB_LAYOUT_INVALID (0xffffffff)
#define XKB_LEVEL_INVALID (0xffffffff)
#define XKB_MOD_INVALID (0xffffffff)
#define XKB_LED_INVALID (0xffffffff)
#define XKB_KEYCODE_MAX (0xffffffff - 1)
/**
* Test whether a value is a valid extended keycode.
* @sa xkb_keycode_t
**/
#define xkb_keycode_is_legal_ext(key) (key <= XKB_KEYCODE_MAX)
/**
* Test whether a value is a valid X11 keycode.
* @sa xkb_keycode_t
*/
#define xkb_keycode_is_legal_x11(key) (key >= 8 && key <= 255)
/**
* Names to compile a keymap with, also known as RMLVO.
*
* The names are the common configuration values by which a user picks
* a keymap.
*
* If the entire struct is NULL, then each field is taken to be NULL.
* You should prefer passing NULL instead of choosing your own defaults.
*/
struct xkb_rule_names {
/**
* The rules file to use. The rules file describes how to interpret
* the values of the model, layout, variant and options fields.
*
* If NULL or the empty string "", a default value is used.
* If the XKB_DEFAULT_RULES environment variable is set, it is used
* as the default. Otherwise the system default is used.
*/
const char *rules;
/**
* The keyboard model by which to interpret keycodes and LEDs.
*
* If NULL or the empty string "", a default value is used.
* If the XKB_DEFAULT_MODEL environment variable is set, it is used
* as the default. Otherwise the system default is used.
*/
const char *model;
/**
* A comma separated list of layouts (languages) to include in the
* keymap.
*
* If NULL or the empty string "", a default value is used.
* If the XKB_DEFAULT_LAYOUT environment variable is set, it is used
* as the default. Otherwise the system default is used.
*/
const char *layout;
/**
* A comma separated list of variants, one per layout, which may
* modify or augment the respective layout in various ways.
*
* Generally, should either be empty or have the same number of values
* as the number of layouts. You may use empty values as in "intl,,neo".
*
* If NULL or the empty string "", and a default value is also used
* for the layout, a default value is used. Otherwise no variant is
* used.
* If the XKB_DEFAULT_VARIANT environment variable is set, it is used
* as the default. Otherwise the system default is used.
*/
const char *variant;
/**
* A comma separated list of options, through which the user specifies
* non-layout related preferences, like which key combinations are used
* for switching layouts, or which key is the Compose key.
*
* If NULL, a default value is used. If the empty string "", no
* options are used.
* If the XKB_DEFAULT_OPTIONS environment variable is set, it is used
* as the default. Otherwise the system default is used.
*/
const char *options;
};
/**
* @defgroup keysyms Keysyms
* Utility functions related to keysyms.
*
* @{
*/
/**
* @page keysym-transformations Keysym Transformations
*
* Keysym translation is subject to several "keysym transformations",
* as described in the XKB specification. These are:
*
* - Capitalization transformation. If the Caps Lock modifier is
* active and was not consumed by the translation process, a single
* keysym is transformed to its upper-case form (if applicable).
* Similarly, the UTF-8/UTF-32 string produced is capitalized.
*
* This is described in:
* https://www.x.org/releases/current/doc/kbproto/xkbproto.html#Interpreting_the_Lock_Modifier
*
* - Control transformation. If the Control modifier is active and
* was not consumed by the translation process, the string produced
* is transformed to its matching ASCII control character (if
* applicable). Keysyms are not affected.
*
* This is described in:
* https://www.x.org/releases/current/doc/kbproto/xkbproto.html#Interpreting_the_Control_Modifier
*
* Each relevant function discusses which transformations it performs.
*
* These transformations are not applicable when a key produces multiple
* keysyms.
*/
/**
* Get the name of a keysym.
*
* For a description of how keysyms are named, see @ref xkb_keysym_t.
*
* @param[in] keysym The keysym.
* @param[out] buffer A string buffer to write the name into.
* @param[in] size Size of the buffer.
*
* @warning If the buffer passed is too small, the string is truncated
* (though still NUL-terminated); a size of at least 64 bytes is recommended.
*
* @returns The number of bytes in the name, excluding the NUL byte. If
* the keysym is invalid, returns -1.
*
* You may check if truncation has occurred by comparing the return value
* with the length of buffer, similarly to the snprintf(3) function.
*
* @sa xkb_keysym_t
*/
int
xkb_keysym_get_name(xkb_keysym_t keysym, char *buffer, size_t size);
/** Flags for xkb_keysym_from_name(). */
enum xkb_keysym_flags {
/** Do not apply any flags. */
XKB_KEYSYM_NO_FLAGS = 0,
/** Find keysym by case-insensitive search. */
XKB_KEYSYM_CASE_INSENSITIVE = (1 << 0)
};
/**
* Get a keysym from its name.
*
* @param name The name of a keysym. See remarks in xkb_keysym_get_name();
* this function will accept any name returned by that function.
* @param flags A set of flags controlling how the search is done. If
* invalid flags are passed, this will fail with XKB_KEY_NoSymbol.
*
* If you use the XKB_KEYSYM_CASE_INSENSITIVE flag and two keysym names
* differ only by case, then the lower-case keysym is returned. For
* instance, for KEY_a and KEY_A, this function would return KEY_a for the
* case-insensitive search. If this functionality is needed, it is
* recommended to first call this function without this flag; and if that
* fails, only then to try with this flag, while possibly warning the user
* he had misspelled the name, and might get wrong results.
*
* Case folding is done according to the C locale; the current locale is not
* consulted.
*
* @returns The keysym. If the name is invalid, returns XKB_KEY_NoSymbol.
*
* @sa xkb_keysym_t
*/
xkb_keysym_t
xkb_keysym_from_name(const char *name, enum xkb_keysym_flags flags);
/**
* Get the Unicode/UTF-8 representation of a keysym.
*
* @param[in] keysym The keysym.
* @param[out] buffer A buffer to write the UTF-8 string into.
* @param[in] size The size of buffer. Must be at least 7.
*
* @returns The number of bytes written to the buffer (including the
* terminating byte). If the keysym does not have a Unicode
* representation, returns 0. If the buffer is too small, returns -1.
*
* This function does not perform any @ref keysym-transformations.
* Therefore, prefer to use xkb_state_key_get_utf8() if possible.
*
* @sa xkb_state_key_get_utf8()
*/
int
xkb_keysym_to_utf8(xkb_keysym_t keysym, char *buffer, size_t size);
/**
* Get the Unicode/UTF-32 representation of a keysym.
*
* @returns The Unicode/UTF-32 representation of keysym, which is also
* compatible with UCS-4. If the keysym does not have a Unicode
* representation, returns 0.
*
* This function does not perform any @ref keysym-transformations.
* Therefore, prefer to use xkb_state_key_get_utf32() if possible.
*
* @sa xkb_state_key_get_utf32()
*/
uint32_t
xkb_keysym_to_utf32(xkb_keysym_t keysym);
/**
* Get the keysym corresponding to a Unicode/UTF-32 codepoint.
*
* @returns The keysym corresponding to the specified Unicode
* codepoint, or XKB_KEY_NoSymbol if there is none.
*
* This function is the inverse of @ref xkb_keysym_to_utf32. In cases
* where a single codepoint corresponds to multiple keysyms, returns
* the keysym with the lowest value.
*
* Unicode codepoints which do not have a special (legacy) keysym
* encoding use a direct encoding scheme. These keysyms don't usually
* have an associated keysym constant (XKB_KEY_*).
*
* For noncharacter Unicode codepoints and codepoints outside of the
* defined Unicode planes this function returns XKB_KEY_NoSymbol.
*
* @sa xkb_keysym_to_utf32()
* @since 1.0.0
*/
xkb_keysym_t
xkb_utf32_to_keysym(uint32_t ucs);
/**
* Convert a keysym to its uppercase form.
*
* If there is no such form, the keysym is returned unchanged.
*
* The conversion rules may be incomplete; prefer to work with the Unicode
* representation instead, when possible.
*/
xkb_keysym_t
xkb_keysym_to_upper(xkb_keysym_t ks);
/**
* Convert a keysym to its lowercase form.
*
* The conversion rules may be incomplete; prefer to work with the Unicode
* representation instead, when possible.
*/
xkb_keysym_t
xkb_keysym_to_lower(xkb_keysym_t ks);
/** @} */
/**
* @defgroup context Library Context
* Creating, destroying and using library contexts.
*
* Every keymap compilation request must have a context associated with
* it. The context keeps around state such as the include path.
*
* @{
*/
/**
* @page envvars Environment Variables
*
* The user may set some environment variables which affect the library:
*
* - `XKB_CONFIG_ROOT`, `XKB_CONFIG_EXTRA_PATH`, `XDG_CONFIG_DIR`, `HOME` - see @ref include-path.
* - `XKB_LOG_LEVEL` - see xkb_context_set_log_level().
* - `XKB_LOG_VERBOSITY` - see xkb_context_set_log_verbosity().
* - `XKB_DEFAULT_RULES`, `XKB_DEFAULT_MODEL`, `XKB_DEFAULT_LAYOUT`,
* `XKB_DEFAULT_VARIANT`, `XKB_DEFAULT_OPTIONS` - see xkb_rule_names.
*/
/** Flags for context creation. */
enum xkb_context_flags {
/** Do not apply any context flags. */
XKB_CONTEXT_NO_FLAGS = 0,
/** Create this context with an empty include path. */
XKB_CONTEXT_NO_DEFAULT_INCLUDES = (1 << 0),
/**
* Don't take RMLVO names from the environment.
* @since 0.3.0
*/
XKB_CONTEXT_NO_ENVIRONMENT_NAMES = (1 << 1)
};
/**
* Create a new context.
*
* @param flags Optional flags for the context, or 0.
*
* @returns A new context, or NULL on failure.
*
* @memberof xkb_context
*/
struct xkb_context *
xkb_context_new(enum xkb_context_flags flags);
/**
* Take a new reference on a context.
*
* @returns The passed in context.
*
* @memberof xkb_context
*/
struct xkb_context *
xkb_context_ref(struct xkb_context *context);
/**
* Release a reference on a context, and possibly free it.
*
* @param context The context. If it is NULL, this function does nothing.
*
* @memberof xkb_context
*/
void
xkb_context_unref(struct xkb_context *context);
/**
* Store custom user data in the context.
*
* This may be useful in conjunction with xkb_context_set_log_fn() or other
* callbacks.
*
* @memberof xkb_context
*/
void
xkb_context_set_user_data(struct xkb_context *context, void *user_data);
/**
* Retrieves stored user data from the context.
*
* @returns The stored user data. If the user data wasn't set, or the
* passed in context is NULL, returns NULL.
*
* This may be useful to access private user data from callbacks like a
* custom logging function.
*
* @memberof xkb_context
**/
void *
xkb_context_get_user_data(struct xkb_context *context);
/** @} */
/**
* @defgroup include-path Include Paths
* Manipulating the include paths in a context.
*
* The include paths are the file-system paths that are searched when an
* include statement is encountered during keymap compilation.
*
* The default include paths are, in that lookup order:
* - The path `$XDG_CONFIG_HOME/xkb`, with the usual `XDG_CONFIG_HOME`
* fallback to `$HOME/.config/` if unset.
* - The path `$HOME/.xkb`, where $HOME is the value of the environment
* variable `HOME`.
* - The `XKB_CONFIG_EXTRA_PATH` environment variable, if defined, otherwise the
* system configuration directory, defined at library configuration time
* (usually `/etc/xkb`).
* - The `XKB_CONFIG_ROOT` environment variable, if defined, otherwise
* the system XKB root, defined at library configuration time.
*
* @{
*/
/**
* Append a new entry to the context's include path.
*
* @returns 1 on success, or 0 if the include path could not be added or is
* inaccessible.
*
* @memberof xkb_context
*/
int
xkb_context_include_path_append(struct xkb_context *context, const char *path);
/**
* Append the default include paths to the context's include path.
*
* @returns 1 on success, or 0 if the primary include path could not be added.
*
* @memberof xkb_context
*/
int
xkb_context_include_path_append_default(struct xkb_context *context);
/**
* Reset the context's include path to the default.
*
* Removes all entries from the context's include path, and inserts the
* default paths.
*
* @returns 1 on success, or 0 if the primary include path could not be added.
*
* @memberof xkb_context
*/
int
xkb_context_include_path_reset_defaults(struct xkb_context *context);
/**
* Remove all entries from the context's include path.
*
* @memberof xkb_context
*/
void
xkb_context_include_path_clear(struct xkb_context *context);
/**
* Get the number of paths in the context's include path.
*
* @memberof xkb_context
*/
unsigned int
xkb_context_num_include_paths(struct xkb_context *context);
/**
* Get a specific include path from the context's include path.
*
* @returns The include path at the specified index. If the index is
* invalid, returns NULL.
*
* @memberof xkb_context
*/
const char *
xkb_context_include_path_get(struct xkb_context *context, unsigned int index);
/** @} */
/**
* @defgroup logging Logging Handling
* Manipulating how logging from this library is handled.
*
* @{
*/
/** Specifies a logging level. */
enum xkb_log_level {
XKB_LOG_LEVEL_CRITICAL = 10, /**< Log critical internal errors only. */
XKB_LOG_LEVEL_ERROR = 20, /**< Log all errors. */
XKB_LOG_LEVEL_WARNING = 30, /**< Log warnings and errors. */
XKB_LOG_LEVEL_INFO = 40, /**< Log information, warnings, and errors. */
XKB_LOG_LEVEL_DEBUG = 50 /**< Log everything. */
};
/**
* Set the current logging level.
*
* @param context The context in which to set the logging level.
* @param level The logging level to use. Only messages from this level
* and below will be logged.
*
* The default level is XKB_LOG_LEVEL_ERROR. The environment variable
* XKB_LOG_LEVEL, if set in the time the context was created, overrides the
* default value. It may be specified as a level number or name.
*
* @memberof xkb_context
*/
void
xkb_context_set_log_level(struct xkb_context *context,
enum xkb_log_level level);
/**
* Get the current logging level.
*
* @memberof xkb_context
*/
enum xkb_log_level
xkb_context_get_log_level(struct xkb_context *context);
/**
* Sets the current logging verbosity.
*
* The library can generate a number of warnings which are not helpful to
* ordinary users of the library. The verbosity may be increased if more
* information is desired (e.g. when developing a new keymap).
*
* The default verbosity is 0. The environment variable XKB_LOG_VERBOSITY,
* if set in the time the context was created, overrides the default value.
*
* @param context The context in which to use the set verbosity.
* @param verbosity The verbosity to use. Currently used values are
* 1 to 10, higher values being more verbose. 0 would result in no verbose
* messages being logged.
*
* Most verbose messages are of level XKB_LOG_LEVEL_WARNING or lower.
*
* @memberof xkb_context
*/
void
xkb_context_set_log_verbosity(struct xkb_context *context, int verbosity);
/**
* Get the current logging verbosity of the context.
*
* @memberof xkb_context
*/
int
xkb_context_get_log_verbosity(struct xkb_context *context);
/**
* Set a custom function to handle logging messages.
*
* @param context The context in which to use the set logging function.
* @param log_fn The function that will be called for logging messages.
* Passing NULL restores the default function, which logs to stderr.
*
* By default, log messages from this library are printed to stderr. This
* function allows you to replace the default behavior with a custom
* handler. The handler is only called with messages which match the
* current logging level and verbosity settings for the context.
* level is the logging level of the message. @a format and @a args are
* the same as in the vprintf(3) function.
*
* You may use xkb_context_set_user_data() on the context, and then call
* xkb_context_get_user_data() from within the logging function to provide
* it with additional private context.
*
* @memberof xkb_context
*/
void
xkb_context_set_log_fn(struct xkb_context *context,
void (*log_fn)(struct xkb_context *context,
enum xkb_log_level level,
const char *format, va_list args));
/** @} */
/**
* @defgroup keymap Keymap Creation
* Creating and destroying keymaps.
*
* @{
*/
/** Flags for keymap compilation. */
enum xkb_keymap_compile_flags {
/** Do not apply any flags. */
XKB_KEYMAP_COMPILE_NO_FLAGS = 0
};
/**
* Create a keymap from RMLVO names.
*
* The primary keymap entry point: creates a new XKB keymap from a set of
* RMLVO (Rules + Model + Layouts + Variants + Options) names.
*
* @param context The context in which to create the keymap.
* @param names The RMLVO names to use. See xkb_rule_names.
* @param flags Optional flags for the keymap, or 0.
*
* @returns A keymap compiled according to the RMLVO names, or NULL if
* the compilation failed.
*
* @sa xkb_rule_names
* @memberof xkb_keymap
*/
struct xkb_keymap *
xkb_keymap_new_from_names(struct xkb_context *context,
const struct xkb_rule_names *names,
enum xkb_keymap_compile_flags flags);
/** The possible keymap formats. */
enum xkb_keymap_format {
/** The current/classic XKB text format, as generated by xkbcomp -xkb. */
XKB_KEYMAP_FORMAT_TEXT_V1 = 1
};
/**
* Create a keymap from a keymap file.
*
* @param context The context in which to create the keymap.
* @param file The keymap file to compile.
* @param format The text format of the keymap file to compile.
* @param flags Optional flags for the keymap, or 0.
*
* @returns A keymap compiled from the given XKB keymap file, or NULL if
* the compilation failed.
*
* The file must contain a complete keymap. For example, in the
* XKB_KEYMAP_FORMAT_TEXT_V1 format, this means the file must contain one
* top level '%xkb_keymap' section, which in turn contains other required
* sections.
*
* @memberof xkb_keymap
*/
struct xkb_keymap *
xkb_keymap_new_from_file(struct xkb_context *context, FILE *file,
enum xkb_keymap_format format,
enum xkb_keymap_compile_flags flags);
/**
* Create a keymap from a keymap string.
*
* This is just like xkb_keymap_new_from_file(), but instead of a file, gets
* the keymap as one enormous string.
*
* @see xkb_keymap_new_from_file()
* @memberof xkb_keymap
*/
struct xkb_keymap *
xkb_keymap_new_from_string(struct xkb_context *context, const char *string,
enum xkb_keymap_format format,
enum xkb_keymap_compile_flags flags);
/**
* Create a keymap from a memory buffer.
*
* This is just like xkb_keymap_new_from_string(), but takes a length argument
* so the input string does not have to be zero-terminated.
*
* @see xkb_keymap_new_from_string()
* @memberof xkb_keymap
* @since 0.3.0
*/
struct xkb_keymap *
xkb_keymap_new_from_buffer(struct xkb_context *context, const char *buffer,
size_t length, enum xkb_keymap_format format,
enum xkb_keymap_compile_flags flags);
/**
* Take a new reference on a keymap.
*
* @returns The passed in keymap.
*
* @memberof xkb_keymap
*/
struct xkb_keymap *
xkb_keymap_ref(struct xkb_keymap *keymap);
/**
* Release a reference on a keymap, and possibly free it.
*
* @param keymap The keymap. If it is NULL, this function does nothing.
*
* @memberof xkb_keymap
*/
void
xkb_keymap_unref(struct xkb_keymap *keymap);
/**
* Get the keymap as a string in the format from which it was created.
* @sa xkb_keymap_get_as_string()
**/
#define XKB_KEYMAP_USE_ORIGINAL_FORMAT ((enum xkb_keymap_format) -1)
/**
* Get the compiled keymap as a string.
*
* @param keymap The keymap to get as a string.
* @param format The keymap format to use for the string. You can pass
* in the special value XKB_KEYMAP_USE_ORIGINAL_FORMAT to use the format
* from which the keymap was originally created.
*
* @returns The keymap as a NUL-terminated string, or NULL if unsuccessful.
*
* The returned string may be fed back into xkb_keymap_new_from_string() to get
* the exact same keymap (possibly in another process, etc.).
*
* The returned string is dynamically allocated and should be freed by the
* caller.
*
* @memberof xkb_keymap
*/
char *
xkb_keymap_get_as_string(struct xkb_keymap *keymap,
enum xkb_keymap_format format);
/** @} */
/**
* @defgroup components Keymap Components
* Enumeration of state components in a keymap.
*
* @{
*/
/**
* Get the minimum keycode in the keymap.
*
* @sa xkb_keycode_t
* @memberof xkb_keymap
* @since 0.3.1
*/
xkb_keycode_t
xkb_keymap_min_keycode(struct xkb_keymap *keymap);
/**
* Get the maximum keycode in the keymap.
*
* @sa xkb_keycode_t
* @memberof xkb_keymap
* @since 0.3.1
*/
xkb_keycode_t
xkb_keymap_max_keycode(struct xkb_keymap *keymap);
/**
* The iterator used by xkb_keymap_key_for_each().
*
* @sa xkb_keymap_key_for_each
* @memberof xkb_keymap
* @since 0.3.1
*/
typedef void
(*xkb_keymap_key_iter_t)(struct xkb_keymap *keymap, xkb_keycode_t key,
void *data);
/**
* Run a specified function for every valid keycode in the keymap. If a
* keymap is sparse, this function may be called fewer than
* (max_keycode - min_keycode + 1) times.
*
* @sa xkb_keymap_min_keycode() xkb_keymap_max_keycode() xkb_keycode_t
* @memberof xkb_keymap
* @since 0.3.1
*/
void
xkb_keymap_key_for_each(struct xkb_keymap *keymap, xkb_keymap_key_iter_t iter,
void *data);
/**
* Find the name of the key with the given keycode.
*
* This function always returns the canonical name of the key (see
* description in xkb_keycode_t).
*
* @returns The key name. If no key with this keycode exists,
* returns NULL.
*
* @sa xkb_keycode_t
* @memberof xkb_keymap
* @since 0.6.0
*/
const char *
xkb_keymap_key_get_name(struct xkb_keymap *keymap, xkb_keycode_t key);
/**
* Find the keycode of the key with the given name.
*
* The name can be either a canonical name or an alias.
*
* @returns The keycode. If no key with this name exists,
* returns XKB_KEYCODE_INVALID.
*
* @sa xkb_keycode_t
* @memberof xkb_keymap
* @since 0.6.0
*/
xkb_keycode_t
xkb_keymap_key_by_name(struct xkb_keymap *keymap, const char *name);
/**
* Get the number of modifiers in the keymap.
*
* @sa xkb_mod_index_t
* @memberof xkb_keymap
*/
xkb_mod_index_t
xkb_keymap_num_mods(struct xkb_keymap *keymap);
/**
* Get the name of a modifier by index.
*
* @returns The name. If the index is invalid, returns NULL.
*
* @sa xkb_mod_index_t
* @memberof xkb_keymap
*/
const char *
xkb_keymap_mod_get_name(struct xkb_keymap *keymap, xkb_mod_index_t idx);
/**
* Get the index of a modifier by name.
*
* @returns The index. If no modifier with this name exists, returns
* XKB_MOD_INVALID.
*
* @sa xkb_mod_index_t
* @memberof xkb_keymap
*/
xkb_mod_index_t
xkb_keymap_mod_get_index(struct xkb_keymap *keymap, const char *name);
/**
* Get the number of layouts in the keymap.
*
* @sa xkb_layout_index_t xkb_rule_names xkb_keymap_num_layouts_for_key()
* @memberof xkb_keymap
*/
xkb_layout_index_t
xkb_keymap_num_layouts(struct xkb_keymap *keymap);
/**
* Get the name of a layout by index.
*
* @returns The name. If the index is invalid, or the layout does not have
* a name, returns NULL.
*
* @sa xkb_layout_index_t
* For notes on layout names.
* @memberof xkb_keymap
*/
const char *
xkb_keymap_layout_get_name(struct xkb_keymap *keymap, xkb_layout_index_t idx);
/**
* Get the index of a layout by name.
*
* @returns The index. If no layout exists with this name, returns
* XKB_LAYOUT_INVALID. If more than one layout in the keymap has this name,
* returns the lowest index among them.
*
* @sa xkb_layout_index_t
* For notes on layout names.
* @memberof xkb_keymap
*/
xkb_layout_index_t
xkb_keymap_layout_get_index(struct xkb_keymap *keymap, const char *name);
/**
* Get the number of LEDs in the keymap.
*
* @warning The range [ 0...xkb_keymap_num_leds() ) includes all of the LEDs
* in the keymap, but may also contain inactive LEDs. When iterating over
* this range, you need the handle this case when calling functions such as
* xkb_keymap_led_get_name() or xkb_state_led_index_is_active().
*
* @sa xkb_led_index_t
* @memberof xkb_keymap
*/
xkb_led_index_t
xkb_keymap_num_leds(struct xkb_keymap *keymap);
/**
* Get the name of a LED by index.
*
* @returns The name. If the index is invalid, returns NULL.
*
* @memberof xkb_keymap
*/
const char *
xkb_keymap_led_get_name(struct xkb_keymap *keymap, xkb_led_index_t idx);
/**
* Get the index of a LED by name.
*
* @returns The index. If no LED with this name exists, returns
* XKB_LED_INVALID.
*
* @memberof xkb_keymap
*/
xkb_led_index_t
xkb_keymap_led_get_index(struct xkb_keymap *keymap, const char *name);
/**
* Get the number of layouts for a specific key.
*
* This number can be different from xkb_keymap_num_layouts(), but is always
* smaller. It is the appropriate value to use when iterating over the
* layouts of a key.
*
* @sa xkb_layout_index_t
* @memberof xkb_keymap
*/
xkb_layout_index_t
xkb_keymap_num_layouts_for_key(struct xkb_keymap *keymap, xkb_keycode_t key);
/**
* Get the number of shift levels for a specific key and layout.
*
* If @c layout is out of range for this key (that is, larger or equal to
* the value returned by xkb_keymap_num_layouts_for_key()), it is brought
* back into range in a manner consistent with xkb_state_key_get_layout().
*
* @sa xkb_level_index_t
* @memberof xkb_keymap
*/
xkb_level_index_t
xkb_keymap_num_levels_for_key(struct xkb_keymap *keymap, xkb_keycode_t key,
xkb_layout_index_t layout);
/**
* Retrieves every possible modifier mask that produces the specified
* shift level for a specific key and layout.
*
* This API is useful for inverse key transformation; i.e. finding out
* which modifiers need to be active in order to be able to type the
* keysym(s) corresponding to the specific key code, layout and level.
*
* @warning It returns only up to masks_size modifier masks. If the
* buffer passed is too small, some of the possible modifier combinations
* will not be returned.
*
* @param[in] keymap The keymap.
* @param[in] key The keycode of the key.
* @param[in] layout The layout for which to get modifiers.
* @param[in] level The shift level in the layout for which to get the
* modifiers. This should be smaller than:
* @code xkb_keymap_num_levels_for_key(keymap, key) @endcode
* @param[out] masks_out A buffer in which the requested masks should be
* stored.
* @param[out] masks_size The size of the buffer pointed to by masks_out.
*
* If @c layout is out of range for this key (that is, larger or equal to
* the value returned by xkb_keymap_num_layouts_for_key()), it is brought
* back into range in a manner consistent with xkb_state_key_get_layout().
*
* @returns The number of modifier masks stored in the masks_out array.
* If the key is not in the keymap or if the specified shift level cannot
* be reached it returns 0 and does not modify the masks_out buffer.
*
* @sa xkb_level_index_t
* @sa xkb_mod_mask_t
* @memberof xkb_keymap
* @since 1.0.0
*/
size_t
xkb_keymap_key_get_mods_for_level(struct xkb_keymap *keymap,
xkb_keycode_t key,
xkb_layout_index_t layout,
xkb_level_index_t level,
xkb_mod_mask_t *masks_out,
size_t masks_size);
/**
* Get the keysyms obtained from pressing a key in a given layout and
* shift level.
*
* This function is like xkb_state_key_get_syms(), only the layout and
* shift level are not derived from the keyboard state but are instead
* specified explicitly.
*
* @param[in] keymap The keymap.
* @param[in] key The keycode of the key.
* @param[in] layout The layout for which to get the keysyms.
* @param[in] level The shift level in the layout for which to get the
* keysyms. This should be smaller than:
* @code xkb_keymap_num_levels_for_key(keymap, key) @endcode
* @param[out] syms_out An immutable array of keysyms corresponding to the
* key in the given layout and shift level.
*
* If @c layout is out of range for this key (that is, larger or equal to
* the value returned by xkb_keymap_num_layouts_for_key()), it is brought
* back into range in a manner consistent with xkb_state_key_get_layout().
*
* @returns The number of keysyms in the syms_out array. If no keysyms
* are produced by the key in the given layout and shift level, returns 0
* and sets syms_out to NULL.
*
* @sa xkb_state_key_get_syms()
* @memberof xkb_keymap
*/
int
xkb_keymap_key_get_syms_by_level(struct xkb_keymap *keymap,
xkb_keycode_t key,
xkb_layout_index_t layout,
xkb_level_index_t level,
const xkb_keysym_t **syms_out);
/**
* Determine whether a key should repeat or not.
*
* A keymap may specify different repeat behaviors for different keys.
* Most keys should generally exhibit repeat behavior; for example, holding
* the 'a' key down in a text editor should normally insert a single 'a'
* character every few milliseconds, until the key is released. However,
* there are keys which should not or do not need to be repeated. For
* example, repeating modifier keys such as Left/Right Shift or Caps Lock
* is not generally useful or desired.
*
* @returns 1 if the key should repeat, 0 otherwise.
*
* @memberof xkb_keymap
*/
int
xkb_keymap_key_repeats(struct xkb_keymap *keymap, xkb_keycode_t key);
/** @} */
/**
* @defgroup state Keyboard State
* Creating, destroying and manipulating keyboard state objects.
*
* @{
*/
/**
* Create a new keyboard state object.
*
* @param keymap The keymap which the state will use.
*
* @returns A new keyboard state object, or NULL on failure.
*
* @memberof xkb_state
*/
struct xkb_state *
xkb_state_new(struct xkb_keymap *keymap);
/**
* Take a new reference on a keyboard state object.
*
* @returns The passed in object.
*
* @memberof xkb_state
*/
struct xkb_state *
xkb_state_ref(struct xkb_state *state);
/**
* Release a reference on a keybaord state object, and possibly free it.
*
* @param state The state. If it is NULL, this function does nothing.
*
* @memberof xkb_state
*/
void
xkb_state_unref(struct xkb_state *state);
/**
* Get the keymap which a keyboard state object is using.
*
* @returns The keymap which was passed to xkb_state_new() when creating
* this state object.
*
* This function does not take a new reference on the keymap; you must
* explicitly reference it yourself if you plan to use it beyond the
* lifetime of the state.
*
* @memberof xkb_state
*/
struct xkb_keymap *
xkb_state_get_keymap(struct xkb_state *state);
/** Specifies the direction of the key (press / release). */
enum xkb_key_direction {
XKB_KEY_UP, /**< The key was released. */
XKB_KEY_DOWN /**< The key was pressed. */
};
/**
* Modifier and layout types for state objects. This enum is bitmaskable,
* e.g. (XKB_STATE_MODS_DEPRESSED | XKB_STATE_MODS_LATCHED) is valid to
* exclude locked modifiers.
*
* In XKB, the DEPRESSED components are also known as 'base'.
*/
enum xkb_state_component {
/** Depressed modifiers, i.e. a key is physically holding them. */
XKB_STATE_MODS_DEPRESSED = (1 << 0),
/** Latched modifiers, i.e. will be unset after the next non-modifier
* key press. */
XKB_STATE_MODS_LATCHED = (1 << 1),
/** Locked modifiers, i.e. will be unset after the key provoking the
* lock has been pressed again. */
XKB_STATE_MODS_LOCKED = (1 << 2),
/** Effective modifiers, i.e. currently active and affect key
* processing (derived from the other state components).
* Use this unless you explicitly care how the state came about. */
XKB_STATE_MODS_EFFECTIVE = (1 << 3),
/** Depressed layout, i.e. a key is physically holding it. */
XKB_STATE_LAYOUT_DEPRESSED = (1 << 4),
/** Latched layout, i.e. will be unset after the next non-modifier
* key press. */
XKB_STATE_LAYOUT_LATCHED = (1 << 5),
/** Locked layout, i.e. will be unset after the key provoking the lock
* has been pressed again. */
XKB_STATE_LAYOUT_LOCKED = (1 << 6),
/** Effective layout, i.e. currently active and affects key processing
* (derived from the other state components).
* Use this unless you explicitly care how the state came about. */
XKB_STATE_LAYOUT_EFFECTIVE = (1 << 7),
/** LEDs (derived from the other state components). */
XKB_STATE_LEDS = (1 << 8)
};
/**
* Update the keyboard state to reflect a given key being pressed or
* released.
*
* This entry point is intended for programs which track the keyboard state
* explicitly (like an evdev client). If the state is serialized to you by
* a master process (like a Wayland compositor) using functions like
* xkb_state_serialize_mods(), you should use xkb_state_update_mask() instead.
* The two functions should not generally be used together.
*
* A series of calls to this function should be consistent; that is, a call
* with XKB_KEY_DOWN for a key should be matched by an XKB_KEY_UP; if a key
* is pressed twice, it should be released twice; etc. Otherwise (e.g. due
* to missed input events), situations like "stuck modifiers" may occur.
*
* This function is often used in conjunction with the function
* xkb_state_key_get_syms() (or xkb_state_key_get_one_sym()), for example,
* when handling a key event. In this case, you should prefer to get the
* keysyms *before* updating the key, such that the keysyms reported for
* the key event are not affected by the event itself. This is the
* conventional behavior.
*
* @returns A mask of state components that have changed as a result of
* the update. If nothing in the state has changed, returns 0.
*
* @memberof xkb_state
*
* @sa xkb_state_update_mask()
*/
enum xkb_state_component
xkb_state_update_key(struct xkb_state *state, xkb_keycode_t key,
enum xkb_key_direction direction);
/**
* Update a keyboard state from a set of explicit masks.
*
* This entry point is intended for window systems and the like, where a
* master process holds an xkb_state, then serializes it over a wire
* protocol, and clients then use the serialization to feed in to their own
* xkb_state.
*
* All parameters must always be passed, or the resulting state may be
* incoherent.
*
* The serialization is lossy and will not survive round trips; it must only
* be used to feed slave state objects, and must not be used to update the
* master state.
*
* If you do not fit the description above, you should use
* xkb_state_update_key() instead. The two functions should not generally be
* used together.
*
* @returns A mask of state components that have changed as a result of
* the update. If nothing in the state has changed, returns 0.
*
* @memberof xkb_state
*
* @sa xkb_state_component
* @sa xkb_state_update_key
*/
enum xkb_state_component
xkb_state_update_mask(struct xkb_state *state,
xkb_mod_mask_t depressed_mods,
xkb_mod_mask_t latched_mods,
xkb_mod_mask_t locked_mods,
xkb_layout_index_t depressed_layout,
xkb_layout_index_t latched_layout,
xkb_layout_index_t locked_layout);
/**
* Get the keysyms obtained from pressing a particular key in a given
* keyboard state.
*
* Get the keysyms for a key according to the current active layout,
* modifiers and shift level for the key, as determined by a keyboard
* state.
*
* @param[in] state The keyboard state object.
* @param[in] key The keycode of the key.
* @param[out] syms_out An immutable array of keysyms corresponding the
* key in the given keyboard state.
*
* As an extension to XKB, this function can return more than one keysym.
* If you do not want to handle this case, you can use
* xkb_state_key_get_one_sym() for a simpler interface.
*
* This function does not perform any @ref keysym-transformations.
* (This might change).
*
* @returns The number of keysyms in the syms_out array. If no keysyms
* are produced by the key in the given keyboard state, returns 0 and sets
* syms_out to NULL.
*
* @memberof xkb_state
*/
int
xkb_state_key_get_syms(struct xkb_state *state, xkb_keycode_t key,
const xkb_keysym_t **syms_out);
/**
* Get the Unicode/UTF-8 string obtained from pressing a particular key
* in a given keyboard state.
*
* @param[in] state The keyboard state object.
* @param[in] key The keycode of the key.
* @param[out] buffer A buffer to write the string into.
* @param[in] size Size of the buffer.
*
* @warning If the buffer passed is too small, the string is truncated
* (though still NUL-terminated).
*
* @returns The number of bytes required for the string, excluding the
* NUL byte. If there is nothing to write, returns 0.
*
* You may check if truncation has occurred by comparing the return value
* with the size of @p buffer, similarly to the snprintf(3) function.
* You may safely pass NULL and 0 to @p buffer and @p size to find the
* required size (without the NUL-byte).
*
* This function performs Capitalization and Control @ref
* keysym-transformations.
*
* @memberof xkb_state
* @since 0.4.1
*/
int
xkb_state_key_get_utf8(struct xkb_state *state, xkb_keycode_t key,
char *buffer, size_t size);
/**
* Get the Unicode/UTF-32 codepoint obtained from pressing a particular
* key in a a given keyboard state.
*
* @returns The UTF-32 representation for the key, if it consists of only
* a single codepoint. Otherwise, returns 0.
*
* This function performs Capitalization and Control @ref
* keysym-transformations.
*
* @memberof xkb_state
* @since 0.4.1
*/
uint32_t
xkb_state_key_get_utf32(struct xkb_state *state, xkb_keycode_t key);
/**
* Get the single keysym obtained from pressing a particular key in a
* given keyboard state.
*
* This function is similar to xkb_state_key_get_syms(), but intended
* for users which cannot or do not want to handle the case where
* multiple keysyms are returned (in which case this function is
* preferred).
*
* @returns The keysym. If the key does not have exactly one keysym,
* returns XKB_KEY_NoSymbol
*
* This function performs Capitalization @ref keysym-transformations.
*
* @sa xkb_state_key_get_syms()
* @memberof xkb_state
*/
xkb_keysym_t
xkb_state_key_get_one_sym(struct xkb_state *state, xkb_keycode_t key);
/**
* Get the effective layout index for a key in a given keyboard state.
*
* @returns The layout index for the key in the given keyboard state. If
* the given keycode is invalid, or if the key is not included in any
* layout at all, returns XKB_LAYOUT_INVALID.
*
* @invariant If the returned layout is valid, the following always holds:
* @code
* xkb_state_key_get_layout(state, key) < xkb_keymap_num_layouts_for_key(keymap, key)
* @endcode
*
* @memberof xkb_state
*/
xkb_layout_index_t
xkb_state_key_get_layout(struct xkb_state *state, xkb_keycode_t key);
/**
* Get the effective shift level for a key in a given keyboard state and
* layout.
*
* @param state The keyboard state.
* @param key The keycode of the key.
* @param layout The layout for which to get the shift level. This must be
* smaller than:
* @code xkb_keymap_num_layouts_for_key(keymap, key) @endcode
* usually it would be:
* @code xkb_state_key_get_layout(state, key) @endcode
*
* @return The shift level index. If the key or layout are invalid,
* returns XKB_LEVEL_INVALID.
*
* @invariant If the returned level is valid, the following always holds:
* @code
* xkb_state_key_get_level(state, key, layout) < xkb_keymap_num_levels_for_key(keymap, key, layout)
* @endcode
*
* @memberof xkb_state
*/
xkb_level_index_t
xkb_state_key_get_level(struct xkb_state *state, xkb_keycode_t key,
xkb_layout_index_t layout);
/**
* Match flags for xkb_state_mod_indices_are_active() and
* xkb_state_mod_names_are_active(), specifying the conditions for a
* successful match. XKB_STATE_MATCH_NON_EXCLUSIVE is bitmaskable with
* the other modes.
*/
enum xkb_state_match {
/** Returns true if any of the modifiers are active. */
XKB_STATE_MATCH_ANY = (1 << 0),
/** Returns true if all of the modifiers are active. */
XKB_STATE_MATCH_ALL = (1 << 1),
/** Makes matching non-exclusive, i.e. will not return false if a
* modifier not specified in the arguments is active. */
XKB_STATE_MATCH_NON_EXCLUSIVE = (1 << 16)
};
/**
* The counterpart to xkb_state_update_mask for modifiers, to be used on
* the server side of serialization.
*
* @param state The keyboard state.
* @param components A mask of the modifier state components to serialize.
* State components other than XKB_STATE_MODS_* are ignored.
* If XKB_STATE_MODS_EFFECTIVE is included, all other state components are
* ignored.
*
* @returns A xkb_mod_mask_t representing the given components of the
* modifier state.
*
* This function should not be used in regular clients; please use the
* xkb_state_mod_*_is_active API instead.
*
* @memberof xkb_state
*/
xkb_mod_mask_t
xkb_state_serialize_mods(struct xkb_state *state,
enum xkb_state_component components);
/**
* The counterpart to xkb_state_update_mask for layouts, to be used on
* the server side of serialization.
*
* @param state The keyboard state.
* @param components A mask of the layout state components to serialize.
* State components other than XKB_STATE_LAYOUT_* are ignored.
* If XKB_STATE_LAYOUT_EFFECTIVE is included, all other state components are
* ignored.
*
* @returns A layout index representing the given components of the
* layout state.
*
* This function should not be used in regular clients; please use the
* xkb_state_layout_*_is_active API instead.
*
* @memberof xkb_state
*/
xkb_layout_index_t
xkb_state_serialize_layout(struct xkb_state *state,
enum xkb_state_component components);
/**
* Test whether a modifier is active in a given keyboard state by name.
*
* @returns 1 if the modifier is active, 0 if it is not. If the modifier
* name does not exist in the keymap, returns -1.
*
* @memberof xkb_state
*/
int
xkb_state_mod_name_is_active(struct xkb_state *state, const char *name,
enum xkb_state_component type);
/**
* Test whether a set of modifiers are active in a given keyboard state by
* name.
*
* @param state The keyboard state.
* @param type The component of the state against which to match the
* given modifiers.
* @param match The manner by which to match the state against the
* given modifiers.
* @param ... The set of of modifier names to test, terminated by a NULL
* argument (sentinel).
*
* @returns 1 if the modifiers are active, 0 if they are not. If any of
* the modifier names do not exist in the keymap, returns -1.
*
* @memberof xkb_state
*/
int
xkb_state_mod_names_are_active(struct xkb_state *state,
enum xkb_state_component type,
enum xkb_state_match match,
...);
/**
* Test whether a modifier is active in a given keyboard state by index.
*
* @returns 1 if the modifier is active, 0 if it is not. If the modifier
* index is invalid in the keymap, returns -1.
*
* @memberof xkb_state
*/
int
xkb_state_mod_index_is_active(struct xkb_state *state, xkb_mod_index_t idx,
enum xkb_state_component type);
/**
* Test whether a set of modifiers are active in a given keyboard state by
* index.
*
* @param state The keyboard state.
* @param type The component of the state against which to match the
* given modifiers.
* @param match The manner by which to match the state against the
* given modifiers.
* @param ... The set of of modifier indices to test, terminated by a
* XKB_MOD_INVALID argument (sentinel).
*
* @returns 1 if the modifiers are active, 0 if they are not. If any of
* the modifier indices are invalid in the keymap, returns -1.
*
* @memberof xkb_state
*/
int
xkb_state_mod_indices_are_active(struct xkb_state *state,
enum xkb_state_component type,
enum xkb_state_match match,
...);
/**
* @page consumed-modifiers Consumed Modifiers
* @parblock
*
* Some functions, like xkb_state_key_get_syms(), look at the state of
* the modifiers in the keymap and derive from it the correct shift level
* to use for the key. For example, in a US layout, pressing the key
* labeled \<A\> while the Shift modifier is active, generates the keysym
* 'A'. In this case, the Shift modifier is said to be "consumed".
* However, the Num Lock modifier does not affect this translation at all,
* even if it is active, so it is not consumed by this translation.
*
* It may be desirable for some application to not reuse consumed modifiers
* for further processing, e.g. for hotkeys or keyboard shortcuts. To
* understand why, consider some requirements from a standard shortcut
* mechanism, and how they are implemented:
*
* 1. The shortcut's modifiers must match exactly to the state. For
* example, it is possible to bind separate actions to \<Alt\>\<Tab\>
* and to \<Alt\>\<Shift\>\<Tab\>. Further, if only \<Alt\>\<Tab\> is
* bound to an action, pressing \<Alt\>\<Shift\>\<Tab\> should not
* trigger the shortcut.
* Effectively, this means that the modifiers are compared using the
* equality operator (==).
*
* 2. Only relevant modifiers are considered for the matching. For example,
* Caps Lock and Num Lock should not generally affect the matching, e.g.
* when matching \<Alt\>\<Tab\> against the state, it does not matter
* whether Num Lock is active or not. These relevant, or "significant",
* modifiers usually include Alt, Control, Shift, Super and similar.
* Effectively, this means that non-significant modifiers are masked out,
* before doing the comparison as described above.
*
* 3. The matching must be independent of the layout/keymap. For example,
* the \<Plus\> (+) symbol is found on the first level on some layouts,
* but requires holding Shift on others. If you simply bind the action
* to the \<Plus\> keysym, it would work for the unshifted kind, but
* not for the others, because the match against Shift would fail. If
* you bind the action to \<Shift\>\<Plus\>, only the shifted kind would
* work. So what is needed is to recognize that Shift is used up in the
* translation of the keysym itself, and therefore should not be included
* in the matching.
* Effectively, this means that consumed modifiers (Shift in this example)
* are masked out as well, before doing the comparison.
*
* In summary, this is approximately how the matching would be performed:
* @code
* (keysym == shortcut_keysym) &&
* ((state_mods & ~consumed_mods & significant_mods) == shortcut_mods)
* @endcode
*
* @c state_mods are the modifiers reported by
* xkb_state_mod_index_is_active() and similar functions.
* @c consumed_mods are the modifiers reported by
* xkb_state_mod_index_is_consumed() and similar functions.
* @c significant_mods are decided upon by the application/toolkit/user;
* it is up to them to decide whether these are configurable or hard-coded.
*
* @endparblock
*/
/**
* Consumed modifiers mode.
*
* There are several possible methods for deciding which modifiers are
* consumed and which are not, each applicable for different systems or
* situations. The mode selects the method to use.
*
* Keep in mind that in all methods, the keymap may decide to "preserve"
* a modifier, meaning it is not reported as consumed even if it would
* have otherwise.
*/
enum xkb_consumed_mode {
/**
* This is the mode defined in the XKB specification and used by libX11.
*
* A modifier is consumed if and only if it *may affect* key translation.
*
* For example, if `Control+Alt+<Backspace>` produces some assigned keysym,
* then when pressing just `<Backspace>`, `Control` and `Alt` are consumed,
* even though they are not active, since if they *were* active they would
* have affected key translation.
*/
XKB_CONSUMED_MODE_XKB,
/**
* This is the mode used by the GTK+ toolkit.
*
* The mode consists of the following two independent heuristics:
*
* - The currently active set of modifiers, excluding modifiers which do
* not affect the key (as described for @ref XKB_CONSUMED_MODE_XKB), are
* considered consumed, if the keysyms produced when all of them are
* active are different from the keysyms produced when no modifiers are
* active.
*
* - A single modifier is considered consumed if the keysyms produced for
* the key when it is the only active modifier are different from the
* keysyms produced when no modifiers are active.
*/
XKB_CONSUMED_MODE_GTK
};
/**
* Get the mask of modifiers consumed by translating a given key.
*
* @param state The keyboard state.
* @param key The keycode of the key.
* @param mode The consumed modifiers mode to use; see enum description.
*
* @returns a mask of the consumed modifiers.
*
* @memberof xkb_state
* @since 0.7.0
*/
xkb_mod_mask_t
xkb_state_key_get_consumed_mods2(struct xkb_state *state, xkb_keycode_t key,
enum xkb_consumed_mode mode);
/**
* Same as xkb_state_key_get_consumed_mods2() with mode XKB_CONSUMED_MODE_XKB.
*
* @memberof xkb_state
* @since 0.4.1
*/
xkb_mod_mask_t
xkb_state_key_get_consumed_mods(struct xkb_state *state, xkb_keycode_t key);
/**
* Test whether a modifier is consumed by keyboard state translation for
* a key.
*
* @param state The keyboard state.
* @param key The keycode of the key.
* @param idx The index of the modifier to check.
* @param mode The consumed modifiers mode to use; see enum description.
*
* @returns 1 if the modifier is consumed, 0 if it is not. If the modifier
* index is not valid in the keymap, returns -1.
*
* @sa xkb_state_mod_mask_remove_consumed()
* @sa xkb_state_key_get_consumed_mods()
* @memberof xkb_state
* @since 0.7.0
*/
int
xkb_state_mod_index_is_consumed2(struct xkb_state *state,
xkb_keycode_t key,
xkb_mod_index_t idx,
enum xkb_consumed_mode mode);
/**
* Same as xkb_state_mod_index_is_consumed2() with mode XKB_CONSUMED_MOD_XKB.
*
* @memberof xkb_state
* @since 0.4.1
*/
int
xkb_state_mod_index_is_consumed(struct xkb_state *state, xkb_keycode_t key,
xkb_mod_index_t idx);
/**
* Remove consumed modifiers from a modifier mask for a key.
*
* @deprecated Use xkb_state_key_get_consumed_mods2() instead.
*
* Takes the given modifier mask, and removes all modifiers which are
* consumed for that particular key (as in xkb_state_mod_index_is_consumed()).
*
* @sa xkb_state_mod_index_is_consumed()
* @memberof xkb_state
*/
xkb_mod_mask_t
xkb_state_mod_mask_remove_consumed(struct xkb_state *state, xkb_keycode_t key,
xkb_mod_mask_t mask);
/**
* Test whether a layout is active in a given keyboard state by name.
*
* @returns 1 if the layout is active, 0 if it is not. If no layout with
* this name exists in the keymap, return -1.
*
* If multiple layouts in the keymap have this name, the one with the lowest
* index is tested.
*
* @sa xkb_layout_index_t
* @memberof xkb_state
*/
int
xkb_state_layout_name_is_active(struct xkb_state *state, const char *name,
enum xkb_state_component type);
/**
* Test whether a layout is active in a given keyboard state by index.
*
* @returns 1 if the layout is active, 0 if it is not. If the layout index
* is not valid in the keymap, returns -1.
*
* @sa xkb_layout_index_t
* @memberof xkb_state
*/
int
xkb_state_layout_index_is_active(struct xkb_state *state,
xkb_layout_index_t idx,
enum xkb_state_component type);
/**
* Test whether a LED is active in a given keyboard state by name.
*
* @returns 1 if the LED is active, 0 if it not. If no LED with this name
* exists in the keymap, returns -1.
*
* @sa xkb_led_index_t
* @memberof xkb_state
*/
int
xkb_state_led_name_is_active(struct xkb_state *state, const char *name);
/**
* Test whether a LED is active in a given keyboard state by index.
*
* @returns 1 if the LED is active, 0 if it not. If the LED index is not
* valid in the keymap, returns -1.
*
* @sa xkb_led_index_t
* @memberof xkb_state
*/
int
xkb_state_led_index_is_active(struct xkb_state *state, xkb_led_index_t idx);
/** @} */
/* Leave this include last, so it can pick up our types, etc. */
#include <xkbcommon/xkbcommon-compat.h>
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* _XKBCOMMON_H_ */