From 518b5b5fbee268bbf8a8b7d310aebb45a79b9ee3 Mon Sep 17 00:00:00 2001 From: Sergey Udaltsov Date: Tue, 28 Feb 2006 01:46:06 +0000 Subject: more files gobjectified --- libxklavier/xklavier.c | 24 ++--- libxklavier/xklavier.h | 2 +- libxklavier/xklavier_config.c | 154 +++++++++++++++-------------- libxklavier/xklavier_config.h | 107 ++++++++++++++------ libxklavier/xklavier_config_xkb.c | 85 ++++++++++------ libxklavier/xklavier_config_xmm.c | 16 +-- libxklavier/xklavier_evt.c | 5 +- libxklavier/xklavier_evt_xkb.c | 37 +++---- libxklavier/xklavier_evt_xmm.c | 74 +++++++------- libxklavier/xklavier_private.h | 51 ++++++---- libxklavier/xklavier_private_xkb.h | 50 ++++++---- libxklavier/xklavier_private_xmm.h | 45 +++++---- libxklavier/xklavier_toplevel.c | 137 +++++++++++++++----------- libxklavier/xklavier_xkb.c | 193 +++++++++++++++++++------------------ libxklavier/xklavier_xmm.c | 140 ++++++++++++++------------- 15 files changed, 642 insertions(+), 478 deletions(-) diff --git a/libxklavier/xklavier.c b/libxklavier/xklavier.c index 5088c90..5c0dd03 100644 --- a/libxklavier/xklavier.c +++ b/libxklavier/xklavier.c @@ -545,9 +545,9 @@ xkl_engine_reset_all_info(XklEngine * engine, const gchar reason[]) reason); xkl_engine_ensure_vtable_inited(engine); if (!xkl_engine_vcall(engine, if_cached_info_equals_actual) - ()) { - xkl_engine_vcall(engine, free_all_info) (); - xkl_engine_vcall(engine, load_all_info) (); + (engine)) { + xkl_engine_vcall(engine, free_all_info) (engine); + xkl_engine_vcall(engine, load_all_info) (engine); } else xkl_debug(100, "NOT Resetting the cache: same configuration\n"); @@ -560,28 +560,28 @@ const gchar ** xkl_engine_groups_get_names(XklEngine * engine) { xkl_engine_ensure_vtable_inited(engine); - return (*engine->priv->get_groups_names) (); + return (*engine->priv->get_groups_names) (engine); } guint xkl_engine_get_num_groups(XklEngine * engine) { xkl_engine_ensure_vtable_inited(engine); - return (*engine->priv->get_num_groups) (); + return (*engine->priv->get_num_groups) (engine); } void -xkl_engine_group_lock(XklEngine * engine, int group) +xkl_engine_lock_group(XklEngine * engine, int group) { xkl_engine_ensure_vtable_inited(engine); - xkl_engine_vcall(engine, lock_group) (group); + xkl_engine_vcall(engine, lock_group) (engine, group); } gint xkl_engine_pause_listen(XklEngine * engine) { xkl_engine_ensure_vtable_inited(engine); - return xkl_engine_vcall(engine, pause_listen) (); + return xkl_engine_vcall(engine, pause_listen) (engine); } gint @@ -589,7 +589,7 @@ xkl_engine_resume_listen(XklEngine * engine) { xkl_engine_ensure_vtable_inited(engine); xkl_debug(150, "listenerType: %x\n", engine->priv->listener_type); - if (xkl_engine_vcall(engine, resume_listen) ()) + if (xkl_engine_vcall(engine, resume_listen) (engine)) return 1; xkl_engine_select_input_merging(engine, engine->priv->root_window, @@ -607,21 +607,21 @@ gboolean xkl_engine_load_all_info(XklEngine * engine) { xkl_engine_ensure_vtable_inited(engine); - return xkl_engine_vcall(engine, load_all_info) (); + return xkl_engine_vcall(engine, load_all_info) (engine); } void xkl_engine_free_all_info(XklEngine * engine) { xkl_engine_ensure_vtable_inited(engine); - xkl_engine_vcall(engine, free_all_info) (); + xkl_engine_vcall(engine, free_all_info) (engine); } guint xkl_engine_get_max_num_groups(XklEngine * engine) { xkl_engine_ensure_vtable_inited(engine); - return (*engine->priv->get_max_num_groups) (); + return (*engine->priv->get_max_num_groups) (engine); } XklEngine * diff --git a/libxklavier/xklavier.h b/libxklavier/xklavier.h index 90af274..6cd465c 100644 --- a/libxklavier/xklavier.h +++ b/libxklavier/xklavier.h @@ -230,7 +230,7 @@ extern "C" { * @param modifiers is a bitmask of modifiers * @return True on success */ - extern gboolean xkl_engine_key_ungrab(XklEngine * engine, + extern gboolean xkl_engine_ungrab_key(XklEngine * engine, gint keycode, unsigned modifiers); diff --git a/libxklavier/xklavier_config.c b/libxklavier/xklavier_config.c index 30ffcee..fec6ca8 100644 --- a/libxklavier/xklavier_config.c +++ b/libxklavier/xklavier_config.c @@ -4,27 +4,16 @@ #include #include -#include - #include "config.h" #include "xklavier_private.h" -typedef struct _XklConfigRegistry { - xmlDocPtr doc; - xmlXPathContextPtr xpath_context; -} XklConfigRegistry; - -static XklConfigRegistry the_registry; - static xmlXPathCompExprPtr models_xpath; static xmlXPathCompExprPtr layouts_xpath; static xmlXPathCompExprPtr option_groups_xpath; -#define xkl_config_registry_is_initialized() \ - ( the_registry.xpath_context != NULL ) - -static XklEngine *engine = NULL; +#define xkl_config_registry_is_initialized(config) \ + ( (config)->priv->xpath_context != NULL ) static xmlChar * xkl_node_get_xml_lang_attr(xmlNodePtr nptr) @@ -158,7 +147,7 @@ xkl_read_config_item(xmlNodePtr iptr, XklConfigItem * item) } static void -xkl_config_enum_from_node_set(xmlNodeSetPtr nodes, +xkl_config_enum_from_node_set(XklConfig * config, xmlNodeSetPtr nodes, ConfigItemProcessFunc func, gpointer data) { gint i; @@ -175,44 +164,47 @@ xkl_config_enum_from_node_set(xmlNodeSetPtr nodes, } static void -xkl_config_enum_simple(xmlXPathCompExprPtr xpath_comp_expr, +xkl_config_enum_simple(XklConfig * config, + xmlXPathCompExprPtr xpath_comp_expr, ConfigItemProcessFunc func, gpointer data) { xmlXPathObjectPtr xpath_obj; - if (!xkl_config_registry_is_initialized()) + if (!xkl_config_registry_is_initialized(config)) return; xpath_obj = xmlXPathCompiledEval(xpath_comp_expr, - the_registry.xpath_context); + config->priv->xpath_context); if (xpath_obj != NULL) { - xkl_config_enum_from_node_set(xpath_obj->nodesetval, func, + xkl_config_enum_from_node_set(config, + xpath_obj->nodesetval, func, data); xmlXPathFreeObject(xpath_obj); } } static void -xkl_config_enum_direct(const gchar * format, +xkl_config_enum_direct(XklConfig * config, const gchar * format, const gchar * value, ConfigItemProcessFunc func, gpointer data) { char xpath_expr[1024]; xmlXPathObjectPtr xpath_obj; - if (!xkl_config_registry_is_initialized()) + if (!xkl_config_registry_is_initialized(config)) return; snprintf(xpath_expr, sizeof xpath_expr, format, value); xpath_obj = xmlXPathEval((unsigned char *) xpath_expr, - the_registry.xpath_context); + config->priv->xpath_context); if (xpath_obj != NULL) { - xkl_config_enum_from_node_set(xpath_obj->nodesetval, func, + xkl_config_enum_from_node_set(config, + xpath_obj->nodesetval, func, data); xmlXPathFreeObject(xpath_obj); } } static gboolean -xkl_config_find_object(const gchar * format, +xkl_config_find_object(XklConfig * config, const gchar * format, const gchar * arg1, XklConfigItem * pitem /* in/out */ , xmlNodePtr * pnode /* out */ ) @@ -222,12 +214,12 @@ xkl_config_find_object(const gchar * format, gboolean rv = FALSE; gchar xpath_expr[1024]; - if (!xkl_config_registry_is_initialized()) + if (!xkl_config_registry_is_initialized(config)) return FALSE; snprintf(xpath_expr, sizeof xpath_expr, format, arg1, pitem->name); xpath_obj = xmlXPathEval((unsigned char *) xpath_expr, - the_registry.xpath_context); + config->priv->xpath_context); if (xpath_obj == NULL) return FALSE; @@ -316,7 +308,7 @@ xkl_engine_get_ruleset_name(XklEngine * engine, } void -xkl_config_init(XklEngine * engine) +xkl_config_init(XklConfig * config) { xmlXPathInit(); models_xpath = xmlXPathCompile((unsigned char *) @@ -327,8 +319,9 @@ xkl_config_init(XklEngine * engine) "/xkbConfigRegistry/optionList/group"); xkl_i18n_init(); + XklEngine *engine = xkl_config_get_engine(config); xkl_engine_ensure_vtable_inited(engine); - xkl_engine_vcall(engine, init_config) (); + xkl_engine_vcall(engine, init_config) (config); } void @@ -349,62 +342,68 @@ xkl_config_term(void) } gboolean -xkl_config_registry_load_from_file(const gchar * file_name) +xkl_config_registry_load_from_file(XklConfig * config, + const gchar * file_name) { - the_registry.doc = xmlParseFile(file_name); - if (the_registry.doc == NULL) { - the_registry.xpath_context = NULL; - engine->priv->last_error_message = + config->priv->doc = xmlParseFile(file_name); + if (config->priv->doc == NULL) { + config->priv->xpath_context = NULL; + xkl_config_get_engine(config)->priv->last_error_message = "Could not parse XKB configuration registry"; } else - the_registry.xpath_context = - xmlXPathNewContext(the_registry.doc); - return xkl_config_registry_is_initialized(); + config->priv->xpath_context = + xmlXPathNewContext(config->priv->doc); + return xkl_config_registry_is_initialized(config); } void -xkl_config_registry_free(void) +xkl_config_registry_free(XklConfig * config) { - if (xkl_config_registry_is_initialized()) { - xmlXPathFreeContext(the_registry.xpath_context); - xmlFreeDoc(the_registry.doc); - the_registry.xpath_context = NULL; - the_registry.doc = NULL; + if (xkl_config_registry_is_initialized(config)) { + xmlXPathFreeContext(config->priv->xpath_context); + xmlFreeDoc(config->priv->doc); + config->priv->xpath_context = NULL; + config->priv->doc = NULL; } } void -xkl_config_enum_models(ConfigItemProcessFunc func, gpointer data) +xkl_config_enum_models(XklConfig * config, ConfigItemProcessFunc func, + gpointer data) { - xkl_config_enum_simple(models_xpath, func, data); + xkl_config_enum_simple(config, models_xpath, func, data); } void -xkl_config_enum_layouts(ConfigItemProcessFunc func, gpointer data) +xkl_config_enum_layouts(XklConfig * config, ConfigItemProcessFunc func, + gpointer data) { - xkl_config_enum_simple(layouts_xpath, func, data); + xkl_config_enum_simple(config, layouts_xpath, func, data); } void -xkl_config_enum_layout_variants(const gchar * layout_name, +xkl_config_enum_layout_variants(XklConfig * config, + const gchar * layout_name, ConfigItemProcessFunc func, gpointer data) { xkl_config_enum_direct - ("/xkbConfigRegistry/layoutList/layout/variantList/variant[../../configItem/name = '%s']", + (config, + "/xkbConfigRegistry/layoutList/layout/variantList/variant[../../configItem/name = '%s']", layout_name, func, data); } void -xkl_config_enum_option_groups(GroupProcessFunc func, gpointer data) +xkl_config_enum_option_groups(XklConfig * config, GroupProcessFunc func, + gpointer data) { xmlXPathObjectPtr xpath_obj; gint i; - if (!xkl_config_registry_is_initialized()) + if (!xkl_config_registry_is_initialized(config)) return; xpath_obj = xmlXPathCompiledEval(option_groups_xpath, - the_registry.xpath_context); + config->priv->xpath_context); if (xpath_obj != NULL) { xmlNodeSetPtr nodes = xpath_obj->nodesetval; xmlNodePtr *pnode = nodes->nodeTab; @@ -435,54 +434,61 @@ xkl_config_enum_option_groups(GroupProcessFunc func, gpointer data) } void -xkl_config_enum_options(const gchar * option_group_name, +xkl_config_enum_options(XklConfig * config, + const gchar * option_group_name, ConfigItemProcessFunc func, gpointer data) { xkl_config_enum_direct - ("/xkbConfigRegistry/optionList/group/option[../configItem/name = '%s']", + (config, + "/xkbConfigRegistry/optionList/group/option[../configItem/name = '%s']", option_group_name, func, data); } gboolean -xkl_config_find_model(XklConfigItem * pitem /* in/out */ ) +xkl_config_find_model(XklConfig * config, + XklConfigItem * pitem /* in/out */ ) { return xkl_config_find_object - ("/xkbConfigRegistry/modelList/model[configItem/name = '%s%s']", + (config, + "/xkbConfigRegistry/modelList/model[configItem/name = '%s%s']", "", pitem, NULL); } gboolean -xkl_config_find_layout(XklConfigItem * pitem /* in/out */ ) +xkl_config_find_layout(XklConfig * config, + XklConfigItem * pitem /* in/out */ ) { return xkl_config_find_object - ("/xkbConfigRegistry/layoutList/layout[configItem/name = '%s%s']", + (config, + "/xkbConfigRegistry/layoutList/layout[configItem/name = '%s%s']", "", pitem, NULL); } gboolean -xkl_config_find_variant(const char *layout_name, +xkl_config_find_variant(XklConfig * config, const char *layout_name, XklConfigItem * pitem /* in/out */ ) { return xkl_config_find_object - ("/xkbConfigRegistry/layoutList/layout/variantList/variant" + (config, + "/xkbConfigRegistry/layoutList/layout/variantList/variant" "[../../configItem/name = '%s' and configItem/name = '%s']", layout_name, pitem, NULL); } gboolean -_xkl_config_find_option_group(XklConfigItem * pitem /* in/out */ , +_xkl_config_find_option_group(XklConfig * config, + XklConfigItem * pitem /* in/out */ , gboolean * allow_multiple_selection /* out */ ) { xmlNodePtr node; - gboolean rv = - xkl_config_find_object - ("/xkbConfigRegistry/optionList/group[configItem/name = '%s%s']", - "", - pitem, &node); + gboolean rv = xkl_config_find_object(config, + "/xkbConfigRegistry/optionList/group[configItem/name = '%s%s']", + "", + pitem, &node); if (rv && allow_multiple_selection != NULL) { xmlChar *val = xmlGetProp(node, @@ -499,12 +505,12 @@ _xkl_config_find_option_group(XklConfigItem * pitem /* in/out */ , } gboolean -xkl_config_find_option(const char *option_group_name, +xkl_config_find_option(XklConfig * config, const char *option_group_name, XklConfigItem * pitem /* in/out */ ) { return xkl_config_find_object - ("/xkbConfigRegistry/optionList/group/option" + (config, "/xkbConfigRegistry/optionList/group/option" "[../configItem/name = '%s' and configItem/name = '%s']", option_group_name, pitem, NULL); } @@ -513,23 +519,26 @@ xkl_config_find_option(const char *option_group_name, * Calling through vtable */ gboolean -xkl_config_activate(const XklConfigRec * data) +xkl_config_activate(XklConfig * config, const XklConfigRec * data) { + XklEngine *engine = xkl_config_get_engine(config); xkl_engine_ensure_vtable_inited(engine); - return xkl_engine_vcall(engine, activate_config) (data); + return xkl_engine_vcall(engine, activate_config) (config, data); } gboolean -xkl_config_registry_load(void) +xkl_config_registry_load(XklConfig * config) { + XklEngine *engine = xkl_config_get_engine(config); xkl_engine_ensure_vtable_inited(engine); - return xkl_engine_vcall(engine, load_config_registry) (); + return xkl_engine_vcall(engine, load_config_registry) (config); } gboolean -xkl_config_write_file(const gchar * file_name, +xkl_config_write_file(XklConfig * config, const gchar * file_name, const XklConfigRec * data, const gboolean binary) { + XklEngine *engine = xkl_config_get_engine(config); if ((!binary && !(engine->priv->features & XKLF_CAN_OUTPUT_CONFIG_AS_ASCII)) || (binary @@ -540,7 +549,8 @@ xkl_config_write_file(const gchar * file_name, return FALSE; } xkl_engine_ensure_vtable_inited(engine); - return xkl_engine_vcall(engine, write_config_to_file) (file_name, + return xkl_engine_vcall(engine, write_config_to_file) (config, + file_name, data, binary); } diff --git a/libxklavier/xklavier_config.h b/libxklavier/xklavier_config.h index 645f86e..c967eac 100644 --- a/libxklavier/xklavier_config.h +++ b/libxklavier/xklavier_config.h @@ -33,11 +33,23 @@ extern "C" { #ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef struct _XklConfig XklConfig; + typedef struct _XklConfigPrivate XklConfigPrivate; + typedef struct _XklConfigClass XklConfigClass; + typedef struct _XklConfigItem XklConfigItem; typedef struct _XklConfigItemClass XklConfigItemClass; + typedef struct _XklConfigRec XklConfigRec; typedef struct _XklConfigRecClass XklConfigRecClass; +#define XKL_TYPE_CONFIG (xkl_config_get_type ()) +#define XKL_CONFIG(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), XKL_TYPE_CONFIG, XklConfig)) +#define XKL_CONFIG_CLASS(obj) (G_TYPE_CHECK_CLASS_CAST ((obj), XKL_CONFIG, XklConfigClass)) +#define XKL_IS_CONFIG(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), XKL_TYPE_CONFIG)) +#define XKL_IS_CONFIG_CLASS(obj) (G_TYPE_CHECK_CLASS_TYPE ((obj), XKL_TYPE_CONFIG)) +#define XKL_CONFIG_GET_CLASS (G_TYPE_INSTANCE_GET_CLASS ((obj), XKL_TYPE_CONFIG, XklConfigClass)) + #define XKL_TYPE_CONFIG_ITEM (xkl_config_item_get_type ()) #define XKL_CONFIG_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), XKL_TYPE_CONFIG_ITEM, XklConfigItem)) #define XKL_CONFIG_ITEM_CLASS(obj) (G_TYPE_CHECK_CLASS_CAST ((obj), XKL_CONFIG_ITEM, XklConfigItemClass)) @@ -54,6 +66,41 @@ extern "C" { #endif // DOXYGEN_SHOULD_SKIP_THIS +/** + * The configuration manager. Corresponds to XML element "configItem". + */ + struct _XklConfig { +/** + * The superclass object + */ + GObject parent; + + XklConfigPrivate *priv; + }; + +/** + * The XklConfig class, derived from GObject + */ + struct _XklConfigClass { + /** + * The superclass + */ + GObjectClass parent_class; + }; +/** + * Get type info for XConfigRec + * @return GType for XConfigRec + */ + extern GType xkl_config_get_type(void); + +/** + * Create new XklConfigRec + * @return new instance + */ + extern XklConfig *xkl_config_get_instance(XklEngine * engine); + + + /** * The configuration item. Corresponds to XML element "configItem". */ @@ -152,34 +199,26 @@ extern "C" { * @{ */ -/** - * Initializes XML configuration-related structures - */ - extern void xkl_config_init(XklEngine * engine); - -/** - * Cleans XML configuration-related structures - */ - extern void xkl_config_term(void); - /** * Loads XML configuration registry * @param file_name file name to load * @return true on success */ - extern gboolean xkl_config_registry_load_from_file(const gchar * + extern gboolean xkl_config_load_registry_from_file(XklConfig * + config, + const gchar * file_name); /** * Loads XML configuration registry * @return true on success */ - extern gboolean xkl_config_registry_load(void); + extern gboolean xkl_config_load_registry(XklConfig * config); /** * Frees XML configuration registry */ - extern void xkl_config_registry_free(void); + extern void xkl_config_free_registry(XklConfig * config); /** @} */ /** @@ -210,7 +249,8 @@ extern "C" { * @param func is a callback to call for every model * @param data is anything which can be stored into the pointer */ - extern void xkl_config_enum_models(ConfigItemProcessFunc func, + extern void xkl_config_enum_models(XklConfig * config, + ConfigItemProcessFunc func, gpointer data); /** @@ -218,7 +258,8 @@ extern "C" { * @param func is a callback to call for every layout * @param data is anything which can be stored into the pointer */ - extern void xkl_config_enum_layouts(ConfigItemProcessFunc func, + extern void xkl_config_enum_layouts(XklConfig * config, + ConfigItemProcessFunc func, gpointer data); /** @@ -227,7 +268,8 @@ extern "C" { * @param func is a callback to call for every layout variant * @param data is anything which can be stored into the pointer */ - extern void xkl_config_enum_layout_variants(const gchar * + extern void xkl_config_enum_layout_variants(XklConfig * config, + const gchar * layout_name, ConfigItemProcessFunc func, gpointer data); @@ -237,7 +279,8 @@ extern "C" { * @param func is a callback to call for every option group * @param data is anything which can be stored into the pointer */ - extern void xkl_config_enum_option_groups(GroupProcessFunc func, + extern void xkl_config_enum_option_groups(XklConfig * config, + GroupProcessFunc func, gpointer data); /** @@ -247,7 +290,8 @@ extern "C" { * @param func is a callback to call for every option * @param data is anything which can be stored into the pointer */ - extern void xkl_config_enum_options(const gchar * + extern void xkl_config_enum_options(XklConfig * config, + const gchar * option_group_name, ConfigItemProcessFunc func, gpointer data); @@ -265,7 +309,8 @@ extern "C" { * keyboard model. On successfull return, the descriptions are filled. * @return TRUE if appropriate element was found and loaded */ - extern gboolean xkl_config_find_model(XklConfigItem * item); + extern gboolean xkl_config_find_model(XklConfig * config, + XklConfigItem * item); /** * Loads a keyboard layout information from the XML configuration registry. @@ -273,7 +318,8 @@ extern "C" { * keyboard layout. On successfull return, the descriptions are filled. * @return TRUE if appropriate element was found and loaded */ - extern gboolean xkl_config_find_layout(XklConfigItem * item); + extern gboolean xkl_config_find_layout(XklConfig * config, + XklConfigItem * item); /** * Loads a keyboard layout variant information from the XML configuration @@ -283,7 +329,8 @@ extern "C" { * keyboard layout variant. On successfull return, the descriptions are filled. * @return TRUE if appropriate element was found and loaded */ - extern gboolean xkl_config_find_variant(const char *layout_name, + extern gboolean xkl_config_find_variant(XklConfig * config, + const char *layout_name, XklConfigItem * item); /** @@ -295,7 +342,8 @@ extern "C" { * the corresponding attribute of XML element "group". * @return TRUE if appropriate element was found and loaded */ - extern gboolean xkl_config_find_option_group(XklConfigItem * item, + extern gboolean xkl_config_find_option_group(XklConfig * config, + XklConfigItem * item, gboolean * allow_multiple_selection); @@ -307,7 +355,8 @@ extern "C" { * keyboard option. On successfull return, the descriptions are filled. * @return TRUE if appropriate element was found and loaded */ - extern gboolean xkl_config_find_option(const gchar * + extern gboolean xkl_config_find_option(XklConfig * config, + const gchar * option_group_name, XklConfigItem * item); /** @} */ @@ -325,14 +374,16 @@ extern "C" { * @see XklSetKeyAsSwitcher * At the moment, accepts only _ONE_ layout. Later probably I'll improve this.. */ - extern gboolean xkl_config_activate(const XklConfigRec * data); + extern gboolean xkl_config_activate(XklConfig * config, + const XklConfigRec * data); /** * Loads the current XKB configuration (from X server) * @param data is a buffer for XKB configuration * @return TRUE on success */ - extern gboolean xkl_config_get_from_server(XklConfigRec * data); + extern gboolean xkl_config_get_from_server(XklConfig * config, + XklConfigRec * data); /** * Loads the current XKB configuration (from backup) @@ -340,7 +391,8 @@ extern "C" { * @return TRUE on success * @see XklBackupNamesProp */ - extern gboolean xkl_config_get_from_backup(XklConfigRec * data); + extern gboolean xkl_config_get_from_backup(XklConfig * config, + XklConfigRec * data); /** * Writes some XKB configuration into XKM/XKB file @@ -350,7 +402,8 @@ extern "C" { * @param binary is a flag indicating whether the output file should be binary * @return TRUE on success */ - extern gboolean xkl_config_write_file(const gchar * file_name, + extern gboolean xkl_config_write_file(XklConfig * config, + const gchar * file_name, const XklConfigRec * data, const gboolean binary); diff --git a/libxklavier/xklavier_config_xkb.c b/libxklavier/xklavier_config_xkb.c index d221695..7c4a336 100644 --- a/libxklavier/xklavier_config_xkb.c +++ b/libxklavier/xklavier_config_xkb.c @@ -33,15 +33,16 @@ static XkbRF_RulesPtr xkl_rules; static XkbRF_RulesPtr -xkl_rules_set_load(void) +xkl_rules_set_load(XklEngine * engine) { XkbRF_RulesPtr rules_set = NULL; char file_name[MAXPATHLEN] = ""; - char *rf = xkl_rules_set_get_name(XKB_DEFAULT_RULESET); + char *rf = + xkl_engine_get_ruleset_name(engine, XKB_DEFAULT_RULESET); char *locale = NULL; if (rf == NULL) { - xkl_last_error_message = + engine->priv->last_error_message = "Could not find the XKB rules set"; return NULL; } @@ -54,7 +55,7 @@ xkl_rules_set_load(void) rules_set = XkbRF_Load(file_name, locale, True, True); if (rules_set == NULL) { - xkl_last_error_message = "Could not load rules"; + engine->priv->last_error_message = "Could not load rules"; return NULL; } return rules_set; @@ -78,11 +79,13 @@ xkl_xkb_config_init(void) } gboolean -xkl_xkb_config_registry_load(void) +xkl_xkb_load_config_registry(XklConfig * config) { struct stat stat_buf; char file_name[MAXPATHLEN] = ""; - char *rf = xkl_rules_set_get_name(XKB_DEFAULT_RULESET); + char *rf = + xkl_engine_get_ruleset_name(xkl_config_get_engine(config), + XKB_DEFAULT_RULESET); if (rf == NULL) return FALSE; @@ -95,12 +98,13 @@ xkl_xkb_config_registry_load(void) sizeof file_name); } - return xkl_config_registry_load_from_file(file_name); + return xkl_config_load_registry_from_file(config, file_name); } #ifdef XKB_HEADERS_PRESENT gboolean -xkl_xkb_config_native_prepare(const XklConfigRec * data, +xkl_xkb_config_native_prepare(XklConfig * config, + const XklConfigRec * data, XkbComponentNamesPtr component_names_ptr) { XkbRF_VarDefsRec xkl_var_defs; @@ -108,7 +112,8 @@ xkl_xkb_config_native_prepare(const XklConfigRec * data, memset(&xkl_var_defs, 0, sizeof(xkl_var_defs)); - xkl_rules = xkl_rules_set_load(); + XklEngine *engine = xkl_config_get_engine(config); + xkl_rules = xkl_rules_set_load(engine); if (!xkl_rules) { return FALSE; } @@ -133,10 +138,10 @@ xkl_xkb_config_native_prepare(const XklConfigRec * data, g_free(xkl_var_defs.options); if (!got_components) { - xkl_last_error_message = + engine->priv->last_error_message = "Could not translate rules into components"; /* Just cleanup the stuff in case of failure */ - xkl_xkb_config_native_cleanup(component_names_ptr); + xkl_xkb_config_native_cleanup(config, component_names_ptr); return FALSE; } @@ -158,7 +163,8 @@ xkl_xkb_config_native_prepare(const XklConfigRec * data, } void -xkl_xkb_config_native_cleanup(XkbComponentNamesPtr component_names_ptr) +xkl_xkb_config_native_cleanup(XklConfig * config, + XkbComponentNamesPtr component_names_ptr) { xkl_rules_set_free(); @@ -171,7 +177,8 @@ xkl_xkb_config_native_cleanup(XkbComponentNamesPtr component_names_ptr) } static XkbDescPtr -xkl_config_get_keyboard(XkbComponentNamesPtr component_names_ptr, +xkl_config_get_keyboard(XklConfig * config, + XkbComponentNamesPtr component_names_ptr, gboolean activate) { XkbDescPtr xkb = NULL; @@ -190,6 +197,9 @@ xkl_config_get_keyboard(XkbComponentNamesPtr component_names_ptr, XkbFileInfo result; int xkmloadres; + XklEngine *engine = xkl_config_get_engine(config); + Display *display = xkl_engine_get_display(engine); + if (tmpnam(xkm_fn) != NULL && tmpnam(xkb_fn) != NULL) { pid_t cpid, pid; int status = 0; @@ -259,7 +269,7 @@ xkl_config_get_keyboard(XkbComponentNamesPtr component_names_ptr, result.xkb = XkbAllocKeyboard(); if (Success == - XkbChangeKbdDisplay(xkl_display, + XkbChangeKbdDisplay(display, &result)) { xkl_debug(150, "Hacked the kbddesc - set the display...\n"); @@ -382,7 +392,7 @@ _XklXkbConfigCleanupNative(gpointer componentNamesPtr) /* check only client side support */ gboolean -xkl_xkb_config_multiple_layouts_supported(void) +xkl_xkb_config_multiple_layouts_supported(XklConfig * config) { enum { NON_SUPPORTED, SUPPORTED, UNCHECKED }; @@ -405,11 +415,13 @@ xkl_xkb_config_multiple_layouts_supported(void) xkl_debug(100, "!!! Checking multiple layouts support\n"); support_state = NON_SUPPORTED; #ifdef XKB_HEADERS_PRESENT - if (xkl_xkb_config_native_prepare(&data, &component_names)) { + if (xkl_xkb_config_native_prepare + (config, &data, &component_names)) { xkl_debug(100, "!!! Multiple layouts ARE supported\n"); support_state = SUPPORTED; - xkl_xkb_config_native_cleanup(&component_names); + xkl_xkb_config_native_cleanup(config, + &component_names); } else { xkl_debug(100, "!!! Multiple layouts ARE NOT supported\n"); @@ -420,7 +432,7 @@ xkl_xkb_config_multiple_layouts_supported(void) } gboolean -xkl_xkb_config_activate(const XklConfigRec * data) +xkl_xkb_activate_config(XklConfig * config, const XklConfigRec * data) { gboolean rv = FALSE; #if 0 @@ -445,37 +457,43 @@ xkl_xkb_config_activate(const XklConfigRec * data) #ifdef XKB_HEADERS_PRESENT XkbComponentNamesRec component_names; memset(&component_names, 0, sizeof(component_names)); + XklEngine *engine = xkl_config_get_engine(config); - if (xkl_xkb_config_native_prepare(data, &component_names)) { + if (xkl_xkb_config_native_prepare(config, data, &component_names)) { XkbDescPtr xkb; - xkb = xkl_config_get_keyboard(&component_names, TRUE); + xkb = + xkl_config_get_keyboard(config, &component_names, + TRUE); if (xkb != NULL) { if (xkl_set_names_prop - (xkl_vtable->base_config_atom, - xkl_rules_set_get_name(XKB_DEFAULT_RULESET), + (engine->priv->base_config_atom, + xkl_engine_get_ruleset_name(engine, + XKB_DEFAULT_RULESET), data)) /* We do not need to check the result of _XklGetRulesSetName - because PrepareBeforeKbd did it for us */ rv = TRUE; else - xkl_last_error_message = + engine->priv->last_error_message = "Could not set names property"; XkbFreeKeyboard(xkb, XkbAllComponentsMask, True); } else { - xkl_last_error_message = + engine->priv->last_error_message = "Could not load keyboard description"; } - xkl_xkb_config_native_cleanup(&component_names); + xkl_xkb_config_native_cleanup(config, &component_names); } #endif return rv; } gboolean -xkl_xkb_config_write_file(const char *file_name, - const XklConfigRec * data, const gboolean binary) +xkl_xkb_write_config_to_file(XklConfig * config, const char *file_name, + const XklConfigRec * data, + const gboolean binary) { gboolean rv = FALSE; + XklEngine *engine = xkl_config_get_engine(config); #ifdef XKB_HEADERS_PRESENT XkbComponentNamesRec component_names; @@ -483,15 +501,18 @@ xkl_xkb_config_write_file(const char *file_name, XkbFileInfo dump_info; if (output == NULL) { - xkl_last_error_message = "Could not open the XKB file"; + engine->priv->last_error_message = + "Could not open the XKB file"; return FALSE; } memset(&component_names, 0, sizeof(component_names)); - if (xkl_xkb_config_native_prepare(data, &component_names)) { + if (xkl_xkb_config_native_prepare(config, data, &component_names)) { XkbDescPtr xkb; - xkb = xkl_config_get_keyboard(&component_names, FALSE); + xkb = + xkl_config_get_keyboard(config, &component_names, + FALSE); if (xkb != NULL) { dump_info.defined = 0; dump_info.xkb = xkb; @@ -505,9 +526,9 @@ xkl_xkb_config_write_file(const char *file_name, XkbFreeKeyboard(xkb, XkbGBN_AllComponentsMask, True); } else - xkl_last_error_message = + engine->priv->last_error_message = "Could not load keyboard description"; - xkl_xkb_config_native_cleanup(&component_names); + xkl_xkb_config_native_cleanup(config, &component_names); } fclose(output); #endif diff --git a/libxklavier/xklavier_config_xmm.c b/libxklavier/xklavier_config_xmm.c index 1fa618b..e6447dd 100644 --- a/libxklavier/xklavier_config_xmm.c +++ b/libxklavier/xklavier_config_xmm.c @@ -25,11 +25,12 @@ xkl_xmm_config_init(void) } gboolean -xkl_xmm_config_registry_load(void) +xkl_xmm_load_config_registry(XklConfig * config) { struct stat stat_buf; gchar file_name[MAXPATHLEN] = ""; - gchar *rf = xkl_rules_set_get_name(""); + XklEngine *engine = xkl_config_get_engine(config); + gchar *rf = xkl_engine_get_ruleset_name(engine, ""); if (rf == NULL || rf[0] == '\0') return FALSE; @@ -38,20 +39,21 @@ xkl_xmm_config_registry_load(void) rf); if (stat(file_name, &stat_buf) != 0) { - xkl_last_error_message = "No rules file found"; + engine->priv->last_error_message = "No rules file found"; return FALSE; } - return xkl_config_registry_load_from_file(file_name); + return xkl_config_load_registry_from_file(config, file_name); } gboolean -xkl_xmm_config_activate(const XklConfigRec * data) +xkl_xmm_activate_config(XklConfig * config, const XklConfigRec * data) { gboolean rv; - rv = xkl_set_names_prop(xkl_vtable->base_config_atom, + XklEngine *engine = xkl_config_get_engine(config); + rv = xkl_set_names_prop(engine->priv->base_config_atom, current_xmm_rules, data); if (rv) - xkl_xmm_group_lock(0); + xkl_xmm_lock_group(engine, 0); return rv; } diff --git a/libxklavier/xklavier_evt.c b/libxklavier/xklavier_evt.c index a6238fa..50344a8 100644 --- a/libxklavier/xklavier_evt.c +++ b/libxklavier/xklavier_evt.c @@ -15,7 +15,7 @@ xkl_engine_events_filter(XklEngine * engine, XEvent * xev) "**> Filtering event %d of type %d from window %d\n", pe->serial, pe->type, pe->window); xkl_engine_ensure_vtable_inited(engine); - if (!xkl_engine_vcall(engine, process_x_event) (xev)) + if (!xkl_engine_vcall(engine, process_x_event) (engine, xev)) switch (xev->type) { /* core events */ case FocusIn: xkl_engine_process_focus_in_evt(engine, @@ -222,7 +222,8 @@ xkl_engine_process_focus_in_evt(XklEngine * engine, (engine); xkl_engine_vcall(engine, set_indicators) - (&selected_window_state); + (engine, + &selected_window_state); } else xkl_debug(150, "Not restoring the indicators %X after gaining focus: indicator handling is not enabled\n", diff --git a/libxklavier/xklavier_evt_xkb.c b/libxklavier/xklavier_evt_xkb.c index eb23aa1..485e7e0 100644 --- a/libxklavier/xklavier_evt_xkb.c +++ b/libxklavier/xklavier_evt_xkb.c @@ -12,7 +12,7 @@ * XKB event handler */ gint -xkl_xkb_process_x_event(XEvent * xev) +xkl_xkb_process_x_event(XklEngine * engine, XEvent * xev) { #ifdef XKB_HEADERS_PRESENT gint i; @@ -23,7 +23,7 @@ xkl_xkb_process_x_event(XEvent * xev) if (xev->type != xkl_xkb_event_type) return 0; - if (!(xkl_listener_type & + if (!(engine->priv->listener_type & (XKLL_MANAGE_WINDOW_STATES | XKLL_TRACK_KEYBOARD_STATE))) return 0; @@ -43,19 +43,20 @@ xkl_xkb_process_x_event(XEvent * xev) kev->state.locked_group); if (kev->state.changed & GROUP_CHANGE_MASK) - xkl_process_state_modification(GROUP_CHANGED, - kev->state. - locked_group, 0, - FALSE); + xkl_engine_process_state_modification(engine, + GROUP_CHANGED, + kev->state. + locked_group, + 0, FALSE); else { /* ...not interested... */ xkl_debug(200, "This type of state notification is not regarding groups\n"); if (kev->state.locked_group != - xkl_current_state.group) + engine->priv->curr_state.group) xkl_debug(0, "ATTENTION! Currently cached group %d is not equal to the current group from the event: %d\n!", - xkl_current_state.group, + engine->priv->curr_state.group, kev->state.locked_group); } @@ -68,7 +69,7 @@ xkl_xkb_process_x_event(XEvent * xev) xkl_debug(150, "XkbIndicatorStateNotify\n"); - inds = xkl_current_state.indicators; + inds = engine->priv->curr_state.indicators; ForPhysIndicators(i, bit) if (kev->indicators.changed & bit) { @@ -78,8 +79,9 @@ xkl_xkb_process_x_event(XEvent * xev) inds &= ~bit; } - xkl_process_state_modification(INDICATORS_CHANGED, - 0, inds, TRUE); + xkl_engine_process_state_modification(engine, + INDICATORS_CHANGED, + 0, inds, TRUE); break; /** @@ -98,7 +100,8 @@ xkl_xkb_process_x_event(XEvent * xev) case XkbNewKeyboardNotify: xkl_debug(150, "%s\n", xkl_xkb_event_get_name(kev->any.xkb_type)); - xkl_reset_all_info("XKB event: XkbNewKeyboardNotify"); + xkl_engine_reset_all_info(engine, + "XKB event: XkbNewKeyboardNotify"); break; /** @@ -117,7 +120,7 @@ xkl_xkb_process_x_event(XEvent * xev) } void -xkl_xkb_indicators_set(const XklState * window_state) +xkl_xkb_set_indicators(XklEngine * engine, const XklState * window_state) { #ifdef XKB_HEADERS_PRESENT int i; @@ -127,11 +130,11 @@ xkl_xkb_indicators_set(const XklState * window_state) bit) if (xkl_xkb_desc->names->indicators[i] != None) { gboolean status; - status = xkl_indicator_set(i, - (window_state-> - indicators & bit) != 0); + status = xkl_engine_set_indicator(engine, i, + (window_state-> + indicators & bit) != 0); xkl_debug(150, "Set indicator \"%s\"/%d to %d: %d\n", - xkl_indicator_names[i], + xkl_xkb_indicator_names[i], xkl_xkb_desc->names->indicators[i], window_state->indicators & bit, status); } diff --git a/libxklavier/xklavier_evt_xmm.c b/libxklavier/xklavier_evt_xmm.c index 2eae35f..05b0b02 100644 --- a/libxklavier/xklavier_evt_xmm.c +++ b/libxklavier/xklavier_evt_xmm.c @@ -10,19 +10,19 @@ #include "xklavier_private_xmm.h" static gint -xkl_xmm_process_keypress_event(XKeyPressedEvent * kpe) +xkl_xmm_process_keypress_event(XklEngine * engine, XKeyPressedEvent * kpe) { - if (xkl_listener_type & XKLL_MANAGE_LAYOUTS) { + if (engine->priv->listener_type & XKLL_MANAGE_LAYOUTS) { xkl_debug(200, "Processing the KeyPress event\n"); gint current_shortcut = 0; const XmmSwitchOption *sop = - xkl_xmm_switch_option_find(kpe->keycode, + xkl_xmm_find_switch_option(engine, kpe->keycode, kpe->state, ¤t_shortcut); if (sop != NULL) { xkl_debug(150, "It is THE shortcut\n"); XklState state; - xkl_xmm_state_get_server(&state); + xkl_xmm_get_server_state(engine, &state); if (state.group != -1) { gint new_group = (state.group + @@ -33,7 +33,7 @@ xkl_xmm_process_keypress_event(XKeyPressedEvent * kpe) xkl_debug(150, "Setting new xmm group %d\n", new_group); - xkl_xmm_group_lock(new_group); + xkl_xmm_lock_group(engine, new_group); return 1; } } @@ -42,7 +42,7 @@ xkl_xmm_process_keypress_event(XKeyPressedEvent * kpe) } static gint -xkl_xmm_process_property_event(XPropertyEvent * kpe) +xkl_xmm_process_property_event(XklEngine * engine, XPropertyEvent * kpe) { xkl_debug(200, "Processing the PropertyNotify event: %d/%d\n", kpe->atom, xmm_state_atom); @@ -51,35 +51,37 @@ xkl_xmm_process_property_event(XPropertyEvent * kpe) */ if (kpe->atom == xmm_state_atom) { XklState state; - xkl_xmm_state_get_server(&state); + xkl_xmm_get_server_state(engine, &state); - if (xkl_listener_type & XKLL_MANAGE_LAYOUTS) { + if (engine->priv->listener_type & XKLL_MANAGE_LAYOUTS) { xkl_debug(150, "Current group from the root window property %d\n", state.group); - xkl_xmm_shortcuts_ungrab(); - xkl_xmm_group_actualize(state.group); - xkl_xmm_shortcuts_grab(); + xkl_xmm_shortcuts_ungrab(engine); + xkl_xmm_actualize_group(engine, state.group); + xkl_xmm_shortcuts_grab(engine); return 1; } - if (xkl_listener_type & + if (engine->priv->listener_type & (XKLL_MANAGE_WINDOW_STATES | XKLL_TRACK_KEYBOARD_STATE)) { xkl_debug(150, "XMM state changed, new 'group' %d\n", state.group); - xkl_process_state_modification(GROUP_CHANGED, - state.group, - 0, False); + xkl_engine_process_state_modification(engine, + GROUP_CHANGED, + state.group, + 0, False); } } else /** * Configuration is changed! */ - if (kpe->atom == xkl_vtable->base_config_atom) { - xkl_reset_all_info("base config atom changed"); + if (kpe->atom == engine->priv->base_config_atom) { + xkl_engine_reset_all_info(engine, + "base config atom changed"); } return 0; @@ -89,14 +91,16 @@ xkl_xmm_process_property_event(XPropertyEvent * kpe) * XMM event handler */ gint -xkl_xmm_process_x_event(XEvent * xev) +xkl_xmm_process_x_event(XklEngine * engine, XEvent * xev) { switch (xev->type) { case KeyPress: - return xkl_xmm_process_keypress_event((XKeyPressedEvent *) + return xkl_xmm_process_keypress_event(engine, + (XKeyPressedEvent *) xev); case PropertyNotify: - return xkl_xmm_process_property_event((XPropertyEvent *) + return xkl_xmm_process_property_event(engine, + (XPropertyEvent *) xev); } return 0; @@ -107,7 +111,8 @@ xkl_xmm_process_x_event(XEvent * xev) * belong to Caps/Num/Scroll lock */ static void -xkl_xmm_init_xmm_indicators_map(guint * p_caps_lock_mask, +xkl_xmm_init_xmm_indicators_map(XklEngine * engine, + guint * p_caps_lock_mask, guint * p_num_lock_mask, guint * p_scroll_lock_mask) { @@ -115,11 +120,12 @@ xkl_xmm_init_xmm_indicators_map(guint * p_caps_lock_mask, KeyCode *kcmap, nlkc, clkc, slkc; int m, k, mask; - xmkm = XGetModifierMapping(xkl_display); + Display *display = xkl_engine_get_display(engine); + xmkm = XGetModifierMapping(display); if (xmkm) { - clkc = XKeysymToKeycode(xkl_display, XK_Num_Lock); - nlkc = XKeysymToKeycode(xkl_display, XK_Caps_Lock); - slkc = XKeysymToKeycode(xkl_display, XK_Scroll_Lock); + clkc = XKeysymToKeycode(display, XK_Num_Lock); + nlkc = XKeysymToKeycode(display, XK_Caps_Lock); + slkc = XKeysymToKeycode(display, XK_Scroll_Lock); kcmap = xmkm->modifiermap; mask = 1; @@ -137,15 +143,16 @@ xkl_xmm_init_xmm_indicators_map(guint * p_caps_lock_mask, } void -xkl_xmm_grab_ignoring_indicators(gint keycode, guint modifiers) +xkl_xmm_grab_ignoring_indicators(XklEngine * engine, gint keycode, + guint modifiers) { guint caps_lock_mask = 0, num_lock_mask = 0, scroll_lock_mask = 0; - xkl_xmm_init_xmm_indicators_map(&caps_lock_mask, &num_lock_mask, - &scroll_lock_mask); + xkl_xmm_init_xmm_indicators_map(engine, &caps_lock_mask, + &num_lock_mask, &scroll_lock_mask); #define GRAB(mods) \ - xkl_key_grab( keycode, modifiers|(mods) ) + xkl_engine_grab_key(engine, keycode, modifiers|(mods)) GRAB(0); GRAB(caps_lock_mask); @@ -159,15 +166,16 @@ xkl_xmm_grab_ignoring_indicators(gint keycode, guint modifiers) } void -xkl_xmm_ungrab_ignoring_indicators(gint keycode, guint modifiers) +xkl_xmm_ungrab_ignoring_indicators(XklEngine * engine, gint keycode, + guint modifiers) { guint caps_lock_mask = 0, num_lock_mask = 0, scroll_lock_mask = 0; - xkl_xmm_init_xmm_indicators_map(&caps_lock_mask, &num_lock_mask, - &scroll_lock_mask); + xkl_xmm_init_xmm_indicators_map(engine, &caps_lock_mask, + &num_lock_mask, &scroll_lock_mask); #define UNGRAB(mods) \ - xkl_key_ungrab( keycode, modifiers|(mods) ) + xkl_engine_ungrab_key(engine, keycode, modifiers|(mods)) UNGRAB(0); UNGRAB(caps_lock_mask); diff --git a/libxklavier/xklavier_private.h b/libxklavier/xklavier_private.h index 64e4cd2..bdf974b 100644 --- a/libxklavier/xklavier_private.h +++ b/libxklavier/xklavier_private.h @@ -3,6 +3,8 @@ #include +#include + #include enum { WM_NAME, @@ -60,14 +62,15 @@ struct _XklEnginePrivate { * xkb: create proper the XkbDescRec and send it to the server * xmodmap: save the property, init layout #1 */ - gboolean(*activate_config) (const XklConfigRec * data); + gboolean(*activate_config) (XklConfig * config, + const XklConfigRec * data); /** * Background-specific initialization. * xkb: XkbInitAtoms - init internal xkb atoms table * xmodmap: void. */ - void (*init_config) (void); + void (*init_config) (XklConfig * config); /** * Loads the registry tree into DOM (using whatever path(s)) @@ -75,7 +78,7 @@ struct _XklEnginePrivate { * xkb: loads xml from XKB_BASE+"/rules/"+ruleset+".xml" * xmodmap: loads xml from XMODMAP_BASE+"/"+ruleset+".xml" */ - gboolean(*load_config_registry) (void); + gboolean(*load_config_registry) (XklConfig * config); /** * Write the configuration into the file (binary/textual) @@ -83,7 +86,8 @@ struct _XklEnginePrivate { * xmodmap: if text requested, just dump XklConfigRec to the * file - not really useful. If binary - fail (not supported) */ - gboolean(*write_config_to_file) (const gchar * file_name, + gboolean(*write_config_to_file) (XklConfig * config, + const gchar * file_name, const XklConfigRec * data, const gboolean binary); @@ -92,21 +96,21 @@ struct _XklEnginePrivate { * xkb: return cached list of the group names * xmodmap: return the list of layouts from the internal XklConfigRec */ - const gchar **(*get_groups_names) (void); + const gchar **(*get_groups_names) (XklEngine * engine); /** * Get the maximum number of loaded groups * xkb: returns 1 or XkbNumKbdGroups * xmodmap: return 0 */ - guint(*get_max_num_groups) (void); + guint(*get_max_num_groups) (XklEngine * engine); /** * Get the number of loaded groups * xkb: return from the cached XkbDesc * xmodmap: return number of layouts from internal XklConfigRec */ - guint(*get_num_groups) (void); + guint(*get_num_groups) (XklEngine * engine); /** * Switches the keyboard to the group N @@ -114,63 +118,65 @@ struct _XklEnginePrivate { * xmodmap: changes the root window property * (listener invokes xmodmap with appropriate config file). */ - void (*lock_group) (gint group); + void (*lock_group) (XklEngine * engine, gint group); /** * Handles X events. * xkb: XkbEvent handling * xmodmap: keep track on the root window properties. What else can we do? */ - gint(*process_x_event) (XEvent * xev); + gint(*process_x_event) (XklEngine * engine, XEvent * xev); /** * Flushes the cached server config info. * xkb: frees XkbDesc * xmodmap: frees internal XklConfigRec */ - void (*free_all_info) (void); + void (*free_all_info) (XklEngine * engine); /** * Compares the cached info with the actual one, from the server * xkb: Compares some parts of XkbDescPtr * xmodmap: returns False */ - gboolean(*if_cached_info_equals_actual) (void); + gboolean(*if_cached_info_equals_actual) (XklEngine * engine); /** * Loads the configuration info from the server * xkb: loads XkbDesc, names, indicators * xmodmap: loads internal XklConfigRec from server */ - gboolean(*load_all_info) (void); + gboolean(*load_all_info) (XklEngine * engine); /** * Gets the current state * xkb: XkbGetState and XkbGetIndicatorState * xmodmap: check the root window property (regarding the group) */ - void (*get_server_state) (XklState * current_state_out); + void (*get_server_state) (XklEngine * engine, + XklState * current_state_out); /** * Stop tracking the keyboard-related events * xkb: XkbSelectEvents(..., 0) * xmodmap: Ungrab the switching shortcut. */ - gint(*pause_listen) (void); + gint(*pause_listen) (XklEngine * engine); /** * Start tracking the keyboard-related events * xkb: XkbSelectEvents + XkbSelectEventDetails * xmodmap: Grab the switching shortcut. */ - gint(*resume_listen) (void); + gint(*resume_listen) (XklEngine * engine); /** * Set the indicators state from the XklState * xkb: XklSetIndicator for all indicators * xmodmap: NULL. Not supported */ - void (*set_indicators) (const XklState * window_state); + void (*set_indicators) (XklEngine * engine, + const XklState * window_state); /* all data is private - no direct access */ /** @@ -201,6 +207,13 @@ struct _XklEnginePrivate { extern XklEngine *xkl_get_the_engine(void); +struct _XklConfigPrivate { + XklEngine *engine; + + xmlDocPtr doc; + + xmlXPathContextPtr xpath_context; +}; extern void xkl_engine_ensure_vtable_inited(XklEngine * engine); @@ -282,7 +295,7 @@ extern Status xkl_status_query_tree(Window w, Window ** children_out, guint * nchildren_out); -extern gboolean xkl_engine_indicator_set(XklEngine * engine, +extern gboolean xkl_engine_set_indicator(XklEngine * engine, gint indicator_num, gboolean set); extern void xkl_engine_try_call_state_func(XklEngine * engine, @@ -295,7 +308,8 @@ extern gchar *xkl_locale_from_utf8(const gchar * utf8string); extern gint xkl_get_language_priority(const gchar * language); -extern gchar *xkl_engine_get_ruleset_name(XklEngine * engine, const gchar default_ruleset[]); +extern gchar *xkl_engine_get_ruleset_name(XklEngine * engine, + const gchar default_ruleset[]); extern gboolean xkl_config_get_full_from_server(gchar ** rules_file_out, XklConfigRec * data); @@ -351,6 +365,7 @@ extern void xkl_engine_one_switch_to_secondary_group_performed(XklEngine * #define xkl_engine_get_display(engine) ((engine)->priv->display) #define xkl_engine_vcall(engine,func) (*(engine)->priv->func) +#define xkl_config_get_engine(config) ((config)->priv->engine) extern gint xkl_debug_level; diff --git a/libxklavier/xklavier_private_xkb.h b/libxklavier/xklavier_private_xkb.h index 0701e20..1c70624 100644 --- a/libxklavier/xklavier_private_xkb.h +++ b/libxklavier/xklavier_private_xkb.h @@ -16,54 +16,62 @@ extern XkbRF_VarDefsRec xkl_var_defs; extern XkbDescPtr xkl_xkb_desc; +extern gchar *xkl_xkb_indicator_names[]; + extern void xkl_dump_xkb_desc(const char *file_name, XkbDescPtr kbd); -extern gboolean xkl_xkb_config_multiple_layouts_supported(void); +extern gboolean xkl_xkb_multiple_layouts_supported(XklEngine * engine); extern const gchar *xkl_xkb_event_get_name(gint xkb_type); -extern gboolean xkl_xkb_config_native_prepare(const XklConfigRec * data, +extern gboolean xkl_xkb_config_native_prepare(XklConfig * config, + const XklConfigRec * data, XkbComponentNamesPtr component_names); -extern void xkl_xkb_config_native_cleanup(XkbComponentNamesPtr +extern void xkl_xkb_config_native_cleanup(XklConfig * config, + XkbComponentNamesPtr component_names); /* Start VTable methods */ -extern gboolean xkl_xkb_config_activate(const XklConfigRec * data); +extern gboolean xkl_xkb_activate_config(XklConfig * config, + const XklConfigRec * data); -extern void xkl_xkb_config_init(void); +extern void xkl_xkb_init_config(XklConfig * config); -extern gboolean xkl_xkb_config_registry_load(void); +extern gboolean xkl_xkb_load_config_registry(XklConfig * config); -extern gboolean xkl_xkb_config_write_file(const char *file_name, - const XklConfigRec * data, - const gboolean binary); +extern gboolean xkl_xkb_write_config_to_file(XklConfig * config, + const char *file_name, + const XklConfigRec * data, + const gboolean binary); -extern gint xkl_xkb_process_x_event(XEvent * kev); +extern gint xkl_xkb_process_x_event(XklEngine * engine, XEvent * kev); -extern void xkl_xkb_free_all_info(void); +extern void xkl_xkb_free_all_info(XklEngine * engine); -extern const gchar **xkl_xkb_groups_get_names(void); +extern const gchar **xkl_xkb_get_groups_names(XklEngine * engine); -extern guint xkl_xkb_groups_get_max_num(void); +extern guint xkl_xkb_get_max_num_groups(XklEngine * engine); -extern guint xkl_xkb_groups_get_num(void); +extern guint xkl_xkb_get_num_groups(XklEngine * engine); -extern void xkl_xkb_state_get_server(XklState * current_state_out); +extern void xkl_xkb_get_server_state(XklEngine * engine, + XklState * current_state_out); -extern gboolean xkl_xkb_if_cached_info_equals_actual(void); +extern gboolean xkl_xkb_if_cached_info_equals_actual(XklEngine * engine); -extern gboolean xkl_xkb_load_all_info(void); +extern gboolean xkl_xkb_load_all_info(XklEngine * engine); -extern void xkl_xkb_group_lock(gint group); +extern void xkl_xkb_lock_group(XklEngine * engine, gint group); -extern gint xkl_xkb_listen_pause(void); +extern gint xkl_xkb_pause_listen(XklEngine * engine); -extern gint xkl_xkb_listen_resume(void); +extern gint xkl_xkb_resume_listen(XklEngine * engine); -extern void xkl_xkb_indicators_set(const XklState * window_state); +extern void xkl_xkb_set_indicators(XklEngine * engine, + const XklState * window_state); /* End of VTable methods */ diff --git a/libxklavier/xklavier_private_xmm.h b/libxklavier/xklavier_private_xmm.h index c63f45b..cdb74a8 100644 --- a/libxklavier/xklavier_private_xmm.h +++ b/libxklavier/xklavier_private_xmm.h @@ -22,56 +22,61 @@ extern Atom xmm_state_atom; /* in the ideal world this should be a hashmap */ extern XmmSwitchOption all_switch_options[]; -extern void xkl_xmm_grab_ignoring_indicators(gint keycode, +extern void xkl_xmm_grab_ignoring_indicators(XklEngine * engine, + gint keycode, guint modifiers); -extern void xkl_xmm_ungrab_ignoring_indicators(gint keycode, +extern void xkl_xmm_ungrab_ignoring_indicators(XklEngine * engine, + gint keycode, guint modifiers); -extern void xkl_xmm_shortcuts_grab(void); +extern void xkl_xmm_shortcuts_grab(XklEngine * engine); -extern void xkl_xmm_shortcuts_ungrab(void); +extern void xkl_xmm_shortcuts_ungrab(XklEngine * engine); extern const gchar *xkl_xmm_shortcut_get_current_option_name(void); XmmSwitchOption *xkl_xmm_shortcut_get_current(void); -extern void xkl_xmm_group_actualize(gint group); +extern void xkl_xmm_actualize_group(XklEngine * engine, gint group); -const XmmSwitchOption *xkl_xmm_switch_option_find(gint keycode, +const XmmSwitchOption *xkl_xmm_find_switch_option(XklEngine * engine, + gint keycode, guint state, gint * current_shortcut_out); /* Start VTable methods */ -extern gboolean xkl_xmm_config_activate(const XklConfigRec * data); +extern gboolean xkl_xmm_activate_config(XklConfig * config, + const XklConfigRec * data); -extern void xkl_xmm_config_init(void); +extern void xkl_xmm_init_config(XklConfig * config); -extern gboolean xkl_xmm_config_registry_load(void); +extern gboolean xkl_xmm_load_config_registry(XklConfig * config); -extern gint xkl_xmm_process_x_event(XEvent * kev); +extern gint xkl_xmm_process_x_event(XklEngine * engine, XEvent * kev); -extern void xkl_xmm_free_all_info(void); +extern void xkl_xmm_free_all_info(XklEngine * engine); -extern const gchar **xkl_xmm_groups_get_names(void); +extern const gchar **xkl_xmm_get_groups_names(XklEngine * engine); -extern guint xkl_xmm_groups_get_max_num(void); +extern guint xkl_xmm_get_max_num_groups(XklEngine * engine); -extern guint xkl_xmm_groups_get_num(void); +extern guint xkl_xmm_get_num_groups(XklEngine * engine); -extern void xkl_xmm_group_lock(gint group); +extern void xkl_xmm_lock_group(XklEngine * engine, gint group); -extern void xkl_xmm_state_get_server(XklState * current_state_out); +extern void xkl_xmm_get_server_state(XklEngine * engine, + XklState * current_state_out); -extern gboolean xkl_xmm_if_cached_info_equals_actual(void); +extern gboolean xkl_xmm_if_cached_info_equals_actual(XklEngine * engine); -extern gboolean xkl_xmm_load_all_info(void); +extern gboolean xkl_xmm_load_all_info(XklEngine * engine); -extern gint xkl_xmm_listen_pause(void); +extern gint xkl_xmm_listen_pause(XklEngine * engine); -extern gint xkl_xmm_listen_resume(void); +extern gint xkl_xmm_listen_resume(XklEngine * engine); /* End of VTable methods */ diff --git a/libxklavier/xklavier_toplevel.c b/libxklavier/xklavier_toplevel.c index f9f31ea..69b9959 100644 --- a/libxklavier/xklavier_toplevel.c +++ b/libxklavier/xklavier_toplevel.c @@ -10,23 +10,28 @@ Window xkl_toplevel_window_prev; void -xkl_toplevel_window_set_transparent(Window toplevel_win, - gboolean transparent) +xkl_engine_set_toplevel_window_transparent(XklEngine * engine, + Window toplevel_win, + gboolean transparent) { gboolean oldval; - oldval = xkl_window_is_transparent(toplevel_win); + oldval = + xkl_engine_is_toplevel_window_transparent(engine, + toplevel_win); xkl_debug(150, "toplevel_win " WINID_FORMAT " was %stransparent\n", toplevel_win, oldval ? "" : "not "); if (transparent && !oldval) { CARD32 prop = 1; - XChangeProperty(xkl_display, toplevel_win, - xkl_atoms[XKLAVIER_TRANSPARENT], + XChangeProperty(xkl_engine_get_display(engine), + toplevel_win, + engine->priv->atoms[XKLAVIER_TRANSPARENT], XA_INTEGER, 32, PropModeReplace, (const unsigned char *) &prop, 1); } else if (!transparent && oldval) { - XDeleteProperty(xkl_display, toplevel_win, - xkl_atoms[XKLAVIER_TRANSPARENT]); + XDeleteProperty(xkl_engine_get_display(engine), + toplevel_win, + engine->priv->atoms[XKLAVIER_TRANSPARENT]); } } @@ -37,25 +42,28 @@ xkl_toplevel_window_set_transparent(Window toplevel_win, * Note: User's callback is called */ void -xkl_toplevel_window_add(Window toplevel_win, Window parent, - gboolean ignore_existing_state, - XklState * init_state) +xkl_engine_add_toplevel_window(XklEngine * engine, Window toplevel_win, + Window parent, + gboolean ignore_existing_state, + XklState * init_state) { XklState state = *init_state; gint default_group_to_use = -1; - if (toplevel_win == xkl_root_window) + if (toplevel_win == engine->priv->root_window) xkl_debug(150, "??? root app win ???\n"); xkl_debug(150, "Trying to add window " WINID_FORMAT "/%s with group %d\n", toplevel_win, - xkl_window_get_debug_title(toplevel_win), + xkl_get_debug_window_title(toplevel_win), init_state->group); if (!ignore_existing_state) { gboolean have_state = - xkl_toplevel_window_get_state(toplevel_win, &state); + xkl_engine_get_toplevel_window_state(engine, + toplevel_win, + &state); if (have_state) { xkl_debug(150, @@ -66,27 +74,33 @@ xkl_toplevel_window_add(Window toplevel_win, Window parent, } } +/* TODO if (xkl_new_window_callback != NULL) default_group_to_use = (*xkl_new_window_callback) (toplevel_win, parent, xkl_new_window_callback_data); +*/ if (default_group_to_use == -1) - default_group_to_use = xkl_default_group; + default_group_to_use = engine->priv->default_group; if (default_group_to_use != -1) state.group = default_group_to_use; - xkl_toplevel_window_save_state(toplevel_win, &state); - xkl_select_input_merging(toplevel_win, - FocusChangeMask | PropertyChangeMask); + xkl_engine_save_toplevel_window_state(engine, toplevel_win, + &state); + xkl_engine_select_input_merging(engine, toplevel_win, + FocusChangeMask | + PropertyChangeMask); if (default_group_to_use != -1) { - if (xkl_current_client == toplevel_win) { - if ((xkl_secondary_groups_mask & + if (engine->priv->curr_toplvl_win == toplevel_win) { + if ((engine->priv->secondary_groups_mask & (1 << default_group_to_use)) != 0) - xkl_group_allow_one_switch_to_secondary(); - xkl_group_lock(default_group_to_use); + xkl_engine_allow_one_switch_to_secondary_group + (engine); + xkl_engine_lock_group(engine, + default_group_to_use); } } @@ -100,16 +114,18 @@ xkl_toplevel_window_add(Window toplevel_win, Window parent, * Checks the window and goes up */ gboolean -xkl_toplevel_window_find_bottom_to_top(Window win, - Window * toplevel_win_out) +xkl_engine_find_toplevel_window_bottom_to_top(XklEngine * engine, + Window win, + Window * toplevel_win_out) { Window parent = (Window) NULL, rwin = (Window) NULL, *children = NULL; guint num = 0; - if (win == (Window) NULL || win == xkl_root_window) { + if (win == (Window) NULL || win == engine->priv->root_window) { *toplevel_win_out = win; - xkl_last_error_message = "The window is either 0 or root"; + engine->priv->last_error_message = + "The window is either 0 or root"; return FALSE; } @@ -118,10 +134,10 @@ xkl_toplevel_window_find_bottom_to_top(Window win, return TRUE; } - xkl_last_error_code = + engine->priv->last_error_code = xkl_status_query_tree(win, &rwin, &parent, &children, &num); - if (xkl_last_error_code != Success) { + if (engine->priv->last_error_code != Success) { *toplevel_win_out = (Window) NULL; return FALSE; } @@ -129,8 +145,9 @@ xkl_toplevel_window_find_bottom_to_top(Window win, if (children != NULL) XFree(children); - return xkl_toplevel_window_find_bottom_to_top(parent, - toplevel_win_out); + return xkl_engine_find_toplevel_window_bottom_to_top(engine, + parent, + toplevel_win_out); } /** @@ -141,16 +158,18 @@ xkl_toplevel_window_find_bottom_to_top(Window win, * NOTE: root window cannot be "App window" under normal circumstances */ gboolean -xkl_toplevel_window_find(Window win, Window * toplevel_win_out) +xkl_engine_find_toplevel_window(XklEngine * engine, Window win, + Window * toplevel_win_out) { Window parent = (Window) NULL, rwin = (Window) NULL, *children = NULL, *child; guint num = 0; gboolean rv; - if (win == (Window) NULL || win == xkl_root_window) { + if (win == (Window) NULL || win == engine->priv->root_window) { *toplevel_win_out = (Window) NULL; - xkl_last_error_message = "The window is either 0 or root"; + engine->priv->last_error_message = + "The window is either 0 or root"; xkl_debug(150, "Window " WINID_FORMAT " is either 0 or root so could not get the app window for it\n", @@ -163,10 +182,10 @@ xkl_toplevel_window_find(Window win, Window * toplevel_win_out) return TRUE; } - xkl_last_error_code = + engine->priv->last_error_code = xkl_status_query_tree(win, &rwin, &parent, &children, &num); - if (xkl_last_error_code != Success) { + if (engine->priv->last_error_code != Success) { *toplevel_win_out = (Window) NULL; xkl_debug(150, "Could not get tree for window " WINID_FORMAT @@ -194,13 +213,13 @@ xkl_toplevel_window_find(Window win, Window * toplevel_win_out) if (children != NULL) XFree(children); - rv = xkl_toplevel_window_find_bottom_to_top(parent, - toplevel_win_out); + rv = xkl_engine_find_toplevel_window_bottom_to_top(engine, parent, + toplevel_win_out); if (!rv) xkl_debug(200, "Could not get the app window for " WINID_FORMAT - "/%s\n", win, xkl_window_get_debug_title(win)); + "/%s\n", win, xkl_get_debug_window_title(win)); return rv; } @@ -209,7 +228,9 @@ xkl_toplevel_window_find(Window win, Window * toplevel_win_out) * Gets the state from the window property */ gboolean -xkl_toplevel_window_get_state(Window toplevel_win, XklState * state_out) +xkl_engine_get_toplevel_window_state(XklEngine * engine, + Window toplevel_win, + XklState * state_out) { Atom type_ret; int format_ret; @@ -221,13 +242,14 @@ xkl_toplevel_window_get_state(Window toplevel_win, XklState * state_out) guint inds = 0; if ((XGetWindowProperty - (xkl_display, toplevel_win, xkl_atoms[XKLAVIER_STATE], 0L, - XKLAVIER_STATE_PROP_LENGTH, False, - XA_INTEGER, &type_ret, &format_ret, &nitems, &rest, + (xkl_engine_get_display(engine), toplevel_win, + engine->priv->atoms[XKLAVIER_STATE], 0L, + XKLAVIER_STATE_PROP_LENGTH, False, XA_INTEGER, &type_ret, + &format_ret, &nitems, &rest, (unsigned char **) (void *) &prop) == Success) && (type_ret == XA_INTEGER) && (format_ret == 32)) { grp = prop[0]; - if (grp >= xkl_groups_get_num() || grp < 0) + if (grp >= xkl_engine_get_num_groups(engine) || grp < 0) grp = 0; inds = prop[1]; @@ -247,13 +269,13 @@ xkl_toplevel_window_get_state(Window toplevel_win, XklState * state_out) "Appwin " WINID_FORMAT ", '%s' has the group %d, indicators %X\n", toplevel_win, - xkl_window_get_debug_title(toplevel_win), grp, + xkl_get_debug_window_title(toplevel_win), grp, inds); else xkl_debug(150, "Appwin " WINID_FORMAT ", '%s' does not have state\n", toplevel_win, - xkl_window_get_debug_title(toplevel_win)); + xkl_get_debug_window_title(toplevel_win)); return ret; } @@ -262,26 +284,29 @@ xkl_toplevel_window_get_state(Window toplevel_win, XklState * state_out) * Deletes the state from the window properties */ void -xkl_toplevel_window_remove_state(Window toplevel_win) +xkl_engine_remove_toplevel_window_state(XklEngine * engine, + Window toplevel_win) { - XDeleteProperty(xkl_display, toplevel_win, - xkl_atoms[XKLAVIER_STATE]); + XDeleteProperty(xkl_engine_get_display(engine), toplevel_win, + engine->priv->atoms[XKLAVIER_STATE]); } /** * Saves the state into the window properties */ void -xkl_toplevel_window_save_state(Window toplevel_win, XklState * state) +xkl_engine_save_toplevel_window_state(XklEngine * engine, + Window toplevel_win, + XklState * state) { CARD32 prop[XKLAVIER_STATE_PROP_LENGTH]; prop[0] = state->group; prop[1] = state->indicators; - XChangeProperty(xkl_display, toplevel_win, - xkl_atoms[XKLAVIER_STATE], XA_INTEGER, 32, - PropModeReplace, (const unsigned char *) prop, + XChangeProperty(xkl_engine_get_display(engine), toplevel_win, + engine->priv->atoms[XKLAVIER_STATE], XA_INTEGER, + 32, PropModeReplace, (const unsigned char *) prop, XKLAVIER_STATE_PROP_LENGTH); xkl_debug(160, @@ -291,16 +316,18 @@ xkl_toplevel_window_save_state(Window toplevel_win, XklState * state) } gboolean -xkl_toplevel_window_is_transparent(Window toplevel_win) +xkl_engine_is_toplevel_window_transparent(XklEngine * engine, + Window toplevel_win) { Atom type_ret; int format_ret; unsigned long nitems, rest; CARD32 *prop = NULL; if ((XGetWindowProperty - (xkl_display, toplevel_win, xkl_atoms[XKLAVIER_TRANSPARENT], - 0L, 1, False, XA_INTEGER, &type_ret, &format_ret, &nitems, - &rest, (unsigned char **) (void *) &prop) == Success) + (xkl_engine_get_display(engine), toplevel_win, + engine->priv->atoms[XKLAVIER_TRANSPARENT], 0L, 1, False, + XA_INTEGER, &type_ret, &format_ret, &nitems, &rest, + (unsigned char **) (void *) &prop) == Success) && (type_ret == XA_INTEGER) && (format_ret == 32)) { if (prop != NULL) XFree(prop); diff --git a/libxklavier/xklavier_xkb.c b/libxklavier/xklavier_xkb.c index fb439e2..fbd7699 100644 --- a/libxklavier/xklavier_xkb.c +++ b/libxklavier/xklavier_xkb.c @@ -14,22 +14,23 @@ XkbDescPtr xkl_xkb_desc; static XkbDescPtr precached_xkb = NULL; -gchar *xkl_indicator_names[XkbNumIndicators]; - gint xkl_xkb_event_type, xkl_xkb_error_code; +gchar *xkl_xkb_indicator_names[XkbNumIndicators]; + static gchar *group_names[XkbNumKbdGroups]; const gchar ** -xkl_xkb_groups_get_names(void) +xkl_xkb_get_groups_names(XklEngine * engine) { return (const gchar **) group_names; } gint -xkl_xkb_listen_pause(void) +xkl_xkb_pause_listen(XklEngine * engine) { - XkbSelectEvents(xkl_display, XkbUseCoreKbd, XkbAllEventsMask, 0); + XkbSelectEvents(xkl_engine_get_display(engine), XkbUseCoreKbd, + XkbAllEventsMask, 0); /* XkbSelectEventDetails( xkl_display, XkbUseCoreKbd, XkbStateNotify, @@ -42,7 +43,7 @@ xkl_xkb_listen_pause(void) } gint -xkl_xkb_listen_resume(void) +xkl_xkb_resume_listen(XklEngine * engine) { /* What events we want */ #define XKB_EVT_MASK \ @@ -53,13 +54,14 @@ xkl_xkb_listen_resume(void) XkbIndicatorMapNotifyMask| \ XkbNewKeyboardNotifyMask) - XkbSelectEvents(xkl_display, XkbUseCoreKbd, XKB_EVT_MASK, + Display *display = xkl_engine_get_display(engine); + XkbSelectEvents(display, XkbUseCoreKbd, XKB_EVT_MASK, XKB_EVT_MASK); #define XKB_STATE_EVT_DTL_MASK \ (XkbGroupStateMask) - XkbSelectEventDetails(xkl_display, + XkbSelectEventDetails(display, XkbUseCoreKbd, XkbStateNotify, XKB_STATE_EVT_DTL_MASK, @@ -68,7 +70,7 @@ xkl_xkb_listen_resume(void) #define XKB_NAMES_EVT_DTL_MASK \ (XkbGroupNamesMask|XkbIndicatorNamesMask) - XkbSelectEventDetails(xkl_display, + XkbSelectEventDetails(display, XkbUseCoreKbd, XkbNamesNotify, XKB_NAMES_EVT_DTL_MASK, @@ -77,14 +79,14 @@ xkl_xkb_listen_resume(void) } guint -xkl_xkb_groups_get_max_num(void) +xkl_xkb_get_max_num_groups(XklEngine * engine) { - return xkl_vtable->features & XKLF_MULTIPLE_LAYOUTS_SUPPORTED ? + return engine->priv->features & XKLF_MULTIPLE_LAYOUTS_SUPPORTED ? XkbNumKbdGroups : 1; } guint -xkl_xkb_groups_get_num(void) +xkl_xkb_get_num_groups(XklEngine * engine) { return xkl_xkb_desc->ctrls->num_groups; } @@ -97,10 +99,10 @@ xkl_xkb_groups_get_num(void) ( XkbGroupNamesMask | XkbIndicatorNamesMask ) void -xkl_xkb_free_all_info(void) +xkl_xkb_free_all_info(XklEngine * engine) { gint i; - gchar **pi = xkl_indicator_names; + gchar **pi = xkl_xkb_indicator_names; for (i = 0; i < XkbNumIndicators; i++, pi++) { /* only free non-empty ones */ if (*pi && **pi) @@ -127,26 +129,28 @@ xkl_xkb_free_all_info(void) } static gboolean -xkl_xkb_load_precached_xkb(void) +xkl_xkb_load_precached_xkb(XklEngine * engine) { gboolean rv = FALSE; Status status; - precached_xkb = XkbGetMap(xkl_display, KBD_MASK, XkbUseCoreKbd); + Display *display = xkl_engine_get_display(engine); + precached_xkb = XkbGetMap(display, KBD_MASK, XkbUseCoreKbd); if (precached_xkb != NULL) { - rv = Success == (status = XkbGetControls(xkl_display, + rv = Success == (status = XkbGetControls(display, CTRLS_MASK, precached_xkb)) && - Success == (status = XkbGetNames(xkl_display, + Success == (status = XkbGetNames(display, NAMES_MASK, precached_xkb)) && - Success == (status = XkbGetIndicatorMap(xkl_display, + Success == (status = XkbGetIndicatorMap(display, XkbAllIndicatorsMask, precached_xkb)); if (!rv) { - xkl_last_error_message = + engine->priv->last_error_message = "Could not load controls/names/indicators"; - xkl_debug(0, "%s: %d\n", xkl_last_error_message, + xkl_debug(0, "%s: %d\n", + engine->priv->last_error_message, status); XkbFreeKeyboard(precached_xkb, XkbAllComponentsMask, True); @@ -156,13 +160,13 @@ xkl_xkb_load_precached_xkb(void) } gboolean -xkl_xkb_if_cached_info_equals_actual(void) +xkl_xkb_if_cached_info_equals_actual(XklEngine * engine) { gint i; Atom *pa1, *pa2; gboolean rv = FALSE; - if (xkl_xkb_load_precached_xkb()) { + if (xkl_xkb_load_precached_xkb(engine)) { /* First, compare the number of groups */ if (xkl_xkb_desc->ctrls->num_groups == precached_xkb->ctrls->num_groups) { @@ -205,16 +209,18 @@ xkl_xkb_if_cached_info_equals_actual(void) * Load some XKB parameters */ gboolean -xkl_xkb_load_all_info(void) +xkl_xkb_load_all_info(XklEngine * engine) { gint i; Atom *pa; gchar **group_name; - gchar **pi = xkl_indicator_names; + gchar **pi = xkl_xkb_indicator_names; + Display *display = xkl_engine_get_display(engine); if (precached_xkb == NULL) - if (!xkl_xkb_load_precached_xkb()) { - xkl_last_error_message = "Could not load keyboard"; + if (!xkl_xkb_load_precached_xkb(engine)) { + engine->priv->last_error_message = + "Could not load keyboard"; return FALSE; } @@ -232,19 +238,20 @@ xkl_xkb_load_all_info(void) for (i = xkl_xkb_desc->ctrls->num_groups; --i >= 0; pa++, group_name++) { *group_name = - XGetAtomName(xkl_display, - *pa == None ? XInternAtom(xkl_display, + XGetAtomName(display, + *pa == None ? XInternAtom(display, "-", False) : *pa); xkl_debug(200, "Group %d has name [%s]\n", i, *group_name); } - xkl_last_error_code = - XkbGetIndicatorMap(xkl_display, XkbAllIndicatorsMask, + engine->priv->last_error_code = + XkbGetIndicatorMap(display, XkbAllIndicatorsMask, xkl_xkb_desc); - if (xkl_last_error_code != Success) { - xkl_last_error_message = "Could not load indicator map"; + if (engine->priv->last_error_code != Success) { + engine->priv->last_error_message = + "Could not load indicator map"; return FALSE; } @@ -253,7 +260,7 @@ xkl_xkb_load_all_info(void) for (i = XkbNumIndicators; --i >= 0; pi++, pa++) { Atom a = *pa; if (a != None) - *pi = XGetAtomName(xkl_display, a); + *pi = XGetAtomName(display, a); else *pi = ""; @@ -262,35 +269,39 @@ xkl_xkb_load_all_info(void) xkl_debug(200, "Real indicators are %X\n", xkl_xkb_desc->indicators->phys_indicators); - +// TODO +#if 0 if (xkl_config_callback != NULL) (*xkl_config_callback) (xkl_config_callback_data); +#endif return TRUE; } void -xkl_xkb_group_lock(int group) +xkl_xkb_lock_group(XklEngine * engine, gint group) { + Display *display = xkl_engine_get_display(engine); xkl_debug(100, "Posted request for change the group to %d ##\n", group); - XkbLockGroup(xkl_display, XkbUseCoreKbd, group); - XSync(xkl_display, False); + XkbLockGroup(display, XkbUseCoreKbd, group); + XSync(display, False); } /** * Updates current internal state from X state */ void -xkl_xkb_get_server_state(XklState * current_state_out) +xkl_xkb_get_server_state(XklEngine * engine, XklState * current_state_out) { XkbStateRec state; + Display *display = xkl_engine_get_display(engine); current_state_out->group = 0; - if (Success == XkbGetState(xkl_display, XkbUseCoreKbd, &state)) + if (Success == XkbGetState(display, XkbUseCoreKbd, &state)) current_state_out->group = state.locked_group; if (Success == - XkbGetIndicatorState(xkl_display, XkbUseCoreKbd, + XkbGetIndicatorState(display, XkbUseCoreKbd, ¤t_state_out->indicators)) current_state_out->indicators &= xkl_xkb_desc->indicators->phys_indicators; @@ -302,9 +313,10 @@ xkl_xkb_get_server_state(XklState * current_state_out) * Actually taken from mxkbledpanel, valueChangedProc */ gboolean -xkl_indicator_set(gint indicator_num, gboolean set) +xkl_set_indicator(XklEngine * engine, gint indicator_num, gboolean set) { XkbIndicatorMapPtr map; + Display *display = xkl_engine_get_display(engine); map = xkl_xkb_desc->indicators->maps + indicator_num; @@ -334,7 +346,7 @@ xkl_indicator_set(gint indicator_num, gboolean set) { if (xkl_xkb_desc->names-> indicators[indicator_num] != None) - XkbSetNamedIndicator(xkl_display, + XkbSetNamedIndicator(display, XkbUseCoreKbd, xkl_xkb_desc->names-> indicators @@ -345,10 +357,10 @@ xkl_indicator_set(gint indicator_num, gboolean set) xkc.led = indicator_num; xkc.led_mode = set ? LedModeOn : LedModeOff; - XChangeKeyboardControl(xkl_display, + XChangeKeyboardControl(display, KBLed | KBLedMode, &xkc); - XSync(xkl_display, False); + XSync(display, False); } return TRUE; @@ -369,13 +381,12 @@ xkl_indicator_set(gint indicator_num, gboolean set) if (map->ctrls) { gulong which = map->ctrls; - XkbGetControls(xkl_display, XkbAllControlsMask, - xkl_xkb_desc); + XkbGetControls(display, XkbAllControlsMask, xkl_xkb_desc); if (set) xkl_xkb_desc->ctrls->enabled_ctrls |= which; else xkl_xkb_desc->ctrls->enabled_ctrls &= ~which; - XkbSetControls(xkl_display, which | XkbControlsEnabledMask, + XkbSetControls(display, which | XkbControlsEnabledMask, xkl_xkb_desc); } @@ -404,7 +415,7 @@ xkl_indicator_set(gint indicator_num, gboolean set) /* Important: Groups should be ignored here - because they are handled separately! */ /* XklLockGroup( group ); */ } else if (map->which_groups & XkbIM_UseLatched) - XkbLatchGroup(xkl_display, XkbUseCoreKbd, + XkbLatchGroup(display, XkbUseCoreKbd, group); else { /* Can do nothing. Just ignore the indicator */ @@ -420,7 +431,7 @@ xkl_indicator_set(gint indicator_num, gboolean set) group = i; break; } - xkl_group_lock(group); + xkl_xkb_lock_group(engine, group); } } @@ -447,10 +458,10 @@ xkl_indicator_set(gint indicator_num, gboolean set) if (map-> which_mods & (XkbIM_UseLocked | XkbIM_UseEffective)) - XkbLockModifiers(xkl_display, XkbUseCoreKbd, + XkbLockModifiers(display, XkbUseCoreKbd, affect, mods); else if (map->which_mods & XkbIM_UseLatched) - XkbLatchModifiers(xkl_display, XkbUseCoreKbd, + XkbLatchModifiers(display, XkbUseCoreKbd, affect, mods); else { return TRUE; @@ -462,87 +473,85 @@ xkl_indicator_set(gint indicator_num, gboolean set) #endif gint -xkl_xkb_init(void) +xkl_xkb_init(XklEngine * engine) { + Display *display = xkl_engine_get_display(engine); #ifdef XKB_HEADERS_PRESENT gint opcode; gboolean xkl_xkb_ext_present; - static XklVTable xkl_xkb_vtable = { - "XKB", - XKLF_CAN_TOGGLE_INDICATORS | - XKLF_CAN_OUTPUT_CONFIG_AS_ASCII | - XKLF_CAN_OUTPUT_CONFIG_AS_BINARY, - xkl_xkb_config_activate, - xkl_xkb_config_init, - xkl_xkb_config_registry_load, - xkl_xkb_config_write_file, - - xkl_xkb_groups_get_names, - xkl_xkb_groups_get_max_num, - xkl_xkb_groups_get_num, - xkl_xkb_group_lock, - - xkl_xkb_process_x_event, - xkl_xkb_free_all_info, - xkl_xkb_if_cached_info_equals_actual, - xkl_xkb_load_all_info, - xkl_xkb_get_server_state, - xkl_xkb_listen_pause, - xkl_xkb_listen_resume, - xkl_xkb_indicators_set, - }; + + engine->priv->backend_id = "XKB"; + engine->priv->features = XKLF_CAN_TOGGLE_INDICATORS | + XKLF_CAN_OUTPUT_CONFIG_AS_ASCII | + XKLF_CAN_OUTPUT_CONFIG_AS_BINARY; + engine->priv->activate_config = xkl_xkb_activate_config; + engine->priv->init_config = xkl_xkb_init_config; + engine->priv->load_config_registry = xkl_xkb_load_config_registry; + engine->priv->write_config_to_file = xkl_xkb_write_config_to_file; + engine->priv->get_groups_names = xkl_xkb_get_groups_names; + engine->priv->get_max_num_groups = xkl_xkb_get_max_num_groups; + engine->priv->get_num_groups = xkl_xkb_get_num_groups; + engine->priv->lock_group = xkl_xkb_lock_group; + engine->priv->process_x_event = xkl_xkb_process_x_event; + engine->priv->free_all_info = xkl_xkb_free_all_info; + engine->priv->if_cached_info_equals_actual = + xkl_xkb_if_cached_info_equals_actual; + engine->priv->load_all_info = xkl_xkb_load_all_info; + engine->priv->get_server_state = xkl_xkb_get_server_state; + engine->priv->pause_listen = xkl_xkb_pause_listen; + engine->priv->resume_listen = xkl_xkb_resume_listen; + engine->priv->set_indicators = xkl_xkb_set_indicators; if (getenv("XKL_XKB_DISABLE") != NULL) return -1; - xkl_xkb_ext_present = XkbQueryExtension(xkl_display, + xkl_xkb_ext_present = XkbQueryExtension(display, &opcode, &xkl_xkb_event_type, &xkl_xkb_error_code, NULL, NULL); if (!xkl_xkb_ext_present) { XSetErrorHandler((XErrorHandler) - xkl_default_error_handler); + engine->priv->default_error_handler); return -1; } xkl_debug(160, "xkbEvenType: %X, xkbError: %X, display: %p, root: " WINID_FORMAT "\n", xkl_xkb_event_type, - xkl_xkb_error_code, xkl_display, xkl_root_window); + xkl_xkb_error_code, display, engine->priv->root_window); - xkl_xkb_vtable.base_config_atom = - XInternAtom(xkl_display, _XKB_RF_NAMES_PROP_ATOM, False); - xkl_xkb_vtable.backup_config_atom = - XInternAtom(xkl_display, "_XKB_RULES_NAMES_BACKUP", False); + engine->priv->base_config_atom = + XInternAtom(display, _XKB_RF_NAMES_PROP_ATOM, False); + engine->priv->backup_config_atom = + XInternAtom(display, "_XKB_RULES_NAMES_BACKUP", False); - xkl_xkb_vtable.default_model = "pc101"; - xkl_xkb_vtable.default_layout = "us"; + engine->priv->default_model = "pc101"; + engine->priv->default_layout = "us"; - xkl_vtable = &xkl_xkb_vtable; /* First, we have to assign xkl_vtable - because this function uses it */ - if (xkl_xkb_config_multiple_layouts_supported()) - xkl_xkb_vtable.features |= XKLF_MULTIPLE_LAYOUTS_SUPPORTED; + if (xkl_xkb_multiple_layouts_supported(engine)) + engine->priv->features |= XKLF_MULTIPLE_LAYOUTS_SUPPORTED; return 0; #else xkl_debug(160, "NO XKB LIBS, display: %p, root: " WINID_FORMAT - "\n", xkl_display, xkl_root_window); + "\n", display, engine->priv->root_window); return -1; #endif } #ifdef XKB_HEADERS_PRESENT const gchar * -xkl_xkb_event_get_name(int xkb_type) +xkl_xkb_event_get_name(gint xkb_type) { /* Not really good to use the fact of consecutivity but XKB protocol extension is already standartized so... */ - static const char *evt_names[] = { + static const gchar *evt_names[] = { "XkbNewKeyboardNotify", "XkbMapNotify", "XkbStateNotify", diff --git a/libxklavier/xklavier_xmm.c b/libxklavier/xklavier_xmm.c index 22d6131..9a4fce6 100755 --- a/libxklavier/xklavier_xmm.c +++ b/libxklavier/xklavier_xmm.c @@ -22,13 +22,13 @@ XklConfigRec current_xmm_config; Atom xmm_state_atom; const gchar ** -xkl_xmm_groups_get_names(void) +xkl_xmm_get_groups_names(XklEngine * engine) { return (const gchar **) current_xmm_config.layouts; } void -xkl_xmm_shortcuts_grab(void) +xkl_xmm_shortcuts_grab(XklEngine * engine) { const XmmShortcut *shortcut; const XmmSwitchOption *option = xkl_xmm_shortcut_get_current(); @@ -40,15 +40,16 @@ xkl_xmm_shortcuts_grab(void) shortcut = option->shortcuts; while (shortcut->keysym != XK_VoidSymbol) { int keycode = - XKeysymToKeycode(xkl_display, shortcut->keysym); - xkl_xmm_grab_ignoring_indicators(keycode, + XKeysymToKeycode(xkl_engine_get_display(engine), + shortcut->keysym); + xkl_xmm_grab_ignoring_indicators(engine, keycode, shortcut->modifiers); shortcut++; } } void -xkl_xmm_shortcuts_ungrab(void) +xkl_xmm_shortcuts_ungrab(XklEngine * engine) { const XmmShortcut *shortcut; const XmmSwitchOption *option = xkl_xmm_shortcut_get_current(); @@ -59,8 +60,9 @@ xkl_xmm_shortcuts_ungrab(void) shortcut = option->shortcuts; while (shortcut->keysym != XK_VoidSymbol) { int keycode = - XKeysymToKeycode(xkl_display, shortcut->keysym); - xkl_xmm_ungrab_ignoring_indicators(keycode, + XKeysymToKeycode(xkl_engine_get_display(engine), + shortcut->keysym); + xkl_xmm_ungrab_ignoring_indicators(engine, keycode, shortcut->modifiers); shortcut++; } @@ -102,7 +104,7 @@ xkl_xmm_shortcut_get_current_option_name(void) } const XmmSwitchOption * -xkl_xmm_switch_option_find(gint keycode, +xkl_xmm_find_switch_option(XklEngine * engine, gint keycode, guint state, gint * current_shortcut_rv) { const XmmSwitchOption *rv = xkl_xmm_shortcut_get_current(); @@ -110,10 +112,10 @@ xkl_xmm_switch_option_find(gint keycode, if (rv != NULL) { XmmShortcut *sc = rv->shortcuts; while (sc->keysym != XK_VoidSymbol) { - if ((XKeysymToKeycode(xkl_display, sc->keysym) == - keycode) - && ((state & sc->modifiers) == - sc->modifiers)) { + if ((XKeysymToKeycode + (xkl_engine_get_display(engine), + sc->keysym) == keycode) + && ((state & sc->modifiers) == sc->modifiers)) { return rv; } sc++; @@ -123,29 +125,29 @@ xkl_xmm_switch_option_find(gint keycode, } gint -xkl_xmm_listen_resume(void) +xkl_xmm_resume_listen(XklEngine * engine) { - if (xkl_listener_type & XKLL_MANAGE_LAYOUTS) - xkl_xmm_shortcuts_grab(); + if (engine->priv->listener_type & XKLL_MANAGE_LAYOUTS) + xkl_xmm_shortcuts_grab(engine); return 0; } gint -xkl_xmm_listen_pause(void) +xkl_xmm_pause_listen(XklEngine * engine) { - if (xkl_listener_type & XKLL_MANAGE_LAYOUTS) - xkl_xmm_shortcuts_ungrab(); + if (engine->priv->listener_type & XKLL_MANAGE_LAYOUTS) + xkl_xmm_shortcuts_ungrab(engine); return 0; } guint -xkl_xmm_groups_get_max_num(void) +xkl_xmm_get_max_num_groups(XklEngine * engine) { return 0; } guint -xkl_xmm_groups_get_num(void) +xkl_xmm_get_num_groups(XklEngine * engine) { gint rv = 0; gchar **p = current_xmm_config.layouts; @@ -156,7 +158,7 @@ xkl_xmm_groups_get_num(void) } void -xkl_xmm_free_all_info(void) +xkl_xmm_free_all_info(XklEngine * engine) { if (current_xmm_rules != NULL) { g_free(current_xmm_rules); @@ -166,20 +168,20 @@ xkl_xmm_free_all_info(void) } gboolean -xkl_xmm_if_cached_info_equals_actual(void) +xkl_xmm_if_cached_info_equals_actual(XklEngine * engine) { return FALSE; } gboolean -xkl_xmm_load_all_info() +xkl_xmm_load_all_info(XklEngine * engine) { return xkl_config_get_full_from_server(¤t_xmm_rules, ¤t_xmm_config); } void -xkl_xmm_state_get_server(XklState * state) +xkl_xmm_get_server_state(XklEngine * engine, XklState * state) { unsigned char *propval = NULL; Atom actual_type; @@ -190,11 +192,12 @@ xkl_xmm_state_get_server(XklState * state) memset(state, 0, sizeof(*state)); - result = XGetWindowProperty(xkl_display, xkl_root_window, - xmm_state_atom, 0L, 1L, - False, XA_INTEGER, &actual_type, - &actual_format, &actual_items, - &bytes_remaining, &propval); + result = + XGetWindowProperty(xkl_engine_get_display(engine), + engine->priv->root_window, xmm_state_atom, + 0L, 1L, False, XA_INTEGER, &actual_type, + &actual_format, &actual_items, + &bytes_remaining, &propval); if (Success == result) { if (actual_format == 32 || actual_items == 1) { @@ -212,13 +215,13 @@ xkl_xmm_state_get_server(XklState * state) } void -xkl_xmm_group_actualize(gint group) +xkl_xmm_group_actualize(XklEngine * engine, gint group) { char cmd[1024]; int res; const gchar *layout_name = NULL; - if (xkl_xmm_groups_get_num() < group) + if (xkl_xmm_get_num_groups(engine) < group) return; layout_name = current_xmm_config.layouts[group]; @@ -232,66 +235,65 @@ xkl_xmm_group_actualize(gint group) } else if (res < 0) { xkl_debug(0, "Could not execute xmodmap: %d\n", res); } - XSync(xkl_display, False); + XSync(xkl_engine_get_display(engine), False); } void -xkl_xmm_group_lock(gint group) +xkl_xmm_lock_group(XklEngine * engine, gint group) { CARD32 propval; - if (xkl_xmm_groups_get_num() < group) + if (xkl_xmm_get_num_groups(engine) < group) return; /* updating the status property */ propval = group; - XChangeProperty(xkl_display, xkl_root_window, xmm_state_atom, + Display *display = xkl_engine_get_display(engine); + XChangeProperty(display, engine->priv->root_window, xmm_state_atom, XA_INTEGER, 32, PropModeReplace, (unsigned char *) &propval, 1); - XSync(xkl_display, False); + XSync(display, False); } gint -xkl_xmm_init(void) +xkl_xmm_init(XklEngine * engine) { - static XklVTable xkl_xmm_vtable = { - "xmodmap", - XKLF_MULTIPLE_LAYOUTS_SUPPORTED | - XKLF_REQUIRES_MANUAL_LAYOUT_MANAGEMENT, - xkl_xmm_config_activate, - xkl_xmm_config_init, - xkl_xmm_config_registry_load, - NULL, /* no write_file */ - - xkl_xmm_groups_get_names, - xkl_xmm_groups_get_max_num, - xkl_xmm_groups_get_num, - xkl_xmm_group_lock, - - xkl_xmm_process_x_event, - xkl_xmm_free_all_info, - xkl_xmm_if_cached_info_equals_actual, - xkl_xmm_load_all_info, - xkl_xmm_state_get_server, - xkl_xmm_listen_pause, - xkl_xmm_listen_resume, - NULL, /* no indicators_set */ - }; + engine->priv->backend_id = "xmodmap"; + engine->priv->features = XKLF_MULTIPLE_LAYOUTS_SUPPORTED | + XKLF_REQUIRES_MANUAL_LAYOUT_MANAGEMENT; + engine->priv->activate_config = xkl_xmm_activate_config; + engine->priv->init_config = xkl_xmm_init_config; + engine->priv->load_config_registry = xkl_xmm_load_config_registry; + engine->priv->write_config_to_file = NULL; + + engine->priv->get_groups_names = xkl_xmm_get_groups_names; + engine->priv->get_max_num_groups = xkl_xmm_get_max_num_groups; + engine->priv->get_num_groups = xkl_xmm_get_num_groups; + engine->priv->lock_group = xkl_xmm_lock_group; + + engine->priv->process_x_event = xkl_xmm_process_x_event; + engine->priv->free_all_info = xkl_xmm_free_all_info; + engine->priv->if_cached_info_equals_actual = + xkl_xmm_if_cached_info_equals_actual; + engine->priv->load_all_info = xkl_xmm_load_all_info; + engine->priv->get_server_state = xkl_xmm_get_server_state; + engine->priv->pause_listen = xkl_xmm_pause_listen; + engine->priv->resume_listen = xkl_xmm_resume_listen; + engine->priv->set_indicators = NULL; if (getenv("XKL_XMODMAP_DISABLE") != NULL) return -1; - xkl_xmm_vtable.base_config_atom = - XInternAtom(xkl_display, "_XMM_NAMES", False); - xkl_xmm_vtable.backup_config_atom = - XInternAtom(xkl_display, "_XMM_NAMES_BACKUP", False); + Display *display = xkl_engine_get_display(engine); + engine->priv->base_config_atom = + XInternAtom(display, "_XMM_NAMES", False); + engine->priv->backup_config_atom = + XInternAtom(display, "_XMM_NAMES_BACKUP", False); - xmm_state_atom = XInternAtom(xkl_display, "_XMM_STATE", False); + xmm_state_atom = XInternAtom(display, "_XMM_STATE", False); - xkl_xmm_vtable.default_model = "generic"; - xkl_xmm_vtable.default_layout = "us"; - - xkl_vtable = &xkl_xmm_vtable; + engine->priv->default_model = "generic"; + engine->priv->default_layout = "us"; return 0; } -- cgit v1.2.1