[andy/viking.git] / src / vikgobjectbuilder.c

/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
/*
 * viking
 * Copyright (C) Guilhem Bonnefille 2009 <guilhem.bonnefille@gmail.com>
 * 
 * viking is free software: you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * viking is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License along
 * with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <stdio.h>
#ifdef HAVE_STRING_H
#include <string.h>
#endif

#include <glib.h>
#include <glib/gstdio.h>

#include <gtk/gtkbuilder.h>

#include "vikgobjectbuilder.h"

/* FIXME use private fields */
static gchar *class_name = NULL;
GType gtype = 0;
gchar *property_name = NULL;
GParameter *parameters = NULL;
gint nb_parameters = 0;

/* signals */
enum
{
	NEW_OBJECT,

	LAST_SIGNAL
};


static guint gobject_builder_signals[LAST_SIGNAL] = { 0 };

G_DEFINE_TYPE (VikGobjectBuilder, vik_gobject_builder, G_TYPE_OBJECT);

static void
vik_gobject_builder_init (VikGobjectBuilder *object)
{
	/* TODO: Add initialization code here */
}

static void
vik_gobject_builder_finalize (GObject *object)
{
	/* TODO: Add deinitalization code here */

	G_OBJECT_CLASS (vik_gobject_builder_parent_class)->finalize (object);
}

static void
vik_gobject_builder_new_object (VikGobjectBuilder *self, GObject *object)
{
	/* TODO: Add default signal handler implementation here */
}

static void
vik_gobject_builder_class_init (VikGobjectBuilderClass *klass)
{
	GObjectClass* object_class = G_OBJECT_CLASS (klass);
	GObjectClass* parent_class = G_OBJECT_CLASS (klass);

	object_class->finalize = vik_gobject_builder_finalize;

	klass->new_object = vik_gobject_builder_new_object;

	gobject_builder_signals[NEW_OBJECT] =
		g_signal_new ("new-object",
		              G_OBJECT_CLASS_TYPE (klass),
		              0,
		              G_STRUCT_OFFSET (VikGobjectBuilderClass, new_object),
		              NULL, NULL,
		              g_cclosure_marshal_VOID__OBJECT,
		              G_TYPE_NONE, 1,
		              G_TYPE_OBJECT);
}

/* Called for open tags <foo bar="baz"> */
static void
_start_element (GMarkupParseContext *context,
                const gchar         *element_name,
                const gchar        **attribute_names,
                const gchar        **attribute_values,
                gpointer             user_data,
                GError             **error)
{
	if (strcmp(element_name, "object") == 0)
	{
		class_name = g_strdup(attribute_values[0]);
		gtype = g_type_from_name (class_name);
		if (gtype == 0)
		{
			g_warning("Unknown GObject type '%s'", class_name);
			return;
		}
	}
	if (strcmp(element_name, "property") == 0 && gtype != 0)
	{
		int i=0;
		while (attribute_names[i] != NULL)
		{
			if (strcmp (attribute_names[i], "name") == 0)
			{
				g_free (property_name);
				property_name = g_strdup (attribute_values[i]);
			}
			i++;
		}
	}
}

/* Called for close tags </foo> */
static void
_end_element (GMarkupParseContext *context,
              const gchar         *element_name,
              gpointer             user_data,
              GError             **error)
{
	VikGobjectBuilder *self = VIK_GOBJECT_BUILDER (user_data);
	gpointer object = NULL;
	if (strcmp(element_name, "object") == 0 && gtype != 0)
	{
		object = g_object_newv(gtype, nb_parameters, parameters);
		if (object != NULL)
		{
			g_debug("VikGobjectBuilder: new GObject of type %s", g_type_name(gtype));
			g_signal_emit ( G_OBJECT(self), gobject_builder_signals[NEW_OBJECT], 0, object );
			g_object_unref (object);
		}
		/* Free memory */
		int i = 0;
		for (i = 0 ; i < nb_parameters ; i++)
		{
			g_free (parameters[i].name);
			g_value_unset (&(parameters[i].value));
		}
		g_free (parameters);
		parameters = NULL;
		nb_parameters = 0;
		gtype = 0;
	}
	if (strcmp(element_name, "property") == 0)
	{
		g_free (property_name);
		property_name = NULL;
	}
}

/* Called for character data */
/* text is not nul-terminated */
static void
_text (GMarkupParseContext *context,
       const gchar         *text,
       gsize                text_len,  
       gpointer             user_data,
       GError             **error)
{
	if (strcmp (g_markup_parse_context_get_element (context), "property") == 0)
	{
		GValue gvalue = {0};
		gboolean found = FALSE;
		if (gtype != 0 && property_name != NULL)
		{
			/* parameter value */
			/* We have to retrieve the expected type of the value 
			 * in order to do the correct transformation */
			GObjectClass *oclass;
			oclass = g_type_class_ref (gtype);
			g_assert (oclass != NULL);
			GParamSpec *pspec;
			pspec = g_object_class_find_property (G_OBJECT_CLASS (oclass), property_name);
			if (!pspec)
			{
				g_warning ("Unknown property: %s.%s", g_type_name (gtype), property_name);
				return;
			}
			gchar *value = g_strndup (text, text_len);
			found = gtk_builder_value_from_string_type(NULL, pspec->value_type, value, &gvalue, NULL);
			g_free (value);
		}
		if (G_IS_VALUE (&gvalue) && found == TRUE)
		{
			/* store new parameter */
			g_debug("VikGobjectBuilder: store new GParameter for %s: (%s)%s=%*s",
			        g_type_name(gtype), g_type_name(G_VALUE_TYPE(&gvalue)), property_name, text_len, text);
			nb_parameters++;
			parameters = g_realloc(parameters, sizeof(GParameter)*nb_parameters);
			/* parameter name */
			parameters[nb_parameters-1].name = g_strdup(property_name);
			/* parameter value */
			parameters[nb_parameters-1].value = gvalue;
		}
	}
}

VikGobjectBuilder *
vik_gobject_builder_new (void)
{
	return g_object_new (VIK_TYPE_GOBJECT_BUILDER, NULL);
}

void
vik_gobject_builder_parse (VikGobjectBuilder *self, const gchar *filename)
{
	GMarkupParser xml_parser;
	GMarkupParseContext *xml_context;
	GError *error;

	FILE *file = g_fopen (filename, "r");
	if (file == NULL)
		/* TODO emit warning */
		return;
	
	/* setup context parse (ie callbacks) */
	xml_parser.start_element = &_start_element;
	xml_parser.end_element = &_end_element;
	xml_parser.text = &_text;
	xml_parser.passthrough = NULL;
	xml_parser.error = NULL;
	
	xml_context = g_markup_parse_context_new(&xml_parser, 0, self, NULL);
	
	gchar buff[BUFSIZ];
	size_t nb;
	while ((nb = fread (buff, sizeof(gchar), BUFSIZ, file)) > 0)
	{
		if (!g_markup_parse_context_parse(xml_context, buff, nb, &error))
			printf("read_xml() : parsing error.\n");
	}
	/* cleanup */
	if (!g_markup_parse_context_end_parse(xml_context, &error))
		printf("read_xml() : errors occurred reading file.\n");
	
	g_markup_parse_context_free(xml_context);
	fclose (file);
}
Commit	Line	Data
7bc5a5a9 GB	1	/* -- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -- */
	2	/*
	3	* viking
	4	* Copyright (C) Guilhem Bonnefille 2009 <guilhem.bonnefille@gmail.com>
	5	*
	6	* viking is free software: you can redistribute it and/or modify it
	7	* under the terms of the GNU General Public License as published by the
	8	* Free Software Foundation, either version 3 of the License, or
	9	* (at your option) any later version.
	10	*
	11	* viking is distributed in the hope that it will be useful, but
	12	* WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
	14	* See the GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License along
	17	* with this program. If not, see <http://www.gnu.org/licenses/>.
	18	*/
	19
	20	#ifdef HAVE_CONFIG_H
	21	#include "config.h"
	22	#endif
	23
	24	#include <stdio.h>
	25	#ifdef HAVE_STRING_H
	26	#include <string.h>
	27	#endif
	28
	29	#include <glib.h>
	30	#include <glib/gstdio.h>
	31
	32	#include <gtk/gtkbuilder.h>
	33
	34	#include "vikgobjectbuilder.h"
	35
	36	/* FIXME use private fields */
	37	static gchar *class_name = NULL;
	38	GType gtype = 0;
	39	gchar *property_name = NULL;
	40	GParameter *parameters = NULL;
	41	gint nb_parameters = 0;
	42
	43	/* signals */
	44	enum
	45	{
	46	NEW_OBJECT,
	47
	48	LAST_SIGNAL
	49	};
	50
	51
	52	static guint gobject_builder_signals[LAST_SIGNAL] = { 0 };
	53
	54	G_DEFINE_TYPE (VikGobjectBuilder, vik_gobject_builder, G_TYPE_OBJECT);
	55
	56	static void
	57	vik_gobject_builder_init (VikGobjectBuilder *object)
	58	{
	59	/* TODO: Add initialization code here */
	60	}
	61
	62	static void
	63	vik_gobject_builder_finalize (GObject *object)
	64	{
65	/* TODO: Add deinitalization code here */
66
67	G_OBJECT_CLASS (vik_gobject_builder_parent_class)->finalize (object);
68	}
69
70	static void
71	vik_gobject_builder_new_object (VikGobjectBuilder self, GObject object)
72	{
73	/* TODO: Add default signal handler implementation here */
74	}
75
76	static void
77	vik_gobject_builder_class_init (VikGobjectBuilderClass *klass)
78	{
79	GObjectClass* object_class = G_OBJECT_CLASS (klass);
80	GObjectClass* parent_class = G_OBJECT_CLASS (klass);
81
82	object_class->finalize = vik_gobject_builder_finalize;
83
84	klass->new_object = vik_gobject_builder_new_object;
85
86	gobject_builder_signals[NEW_OBJECT] =
87	g_signal_new ("new-object",
88	G_OBJECT_CLASS_TYPE (klass),
89	0,
90	G_STRUCT_OFFSET (VikGobjectBuilderClass, new_object),
91	NULL, NULL,
92	g_cclosure_marshal_VOID__OBJECT,
93	G_TYPE_NONE, 1,
94	G_TYPE_OBJECT);
95	}
96
97	/* Called for open tags <foo bar="baz"> */
98	static void
99	_start_element (GMarkupParseContext *context,
100	const gchar *element_name,
101	const gchar **attribute_names,
102	const gchar **attribute_values,
103	gpointer user_data,
104	GError **error)
105	{
106	if (strcmp(element_name, "object") == 0)
107	{
108	class_name = g_strdup(attribute_values[0]);
109	gtype = g_type_from_name (class_name);
1487f9b6 GB	110	if (gtype == 0)
	111	{
	112	g_warning("Unknown GObject type '%s'", class_name);
	113	return;
	114	}
7bc5a5a9 GB	115	}
	116	if (strcmp(element_name, "property") == 0 && gtype != 0)
	117	{
	118	int i=0;
	119	while (attribute_names[i] != NULL)
	120	{
	121	if (strcmp (attribute_names[i], "name") == 0)
	122	{
	123	g_free (property_name);
	124	property_name = g_strdup (attribute_values[i]);
	125	}
	126	i++;
	127	}
	128	}
	129	}
	130
	131	/* Called for close tags </foo> */
	132	static void
	133	_end_element (GMarkupParseContext *context,
	134	const gchar *element_name,
	135	gpointer user_data,
	136	GError **error)
	137	{
	138	VikGobjectBuilder *self = VIK_GOBJECT_BUILDER (user_data);
	139	gpointer object = NULL;
	140	if (strcmp(element_name, "object") == 0 && gtype != 0)
	141	{
	142	object = g_object_newv(gtype, nb_parameters, parameters);
	143	if (object != NULL)
	144	{
	145	g_debug("VikGobjectBuilder: new GObject of type %s", g_type_name(gtype));
	146	g_signal_emit ( G_OBJECT(self), gobject_builder_signals[NEW_OBJECT], 0, object );
	147	g_object_unref (object);
	148	}
	149	/* Free memory */
	150	int i = 0;
	151	for (i = 0 ; i < nb_parameters ; i++)
	152	{
	153	g_free (parameters[i].name);
	154	g_value_unset (&(parameters[i].value));
	155	}
	156	g_free (parameters);
	157	parameters = NULL;
	158	nb_parameters = 0;
	159	gtype = 0;
	160	}
	161	if (strcmp(element_name, "property") == 0)
	162	{
	163	g_free (property_name);
	164	property_name = NULL;
	165	}
	166	}
	167
	168	/* Called for character data */
	169	/* text is not nul-terminated */
	170	static void
	171	_text (GMarkupParseContext *context,
	172	const gchar *text,
	173	gsize text_len,
	174	gpointer user_data,
	175	GError **error)
	176	{
	177	if (strcmp (g_markup_parse_context_get_element (context), "property") == 0)
	178	{
179	GValue gvalue = {0};
180	gboolean found = FALSE;
181	if (gtype != 0 && property_name != NULL)
182	{
183	/* parameter value */
184	/* We have to retrieve the expected type of the value
185	* in order to do the correct transformation */
186	GObjectClass *oclass;
187	oclass = g_type_class_ref (gtype);
188	g_assert (oclass != NULL);
189	GParamSpec *pspec;
190	pspec = g_object_class_find_property (G_OBJECT_CLASS (oclass), property_name);
191	if (!pspec)
192	{
193	g_warning ("Unknown property: %s.%s", g_type_name (gtype), property_name);
194	return;
195	}
196	gchar *value = g_strndup (text, text_len);
197	found = gtk_builder_value_from_string_type(NULL, pspec->value_type, value, &gvalue, NULL);
198	g_free (value);
199	}
200	if (G_IS_VALUE (&gvalue) && found == TRUE)
201	{
202	/* store new parameter */
203	g_debug("VikGobjectBuilder: store new GParameter for %s: (%s)%s=%*s",
204	g_type_name(gtype), g_type_name(G_VALUE_TYPE(&gvalue)), property_name, text_len, text);
205	nb_parameters++;
206	parameters = g_realloc(parameters, sizeof(GParameter)*nb_parameters);
207	/* parameter name */
208	parameters[nb_parameters-1].name = g_strdup(property_name);
209	/* parameter value */
210	parameters[nb_parameters-1].value = gvalue;
211	}
212	}
213	}
214
215	VikGobjectBuilder *
216	vik_gobject_builder_new (void)
217	{
218	return g_object_new (VIK_TYPE_GOBJECT_BUILDER, NULL);
219	}
220
221	void
222	vik_gobject_builder_parse (VikGobjectBuilder self, const gchar filename)
223	{
224	GMarkupParser xml_parser;
225	GMarkupParseContext *xml_context;
226	GError *error;
227
228	FILE *file = g_fopen (filename, "r");
229	if (file == NULL)
230	/* TODO emit warning */
231	return;
232
233	/* setup context parse (ie callbacks) */
234	xml_parser.start_element = &_start_element;
235	xml_parser.end_element = &_end_element;
236	xml_parser.text = &_text;
237	xml_parser.passthrough = NULL;
238	xml_parser.error = NULL;
239
240	xml_context = g_markup_parse_context_new(&xml_parser, 0, self, NULL);
241
242	gchar buff[BUFSIZ];
243	size_t nb;
244	while ((nb = fread (buff, sizeof(gchar), BUFSIZ, file)) > 0)
245	{
246	if (!g_markup_parse_context_parse(xml_context, buff, nb, &error))
247	printf("read_xml() : parsing error.\n");
248	}
249	/* cleanup */
250	if (!g_markup_parse_context_end_parse(xml_context, &error))
251	printf("read_xml() : errors occurred reading file.\n");
252
253	g_markup_parse_context_free(xml_context);
254	fclose (file);
255	}