all repos — openbox @ d6652d0a90bd6c93084b0b9e6cf36123e0ec15d1

openbox fork - make it a bit more like ryudo

tools/obconf/plugins.c (raw)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
 
#include "obconf.h"
#include "plugins/obconf_interface.h"

#include <sys/types.h>
#include <dirent.h>
#include <string.h>
#include <gmodule.h>

typedef struct ConfigPlugin {
    GModule *module;
    char *fname;
    char *name;
    char *plugin_name;

    PluginStartupFunc start;
    PluginShutdownFunc stop;
    PluginInterfaceVersionFunc interface;
    PluginNameFunc getname;
    PluginPluginNameFunc getpname;
    PluginIconFunc icon;
    PluginToplevelWidgetFunc toplevel;
    PluginEditedFunc edited;
    PluginLoadFunc load;
    PluginSaveFunc save;
} ConfigPlugin;

GSList *plugins_list = NULL;

static gpointer load_sym(GModule *module, char *name, char *symbol,
			 gboolean allow_fail)
{
    gpointer var;
    if (!g_module_symbol(module, symbol, &var)) {
        if (!allow_fail)
	    g_warning("Failed to load symbol '%s' from plugin '%s'",
		      symbol, name);
        var = NULL;
    }
    return var;
}

static void add_plugin(ConfigPlugin *p)
{
    GtkTreeIter it;

    gtk_list_store_append(obconf_sections_store, &it);
    gtk_list_store_set(obconf_sections_store, &it, 0, p->name, -1);
    gtk_notebook_append_page(obconf_options, p->toplevel(), NULL);
}

void load_dir(char *path)
{
    char *fpath;
    DIR *dir;
    struct dirent *dirp;
    ConfigPlugin *p;
    GModule *mod;
    GSList *it;
    char *suffix;

    suffix = g_strconcat("-config.", G_MODULE_SUFFIX, NULL);

    if (!(dir = opendir(path)))
        return;
    while ((dirp = readdir(dir))) {
        if (g_strrstr(dirp->d_name, suffix)) {
            /* look for duplicates */
            for (it = plugins_list; it; it = it->next)
                if (!strcmp(((ConfigPlugin*)it->data)->fname, dirp->d_name))
                    break;
            if (!it) {
                fpath = g_build_filename(path, dirp->d_name, NULL);
        
                if ((mod = g_module_open(fpath, 0))) {
                    p = g_new(ConfigPlugin, 1);
                    p->module = mod;
                    p->fname = g_strdup(dirp->d_name);

                    p->interface = (PluginInterfaceVersionFunc)
                        load_sym(p->module, p->fname,
                                 "plugin_interface_version",
                                 FALSE);
                    p->start = (PluginStartupFunc)
                        load_sym(p->module, p->fname, "plugin_startup", FALSE);
                    p->stop = (PluginShutdownFunc)
                        load_sym(p->module, p->fname, "plugin_shutdown",FALSE);
                    p->getname = (PluginNameFunc)
                        load_sym(p->module, p->fname, "plugin_name", FALSE);
                    p->getpname = (PluginNameFunc)
                        load_sym(p->module, p->fname, "plugin_plugin_name",
                                 FALSE);
                    p->icon = (PluginIconFunc)
                        load_sym(p->module, p->fname, "plugin_icon", FALSE);
                    p->toplevel = (PluginToplevelWidgetFunc)
                        load_sym(p->module, p->fname, "plugin_toplevel_widget",
                                 FALSE);
                    p->edited = (PluginEditedFunc)
                        load_sym(p->module, p->fname, "plugin_edited", FALSE);
                    p->load = (PluginLoadFunc)
                        load_sym(p->module, p->fname, "plugin_load", FALSE);
                    p->save = (PluginSaveFunc)
                        load_sym(p->module, p->fname, "plugin_save", FALSE);

                    if (!(p->start &&
                          p->stop &&
                          p->interface &&
                          p->name &&
                          p->icon &&
                          p->toplevel &&
                          p->edited &&
                          p->load &&
                          p->save)) {
                        g_module_close(p->module);
                        g_free(p->fname);
                        g_free(p);
                    } else {
                        p->start();
                        p->name = p->getname();
                        p->plugin_name = p->getpname();
                        plugins_list = g_slist_append(plugins_list, p);

                        add_plugin(p); /* add to the gui */
                    }
                }
                g_free(fpath);
            }
        }              
    }

    g_free(suffix);
}

void plugins_load()
{
    char *path;

    path = g_build_filename(g_get_home_dir(), ".openbox", "plugins", NULL);
    load_dir(path);
    g_free(path);

    load_dir(PLUGINDIR);
}

gboolean plugins_edited(ConfigPlugin *p)
{
    return p->edited();
}

void plugins_load_settings(ConfigPlugin *p, xmlDocPtr doc, xmlNodePtr root)
{
    p->load(doc, root);
}

void plugins_save_settings(ConfigPlugin *p, xmlDocPtr doc, xmlNodePtr root)
{
    p->save(doc, root);
}