lighten the default shadow, it's alittle harsh right now
[mikachu/openbox.git] / parser / parse.c
1 /* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
2
3    parse.c for the Openbox window manager
4    Copyright (c) 2003        Ben 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 "parse.h"
20 #include <glib.h>
21 #include <string.h>
22 #include <errno.h>
23 #include <sys/stat.h>
24 #include <sys/types.h>
25
26 static gboolean xdg_start;
27 static gchar   *xdg_config_home_path;
28 static gchar   *xdg_data_home_path;
29 static GSList  *xdg_config_dir_paths;
30 static GSList  *xdg_data_dir_paths;
31
32 struct Callback {
33     gchar *tag;
34     ParseCallback func;
35     gpointer data;
36 };
37
38 struct _ObParseInst {
39     GHashTable *callbacks;
40 };
41
42 static void destfunc(struct Callback *c)
43 {
44     g_free(c->tag);
45     g_free(c);
46 }
47
48 ObParseInst* parse_startup()
49 {
50     ObParseInst *i = g_new(ObParseInst, 1);
51     i->callbacks = g_hash_table_new_full(g_str_hash, g_str_equal, NULL,
52                                          (GDestroyNotify)destfunc);
53     return i;
54 }
55
56 void parse_shutdown(ObParseInst *i)
57 {
58     if (i) {
59         g_hash_table_destroy(i->callbacks);
60         g_free(i);
61     }
62 }
63
64 void parse_register(ObParseInst *i, const gchar *tag,
65                     ParseCallback func, gpointer data)
66 {
67     struct Callback *c;
68
69     if ((c = g_hash_table_lookup(i->callbacks, tag))) {
70         g_warning("tag '%s' already registered", tag);
71         return;
72     }
73
74     c = g_new(struct Callback, 1);
75     c->tag = g_strdup(tag);
76     c->func = func;
77     c->data = data;
78     g_hash_table_insert(i->callbacks, c->tag, c);
79 }
80
81 gboolean parse_load_rc(xmlDocPtr *doc, xmlNodePtr *root)
82 {
83     GSList *it;
84     gchar *path;
85     gboolean r = FALSE;
86
87     for (it = xdg_config_dir_paths; !r && it; it = g_slist_next(it)) {
88         path = g_build_filename(it->data, "openbox", "rc.xml", NULL);
89         r = parse_load(path, "openbox_config", doc, root);
90         g_free(path);
91     }
92     if (!r)
93         g_warning("unable to find a valid config file, using defaults");
94     return r;
95 }
96
97 gboolean parse_load_menu(const gchar *file, xmlDocPtr *doc, xmlNodePtr *root)
98 {
99     GSList *it;
100     gchar *path;
101     gboolean r = FALSE;
102
103     if (file[0] == '/') {
104         r = parse_load(file, "openbox_menu", doc, root);
105     } else {
106         for (it = xdg_config_dir_paths; !r && it; it = g_slist_next(it)) {
107             path = g_build_filename(it->data, "openbox", file, NULL);
108             r = parse_load(path, "openbox_menu", doc, root);
109             g_free(path);
110         }
111     }
112     if (!r)
113         g_warning("unable to find a valid menu file '%s'", file);
114     return r;
115 }
116
117 gboolean parse_load(const gchar *path, const gchar *rootname,
118                     xmlDocPtr *doc, xmlNodePtr *root)
119 {
120     if ((*doc = xmlParseFile(path))) {
121         *root = xmlDocGetRootElement(*doc);
122         if (!*root) {
123             xmlFreeDoc(*doc);
124             *doc = NULL;
125             g_warning("%s is an empty document", path);
126         } else {
127             if (xmlStrcasecmp((*root)->name, (const xmlChar*)rootname)) {
128                 xmlFreeDoc(*doc);
129                 *doc = NULL;
130                 g_warning("document %s is of wrong type. root node is "
131                           "not '%s'", path, rootname);
132             }
133         }
134     }
135     if (!*doc)
136         return FALSE;
137     return TRUE;
138 }
139
140 gboolean parse_load_mem(gpointer data, guint len, const gchar *rootname,
141                         xmlDocPtr *doc, xmlNodePtr *root)
142 {
143     if ((*doc = xmlParseMemory(data, len))) {
144         *root = xmlDocGetRootElement(*doc);
145         if (!*root) {
146             xmlFreeDoc(*doc);
147             *doc = NULL;
148             g_warning("Given memory is an empty document");
149         } else {
150             if (xmlStrcasecmp((*root)->name, (const xmlChar*)rootname)) {
151                 xmlFreeDoc(*doc);
152                 *doc = NULL;
153                 g_warning("document in given memory is of wrong type. root "
154                           "node is not '%s'", rootname);
155             }
156         }
157     }
158     if (!*doc)
159         return FALSE;
160     return TRUE;
161 }
162
163 void parse_close(xmlDocPtr doc)
164 {
165     xmlFreeDoc(doc);
166 }
167
168 void parse_tree(ObParseInst *i, xmlDocPtr doc, xmlNodePtr node)
169 {
170     while (node) {
171         struct Callback *c = g_hash_table_lookup(i->callbacks, node->name);
172
173         if (c)
174             c->func(i, doc, node, c->data);
175
176         node = node->next;
177     }
178 }
179
180 gchar *parse_string(xmlDocPtr doc, xmlNodePtr node)
181 {
182     xmlChar *c = xmlNodeListGetString(doc, node->children, TRUE);
183     gchar *s = g_strdup(c ? (gchar*)c : "");
184     xmlFree(c);
185     return s;
186 }
187
188 gint parse_int(xmlDocPtr doc, xmlNodePtr node)
189 {
190     xmlChar *c = xmlNodeListGetString(doc, node->children, TRUE);
191     gint i = atoi((gchar*)c);
192     xmlFree(c);
193     return i;
194 }
195
196 gboolean parse_bool(xmlDocPtr doc, xmlNodePtr node)
197 {
198     xmlChar *c = xmlNodeListGetString(doc, node->children, TRUE);
199     gboolean b = FALSE;
200     if (!xmlStrcasecmp(c, (const xmlChar*) "true"))
201         b = TRUE;
202     else if (!xmlStrcasecmp(c, (const xmlChar*) "yes"))
203         b = TRUE;
204     else if (!xmlStrcasecmp(c, (const xmlChar*) "on"))
205         b = TRUE;
206     xmlFree(c);
207     return b;
208 }
209
210 gboolean parse_contains(const gchar *val, xmlDocPtr doc, xmlNodePtr node)
211 {
212     xmlChar *c = xmlNodeListGetString(doc, node->children, TRUE);
213     gboolean r;
214     r = !xmlStrcasecmp(c, (const xmlChar*) val);
215     xmlFree(c);
216     return r;
217 }
218
219 xmlNodePtr parse_find_node(const gchar *tag, xmlNodePtr node)
220 {
221     while (node) {
222         if (!xmlStrcasecmp(node->name, (const xmlChar*) tag))
223             return node;
224         node = node->next;
225     }
226     return NULL;
227 }
228
229 gboolean parse_attr_bool(const gchar *name, xmlNodePtr node, gboolean *value)
230 {
231     xmlChar *c = xmlGetProp(node, (const xmlChar*) name);
232     gboolean r = FALSE;
233     if (c) {
234         if (!xmlStrcasecmp(c, (const xmlChar*) "true"))
235             *value = TRUE, r = TRUE;
236         else if (!xmlStrcasecmp(c, (const xmlChar*) "yes"))
237             *value = TRUE, r = TRUE;
238         else if (!xmlStrcasecmp(c, (const xmlChar*) "on"))
239             *value = TRUE, r = TRUE;
240         else if (!xmlStrcasecmp(c, (const xmlChar*) "false"))
241             *value = FALSE, r = TRUE;
242         else if (!xmlStrcasecmp(c, (const xmlChar*) "no"))
243             *value = FALSE, r = TRUE;
244         else if (!xmlStrcasecmp(c, (const xmlChar*) "off"))
245             *value = FALSE, r = TRUE;
246     }
247     xmlFree(c);
248     return r;
249 }
250
251 gboolean parse_attr_int(const gchar *name, xmlNodePtr node, gint *value)
252 {
253     xmlChar *c = xmlGetProp(node, (const xmlChar*) name);
254     gboolean r = FALSE;
255     if (c) {
256         *value = atoi((gchar*)c);
257         r = TRUE;
258     }
259     xmlFree(c);
260     return r;
261 }
262
263 gboolean parse_attr_string(const gchar *name, xmlNodePtr node, gchar **value)
264 {
265     xmlChar *c = xmlGetProp(node, (const xmlChar*) name);
266     gboolean r = FALSE;
267     if (c) {
268         *value = g_strdup((gchar*)c);
269         r = TRUE;
270     }
271     xmlFree(c);
272     return r;
273 }
274
275 gboolean parse_attr_contains(const gchar *val, xmlNodePtr node,
276                              const gchar *name)
277 {
278     xmlChar *c = xmlGetProp(node, (const xmlChar*) name);
279     gboolean r = FALSE;
280     if (c)
281         r = !xmlStrcasecmp(c, (const xmlChar*) val);
282     xmlFree(c);
283     return r;
284 }
285
286 static gint slist_path_cmp(const gchar *a, const gchar *b)
287 {
288     return strcmp(a, b);
289 }
290
291 typedef GSList* (*GSListFunc) (gpointer list, gconstpointer data);
292
293 static GSList* slist_path_add(GSList *list, gpointer data, GSListFunc func)
294 {
295     g_assert(func);
296
297     if (!data)
298         return list;
299
300     if (!g_slist_find_custom(list, data, (GCompareFunc) slist_path_cmp))
301         list = func(list, data);
302
303     return list;
304 }
305
306 static GSList* split_paths(const gchar *paths)
307 {
308     GSList *list = NULL;
309     gchar **spl, **it;
310
311     if (!paths)
312         return NULL;
313     spl = g_strsplit(paths, ":", -1);
314     for (it = spl; *it; ++it)
315         list = slist_path_add(list, *it, (GSListFunc) g_slist_append);
316     g_free(spl);
317     return list;
318 }
319
320 void parse_paths_startup()
321 {
322     const gchar *path;
323
324     if (xdg_start)
325         return;
326     xdg_start = TRUE;
327
328     path = g_getenv("XDG_CONFIG_HOME");
329     if (path && path[0] != '\0') /* not unset or empty */
330         xdg_config_home_path = g_build_filename(path, NULL);
331     else
332         xdg_config_home_path = g_build_filename(g_get_home_dir(), ".config",
333                                                 NULL);
334
335     path = g_getenv("XDG_DATA_HOME");
336     if (path && path[0] != '\0') /* not unset or empty */
337         xdg_data_home_path = g_build_filename(path, NULL);
338     else
339         xdg_data_home_path = g_build_filename(g_get_home_dir(), ".local",
340                                               "share", NULL);
341
342     path = g_getenv("XDG_CONFIG_DIRS");
343     if (path && path[0] != '\0') /* not unset or empty */
344         xdg_config_dir_paths = split_paths(path);
345     else {
346         xdg_config_dir_paths = slist_path_add(xdg_config_dir_paths,
347                                               g_build_filename
348                                               (G_DIR_SEPARATOR_S,
349                                                "etc", "xdg", NULL),
350                                               (GSListFunc) g_slist_append);
351         xdg_config_dir_paths = slist_path_add(xdg_config_dir_paths,
352                                               g_strdup(CONFIGDIR),
353                                               (GSListFunc) g_slist_append);
354     }
355     xdg_config_dir_paths = slist_path_add(xdg_config_dir_paths,
356                                           xdg_config_home_path,
357                                           (GSListFunc) g_slist_prepend);
358     
359     path = g_getenv("XDG_DATA_DIRS");
360     if (path && path[0] != '\0') /* not unset or empty */
361         xdg_data_dir_paths = split_paths(path);
362     else {
363         xdg_data_dir_paths = slist_path_add(xdg_data_dir_paths,
364                                             g_build_filename
365                                             (G_DIR_SEPARATOR_S,
366                                              "usr", "local", "share", NULL),
367                                             (GSListFunc) g_slist_append);
368         xdg_data_dir_paths = slist_path_add(xdg_data_dir_paths,
369                                             g_build_filename
370                                             (G_DIR_SEPARATOR_S,
371                                              "usr", "share", NULL),
372                                             (GSListFunc) g_slist_append);
373         xdg_data_dir_paths = slist_path_add(xdg_data_dir_paths,
374                                             g_strdup(DATADIR),
375                                             (GSListFunc) g_slist_append);
376     }
377     xdg_data_dir_paths = slist_path_add(xdg_data_dir_paths,
378                                         xdg_data_home_path,
379                                         (GSListFunc) g_slist_prepend);
380 }
381
382 void parse_paths_shutdown()
383 {
384     GSList *it;
385
386     if (!xdg_start)
387         return;
388     xdg_start = FALSE;
389
390     for (it = xdg_config_dir_paths; it; it = g_slist_next(it))
391         g_free(it->data);
392     g_slist_free(xdg_config_dir_paths);
393     xdg_config_dir_paths = NULL;
394     for (it = xdg_data_dir_paths; it; it = g_slist_next(it))
395         g_free(it->data);
396     g_slist_free(xdg_data_dir_paths);
397     xdg_data_dir_paths = NULL;
398 }
399
400 gchar *parse_expand_tilde(const gchar *f)
401 {
402     gchar **spl;
403     gchar *ret;
404
405     if (!f)
406         return NULL;
407     spl = g_strsplit(f, "~", 0);
408     ret = g_strjoinv(g_get_home_dir(), spl);
409     g_strfreev(spl);
410     return ret;
411 }
412
413 gboolean parse_mkdir(const gchar *path, gint mode)
414 {
415     gboolean ret = TRUE;
416
417     g_return_val_if_fail(path != NULL, FALSE);
418     g_return_val_if_fail(path[0] != '\0', FALSE);
419
420     if (!g_file_test(path, G_FILE_TEST_IS_DIR))
421         if (mkdir(path, mode) == -1)
422             ret = FALSE;
423
424     return ret;
425 }
426
427 gboolean parse_mkdir_path(const gchar *path, gint mode)
428 {
429     gboolean ret = TRUE;
430
431     g_return_val_if_fail(path != NULL, FALSE);
432     g_return_val_if_fail(path[0] == '/', FALSE);
433
434     if (!g_file_test(path, G_FILE_TEST_IS_DIR)) {
435         gchar *c, *e;
436
437         c = g_strdup(path);
438         e = c;
439         while ((e = strchr(e + 1, '/'))) {
440             *e = '\0';
441             if (!(ret = parse_mkdir(c, mode)))
442                 goto parse_mkdir_path_end;
443             *e = '/';
444         }
445         ret = parse_mkdir(c, mode);
446
447     parse_mkdir_path_end:
448         g_free(c);
449     }
450
451     return ret;
452 }
453
454 const gchar* parse_xdg_config_home_path()
455 {
456     return xdg_config_home_path;
457 }
458
459 const gchar* parse_xdg_data_home_path()
460 {
461     return xdg_data_home_path;
462 }
463
464 GSList* parse_xdg_config_dir_paths()
465 {
466     return xdg_config_dir_paths;
467 }
468
469 GSList* parse_xdg_data_dir_paths()
470 {
471     return xdg_data_dir_paths;
472 }