XklConfig -> XklConfigRegistry

11 files changed, 218 insertions, 184 deletions

diff --git a/libxklavier/xklavier_config.c b/libxklavier/xklavier_config.c
index 72473f3..9386390 100644
--- a/libxklavier/xklavier_config.c
+++ b/libxklavier/xklavier_config.c
@@ -10,7 +10,7 @@
 
 static GObjectClass *g_object_class = NULL;
 
-static XklConfig *the_config = NULL;
+static XklConfigRegistry *the_config = NULL;
 
 static xmlXPathCompExprPtr models_xpath;
 static xmlXPathCompExprPtr layouts_xpath;
@@ -151,8 +151,10 @@ xkl_read_config_item(xmlNodePtr iptr, XklConfigItem * item)
 }
 
 static void
-xkl_config_enum_from_node_set(XklConfig * config, xmlNodeSetPtr nodes,
-			      ConfigItemProcessFunc func, gpointer data)
+xkl_config_registry_enum_from_node_set(XklConfigRegistry * config,
+				       xmlNodeSetPtr nodes,
+				       ConfigItemProcessFunc func,
+				       gpointer data)
 {
 	gint i;
 	if (nodes != NULL) {
@@ -168,9 +170,9 @@ xkl_config_enum_from_node_set(XklConfig * config, xmlNodeSetPtr nodes,
 }
 
 static void
-xkl_config_enum_simple(XklConfig * config,
-		       xmlXPathCompExprPtr xpath_comp_expr,
-		       ConfigItemProcessFunc func, gpointer data)
+xkl_config_registry_enum_simple(XklConfigRegistry * config,
+				xmlXPathCompExprPtr xpath_comp_expr,
+				ConfigItemProcessFunc func, gpointer data)
 {
 	xmlXPathObjectPtr xpath_obj;
 
@@ -179,17 +181,18 @@ xkl_config_enum_simple(XklConfig * config,
 	xpath_obj = xmlXPathCompiledEval(xpath_comp_expr,
 					 config->priv->xpath_context);
 	if (xpath_obj != NULL) {
-		xkl_config_enum_from_node_set(config,
-					      xpath_obj->nodesetval, func,
-					      data);
+		xkl_config_registry_enum_from_node_set(config,
+						       xpath_obj->
+						       nodesetval, func,
+						       data);
 		xmlXPathFreeObject(xpath_obj);
 	}
 }
 
 static void
-xkl_config_enum_direct(XklConfig * config, const gchar * format,
-		       const gchar * value,
-		       ConfigItemProcessFunc func, gpointer data)
+xkl_config_registry_enum_direct(XklConfigRegistry * config,
+				const gchar * format, const gchar * value,
+				ConfigItemProcessFunc func, gpointer data)
 {
 	char xpath_expr[1024];
 	xmlXPathObjectPtr xpath_obj;
@@ -200,18 +203,19 @@ xkl_config_enum_direct(XklConfig * config, const gchar * format,
 	xpath_obj = xmlXPathEval((unsigned char *) xpath_expr,
 				 config->priv->xpath_context);
 	if (xpath_obj != NULL) {
-		xkl_config_enum_from_node_set(config,
-					      xpath_obj->nodesetval, func,
-					      data);
+		xkl_config_registry_enum_from_node_set(config,
+						       xpath_obj->
+						       nodesetval, func,
+						       data);
 		xmlXPathFreeObject(xpath_obj);
 	}
 }
 
 static gboolean
-xkl_config_find_object(XklConfig * config, const gchar * format,
-		       const gchar * arg1,
-		       XklConfigItem * pitem /* in/out */ ,
-		       xmlNodePtr * pnode /* out */ )
+xkl_config_registry_find_object(XklConfigRegistry * config,
+				const gchar * format, const gchar * arg1,
+				XklConfigItem * pitem /* in/out */ ,
+				xmlNodePtr * pnode /* out */ )
 {
 	xmlXPathObjectPtr xpath_obj;
 	xmlNodeSetPtr nodes;
@@ -311,8 +315,8 @@ xkl_engine_get_ruleset_name(XklEngine * engine,
 	return rules_set_name;
 }
 
-XklConfig *
-xkl_config_get_instance(XklEngine * engine)
+XklConfigRegistry *
+xkl_config_registry_get_instance(XklEngine * engine)
 {
 	if (the_config != NULL) {
 		g_object_ref(G_OBJECT(the_config));
@@ -321,11 +325,13 @@ xkl_config_get_instance(XklEngine * engine)
 
 	if (!engine) {
 		xkl_debug(10,
-			  "xkl_config_get_instance : engine is NULL ?\n");
+			  "xkl_config_registry_get_instance : engine is NULL ?\n");
 		return NULL;
 	}
 
-	the_config = XKL_CONFIG(g_object_new(xkl_config_get_type(), NULL));
+	the_config =
+	    XKL_CONFIG_REGISTRY(g_object_new
+				(xkl_config_registry_get_type(), NULL));
 
 	the_config->priv->engine = engine;
 
@@ -339,19 +345,20 @@ xkl_config_get_instance(XklEngine * engine)
 	xkl_i18n_init();
 
 	xkl_engine_ensure_vtable_inited(engine);
-	xkl_engine_vcall(engine, init_config) (the_config);
+	xkl_engine_vcall(engine, init_config_registry) (the_config);
 
 	return the_config;
 }
 
 gboolean
-xkl_config_load_registry_from_file(XklConfig * config,
+xkl_config_registry_load_from_file(XklConfigRegistry * config,
 				   const gchar * file_name)
 {
 	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 =
+		xkl_config_registry_get_engine(config)->priv->
+		    last_error_message =
 		    "Could not parse XKB configuration registry";
 	} else
 		config->priv->xpath_context =
@@ -360,7 +367,7 @@ xkl_config_load_registry_from_file(XklConfig * config,
 }
 
 void
-xkl_config_free_registry(XklConfig * config)
+xkl_config_registry_free(XklConfigRegistry * config)
 {
 	if (xkl_config_registry_is_initialized(config)) {
 		xmlXPathFreeContext(config->priv->xpath_context);
@@ -371,33 +378,35 @@ xkl_config_free_registry(XklConfig * config)
 }
 
 void
-xkl_config_enum_models(XklConfig * config, ConfigItemProcessFunc func,
-		       gpointer data)
+xkl_config_registry_enum_models(XklConfigRegistry * config,
+				ConfigItemProcessFunc func, gpointer data)
 {
-	xkl_config_enum_simple(config, models_xpath, func, data);
+	xkl_config_registry_enum_simple(config, models_xpath, func, data);
 }
 
 void
-xkl_config_enum_layouts(XklConfig * config, ConfigItemProcessFunc func,
-			gpointer data)
+xkl_config_registry_enum_layouts(XklConfigRegistry * config,
+				 ConfigItemProcessFunc func, gpointer data)
 {
-	xkl_config_enum_simple(config, layouts_xpath, func, data);
+	xkl_config_registry_enum_simple(config, layouts_xpath, func, data);
 }
 
 void
-xkl_config_enum_layout_variants(XklConfig * config,
-				const gchar * layout_name,
-				ConfigItemProcessFunc func, gpointer data)
+xkl_config_registry_enum_layout_variants(XklConfigRegistry * config,
+					 const gchar * layout_name,
+					 ConfigItemProcessFunc func,
+					 gpointer data)
 {
-	xkl_config_enum_direct
+	xkl_config_registry_enum_direct
 	    (config,
 	     "/xkbConfigRegistry/layoutList/layout/variantList/variant[../../configItem/name = '%s']",
 	     layout_name, func, data);
 }
 
 void
-xkl_config_enum_option_groups(XklConfig * config, GroupProcessFunc func,
-			      gpointer data)
+xkl_config_registry_enum_option_groups(XklConfigRegistry * config,
+				       GroupProcessFunc func,
+				       gpointer data)
 {
 	xmlXPathObjectPtr xpath_obj;
 	gint i;
@@ -437,44 +446,45 @@ xkl_config_enum_option_groups(XklConfig * config, GroupProcessFunc func,
 }
 
 void
-xkl_config_enum_options(XklConfig * config,
-			const gchar * option_group_name,
-			ConfigItemProcessFunc func, gpointer data)
+xkl_config_registry_enum_options(XklConfigRegistry * config,
+				 const gchar * option_group_name,
+				 ConfigItemProcessFunc func, gpointer data)
 {
-	xkl_config_enum_direct
+	xkl_config_registry_enum_direct
 	    (config,
 	     "/xkbConfigRegistry/optionList/group/option[../configItem/name = '%s']",
 	     option_group_name, func, data);
 }
 
 gboolean
-xkl_config_find_model(XklConfig * config,
-		      XklConfigItem * pitem /* in/out */ )
+xkl_config_registry_find_model(XklConfigRegistry * config,
+			       XklConfigItem * pitem /* in/out */ )
 {
 	return
-	    xkl_config_find_object
+	    xkl_config_registry_find_object
 	    (config,
 	     "/xkbConfigRegistry/modelList/model[configItem/name = '%s%s']",
 	     "", pitem, NULL);
 }
 
 gboolean
-xkl_config_find_layout(XklConfig * config,
-		       XklConfigItem * pitem /* in/out */ )
+xkl_config_registry_find_layout(XklConfigRegistry * config,
+				XklConfigItem * pitem /* in/out */ )
 {
 	return
-	    xkl_config_find_object
+	    xkl_config_registry_find_object
 	    (config,
 	     "/xkbConfigRegistry/layoutList/layout[configItem/name = '%s%s']",
 	     "", pitem, NULL);
 }
 
 gboolean
-xkl_config_find_variant(XklConfig * config, const char *layout_name,
-			XklConfigItem * pitem /* in/out */ )
+xkl_config_registry_find_variant(XklConfigRegistry * config,
+				 const char *layout_name,
+				 XklConfigItem * pitem /* in/out */ )
 {
 	return
-	    xkl_config_find_object
+	    xkl_config_registry_find_object
 	    (config,
 	     "/xkbConfigRegistry/layoutList/layout/variantList/variant"
 	     "[../../configItem/name = '%s' and configItem/name = '%s']",
@@ -482,16 +492,16 @@ xkl_config_find_variant(XklConfig * config, const char *layout_name,
 }
 
 gboolean
-_xkl_config_find_option_group(XklConfig * config,
-			      XklConfigItem * pitem /* in/out */ ,
-			      gboolean *
-			      allow_multiple_selection /* out */ )
+xkl_config_registry_find_option_group(XklConfigRegistry * config,
+				      XklConfigItem * pitem /* in/out */ ,
+				      gboolean *
+				      allow_multiple_selection /* out */ )
 {
 	xmlNodePtr node;
-	gboolean rv = xkl_config_find_object(config,
-					     "/xkbConfigRegistry/optionList/group[configItem/name = '%s%s']",
-					     "",
-					     pitem, &node);
+	gboolean rv = xkl_config_registry_find_object(config,
+						      "/xkbConfigRegistry/optionList/group[configItem/name = '%s%s']",
+						      "",
+						      pitem, &node);
 
 	if (rv && allow_multiple_selection != NULL) {
 		xmlChar *val = xmlGetProp(node,
@@ -508,11 +518,12 @@ _xkl_config_find_option_group(XklConfig * config,
 }
 
 gboolean
-xkl_config_find_option(XklConfig * config, const char *option_group_name,
-		       XklConfigItem * pitem /* in/out */ )
+xkl_config_registry_find_option(XklConfigRegistry * config,
+				const char *option_group_name,
+				XklConfigItem * pitem /* in/out */ )
 {
 	return
-	    xkl_config_find_object
+	    xkl_config_registry_find_object
 	    (config, "/xkbConfigRegistry/optionList/group/option"
 	     "[../configItem/name = '%s' and configItem/name = '%s']",
 	     option_group_name, pitem, NULL);
@@ -525,13 +536,14 @@ gboolean
 xkl_config_rec_activate(const XklConfigRec * data, XklEngine * engine)
 {
 	xkl_engine_ensure_vtable_inited(engine);
-	return xkl_engine_vcall(engine, activate_config) (engine, data);
+	return xkl_engine_vcall(engine, activate_config_rec) (engine,
+							      data);
 }
 
 gboolean
-xkl_config_load_registry(XklConfig * config)
+xkl_config_registry_load(XklConfigRegistry * config)
 {
-	XklEngine *engine = xkl_config_get_engine(config);
+	XklEngine *engine = xkl_config_registry_get_engine(config);
 	xkl_engine_ensure_vtable_inited(engine);
 	return xkl_engine_vcall(engine, load_config_registry) (config);
 }
@@ -551,14 +563,14 @@ xkl_config_rec_write_to_file(XklEngine * engine, const gchar * file_name,
 		return FALSE;
 	}
 	xkl_engine_ensure_vtable_inited(engine);
-	return xkl_engine_vcall(engine, write_config_to_file) (engine,
-							       file_name,
-							       data,
-							       binary);
+	return xkl_engine_vcall(engine, write_config_rec_to_file) (engine,
+								   file_name,
+								   data,
+								   binary);
 }
 
 void
-xkl_config_dump(FILE * file, XklConfigRec * data)
+xkl_config_rec_dump(FILE * file, XklConfigRec * data)
 {
 	int j;
 	fprintf(file, "  model: [%s]\n", data->model);
@@ -578,18 +590,18 @@ xkl_config_dump(FILE * file, XklConfigRec * data)
 
 }
 
-G_DEFINE_TYPE(XklConfig, xkl_config, G_TYPE_OBJECT)
+G_DEFINE_TYPE(XklConfigRegistry, xkl_config_registry, G_TYPE_OBJECT)
 
 static void
-xkl_config_init(XklConfig * config)
+xkl_config_registry_init(XklConfigRegistry * config)
 {
-	config->priv = g_new0(XklConfigPrivate, 1);
+	config->priv = g_new0(XklConfigRegistryPrivate, 1);
 }
 
 static void
-xkl_config_finalize(GObject * obj)
+xkl_config_registry_finalize(GObject * obj)
 {
-	XklConfig *config = (XklConfig *) obj;
+	XklConfigRegistry *config = (XklConfigRegistry *) obj;
 
 	if (models_xpath != NULL) {
 		xmlXPathFreeCompExpr(models_xpath);
@@ -610,11 +622,11 @@ xkl_config_finalize(GObject * obj)
 }
 
 static void
-xkl_config_class_init(XklConfigClass * klass)
+xkl_config_registry_class_init(XklConfigRegistryClass * klass)
 {
 	GObjectClass *object_class;
 
 	object_class = (GObjectClass *) klass;
 	g_object_class = g_type_class_peek_parent(object_class);
-	object_class->finalize = xkl_config_finalize;
+	object_class->finalize = xkl_config_registry_finalize;
 }
diff --git a/libxklavier/xklavier_config.h b/libxklavier/xklavier_config.h
index 34c9521..e172acc 100644
--- a/libxklavier/xklavier_config.h
+++ b/libxklavier/xklavier_config.h
@@ -33,9 +33,9 @@ extern "C" {
 
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 
-	typedef struct _XklConfig XklConfig;
-	typedef struct _XklConfigPrivate XklConfigPrivate;
-	typedef struct _XklConfigClass XklConfigClass;
+	typedef struct _XklConfigRegistry XklConfigRegistry;
+	typedef struct _XklConfigRegistryPrivate XklConfigRegistryPrivate;
+	typedef struct _XklConfigRegistryClass XklConfigRegistryClass;
 
 	typedef struct _XklConfigItem XklConfigItem;
 	typedef struct _XklConfigItemClass XklConfigItemClass;
@@ -43,12 +43,12 @@ extern "C" {
 	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_REGISTRY             (xkl_config_registry_get_type ())
+#define XKL_CONFIG_REGISTRY(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), XKL_TYPE_CONFIG_REGISTRY, XklConfigRegistry))
+#define XKL_CONFIG_REGISTRY_CLASS(obj)       (G_TYPE_CHECK_CLASS_CAST ((obj), XKL_CONFIG_REGISTRY,  XklConfigRegistryClass))
+#define XKL_IS_CONFIG_REGISTRY(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), XKL_TYPE_CONFIG_REGISTRY))
+#define XKL_IS_CONFIG_REGISTRY_CLASS(obj)    (G_TYPE_CHECK_CLASS_TYPE ((obj), XKL_TYPE_CONFIG_REGISTRY))
+#define XKL_CONFIG_REGISTRY_GET_CLASS        (G_TYPE_INSTANCE_GET_CLASS ((obj), XKL_TYPE_CONFIG_REGISTRY, XklConfigRegistryClass))
 
 #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))
@@ -69,35 +69,36 @@ extern "C" {
 /**
  * The configuration manager. Corresponds to XML element "configItem".
  */
-	struct _XklConfig {
+	struct _XklConfigRegistry {
 /**
  * The superclass object
  */
 		GObject parent;
 
-		XklConfigPrivate *priv;
+		XklConfigRegistryPrivate *priv;
 	};
 
 /**
- * The XklConfig class, derived from GObject
+ * The XklConfigRegistry class, derived from GObject
  */
-	struct _XklConfigClass {
+	struct _XklConfigRegistryClass {
     /**
      * The superclass
      */
 		GObjectClass parent_class;
 	};
 /**
- * Get type info for XConfigRec
- * @return GType for XConfigRec
+ * Get type info for XConfig
+ * @return GType for XConfig
  */
-	extern GType xkl_config_get_type(void);
+	extern GType xkl_config_registry_get_type(void);
 
 /**
- * Create new XklConfigRec
+ * Create new XklConfig
  * @return new instance
  */
-	extern XklConfig *xkl_config_get_instance(XklEngine * engine);
+	extern XklConfigRegistry
+	    * xkl_config_registry_get_instance(XklEngine * engine);
 
 
 
@@ -204,21 +205,21 @@ extern "C" {
  * @param file_name file name to load
  * @return true on success
  */
-	extern gboolean xkl_config_load_registry_from_file(XklConfig *
-							   config,
-							   const gchar *
-							   file_name);
+	extern gboolean
+	    xkl_config_registry_load_from_file(XklConfigRegistry * config,
+					       const gchar * file_name);
 
 /**
  * Loads XML configuration registry
  * @return true on success
  */
-	extern gboolean xkl_config_load_registry(XklConfig * config);
+	extern gboolean xkl_config_registry_load(XklConfigRegistry *
+						 config);
 
 /**
  * Frees XML configuration registry
  */
-	extern void xkl_config_free_registry(XklConfig * config);
+	extern void xkl_config_registry_free(XklConfigRegistry * config);
 /** @} */
 
 /**
@@ -249,18 +250,20 @@ 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(XklConfig * config,
-					   ConfigItemProcessFunc func,
-					   gpointer data);
+	extern void xkl_config_registry_enum_models(XklConfigRegistry *
+						    config,
+						    ConfigItemProcessFunc
+						    func, gpointer data);
 
 /**
  * Enumerates keyboard layouts from the XML configuration registry
  * @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(XklConfig * config,
-					    ConfigItemProcessFunc func,
-					    gpointer data);
+	extern void xkl_config_registry_enum_layouts(XklConfigRegistry *
+						     config,
+						     ConfigItemProcessFunc
+						     func, gpointer data);
 
 /**
  * Enumerates keyboard layout variants from the XML configuration registry
@@ -268,20 +271,24 @@ 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(XklConfig * config,
-						    const gchar *
-						    layout_name,
-						    ConfigItemProcessFunc
-						    func, gpointer data);
+	extern void
+	 xkl_config_registry_enum_layout_variants(XklConfigRegistry *
+						  config,
+						  const gchar *
+						  layout_name,
+						  ConfigItemProcessFunc
+						  func, gpointer data);
 
 /**
  * Enumerates keyboard option groups from the XML configuration registry
  * @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(XklConfig * config,
-						  GroupProcessFunc func,
-						  gpointer data);
+	extern void
+	 xkl_config_registry_enum_option_groups(XklConfigRegistry *
+						config,
+						GroupProcessFunc func,
+						gpointer data);
 
 /**
  * Enumerates keyboard options from the XML configuration registry
@@ -290,11 +297,12 @@ 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(XklConfig * config,
-					    const gchar *
-					    option_group_name,
-					    ConfigItemProcessFunc func,
-					    gpointer data);
+	extern void xkl_config_registry_enum_options(XklConfigRegistry *
+						     config,
+						     const gchar *
+						     option_group_name,
+						     ConfigItemProcessFunc
+						     func, gpointer data);
 
 /** @} */
 
@@ -309,8 +317,10 @@ 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(XklConfig * config,
-					      XklConfigItem * item);
+	extern gboolean xkl_config_registry_find_model(XklConfigRegistry *
+						       config,
+						       XklConfigItem *
+						       item);
 
 /**
  * Loads a keyboard layout information from the XML configuration registry.
@@ -318,8 +328,10 @@ 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(XklConfig * config,
-					       XklConfigItem * item);
+	extern gboolean xkl_config_registry_find_layout(XklConfigRegistry *
+							config,
+							XklConfigItem *
+							item);
 
 /**
  * Loads a keyboard layout variant information from the XML configuration 
@@ -329,9 +341,12 @@ 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(XklConfig * config,
-						const char *layout_name,
-						XklConfigItem * item);
+	extern gboolean xkl_config_registry_find_variant(XklConfigRegistry
+							 * config,
+							 const char
+							 *layout_name,
+							 XklConfigItem *
+							 item);
 
 /**
  * Loads a keyboard option group information from the XML configuration 
@@ -342,10 +357,12 @@ 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(XklConfig * config,
-						     XklConfigItem * item,
-						     gboolean *
-						     allow_multiple_selection);
+	extern gboolean
+	    xkl_config_registry_find_option_group(XklConfigRegistry *
+						  config,
+						  XklConfigItem * item,
+						  gboolean *
+						  allow_multiple_selection);
 
 /**
  * Loads a keyboard option information from the XML configuration 
@@ -355,10 +372,12 @@ 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(XklConfig * config,
-					       const gchar *
-					       option_group_name,
-					       XklConfigItem * item);
+	extern gboolean xkl_config_registry_find_option(XklConfigRegistry *
+							config,
+							const gchar *
+							option_group_name,
+							XklConfigItem *
+							item);
 /** @} */
 
 /**
diff --git a/libxklavier/xklavier_config_xkb.c b/libxklavier/xklavier_config_xkb.c
index f1d1873..566163b 100644
--- a/libxklavier/xklavier_config_xkb.c
+++ b/libxklavier/xklavier_config_xkb.c
@@ -71,7 +71,7 @@ xkl_rules_set_free(void)
 #endif
 
 void
-xkl_xkb_init_config(XklConfig * config)
+xkl_xkb_init_config_registry(XklConfigRegistry * config)
 {
 #ifdef XKB_HEADERS_PRESENT
 	XkbInitAtoms(NULL);
@@ -79,12 +79,13 @@ xkl_xkb_init_config(XklConfig * config)
 }
 
 gboolean
-xkl_xkb_load_config_registry(XklConfig * config)
+xkl_xkb_load_config_registry(XklConfigRegistry * config)
 {
 	struct stat stat_buf;
 	char file_name[MAXPATHLEN] = "";
 	char *rf =
-	    xkl_engine_get_ruleset_name(xkl_config_get_engine(config),
+	    xkl_engine_get_ruleset_name(xkl_config_registry_get_engine
+					(config),
 					XKB_DEFAULT_RULESET);
 
 	if (rf == NULL)
@@ -98,7 +99,7 @@ xkl_xkb_load_config_registry(XklConfig * config)
 			  sizeof file_name);
 	}
 
-	return xkl_config_load_registry_from_file(config, file_name);
+	return xkl_config_registry_load_from_file(config, file_name);
 }
 
 #ifdef XKB_HEADERS_PRESENT
@@ -430,7 +431,7 @@ xkl_xkb_multiple_layouts_supported(XklEngine * engine)
 }
 
 gboolean
-xkl_xkb_activate_config(XklEngine * engine, const XklConfigRec * data)
+xkl_xkb_activate_config_rec(XklEngine * engine, const XklConfigRec * data)
 {
 	gboolean rv = FALSE;
 #if 0
@@ -485,9 +486,9 @@ xkl_xkb_activate_config(XklEngine * engine, const XklConfigRec * data)
 }
 
 gboolean
-xkl_xkb_write_config_to_file(XklEngine * engine, const char *file_name,
-			     const XklConfigRec * data,
-			     const gboolean binary)
+xkl_xkb_write_config_rec_to_file(XklEngine * engine, const char *file_name,
+				 const XklConfigRec * data,
+				 const gboolean binary)
 {
 	gboolean rv = FALSE;
 
diff --git a/libxklavier/xklavier_config_xmm.c b/libxklavier/xklavier_config_xmm.c
index 350791c..ba637df 100644
--- a/libxklavier/xklavier_config_xmm.c
+++ b/libxklavier/xklavier_config_xmm.c
@@ -20,16 +20,16 @@
 #include <X11/keysymdef.h>
 
 void
-xkl_xmm_init_config(XklConfig * config)
+xkl_xmm_init_config_registry(XklConfigRegistry * config)
 {
 }
 
 gboolean
-xkl_xmm_load_config_registry(XklConfig * config)
+xkl_xmm_load_config_registry(XklConfigRegistry * config)
 {
 	struct stat stat_buf;
 	gchar file_name[MAXPATHLEN] = "";
-	XklEngine *engine = xkl_config_get_engine(config);
+	XklEngine *engine = xkl_config_registry_get_engine(config);
 	gchar *rf = xkl_engine_get_ruleset_name(engine, "");
 
 	if (rf == NULL || rf[0] == '\0')
@@ -43,11 +43,11 @@ xkl_xmm_load_config_registry(XklConfig * config)
 		return FALSE;
 	}
 
-	return xkl_config_load_registry_from_file(config, file_name);
+	return xkl_config_registry_load_from_file(config, file_name);
 }
 
 gboolean
-xkl_xmm_activate_config(XklEngine * engine, const XklConfigRec * data)
+xkl_xmm_activate_config_rec(XklEngine * engine, const XklConfigRec * data)
 {
 	gboolean rv;
 	rv = xkl_config_rec_set_to_root_window_property(data,
diff --git a/libxklavier/xklavier_private.h b/libxklavier/xklavier_private.h
index b94bef4..39e1c73 100644
--- a/libxklavier/xklavier_private.h
+++ b/libxklavier/xklavier_private.h
@@ -62,15 +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) (XklEngine * engine,
-				     const XklConfigRec * data);
+	 gboolean(*activate_config_rec) (XklEngine * engine,
+					 const XklConfigRec * data);
 
   /**
    * Background-specific initialization.
    * xkb: XkbInitAtoms - init internal xkb atoms table
    * xmodmap: void.
    */
-	void (*init_config) (XklConfig * config);
+	void (*init_config_registry) (XklConfigRegistry * config);
 
   /**
    * Loads the registry tree into DOM (using whatever path(s))
@@ -78,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) (XklConfig * config);
+	 gboolean(*load_config_registry) (XklConfigRegistry * config);
 
   /**
    * Write the configuration into the file (binary/textual)
@@ -86,10 +86,10 @@ 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) (XklEngine * engine,
-					  const gchar * file_name,
-					  const XklConfigRec * data,
-					  const gboolean binary);
+	 gboolean(*write_config_rec_to_file) (XklEngine * engine,
+					      const gchar * file_name,
+					      const XklConfigRec * data,
+					      const gboolean binary);
 
   /**
    * Get the list of the group names
@@ -207,7 +207,7 @@ struct _XklEnginePrivate {
 
 extern XklEngine *xkl_get_the_engine(void);
 
-struct _XklConfigPrivate {
+struct _XklConfigRegistryPrivate {
 	XklEngine *engine;
 
 	xmlDocPtr doc;
@@ -343,7 +343,7 @@ extern void xkl_config_rec_split_options(XklConfigRec * data,
 					 const gchar * merged);
 /***/
 
-extern void xkl_config_dump(FILE * file, XklConfigRec * data);
+extern void xkl_config_rec_dump(FILE * file, XklConfigRec * data);
 
 extern const gchar *xkl_event_get_name(gint type);
 
@@ -370,7 +370,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)
+#define xkl_config_registry_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 4378610..6f6033d 100644
--- a/libxklavier/xklavier_private_xkb.h
+++ b/libxklavier/xklavier_private_xkb.h
@@ -37,14 +37,14 @@ extern void xkl_xkb_config_native_cleanup(XklEngine * engine,
 
 /* Start VTable methods */
 
-extern gboolean xkl_xkb_activate_config(XklEngine * engine,
+extern gboolean xkl_xkb_activate_config_rec(XklEngine * engine,
 					const XklConfigRec * data);
 
-extern void xkl_xkb_init_config(XklConfig * config);
+extern void xkl_xkb_init_config_registry(XklConfigRegistry * config);
 
-extern gboolean xkl_xkb_load_config_registry(XklConfig * config);
+extern gboolean xkl_xkb_load_config_registry(XklConfigRegistry * config);
 
-extern gboolean xkl_xkb_write_config_to_file(XklEngine * engine,
+extern gboolean xkl_xkb_write_config_rec_to_file(XklEngine * engine,
 					     const char *file_name,
 					     const XklConfigRec * data,
 					     const gboolean binary);
diff --git a/libxklavier/xklavier_private_xmm.h b/libxklavier/xklavier_private_xmm.h
index 39c5fd0..2e0e199 100644
--- a/libxklavier/xklavier_private_xmm.h
+++ b/libxklavier/xklavier_private_xmm.h
@@ -48,12 +48,12 @@ const XmmSwitchOption *xkl_xmm_find_switch_option(XklEngine * engine,
 
 /* Start VTable methods */
 
-extern gboolean xkl_xmm_activate_config(XklEngine * engine,
-					const XklConfigRec * data);
+extern gboolean xkl_xmm_activate_config_rec(XklEngine * engine,
+					    const XklConfigRec * data);
 
-extern void xkl_xmm_init_config(XklConfig * config);
+extern void xkl_xmm_init_config_registry(XklConfigRegistry * config);
 
-extern gboolean xkl_xmm_load_config_registry(XklConfig * config);
+extern gboolean xkl_xmm_load_config_registry(XklConfigRegistry * config);
 
 extern gint xkl_xmm_process_x_event(XklEngine * engine, XEvent * kev);
 
diff --git a/libxklavier/xklavier_xkb.c b/libxklavier/xklavier_xkb.c
index d5ca7f8..a312ef3 100644
--- a/libxklavier/xklavier_xkb.c
+++ b/libxklavier/xklavier_xkb.c
@@ -485,10 +485,11 @@ xkl_xkb_init(XklEngine * engine)
 	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->activate_config_rec = xkl_xkb_activate_config_rec;
+	engine->priv->init_config_registry = xkl_xkb_init_config_registry;
 	engine->priv->load_config_registry = xkl_xkb_load_config_registry;
-	engine->priv->write_config_to_file = xkl_xkb_write_config_to_file;
+	engine->priv->write_config_rec_to_file =
+	    xkl_xkb_write_config_rec_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;
diff --git a/libxklavier/xklavier_xmm.c b/libxklavier/xklavier_xmm.c
index 4beecc5..385e742 100755
--- a/libxklavier/xklavier_xmm.c
+++ b/libxklavier/xklavier_xmm.c
@@ -262,10 +262,10 @@ xkl_xmm_init(XklEngine * engine)
 	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->activate_config_rec = xkl_xmm_activate_config_rec;
+	engine->priv->init_config_registry = xkl_xmm_init_config_registry;
 	engine->priv->load_config_registry = xkl_xmm_load_config_registry;
-	engine->priv->write_config_to_file = NULL;
+	engine->priv->write_config_rec_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;
diff --git a/tests/test_config.c b/tests/test_config.c
index 1defebb..4bfbf37 100644
--- a/tests/test_config.c
+++ b/tests/test_config.c
@@ -8,7 +8,7 @@
 #include <libxklavier/xklavier.h>
 #include <libxklavier/xklavier_config.h>
 
-extern void xkl_config_dump(FILE * file, XklConfigRec * data);
+extern void xkl_config_rec_dump(FILE * file, XklConfigRec * data);
 
 enum { ACTION_NONE, ACTION_GET, ACTION_SET, ACTION_WRITE };
 
@@ -101,8 +101,8 @@ main(int argc, char *const argv[])
 		if (debug_level != -1)
 			xkl_set_debug_level(debug_level);
 		xkl_debug(0, "Xklavier initialized\n");
-		XklConfig *config = xkl_config_get_instance(engine);
-		xkl_config_load_registry(config);
+		XklConfigRegistry *config = xkl_config_registry_get_instance(engine);
+		xkl_config_registry_load(config);
 		xkl_debug(0, "Xklavier registry loaded\n");
 		xkl_debug(0, "Backend: [%s]\n",
 			  xkl_engine_get_backend_name(engine));
@@ -117,14 +117,14 @@ main(int argc, char *const argv[])
 		switch (action) {
 		case ACTION_GET:
 			xkl_debug(0, "Got config from the server\n");
-			xkl_config_dump(stdout, current_config);
+			xkl_config_rec_dump(stdout, current_config);
 
 			r2 = xkl_config_rec_new();
 
 			if (xkl_config_rec_get_from_backup(r2, engine)) {
 				xkl_debug(0,
 					  "Got config from the backup\n");
-				xkl_config_dump(stdout, r2);
+				xkl_config_rec_dump(stdout, r2);
 			}
 
 			if (xkl_config_rec_activate(r2, engine)) {
@@ -185,7 +185,7 @@ main(int argc, char *const argv[])
 			}
 
 			xkl_debug(0, "New config:\n");
-			xkl_config_dump(stdout, current_config);
+			xkl_config_rec_dump(stdout, current_config);
 			if (xkl_config_rec_activate
 			    (current_config, engine))
 				xkl_debug(0, "Set the config\n");
@@ -209,7 +209,7 @@ main(int argc, char *const argv[])
 
 		g_object_unref(G_OBJECT(current_config));
 
-		xkl_config_free_registry(config);
+		xkl_config_registry_free(config);
 		g_object_unref(G_OBJECT(config));
 		xkl_debug(0, "Xklavier registry freed\n");
 		xkl_debug(0, "Xklavier terminating\n");
diff --git a/tests/test_monitor.c b/tests/test_monitor.c
index 2d91f1a..c6e1acb 100644
--- a/tests/test_monitor.c
+++ b/tests/test_monitor.c
@@ -79,8 +79,9 @@ main(int argc, char *argv[])
 		if (debug_level != -1)
 			xkl_set_debug_level(debug_level);
 		xkl_debug(0, "Xklavier initialized\n");
-		XklConfig *config = xkl_config_get_instance(engine);
-		xkl_config_load_registry(config);
+		XklConfigRegistry *config =
+		    xkl_config_registry_get_instance(engine);
+		xkl_config_registry_load(config);
 		xkl_debug(0, "Xklavier registry loaded\n");
 
 		current_config = xkl_config_rec_new();
@@ -100,7 +101,7 @@ main(int argc, char *argv[])
 
 		g_object_unref(G_OBJECT(current_config));
 
-		xkl_config_free_registry(config);
+		xkl_config_registry_free(config);
 		g_object_unref(G_OBJECT(config));
 		xkl_debug(0, "Xklavier registry freed\n");
 		xkl_debug(0, "Xklavier terminating\n");