all files are compiling with gobject, but it is not all...

9 files changed, 110 insertions, 76 deletions

diff --git a/libxklavier/xklavier_config.c b/libxklavier/xklavier_config.c
index fec6ca8..cd70dbb 100644
--- a/libxklavier/xklavier_config.c
+++ b/libxklavier/xklavier_config.c
@@ -291,8 +291,8 @@ xkl_engine_get_ruleset_name(XklEngine * engine,
 	if (!rules_set_name[0]) {
 		/* first call */
 		gchar *rf = NULL;
-		if (!xkl_get_names_prop
-		    (engine->priv->base_config_atom, &rf, NULL)
+		if (!xkl_engine_get_names_prop
+		    (engine, engine->priv->base_config_atom, &rf, NULL)
 		    || (rf == NULL)) {
 			g_strlcpy(rules_set_name, default_ruleset,
 				  sizeof rules_set_name);
diff --git a/libxklavier/xklavier_config.h b/libxklavier/xklavier_config.h
index c967eac..71fc45a 100644
--- a/libxklavier/xklavier_config.h
+++ b/libxklavier/xklavier_config.h
@@ -374,16 +374,16 @@ extern "C" {
  * @see XklSetKeyAsSwitcher
  * At the moment, accepts only _ONE_ layout. Later probably I'll improve this..
  */
-	extern gboolean xkl_config_activate(XklConfig * config,
-					    const XklConfigRec * data);
+	extern gboolean xkl_config_rec_activate(const XklConfigRec * data,
+						XklEngine * engine);
 
 /**
  * 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(XklConfig * config,
-						   XklConfigRec * data);
+	extern gboolean xkl_config_rec_get_from_server(XklConfigRec * data,
+						       XklEngine * engine);
 
 /**
  * Loads the current XKB configuration (from backup)
@@ -391,8 +391,8 @@ extern "C" {
  * @return TRUE on success
  * @see XklBackupNamesProp
  */
-	extern gboolean xkl_config_get_from_backup(XklConfig * config,
-						   XklConfigRec * data);
+	extern gboolean xkl_config_rec_get_from_backup(XklConfigRec * data,
+						       XklEngine * engine);
 
 /**
  * Writes some XKB configuration into XKM/XKB file
@@ -402,10 +402,11 @@ 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(XklConfig * config,
-					      const gchar * file_name,
-					      const XklConfigRec * data,
-					      const gboolean binary);
+	extern gboolean xkl_config_rec_write_file(XklEngine * engine,
+						  const gchar * file_name,
+						  const XklConfigRec *
+						  data,
+						  const gboolean binary);
 
 /** @} */
 
@@ -423,9 +424,11 @@ extern "C" {
  *   all records are allocated using standard malloc 
  * @return TRUE on success
  */
-	extern gboolean xkl_get_names_prop(Atom rules_atom_name,
-					   gchar ** rules_file_out,
-					   XklConfigRec * config_out);
+	extern gboolean xkl_engine_get_names_prop(XklEngine * engine,
+						  Atom rules_atom_name,
+						  gchar ** rules_file_out,
+						  XklConfigRec *
+						  config_out);
 
 /**
  * Saves the XKB configuration into any root window property
@@ -434,23 +437,25 @@ extern "C" {
  * @param config is a configuration to save 
  * @return TRUE on success
  */
-	extern gboolean xkl_set_names_prop(Atom rules_atom_name,
-					   gchar * rules_file,
-					   const XklConfigRec * config);
+	extern gboolean xkl_engine_set_names_prop(XklEngine * engine,
+						  Atom rules_atom_name,
+						  gchar * rules_file,
+						  const XklConfigRec *
+						  config);
 
 /**
  * Backups current XKB configuration into some property - 
  * if this property is not defined yet.
  * @return TRUE on success
  */
-	extern gboolean xkl_backup_names_prop();
+	extern gboolean xkl_backup_names_prop(XklEngine * engine);
 
 /**
  * Restores XKB from the property saved by xkl_backup_names_prop
  * @return TRUE on success
  * @see xkl_backup_names_prop
  */
-	extern gboolean xkl_restore_names_prop();
+	extern gboolean xkl_restore_names_prop(XklEngine * engine);
 
 /** @} */
 
diff --git a/libxklavier/xklavier_config_xkb.c b/libxklavier/xklavier_config_xkb.c
index 7c4a336..3b2de70 100644
--- a/libxklavier/xklavier_config_xkb.c
+++ b/libxklavier/xklavier_config_xkb.c
@@ -465,8 +465,8 @@ xkl_xkb_activate_config(XklConfig * config, const XklConfigRec * data)
 		    xkl_config_get_keyboard(config, &component_names,
 					    TRUE);
 		if (xkb != NULL) {
-			if (xkl_set_names_prop
-			    (engine->priv->base_config_atom,
+			if (xkl_engine_set_names_prop
+			    (engine, engine->priv->base_config_atom,
 			     xkl_engine_get_ruleset_name(engine,
 							 XKB_DEFAULT_RULESET),
 			     data))
diff --git a/libxklavier/xklavier_config_xmm.c b/libxklavier/xklavier_config_xmm.c
index e6447dd..15ddce1 100644
--- a/libxklavier/xklavier_config_xmm.c
+++ b/libxklavier/xklavier_config_xmm.c
@@ -51,8 +51,9 @@ xkl_xmm_activate_config(XklConfig * config, const XklConfigRec * data)
 {
 	gboolean rv;
 	XklEngine *engine = xkl_config_get_engine(config);
-	rv = xkl_set_names_prop(engine->priv->base_config_atom,
-				current_xmm_rules, data);
+	rv = xkl_engine_set_names_prop(engine,
+				       engine->priv->base_config_atom,
+				       current_xmm_rules, data);
 	if (rv)
 		xkl_xmm_lock_group(engine, 0);
 	return rv;
diff --git a/libxklavier/xklavier_dump.c b/libxklavier/xklavier_dump.c
index a62711c..3b269db 100644
--- a/libxklavier/xklavier_dump.c
+++ b/libxklavier/xklavier_dump.c
@@ -177,10 +177,13 @@ xkb_server_map_dump(FILE * fs, gint level, XkbServerMapPtr server,
 }
 
 static void
-xkb_key_type_dump(FILE * fs, gint level, XkbKeyTypePtr type)
+xkb_key_type_dump(FILE * fs, gint level, XkbKeyTypePtr type,
+		  XklEngine * engine)
 {
-	gchar *z = type->name == None ? NULL : XGetAtomName(xkl_display,
-							    type->name);
+	gchar *z =
+	    type->name ==
+	    None ? NULL : XGetAtomName(xkl_engine_get_display(engine),
+				       type->name);
 	fprintf(fs, "%*sname: 0x%X(%s)\n", level, "", (gint) type->name,
 		z);
 	if (z != NULL)
@@ -202,7 +205,7 @@ xkb_sym_map_dump(FILE * fs, gint level, XkbSymMapPtr ksm)
 
 static void
 xkb_client_map_dump(FILE * fs, gint level, XkbClientMapPtr map,
-		    XkbDescPtr kbd)
+		    XkbDescPtr kbd, XklEngine * engine)
 {
 	gint i;
 	fprintf(fs, "%*ssize_types: %d\n", level, "", map->size_types);
@@ -211,7 +214,7 @@ xkb_client_map_dump(FILE * fs, gint level, XkbClientMapPtr map,
 		XkbKeyTypePtr type = map->types;
 		for (i = 0; i < map->num_types; i++) {
 			fprintf(fs, "%*stypes[%d]:\n", level, "", i);
-			xkb_key_type_dump(fs, level + 2, type++);
+			xkb_key_type_dump(fs, level + 2, type++, engine);
 		}
 	} else
 		fprintf(fs, "%*sNO types\n", level, "");
@@ -236,7 +239,7 @@ xkb_client_map_dump(FILE * fs, gint level, XkbClientMapPtr map,
 }
 
 static void
-xkb_desc_dump(FILE * fs, gint level, XkbDescPtr kbd)
+xkb_desc_dump(FILE * fs, gint level, XkbDescPtr kbd, XklEngine * engine)
 {
 	fprintf(fs, "%*sflags: 0x%X\n", level, "", kbd->flags);
 	fprintf(fs, "%*sdevice_spec: %d\n", level, "", kbd->device_spec);
@@ -257,18 +260,20 @@ xkb_desc_dump(FILE * fs, gint level, XkbDescPtr kbd)
 
 	if (kbd->map != NULL) {
 		fprintf(fs, "%*smap:\n", level, "");
-		xkb_client_map_dump(fs, level + 2, kbd->map, kbd);
+		xkb_client_map_dump(fs, level + 2, kbd->map, kbd, engine);
 	} else
 		fprintf(fs, "%*sNO map\n", level, "");
 	fprintf(fs, "XKB libraries not present\n");
 }
 
 void
-xkl_dump_xkb_desc(const gchar * file_name, XkbDescPtr kbd)
+xkl_engine_dump_xkb_desc(XklEngine * engine, const gchar * file_name,
+			 XkbDescPtr kbd)
 {
 	FILE *fs = fopen(file_name, "w+");
 	if (fs != NULL) {
-		xkb_desc_dump(fs, 0, kbd == NULL ? xkl_xkb_desc : kbd);
+		xkb_desc_dump(fs, 0, kbd == NULL ? xkl_xkb_desc : kbd,
+			      engine);
 		fclose(fs);
 	}
 
diff --git a/libxklavier/xklavier_private.h b/libxklavier/xklavier_private.h
index eda75f5..0a5a96e 100644
--- a/libxklavier/xklavier_private.h
+++ b/libxklavier/xklavier_private.h
@@ -313,8 +313,10 @@ extern gint xkl_get_language_priority(const gchar * language);
 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);
+extern gboolean xkl_config_rec_get_full_from_server(gchar **
+						    rules_file_out,
+						    XklConfigRec * data,
+						    XklEngine * engine);
 
 extern gchar *xkl_strings_concat_comma_separated(gchar ** array);
 
diff --git a/libxklavier/xklavier_private_xkb.h b/libxklavier/xklavier_private_xkb.h
index 1c70624..55e6134 100644
--- a/libxklavier/xklavier_private_xkb.h
+++ b/libxklavier/xklavier_private_xkb.h
@@ -18,7 +18,9 @@ extern XkbDescPtr xkl_xkb_desc;
 
 extern gchar *xkl_xkb_indicator_names[];
 
-extern void xkl_dump_xkb_desc(const char *file_name, XkbDescPtr kbd);
+extern void xkl_engine_dump_xkb_desc(XklEngine * engine,
+				     const char *file_name,
+				     XkbDescPtr kbd);
 
 extern gboolean xkl_xkb_multiple_layouts_supported(XklEngine * engine);
 
diff --git a/libxklavier/xklavier_props.c b/libxklavier/xklavier_props.c
index 2a56868..f76d649 100644
--- a/libxklavier/xklavier_props.c
+++ b/libxklavier/xklavier_props.c
@@ -92,14 +92,16 @@ xkl_lists_equal(gchar ** items1, gchar ** items2)
 }
 
 static gboolean
-xkl_get_default_names_prop(char **rules_file_out, XklConfigRec * data)
+xkl_engine_get_default_names_prop(XklEngine * engine,
+				  char **rules_file_out,
+				  XklConfigRec * data)
 {
 	if (rules_file_out != NULL)
 		*rules_file_out = g_strdup(XKB_DEFAULT_RULESET);
-	data->model = g_strdup(xkl_vtable->default_model);
+	data->model = g_strdup(engine->priv->default_model);
 /* keeping Nvariants = Nlayouts */
 	data->layouts = g_new0(char *, 2);
-	data->layouts[0] = g_strdup(xkl_vtable->default_layout);
+	data->layouts[0] = g_strdup(engine->priv->default_layout);
 	data->variants = g_new0(char *, 2);
 	data->variants[0] = g_strdup("");
 	data->options = NULL;
@@ -107,13 +109,19 @@ xkl_get_default_names_prop(char **rules_file_out, XklConfigRec * data)
 }
 
 gboolean
-xkl_config_get_full_from_server(char **rules_file_out, XklConfigRec * data)
+xkl_config_rec_get_full_from_server(char **rules_file_out,
+				    XklConfigRec * data,
+				    XklEngine * engine)
 {
-	gboolean rv = xkl_get_names_prop(xkl_vtable->base_config_atom,
-					 rules_file_out, data);
+	gboolean rv =
+	    xkl_engine_get_names_prop(engine,
+				      engine->priv->base_config_atom,
+				      rules_file_out, data);
 
 	if (!rv)
-		rv = xkl_get_default_names_prop(rules_file_out, data);
+		rv = xkl_engine_get_default_names_prop(engine,
+						       rules_file_out,
+						       data);
 
 	return rv;
 }
@@ -160,20 +168,21 @@ xkl_config_rec_reset(XklConfigRec * data)
 }
 
 gboolean
-xkl_config_get_from_server(XklConfigRec * data)
+xkl_config_rec_get_from_server(XklConfigRec * data, XklEngine * engine)
 {
-	return xkl_config_get_full_from_server(NULL, data);
+	return xkl_config_rec_get_full_from_server(NULL, data, engine);
 }
 
 gboolean
-xkl_config_get_from_backup(XklConfigRec * data)
+xkl_config_rec_get_from_backup(XklConfigRec * data, XklEngine * engine)
 {
-	return xkl_get_names_prop(xkl_vtable->backup_config_atom, NULL,
-				  data);
+	return xkl_engine_get_names_prop(engine,
+					 engine->priv->backup_config_atom,
+					 NULL, data);
 }
 
 gboolean
-xkl_backup_names_prop(void)
+xkl_backup_names_prop(XklEngine * engine)
 {
 	gboolean rv = TRUE;
 	gchar *rf = NULL;
@@ -181,18 +190,19 @@ xkl_backup_names_prop(void)
 	gboolean cgp = FALSE;
 
 	xkl_config_rec_init(&data);
-	if (xkl_get_names_prop
-	    (xkl_vtable->backup_config_atom, NULL, &data)) {
+	if (xkl_engine_get_names_prop
+	    (engine, engine->priv->backup_config_atom, NULL, &data)) {
 		xkl_config_rec_destroy(&data);
 		return TRUE;
 	}
 	/* "backup" property is not defined */
 	xkl_config_rec_reset(&data);
-	cgp = xkl_config_get_full_from_server(&rf, &data);
+	cgp = xkl_config_rec_get_full_from_server(&rf, &data, engine);
 
 	if (cgp) {
-		if (!xkl_set_names_prop
-		    (xkl_vtable->backup_config_atom, rf, &data)) {
+		if (!xkl_engine_set_names_prop
+		    (engine, engine->priv->backup_config_atom, rf,
+		     &data)) {
 			xkl_debug(150,
 				  "Could not backup the configuration");
 			rv = FALSE;
@@ -209,20 +219,21 @@ xkl_backup_names_prop(void)
 }
 
 gboolean
-xkl_restore_names_prop(void)
+xkl_restore_names_prop(XklEngine * engine)
 {
 	gboolean rv = TRUE;
 	gchar *rf = NULL;
 	XklConfigRec data;
 
 	xkl_config_rec_init(&data);
-	if (!xkl_get_names_prop
-	    (xkl_vtable->backup_config_atom, NULL, &data)) {
+	if (!xkl_engine_get_names_prop
+	    (engine, engine->priv->backup_config_atom, NULL, &data)) {
 		xkl_config_rec_destroy(&data);
 		return FALSE;
 	}
 
-	if (!xkl_set_names_prop(xkl_vtable->base_config_atom, rf, &data)) {
+	if (!xkl_engine_set_names_prop
+	    (engine, engine->priv->base_config_atom, rf, &data)) {
 		xkl_debug(150, "Could not backup the configuration");
 		rv = FALSE;
 	}
@@ -231,8 +242,8 @@ xkl_restore_names_prop(void)
 }
 
 gboolean
-xkl_get_names_prop(Atom rules_atom,
-		   gchar ** rules_file_out, XklConfigRec * data)
+xkl_engine_get_names_prop(XklEngine * engine, Atom rules_atom,
+			  gchar ** rules_file_out, XklConfigRec * data)
 {
 	Atom real_prop_type;
 	int fmt;
@@ -242,19 +253,22 @@ xkl_get_names_prop(Atom rules_atom,
 
 	/* no such atom! */
 	if (rules_atom == None) {	/* property cannot exist */
-		xkl_last_error_message = "Could not find the atom";
+		engine->priv->last_error_message =
+		    "Could not find the atom";
 		return FALSE;
 	}
 
 	rtrn =
-	    XGetWindowProperty(xkl_display, xkl_root_window, rules_atom,
-			       0L, XKB_RF_NAMES_PROP_MAXLEN, False,
-			       XA_STRING, &real_prop_type, &fmt, &nitems,
+	    XGetWindowProperty(xkl_engine_get_display(engine),
+			       engine->priv->root_window, rules_atom, 0L,
+			       XKB_RF_NAMES_PROP_MAXLEN, False, XA_STRING,
+			       &real_prop_type, &fmt, &nitems,
 			       &extra_bytes,
 			       (unsigned char **) (void *) &prop_data);
 	/* property not found! */
 	if (rtrn != Success) {
-		xkl_last_error_message = "Could not get the property";
+		engine->priv->last_error_message =
+		    "Could not get the property";
 		return FALSE;
 	}
 	/* set rules file to "" */
@@ -266,12 +280,13 @@ xkl_get_names_prop(Atom rules_atom,
 	    || (fmt != 8)) {
 		if (prop_data)
 			XFree(prop_data);
-		xkl_last_error_message = "Wrong property format";
+		engine->priv->last_error_message = "Wrong property format";
 		return FALSE;
 	}
 
 	if (!prop_data) {
-		xkl_last_error_message = "No properties returned";
+		engine->priv->last_error_message =
+		    "No properties returned";
 		return FALSE;
 	}
 
@@ -358,8 +373,8 @@ xkl_get_names_prop(Atom rules_atom,
 
 /* taken from XFree86 maprules.c */
 gboolean
-xkl_set_names_prop(Atom rules_atom,
-		   gchar * rules_file, const XklConfigRec * data)
+xkl_engine_set_names_prop(XklEngine * engine, Atom rules_atom,
+			  gchar * rules_file, const XklConfigRec * data)
 {
 	gint len, rv;
 	gchar *pval;
@@ -380,7 +395,8 @@ xkl_set_names_prop(Atom rules_atom,
 
 	pval = next = g_new(char, len + 1);
 	if (!pval) {
-		xkl_last_error_message = "Could not allocate buffer";
+		engine->priv->last_error_message =
+		    "Could not allocate buffer";
 		if (all_layouts != NULL)
 			g_free(all_layouts);
 		if (all_variants != NULL)
@@ -424,14 +440,16 @@ xkl_set_names_prop(Atom rules_atom,
 		if (all_options != NULL)
 			g_free(all_options);
 		g_free(pval);
-		xkl_last_error_message = "Internal property parsing error";
+		engine->priv->last_error_message =
+		    "Internal property parsing error";
 		return FALSE;
 	}
 
-	rv = XChangeProperty(xkl_display, xkl_root_window, rules_atom,
-			     XA_STRING, 8, PropModeReplace,
+	Display *display = xkl_engine_get_display(engine);
+	rv = XChangeProperty(display, engine->priv->root_window,
+			     rules_atom, XA_STRING, 8, PropModeReplace,
 			     (unsigned char *) pval, len);
-	XSync(xkl_display, False);
+	XSync(display, False);
 #if 0
 	for (i = len - 1; --i >= 0;)
 		if (pval[i] == '\0')
diff --git a/libxklavier/xklavier_xmm.c b/libxklavier/xklavier_xmm.c
index 9a4fce6..0636dff 100755
--- a/libxklavier/xklavier_xmm.c
+++ b/libxklavier/xklavier_xmm.c
@@ -176,8 +176,9 @@ xkl_xmm_if_cached_info_equals_actual(XklEngine * engine)
 gboolean
 xkl_xmm_load_all_info(XklEngine * engine)
 {
-	return xkl_config_get_full_from_server(&current_xmm_rules,
-					       &current_xmm_config);
+	return xkl_config_rec_get_full_from_server(&current_xmm_rules,
+						   &current_xmm_config,
+						   engine);
 }
 
 void