gntstyle.c

   1 /**
   2  * GNT - The GLib Ncurses Toolkit
   3  *
   4  * GNT 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 library 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 "gntstyle.h"
  24 #include "gntcolors.h"
  25 #include "gntws.h"
  26
  27 #include <glib.h>
  28 #include <ctype.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31
  32 #define MAX_WORKSPACES 99
  33
  34 #if GLIB_CHECK_VERSION(2,6,0)
  35 static GKeyFile *gkfile;
  36 #endif
  37
  38 static char * str_styles[GNT_STYLES];
  39 static int int_styles[GNT_STYLES];
  40 static int bool_styles[GNT_STYLES];
  41
  42 const char *gnt_style_get(GntStyle style)
  43 {
  44         return str_styles[style];
  45 }
  46
  47 char *gnt_style_get_from_name(const char *group, const char *key)
  48 {
  49 #if GLIB_CHECK_VERSION(2,6,0)
  50         const char *prg = g_get_prgname();
  51         if ((group == NULL || *group == '\0') && prg &&
  52                         g_key_file_has_group(gkfile, prg))
  53                 group = prg;
  54         if (!group)
  55                 group = "general";
  56         return g_key_file_get_value(gkfile, group, key, NULL);
  57 #else
  58         return NULL;
  59 #endif
  60 }
  61
  62 int
  63 gnt_style_get_color(char *group, char *key)
  64 {
  65 #if GLIB_CHECK_VERSION(2,6,0)
  66         int fg = 0, bg = 0;
  67         gsize n;
  68         char **vals;
  69         int ret = 0;
  70         vals = gnt_style_get_string_list(group, key, &n);
  71         if (vals && n == 2) {
  72                 fg = gnt_colors_get_color(vals[0]);
  73                 bg = gnt_colors_get_color(vals[1]);
  74                 ret = gnt_color_add_pair(fg, bg);
  75         }
  76         g_strfreev(vals);
  77         return ret;
  78 #else
  79         return 0;
  80 #endif
  81 }
  82
  83 char **gnt_style_get_string_list(const char *group, const char *key, gsize *length)
  84 {
  85 #if GLIB_CHECK_VERSION(2,6,0)
  86         const char *prg = g_get_prgname();
  87         if ((group == NULL || *group == '\0') && prg &&
  88                         g_key_file_has_group(gkfile, prg))
  89                 group = prg;
  90         if (!group)
  91                 group = "general";
  92         return g_key_file_get_string_list(gkfile, group, key, length, NULL);
  93 #else
  94         return NULL;
  95 #endif
  96 }
  97
  98 gboolean gnt_style_get_bool(GntStyle style, gboolean def)
  99 {
 100         const char * str;
 101
 102         if (bool_styles[style] != -1)
 103                 return bool_styles[style];
 104
 105         str = gnt_style_get(style);
 106
 107         bool_styles[style] = str ? gnt_style_parse_bool(str) : def;
 108         return bool_styles[style];
 109 }
 110
 111 gboolean gnt_style_parse_bool(const char *str)
 112 {
 113         gboolean def = FALSE;
 114         int i;
 115
 116         if (str)
 117         {
 118                 if (g_ascii_strcasecmp(str, "false") == 0)
 119                         def = FALSE;
 120                 else if (g_ascii_strcasecmp(str, "true") == 0)
 121                         def = TRUE;
 122                 else if (sscanf(str, "%d", &i) == 1)
 123                 {
 124                         if (i)
 125                                 def = TRUE;
 126                         else
 127                                 def = FALSE;
 128                 }
 129         }
 130         return def;
 131 }
 132
 133 #if GLIB_CHECK_VERSION(2,6,0)
 134 static void
 135 refine(char *text)
 136 {
 137         char *s = text, *t = text;
 138
 139         while (*s)
 140         {
 141                 if (*s == '^' && *(s + 1) == '[')
 142                 {
 143                         *t = '\033';  /* escape */
 144                         s++;
 145                 }
 146                 else if (*s == '\\')
 147                 {
 148                         if (*(s + 1) == '\0')
 149                                 *t = ' ';
 150                         else
 151                         {
 152                                 s++;
 153                                 if (*s == 'r' || *s == 'n')
 154                                         *t = '\r';
 155                                 else if (*s == 't')
 156                                         *t = '\t';
 157                                 else
 158                                         *t = *s;
 159                         }
 160                 }
 161                 else
 162                         *t = *s;
 163                 t++;
 164                 s++;
 165         }
 166         *t = '\0';
 167 }
 168
 169 static char *
 170 parse_key(const char *key)
 171 {
 172         return (char *)gnt_key_translate(key);
 173 }
 174 #endif
 175
 176 void gnt_style_read_workspaces(GntWM *wm)
 177 {
 178 #if GLIB_CHECK_VERSION(2,6,0)
 179         int i;
 180         gchar *name;
 181         gsize c;
 182
 183         for (i = 1; i < MAX_WORKSPACES; ++i) {
 184                 int j;
 185                 GntWS *ws;
 186                 gchar **titles;
 187                 char group[32];
 188                 g_snprintf(group, sizeof(group), "Workspace-%d", i);
 189                 name = g_key_file_get_value(gkfile, group, "name", NULL);
 190                 if (!name)
 191                         return;
 192
 193                 ws = gnt_ws_new(name);
 194                 gnt_wm_add_workspace(wm, ws);
 195                 g_free(name);
 196
 197                 titles = g_key_file_get_string_list(gkfile, group, "window-names", &c, NULL);
 198                 if (titles) {
 199                         for (j = 0; j < c; ++j)
 200                                 g_hash_table_replace(wm->name_places, g_strdup(titles[j]), ws);
 201                         g_strfreev(titles);
 202                 }
 203
 204                 titles = g_key_file_get_string_list(gkfile, group, "window-titles", &c, NULL);
 205                 if (titles) {
 206                         for (j = 0; j < c; ++j)
 207                                 g_hash_table_replace(wm->title_places, g_strdup(titles[j]), ws);
 208                         g_strfreev(titles);
 209                 }
 210         }
 211 #endif
 212 }
 213 void gnt_style_read_actions(GType type, GntBindableClass *klass)
 214 {
 215 #if GLIB_CHECK_VERSION(2,6,0)
 216         char *name;
 217         GError *error = NULL;
 218
 219         name = g_strdup_printf("%s::binding", g_type_name(type));
 220
 221         if (g_key_file_has_group(gkfile, name))
 222         {
 223                 gsize len = 0;
 224                 char **keys;
 225
 226                 keys = g_key_file_get_keys(gkfile, name, &len, &error);
 227                 if (error)
 228                 {
 229                         g_printerr("GntStyle: %s\n", error->message);
 230                         g_error_free(error);
 231                         g_free(name);
 232                         return;
 233                 }
 234
 235                 while (len--)
 236                 {
 237                         char *key, *action;
 238
 239                         key = g_strdup(keys[len]);
 240                         action = g_key_file_get_string(gkfile, name, keys[len], &error);
 241
 242                         if (error)
 243                         {
 244                                 g_printerr("GntStyle: %s\n", error->message);
 245                                 g_error_free(error);
 246                                 error = NULL;
 247                         }
 248                         else
 249                         {
 250                                 const char *keycode = parse_key(key);
 251                                 if (keycode == NULL) {
 252                                         g_printerr("GntStyle: Invalid key-binding %s\n", key);
 253                                 } else {
 254                                         gnt_bindable_register_binding(klass, action, keycode, NULL);
 255                                 }
 256                         }
 257                         g_free(key);
 258                         g_free(action);
 259                 }
 260                 g_strfreev(keys);
 261         }
 262         g_free(name);
 263 #endif
 264 }
 265
 266 gboolean gnt_style_read_menu_accels(const char *name, GHashTable *table)
 267 {
 268 #if GLIB_CHECK_VERSION(2,6,0)
 269         char *kname;
 270         GError *error = NULL;
 271         gboolean ret = FALSE;
 272
 273         kname = g_strdup_printf("%s::menu", name);
 274
 275         if (g_key_file_has_group(gkfile, kname))
 276         {
 277                 gsize len = 0;
 278                 char **keys;
 279
 280                 keys = g_key_file_get_keys(gkfile, kname, &len, &error);
 281                 if (error)
 282                 {
 283                         g_printerr("GntStyle: %s\n", error->message);
 284                         g_error_free(error);
 285                         g_free(kname);
 286                         return ret;
 287                 }
 288
 289                 while (len--)
 290                 {
 291                         char *key, *menuid;
 292
 293                         key = g_strdup(keys[len]);
 294                         menuid = g_key_file_get_string(gkfile, kname, keys[len], &error);
 295
 296                         if (error)
 297                         {
 298                                 g_printerr("GntStyle: %s\n", error->message);
 299                                 g_error_free(error);
 300                                 error = NULL;
 301                         }
 302                         else
 303                         {
 304                                 const char *keycode = parse_key(key);
 305                                 if (keycode == NULL) {
 306                                         g_printerr("GntStyle: Invalid key-binding %s\n", key);
 307                                 } else {
 308                                         ret = TRUE;
 309                                         g_hash_table_replace(table, g_strdup(keycode), menuid);
 310                                         menuid = NULL;
 311                                 }
 312                         }
 313                         g_free(key);
 314                         g_free(menuid);
 315                 }
 316                 g_strfreev(keys);
 317         }
 318
 319         g_free(kname);
 320         return ret;
 321 #endif
 322         return FALSE;
 323 }
 324
 325 void gnt_styles_get_keyremaps(GType type, GHashTable *hash)
 326 {
 327 #if GLIB_CHECK_VERSION(2,6,0)
 328         char *name;
 329         GError *error = NULL;
 330
 331         name = g_strdup_printf("%s::remap", g_type_name(type));
 332
 333         if (g_key_file_has_group(gkfile, name))
 334         {
 335                 gsize len = 0;
 336                 char **keys;
 337
 338                 keys = g_key_file_get_keys(gkfile, name, &len, &error);
 339                 if (error)
 340                 {
 341                         g_printerr("GntStyle: %s\n", error->message);
 342                         g_error_free(error);
 343                         g_free(name);
 344                         return;
 345                 }
 346
 347                 while (len--)
 348                 {
 349                         char *key, *replace;
 350
 351                         key = g_strdup(keys[len]);
 352                         replace = g_key_file_get_string(gkfile, name, keys[len], &error);
 353
 354                         if (error)
 355                         {
 356                                 g_printerr("GntStyle: %s\n", error->message);
 357                                 g_error_free(error);
 358                                 error = NULL;
 359                                 g_free(key);
 360                         }
 361                         else
 362                         {
 363                                 refine(key);
 364                                 refine(replace);
 365                                 g_hash_table_insert(hash, key, replace);
 366                         }
 367                 }
 368                 g_strfreev(keys);
 369         }
 370
 371         g_free(name);
 372 #endif
 373 }
 374
 375 #if GLIB_CHECK_VERSION(2,6,0)
 376 static void
 377 read_general_style(GKeyFile *kfile)
 378 {
 379         GError *error = NULL;
 380         gsize nkeys;
 381         const char *prgname = g_get_prgname();
 382         char **keys = NULL;
 383         int i;
 384         struct
 385         {
 386                 const char *style;
 387                 GntStyle en;
 388         } styles[] = {{"shadow", GNT_STYLE_SHADOW},
 389                       {"customcolor", GNT_STYLE_COLOR},
 390                       {"mouse", GNT_STYLE_MOUSE},
 391                       {"wm", GNT_STYLE_WM},
 392                       {"remember_position", GNT_STYLE_REMPOS},
 393                       {NULL, 0}};
 394
 395         if (prgname && *prgname)
 396                 keys = g_key_file_get_keys(kfile, prgname, &nkeys, NULL);
 397
 398         if (keys == NULL) {
 399                 prgname = "general";
 400                 keys = g_key_file_get_keys(kfile, prgname, &nkeys, &error);
 401         }
 402
 403         if (error)
 404         {
 405                 g_printerr("GntStyle: %s\n", error->message);
 406                 g_error_free(error);
 407         }
 408         else
 409         {
 410                 for (i = 0; styles[i].style; i++)
 411                 {
 412                         str_styles[styles[i].en] =
 413                                         g_key_file_get_string(kfile, prgname, styles[i].style, NULL);
 414                 }
 415         }
 416         g_strfreev(keys);
 417 }
 418 #endif
 419
 420 void gnt_style_read_configure_file(const char *filename)
 421 {
 422 #if GLIB_CHECK_VERSION(2,6,0)
 423         GError *error = NULL;
 424         gkfile = g_key_file_new();
 425
 426         if (!g_key_file_load_from_file(gkfile, filename,
 427                 G_KEY_FILE_KEEP_COMMENTS | G_KEY_FILE_KEEP_TRANSLATIONS, &error))
 428         {
 429                 g_printerr("GntStyle: %s\n", error->message);
 430                 g_error_free(error);
 431                 return;
 432         }
 433         gnt_colors_parse(gkfile);
 434         read_general_style(gkfile);
 435 #endif
 436 }
 437
 438 void gnt_init_styles()
 439 {
 440         int i;
 441         for (i = 0; i < GNT_STYLES; i++)
 442         {
 443                 str_styles[i] = NULL;
 444                 int_styles[i] = -1;
 445                 bool_styles[i] = -1;
 446         }
 447 }
 448
 449 void gnt_uninit_styles()
 450 {
 451         int i;
 452         for (i = 0; i < GNT_STYLES; i++) {
 453                 g_free(str_styles[i]);
 454                 str_styles[i] = NULL;
 455         }
 456
 457 #if GLIB_CHECK_VERSION(2,6,0)
 458         g_key_file_free(gkfile);
 459         gkfile = NULL;
 460 #endif
 461 }
 462