Remove unused variable
[dana/openbox.git] / obt / xml.c
1 /* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
2
3    obt/xml.c for the Openbox window manager
4    Copyright (c) 2003-2007   Dana Jansens
5
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 2 of the License, or
9    (at your option) any later version.
10
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15
16    See the COPYING file for a copy of the GNU General Public License.
17 */
18
19 #include "obt/xml.h"
20 #include "obt/paths.h"
21
22 #include <libxml/xinclude.h>
23 #include <glib.h>
24
25 #ifdef HAVE_STDLIB_H
26 #  include <stdlib.h>
27 #endif
28 #ifdef HAVE_SYS_STAT_H
29 #  include <sys/stat.h>
30 #endif
31 #ifdef HAVE_SYS_TYPES_H
32 #  include <sys/types.h>
33 #endif
34 #ifdef HAVE_UNISTD_H
35 #  include <unistd.h>
36 #endif
37
38 struct Callback {
39     gchar *tag;
40     ObtXmlCallback func;
41     gpointer data;
42 };
43
44 struct _ObtXmlInst {
45     gint ref;
46     ObtPaths *xdg_paths;
47     GHashTable *callbacks;
48     xmlDocPtr doc;
49     xmlNodePtr root;
50     gchar *path;
51 };
52
53 static void destfunc(struct Callback *c)
54 {
55     g_free(c->tag);
56     g_slice_free(struct Callback, c);
57 }
58
59 ObtXmlInst* obt_xml_instance_new(void)
60 {
61     ObtXmlInst *i = g_slice_new(ObtXmlInst);
62     i->ref = 1;
63     i->xdg_paths = obt_paths_new();
64     i->callbacks = g_hash_table_new_full(g_str_hash, g_str_equal, NULL,
65                                          (GDestroyNotify)destfunc);
66     i->doc = NULL;
67     i->root = NULL;
68     i->path = NULL;
69     return i;
70 }
71
72 void obt_xml_instance_ref(ObtXmlInst *i)
73 {
74     ++i->ref;
75 }
76
77 void obt_xml_instance_unref(ObtXmlInst *i)
78 {
79     if (i && --i->ref == 0) {
80         obt_paths_unref(i->xdg_paths);
81         g_hash_table_destroy(i->callbacks);
82         g_slice_free(ObtXmlInst, i);
83     }
84 }
85
86 xmlDocPtr obt_xml_doc(ObtXmlInst *i)
87 {
88     g_assert(i->doc); /* a doc is open? */
89     return i->doc;
90 }
91
92 xmlNodePtr obt_xml_root(ObtXmlInst *i)
93 {
94     g_assert(i->doc); /* a doc is open? */
95     return i->root;
96 }
97
98 void obt_xml_register(ObtXmlInst *i, const gchar *tag,
99                       ObtXmlCallback func, gpointer data)
100 {
101     struct Callback *c;
102
103     if (g_hash_table_lookup(i->callbacks, tag)) {
104         g_error("Tag '%s' already registered", tag);
105         return;
106     }
107
108     c = g_slice_new(struct Callback);
109     c->tag = g_strdup(tag);
110     c->func = func;
111     c->data = data;
112     g_hash_table_insert(i->callbacks, c->tag, c);
113 }
114
115 static gboolean load_file(ObtXmlInst *i,
116                           const gchar *domain,
117                           const gchar *filename,
118                           const gchar *root_node,
119                           GSList *paths)
120 {
121     GSList *it;
122     gboolean r = FALSE;
123
124     g_assert(i->doc == NULL); /* another doc isn't open already? */
125
126     for (it = paths; !r && it; it = g_slist_next(it)) {
127         gchar *path;
128         struct stat s;
129
130         if (!domain && !filename) /* given a full path to the file */
131             path = g_strdup(it->data);
132         else
133             path = g_build_filename(it->data, domain, filename, NULL);
134
135         if (stat(path, &s) >= 0) {
136             /* XML_PARSE_BLANKS is needed apparently, or the tree can end up
137                with extra nodes in it. */
138             i->doc = xmlReadFile(path, NULL, (XML_PARSE_NOBLANKS |
139                                               XML_PARSE_RECOVER));
140             xmlXIncludeProcessFlags(i->doc, (XML_PARSE_NOBLANKS |
141                                              XML_PARSE_RECOVER));
142             if (i->doc) {
143                 i->root = xmlDocGetRootElement(i->doc);
144                 if (!i->root) {
145                     xmlFreeDoc(i->doc);
146                     i->doc = NULL;
147                     g_message("%s is an empty XML document", path);
148                 }
149                 else if (xmlStrcmp(i->root->name,
150                                    (const xmlChar*)root_node)) {
151                     xmlFreeDoc(i->doc);
152                     i->doc = NULL;
153                     i->root = NULL;
154                     g_message("XML document %s is of wrong type. Root "
155                               "node is not '%s'", path, root_node);
156                 }
157                 else {
158                     i->path = g_strdup(path);
159                     r = TRUE; /* ok! */
160                 }
161             }
162         }
163
164         g_free(path);
165     }
166
167     return r;
168 }
169
170 gboolean obt_xml_load_file(ObtXmlInst *i,
171                            const gchar *path,
172                            const gchar *root_node)
173 {
174     GSList *paths;
175     gboolean r;
176
177     paths = g_slist_append(NULL, g_strdup(path));
178
179     r = load_file(i, NULL, NULL, root_node, paths);
180
181     while (paths) {
182         g_free(paths->data);
183         paths = g_slist_delete_link(paths, paths);
184     }
185     return r;
186 }
187
188 gboolean obt_xml_load_config_file(ObtXmlInst *i,
189                                   const gchar *domain,
190                                   const gchar *filename,
191                                   const gchar *root_node)
192 {
193     GSList *it, *paths = NULL;
194     gboolean r;
195
196     for (it = obt_paths_config_dirs(i->xdg_paths); it; it = g_slist_next(it))
197         paths = g_slist_append(paths, g_strdup(it->data));
198
199     r = load_file(i, domain, filename, root_node, paths);
200
201     while (paths) {
202         g_free(paths->data);
203         paths = g_slist_delete_link(paths, paths);
204     }
205     return r;
206 }
207
208 gboolean obt_xml_load_data_file(ObtXmlInst *i,
209                                 const gchar *domain,
210                                 const gchar *filename,
211                                 const gchar *root_node)
212 {
213     GSList *it, *paths = NULL;
214     gboolean r;
215
216     for (it = obt_paths_data_dirs(i->xdg_paths); it; it = g_slist_next(it))
217         paths = g_slist_append(paths, g_strdup(it->data));
218
219     r = load_file(i, domain, filename, root_node, paths);
220
221     while (paths) {
222         g_free(paths->data);
223         paths = g_slist_delete_link(paths, paths);
224     }
225     return r;
226 }
227
228 gboolean obt_xml_load_theme_file(ObtXmlInst *i,
229                                  const gchar *theme,
230                                  const gchar *domain,
231                                  const gchar *filename,
232                                  const gchar *root_node)
233 {
234     GSList *it, *paths = NULL;
235     gboolean r;
236
237     /* use ~/.themes for backwards compatibility */
238     paths = g_slist_append
239         (paths, g_build_filename(g_get_home_dir(), ".themes", theme, NULL));
240
241     for (it = obt_paths_data_dirs(i->xdg_paths); it; it = g_slist_next(it))
242         paths = g_slist_append
243             (paths, g_build_filename(it->data, "themes", theme, NULL));
244
245     r = load_file(i, domain, filename, root_node, paths);
246
247     while (paths) {
248         g_free(paths->data);
249         paths = g_slist_delete_link(paths, paths);
250     }
251     return r;
252 }
253
254
255 gboolean obt_xml_load_mem(ObtXmlInst *i,
256                           gpointer data, guint len, const gchar *root_node)
257 {
258     gboolean r = FALSE;
259
260     g_assert(i->doc == NULL); /* another doc isn't open already? */
261
262     i->doc = xmlParseMemory(data, len);
263     if (i) {
264         i->root = xmlDocGetRootElement(i->doc);
265         if (!i->root) {
266             xmlFreeDoc(i->doc);
267             i->doc = NULL;
268             g_message("Given memory is an empty document");
269         }
270         else if (xmlStrcmp(i->root->name, (const xmlChar*)root_node)) {
271             xmlFreeDoc(i->doc);
272             i->doc = NULL;
273             i->root = NULL;
274             g_message("XML Document in given memory is of wrong "
275                       "type. Root node is not '%s'\n", root_node);
276         }
277         else
278             r = TRUE; /* ok ! */
279     }
280     return r;
281 }
282
283 gboolean obt_xml_save_file(ObtXmlInst *inst,
284                            const gchar *path,
285                            gboolean pretty)
286 {
287     return xmlSaveFormatFile(path, inst->doc, pretty) != -1;
288 }
289
290 void obt_xml_close(ObtXmlInst *i)
291 {
292     if (i && i->doc) {
293         xmlFreeDoc(i->doc);
294         g_free(i->path);
295         i->doc = NULL;
296         i->root = NULL;
297         i->path = NULL;
298     }
299 }
300
301 void obt_xml_tree(ObtXmlInst *i, xmlNodePtr node)
302 {
303     g_assert(i->doc); /* a doc is open? */
304
305     while (node) {
306         if (node->name) {
307             struct Callback *c = g_hash_table_lookup(i->callbacks, node->name);
308             if (c) c->func(node, c->data);
309         }
310         node = node->next;
311     }
312 }
313
314 void obt_xml_tree_from_root(ObtXmlInst *i)
315 {
316     obt_xml_tree(i, i->root->children);
317 }
318
319 gchar *obt_xml_node_string(xmlNodePtr node)
320 {
321     xmlChar *c = xmlNodeGetContent(node);
322     gchar *s;
323     if (c) g_strstrip((char*)c); /* strip leading/trailing whitespace */
324     s = g_strdup(c ? (gchar*)c : "");
325     xmlFree(c);
326     return s;
327 }
328
329 gint obt_xml_node_int(xmlNodePtr node)
330 {
331     xmlChar *c = xmlNodeGetContent(node);
332     gint i;
333     if (c) g_strstrip((char*)c); /* strip leading/trailing whitespace */
334     i = c ? atoi((gchar*)c) : 0;
335     xmlFree(c);
336     return i;
337 }
338
339 gboolean obt_xml_node_bool(xmlNodePtr node)
340 {
341     xmlChar *c = xmlNodeGetContent(node);
342     gboolean b = FALSE;
343     if (c) g_strstrip((char*)c); /* strip leading/trailing whitespace */
344     if (c && !xmlStrcasecmp(c, (const xmlChar*) "true"))
345         b = TRUE;
346     else if (c && !xmlStrcasecmp(c, (const xmlChar*) "yes"))
347         b = TRUE;
348     else if (c && !xmlStrcasecmp(c, (const xmlChar*) "on"))
349         b = TRUE;
350     xmlFree(c);
351     return b;
352 }
353
354 gboolean obt_xml_node_contains(xmlNodePtr node, const gchar *val)
355 {
356     xmlChar *c = xmlNodeGetContent(node);
357     gboolean r;
358     if (c) g_strstrip((char*)c); /* strip leading/trailing whitespace */
359     r = !xmlStrcasecmp(c, (const xmlChar*) val);
360     xmlFree(c);
361     return r;
362 }
363
364 xmlNodePtr obt_xml_find_node(xmlNodePtr node, const gchar *tag)
365 {
366     while (node) {
367         if (!xmlStrcmp(node->name, (const xmlChar*) tag))
368             return node;
369         node = node->next;
370     }
371     return NULL;
372 }
373
374 gboolean obt_xml_attr_bool(xmlNodePtr node, const gchar *name,
375                            gboolean *value)
376 {
377     xmlChar *c = xmlGetProp(node, (const xmlChar*) name);
378     gboolean r = FALSE;
379     if (c) {
380         g_strstrip((char*)c); /* strip leading/trailing whitespace */
381         if (!xmlStrcasecmp(c, (const xmlChar*) "true"))
382             *value = TRUE, r = TRUE;
383         else if (!xmlStrcasecmp(c, (const xmlChar*) "yes"))
384             *value = TRUE, r = TRUE;
385         else if (!xmlStrcasecmp(c, (const xmlChar*) "on"))
386             *value = TRUE, r = TRUE;
387         else if (!xmlStrcasecmp(c, (const xmlChar*) "false"))
388             *value = FALSE, r = TRUE;
389         else if (!xmlStrcasecmp(c, (const xmlChar*) "no"))
390             *value = FALSE, r = TRUE;
391         else if (!xmlStrcasecmp(c, (const xmlChar*) "off"))
392             *value = FALSE, r = TRUE;
393     }
394     xmlFree(c);
395     return r;
396 }
397
398 gboolean obt_xml_attr_int(xmlNodePtr node, const gchar *name, gint *value)
399 {
400     xmlChar *c = xmlGetProp(node, (const xmlChar*) name);
401     gboolean r = FALSE;
402     if (c) {
403         g_strstrip((char*)c); /* strip leading/trailing whitespace */
404         *value = atoi((gchar*)c);
405         r = TRUE;
406     }
407     xmlFree(c);
408     return r;
409 }
410
411 gboolean obt_xml_attr_string(xmlNodePtr node, const gchar *name,
412                              gchar **value)
413 {
414     xmlChar *c = xmlGetProp(node, (const xmlChar*) name);
415     gboolean r = FALSE;
416     if (c) {
417         g_strstrip((char*)c); /* strip leading/trailing whitespace */
418         *value = g_strdup((gchar*)c);
419         r = TRUE;
420     }
421     xmlFree(c);
422     return r;
423 }
424
425 gboolean obt_xml_attr_contains(xmlNodePtr node, const gchar *name,
426                                const gchar *val)
427 {
428     xmlChar *c = xmlGetProp(node, (const xmlChar*) name);
429     gboolean r = FALSE;
430     if (c) {
431         g_strstrip((char*)c); /* strip leading/trailing whitespace */
432         r = !xmlStrcasecmp(c, (const xmlChar*) val);
433     }
434     xmlFree(c);
435     return r;
436 }