irreco/src/core/irreco_lircdb_dlg.c

   1 /*
   2  * irreco - Ir Remote Control
   3  * Copyright (C) 2007,2008  Arto Karppinen (arto.karppinen@iki.fi),
   4  * Joni Kokko (t5kojo01@students.oamk.fi),
   5  * Harri Vattulainen (t5vaha01@students.oamk.fi)
   6  * Sami Mäki (kasmra@xob.kapsi.fi)
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License
  10  * as published by the Free Software Foundation; either version 2
  11  * of the License, or (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 Foundation,
  20  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  21  */
  22
  23 #include "irreco_lircdb_dlg.h"
  24 #include <hildon/hildon-banner.h>
  25 #include "irreco_webdb_register_dlg.h"
  26 #include "irreco_select_instance_dlg.h"
  27 #include "irreco_config.h"
  28 #include <hildon/hildon-gtk.h>
  29 #include <hildon/hildon-pannable-area.h>
  30
  31
  32 /**
  33  * @addtogroup IrrecoLircdbDlg
  34  * @ingroup Irreco
  35  *
  36  * @todo PURPOSE OF CLASS.
  37  *
  38  * @{
  39  */
  40
  41 /**
  42  * @file
  43  * Source file of @ref IrrecoLircdbDlg.
  44  */
  45
  46
  47 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  48 /* Prototypes                                                                 */
  49 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  50 static void irreco_lircdb_dlg_clean_details(IrrecoLircdbDlg *self);
  51 static gboolean irreco_lircdb_dlg_loader_dirs(IrrecoLircdbDlg *self);
  52 static gboolean irreco_lircdb_dlg_loader_manuf(IrrecoLircdbDlg *self);
  53 static gboolean irreco_lircdb_dlg_loader_models(IrrecoLircdbDlg *self);
  54 static gboolean irreco_lircdb_dlg_ready_to_dl(IrrecoLircdbDlg *self,
  55                                                        GtkTreeIter * iter);
  56 static gboolean irreco_lircdb_dlg_load_file(IrrecoLircdbDlg *self);
  57
  58 static gboolean irreco_show_lircdb_dlg_map_event(IrrecoLircdbDlg *self,
  59                                                 GdkEvent  *event,
  60                                                 gpointer   user_data);
  61 static void irreco_show_lircdb_dlg_destroy_event(IrrecoLircdbDlg *self,
  62                                                 gpointer user_data);
  63 static void irreco_show_lircdb_dlg_row_activated_event(GtkTreeView *tree_view,
  64                                                       GtkTreePath *path,
  65                                                       GtkTreeViewColumn *column,
  66                                                       IrrecoLircdbDlg *self);
  67 static void irreco_show_lircdb_dlg_row_expanded_event(GtkTreeView *tree_view,
  68                                                      GtkTreeIter *iter,
  69                                                      GtkTreePath *path,
  70                                                      IrrecoLircdbDlg *self);
  71 static void irreco_show_lircdb_dlg_row_collapsed_event(GtkTreeView *tree_view,
  72                                                      GtkTreeIter *iter,
  73                                                      GtkTreePath *path,
  74                                                      IrrecoLircdbDlg *self);
  75 static void irreco_show_lircdb_dlg_row_selected_event(GtkTreeSelection *sel,
  76                                                      IrrecoLircdbDlg *self);
  77
  78
  79
  80
  81 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  82 /* Datatypes                                                                  */
  83 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  84
  85 /** Button response codes. */
  86 enum {
  87         IRRECO_DEVICE_REFRESH
  88 };
  89
  90 /** GtkTreeStore colums. */
  91 enum
  92 {
  93         TEXT_COL,
  94         FLAG_COL,
  95         DATA_COL,
  96         N_COLUMNS
  97 };
  98
  99 /** Loader states. */
 100 enum
 101 {
 102         LOADER_STATE_INIT,
 103         LOADER_STATE_LOOP,
 104         LOADER_STATE_END,
 105         LOADER_STATE_CLEANUP
 106 };
 107
 108 /** Row flags. */
 109 enum
 110 {
 111         ROW_CHILDREN_LOADED     = 1 << 1,
 112         ROW_TYPE_DIR            = 1 << 2,
 113         ROW_TYPE_MANUFACTURER   = 1 << 3,
 114         ROW_TYPE_MODEL          = 1 << 4,
 115         ROW_TYPE_LOADING        = 1 << 5
 116 };
 117
 118
 119
 120 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 121 /* Construction & Destruction                                                 */
 122 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 123
 124 /**
 125  * @name Construction & Destruction
 126  * @{
 127  */
 128
 129 G_DEFINE_TYPE(IrrecoLircdbDlg, irreco_lircdb_dlg, IRRECO_TYPE_DLG)
 130
 131 static void irreco_lircdb_dlg_finalize(GObject *object)
 132 {
 133         if (G_OBJECT_CLASS(irreco_lircdb_dlg_parent_class)->finalize)
 134                 G_OBJECT_CLASS(irreco_lircdb_dlg_parent_class)->finalize(object);
 135 }
 136
 137 static void irreco_lircdb_dlg_class_init(IrrecoLircdbDlgClass *klass)
 138 {
 139         GObjectClass *object_class = G_OBJECT_CLASS(klass);
 140         object_class->finalize = irreco_lircdb_dlg_finalize;
 141 }
 142
 143 static void irreco_lircdb_dlg_init(IrrecoLircdbDlg *self)
 144 {
 145         GtkTreeViewColumn *column;
 146         GtkCellRenderer *renderer;
 147         GtkTreeSelection *select;
 148         GtkWidget *tree_view_frame;
 149         GtkWidget *tree_view_pannable;
 150         GtkWidget *tree_box;
 151
 152         IRRECO_ENTER
 153
 154         self->download_button = gtk_button_new_with_label("Download");
 155
 156         /* Construct dialog. */
 157         gtk_window_set_title(GTK_WINDOW(self),
 158                              _("Download device from LircDB"));
 159         gtk_window_set_modal(GTK_WINDOW(self), TRUE);
 160         gtk_window_set_destroy_with_parent(GTK_WINDOW(self), TRUE);
 161         gtk_dialog_set_has_separator(GTK_DIALOG(self), FALSE);
 162
 163         self->download_button = gtk_dialog_add_button(GTK_DIALOG(self),
 164                                 _("Download"), GTK_RESPONSE_OK);
 165         /* Create hbox */
 166         self->hbox = g_object_new(GTK_TYPE_HBOX, NULL);
 167         gtk_box_set_spacing(GTK_BOX(self->hbox), 8);
 168         gtk_container_add(GTK_CONTAINER(GTK_DIALOG(self)->vbox),
 169                           irreco_gtk_align(GTK_WIDGET(self->hbox),
 170                                            0, 0, 1, 1, 8, 8, 8, 8));
 171         /* Create tree_view_hbox */
 172         tree_box = gtk_hbox_new(FALSE, 2);
 173         tree_view_pannable = hildon_pannable_area_new();
 174
 175         /* Create Treeview */
 176         self->tree_store = gtk_tree_store_new(
 177                 N_COLUMNS, G_TYPE_STRING, G_TYPE_INT, G_TYPE_POINTER);
 178         self->tree_view = GTK_TREE_VIEW(hildon_gtk_tree_view_new_with_model(1,
 179                 GTK_TREE_MODEL(self->tree_store)));
 180
 181         renderer = gtk_cell_renderer_text_new();
 182         column = gtk_tree_view_column_new_with_attributes(
 183                 NULL, renderer, "text", TEXT_COL, NULL);
 184         gtk_tree_view_append_column(self->tree_view, column);
 185
 186         gtk_box_pack_start(GTK_BOX(tree_box), GTK_WIDGET(self->tree_view),
 187                                            TRUE, TRUE, 0);
 188
 189         hildon_pannable_area_add_with_viewport(HILDON_PANNABLE_AREA(tree_view_pannable),
 190                                                GTK_WIDGET(tree_box));
 191
 192         /* Create Frame for Treeview */
 193         tree_view_frame = gtk_frame_new("");
 194         gtk_frame_set_label_widget(GTK_FRAME(tree_view_frame),
 195                 irreco_gtk_label_bold("Devices", 0, 0, 0, 0, 0, 0));
 196
 197         gtk_container_add(GTK_CONTAINER(tree_view_frame),
 198                           GTK_WIDGET(tree_view_pannable));
 199
 200         gtk_box_pack_start(GTK_BOX(self->hbox), GTK_WIDGET(tree_view_frame),
 201                            TRUE, TRUE, 0);
 202
 203         /* Setup the selection handler for TREE */
 204         select = gtk_tree_view_get_selection(self->tree_view);
 205         gtk_tree_selection_set_mode(select, GTK_SELECTION_SINGLE);
 206
 207         /* Signal handlers. */
 208         g_signal_connect(G_OBJECT(self), "map-event",
 209                          G_CALLBACK(irreco_show_lircdb_dlg_map_event), NULL);
 210         g_signal_connect(G_OBJECT(self), "destroy",
 211                          G_CALLBACK(irreco_show_lircdb_dlg_destroy_event), NULL);
 212         g_signal_connect(G_OBJECT(self->tree_view), "row-activated",
 213                          G_CALLBACK(irreco_show_lircdb_dlg_row_activated_event),
 214                          self);
 215         g_signal_connect(G_OBJECT(self->tree_view), "row-expanded",
 216                          G_CALLBACK(irreco_show_lircdb_dlg_row_expanded_event),
 217                          self);
 218         g_signal_connect(G_OBJECT(self->tree_view), "row-collapsed",
 219                          G_CALLBACK(irreco_show_lircdb_dlg_row_collapsed_event),
 220                          self);
 221         g_signal_connect(G_OBJECT (select), "changed",
 222                          G_CALLBACK (irreco_show_lircdb_dlg_row_selected_event),
 223                          self);
 224
 225
 226         gtk_tree_view_set_enable_tree_lines(self->tree_view, TRUE);
 227         g_object_set (G_OBJECT (self->tree_view), "show-expanders", TRUE, NULL);
 228         /*g_object_set (G_OBJECT (self->tree_view), "level-indentation", 0, NULL);
 229         gtk_tree_view_set_rubber_banding(self->tree_view, FALSE);*/
 230
 231         gtk_widget_set_size_request(GTK_WIDGET(self), -1, 335);
 232         gtk_widget_show_all(GTK_WIDGET(self));
 233         gtk_widget_hide(self->download_button);
 234         IRRECO_RETURN
 235 }
 236
 237 GtkWidget *irreco_lircdb_dlg_new(IrrecoData *irreco_data,
 238                                 GtkWindow *parent)
 239 {
 240         IrrecoLircdbDlg *self;
 241         IRRECO_ENTER
 242
 243         self = g_object_new(IRRECO_TYPE_LIRCDB_DLG, NULL);
 244         irreco_dlg_set_parent(IRRECO_DLG(self), parent);
 245         irreco_lircdb_dlg_set_irreco_data(self, irreco_data);
 246         IRRECO_RETURN_PTR(self);
 247 }
 248
 249 /** @} */
 250
 251
 252
 253 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 254 /* Private Functions                                                          */
 255 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 256
 257 /**
 258  * @name Private Functions
 259  * @{
 260  */
 261
 262 /**
 263  * Clean detail list
 264  *
 265  */
 266 static void irreco_lircdb_dlg_clean_details(IrrecoLircdbDlg *self)
 267 {
 268         IRRECO_ENTER
 269
 270         self->config = NULL;
 271
 272         gtk_widget_hide(self->download_button);
 273
 274         IRRECO_RETURN
 275 }
 276
 277 /**
 278  * Have the childern of this item been loaded.
 279  *
 280  * @return TRUE if children have been loade, FALSE otherwise.
 281  */
 282 static gboolean irreco_lircdb_dlg_row_is_loaded(IrrecoLircdbDlg *self,
 283                                                GtkTreeIter *iter)
 284 {
 285         gint i;
 286         IRRECO_ENTER
 287
 288         gtk_tree_model_get(GTK_TREE_MODEL(self->tree_store),
 289                            iter, FLAG_COL, &i, -1);
 290         if (i & ROW_CHILDREN_LOADED) IRRECO_RETURN_BOOL(TRUE);
 291         IRRECO_RETURN_BOOL(FALSE);
 292 }
 293
 294 /**
 295  * Enable / Disable ROW_CHILDREN_LOADED flag from a row.
 296  *
 297  * @param value If set, ROW_CHILDREN_LOADED will be enabled.
 298  */
 299 static void irreco_lircdb_dlg_row_set_loaded(IrrecoLircdbDlg *self,
 300                                             GtkTreeIter *iter,
 301                                             gboolean value)
 302 {
 303         gint i;
 304         IRRECO_ENTER
 305
 306         gtk_tree_model_get(GTK_TREE_MODEL(self->tree_store),
 307                            iter, FLAG_COL, &i, -1);
 308         if (value) {
 309                 i = i | ROW_CHILDREN_LOADED;
 310         } else {
 311                 i = i & ~ROW_CHILDREN_LOADED;
 312         }
 313         gtk_tree_store_set(self->tree_store, iter, FLAG_COL, i, -1);
 314
 315         IRRECO_RETURN
 316 }
 317
 318 /**
 319  * Get type of row.
 320  */
 321 static gint irreco_lircdb_dlg_row_get_type(IrrecoLircdbDlg *self,
 322                                           GtkTreeIter *iter)
 323 {
 324         gint i;
 325         IRRECO_ENTER
 326
 327         gtk_tree_model_get(GTK_TREE_MODEL(self->tree_store),
 328                            iter, FLAG_COL, &i, -1);
 329         if (i & ROW_TYPE_DIR)
 330                 IRRECO_RETURN_ENUM(ROW_TYPE_DIR);
 331         if (i & ROW_TYPE_MANUFACTURER)
 332                 IRRECO_RETURN_ENUM(ROW_TYPE_MANUFACTURER);
 333         if (i & ROW_TYPE_MODEL)
 334                 IRRECO_RETURN_ENUM(ROW_TYPE_MODEL);
 335         if (i & ROW_TYPE_LOADING)
 336                 IRRECO_RETURN_ENUM(ROW_TYPE_LOADING);
 337         IRRECO_RETURN_INT(0);
 338 }
 339
 340 /**
 341  * Show hildon progressbar banner.
 342  *
 343  * This function will create a new banner if one has not been created yet,
 344  * if banner already exists, it's properties will be changed.
 345  *
 346  * @param text          Text to show.
 347  * @param fraction      Value of progress.
 348  */
 349 static void irreco_lircdb_dlg_set_banner(IrrecoLircdbDlg *self,
 350                                         const gchar *text,
 351                                         gdouble fraction)
 352 {
 353         IRRECO_ENTER
 354         if (self->banner == NULL) {
 355                 self->banner = hildon_banner_show_progress(
 356                         GTK_WIDGET(self), NULL, "");
 357         }
 358
 359         hildon_banner_set_text(HILDON_BANNER(self->banner), text);
 360         hildon_banner_set_fraction(HILDON_BANNER(self->banner), fraction);
 361         IRRECO_RETURN
 362 }
 363
 364 /**
 365  * Destroy banner, if it exists.
 366  */
 367 static void irreco_lircdb_dlg_hide_banner(IrrecoLircdbDlg *self)
 368 {
 369         IRRECO_ENTER
 370         if (self->banner) {
 371                 gtk_widget_destroy(self->banner);
 372                 self->banner = NULL;
 373         }
 374         IRRECO_RETURN
 375 }
 376
 377 /**
 378  * Start a loader state machine if one is not running already.
 379  */
 380 static void irreco_lircdb_dlg_loader_start(IrrecoLircdbDlg *self,
 381                                           GSourceFunc function,
 382                                           GtkTreeIter *parent_iter)
 383 {
 384         IRRECO_ENTER
 385
 386         if (self->loader_func_id == 0) {
 387                 if (parent_iter) {
 388                         self->loader_parent_iter = gtk_tree_iter_copy(
 389                                 parent_iter);
 390                 }
 391
 392                 if (function) {
 393                         self->loader_func_id = g_idle_add(function, self);
 394                 } else {
 395                         IRRECO_ERROR("Loader function pointer not given.\n");
 396                 }
 397         }
 398
 399         IRRECO_RETURN
 400 }
 401
 402 /**
 403  * Stop and cleanup loader if a loader is running.
 404  */
 405 static void irreco_lircdb_dlg_loader_stop(IrrecoLircdbDlg *self)
 406 {
 407         IRRECO_ENTER
 408         if (self->loader_func_id != 0) {
 409                 g_source_remove(self->loader_func_id);
 410                 self->loader_func_id = 0;
 411                 self->loader_state = 0;
 412                 if (self->loader_parent_iter) {
 413                         gtk_tree_iter_free(self->loader_parent_iter);
 414                 }
 415                 self->loader_parent_iter = NULL;
 416         }
 417         IRRECO_RETURN
 418 }
 419
 420 /**
 421  * Load Lircdb directories.
 422  *
 423  * This loader will request a list of directories from the Lircdb server and
 424  * update the TreeView accordingly. Every directory row created by this loader
 425  * will have row type ROW_TYPE_DIR.
 426  */
 427 static gboolean irreco_lircdb_dlg_loader_dirs(IrrecoLircdbDlg *self)
 428 {
 429         IRRECO_ENTER
 430
 431         switch (self->loader_state) {
 432         case LOADER_STATE_INIT:
 433                 irreco_lircdb_dlg_set_banner(self, _("Loading ..."), 0);
 434                 self->loader_state = LOADER_STATE_LOOP;
 435                 irreco_lircdb_dlg_clean_details(self);
 436                 IRRECO_RETURN_BOOL(TRUE);
 437
 438         case LOADER_STATE_LOOP: {
 439                 GtkTreeIter iter;
 440                 GtkTreeIter iter_loading;
 441                 IrrecoStringTable *dirs = NULL;
 442                 IrrecoWebdbCache *webdb_cache = NULL;
 443
 444                 gtk_widget_hide(self->download_button);
 445
 446                 webdb_cache = irreco_data_get_webdb_cache(self->irreco_data,
 447                                                           FALSE);
 448                 if(irreco_webdb_cache_get_lirc_dirs(webdb_cache, &dirs)){
 449                         IRRECO_STRING_TABLE_FOREACH_KEY(dirs, key)
 450
 451                                 /* Append directory */
 452                                 gtk_tree_store_append(self->tree_store,
 453                                                       &iter, NULL);
 454                                 gtk_tree_store_set(self->tree_store,
 455                                                    &iter, TEXT_COL, key,
 456                                                    FLAG_COL, ROW_TYPE_DIR,
 457                                                    DATA_COL, NULL, -1);
 458
 459                                 /* Add loading item into directory */
 460                                 gtk_tree_store_append(self->tree_store,
 461                                                       &iter_loading, &iter);
 462                                 gtk_tree_store_set(self->tree_store,
 463                                                    &iter_loading,
 464                                                    TEXT_COL, _("Loading ..."),
 465                                                    FLAG_COL, ROW_TYPE_LOADING,
 466                                                    DATA_COL, NULL, -1);
 467                         IRRECO_STRING_TABLE_FOREACH_END
 468                 } else {
 469                         irreco_error_dlg(GTK_WINDOW(self),
 470                                          irreco_webdb_cache_get_error(
 471                                          webdb_cache));
 472                 }
 473
 474                 irreco_lircdb_dlg_set_banner(self, _("Loading ..."), 1);
 475                 self->loader_state = LOADER_STATE_END;
 476                 IRRECO_RETURN_BOOL(TRUE);
 477                 }
 478
 479         case LOADER_STATE_END:
 480                 irreco_lircdb_dlg_hide_banner(self);
 481                 irreco_lircdb_dlg_loader_stop(self);
 482         }
 483
 484         IRRECO_RETURN_BOOL(FALSE);
 485 }
 486
 487 /**
 488  * Load Lircdb manufacturers
 489  *
 490  * @todo
 491  */
 492 static gboolean irreco_lircdb_dlg_loader_manuf(IrrecoLircdbDlg *self)
 493 {
 494         IRRECO_ENTER
 495
 496         switch (self->loader_state) {
 497         case LOADER_STATE_INIT:
 498                 irreco_lircdb_dlg_set_banner(self, _("Loading ..."), 0);
 499                 self->loader_state = LOADER_STATE_LOOP;
 500                 IRRECO_RETURN_BOOL(TRUE);
 501
 502         case LOADER_STATE_LOOP: {
 503                 GtkTreeIter iter;
 504                 GtkTreeIter iter_loading;
 505                 IrrecoStringTable *manufacturers = NULL;
 506                 IrrecoWebdbCache *webdb_cache = NULL;
 507
 508                 gtk_tree_model_get(GTK_TREE_MODEL(self->tree_store),
 509                                    self->loader_parent_iter,
 510                                    TEXT_COL, &self->dir, -1);
 511
 512                 webdb_cache = irreco_data_get_webdb_cache(self->irreco_data,
 513                                                           FALSE);
 514
 515                 if(irreco_webdb_cache_get_lirc_manufacturers(webdb_cache,
 516                                                         self->dir,
 517                                                         &manufacturers)){
 518
 519                         IRRECO_STRING_TABLE_FOREACH_KEY(manufacturers, key)
 520
 521                                 /* Add manufacturer item into directory. */
 522                                 gtk_tree_store_append(self->tree_store,
 523                                        &iter, self->loader_parent_iter);
 524                                 gtk_tree_store_set(self->tree_store,
 525                                                 &iter,
 526                                                 TEXT_COL, key,
 527                                                 FLAG_COL, ROW_TYPE_MANUFACTURER,
 528                                                 DATA_COL, NULL, -1);
 529
 530                                 /* Add loading item into manufacturer. */
 531                                 gtk_tree_store_append(self->tree_store,
 532                                                       &iter_loading, &iter);
 533                                 gtk_tree_store_set(self->tree_store,
 534                                                    &iter_loading,
 535                                                    TEXT_COL, _("Loading ..."),
 536                                                    FLAG_COL, ROW_TYPE_LOADING,
 537                                                    DATA_COL, NULL, -1);
 538
 539                         IRRECO_STRING_TABLE_FOREACH_END
 540                 } else {
 541                         irreco_error_dlg(GTK_WINDOW(self),
 542                                          irreco_webdb_cache_get_error(
 543                                          webdb_cache));
 544                 }
 545
 546                 /* Delete loading item from directory. */
 547                 gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(self->tree_store),
 548                                               &iter,self->loader_parent_iter,0);
 549                 if(irreco_lircdb_dlg_row_get_type(self,
 550                                                 &iter) == ROW_TYPE_LOADING) {
 551                         gtk_tree_store_remove(self->tree_store,&iter);
 552                 }
 553                 irreco_lircdb_dlg_set_banner(self, _("Loading ..."), 1);
 554                 self->loader_state = LOADER_STATE_END;
 555                 IRRECO_RETURN_BOOL(TRUE);
 556                 }
 557
 558         case LOADER_STATE_END:
 559                 irreco_lircdb_dlg_row_set_loaded(self, self->loader_parent_iter,
 560                                                 TRUE);
 561                 irreco_lircdb_dlg_hide_banner(self);
 562                 irreco_lircdb_dlg_loader_stop(self);
 563         }
 564
 565         IRRECO_RETURN_BOOL(FALSE);
 566 }
 567
 568 /**
 569  * Load Lircdb models
 570  *
 571  * @todo
 572  */
 573 static gboolean irreco_lircdb_dlg_loader_models(IrrecoLircdbDlg *self)
 574 {
 575         IRRECO_ENTER
 576
 577         switch (self->loader_state) {
 578         case LOADER_STATE_INIT:
 579                 irreco_lircdb_dlg_set_banner(self, _("Loading ..."), 0);
 580                 self->loader_state = LOADER_STATE_LOOP;
 581                 IRRECO_RETURN_BOOL(TRUE);
 582
 583         case LOADER_STATE_LOOP: {
 584                 GtkTreeIter iter;
 585                 GtkTreeIter dir_iter;
 586                 IrrecoStringTable *models = NULL;
 587                 IrrecoWebdbCache *webdb_cache = NULL;
 588
 589                 /*Get directory and manufacturer*/
 590
 591                 gtk_tree_model_get(GTK_TREE_MODEL(self->tree_store),
 592                                    self->loader_parent_iter,
 593                                    TEXT_COL, &self->manufacturer, -1);
 594
 595                 gtk_tree_model_iter_parent(GTK_TREE_MODEL(self->tree_store),
 596                                            &dir_iter,
 597                                            self->loader_parent_iter);
 598
 599                 gtk_tree_model_get(GTK_TREE_MODEL(self->tree_store),
 600                                    &dir_iter,
 601                                    TEXT_COL, &self->dir, -1);
 602
 603                 webdb_cache = irreco_data_get_webdb_cache(self->irreco_data,
 604                                                           FALSE);
 605
 606                 self->file_path = g_strdup_printf("%s/%s/", self->dir,
 607                                         self->manufacturer);
 608
 609                 if(irreco_webdb_cache_get_lirc_models(webdb_cache, self->file_path,
 610                                                  &models)){
 611
 612                         IRRECO_STRING_TABLE_FOREACH_KEY(models, key)
 613
 614                                 /* Add model item into manufacturer. */
 615                                 gtk_tree_store_append(self->tree_store,
 616                                        &iter, self->loader_parent_iter);
 617                                 gtk_tree_store_set(self->tree_store,
 618                                                 &iter,
 619                                                 TEXT_COL, key,
 620                                                 FLAG_COL, ROW_TYPE_MODEL,
 621                                                 DATA_COL, NULL, -1);
 622
 623                         IRRECO_STRING_TABLE_FOREACH_END
 624                 } else {
 625                         irreco_error_dlg(GTK_WINDOW(self),
 626                                          irreco_webdb_cache_get_error(
 627                                          webdb_cache));
 628                 }
 629
 630                 /* Delete loading item from manufacturer. */
 631                 gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(self->tree_store),
 632                                               &iter, self->loader_parent_iter,
 633                                               0);
 634                 if(irreco_lircdb_dlg_row_get_type(self,
 635                                                 &iter) == ROW_TYPE_LOADING) {
 636                         gtk_tree_store_remove(self->tree_store, &iter);
 637                 }
 638
 639                 irreco_lircdb_dlg_set_banner(self, _("Loading ..."), 1);
 640                 self->loader_state = LOADER_STATE_END;
 641
 642                 IRRECO_RETURN_BOOL(TRUE);
 643         }
 644         case LOADER_STATE_END:
 645                 irreco_lircdb_dlg_row_set_loaded(self, self->loader_parent_iter,
 646                                                 TRUE);
 647                 irreco_lircdb_dlg_hide_banner(self);
 648                 irreco_lircdb_dlg_loader_stop(self);
 649         }
 650
 651         IRRECO_RETURN_BOOL(FALSE);
 652 }
 653
 654 /**
 655  * Get filepath and show D/L button.
 656  *
 657  * @todo
 658  */
 659 static gboolean irreco_lircdb_dlg_ready_to_dl(IrrecoLircdbDlg *self,
 660                                                        GtkTreeIter * iter)
 661 {
 662         IRRECO_ENTER
 663
 664         gtk_tree_model_get(GTK_TREE_MODEL(self->tree_store),
 665                                 iter, TEXT_COL, &self->model, -1);
 666
 667         self->file_path = g_strdup_printf("%s/%s/%s", self->dir,
 668                                 self->manufacturer, self->model);
 669
 670         gtk_widget_show(self->download_button);
 671
 672         IRRECO_RETURN_BOOL(TRUE);
 673 }
 674
 675
 676 /**
 677  * Load config file from Lircdb.
 678  *
 679  * @todo
 680  */
 681 static gboolean irreco_lircdb_dlg_load_file(IrrecoLircdbDlg *self)
 682 {
 683         IrrecoWebdbCache                *webdb_cache    = NULL;
 684         IrrecoBackendInstance           *inst           = NULL;
 685         GString                         *error_msg      = g_string_new("");
 686         IrrecoBackendManager            *manager;
 687         IrrecoBackendFileContainer      *file_container;
 688         IrrecoStringTable               *file = NULL;
 689         gboolean                        success         = TRUE;
 690         gboolean                        new_instance    = FALSE;
 691         gint                            instances;
 692         gchar                           *backend = "Internal Lirc";
 693         gchar                   *file_contents = NULL;
 694         IRRECO_ENTER
 695
 696         webdb_cache = irreco_data_get_webdb_cache(self->irreco_data,
 697                                                   FALSE);
 698
 699         if(irreco_webdb_cache_get_lirc_file(webdb_cache, self->file_path, &file)) {
 700                 IRRECO_STRING_TABLE_FOREACH_KEY(file, key)
 701                         if(file_contents == NULL) {
 702                                 file_contents = g_strdup_printf("%s", key);
 703                         } else {
 704                                 file_contents = g_strdup_printf(
 705                                                 "%s%s", file_contents, key);
 706                         }
 707                 IRRECO_STRING_TABLE_FOREACH_END
 708         } else {
 709                 goto end;
 710         }
 711
 712         webdb_cache = NULL;
 713
 714         /* Search backend */
 715         manager = self->irreco_data->irreco_backend_manager;
 716         IRRECO_BACKEND_MANAGER_FOREACH_LIB(manager, lib)
 717                 if (g_utf8_collate(lib->name, backend) != 0){
 718                         continue;
 719                 }
 720                 if (!(lib->api->flags & IRRECO_BACKEND_EDITABLE_DEVICES)) {
 721                         g_string_printf(error_msg,
 722                         "\"%s\" backend is not editable...",
 723                         backend);
 724                         goto end;
 725                 }
 726                 else if (!(lib->api->flags &
 727                          IRRECO_BACKEND_CONFIGURATION_EXPORT)) {
 728                         g_string_printf(error_msg,
 729                         "\"%s\" backend doesn't support "
 730                         "exporting its configuration...",
 731                         backend);
 732                         goto end;
 733                 }
 734                 /* Check if many instances */
 735                 instances = 0;
 736                 IRRECO_BACKEND_MANAGER_FOREACH_INSTANCE(manager, instance)
 737                         irreco_backend_instance_get_description(instance);
 738                         if (g_utf8_collate(instance->lib->name,
 739                                     backend) == 0) {
 740                                 instances++;
 741
 742                                 /*if there is only one instance, then use it */
 743                                 inst = instance;
 744                         }
 745                 IRRECO_STRING_TABLE_FOREACH_END
 746                 IRRECO_DEBUG("INSTANCES: %d\n",instances);
 747
 748                 /* Create new instance if it comes to the crunch */
 749                 if (instances == 0 || lib->api->flags &
 750                     IRRECO_BACKEND_NEW_INST_ON_CONF_IMPORT) {
 751                         inst = irreco_backend_manager_create_instance(
 752                         manager, lib, NULL, NULL);
 753                         new_instance = TRUE;
 754                         break;
 755                 }
 756
 757                 /* Select instace */
 758                 if (instances > 1) {
 759                         if (!irreco_show_select_instance_dlg(
 760                             self->irreco_data, GTK_WINDOW(self),
 761                             backend, &inst)) {
 762                                 g_string_printf(error_msg,
 763                                 "Operation aborted by user...");
 764                                 goto end;
 765                         }
 766                 }
 767                 goto instance_ready;
 768         IRRECO_STRING_TABLE_FOREACH_END
 769
 770         if (inst == NULL) {
 771                 g_string_printf(error_msg, "\"%s\" backend is not installed...",
 772                                 backend);
 773                 goto end;
 774         }
 775
 776         irreco_backend_instance_configure(inst, GTK_WINDOW(self));
 777         irreco_backend_instance_save_to_conf(inst);
 778         irreco_config_save_backends(manager);
 779
 780         instance_ready:
 781         g_print("instance_ready: \n");
 782
 783         file_container = irreco_backend_file_container_new();
 784         irreco_backend_file_container_set(file_container,
 785                                           inst->lib->name,
 786                                           backend,
 787                                           self->manufacturer,
 788                                           self->model,
 789                                           self->model,
 790                                           file_contents);
 791
 792         if (irreco_backend_instance_check_conf(inst, file_container)) {
 793                 GString *question = g_string_new("");
 794                 g_string_printf(question, "\"%s\" backend already contains\n"
 795                                 "device \"%s\".\n"
 796                                 "Do you want to overwrite?",
 797                                 inst->lib->name,self->model);
 798                 success = irreco_yes_no_dlg(GTK_WINDOW(self), question->str);
 799                 g_string_free(question, TRUE);
 800
 801                 if(success == FALSE) {
 802                         goto end;
 803                 }
 804         }
 805
 806         /* Send file_data for backend */
 807         if(irreco_backend_instance_import_conf(inst, file_container)) {
 808                 irreco_info_dlg(GTK_WINDOW(self),
 809                                 "Configuration downloaded successfully!");
 810                 irreco_backend_manager_get_devcmd_lists(
 811                                self->irreco_data->irreco_backend_manager);
 812         } else {
 813                 g_string_printf(error_msg, "Backend error");
 814
 815                 if (new_instance) {
 816                         irreco_backend_manager_destroy_instance(manager, inst);
 817                 }
 818                 goto end;
 819         }
 820
 821         end:
 822         if(error_msg->len > 0) {
 823                 irreco_error_dlg(GTK_WINDOW(self), error_msg->str);
 824                 success = FALSE;
 825         }
 826
 827         g_free(file_contents);
 828         g_string_free(error_msg, TRUE);
 829         IRRECO_RETURN_BOOL(success);
 830 }
 831
 832 /** @} */
 833
 834
 835
 836 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 837 /* Functions                                                                  */
 838 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 839
 840 /**
 841  * @name Public Functions
 842  * @{
 843  */
 844
 845 void irreco_lircdb_dlg_set_irreco_data(IrrecoLircdbDlg *self,
 846                                       IrrecoData *irreco_data)
 847 {
 848         IRRECO_ENTER
 849         self->irreco_data = irreco_data;
 850         IRRECO_RETURN
 851 }
 852
 853 void irreco_show_lircdb_dlg(IrrecoData *irreco_data, GtkWindow *parent)
 854 {
 855         IrrecoLircdbDlg *self;
 856         gint            response;
 857         gboolean        loop = TRUE;
 858         IRRECO_ENTER
 859
 860         self = IRRECO_LIRCDB_DLG(irreco_lircdb_dlg_new(irreco_data, parent));
 861
 862         do {
 863                 response = gtk_dialog_run(GTK_DIALOG(self));
 864                 switch (response) {
 865                 case IRRECO_DEVICE_REFRESH:
 866                         IRRECO_DEBUG("IRRECO_DEVICE_REFRESH\n");
 867                         gtk_tree_store_clear(self->tree_store);
 868                         irreco_data_get_webdb_cache(self->irreco_data, TRUE);
 869                         irreco_lircdb_dlg_loader_start(self,
 870                                 G_SOURCEFUNC(irreco_lircdb_dlg_loader_dirs),
 871                                 NULL);
 872                         break;
 873
 874                 case GTK_RESPONSE_DELETE_EVENT:
 875                         IRRECO_DEBUG("GTK_RESPONSE_DELETE_EVENT\n");
 876                         loop = FALSE;
 877                         break;
 878
 879                 case GTK_RESPONSE_OK:
 880                         IRRECO_DEBUG("GTK_RESPONSE_OK\n");
 881                         loop = !irreco_lircdb_dlg_load_file(self);
 882                         break;
 883
 884                 }
 885         } while (loop);
 886
 887         gtk_widget_destroy(GTK_WIDGET(self));
 888         IRRECO_RETURN
 889 }
 890
 891 /** @} */
 892
 893
 894
 895 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 896 /* Events and Callbacks                                                       */
 897 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 898
 899 /**
 900  * @name Events and Callbacks
 901  * @{
 902  */
 903
 904 static gboolean irreco_show_lircdb_dlg_map_event(IrrecoLircdbDlg *self,
 905                                                 GdkEvent *event,
 906                                                 gpointer user_data)
 907 {
 908         IRRECO_ENTER
 909         irreco_lircdb_dlg_loader_start(
 910                 self, G_SOURCEFUNC(irreco_lircdb_dlg_loader_dirs), NULL);
 911         IRRECO_RETURN_BOOL(FALSE);
 912 }
 913
 914 static void irreco_show_lircdb_dlg_destroy_event(IrrecoLircdbDlg *self,
 915                                                 gpointer user_data)
 916 {
 917         IRRECO_ENTER
 918         irreco_lircdb_dlg_loader_stop(self);
 919         IRRECO_RETURN
 920 }
 921
 922 static void irreco_show_lircdb_dlg_row_activated_event(GtkTreeView *tree_view,
 923                                                       GtkTreePath *path,
 924                                                       GtkTreeViewColumn *column,
 925                                                       IrrecoLircdbDlg *self)
 926 {
 927         IRRECO_ENTER
 928
 929         if (gtk_tree_view_row_expanded(tree_view, path)) {
 930                 g_print("was expanded\n");
 931                 gtk_tree_view_expand_row(tree_view, path, FALSE);
 932                 g_print("tried expand row\n");
 933         } else {
 934                 g_print("was not expanded\n");
 935                 gtk_tree_view_collapse_row(tree_view, path);
 936                 g_print("tried collapsing row\n");
 937         }
 938         IRRECO_RETURN
 939 }
 940
 941 static void irreco_show_lircdb_dlg_row_expanded_event(GtkTreeView *tree_view,
 942                                                      GtkTreeIter *iter,
 943                                                      GtkTreePath *path,
 944                                                      IrrecoLircdbDlg *self)
 945 {
 946         IRRECO_ENTER
 947
 948         irreco_lircdb_dlg_clean_details(self);
 949
 950         if (self->loader_func_id != 0) {
 951                 gtk_tree_view_collapse_row(tree_view, path);
 952         }
 953
 954         if (!irreco_lircdb_dlg_row_is_loaded(self, iter)) {
 955                 switch (irreco_lircdb_dlg_row_get_type(self, iter)) {
 956                 case ROW_TYPE_DIR:
 957                         irreco_lircdb_dlg_loader_start(self,
 958                                 G_SOURCEFUNC(irreco_lircdb_dlg_loader_manuf),
 959                                 iter);
 960                         gtk_widget_hide(self->download_button);
 961                         break;
 962
 963                 case ROW_TYPE_MANUFACTURER:
 964                         irreco_lircdb_dlg_loader_start(self,
 965                                 G_SOURCEFUNC(irreco_lircdb_dlg_loader_models),
 966                                 iter);
 967                         gtk_widget_hide(self->download_button);
 968                         break;
 969                 }
 970         }
 971
 972         IRRECO_RETURN
 973 }
 974
 975 static void irreco_show_lircdb_dlg_row_collapsed_event(GtkTreeView *tree_view,
 976                                                      GtkTreeIter *iter,
 977                                                      GtkTreePath *path,
 978                                                      IrrecoLircdbDlg *self)
 979 {
 980         IRRECO_ENTER
 981
 982         irreco_lircdb_dlg_clean_details(self);
 983
 984         IRRECO_RETURN
 985 }
 986
 987 static void irreco_show_lircdb_dlg_row_selected_event(GtkTreeSelection *sel,
 988                                                      IrrecoLircdbDlg *self)
 989 {
 990         GtkTreeIter iter;
 991         GtkTreeModel *model;
 992
 993         IRRECO_ENTER
 994
 995         if (gtk_tree_selection_get_selected (sel, &model, &iter))
 996         {
 997                 switch (irreco_lircdb_dlg_row_get_type(self, &iter)) {
 998
 999                 case ROW_TYPE_MODEL:
1000                         IRRECO_DEBUG("ROW_TYPE_MODEL\n");
1001                         irreco_lircdb_dlg_ready_to_dl(self, &iter);
1002                         break;
1003
1004                 default:
1005                         irreco_lircdb_dlg_clean_details(self);
1006                         break;
1007                 }
1008         }
1009
1010         IRRECO_RETURN
1011 }
1012
1013 /** @} */
1014 /** @} */
1015