more files gobjectified

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 <locale.h>
 #include <sys/stat.h>
 
-#include <libxml/xpath.h>
-
 #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))
@@ -55,6 +67,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".
  */
 	struct _XklConfigItem {
@@ -153,33 +200,25 @@ 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,
 					       &current_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 <stdio.h>
 
+#include <libxml/xpath.h>
+
 #include <libxklavier/xklavier_config.h>
 
 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,
 				 &current_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(&current_xmm_rules,
 					       &current_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;
 }