first round of cleanup in tests

8 files changed, 58 insertions, 61 deletions

diff --git a/libxklavier/xklavier_config.c b/libxklavier/xklavier_config.c
index cd70dbb..658de2a 100644
--- a/libxklavier/xklavier_config.c
+++ b/libxklavier/xklavier_config.c
@@ -357,7 +357,7 @@ xkl_config_registry_load_from_file(XklConfig * config,
 }
 
 void
-xkl_config_registry_free(XklConfig * config)
+xkl_config_free_registry(XklConfig * config)
 {
 	if (xkl_config_registry_is_initialized(config)) {
 		xmlXPathFreeContext(config->priv->xpath_context);
@@ -519,15 +519,14 @@ xkl_config_find_option(XklConfig * config, const char *option_group_name,
  * Calling through vtable
  */
 gboolean
-xkl_config_activate(XklConfig * config, const XklConfigRec * data)
+xkl_config_rec_activate(const XklConfigRec * data, XklEngine * engine)
 {
-	XklEngine *engine = xkl_config_get_engine(config);
 	xkl_engine_ensure_vtable_inited(engine);
-	return xkl_engine_vcall(engine, activate_config) (config, data);
+	return xkl_engine_vcall(engine, activate_config) (engine, data);
 }
 
 gboolean
-xkl_config_registry_load(XklConfig * config)
+xkl_config_load_registry(XklConfig * config)
 {
 	XklEngine *engine = xkl_config_get_engine(config);
 	xkl_engine_ensure_vtable_inited(engine);
@@ -535,10 +534,10 @@ xkl_config_registry_load(XklConfig * config)
 }
 
 gboolean
-xkl_config_write_file(XklConfig * config, const gchar * file_name,
-		      const XklConfigRec * data, const gboolean binary)
+xkl_config_rec_write_to_file(XklEngine * engine, 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
@@ -549,7 +548,7 @@ xkl_config_write_file(XklConfig * config, const gchar * file_name,
 		return FALSE;
 	}
 	xkl_engine_ensure_vtable_inited(engine);
-	return xkl_engine_vcall(engine, write_config_to_file) (config,
+	return xkl_engine_vcall(engine, write_config_to_file) (engine,
 							       file_name,
 							       data,
 							       binary);
diff --git a/libxklavier/xklavier_config.h b/libxklavier/xklavier_config.h
index 71fc45a..ef3730f 100644
--- a/libxklavier/xklavier_config.h
+++ b/libxklavier/xklavier_config.h
@@ -402,11 +402,13 @@ extern "C" {
  * @param binary is a flag indicating whether the output file should be binary
  * @return TRUE on success
  */
-	extern gboolean xkl_config_rec_write_file(XklEngine * engine,
-						  const gchar * file_name,
-						  const XklConfigRec *
-						  data,
-						  const gboolean binary);
+	extern gboolean xkl_config_rec_write_to_file(XklEngine * engine,
+						     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 3b2de70..addfcc5 100644
--- a/libxklavier/xklavier_config_xkb.c
+++ b/libxklavier/xklavier_config_xkb.c
@@ -103,7 +103,7 @@ xkl_xkb_load_config_registry(XklConfig * config)
 
 #ifdef XKB_HEADERS_PRESENT
 gboolean
-xkl_xkb_config_native_prepare(XklConfig * config,
+xkl_xkb_config_native_prepare(XklEngine * engine,
 			      const XklConfigRec * data,
 			      XkbComponentNamesPtr component_names_ptr)
 {
@@ -112,7 +112,6 @@ xkl_xkb_config_native_prepare(XklConfig * config,
 
 	memset(&xkl_var_defs, 0, sizeof(xkl_var_defs));
 
-	XklEngine *engine = xkl_config_get_engine(config);
 	xkl_rules = xkl_rules_set_load(engine);
 	if (!xkl_rules) {
 		return FALSE;
@@ -141,7 +140,7 @@ xkl_xkb_config_native_prepare(XklConfig * config,
 		engine->priv->last_error_message =
 		    "Could not translate rules into components";
 		/* Just cleanup the stuff in case of failure */
-		xkl_xkb_config_native_cleanup(config, component_names_ptr);
+		xkl_xkb_config_native_cleanup(engine, component_names_ptr);
 
 		return FALSE;
 	}
@@ -163,7 +162,7 @@ xkl_xkb_config_native_prepare(XklConfig * config,
 }
 
 void
-xkl_xkb_config_native_cleanup(XklConfig * config,
+xkl_xkb_config_native_cleanup(XklEngine * engine,
 			      XkbComponentNamesPtr component_names_ptr)
 {
 	xkl_rules_set_free();
@@ -177,7 +176,7 @@ xkl_xkb_config_native_cleanup(XklConfig * config,
 }
 
 static XkbDescPtr
-xkl_config_get_keyboard(XklConfig * config,
+xkl_config_get_keyboard(XklEngine * engine,
 			XkbComponentNamesPtr component_names_ptr,
 			gboolean activate)
 {
@@ -197,7 +196,6 @@ xkl_config_get_keyboard(XklConfig * config,
 	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) {
@@ -415,12 +413,13 @@ xkl_xkb_config_multiple_layouts_supported(XklConfig * config)
 		xkl_debug(100, "!!! Checking multiple layouts support\n");
 		support_state = NON_SUPPORTED;
 #ifdef XKB_HEADERS_PRESENT
+		XklEngine *engine = xkl_config_get_engine(config);
 		if (xkl_xkb_config_native_prepare
-		    (config, &data, &component_names)) {
+		    (engine, &data, &component_names)) {
 			xkl_debug(100,
 				  "!!! Multiple layouts ARE supported\n");
 			support_state = SUPPORTED;
-			xkl_xkb_config_native_cleanup(config,
+			xkl_xkb_config_native_cleanup(engine,
 						      &component_names);
 		} else {
 			xkl_debug(100,
@@ -432,7 +431,7 @@ xkl_xkb_config_multiple_layouts_supported(XklConfig * config)
 }
 
 gboolean
-xkl_xkb_activate_config(XklConfig * config, const XklConfigRec * data)
+xkl_xkb_activate_config(XklEngine * engine, const XklConfigRec * data)
 {
 	gboolean rv = FALSE;
 #if 0
@@ -457,12 +456,11 @@ xkl_xkb_activate_config(XklConfig * config, 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(config, data, &component_names)) {
+	if (xkl_xkb_config_native_prepare(engine, data, &component_names)) {
 		XkbDescPtr xkb;
 		xkb =
-		    xkl_config_get_keyboard(config, &component_names,
+		    xkl_config_get_keyboard(engine, &component_names,
 					    TRUE);
 		if (xkb != NULL) {
 			if (xkl_engine_set_names_prop
@@ -481,19 +479,18 @@ xkl_xkb_activate_config(XklConfig * config, const XklConfigRec * data)
 			engine->priv->last_error_message =
 			    "Could not load keyboard description";
 		}
-		xkl_xkb_config_native_cleanup(config, &component_names);
+		xkl_xkb_config_native_cleanup(engine, &component_names);
 	}
 #endif
 	return rv;
 }
 
 gboolean
-xkl_xkb_write_config_to_file(XklConfig * config, const char *file_name,
+xkl_xkb_write_config_to_file(XklEngine * engine, 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;
@@ -508,10 +505,10 @@ xkl_xkb_write_config_to_file(XklConfig * config, const char *file_name,
 
 	memset(&component_names, 0, sizeof(component_names));
 
-	if (xkl_xkb_config_native_prepare(config, data, &component_names)) {
+	if (xkl_xkb_config_native_prepare(engine, data, &component_names)) {
 		XkbDescPtr xkb;
 		xkb =
-		    xkl_config_get_keyboard(config, &component_names,
+		    xkl_config_get_keyboard(engine, &component_names,
 					    FALSE);
 		if (xkb != NULL) {
 			dump_info.defined = 0;
@@ -528,7 +525,7 @@ xkl_xkb_write_config_to_file(XklConfig * config, const char *file_name,
 		} else
 			engine->priv->last_error_message =
 			    "Could not load keyboard description";
-		xkl_xkb_config_native_cleanup(config, &component_names);
+		xkl_xkb_config_native_cleanup(engine, &component_names);
 	}
 	fclose(output);
 #endif
diff --git a/libxklavier/xklavier_config_xmm.c b/libxklavier/xklavier_config_xmm.c
index 15ddce1..346d4f7 100644
--- a/libxklavier/xklavier_config_xmm.c
+++ b/libxklavier/xklavier_config_xmm.c
@@ -47,10 +47,9 @@ xkl_xmm_load_config_registry(XklConfig * config)
 }
 
 gboolean
-xkl_xmm_activate_config(XklConfig * config, const XklConfigRec * data)
+xkl_xmm_activate_config(XklEngine * engine, const XklConfigRec * data)
 {
 	gboolean rv;
-	XklEngine *engine = xkl_config_get_engine(config);
 	rv = xkl_engine_set_names_prop(engine,
 				       engine->priv->base_config_atom,
 				       current_xmm_rules, data);
diff --git a/libxklavier/xklavier_private.h b/libxklavier/xklavier_private.h
index 0a5a96e..e65d7d7 100644
--- a/libxklavier/xklavier_private.h
+++ b/libxklavier/xklavier_private.h
@@ -62,7 +62,7 @@ struct _XklEnginePrivate {
    * xkb: create proper the XkbDescRec and send it to the server
    * xmodmap: save the property, init layout #1
    */
-	 gboolean(*activate_config) (XklConfig * config,
+	 gboolean(*activate_config) (XklEngine * engine,
 				     const XklConfigRec * data);
 
   /**
@@ -86,7 +86,7 @@ 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) (XklConfig * config,
+	 gboolean(*write_config_to_file) (XklEngine * engine,
 					  const gchar * file_name,
 					  const XklConfigRec * data,
 					  const gboolean binary);
diff --git a/libxklavier/xklavier_private_xkb.h b/libxklavier/xklavier_private_xkb.h
index 55e6134..4378610 100644
--- a/libxklavier/xklavier_private_xkb.h
+++ b/libxklavier/xklavier_private_xkb.h
@@ -26,25 +26,25 @@ 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(XklConfig * config,
+extern gboolean xkl_xkb_config_native_prepare(XklEngine * engine,
 					      const XklConfigRec * data,
 					      XkbComponentNamesPtr
 					      component_names);
 
-extern void xkl_xkb_config_native_cleanup(XklConfig * config,
+extern void xkl_xkb_config_native_cleanup(XklEngine * engine,
 					  XkbComponentNamesPtr
 					  component_names);
 
 /* Start VTable methods */
 
-extern gboolean xkl_xkb_activate_config(XklConfig * config,
+extern gboolean xkl_xkb_activate_config(XklEngine * engine,
 					const XklConfigRec * data);
 
 extern void xkl_xkb_init_config(XklConfig * config);
 
 extern gboolean xkl_xkb_load_config_registry(XklConfig * config);
 
-extern gboolean xkl_xkb_write_config_to_file(XklConfig * config,
+extern gboolean xkl_xkb_write_config_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 cdb74a8..39c5fd0 100644
--- a/libxklavier/xklavier_private_xmm.h
+++ b/libxklavier/xklavier_private_xmm.h
@@ -48,7 +48,7 @@ const XmmSwitchOption *xkl_xmm_find_switch_option(XklEngine * engine,
 
 /* Start VTable methods */
 
-extern gboolean xkl_xmm_activate_config(XklConfig * config,
+extern gboolean xkl_xmm_activate_config(XklEngine * engine,
 					const XklConfigRec * data);
 
 extern void xkl_xmm_init_config(XklConfig * config);
diff --git a/tests/test_config.c b/tests/test_config.c
index 1a9886c..df8974b 100644
--- a/tests/test_config.c
+++ b/tests/test_config.c
@@ -94,22 +94,23 @@ main(int argc, char *const argv[])
 		exit(1);
 	}
 	printf("opened display: %p\n", dpy);
-	if (!xkl_init(dpy)) {
+	XklEngine * engine = xkl_engine_get_instance(dpy);
+	if (engine == NULL) {
 		XklConfigRec *current_config, *r2;
 		if (debug_level != -1)
 			xkl_set_debug_level(debug_level);
 		xkl_debug(0, "Xklavier initialized\n");
-		xkl_config_init();
-		xkl_config_registry_load();
+		XklConfig * config = xkl_config_get_instance(engine);
+		xkl_config_load_registry(config);
 		xkl_debug(0, "Xklavier registry loaded\n");
-		xkl_debug(0, "Backend: [%s]\n", xkl_backend_get_name());
+		xkl_debug(0, "Backend: [%s]\n", xkl_engine_get_backend_name(engine));
 		xkl_debug(0, "Supported features: 0x0%X\n",
-			  xkl_backend_get_features());
+			  xkl_engine_get_features(engine));
 		xkl_debug(0, "Max number of groups: %d\n",
-			  xkl_groups_get_max_num());
+			  xkl_engine_get_max_num_groups(engine));
 
 		current_config = xkl_config_rec_new();
-		xkl_config_get_from_server(current_config);
+		xkl_config_rec_get_from_server(current_config,engine);
 
 		switch (action) {
 		case ACTION_GET:
@@ -118,27 +119,27 @@ main(int argc, char *const argv[])
 
 			r2 = xkl_config_rec_new();
 
-			if (xkl_config_get_from_backup(r2)) {
+			if (xkl_config_rec_get_from_backup(r2,engine)) {
 				xkl_debug(0,
 					  "Got config from the backup\n");
 				xkl_config_dump(stdout, r2);
 			}
 
-			if (xkl_config_activate(r2)) {
+			if (xkl_config_rec_activate(r2,engine)) {
 				xkl_debug(0,
 					  "The backup configuration restored\n");
-				if (xkl_config_activate(current_config)) {
+				if (xkl_config_rec_activate(current_config,engine)) {
 					xkl_debug(0,
 						  "Reverting the configuration change\n");
 				} else {
 					xkl_debug(0,
 						  "The configuration could not be reverted: %s\n",
-						  xkl_get_last_error());
+						  xkl_engine_get_last_error(engine));
 				}
 			} else {
 				xkl_debug(0,
 					  "The backup configuration could not be restored: %s\n",
-					  xkl_get_last_error());
+					  xkl_engine_get_last_error(engine));
 			}
 
 			g_object_unref(G_OBJECT(r2));
@@ -176,15 +177,15 @@ main(int argc, char *const argv[])
 
 			xkl_debug(0, "New config:\n");
 			xkl_config_dump(stdout, current_config);
-			if (xkl_config_activate(current_config))
+			if (xkl_config_rec_activate(current_config,engine))
 				xkl_debug(0, "Set the config\n");
 			else
 				xkl_debug(0,
 					  "Could not set the config: %s\n",
-					  xkl_get_last_error());
+					  xkl_engine_get_last_error(engine));
 			break;
 		case ACTION_WRITE:
-			xkl_config_write_file(binary ? (PACKAGE ".xkm")
+			xkl_config_rec_write_to_file(engine,binary ? (PACKAGE ".xkm")
 					      : (PACKAGE ".xkb"),
 					      current_config, binary);
 			xkl_debug(0, "The file " PACKAGE "%s is written\n",
@@ -194,14 +195,13 @@ main(int argc, char *const argv[])
 
 		g_object_unref(G_OBJECT(current_config));
 
-		xkl_config_registry_free();
-		xkl_config_term();
+		xkl_config_free_registry(config);
+		g_object_unref(G_OBJECT(config));
 		xkl_debug(0, "Xklavier registry freed\n");
 		xkl_debug(0, "Xklavier terminating\n");
-		xkl_term();
+		g_object_unref(G_OBJECT(engine));
 	} else {
-		fprintf(stderr, "Could not init _xklavier: %s\n",
-			xkl_get_last_error());
+		fprintf(stderr, "Could not init _xklavier\n");
 		exit(2);
 	}
 	printf("closing display: %p\n", dpy);