X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=parser%2Fparse.c;h=6daa8517ffd5f70e6893df44d2eabb56206b7cde;hb=0667bbc3e2fbd3fa39206e843560735524840d35;hp=0bd77797bd72a8443f9e004c3b65b811a5973dc1;hpb=16f46c296d1fcd3f27fc62a18e71c55fb3fd3e88;p=chaz%2Fopenbox

diff --git a/parser/parse.c b/parser/parse.c
index 0bd77797..6daa8517 100644
--- a/parser/parse.c
+++ b/parser/parse.c
@@ -1,7 +1,7 @@
 /* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
 
    parse.c for the Openbox window manager
-   Copyright (c) 2003        Ben Jansens
+   Copyright (c) 2003-2007   Dana Jansens
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -19,8 +19,10 @@
 #include "parse.h"
 #include <glib.h>
 #include <string.h>
+#include <errno.h>
 #include <sys/stat.h>
 #include <sys/types.h>
+#include <unistd.h>
 
 static gboolean xdg_start;
 static gchar   *xdg_config_home_path;
@@ -29,9 +31,9 @@ static GSList  *xdg_config_dir_paths;
 static GSList  *xdg_data_dir_paths;
 
 struct Callback {
-    char *tag;
+    gchar *tag;
     ParseCallback func;
-    void *data;
+    gpointer data;
 };
 
 struct _ObParseInst {
@@ -44,7 +46,7 @@ static void destfunc(struct Callback *c)
     g_free(c);
 }
 
-ObParseInst* parse_startup()
+ObParseInst* parse_startup(void)
 {
     ObParseInst *i = g_new(ObParseInst, 1);
     i->callbacks = g_hash_table_new_full(g_str_hash, g_str_equal, NULL,
@@ -60,13 +62,13 @@ void parse_shutdown(ObParseInst *i)
     }
 }
 
-void parse_register(ObParseInst *i, const char *tag,
-                    ParseCallback func, void *data)
+void parse_register(ObParseInst *i, const gchar *tag,
+                    ParseCallback func, gpointer data)
 {
     struct Callback *c;
 
     if ((c = g_hash_table_lookup(i->callbacks, tag))) {
-        g_warning("tag '%s' already registered", tag);
+        g_error("Tag '%s' already registered", tag);
         return;
     }
 
@@ -77,19 +79,67 @@ void parse_register(ObParseInst *i, const char *tag,
     g_hash_table_insert(i->callbacks, c->tag, c);
 }
 
-gboolean parse_load_rc(xmlDocPtr *doc, xmlNodePtr *root)
+gboolean parse_load_rc(const gchar *type, xmlDocPtr *doc, xmlNodePtr *root)
 {
     GSList *it;
-    gchar *path;
     gboolean r = FALSE;
+    gchar *fname;
+
+    if (type == NULL)
+        fname = g_strdup("rc.xml");
+    else
+        fname = g_strdup_printf("rc-%s.xml", type);
 
     for (it = xdg_config_dir_paths; !r && it; it = g_slist_next(it)) {
-        path = g_build_filename(it->data, "openbox", "rc.xml", NULL);
+        gchar *path;
+
+        path = g_build_filename(it->data, "openbox", fname, NULL);
         r = parse_load(path, "openbox_config", doc, root);
         g_free(path);
     }
-    if (!r)
-        g_warning("unable to find a valid config file, using defaults");
+    g_free(fname);
+
+    return r;
+}
+
+gboolean parse_load_theme(const gchar *name, xmlDocPtr *doc, xmlNodePtr *root,
+                          gchar **retpath)
+{
+    GSList *it;
+    gchar *path;
+    gboolean r = FALSE;
+    gchar *eng;
+
+    /* backward compatibility.. */
+    path = g_build_filename(g_get_home_dir(), ".themes", name,
+                            "openbox-3", "themerc.xml", NULL);
+    if (parse_load(path, "openbox_theme", doc, root) &&
+        parse_attr_string("engine", *root, &eng))
+    {
+        if (!strcmp(eng, "box")) {
+            *retpath = g_path_get_dirname(path);
+            r = TRUE;
+        }
+        g_free(eng);
+    }
+    g_free(path);
+
+    if (!r) {
+        for (it = xdg_data_dir_paths; !r && it; it = g_slist_next(it)) {
+            path = g_build_filename(it->data, "themes", name, "openbox-3",
+                                    "themerc.xml", NULL);
+            if (parse_load(path, "openbox_theme", doc, root) &&
+                parse_attr_string("engine", *root, &eng))
+            {
+                if (!strcmp(eng, "box")) {
+                    *retpath = g_path_get_dirname(path);
+                    r = TRUE;
+                }
+                g_free(eng);
+            }
+            g_free(path);
+        }
+    }
     return r;
 }
 
@@ -108,26 +158,32 @@ gboolean parse_load_menu(const gchar *file, xmlDocPtr *doc, xmlNodePtr *root)
             g_free(path);
         }
     }
-    if (!r)
-        g_warning("unable to find a valid menu file '%s'", file);
     return r;
 }
 
-gboolean parse_load(const char *path, const char *rootname,
+gboolean parse_load(const gchar *path, const gchar *rootname,
                     xmlDocPtr *doc, xmlNodePtr *root)
 {
-    if ((*doc = xmlParseFile(path))) {
+    struct stat s;
+
+    if (stat(path, &s) < 0)
+        return FALSE;
+
+    /* XML_PARSE_BLANKS is needed apparently. When it loads a theme file,
+       without this option, the tree is weird and has extra nodes in it. */
+    if ((*doc = xmlReadFile(path, NULL,
+                            XML_PARSE_NOBLANKS | XML_PARSE_RECOVER))) {
         *root = xmlDocGetRootElement(*doc);
         if (!*root) {
             xmlFreeDoc(*doc);
             *doc = NULL;
-            g_warning("%s is an empty document", path);
+            g_message("%s is an empty document", path);
         } else {
-            if (xmlStrcasecmp((*root)->name, (const xmlChar*)rootname)) {
+            if (xmlStrcmp((*root)->name, (const xmlChar*)rootname)) {
                 xmlFreeDoc(*doc);
                 *doc = NULL;
-                g_warning("document %s is of wrong type. root node is "
-                          "not '%s'", path, rootname);
+                g_message("XML Document %s is of wrong type. Root "
+                          "node is not '%s'", path, rootname);
             }
         }
     }
@@ -136,7 +192,7 @@ gboolean parse_load(const char *path, const char *rootname,
     return TRUE;
 }
 
-gboolean parse_load_mem(gpointer data, guint len, const char *rootname,
+gboolean parse_load_mem(gpointer data, guint len, const gchar *rootname,
                         xmlDocPtr *doc, xmlNodePtr *root)
 {
     if ((*doc = xmlParseMemory(data, len))) {
@@ -144,13 +200,13 @@ gboolean parse_load_mem(gpointer data, guint len, const char *rootname,
         if (!*root) {
             xmlFreeDoc(*doc);
             *doc = NULL;
-            g_warning("Given memory is an empty document");
+            g_message("Given memory is an empty document");
         } else {
-            if (xmlStrcasecmp((*root)->name, (const xmlChar*)rootname)) {
+            if (xmlStrcmp((*root)->name, (const xmlChar*)rootname)) {
                 xmlFreeDoc(*doc);
                 *doc = NULL;
-                g_warning("document in given memory is of wrong type. root "
-                          "node is not '%s'", rootname);
+                g_message("XML Document in given memory is of wrong "
+                          "type. Root node is not '%s'\n", rootname);
             }
         }
     }
@@ -161,7 +217,7 @@ gboolean parse_load_mem(gpointer data, guint len, const char *rootname,
 
 void parse_close(xmlDocPtr doc)
 {
-    xmlFree(doc);
+    xmlFreeDoc(doc);
 }
 
 void parse_tree(ObParseInst *i, xmlDocPtr doc, xmlNodePtr node)
@@ -176,18 +232,18 @@ void parse_tree(ObParseInst *i, xmlDocPtr doc, xmlNodePtr node)
     }
 }
 
-char *parse_string(xmlDocPtr doc, xmlNodePtr node)
+gchar *parse_string(xmlDocPtr doc, xmlNodePtr node)
 {
     xmlChar *c = xmlNodeListGetString(doc, node->children, TRUE);
-    char *s = g_strdup(c ? (char*)c : "");
+    gchar *s = g_strdup(c ? (gchar*)c : "");
     xmlFree(c);
     return s;
 }
 
-int parse_int(xmlDocPtr doc, xmlNodePtr node)
+gint parse_int(xmlDocPtr doc, xmlNodePtr node)
 {
     xmlChar *c = xmlNodeListGetString(doc, node->children, TRUE);
-    int i = atoi((char*)c);
+    gint i = c ? atoi((gchar*)c) : 0;
     xmlFree(c);
     return i;
 }
@@ -196,17 +252,17 @@ gboolean parse_bool(xmlDocPtr doc, xmlNodePtr node)
 {
     xmlChar *c = xmlNodeListGetString(doc, node->children, TRUE);
     gboolean b = FALSE;
-    if (!xmlStrcasecmp(c, (const xmlChar*) "true"))
+    if (c && !xmlStrcasecmp(c, (const xmlChar*) "true"))
         b = TRUE;
-    else if (!xmlStrcasecmp(c, (const xmlChar*) "yes"))
+    else if (c && !xmlStrcasecmp(c, (const xmlChar*) "yes"))
         b = TRUE;
-    else if (!xmlStrcasecmp(c, (const xmlChar*) "on"))
+    else if (c && !xmlStrcasecmp(c, (const xmlChar*) "on"))
         b = TRUE;
     xmlFree(c);
     return b;
 }
 
-gboolean parse_contains(const char *val, xmlDocPtr doc, xmlNodePtr node)
+gboolean parse_contains(const gchar *val, xmlDocPtr doc, xmlNodePtr node)
 {
     xmlChar *c = xmlNodeListGetString(doc, node->children, TRUE);
     gboolean r;
@@ -215,128 +271,172 @@ gboolean parse_contains(const char *val, xmlDocPtr doc, xmlNodePtr node)
     return r;
 }
 
-xmlNodePtr parse_find_node(const char *tag, xmlNodePtr node)
+xmlNodePtr parse_find_node(const gchar *tag, xmlNodePtr node)
 {
     while (node) {
-        if (!xmlStrcasecmp(node->name, (const xmlChar*) tag))
+        if (!xmlStrcmp(node->name, (const xmlChar*) tag))
             return node;
         node = node->next;
     }
     return NULL;
 }
 
-gboolean parse_attr_int(const char *name, xmlNodePtr node, int *value)
+gboolean parse_attr_bool(const gchar *name, xmlNodePtr node, gboolean *value)
+{
+    xmlChar *c = xmlGetProp(node, (const xmlChar*) name);
+    gboolean r = FALSE;
+    if (c) {
+        if (!xmlStrcasecmp(c, (const xmlChar*) "true"))
+            *value = TRUE, r = TRUE;
+        else if (!xmlStrcasecmp(c, (const xmlChar*) "yes"))
+            *value = TRUE, r = TRUE;
+        else if (!xmlStrcasecmp(c, (const xmlChar*) "on"))
+            *value = TRUE, r = TRUE;
+        else if (!xmlStrcasecmp(c, (const xmlChar*) "false"))
+            *value = FALSE, r = TRUE;
+        else if (!xmlStrcasecmp(c, (const xmlChar*) "no"))
+            *value = FALSE, r = TRUE;
+        else if (!xmlStrcasecmp(c, (const xmlChar*) "off"))
+            *value = FALSE, r = TRUE;
+    }
+    xmlFree(c);
+    return r;
+}
+
+gboolean parse_attr_int(const gchar *name, xmlNodePtr node, gint *value)
 {
     xmlChar *c = xmlGetProp(node, (const xmlChar*) name);
     gboolean r = FALSE;
     if (c) {
-        *value = atoi((char*)c);
+        *value = atoi((gchar*)c);
         r = TRUE;
     }
     xmlFree(c);
     return r;
 }
 
-gboolean parse_attr_string(const char *name, xmlNodePtr node, char **value)
+gboolean parse_attr_string(const gchar *name, xmlNodePtr node, gchar **value)
 {
     xmlChar *c = xmlGetProp(node, (const xmlChar*) name);
     gboolean r = FALSE;
     if (c) {
-        *value = g_strdup((char*)c);
+        *value = g_strdup((gchar*)c);
         r = TRUE;
     }
     xmlFree(c);
     return r;
 }
 
-gboolean parse_attr_contains(const char *val, xmlNodePtr node,
-                             const char *name)
+gboolean parse_attr_contains(const gchar *val, xmlNodePtr node,
+                             const gchar *name)
 {
     xmlChar *c = xmlGetProp(node, (const xmlChar*) name);
-    gboolean r;
-    r = !xmlStrcasecmp(c, (const xmlChar*) val);
+    gboolean r = FALSE;
+    if (c)
+        r = !xmlStrcasecmp(c, (const xmlChar*) val);
     xmlFree(c);
     return r;
 }
 
+static gint slist_path_cmp(const gchar *a, const gchar *b)
+{
+    return strcmp(a, b);
+}
+
+typedef GSList* (*GSListFunc) (gpointer list, gconstpointer data);
+
+static GSList* slist_path_add(GSList *list, gpointer data, GSListFunc func)
+{
+    g_assert(func);
+
+    if (!data)
+        return list;
+
+    if (!g_slist_find_custom(list, data, (GCompareFunc) slist_path_cmp))
+        list = func(list, data);
+    else
+        g_free(data);
+
+    return list;
+}
+
 static GSList* split_paths(const gchar *paths)
 {
     GSList *list = NULL;
-    gchar *c, *e, *s;
-
-    c = g_strdup(paths);
-    s = c;
-    e = c - 1;
-    g_message("paths %s", paths);
-    while ((e = strchr(e + 1, ':'))) {
-        *e = '\0';
-        g_message("s %s", s);
-        if (s[0] != '\0')
-            list = g_slist_append(list, g_strdup(s));
-        s = e + 1;
-    }
-    if (s[0] != '\0')
-        list = g_slist_append(list, g_strdup(s));
-    g_free(c);
+    gchar **spl, **it;
+
+    if (!paths)
+        return NULL;
+    spl = g_strsplit(paths, ":", -1);
+    for (it = spl; *it; ++it)
+        list = slist_path_add(list, *it, (GSListFunc) g_slist_append);
+    g_free(spl);
     return list;
 }
 
-void parse_paths_startup()
+void parse_paths_startup(void)
 {
-    gchar *path;
+    const gchar *path;
 
     if (xdg_start)
         return;
     xdg_start = TRUE;
 
-    path = getenv("XDG_CONFIG_HOME");
+    path = g_getenv("XDG_CONFIG_HOME");
     if (path && path[0] != '\0') /* not unset or empty */
         xdg_config_home_path = g_build_filename(path, NULL);
     else
         xdg_config_home_path = g_build_filename(g_get_home_dir(), ".config",
                                                 NULL);
 
-    path = getenv("XDG_DATA_HOME");
+    path = g_getenv("XDG_DATA_HOME");
     if (path && path[0] != '\0') /* not unset or empty */
         xdg_data_home_path = g_build_filename(path, NULL);
     else
         xdg_data_home_path = g_build_filename(g_get_home_dir(), ".local",
                                               "share", NULL);
 
-    path = getenv("XDG_CONFIG_DIRS");
+    path = g_getenv("XDG_CONFIG_DIRS");
     if (path && path[0] != '\0') /* not unset or empty */
         xdg_config_dir_paths = split_paths(path);
     else {
-        xdg_config_dir_paths = g_slist_append(xdg_config_dir_paths,
+        xdg_config_dir_paths = slist_path_add(xdg_config_dir_paths,
+                                              g_strdup(CONFIGDIR),
+                                              (GSListFunc) g_slist_append);
+        xdg_config_dir_paths = slist_path_add(xdg_config_dir_paths,
                                               g_build_filename
                                               (G_DIR_SEPARATOR_S,
-                                               "etc", "xdg", NULL));
-        xdg_config_dir_paths = g_slist_append(xdg_config_dir_paths,
-                                              g_strdup(CONFIGDIR));
+                                               "etc", "xdg", NULL),
+                                              (GSListFunc) g_slist_append);
     }
-    xdg_config_dir_paths = g_slist_prepend(xdg_config_dir_paths,
-                                           xdg_config_home_path);
-    
-    path = getenv("XDG_DATA_DIRS");
+    xdg_config_dir_paths = slist_path_add(xdg_config_dir_paths,
+                                          g_strdup(xdg_config_home_path),
+                                          (GSListFunc) g_slist_prepend);
+
+    path = g_getenv("XDG_DATA_DIRS");
     if (path && path[0] != '\0') /* not unset or empty */
         xdg_data_dir_paths = split_paths(path);
     else {
-        xdg_data_dir_paths = g_slist_append(xdg_data_dir_paths,
+        xdg_data_dir_paths = slist_path_add(xdg_data_dir_paths,
+                                            g_strdup(DATADIR),
+                                            (GSListFunc) g_slist_append);
+        xdg_data_dir_paths = slist_path_add(xdg_data_dir_paths,
                                             g_build_filename
                                             (G_DIR_SEPARATOR_S,
-                                             "usr", "local", "share", NULL));
-        xdg_data_dir_paths = g_slist_append(xdg_data_dir_paths,
+                                             "usr", "local", "share", NULL),
+                                            (GSListFunc) g_slist_append);
+        xdg_data_dir_paths = slist_path_add(xdg_data_dir_paths,
                                             g_build_filename
                                             (G_DIR_SEPARATOR_S,
-                                             "usr", "share", NULL));
-        xdg_config_dir_paths = g_slist_append(xdg_config_dir_paths,
-                                              g_strdup(DATADIR));
+                                             "usr", "share", NULL),
+                                            (GSListFunc) g_slist_append);
     }
-    xdg_data_dir_paths = g_slist_prepend(xdg_data_dir_paths,
-                                         xdg_data_home_path);
+    xdg_data_dir_paths = slist_path_add(xdg_data_dir_paths,
+                                        g_strdup(xdg_data_home_path),
+                                        (GSListFunc) g_slist_prepend);
 }
 
-void parse_paths_shutdown()
+void parse_paths_shutdown(void)
 {
     GSList *it;
 
@@ -348,6 +448,14 @@ void parse_paths_shutdown()
         g_free(it->data);
     g_slist_free(xdg_config_dir_paths);
     xdg_config_dir_paths = NULL;
+    for (it = xdg_data_dir_paths; it; it = g_slist_next(it))
+        g_free(it->data);
+    g_slist_free(xdg_data_dir_paths);
+    xdg_data_dir_paths = NULL;
+    g_free(xdg_config_home_path);
+    xdg_config_home_path = NULL;
+    g_free(xdg_data_home_path);
+    xdg_data_home_path = NULL;
 }
 
 gchar *parse_expand_tilde(const gchar *f)
@@ -363,39 +471,63 @@ gchar *parse_expand_tilde(const gchar *f)
     return ret;
 }
 
-void parse_mkdir_path(const gchar *path, gint mode)
+gboolean parse_mkdir(const gchar *path, gint mode)
+{
+    gboolean ret = TRUE;
+
+    g_return_val_if_fail(path != NULL, FALSE);
+    g_return_val_if_fail(path[0] != '\0', FALSE);
+
+    if (!g_file_test(path, G_FILE_TEST_IS_DIR))
+        if (mkdir(path, mode) == -1)
+            ret = FALSE;
+
+    return ret;
+}
+
+gboolean parse_mkdir_path(const gchar *path, gint mode)
 {
-    gchar *c, *e;
+    gboolean ret = TRUE;
+
+    g_return_val_if_fail(path != NULL, FALSE);
+    g_return_val_if_fail(path[0] == '/', FALSE);
+
+    if (!g_file_test(path, G_FILE_TEST_IS_DIR)) {
+        gchar *c, *e;
 
-    g_assert(path[0] == '/');
+        c = g_strdup(path);
+        e = c;
+        while ((e = strchr(e + 1, '/'))) {
+            *e = '\0';
+            if (!(ret = parse_mkdir(c, mode)))
+                goto parse_mkdir_path_end;
+            *e = '/';
+        }
+        ret = parse_mkdir(c, mode);
 
-    c = g_strdup(path);
-    e = c;
-    while ((e = strchr(e + 1, '/'))) {
-        *e = '\0';
-        mkdir(c, mode);
-        *e = '/';
+    parse_mkdir_path_end:
+        g_free(c);
     }
-    mkdir(c, mode);
-    g_free(c);
+
+    return ret;
 }
 
-const gchar* parse_xdg_config_home_path()
+const gchar* parse_xdg_config_home_path(void)
 {
     return xdg_config_home_path;
 }
 
-const gchar* parse_xdg_data_home_path()
+const gchar* parse_xdg_data_home_path(void)
 {
     return xdg_data_home_path;
 }
 
-GSList* parse_xdg_config_dir_paths()
+GSList* parse_xdg_config_dir_paths(void)
 {
     return xdg_config_dir_paths;
 }
 
-GSList* parse_xdg_data_dir_paths()
+GSList* parse_xdg_data_dir_paths(void)
 {
     return xdg_data_dir_paths;
 }