libpurple/theme-manager.c

   1 /*
   2  * Themes for libpurple
   3  *
   4  * Pidgin is the legal property of its developers, whose names are too numerous
   5  * to list here.  Please refer to the COPYRIGHT file distributed with this
   6  * source distribution.
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  21  */
  22
  23 #include "internal.h"
  24 #include "theme-manager.h"
  25 #include "util.h"
  26
  27 /******************************************************************************
  28  * Globals
  29  *****************************************************************************/
  30
  31 static GHashTable *theme_table = NULL;
  32
  33 /*****************************************************************************
  34  * GObject Stuff
  35  ****************************************************************************/
  36
  37 GType
  38 purple_theme_manager_get_type(void)
  39 {
  40         static GType type = 0;
  41         if (type == 0) {
  42                 static const GTypeInfo info = {
  43                         sizeof(PurpleThemeManagerClass),
  44                         NULL, /* base_init */
  45                         NULL, /* base_finalize */
  46                         NULL, /* class_init */
  47                         NULL, /* class_finalize */
  48                         NULL, /* class_data */
  49                         sizeof(PurpleThemeManager),
  50                         0, /* n_preallocs */
  51                         NULL, /* instance_init */
  52                         NULL, /* Value Table */
  53                 };
  54                 type = g_type_register_static(G_TYPE_OBJECT,
  55                                 "PurpleThemeManager", &info, 0);
  56         }
  57         return type;
  58 }
  59
  60 /******************************************************************************
  61  * Helpers
  62  *****************************************************************************/
  63
  64 /* makes a key of <type> + '/' + <name> */
  65 static gchar *
  66 purple_theme_manager_make_key(const gchar *name, const gchar *type)
  67 {
  68         g_return_val_if_fail(name && *name, NULL);
  69         g_return_val_if_fail(type && *type, NULL);
  70         return g_strconcat(type, "/", name, NULL);
  71 }
  72
  73 /* returns TRUE if theme is of type "user_data" */
  74 static gboolean
  75 purple_theme_manager_is_theme_type(gchar *key,
  76                 gpointer value,
  77                 gchar *user_data)
  78 {
  79         return g_str_has_prefix(key, g_strconcat(user_data, "/", NULL));
  80 }
  81
  82 static gboolean
  83 check_if_theme_or_loader(gchar *key, gpointer value, GSList **loaders)
  84 {
  85         if (PURPLE_IS_THEME(value))
  86                 return TRUE;
  87         else if (PURPLE_IS_THEME_LOADER(value))
  88                 *loaders = g_slist_prepend(*loaders, value);
  89
  90         return FALSE;
  91 }
  92
  93 static void
  94 purple_theme_manager_function_wrapper(gchar *key,
  95                 gpointer value,
  96                 PurpleThemeFunc user_data)
  97 {
  98         if (PURPLE_IS_THEME(value))
  99                 (* user_data)(value);
 100 }
 101
 102 static void
 103 purple_theme_manager_build_dir(GSList *loaders, const gchar *root)
 104 {
 105         gchar *theme_dir;
 106         const gchar *name;
 107         GDir *rdir;
 108         GSList *tmp;
 109         PurpleThemeLoader *loader;
 110
 111         rdir = g_dir_open(root, 0, NULL);
 112
 113         if (!rdir)
 114                 return;
 115
 116         while ((name = g_dir_read_name(rdir))) {
 117                 theme_dir = g_build_filename(root, name, NULL);
 118
 119                 for (tmp = loaders; tmp; tmp = g_slist_next(tmp)) {
 120                         loader = PURPLE_THEME_LOADER(tmp->data);
 121
 122                         if (purple_theme_loader_probe(loader, theme_dir)) {
 123                                 PurpleTheme *theme = purple_theme_loader_build(loader, theme_dir);
 124                                 if (PURPLE_IS_THEME(theme))
 125                                         purple_theme_manager_add_theme(theme);
 126                         }
 127                 }
 128
 129                 g_free(theme_dir);
 130         }
 131
 132         g_dir_close(rdir);
 133 }
 134
 135 /*****************************************************************************
 136  * Public API functions
 137  *****************************************************************************/
 138
 139 void
 140 purple_theme_manager_init(void)
 141 {
 142         theme_table = g_hash_table_new_full(g_str_hash,
 143                         g_str_equal, g_free, g_object_unref);
 144 }
 145
 146 void
 147 purple_theme_manager_refresh(void)
 148 {
 149         gchar *path;
 150         const gchar *xdg;
 151         gint i;
 152         GSList *loaders = NULL;
 153
 154         g_hash_table_foreach_remove(theme_table, (GHRFunc)check_if_theme_or_loader,
 155                                     &loaders);
 156
 157         /* Add themes from ~/.purple */
 158         path = g_build_filename(purple_user_dir(), "themes", NULL);
 159         purple_theme_manager_build_dir(loaders, path);
 160         g_free(path);
 161
 162         /* look for XDG_DATA_HOME.  If we don't have it use ~/.local, and add it */
 163         if ((xdg = g_getenv("XDG_DATA_HOME")) != NULL)  /* XXX: change to g_get_user_data_dir() ? */
 164                 path = g_build_filename(xdg, "themes", NULL);
 165         else
 166                 path = g_build_filename(purple_home_dir(), ".local", "themes", NULL);
 167
 168         purple_theme_manager_build_dir(loaders, path);
 169         g_free(path);
 170
 171         /* now dig through XDG_DATA_DIRS and add those too */
 172         xdg = g_getenv("XDG_DATA_DIRS");  /* XXX: change to g_get_system_data_dir() ? */
 173         if (xdg) {
 174                 gchar **xdg_dirs = g_strsplit(xdg, G_SEARCHPATH_SEPARATOR_S, 0);
 175
 176                 for (i = 0; xdg_dirs[i]; i++) {
 177                         path = g_build_filename(xdg_dirs[i], "themes", NULL);
 178                         purple_theme_manager_build_dir(loaders, path);
 179                         g_free(path);
 180                 }
 181
 182                 g_strfreev(xdg_dirs);
 183         }
 184
 185         g_slist_free(loaders);
 186 }
 187
 188 void
 189 purple_theme_manager_uninit(void)
 190 {
 191         g_hash_table_destroy(theme_table);
 192 }
 193
 194 void
 195 purple_theme_manager_register_type(PurpleThemeLoader *loader)
 196 {
 197         gchar *type;
 198
 199         g_return_if_fail(PURPLE_IS_THEME_LOADER(loader));
 200
 201         type = g_strdup(purple_theme_loader_get_type_string(loader));
 202         g_return_if_fail(type);
 203
 204         /* if something is already there do nothing */
 205         if (!g_hash_table_lookup(theme_table, type))
 206                 g_hash_table_insert(theme_table, type, loader);
 207 }
 208
 209 void
 210 purple_theme_manager_unregister_type(PurpleThemeLoader *loader)
 211 {
 212         const gchar *type;
 213
 214         g_return_if_fail(PURPLE_IS_THEME_LOADER(loader));
 215
 216         type = purple_theme_loader_get_type_string(loader);
 217         g_return_if_fail(type);
 218
 219         if (g_hash_table_lookup(theme_table, type) == loader)
 220         {
 221                 g_hash_table_remove(theme_table, type);
 222
 223                 g_hash_table_foreach_remove(theme_table,
 224                                 (GHRFunc)purple_theme_manager_is_theme_type, (gpointer)type);
 225         } /* only free if given registered loader */
 226 }
 227
 228 PurpleTheme *
 229 purple_theme_manager_find_theme(const gchar *name,
 230                 const gchar *type)
 231 {
 232         gchar *key;
 233         PurpleTheme *theme;
 234
 235         key = purple_theme_manager_make_key(name, type);
 236
 237         g_return_val_if_fail(key, NULL);
 238
 239         theme = g_hash_table_lookup(theme_table, key);
 240
 241         g_free(key);
 242
 243         return theme;
 244 }
 245
 246 void
 247 purple_theme_manager_add_theme(PurpleTheme *theme)
 248 {
 249         gchar *key;
 250
 251         g_return_if_fail(PURPLE_IS_THEME(theme));
 252
 253         key = purple_theme_manager_make_key(purple_theme_get_name(theme),
 254                         purple_theme_get_type_string(theme));
 255
 256         g_return_if_fail(key);
 257
 258         /* if something is already there do nothing */
 259         if (g_hash_table_lookup(theme_table, key) == NULL)
 260                 g_hash_table_insert(theme_table, key, theme);
 261 }
 262
 263 void
 264 purple_theme_manager_remove_theme(PurpleTheme *theme)
 265 {
 266         gchar *key;
 267
 268         g_return_if_fail(PURPLE_IS_THEME(theme));
 269
 270         key = purple_theme_manager_make_key(purple_theme_get_name(theme),
 271                         purple_theme_get_type_string(theme));
 272
 273         g_return_if_fail(key);
 274
 275         g_hash_table_remove(theme_table, key);
 276
 277         g_free(key);
 278 }
 279
 280 void
 281 purple_theme_manager_for_each_theme(PurpleThemeFunc func)
 282 {
 283         g_return_if_fail(func);
 284
 285         g_hash_table_foreach(theme_table,
 286                         (GHFunc) purple_theme_manager_function_wrapper, func);
 287 }
 288
 289 PurpleTheme *
 290 purple_theme_manager_load_theme(const gchar *theme_dir, const gchar *type)
 291 {
 292         PurpleThemeLoader *loader;
 293
 294         g_return_val_if_fail(theme_dir != NULL && type != NULL, NULL);
 295
 296         loader = g_hash_table_lookup(theme_table, type);
 297         g_return_val_if_fail(PURPLE_IS_THEME_LOADER(loader), NULL);
 298
 299         return purple_theme_loader_build(loader, theme_dir);
 300 }