|  |  |  | Libxklavier Reference Manual |  | 
|---|---|---|---|---|
                    XklEnginePrivate;
enum                XklEngineStateChange;
enum                XklEngineFeatures;
                    XklState;
                    XklEngine;
XklEngine*          xkl_engine_get_instance             (Display *display);
const gchar*        xkl_engine_get_backend_name         (XklEngine *engine);
guint               xkl_engine_get_features             (XklEngine *engine);
guint               xkl_engine_get_max_num_groups       (XklEngine *engine);
enum                XklEngineListenModes;
gint                xkl_engine_start_listen             (XklEngine *engine,
                                                         guint flags);
gint                xkl_engine_stop_listen              (XklEngine *engine);
gint                xkl_engine_pause_listen             (XklEngine *engine);
gint                xkl_engine_resume_listen            (XklEngine *engine);
gboolean            xkl_engine_grab_key                 (XklEngine *engine,
                                                         gint keycode,
                                                         guint modifiers);
gboolean            xkl_engine_ungrab_key               (XklEngine *engine,
                                                         gint keycode,
                                                         guint modifiers);
gint                xkl_engine_filter_events            (XklEngine *engine,
                                                         XEvent *evt);
void                xkl_engine_allow_one_switch_to_secondary_group
                                                        (XklEngine *engine);
Window              xkl_engine_get_current_window       (XklEngine *engine);
XklState*           xkl_engine_get_current_state        (XklEngine *engine);
gchar*              xkl_engine_get_window_title         (XklEngine *engine,
                                                         Window win);
gboolean            xkl_engine_get_state                (XklEngine *engine,
                                                         Window win,
                                                         XklState *state_out);
void                xkl_engine_delete_state             (XklEngine *engine,
                                                         Window win);
void                xkl_engine_save_state               (XklEngine *engine,
                                                         Window win,
                                                         XklState *state);
void                xkl_engine_set_window_transparent   (XklEngine *engine,
                                                         Window win,
                                                         gbooleantransparent );
gboolean            xkl_engine_is_window_transparent    (XklEngine *engine,
                                                         Window win);
gboolean            xkl_engine_is_window_from_same_toplevel_window
                                                        (XklEngine *engine,
                                                         Window win1,
                                                         Window win2);
guint               xkl_engine_get_num_groups           (XklEngine *engine);
const gchar**       xkl_engine_get_groups_names         (XklEngine *engine);
const gchar**       xkl_engine_get_indicators_names     (XklEngine *engine);
gint                xkl_engine_get_next_group           (XklEngine *engine);
gint                xkl_engine_get_prev_group           (XklEngine *engine);
gint                xkl_engine_get_current_window_group (XklEngine *engine);
void                xkl_engine_lock_group               (XklEngine *engine,
                                                         gint group);
void                xkl_engine_set_group_per_toplevel_window
                                                        (XklEngine *engine,
                                                         gbooleanis_global );
gboolean            xkl_engine_is_group_per_toplevel_window
                                                        (XklEngine *engine);
void                xkl_engine_set_indicators_handling  (XklEngine *engine,
                                                         gbooleanwhether_handle );
gboolean            xkl_engine_get_indicators_handling  (XklEngine *engine);
void                xkl_engine_set_secondary_groups_mask
                                                        (XklEngine *engine,
                                                         guint mask);
guint               xkl_engine_get_secondary_groups_mask
                                                        (XklEngine *engine);
	typedef enum {
		XKLF_CAN_TOGGLE_INDICATORS = 0x01,
		XKLF_CAN_OUTPUT_CONFIG_AS_ASCII = 0x02,
		XKLF_CAN_OUTPUT_CONFIG_AS_BINARY = 0x04,
		XKLF_MULTIPLE_LAYOUTS_SUPPORTED = 0x08,
		XKLF_REQUIRES_MANUAL_LAYOUT_MANAGEMENT = 0x10,
	} XklEngineFeatures;
typedef struct {
/** 
 * selected group 
 */
		gint32 group;
/**
 * set of active indicators
 */
		guint32 indicators;
} XklState;
typedef struct {
/**
 * The superclass object
 */
		GObject parent;
/**
 * Private data
 */
		XklEnginePrivate *priv;
} XklEngine;
XklEngine* xkl_engine_get_instance (Display *display);
Get the instance of the XklEngine. Within a process, there is always once instance.
| display: | the X display used by the application | 
| Returns : | the singleton instance | 
const gchar* xkl_engine_get_backend_name (XklEngine *engine);
What kind of backend is used
| engine: | the engine | 
| Returns : | some string id of the backend | 
guint xkl_engine_get_features (XklEngine *engine);
Provides information regarding available backend features (combination of XKLF_* constants)
| engine: | the engine | 
| Returns : | ORed XKLF_* constants | 
guint xkl_engine_get_max_num_groups (XklEngine *engine);
Provides the information on maximum number of simultaneously supported groups (layouts)
| engine: | the engine | 
| Returns : | maximum number of the groups in configuration, 0 if no restrictions. | 
	typedef enum {
		XKLL_MANAGE_WINDOW_STATES = 0x01,
		XKLL_TRACK_KEYBOARD_STATE = 0x02,
		XKLL_MANAGE_LAYOUTS = 0x04
	} XklEngineListenModes;
gint xkl_engine_start_listen (XklEngine *engine, guint flags);
Starts listening for XKB-related events
| engine: | the engine | 
| flags: | any combination of XKLL_* constants | 
| Returns : | 0 | 
gint xkl_engine_stop_listen (XklEngine *engine);
Stops listening for XKB-related events
| engine: | the engine | 
| Returns : | 0 | 
gint xkl_engine_pause_listen (XklEngine *engine);
Temporary pauses listening for XKB-related events
| engine: | the engine | 
| Returns : | 0 | 
gint xkl_engine_resume_listen (XklEngine *engine);
Resumes listening for XKB-related events
| engine: | the engine | 
| Returns : | 0 | 
gboolean xkl_engine_grab_key (XklEngine *engine, gint keycode, guint modifiers);
Grabs some key
| engine: | the engine | 
| keycode: | keycode | 
| modifiers: | bitmask of modifiers | 
| Returns : | TRUE on success | 
gboolean xkl_engine_ungrab_key (XklEngine *engine, gint keycode, guint modifiers);
Ungrabs some key
| engine: | the engine | 
| keycode: | keycode | 
| modifiers: | bitmask of modifiers | 
| Returns : | TRUE on success | 
gint xkl_engine_filter_events (XklEngine *engine, XEvent *evt);
Processes X events. Should be included into the main event cycle of an application. One of the most important functions.
| engine: | the engine | 
| evt: | delivered X event | 
| Returns : | 0 if the event it processed - 1 otherwise | 
void                xkl_engine_allow_one_switch_to_secondary_group
                                                        (XklEngine *engine);
Allows to switch (once) to the secondary group
| engine: | the engine | 
Window xkl_engine_get_current_window (XklEngine *engine);
| engine: | the engine | 
| Returns : | currently focused window | 
XklState* xkl_engine_get_current_state (XklEngine *engine);
| engine: | the engine | 
| Returns : | current state of the keyboard. Returned value is a statically allocated buffer, should not be freed. | 
gchar* xkl_engine_get_window_title (XklEngine *engine, Window win);
| engine: | the engine | 
| win: | X window | 
| Returns : | the window title of some window or NULL. If not NULL, it should be freed with XFree | 
gboolean xkl_engine_get_state (XklEngine *engine, Window win, XklState *state_out);
Finds the state for a given window (for its "App window").
| engine: | the engine | 
| win: | window to query | 
| state_out: | structure to store the state | 
| Returns : | TRUE on success, otherwise FALSE (the error message can be obtained using xkl_GetLastError). | 
void xkl_engine_delete_state (XklEngine *engine, Window win);
Drops the state of a given window (of its "App window").
| engine: | the engine | 
| win: | target window | 
void xkl_engine_save_state (XklEngine *engine, Window win, XklState *state);
Stores ths state for a given window
| engine: | the engine | 
| win: | target window | 
| state: | new state of the window | 
void xkl_engine_set_window_transparent (XklEngine *engine, Window win, gbooleantransparent );
Sets the "transparent" flag. It means focus switching onto this window will never change the state.
| engine: | the engine | 
| win: | window do set the flag for. | 
| Param3: | 
gboolean xkl_engine_is_window_transparent (XklEngine *engine, Window win);
| engine: | the engine | 
| win: | window to get the transparent flag from. | 
| Returns : | TRUE if the window is "transparent" | 
gboolean            xkl_engine_is_window_from_same_toplevel_window
                                                        (XklEngine *engine,
                                                         Window win1,
                                                         Window win2);
Checks whether 2 windows have the same topmost window
| engine: | the engine | 
| win1: | first window | 
| win2: | second window | 
| Returns : | TRUE is windows are in the same application | 
guint xkl_engine_get_num_groups (XklEngine *engine);
| engine: | the engine | 
| Returns : | the total number of groups in the current configuration (keyboard) | 
const gchar** xkl_engine_get_groups_names (XklEngine *engine);
| engine: | the engine | 
| Returns : | the array of group names for the current XKB configuration (keyboard). This array is static, should not be freed | 
const gchar** xkl_engine_get_indicators_names (XklEngine *engine);
| engine: | the engine | 
| Returns : | the array of indicator names for the current XKB configuration (keyboard). This array is static, should not be freed | 
gint xkl_engine_get_next_group (XklEngine *engine);
Calculates next group id. Does not change the state of anything.
| engine: | the engine | 
| Returns : | next group id | 
gint xkl_engine_get_prev_group (XklEngine *engine);
Calculates prev group id. Does not change the state of anything.
| engine: | the engine | 
| Returns : | prev group id | 
gint xkl_engine_get_current_window_group (XklEngine *engine);
| engine: | the engine | 
| Returns : | saved group id of the current window. | 
void xkl_engine_lock_group (XklEngine *engine, gint group);
Locks the group. Can be used after xkl_GetXXXGroup functions
| engine: | the engine | 
| group: | group number for locking | 
void                xkl_engine_set_group_per_toplevel_window
                                                        (XklEngine *engine,
                                                         gbooleanis_global );
Sets the configuration parameter: group per application
| engine: | the engine | 
| Param2: | 
gboolean            xkl_engine_is_group_per_toplevel_window
                                                        (XklEngine *engine);
| engine: | the engine | 
| Returns : | the value of the parameter: group per application | 
void xkl_engine_set_indicators_handling (XklEngine *engine, gbooleanwhether_handle );
Sets the configuration parameter: perform indicators handling
| engine: | the engine | 
| Param2: | 
gboolean xkl_engine_get_indicators_handling (XklEngine *engine);
| engine: | the engine | 
| Returns : | the value of the parameter: perform indicator handling | 
void                xkl_engine_set_secondary_groups_mask
                                                        (XklEngine *engine,
                                                         guint mask);
Sets the secondary groups (one bit per group). Secondary groups require explicit "allowance" for switching
| engine: | the engine | 
| mask: | new group mask | 
guint               xkl_engine_get_secondary_groups_mask
                                                        (XklEngine *engine);
| engine: | the engine | 
| Returns : | the secondary group mask |