irreco/src/core/irreco_config.c

   1 /*
   2  * irreco - Ir Remote Control
   3  * Copyright (C) 2007  Arto Karppinen (arto.karppinen@iki.fi),
   4  *                      Harri Vattulainen (t5vaha01@students.oamk.fi)
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version 2
   9  * of the License, or (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  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software Foundation,
  18  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  19  */
  20
  21 #include "irreco_config.h"
  22 #include "irreco_button.h"
  23
  24 /**
  25  * @addtogroup IrrecoConfig
  26  * @ingroup Irreco
  27  *
  28  * Configuration saving and reading.
  29  *
  30  * @{
  31  */
  32
  33 /**
  34  * @file
  35  * Source file of @ref IrrecoConfig.
  36  */
  37
  38
  39 #define IRRECO_CONFIG_GROUP_LEN 20
  40
  41 gchar* irreco_config_layout_file        = "layouts.conf";
  42 gchar* irreco_config_active_layout_file = "active-layout.conf";
  43 gchar* irreco_config_backend_file       = "backends.conf";
  44 gchar* irreco_config_cmd_chain_file     = "command-chains.conf";
  45
  46
  47
  48 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  49 /* Prototypes                                                                 */
  50 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  51
  52 void irreco_config_read_button_from_keyfile(IrrecoData * irreco_data,
  53                                             IrrecoKeyFile * keyfile);
  54 void irreco_config_read_hardkey_from_keyfile(IrrecoData * irreco_data,
  55                                              IrrecoKeyFile * keyfile);
  56 void irreco_config_read_layout_from_keyfile(IrrecoData * irreco_data,
  57                                             IrrecoKeyFile * keyfile,
  58                                             const gchar *filename);
  59 void irreco_config_save_layout_to_keyfile(GKeyFile * keyfile,
  60                                           IrrecoButtonLayout * layout,
  61                                           gint * button_index,
  62                                           gint * command_index,
  63                                           gint * hardkey_index);
  64 void irreco_config_save_hardkey_to_file(IrrecoHardkeyMap *hardkey_map,
  65                                         guint             keyval,
  66                                         IrrecoCmdChainId  chain_id,
  67                                         IrrecoCmdChain   *chain,
  68                                         gpointer          user_data);
  69 void irreco_config_save_button_to_keyfile(GKeyFile * keyfile,
  70                                           IrrecoButton * button,
  71                                           gint * button_index,
  72                                           gint * command_index);
  73 void irreco_config_save_cmd_chain_to_keyfile(GKeyFile * keyfile,
  74                                              IrrecoButton * button,
  75                                              gint * command_index);
  76 void irreco_config_read_backend_from_keyfile(
  77                                          IrrecoBackendManager * backend_manager,
  78                                          IrrecoKeyFile * keyfile);
  79 void irreco_config_read_layouts(IrrecoDirForeachData *dir_data);
  80
  81
  82 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  83 /* Layout reading.                                                            */
  84 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  85
  86 /**
  87  * @name Layout reading
  88  * @{
  89  */
  90
  91 gboolean irreco_config_read_layouts_from_files(IrrecoData *irreco_data)
  92 {
  93         IrrecoDirForeachData dir_data;
  94         IRRECO_ENTER
  95
  96         dir_data.directory = irreco_get_config_dir("irreco");
  97         dir_data.filesuffix = ".conf";
  98         dir_data.user_data_1 = irreco_data;
  99
 100         irreco_dir_foreach(&dir_data,
 101                            irreco_config_read_layouts);
 102
 103         IRRECO_RETURN_BOOL(TRUE);
 104 }
 105
 106 void irreco_config_read_layouts(IrrecoDirForeachData *dir_data)
 107 {
 108         guint i;
 109         IrrecoKeyFile *keyfile = NULL;
 110         gchar *config_dir = NULL;
 111         gchar *config_file = NULL;
 112         gchar** groups = NULL;
 113         gsize group_count = 0;
 114         IrrecoData *irreco_data = dir_data->user_data_1;
 115         IRRECO_ENTER
 116
 117         /* Modified to allow reading old layouts.conf */
 118         if(!g_str_has_prefix(dir_data->filename, "layout") /* ||
 119            strcmp(dir_data->filename, "layouts.conf") == 0*/ ) {
 120                 IRRECO_DEBUG("Not layout*.conf file\n");
 121                 IRRECO_RETURN
 122         }
 123
 124         config_dir = (gchar*) dir_data->directory;
 125         config_file = irreco_get_config_file("irreco", dir_data->filename);
 126
 127         keyfile = irreco_keyfile_create(config_dir, config_file, NULL);
 128         if (config_dir == NULL || config_file == NULL || keyfile == NULL) {
 129                 g_free(config_dir);
 130                 g_free(config_file);
 131                 irreco_keyfile_destroy(keyfile);
 132                 IRRECO_RETURN
 133         }
 134
 135         IRRECO_PRINTF("Reading layout configuration file \"%s\"\n",
 136                       config_file);
 137         groups = g_key_file_get_groups(keyfile->keyfile, &group_count);
 138
 139         /* Read layout. */
 140         for (i = 0; i < group_count; i++) {
 141                 gchar *group = groups[i];
 142                 if (g_str_has_prefix(group, "layout")) {
 143                         IRRECO_PRINTF("Reading layout group \"%s\"\n", group);
 144                         irreco_keyfile_set_group(keyfile, group);
 145                         irreco_config_read_layout_from_keyfile(irreco_data,
 146                                                                keyfile,
 147                                                         dir_data->filename);
 148                 }
 149         }
 150
 151         /* Read Buttons. */
 152         for (i = 0; i < group_count; i++) {
 153                 gchar *group = groups[i];
 154                 if (g_str_has_prefix(group, "button")) {
 155                         IRRECO_PRINTF("Reading button group \"%s\"\n", group);
 156                         irreco_keyfile_set_group(keyfile, group);
 157                         irreco_config_read_button_from_keyfile(irreco_data,
 158                                                                keyfile);
 159                 }
 160         }
 161
 162         /* Read Hardkeys. */
 163         for (i = 0; i < group_count; i++) {
 164                 gchar *group = groups[i];
 165                 if (g_str_has_prefix(group, "hardkey")) {
 166                         IRRECO_PRINTF("Reading hardkey group \"%s\"\n", group);
 167                         irreco_keyfile_set_group(keyfile, group);
 168                         irreco_config_read_hardkey_from_keyfile(irreco_data,
 169                                                                 keyfile);
 170                 }
 171         }
 172
 173         /* Read command chains. */
 174         irreco_cmd_chain_manager_from_config(irreco_data);
 175
 176         g_strfreev(groups);
 177         irreco_keyfile_destroy(keyfile);
 178
 179         IRRECO_RETURN
 180 }
 181
 182 void irreco_config_read_layout_from_keyfile(IrrecoData * irreco_data,
 183                                             IrrecoKeyFile * keyfile,
 184                                             const gchar *filename)
 185 {
 186         gchar *name = NULL;
 187         IrrecoButtonLayout *layout = NULL;
 188         GdkColor color;
 189         gint type;
 190         gchar *image = NULL;
 191         IRRECO_ENTER
 192
 193         /* Required fields. */
 194         if (!irreco_keyfile_get_str(keyfile, "name", &name)) IRRECO_RETURN
 195         layout = irreco_button_layout_create(NULL,
 196                                              irreco_data->cmd_chain_manager);
 197         irreco_button_layout_set_name(layout, name);
 198         g_free(name);
 199         name = NULL;
 200
 201         /* Don't save old type filename, so it get renamed */
 202         if(!strcmp(filename, "layouts.conf") == 0) {
 203                 irreco_button_layout_set_filename(layout, filename);
 204         }
 205
 206         if (irreco_keyfile_get_int(keyfile, "bg-type", &type)) {
 207                 switch (type) {
 208                 case IRRECO_BACKGROUND_DEFAULT:
 209                 case IRRECO_BACKGROUND_COLOR:
 210                 case IRRECO_BACKGROUND_IMAGE:
 211                         irreco_button_layout_set_bg_type(layout, type);
 212                         break;
 213
 214                 default:
 215                         IRRECO_ERROR("Unknown background type \"%i\".\n",
 216                                      type);
 217                         break;
 218                 }
 219         }
 220
 221         if (irreco_keyfile_get_str(keyfile, "bg-image", &image)) {
 222                 irreco_button_layout_set_bg_image(layout, image);
 223                 g_free(image);
 224                 image = NULL;
 225         }
 226
 227         color.pixel = 0;
 228         if (irreco_keyfile_get_uint16(keyfile, "bg-color-red", &color.red) &&
 229             irreco_keyfile_get_uint16(keyfile, "bg-color-green", &color.green)&&
 230             irreco_keyfile_get_uint16(keyfile, "bg-color-blue", &color.blue)) {
 231                 irreco_button_layout_set_bg_color(layout, &color);
 232         }
 233
 234         if (!irreco_string_table_add(irreco_data->irreco_layout_array,
 235                                     irreco_button_layout_get_name(layout),
 236                                     layout)) {
 237                 IRRECO_ERROR("Layout \"%s\" already exists.",
 238                              irreco_button_layout_get_name(layout));
 239                 irreco_button_layout_destroy(layout);
 240         }
 241
 242         IRRECO_RETURN
 243 }
 244
 245 void irreco_config_read_button_from_keyfile(IrrecoData * irreco_data,
 246                                             IrrecoKeyFile * keyfile)
 247 {
 248         gchar *layout_name = NULL;
 249         gchar *style_name = NULL;
 250         gchar *title = NULL;
 251         gchar *command = NULL;
 252         IrrecoCmdChainId chain_id;
 253         gint x;
 254         gint y;
 255
 256         IrrecoButton *button = NULL;
 257         IrrecoButtonLayout *layout = NULL;
 258         IrrecoThemeButton *style = NULL;
 259         IRRECO_ENTER
 260
 261         /* Required fields. */
 262         if (!irreco_keyfile_get_int(keyfile, "x", &x) ||
 263             !irreco_keyfile_get_int(keyfile, "y", &y) ||
 264             !irreco_keyfile_get_str(keyfile, "layout", &layout_name)) {
 265                 IRRECO_RETURN
 266         }
 267         IRRECO_PRINTF("Position: x%i y%i\n", x, y);
 268
 269         /* Find layout. */
 270         if (!irreco_string_table_get(irreco_data->irreco_layout_array,
 271                                     layout_name, (gpointer *) &layout)) {
 272                 IRRECO_ERROR("Button uses unknown layout \"%s\"\n",
 273                              layout_name);
 274                 g_free(layout_name);
 275                 IRRECO_RETURN
 276         }
 277         g_free(layout_name);
 278         IRRECO_PRINTF("Style: \"%s\"\n",
 279                       irreco_button_layout_get_name(layout));
 280
 281         /* Find style. */
 282         irreco_keyfile_get_str(keyfile, "style", &style_name);
 283         if (style_name != NULL) {
 284                 if (irreco_theme_manager_get_button_style(
 285                                                 irreco_data->theme_manager,
 286                                                 style_name, &style)) {
 287                         IRRECO_PRINTF("Style: \"%s\"\n", style->name->str);
 288                 } else {
 289                         IRRECO_ERROR("Button uses unknown style \"%s\"\n",
 290                                      style_name);
 291                 }
 292
 293                 g_free(style_name);
 294         }
 295
 296         /* Get title and command. */
 297         irreco_keyfile_get_str(keyfile, "title", &title);
 298         IRRECO_PRINTF("title: \"%s\"\n", title);
 299
 300         button = irreco_button_create(layout, x, y, title, style,
 301                                       irreco_data->cmd_chain_manager);
 302
 303         if (irreco_keyfile_get_int(keyfile, "command-chain-id", &chain_id)) {
 304                 irreco_button_set_cmd_chain_id(button, chain_id);
 305         }
 306
 307         g_free(title);
 308         g_free(command);
 309         IRRECO_RETURN
 310 }
 311
 312 void irreco_config_read_hardkey_from_keyfile(IrrecoData * irreco_data,
 313                                              IrrecoKeyFile * keyfile)
 314 {
 315         IrrecoButtonLayout *layout = NULL;
 316         gchar *layout_name = NULL;
 317         IrrecoCmdChainId id;
 318         guint keyval;
 319         gchar *hardkey_str = NULL;
 320         IRRECO_ENTER
 321
 322         /* Required fields. */
 323         if (!irreco_keyfile_get_str(keyfile, "layout", &layout_name) ||
 324             !irreco_keyfile_get_int(keyfile, "chain-id", &id) ||
 325             !irreco_keyfile_get_uint(keyfile, "key-value", &keyval)) {
 326                 g_free(layout_name);
 327                 IRRECO_RETURN
 328         }
 329
 330         /* Find layout. */
 331         if (!irreco_string_table_get(irreco_data->irreco_layout_array,
 332                                      layout_name, (gpointer *) &layout)) {
 333                 IRRECO_ERROR("Hardkey uses unknown layout \"%s\"\n",
 334                              layout_name);
 335                 g_free(layout_name);
 336                 IRRECO_RETURN
 337         }
 338         g_free(layout_name);
 339
 340         hardkey_str = irreco_hardkey_to_str(keyval);
 341         IRRECO_PRINTF("Associating layout \"%s\" hardkey \"%s\" with "
 342                       "command chain \"%i\".\n",
 343                       irreco_button_layout_get_name(layout),
 344                       hardkey_str, id);
 345         g_free(hardkey_str);
 346
 347         irreco_hardkey_map_assosiate_chain_with_id(layout->hardkey_map,
 348                                                    keyval, id);
 349         IRRECO_RETURN
 350 }
 351
 352 /** @} */
 353
 354
 355
 356 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 357 /* Layout saving.                                                             */
 358 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 359
 360 /**
 361  * @name Layout saving
 362  * @{
 363  */
 364
 365 /**
 366  * Save layout.
 367  *
 368  * Since GKeyFile does not allow two groups with the same name,
 369  * layout_index and button_index variables are used to make sure that each
 370  * button and layout group has unique name. The index is ignored when reading
 371  * the layout config.
 372  */
 373 gboolean irreco_config_save_layouts(IrrecoData * irreco_data)
 374 {
 375         gint button_index = 1;
 376         gint command_index = 1;
 377         gint hardkey_index = 1;
 378         GKeyFile *keyfile;
 379         IrrecoStringTable *table;
 380         gboolean success;
 381         GList *list = NULL;
 382
 383         IRRECO_ENTER
 384
 385         /* TODO Sami FIXME */
 386         /* Remover 'cause goes to wrong file (I guess) */
 387         /*irreco_cmd_chain_manager_to_config(irreco_data->cmd_chain_manager);*/
 388
 389         table = irreco_data->irreco_layout_array;
 390         IRRECO_STRING_TABLE_FOREACH(table, key, IrrecoButtonLayout *, layout)
 391                 gchar *filename;
 392                 keyfile = g_key_file_new();
 393                 irreco_config_save_layout_to_keyfile(keyfile,
 394                                                      layout,
 395                                                      &button_index,
 396                                                      &command_index,
 397                                                      &hardkey_index);
 398
 399                 filename = irreco_create_uniq_layout_filename(
 400                                                         layout->filename->str);
 401                 g_string_assign(layout->filename, filename);
 402
 403                 list = g_list_prepend(list, g_strdup(filename));
 404
 405                 IRRECO_DEBUG("Layout %s in file: %s\n",
 406                              layout->name->str,
 407                              layout->filename->str);
 408
 409                 success = irreco_gkeyfile_write_to_config_file(keyfile, "irreco",
 410                                                                filename);
 411                 g_key_file_free(keyfile);
 412                 g_free(filename);
 413         IRRECO_STRING_TABLE_FOREACH_END
 414
 415         /* Remove unused layouts afterwards */
 416         irreco_remove_layouts_exept_glist(list);
 417         g_list_free(list);
 418
 419         IRRECO_RETURN_BOOL(success);
 420 }
 421
 422 typedef struct _IrrecoConfigSaveHardkeyData IrrecoConfigSaveHardkeyData;
 423 struct _IrrecoConfigSaveHardkeyData {
 424         GKeyFile *keyfile;
 425         gint *hardkey_index;
 426         IrrecoButtonLayout *layout;
 427 };
 428
 429 void irreco_config_save_layout_to_keyfile(GKeyFile * keyfile,
 430                                           IrrecoButtonLayout * layout,
 431                                           gint * button_index,
 432                                           gint * command_index,
 433                                           gint * hardkey_index)
 434 {
 435         GdkColor *color;
 436         gchar group[IRRECO_CONFIG_GROUP_LEN];
 437         IrrecoConfigSaveHardkeyData hardkey_data;
 438         IRRECO_ENTER
 439
 440         /* Save layout. */
 441         g_assert(irreco_button_layout_get_name(layout) != NULL);
 442         g_snprintf(group, IRRECO_CONFIG_GROUP_LEN, "layout");
 443         irreco_gkeyfile_set_string(keyfile, group, "name",
 444                                  irreco_button_layout_get_name(layout));
 445         g_key_file_set_integer(keyfile, group, "bg-type",
 446                                irreco_button_layout_get_bg_type(layout));
 447         irreco_gkeyfile_set_string(keyfile, group, "bg-image",
 448                                  irreco_button_layout_get_bg_image(layout));
 449         color = irreco_button_layout_get_bg_color(layout);
 450         g_key_file_set_integer(keyfile, group, "bg-color-red", color->red);
 451         g_key_file_set_integer(keyfile, group, "bg-color-green", color->green);
 452         g_key_file_set_integer(keyfile, group, "bg-color-blue", color->blue);
 453
 454         /* Save buttons. */
 455         irreco_button_layout_reindex(layout);
 456         IRRECO_PTR_ARRAY_FORWARDS(layout->button_array, IrrecoButton *, button)
 457                 irreco_config_save_button_to_keyfile(keyfile,
 458                                                      button,
 459                                                      button_index,
 460                                                      command_index);
 461                 *button_index = *button_index + 1;
 462         IRRECO_PTR_ARRAY_FORWARDS_END
 463
 464         /* Save Hardkeys. */
 465         hardkey_data.keyfile = keyfile;
 466         hardkey_data.hardkey_index = hardkey_index;
 467         hardkey_data.layout = layout;
 468         irreco_hardkey_map_chain_foreach(layout->hardkey_map,
 469                                          irreco_config_save_hardkey_to_file,
 470                                          &hardkey_data);
 471         IRRECO_RETURN
 472 }
 473
 474 void irreco_config_save_hardkey_to_file(IrrecoHardkeyMap *hardkey_map,
 475                                         guint             keyval,
 476                                         IrrecoCmdChainId  chain_id,
 477                                         IrrecoCmdChain   *chain,
 478                                         gpointer          user_data)
 479 {
 480         gchar group[IRRECO_CONFIG_GROUP_LEN];
 481         IrrecoConfigSaveHardkeyData *hardkey_data;
 482         IRRECO_ENTER
 483
 484         hardkey_data = (IrrecoConfigSaveHardkeyData*) user_data;
 485
 486         g_snprintf(group, IRRECO_CONFIG_GROUP_LEN, "hardkey-%i",
 487                    *hardkey_data->hardkey_index);
 488         irreco_gkeyfile_set_string(hardkey_data->keyfile, group, "layout",
 489                 irreco_button_layout_get_name(hardkey_data->layout));
 490         g_key_file_set_integer(hardkey_data->keyfile, group,
 491                                "chain-id", chain_id);
 492         irreco_gkeyfile_set_guint(hardkey_data->keyfile, group,
 493                                   "key-value", keyval);
 494
 495         *hardkey_data->hardkey_index = *hardkey_data->hardkey_index + 1;
 496         IRRECO_RETURN
 497 }
 498
 499 void irreco_config_save_button_to_keyfile(GKeyFile * keyfile,
 500                                           IrrecoButton * button,
 501                                           gint * button_index,
 502                                           gint * command_index)
 503 {
 504         gchar group[IRRECO_CONFIG_GROUP_LEN];
 505         IRRECO_ENTER
 506
 507         g_snprintf(group, IRRECO_CONFIG_GROUP_LEN, "button-%i", *button_index);
 508         irreco_gkeyfile_set_string(keyfile, group, "layout",
 509                 irreco_button_layout_get_name(button->irreco_layout));
 510         irreco_gkeyfile_set_string(keyfile, group, "title", button->title);
 511         g_key_file_set_integer(keyfile, group, "index", button->index);
 512         g_key_file_set_integer(keyfile, group, "command-chain-id",
 513                                button->cmd_chain_id);
 514         g_key_file_set_integer(keyfile, group, "x", button->x);
 515         g_key_file_set_integer(keyfile, group, "y", button->y);
 516
 517         /* It is valid for a button to have NULL style. */
 518         if (button->style != NULL) {
 519                 irreco_gkeyfile_set_string(keyfile, group, "style",
 520                                       button->style->style_name->str);
 521         }
 522
 523         IRRECO_RETURN
 524 }
 525
 526 /** @} */
 527
 528
 529
 530 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 531 /* Save / Read active layout.                                                 */
 532 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 533
 534 /**
 535  * @name Save / Read active layout
 536  * @{
 537  */
 538
 539 gboolean irreco_config_save_active_layout(IrrecoButtonLayout * irreco_layout)
 540 {
 541         GKeyFile *keyfile;
 542         gboolean success;
 543         IRRECO_ENTER
 544
 545         keyfile = g_key_file_new();
 546         if (irreco_layout != NULL) {
 547                 irreco_gkeyfile_set_string(keyfile, "active-layout", "name",
 548                         irreco_button_layout_get_name(irreco_layout));
 549         }
 550         success = irreco_gkeyfile_write_to_config_file(keyfile, "irreco",
 551                                               irreco_config_active_layout_file);
 552         g_key_file_free(keyfile);
 553         IRRECO_RETURN_BOOL(success);
 554 }
 555
 556 IrrecoButtonLayout *irreco_config_read_active_layout(IrrecoData * irreco_data)
 557 {
 558         IrrecoKeyFile *keyfile = NULL;
 559         gchar *config_dir = NULL;
 560         gchar *config_file = NULL;
 561         gchar *name = NULL;
 562         IrrecoButtonLayout *irreco_layout = NULL;
 563         IRRECO_ENTER
 564
 565         /* Attempt to read layout name, and find layout with the same name. */
 566         config_dir = irreco_get_config_dir("irreco");
 567         config_file = irreco_get_config_file("irreco",
 568                                              irreco_config_active_layout_file);
 569         keyfile = irreco_keyfile_create(config_dir, config_file, NULL);
 570         if (config_dir != NULL && config_file != NULL && keyfile != NULL
 571             && irreco_keyfile_set_group(keyfile, "active-layout")
 572             && irreco_keyfile_get_str(keyfile, "name", &name)) {
 573
 574                 IRRECO_DEBUG("Read active layout name \"%s\" from \"%s\".\n",
 575                           name, irreco_config_active_layout_file);
 576
 577                 if (irreco_string_table_get(irreco_data->irreco_layout_array,
 578                                             name, (gpointer *) &irreco_layout)){
 579                         IRRECO_DEBUG("Found matching layout.\n");
 580                 } else {
 581                         IRRECO_DEBUG("No matching layout found.\n");
 582                 }
 583         }
 584
 585         irreco_keyfile_destroy(keyfile);
 586         g_free(name);
 587         g_free(config_dir);
 588         g_free(config_file);
 589
 590         /* If we could not find correct active layout,
 591            attempt to get some layout.*/
 592         if (irreco_layout == NULL) {
 593                 irreco_string_table_index(irreco_data->irreco_layout_array, 0,
 594                                           NULL, (gpointer *) &irreco_layout);
 595         }
 596         IRRECO_RETURN_PTR(irreco_layout);
 597 }
 598
 599 /** @} */
 600
 601
 602
 603 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 604 /* Save / Read backend configuration.                                         */
 605 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 606
 607 /**
 608  * @name Save / Read backend configuration
 609  * @{
 610  */
 611
 612 gboolean irreco_config_save_backends(IrrecoBackendManager * backend_manager)
 613 {
 614         gint i = 0;
 615         GKeyFile *keyfile;
 616         gboolean success;
 617         gchar group[IRRECO_CONFIG_GROUP_LEN];
 618         IRRECO_ENTER
 619
 620         keyfile = g_key_file_new();
 621         IRRECO_BACKEND_MANAGER_FOREACH_INSTANCE(backend_manager, instance)
 622                 g_snprintf(group, IRRECO_CONFIG_GROUP_LEN, "instance-%i", ++i);
 623                 irreco_gkeyfile_set_string(keyfile, group, "library",
 624                                          instance->lib->filename);
 625                 irreco_gkeyfile_set_string(keyfile, group, "config",
 626                                          instance->config);
 627                 irreco_gkeyfile_set_string(keyfile, group, "name",
 628                                          instance->name);
 629         IRRECO_BACKEND_MANAGER_FOREACH_END
 630
 631         success = irreco_gkeyfile_write_to_config_file(keyfile, "irreco",
 632                                                     irreco_config_backend_file);
 633         g_key_file_free(keyfile);
 634         IRRECO_RETURN_BOOL(success);
 635 }
 636
 637 gboolean irreco_config_read_backends(IrrecoBackendManager * manager)
 638 {
 639         guint i;
 640         IrrecoKeyFile *keyfile = NULL;
 641         gchar *config_dir = NULL;
 642         gchar *config_file = NULL;
 643         gchar** groups = NULL;
 644         gsize group_count = 0;
 645         IRRECO_ENTER
 646
 647         config_dir = irreco_get_config_dir("irreco");
 648         config_file = irreco_get_config_file("irreco",
 649                                              irreco_config_backend_file);
 650         keyfile = irreco_keyfile_create(config_dir, config_file, NULL);
 651         if (config_dir == NULL || config_file == NULL || keyfile == NULL) {
 652                 g_free(config_dir);
 653                 g_free(config_file);
 654                 irreco_keyfile_destroy(keyfile);
 655                 IRRECO_RETURN_BOOL(FALSE);
 656         }
 657
 658         IRRECO_PRINTF("Reading backend configuration file \"%s\"\n",
 659                       config_file);
 660         groups = g_key_file_get_groups(keyfile->keyfile, &group_count);
 661
 662         /* Read instances. */
 663         for (i = 0; i < group_count; i++) {
 664                 gchar *group = groups[i];
 665                 if (g_str_has_prefix(group, "instance")) {
 666                         IRRECO_PRINTF("Reading instance group \"%s\"\n", group);
 667                         irreco_keyfile_set_group(keyfile, group);
 668                         irreco_config_read_backend_from_keyfile(manager,
 669                                                                 keyfile);
 670                 }
 671         }
 672
 673         g_strfreev(groups);
 674         irreco_keyfile_destroy(keyfile);
 675         g_free(config_dir);
 676         g_free(config_file);
 677         IRRECO_RETURN_BOOL(TRUE);
 678 }
 679
 680 void irreco_config_read_backend_from_keyfile(IrrecoBackendManager * manager,
 681                                              IrrecoKeyFile * keyfile)
 682 {
 683         gchar *library = NULL;
 684         gchar *config = NULL;
 685         gchar *name = NULL;
 686         IrrecoBackendLib *lib;
 687         IRRECO_ENTER
 688
 689         /* Read variables. */
 690         if (!irreco_keyfile_get_str(keyfile, "library", &library) ||
 691             !irreco_keyfile_get_str(keyfile, "config", &config) ||
 692             !irreco_keyfile_get_str(keyfile, "name", &name)) {
 693                 g_free(library);
 694                 g_free(config);
 695                 g_free(name);
 696                 IRRECO_RETURN
 697         }
 698
 699         /* Find library. */
 700         if (!irreco_backend_manager_find_lib(manager, library, &lib)) {
 701                 IRRECO_ERROR("Cannot find backend library \"%s\"\n", library);
 702                 g_free(library);
 703                 g_free(config);
 704                 g_free(name);
 705                 IRRECO_RETURN
 706         }
 707         g_free(library);
 708
 709         /* Create instance. */
 710         irreco_backend_manager_create_instance(manager, lib, name, config);
 711         g_free(name);
 712         g_free(config);
 713
 714         IRRECO_RETURN
 715 }
 716
 717
 718 /** @} */
 719
 720
 721 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 722 /* Misc layout functions                                                      */
 723 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 724
 725 /**
 726  * @name Misc layout functions
 727  * @{
 728  */
 729
 730 /**
 731  * Get list of themes used by layout
 732  *
 733  * @param data IrrecoData
 734  * @param layoutname name of layout
 735  * @param list StringTable that'll contain theme names (key) and versions (data)
 736  * @returns TRUE in case of success, FALSE otherwise
 737  */
 738 gboolean irreco_layout_get_themes(IrrecoData *data,
 739                                   gchar *layoutname,
 740                                   IrrecoStringTable **list)
 741 {
 742         IrrecoStringTable       *themelist = NULL;
 743         gchar                   *bgpath = NULL;
 744
 745         IRRECO_ENTER
 746
 747         /* List of theme names used by layout, stored as keys */
 748         *list = irreco_string_table_new(NULL, NULL);
 749         /* List of all themes */
 750         themelist = irreco_theme_manager_get_themes(data->theme_manager);
 751
 752         if(irreco_string_table_lenght(data->irreco_layout_array) == 0) {
 753                 IRRECO_RETURN_BOOL(FALSE);
 754         }
 755
 756         /* Loop through layout buttons and store used themes to list */
 757         IRRECO_STRING_TABLE_FOREACH(data->irreco_layout_array,
 758                                     key,
 759                                     IrrecoButtonLayout *,
 760                                     layout)
 761                 /* Skip layouts with wrong name */
 762                 if(g_str_equal(layoutname, layout->name->str)) {
 763                         if(layout->background_type == 2) {
 764                                 bgpath = g_strdup(layout->background_image->str);
 765                         }
 766                         IRRECO_PTR_ARRAY_FORWARDS(layout->button_array,
 767                                                 IrrecoButton *,
 768                                                 irreco_button)
 769                                 /* Block buttons without theme */
 770                                 if(irreco_button->style != NULL) {
 771                                 gboolean match = FALSE;
 772                                 IRRECO_STRING_TABLE_FOREACH_KEY(*list, themename)
 773                                         if(g_str_equal(
 774                                         irreco_button->style->theme_name->str,
 775                                         themename)) {
 776                                                 match = TRUE;
 777                                         }
 778                                 IRRECO_STRING_TABLE_FOREACH_END
 779                                 if(!match) {
 780                                         irreco_string_table_add(*list,
 781                                         irreco_button->style->theme_name->str,
 782                                                                 NULL);
 783                                 }
 784                                 }
 785                         IRRECO_PTR_ARRAY_BACKWARDS_END
 786                 }
 787         IRRECO_STRING_TABLE_FOREACH_END
 788
 789         /* Loop through themes and get versions of wanted themes */
 790         IRRECO_STRING_TABLE_FOREACH(themelist, key, IrrecoTheme*, theme)
 791                 IRRECO_STRING_TABLE_FOREACH(theme->backgrounds,
 792                                             bgkey,
 793                                             IrrecoThemeBg*,
 794                                             bgtheme)
 795                         if(bgpath != NULL)
 796                         if(g_str_equal(bgtheme->image_path->str, bgpath)) {
 797                                 gboolean match = FALSE;
 798                                 /* Matching theme found for bg */
 799                                 IRRECO_STRING_TABLE_FOREACH_KEY(*list, themename)
 800                                         if(g_str_equal(theme->name->str,
 801                                                        themename)) {
 802                                                 match = TRUE;
 803                                         }
 804                                 IRRECO_STRING_TABLE_FOREACH_END
 805                                 if(!match) {
 806                                         irreco_string_table_add(*list,
 807                                                                 theme->name->str,
 808                                                                 NULL);
 809                                 }
 810                         }
 811                 IRRECO_STRING_TABLE_FOREACH_END
 812                 IRRECO_STRING_TABLE_FOREACH_KEY(*list, themename)
 813                                 if(g_str_equal(themename, theme->name->str)) {
 814                                 irreco_string_table_change_data(*list, themename, theme->version->str);
 815                                 }
 816                 IRRECO_STRING_TABLE_FOREACH_END
 817         IRRECO_STRING_TABLE_FOREACH_END
 818
 819         g_free(bgpath);
 820
 821         IRRECO_RETURN_BOOL(TRUE);
 822 }
 823
 824
 825 /** @} */
 826 /** @} */
 827