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 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  50 /* Prototypes                                                                 */
  51 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  52 #if 0
  53 void irreco_config_read_style_from_keyfile(IrrecoData * irreco_data,
  54                                            IrrecoKeyFile *keyfile,
  55                                            gboolean editable);
  56 #endif
  57 void irreco_config_read_button_from_keyfile(IrrecoData * irreco_data,
  58                                             IrrecoKeyFile * keyfile);
  59 void irreco_config_read_hardkey_from_keyfile(IrrecoData * irreco_data,
  60                                              IrrecoKeyFile * keyfile);
  61 void irreco_config_read_layout_from_keyfile(IrrecoData * irreco_data,
  62                                             IrrecoKeyFile * keyfile);
  63 void irreco_config_read_command_from_keyfile(IrrecoData * irreco_data,
  64                                              IrrecoKeyFile * keyfile);
  65 void irreco_config_save_layout_to_keyfile(GKeyFile * keyfile,
  66                                           IrrecoButtonLayout * layout,
  67                                           gint * layout_index,
  68                                           gint * button_index,
  69                                           gint * command_index,
  70                                           gint * hardkey_index);
  71 void irreco_config_save_hardkey_to_file(IrrecoHardkeyMap *hardkey_map,
  72                                         guint             keyval,
  73                                         IrrecoCmdChainId  chain_id,
  74                                         IrrecoCmdChain   *chain,
  75                                         gpointer          user_data);
  76 void irreco_config_save_button_to_keyfile(GKeyFile * keyfile,
  77                                           IrrecoButton * button,
  78                                           gint * button_index,
  79                                           gint * command_index);
  80 void irreco_config_save_cmd_chain_to_keyfile(GKeyFile * keyfile,
  81                                              IrrecoButton * button,
  82                                              gint * command_index);
  83 void irreco_config_read_backend_from_keyfile(
  84                                          IrrecoBackendManager * backend_manager,
  85                                          IrrecoKeyFile * keyfile);
  86
  87
  88
  89 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  90 /* Layout reading.                                                            */
  91 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  92
  93 /**
  94  * @name Layout reading
  95  * @{
  96  */
  97
  98 #if 0
  99 void irreco_config_read_styles_from_dir_foreach(IrrecoDirForeachData * dir_data)
 100 {
 101         IrrecoData * irreco_data = (IrrecoData*) dir_data->user_data_1;
 102         IrrecoKeyFile *keyfile;
 103         IRRECO_ENTER
 104
 105         keyfile = irreco_keyfile_create(dir_data->directory,
 106                                          dir_data->filepath,
 107                                          "button-style");
 108         if (keyfile != NULL) {
 109                 irreco_config_read_style_from_keyfile(irreco_data, keyfile,
 110                                                       FALSE);
 111                 irreco_keyfile_destroy(keyfile);
 112         }
 113
 114         IRRECO_RETURN
 115 }
 116 #endif
 117 /**
 118  * Reads buttons-folder inside themefolder
 119  *
 120  * This function uses irreco_dir_foreach() which calls
 121  * irreco_config_read_styles_from_dir_foreach()
 122  */
 123 #if 0
 124 void irreco_config_read_buttons_from_dir_foreach(IrrecoDirForeachData * dir_data)
 125 {
 126         IrrecoDirForeachData button_styles;
 127         GString * directory = g_string_new("");
 128         IRRECO_ENTER
 129
 130         g_string_printf(directory, "%s/buttons/", dir_data->filepath);
 131         IRRECO_DEBUG("Directory = %s\n", directory->str);
 132         button_styles.directory = directory->str;
 133
 134         button_styles.filesuffix = "bstyleconf";
 135         button_styles.user_data_1 = dir_data->user_data_1;
 136
 137         irreco_dir_foreach_subdirectories(&button_styles,
 138                            irreco_config_read_styles_from_dir_foreach);
 139
 140         g_string_free(directory, TRUE);
 141         directory = NULL;
 142         IRRECO_RETURN
 143 }
 144
 145 #endif
 146
 147 /*
 148  * Reads configs from subdirectories ONLY
 149  */
 150 /*
 151 void irreco_config_read_styles_from_dir(IrrecoData * irreco_data,
 152                                         const gchar *dir)
 153 {
 154         IrrecoDirForeachData dir_data;
 155         IRRECO_ENTER
 156
 157         dir_data.directory = dir;
 158         dir_data.filesuffix = ".bstyleconf";
 159         dir_data.user_data_1 = irreco_data;
 160         irreco_dir_foreach_subdirectories(&dir_data,
 161                            irreco_config_read_styles_from_dir_foreach);
 162
 163         IRRECO_RETURN
 164 }
 165 */
 166
 167 /**
 168  * Reads themefolders from subdirectories
 169  *
 170  * This function uses irreco_dir_foreach() which calls
 171  * irreco_config_read_buttons_from_dir_foreach()
 172  */
 173 #if 0
 174 void irreco_config_read_themes_from_dir(IrrecoData * irreco_data,
 175                                         const gchar *dir)
 176 {
 177         IrrecoDirForeachData dir_data;
 178         IRRECO_ENTER
 179
 180         dir_data.directory = dir;
 181         dir_data.filesuffix = "";
 182         dir_data.user_data_1 = irreco_data;
 183         irreco_dir_foreach(&dir_data,
 184                            irreco_config_read_buttons_from_dir_foreach);
 185
 186         IRRECO_RETURN
 187 }
 188 #endif
 189 #if 0
 190 void irreco_config_read_style_from_file(IrrecoData * irreco_data,
 191                                         const gchar *file)
 192 {
 193         gchar *dir;
 194         IrrecoKeyFile *keyfile;
 195         IRRECO_ENTER
 196
 197         dir = g_path_get_dirname(file);
 198         keyfile = irreco_keyfile_create(dir, file, "button-style");
 199         if (keyfile != NULL) {
 200                 irreco_config_read_style_from_keyfile(irreco_data, keyfile,
 201                                                       FALSE);
 202                 irreco_keyfile_destroy(keyfile);
 203         }
 204         g_free(dir);
 205
 206         IRRECO_RETURN
 207 }
 208 #endif
 209 gboolean irreco_config_read_layouts(IrrecoData * irreco_data)
 210 {
 211         guint i;
 212         IrrecoKeyFile *keyfile = NULL;
 213         gchar *config_dir = NULL;
 214         gchar *config_file = NULL;
 215         gchar** groups = NULL;
 216         gsize group_count = 0;
 217         IRRECO_ENTER
 218
 219         config_dir = irreco_get_config_dir("irreco");
 220         config_file = irreco_get_config_file("irreco",
 221                                              irreco_config_layout_file);
 222         keyfile = irreco_keyfile_create(config_dir, config_file, NULL);
 223         if (config_dir == NULL || config_file == NULL || keyfile == NULL) {
 224                 g_free(config_dir);
 225                 g_free(config_file);
 226                 irreco_keyfile_destroy(keyfile);
 227                 IRRECO_RETURN_BOOL(FALSE);
 228         }
 229
 230         IRRECO_PRINTF("Reading layout configuration file \"%s\"\n",
 231                       config_file);
 232         groups = g_key_file_get_groups(keyfile->keyfile, &group_count);
 233
 234         /* Read layouts. */
 235         for (i = 0; i < group_count; i++) {
 236                 gchar *group = groups[i];
 237                 if (g_str_has_prefix(group, "layout")) {
 238                         IRRECO_PRINTF("Reading layout group \"%s\"\n", group);
 239                         irreco_keyfile_set_group(keyfile, group);
 240                         irreco_config_read_layout_from_keyfile(irreco_data,
 241                                                                keyfile);
 242                 }
 243         }
 244
 245         /* Read Buttons. */
 246         for (i = 0; i < group_count; i++) {
 247                 gchar *group = groups[i];
 248                 if (g_str_has_prefix(group, "button")) {
 249                         IRRECO_PRINTF("Reading button group \"%s\"\n", group);
 250                         irreco_keyfile_set_group(keyfile, group);
 251                         irreco_config_read_button_from_keyfile(irreco_data,
 252                                                                keyfile);
 253                 }
 254         }
 255
 256         /* Read Hardkeys. */
 257         for (i = 0; i < group_count; i++) {
 258                 gchar *group = groups[i];
 259                 if (g_str_has_prefix(group, "hardkey")) {
 260                         IRRECO_PRINTF("Reading hardkey group \"%s\"\n", group);
 261                         irreco_keyfile_set_group(keyfile, group);
 262                         irreco_config_read_hardkey_from_keyfile(irreco_data,
 263                                                                 keyfile);
 264                 }
 265         }
 266
 267         /*
 268          * Read LEGACY command group configuration.
 269          */
 270         {
 271         gchar *chain_config = irreco_get_config_file(
 272                 "irreco", irreco_config_cmd_chain_file);
 273         if (irreco_file_exists(chain_config) == FALSE) {
 274                 for (i = 0; i < group_count; i++) {
 275                         gchar *group = groups[i];
 276                         if (g_str_has_prefix(group, "command")) {
 277                                 IRRECO_PRINTF("Reading command group \"%s\"\n",
 278                                               group);
 279                                 irreco_keyfile_set_group(keyfile, group);
 280                                 irreco_config_read_command_from_keyfile(
 281                                         irreco_data, keyfile);
 282                         }
 283                 }
 284         }
 285         g_free(chain_config);
 286         }
 287
 288         /* Read command chains. */
 289         irreco_cmd_chain_manager_from_config(irreco_data);
 290
 291         g_strfreev(groups);
 292         irreco_keyfile_destroy(keyfile);
 293         g_free(config_dir);
 294         g_free(config_file);
 295         IRRECO_RETURN_BOOL(TRUE);
 296 }
 297
 298 void irreco_config_read_layout_from_keyfile(IrrecoData * irreco_data,
 299                                             IrrecoKeyFile * keyfile)
 300 {
 301         gchar *name = NULL;
 302         IrrecoButtonLayout *layout = NULL;
 303         GdkColor color;
 304         gint type;
 305         gchar *image = NULL;
 306         IRRECO_ENTER
 307
 308         /* Required fields. */
 309         if (!irreco_keyfile_get_str(keyfile, "name", &name)) IRRECO_RETURN
 310         layout = irreco_button_layout_create(NULL,
 311                                              irreco_data->cmd_chain_manager);
 312         irreco_button_layout_set_name(layout, name);
 313         g_free(name);
 314         name = NULL;
 315
 316         if (irreco_keyfile_get_int(keyfile, "bg-type", &type)) {
 317                 switch (type) {
 318                 case IRRECO_BACKGROUND_DEFAULT:
 319                 case IRRECO_BACKGROUND_COLOR:
 320                 case IRRECO_BACKGROUND_IMAGE:
 321                         irreco_button_layout_set_bg_type(layout, type);
 322                         break;
 323
 324                 default:
 325                         IRRECO_ERROR("Unknown background type \"%i\".\n",
 326                                      type);
 327                         break;
 328                 }
 329         }
 330
 331         if (irreco_keyfile_get_str(keyfile, "bg-image", &image)) {
 332                 irreco_button_layout_set_bg_image(layout, image);
 333                 g_free(image);
 334                 image = NULL;
 335         }
 336
 337         color.pixel = 0;
 338         if (irreco_keyfile_get_uint16(keyfile, "bg-color-red", &color.red) &&
 339             irreco_keyfile_get_uint16(keyfile, "bg-color-green", &color.green)&&
 340             irreco_keyfile_get_uint16(keyfile, "bg-color-blue", &color.blue)) {
 341                 irreco_button_layout_set_bg_color(layout, &color);
 342         }
 343
 344         if (!irreco_string_table_add(irreco_data->irreco_layout_array,
 345                                     irreco_button_layout_get_name(layout),
 346                                     layout)) {
 347                 IRRECO_ERROR("Layout \"%s\" already exists.",
 348                              irreco_button_layout_get_name(layout));
 349                 irreco_button_layout_destroy(layout);
 350         }
 351
 352         IRRECO_RETURN
 353 }
 354
 355 void irreco_config_read_button_from_keyfile(IrrecoData * irreco_data,
 356                                             IrrecoKeyFile * keyfile)
 357 {
 358         gchar *layout_name = NULL;
 359         gchar *style_name = NULL;
 360         gchar *title = NULL;
 361         gchar *command = NULL;
 362         IrrecoCmdChainId chain_id;
 363         gint x;
 364         gint y;
 365
 366         IrrecoButton *button = NULL;
 367         IrrecoButtonLayout *layout = NULL;
 368         IrrecoThemeButton *style = NULL;
 369         IRRECO_ENTER
 370
 371         /* Required fields. */
 372         if (!irreco_keyfile_get_int(keyfile, "x", &x) ||
 373             !irreco_keyfile_get_int(keyfile, "y", &y) ||
 374             !irreco_keyfile_get_str(keyfile, "layout", &layout_name)) {
 375                 IRRECO_RETURN
 376         }
 377         IRRECO_PRINTF("Position: x%i y%i\n", x, y);
 378
 379         /* Find layout. */
 380         if (!irreco_string_table_get(irreco_data->irreco_layout_array,
 381                                     layout_name, (gpointer *) &layout)) {
 382                 IRRECO_ERROR("Button uses unknown layout \"%s\"\n",
 383                              layout_name);
 384                 g_free(layout_name);
 385                 IRRECO_RETURN
 386         }
 387         g_free(layout_name);
 388         IRRECO_PRINTF("Style: \"%s\"\n",
 389                       irreco_button_layout_get_name(layout));
 390
 391         /* Find style. */
 392         irreco_keyfile_get_str(keyfile, "style", &style_name);
 393         if (style_name != NULL) {
 394                 if (irreco_theme_manager_get_button_style(
 395                                                 irreco_data->theme_manager,
 396                                                 style_name, &style)) {
 397                         IRRECO_LINE
 398                         IRRECO_PRINTF("Style: \"%s\"\n", style->name->str);
 399                 } else {
 400                         IRRECO_ERROR("Button uses unknown style \"%s\"\n",
 401                                      style_name);
 402                 }
 403
 404                 g_free(style_name);
 405         }
 406
 407         /* Get title and command. */
 408         irreco_keyfile_get_str(keyfile, "title", &title);
 409         IRRECO_PRINTF("title: \"%s\"\n", title);
 410
 411         button = irreco_button_create(layout, x, y, title, style,
 412                                       irreco_data->cmd_chain_manager);
 413
 414         if (irreco_keyfile_get_int(keyfile, "command-chain-id", &chain_id)) {
 415                 irreco_button_set_cmd_chain_id(button, chain_id);
 416         }
 417
 418         g_free(title);
 419         g_free(command);
 420         IRRECO_RETURN
 421 }
 422
 423 void irreco_config_read_hardkey_from_keyfile(IrrecoData * irreco_data,
 424                                              IrrecoKeyFile * keyfile)
 425 {
 426         IrrecoButtonLayout *layout = NULL;
 427         gchar *layout_name = NULL;
 428         IrrecoCmdChainId id;
 429         guint keyval;
 430         gchar *hardkey_str = NULL;
 431         IRRECO_ENTER
 432
 433         /* Required fields. */
 434         if (!irreco_keyfile_get_str(keyfile, "layout", &layout_name) ||
 435             !irreco_keyfile_get_int(keyfile, "chain-id", &id) ||
 436             !irreco_keyfile_get_uint(keyfile, "key-value", &keyval)) {
 437                 g_free(layout_name);
 438                 IRRECO_RETURN
 439         }
 440
 441         /* Find layout. */
 442         if (!irreco_string_table_get(irreco_data->irreco_layout_array,
 443                                      layout_name, (gpointer *) &layout)) {
 444                 IRRECO_ERROR("Hardkey uses unknown layout \"%s\"\n",
 445                              layout_name);
 446                 g_free(layout_name);
 447                 IRRECO_RETURN
 448         }
 449         g_free(layout_name);
 450
 451         hardkey_str = irreco_hardkey_to_str(keyval);
 452         IRRECO_PRINTF("Associating layout \"%s\" hardkey \"%s\" with "
 453                       "command chain \"%i\".\n",
 454                       irreco_button_layout_get_name(layout),
 455                       hardkey_str, id);
 456         g_free(hardkey_str);
 457
 458         irreco_hardkey_map_assosiate_chain_with_id(layout->hardkey_map,
 459                                                    keyval, id);
 460         IRRECO_RETURN
 461 }
 462
 463 /**
 464  * Support LEGACY configuration.
 465  *
 466  * This still exists in order to read layout configs from old versions of
 467  * irreco.
 468  *
 469  * TODO: Remove sometime next year.
 470  */
 471 void irreco_config_read_command_from_keyfile(IrrecoData * irreco_data,
 472                                              IrrecoKeyFile * keyfile)
 473 {
 474         gint button_index;
 475         IrrecoCmdType type;
 476         gchar *layout_name = NULL;
 477         gchar *type_name = NULL;
 478
 479         IrrecoCmd *command;
 480         IrrecoButton *button;
 481         IrrecoButtonLayout *layout;
 482         IRRECO_ENTER
 483
 484         if (!irreco_keyfile_get_str(keyfile, "layout", &layout_name) ||
 485             !irreco_keyfile_get_str(keyfile, "type",   &type_name) ||
 486             !irreco_keyfile_get_int(keyfile, "button", &button_index)) {
 487                 g_free(layout_name);
 488                 g_free(type_name);
 489                 IRRECO_RETURN
 490         }
 491
 492         /* Convert type name to type ID. */
 493         if ((type = irreco_cmd_str_to_type(type_name)) == -1) {
 494                 IRRECO_ERROR("Unknown command type \"%s\"\n", type_name);
 495                 g_free(layout_name);
 496                 g_free(type_name);
 497                 IRRECO_RETURN
 498         }
 499         g_free(type_name);
 500
 501         /* Find layout. */
 502         if (!irreco_string_table_get(irreco_data->irreco_layout_array,
 503                                      layout_name, (gpointer *) &layout)) {
 504                 IRRECO_ERROR("Unknown layout \"%s\"\n", layout_name);
 505                 g_free(layout_name);
 506                 IRRECO_RETURN
 507         }
 508         g_free(layout_name);
 509
 510         /* Find Button. */
 511         if (button_index >= layout->button_array->len) {
 512                 IRRECO_ERROR("Invalid button index \"%i\"\n", button_index);
 513                 IRRECO_RETURN
 514         }
 515         button = g_ptr_array_index(layout->button_array, button_index);
 516
 517         /* Append command to button command chain. */
 518         switch (type) {
 519         case IRRECO_COMMAND_NONE:
 520         case IRRECO_COMMAND_NEXT_REMOTE:
 521         case IRRECO_COMMAND_PREVIOUS_REMOTE:
 522         case IRRECO_COMMAND_FULLSCREEN_TOGGLE:
 523                 command = irreco_cmd_create();
 524                 irreco_cmd_set_builtin(command, type);
 525                 irreco_cmd_chain_append(irreco_button_get_cmd_chain(button),
 526                                         command);
 527                 break;
 528
 529         case IRRECO_COMMAND_BACKEND: {
 530                 gchar *instance_name = NULL;
 531                 gchar *device_name = NULL;
 532                 gchar *command_name = NULL;
 533                 IrrecoBackendInstance * backend_instance;
 534
 535                 if (!irreco_keyfile_get_str(keyfile, "instance-name",
 536                                              &instance_name) ||
 537                     !irreco_keyfile_get_str(keyfile, "device-name",
 538                                              &device_name) ||
 539                     !irreco_keyfile_get_str(keyfile, "command-name",
 540                                              &command_name)) {
 541                         g_free(instance_name);
 542                         g_free(device_name);
 543                         g_free(command_name);
 544                         IRRECO_RETURN
 545                 }
 546
 547                 if (!irreco_backend_manager_find_instance(
 548                         irreco_data->irreco_backend_manager,
 549                         instance_name,
 550                         &backend_instance)) {
 551                         IRRECO_ERROR("Could not find instance with name "
 552                                      "\"%s\"\n", instance_name);
 553                         IRRECO_RETURN
 554                 }
 555                 command = irreco_cmd_create();
 556                 irreco_cmd_set_backend(command,
 557                                        backend_instance,
 558                                        device_name,
 559                                        command_name);
 560                 irreco_cmd_chain_append(irreco_button_get_cmd_chain(button),
 561                                         command);
 562
 563                 g_free(instance_name);
 564                 g_free(device_name);
 565                 g_free(command_name);
 566                 } break;
 567
 568         case IRRECO_COMMAND_SHOW_LAYOUT: {
 569                 gchar *show_layout;
 570                 if (!irreco_keyfile_get_str(keyfile, "show-layout",
 571                                              &show_layout)) {
 572                         IRRECO_RETURN
 573                 }
 574
 575                 command = irreco_cmd_create();
 576                 irreco_cmd_set_layout(command, show_layout);
 577                 irreco_cmd_chain_append(irreco_button_get_cmd_chain(button),
 578                                         command);
 579                 g_free(show_layout);
 580                 } break;
 581
 582         case IRRECO_COMMAND_WAIT: {
 583                 guint delay;
 584                 if (!irreco_keyfile_get_uint(keyfile, "delay", &delay)) {
 585                         IRRECO_RETURN
 586                 }
 587
 588                 command = irreco_cmd_create();
 589                 irreco_cmd_set_wait(command, delay);
 590                 irreco_cmd_chain_append(irreco_button_get_cmd_chain(button),
 591                                         command);
 592                 } break;
 593         }
 594
 595         IRRECO_RETURN
 596 }
 597
 598
 599 /** @} */
 600
 601
 602
 603 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 604 /* Layout saving.                                                             */
 605 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 606
 607 /**
 608  * @name Layout saving
 609  * @{
 610  */
 611
 612 /**
 613  * Save layout.
 614  *
 615  * Since GKeyFile does not allow two groups with the same name,
 616  * layout_index and button_index variables are used to make sure that each
 617  * button and layout group has unique name. The index is ignored when reading
 618  * the layout config.
 619  */
 620 gboolean irreco_config_save_layouts(IrrecoData * irreco_data)
 621 {
 622         gint layout_index = 1;
 623         gint button_index = 1;
 624         gint command_index = 1;
 625         gint hardkey_index = 1;
 626         GKeyFile *keyfile;
 627         IrrecoStringTable *table;
 628         gboolean success;
 629         IRRECO_ENTER
 630
 631         irreco_cmd_chain_manager_to_config(irreco_data->cmd_chain_manager);
 632
 633         keyfile = g_key_file_new();
 634         table = irreco_data->irreco_layout_array;
 635         IRRECO_STRING_TABLE_FOREACH(table, key, IrrecoButtonLayout *, layout)
 636                 irreco_config_save_layout_to_keyfile(keyfile,
 637                                                      layout,
 638                                                      &layout_index,
 639                                                      &button_index,
 640                                                      &command_index,
 641                                                      &hardkey_index);
 642                 layout_index++;
 643         IRRECO_STRING_TABLE_FOREACH_END
 644
 645         success = irreco_gkeyfile_write_to_config_file(keyfile, "irreco",
 646                                                      irreco_config_layout_file);
 647         g_key_file_free(keyfile);
 648         IRRECO_RETURN_BOOL(success);
 649 }
 650
 651 typedef struct _IrrecoConfigSaveHardkeyData IrrecoConfigSaveHardkeyData;
 652 struct _IrrecoConfigSaveHardkeyData {
 653         GKeyFile *keyfile;
 654         gint *hardkey_index;
 655         IrrecoButtonLayout *layout;
 656 };
 657
 658 void irreco_config_save_layout_to_keyfile(GKeyFile * keyfile,
 659                                           IrrecoButtonLayout * layout,
 660                                           gint * layout_index,
 661                                           gint * button_index,
 662                                           gint * command_index,
 663                                           gint * hardkey_index)
 664 {
 665         GdkColor *color;
 666         gchar group[IRRECO_CONFIG_GROUP_LEN];
 667         IrrecoConfigSaveHardkeyData hardkey_data;
 668         IRRECO_ENTER
 669
 670         /* Save layout. */
 671         g_assert(irreco_button_layout_get_name(layout) != NULL);
 672         g_snprintf(group, IRRECO_CONFIG_GROUP_LEN, "layout-%i", *layout_index);
 673         irreco_gkeyfile_set_string(keyfile, group, "name",
 674                                  irreco_button_layout_get_name(layout));
 675         g_key_file_set_integer(keyfile, group, "bg-type",
 676                                irreco_button_layout_get_bg_type(layout));
 677         irreco_gkeyfile_set_string(keyfile, group, "bg-image",
 678                                  irreco_button_layout_get_bg_image(layout));
 679         color = irreco_button_layout_get_bg_color(layout);
 680         g_key_file_set_integer(keyfile, group, "bg-color-red", color->red);
 681         g_key_file_set_integer(keyfile, group, "bg-color-green", color->green);
 682         g_key_file_set_integer(keyfile, group, "bg-color-blue", color->blue);
 683
 684         /* Save buttons. */
 685         irreco_button_layout_reindex(layout);
 686         IRRECO_PTR_ARRAY_FORWARDS(layout->button_array, IrrecoButton *, button)
 687                 irreco_config_save_button_to_keyfile(keyfile,
 688                                                      button,
 689                                                      button_index,
 690                                                      command_index);
 691                 *button_index = *button_index + 1;
 692         IRRECO_PTR_ARRAY_FORWARDS_END
 693
 694         /* Save Hardkeys. */
 695         hardkey_data.keyfile = keyfile;
 696         hardkey_data.hardkey_index = hardkey_index;
 697         hardkey_data.layout = layout;
 698         irreco_hardkey_map_chain_foreach(layout->hardkey_map,
 699                                          irreco_config_save_hardkey_to_file,
 700                                          &hardkey_data);
 701         IRRECO_RETURN
 702 }
 703
 704 void irreco_config_save_hardkey_to_file(IrrecoHardkeyMap *hardkey_map,
 705                                         guint             keyval,
 706                                         IrrecoCmdChainId  chain_id,
 707                                         IrrecoCmdChain   *chain,
 708                                         gpointer          user_data)
 709 {
 710         gchar group[IRRECO_CONFIG_GROUP_LEN];
 711         IrrecoConfigSaveHardkeyData *hardkey_data;
 712         IRRECO_ENTER
 713
 714         hardkey_data = (IrrecoConfigSaveHardkeyData*) user_data;
 715
 716         g_snprintf(group, IRRECO_CONFIG_GROUP_LEN, "hardkey-%i",
 717                    *hardkey_data->hardkey_index);
 718         irreco_gkeyfile_set_string(hardkey_data->keyfile, group, "layout",
 719                 irreco_button_layout_get_name(hardkey_data->layout));
 720         g_key_file_set_integer(hardkey_data->keyfile, group,
 721                                "chain-id", chain_id);
 722         irreco_gkeyfile_set_guint(hardkey_data->keyfile, group,
 723                                   "key-value", keyval);
 724
 725         *hardkey_data->hardkey_index = *hardkey_data->hardkey_index + 1;
 726         IRRECO_RETURN
 727 }
 728
 729 void irreco_config_save_button_to_keyfile(GKeyFile * keyfile,
 730                                           IrrecoButton * button,
 731                                           gint * button_index,
 732                                           gint * command_index)
 733 {
 734         gchar group[IRRECO_CONFIG_GROUP_LEN];
 735         IRRECO_ENTER
 736
 737         g_snprintf(group, IRRECO_CONFIG_GROUP_LEN, "button-%i", *button_index);
 738         irreco_gkeyfile_set_string(keyfile, group, "layout",
 739                 irreco_button_layout_get_name(button->irreco_layout));
 740         irreco_gkeyfile_set_string(keyfile, group, "title", button->title);
 741         g_key_file_set_integer(keyfile, group, "index", button->index);
 742         g_key_file_set_integer(keyfile, group, "command-chain-id",
 743                                button->cmd_chain_id);
 744         g_key_file_set_integer(keyfile, group, "x", button->x);
 745         g_key_file_set_integer(keyfile, group, "y", button->y);
 746
 747         /* It is valid for a button to have NULL style. */
 748         if (button->style != NULL) {
 749                 irreco_gkeyfile_set_string(keyfile, group, "style",
 750                                       button->style->style_name->str);
 751         }
 752
 753         IRRECO_RETURN
 754 }
 755
 756 /** @} */
 757
 758
 759
 760 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 761 /* Save / Read active layout.                                                 */
 762 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 763
 764 /**
 765  * @name Save / Read active layout
 766  * @{
 767  */
 768
 769 gboolean irreco_config_save_active_layout(IrrecoButtonLayout * irreco_layout)
 770 {
 771         GKeyFile *keyfile;
 772         gboolean success;
 773         IRRECO_ENTER
 774
 775         keyfile = g_key_file_new();
 776         if (irreco_layout != NULL) {
 777                 irreco_gkeyfile_set_string(keyfile, "active-layout", "name",
 778                         irreco_button_layout_get_name(irreco_layout));
 779         }
 780         success = irreco_gkeyfile_write_to_config_file(keyfile, "irreco",
 781                                               irreco_config_active_layout_file);
 782         g_key_file_free(keyfile);
 783         IRRECO_RETURN_BOOL(success);
 784 }
 785
 786 IrrecoButtonLayout *irreco_config_read_active_layout(IrrecoData * irreco_data)
 787 {
 788         IrrecoKeyFile *keyfile = NULL;
 789         gchar *config_dir = NULL;
 790         gchar *config_file = NULL;
 791         gchar *name = NULL;
 792         IrrecoButtonLayout *irreco_layout = NULL;
 793         IRRECO_ENTER
 794
 795         /* Attempt to read layout name, and find layout with the same name. */
 796         config_dir = irreco_get_config_dir("irreco");
 797         config_file = irreco_get_config_file("irreco",
 798                                              irreco_config_active_layout_file);
 799         keyfile = irreco_keyfile_create(config_dir, config_file, NULL);
 800         if (config_dir != NULL && config_file != NULL && keyfile != NULL
 801             && irreco_keyfile_set_group(keyfile, "active-layout")
 802             && irreco_keyfile_get_str(keyfile, "name", &name)) {
 803
 804                 IRRECO_DEBUG("Read active layout name \"%s\" from \"%s\".\n",
 805                           name, irreco_config_active_layout_file);
 806
 807                 if (irreco_string_table_get(irreco_data->irreco_layout_array,
 808                                             name, (gpointer *) &irreco_layout)){
 809                         IRRECO_DEBUG("Found matching layout.\n");
 810                 } else {
 811                         IRRECO_DEBUG("No matching layout found.\n");
 812                 }
 813         }
 814
 815         irreco_keyfile_destroy(keyfile);
 816         g_free(name);
 817         g_free(config_dir);
 818         g_free(config_file);
 819
 820         /* If we could not find correct active layout,
 821            attempt to get some layout.*/
 822         if (irreco_layout == NULL) {
 823                 irreco_string_table_index(irreco_data->irreco_layout_array, 0,
 824                                           NULL, (gpointer *) &irreco_layout);
 825         }
 826         IRRECO_RETURN_PTR(irreco_layout);
 827 }
 828
 829 /** @} */
 830
 831
 832
 833 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 834 /* Save / Read backend configuration.                                         */
 835 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 836
 837 /**
 838  * @name Save / Read backend configuration
 839  * @{
 840  */
 841
 842 gboolean irreco_config_save_backends(IrrecoBackendManager * backend_manager)
 843 {
 844         gint i = 0;
 845         GKeyFile *keyfile;
 846         gboolean success;
 847         gchar group[IRRECO_CONFIG_GROUP_LEN];
 848         IRRECO_ENTER
 849
 850         keyfile = g_key_file_new();
 851         IRRECO_BACKEND_MANAGER_FOREACH_INSTANCE(backend_manager, instance)
 852                 g_snprintf(group, IRRECO_CONFIG_GROUP_LEN, "instance-%i", ++i);
 853                 irreco_gkeyfile_set_string(keyfile, group, "library",
 854                                          instance->lib->filename);
 855                 irreco_gkeyfile_set_string(keyfile, group, "config",
 856                                          instance->config);
 857                 irreco_gkeyfile_set_string(keyfile, group, "name",
 858                                          instance->name);
 859         IRRECO_BACKEND_MANAGER_FOREACH_END
 860
 861         success = irreco_gkeyfile_write_to_config_file(keyfile, "irreco",
 862                                                     irreco_config_backend_file);
 863         g_key_file_free(keyfile);
 864         IRRECO_RETURN_BOOL(success);
 865 }
 866
 867 gboolean irreco_config_read_backends(IrrecoBackendManager * manager)
 868 {
 869         guint i;
 870         IrrecoKeyFile *keyfile = NULL;
 871         gchar *config_dir = NULL;
 872         gchar *config_file = NULL;
 873         gchar** groups = NULL;
 874         gsize group_count = 0;
 875         IRRECO_ENTER
 876
 877         config_dir = irreco_get_config_dir("irreco");
 878         config_file = irreco_get_config_file("irreco",
 879                                              irreco_config_backend_file);
 880         keyfile = irreco_keyfile_create(config_dir, config_file, NULL);
 881         if (config_dir == NULL || config_file == NULL || keyfile == NULL) {
 882                 g_free(config_dir);
 883                 g_free(config_file);
 884                 irreco_keyfile_destroy(keyfile);
 885                 IRRECO_RETURN_BOOL(FALSE);
 886         }
 887
 888         IRRECO_PRINTF("Reading backend configuration file \"%s\"\n",
 889                       config_file);
 890         groups = g_key_file_get_groups(keyfile->keyfile, &group_count);
 891
 892         /* Read instances. */
 893         for (i = 0; i < group_count; i++) {
 894                 gchar *group = groups[i];
 895                 if (g_str_has_prefix(group, "instance")) {
 896                         IRRECO_PRINTF("Reading instance group \"%s\"\n", group);
 897                         irreco_keyfile_set_group(keyfile, group);
 898                         irreco_config_read_backend_from_keyfile(manager,
 899                                                                 keyfile);
 900                 }
 901         }
 902
 903         g_strfreev(groups);
 904         irreco_keyfile_destroy(keyfile);
 905         g_free(config_dir);
 906         g_free(config_file);
 907         IRRECO_RETURN_BOOL(TRUE);
 908 }
 909
 910 void irreco_config_read_backend_from_keyfile(IrrecoBackendManager * manager,
 911                                              IrrecoKeyFile * keyfile)
 912 {
 913         gchar *library = NULL;
 914         gchar *config = NULL;
 915         gchar *name = NULL;
 916         IrrecoBackendLib *lib;
 917         IRRECO_ENTER
 918
 919         /* Read variables. */
 920         if (!irreco_keyfile_get_str(keyfile, "library", &library) ||
 921             !irreco_keyfile_get_str(keyfile, "config", &config) ||
 922             !irreco_keyfile_get_str(keyfile, "name", &name)) {
 923                 g_free(library);
 924                 g_free(config);
 925                 g_free(name);
 926                 IRRECO_RETURN
 927         }
 928
 929         /* Find library. */
 930         if (!irreco_backend_manager_find_lib(manager, library, &lib)) {
 931                 IRRECO_ERROR("Cannot find backend library \"%s\"\n", library);
 932                 g_free(library);
 933                 g_free(config);
 934                 g_free(name);
 935                 IRRECO_RETURN
 936         }
 937         g_free(library);
 938
 939         /* Create instance. */
 940         irreco_backend_manager_create_instance(manager, lib, name, config);
 941         g_free(name);
 942         g_free(config);
 943
 944         IRRECO_RETURN
 945 }
 946
 947 /** @} */
 948 /** @} */
 949