?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Mostly minor fixes up until version 0.8.10.
[irreco.git] / irreco / src / core / irreco_webdb_dlg.c
blobfbf33cd5da8bcd0002aef607bd377abb5985de80
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 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version 2
10 * of the License, or (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
20 */
21
22 #include "irreco_webdb_dlg.h"
23 #include <hildon/hildon-banner.h>
24 #include "irreco_webdb_register_dlg.h"
25 #include "irreco_select_instance_dlg.h"
26 #include "irreco_config.h"
27 #include <hildon/hildon-gtk.h>
28 #include <hildon/hildon-pannable-area.h>
29
30
31 /**
32 * @addtogroup IrrecoWebdbDlg
33 * @ingroup Irreco
34 *
35 * @todo PURPOCE OF CLASS.
36 *
37 * @{
38 */
39
40 /**
41 * @file
42 * Source file of @ref IrrecoWebdbDlg.
43 */
44
45
46 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
47 /* Prototypes */
48 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
49 static void irreco_webdb_dlg_clean_details(IrrecoWebdbDlg *self);
50 static gboolean irreco_webdb_dlg_loader_categ(IrrecoWebdbDlg *self);
51 static gboolean irreco_webdb_dlg_loader_manuf(IrrecoWebdbDlg *self);
52 static gboolean irreco_webdb_dlg_loader_model(IrrecoWebdbDlg *self);
53 static gboolean irreco_webdb_dlg_loader_config(IrrecoWebdbDlg *self);
54 static gboolean irreco_webdb_dlg_display_config_detail(IrrecoWebdbDlg *self,
55 GtkTreeIter * iter);
56 static gboolean irreco_webdb_dlg_load_file(IrrecoWebdbDlg *self);
57
58 static gboolean irreco_show_webdb_dlg_map_event(IrrecoWebdbDlg *self,
59 GdkEvent *event,
60 gpointer user_data);
61 static void irreco_show_webdb_dlg_destroy_event(IrrecoWebdbDlg *self,
62 gpointer user_data);
63 static void irreco_show_webdb_dlg_row_activated_event(GtkTreeView *tree_view,
64 GtkTreePath *path,
65 GtkTreeViewColumn *column,
66 IrrecoWebdbDlg *self);
67 static void irreco_show_webdb_dlg_row_expanded_event(GtkTreeView *tree_view,
68 GtkTreeIter *iter,
69 GtkTreePath *path,
70 IrrecoWebdbDlg *self);
71 static void irreco_show_webdb_dlg_row_collapsed_event(GtkTreeView *tree_view,
72 GtkTreeIter *iter,
73 GtkTreePath *path,
74 IrrecoWebdbDlg *self);
75 static void irreco_show_webdb_dlg_row_selected_event(GtkTreeSelection *sel,
76 IrrecoWebdbDlg *self);
77
78
79
80
81 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
82 /* Datatypes */
83 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
84
85 /** Button responce 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_CATEGORY = 1 << 2,
113 ROW_TYPE_MANUFACTURER = 1 << 3,
114 ROW_TYPE_MODEL = 1 << 4,
115 ROW_TYPE_CONFIG = 1 << 5,
116 ROW_TYPE_LOADING = 1 << 6
117 };
118
119
120
121 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
122 /* Construction & Destruction */
123 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
124
125 /**
126 * @name Construction & Destruction
127 * @{
128 */
129
130 G_DEFINE_TYPE(IrrecoWebdbDlg, irreco_webdb_dlg, IRRECO_TYPE_DLG)
131
132 static void irreco_webdb_dlg_finalize(GObject *object)
133 {
134 if (G_OBJECT_CLASS(irreco_webdb_dlg_parent_class)->finalize)
135 G_OBJECT_CLASS(irreco_webdb_dlg_parent_class)->finalize(object);
136 }
137
138 static void irreco_webdb_dlg_class_init(IrrecoWebdbDlgClass *klass)
139 {
140 GObjectClass *object_class = G_OBJECT_CLASS(klass);
141 object_class->finalize = irreco_webdb_dlg_finalize;
142 }
143
144 static void irreco_webdb_dlg_init(IrrecoWebdbDlg *self)
145 {
146 GtkTreeViewColumn *column;
147 GtkCellRenderer *renderer;
148 GtkTreeSelection *select;
149 GtkWidget *label_user;
150 GtkWidget *label_backend;
151 GtkWidget *label_category;
152 GtkWidget *label_manuf;
153 GtkWidget *label_model;
154 GtkWidget *label_file_uploaded;
155 GtkWidget *label_file_download_count;
156 GtkWidget *config_info_alignment;
157 GtkWidget *config_info_frame;
158 GtkWidget *tree_view_frame;
159 GtkWidget *tree_view_hbox;
160 PangoFontDescription *initial_font;
161 /* GtkWidget *pannablearea;*/
162
163 IRRECO_ENTER
164
165 /* Construct dialog. */
166 gtk_window_set_title(GTK_WINDOW(self),
167 _("Download device from IrrecoDB"));
168 gtk_window_set_modal(GTK_WINDOW(self), TRUE);
169 gtk_window_set_destroy_with_parent(GTK_WINDOW(self), TRUE);
170 gtk_dialog_set_has_separator(GTK_DIALOG(self), FALSE);
171 gtk_dialog_add_buttons(GTK_DIALOG(self),
172 GTK_STOCK_REFRESH, IRRECO_DEVICE_REFRESH,
173 GTK_STOCK_OK, GTK_RESPONSE_OK,
174 NULL);
175 /* Create hbox */
176 self->hbox = g_object_new(GTK_TYPE_HBOX, NULL);
177 gtk_box_set_spacing(GTK_BOX(self->hbox), 8);
178 gtk_container_add(GTK_CONTAINER(GTK_DIALOG(self)->vbox),
179 irreco_gtk_align(GTK_WIDGET(self->hbox),
180 0, 0, 1, 1, 8, 8, 8, 8));
181 /* Create tree_view_hbox */
182 tree_view_hbox = g_object_new(GTK_TYPE_HBOX, NULL);
183
184 /* Create Treeview */
185 self->tree_store = gtk_tree_store_new(
186 N_COLUMNS, G_TYPE_STRING, G_TYPE_INT, G_TYPE_POINTER);
187 /* self->tree_view = GTK_TREE_VIEW(gtk_tree_view_new_with_model(
188 GTK_TREE_MODEL(self->tree_store)));*/
189 self->tree_view = hildon_gtk_tree_view_new_with_model(
190 HILDON_UI_MODE_NORMAL,
191 GTK_TREE_MODEL(self->tree_store));
192
193 renderer = gtk_cell_renderer_text_new();
194 column = gtk_tree_view_column_new_with_attributes(
195 NULL, renderer, "text", TEXT_COL, NULL);
196 gtk_tree_view_append_column(GTK_TREE_VIEW(self->tree_view), column);
197
198 /* Treeview to pannablearea */
199 /*TODO*/
200 gtk_box_pack_start(GTK_BOX(tree_view_hbox), GTK_WIDGET(self->tree_view),
201 TRUE, TRUE, 0);
202
203 /* Create scrollbar for Treeview */
204 /*self->scrollbar = gtk_vscrollbar_new(gtk_tree_view_get_vadjustment(
205 GTK_TREE_VIEW(self->tree_view)));
206 gtk_box_pack_start(GTK_BOX(tree_view_hbox), GTK_WIDGET(self->scrollbar),
207 FALSE, TRUE, 0);TODO rm*/
208
209 /* Create Frame for Treeview */
210 tree_view_frame = gtk_frame_new("");
211 gtk_frame_set_label_widget(GTK_FRAME(tree_view_frame),
212 irreco_gtk_label_bold("Devices", 0, 0, 0, 0, 0, 0));
213
214 /* pannablearea = hildon_pannable_area_new();
215 hildon_pannable_area_add_with_viewport(HILDON_PANNABLE_AREA(pannablearea), tree_view_hbox);*/
216
217 gtk_container_add(GTK_CONTAINER(tree_view_frame),
218 GTK_WIDGET(tree_view_hbox));
219
220 gtk_box_pack_start(GTK_BOX(self->hbox), GTK_WIDGET(tree_view_frame),
221 TRUE, TRUE, 0);
222
223 /* Create config_info */
224 self->config_info = gtk_table_new(7, 2, FALSE);
225 gtk_table_set_row_spacings(GTK_TABLE(self->config_info), 4);
226
227 label_user = gtk_label_new("Creator: ");
228 gtk_misc_set_alignment(GTK_MISC(label_user), 0, 0.5);
229 gtk_table_attach_defaults(GTK_TABLE(self->config_info),
230 label_user, 0, 1, 0, 1);
231
232 label_backend = gtk_label_new("Backend: ");
233 gtk_misc_set_alignment(GTK_MISC(label_backend), 0, 0.5);
234 gtk_table_attach_defaults(GTK_TABLE(self->config_info),
235 label_backend, 0, 1, 1, 2);
236
237 label_category = gtk_label_new("Category: ");
238 gtk_misc_set_alignment(GTK_MISC(label_category), 0, 0.5);
239 gtk_table_attach_defaults(GTK_TABLE(self->config_info),
240 label_category, 0, 1, 2, 3);
241
242 label_manuf = gtk_label_new("Manufacturer: ");
243 gtk_misc_set_alignment(GTK_MISC(label_manuf), 0, 0.5);
244 gtk_table_attach_defaults(GTK_TABLE(self->config_info),
245 label_manuf, 0, 1, 3, 4);
246
247 label_model = gtk_label_new("Model: ");
248 gtk_misc_set_alignment(GTK_MISC(label_model), 0, 0.5);
249 gtk_table_attach_defaults(GTK_TABLE(self->config_info),
250 label_model, 0, 1, 4, 5);
251
252 label_file_uploaded = gtk_label_new("Created: ");
253 gtk_misc_set_alignment(GTK_MISC(label_file_uploaded), 0, 0.5);
254 gtk_table_attach_defaults(GTK_TABLE(self->config_info),
255 label_file_uploaded, 0, 1, 5, 6);
256
257 label_file_download_count = gtk_label_new("Downloaded: ");
258 gtk_misc_set_alignment(GTK_MISC(label_file_download_count), 0, 0.5);
259 gtk_table_attach_defaults(GTK_TABLE(self->config_info),
260 label_file_download_count, 0, 1, 6, 7);
261
262 self->config_user = gtk_label_new("-");
263 gtk_misc_set_alignment(GTK_MISC(self->config_user), 0, 0.5);
264 gtk_table_attach(GTK_TABLE(self->config_info), self->config_user,
265 1, 2, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
266
267 self->config_backend = gtk_label_new("-");
268 gtk_misc_set_alignment(GTK_MISC(self->config_backend), 0, 0.5);
269 gtk_table_attach(GTK_TABLE(self->config_info), self->config_backend,
270 1, 2, 1, 2, GTK_FILL, GTK_FILL, 0, 0);
271
272 self->config_category = gtk_label_new("-");
273 gtk_misc_set_alignment(GTK_MISC(self->config_category), 0, 0.5);
274 gtk_table_attach(GTK_TABLE(self->config_info), self->config_category,
275 1, 2, 2, 3, GTK_FILL, GTK_FILL, 0, 0);
276
277 self->config_manuf = gtk_label_new("-");
278 gtk_misc_set_alignment(GTK_MISC(self->config_manuf), 0, 0.5);
279 gtk_table_attach(GTK_TABLE(self->config_info), self->config_manuf,
280 1, 2, 3, 4, GTK_FILL, GTK_FILL, 0, 0);
281
282 self->config_model = gtk_label_new("-");
283 gtk_misc_set_alignment(GTK_MISC(self->config_model), 0, 0.5);
284 gtk_table_attach(GTK_TABLE(self->config_info), self->config_model,
285 1, 2, 4, 5, GTK_FILL, GTK_FILL, 0, 0);
286
287 self->config_uploaded = gtk_label_new("-");
288 gtk_misc_set_alignment(GTK_MISC(self->config_uploaded), 0, 0.5);
289 gtk_table_attach(GTK_TABLE(self->config_info),
290 self->config_uploaded,
291 1, 2, 5, 6, GTK_FILL, GTK_FILL, 0, 0);
292
293 self->config_download_count = gtk_label_new("-");
294 gtk_misc_set_alignment(GTK_MISC(self->config_download_count), 0, 0.5);
295 gtk_table_attach(GTK_TABLE(self->config_info),
296 self->config_download_count,
297 1, 2, 6, 7, GTK_FILL, GTK_FILL, 0, 0);
298
299 /* Resize text */
300 initial_font = pango_font_description_from_string ("Sans 9");
301 gtk_widget_modify_font (label_user, initial_font);
302 gtk_widget_modify_font (label_backend, initial_font);
303 gtk_widget_modify_font (label_category, initial_font);
304 gtk_widget_modify_font (label_manuf, initial_font);
305 gtk_widget_modify_font (label_model, initial_font);
306 gtk_widget_modify_font (label_file_uploaded, initial_font);
307 gtk_widget_modify_font (label_file_download_count, initial_font);
308 gtk_widget_modify_font (self->config_user, initial_font);
309 gtk_widget_modify_font (self->config_backend, initial_font);
310 gtk_widget_modify_font (self->config_category, initial_font);
311 gtk_widget_modify_font (self->config_manuf, initial_font);
312 gtk_widget_modify_font (self->config_model, initial_font);
313 gtk_widget_modify_font (self->config_uploaded, initial_font);
314 gtk_widget_modify_font (self->config_download_count, initial_font);
315
316
317 /* Create frame for config_info */
318 config_info_frame = gtk_frame_new("");
319 gtk_frame_set_label_widget(GTK_FRAME(config_info_frame),
320 irreco_gtk_label_bold("Details", 0, 0, 0, 0, 0, 0));
321
322 gtk_box_pack_start(GTK_BOX(self->hbox),
323 GTK_WIDGET(config_info_frame),
324 FALSE, TRUE, 0);
325
326 config_info_alignment = gtk_alignment_new(0, 0, 0, 0);
327 gtk_alignment_set_padding(GTK_ALIGNMENT(config_info_alignment),
328 0, 8, 8, 8);
329 gtk_container_add(GTK_CONTAINER(config_info_frame),
330 GTK_WIDGET(config_info_alignment));
331
332 gtk_container_add(GTK_CONTAINER(config_info_alignment),
333 GTK_WIDGET(self->config_info));
334
335 /* Setup the selection handler for TREE */
336 select = gtk_tree_view_get_selection(GTK_TREE_VIEW(self->tree_view));
337 gtk_tree_selection_set_mode(select, GTK_SELECTION_SINGLE);
338
339 /* Signal handlers. */
340 g_signal_connect(G_OBJECT(self), "map-event",
341 G_CALLBACK(irreco_show_webdb_dlg_map_event), NULL);
342 g_signal_connect(G_OBJECT(self), "destroy",
343 G_CALLBACK(irreco_show_webdb_dlg_destroy_event), NULL);
344 g_signal_connect(G_OBJECT(self->tree_view), "row-activated",
345 G_CALLBACK(irreco_show_webdb_dlg_row_activated_event),
346 self);
347 g_signal_connect(G_OBJECT(self->tree_view), "row-expanded",
348 G_CALLBACK(irreco_show_webdb_dlg_row_expanded_event),
349 self);
350 g_signal_connect(G_OBJECT(self->tree_view), "row-collapsed",
351 G_CALLBACK(irreco_show_webdb_dlg_row_collapsed_event),
352 self);
353 g_signal_connect(G_OBJECT (select), "changed",
354 G_CALLBACK (irreco_show_webdb_dlg_row_selected_event),
355 self);
356
357
358 gtk_tree_view_set_enable_tree_lines(GTK_TREE_VIEW(self->tree_view), TRUE);
359 g_object_set (G_OBJECT (self->tree_view), "show-expanders", TRUE, NULL);
360 g_object_set (G_OBJECT (self->tree_view), "level-indentation", 0, NULL);
361 gtk_tree_view_set_rubber_banding(GTK_TREE_VIEW(self->tree_view), FALSE);
362
363 gtk_widget_set_size_request(GTK_WIDGET(self), -1, 335);
364 gtk_widget_show_all(GTK_WIDGET(self));
365 IRRECO_RETURN
366 }
367
368 GtkWidget *irreco_webdb_dlg_new(IrrecoData *irreco_data,
369 GtkWindow *parent)
370 {
371 IrrecoWebdbDlg *self;
372 IRRECO_ENTER
373
374 self = g_object_new(IRRECO_TYPE_WEBDB_DLG, NULL);
375 irreco_dlg_set_parent(IRRECO_DLG(self), parent);
376 irreco_webdb_dlg_set_irreco_data(self, irreco_data);
377 IRRECO_RETURN_PTR(self);
378 }
379
380 /** @} */
381
382
383
384 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
385 /* Private Functions */
386 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
387
388 /**
389 * @name Private Functions
390 * @{
391 */
392
393 /**
394 * Clean detail list
395 *
396 */
397 static void irreco_webdb_dlg_clean_details(IrrecoWebdbDlg *self)
398 {
399 IRRECO_ENTER
400
401 self->config = NULL;
402 gtk_label_set_text(
403 GTK_LABEL(self->config_user), "-");
404 gtk_label_set_text(
405 GTK_LABEL(self->config_backend), "-");
406 gtk_label_set_text(
407 GTK_LABEL(self->config_category), "-");
408 gtk_label_set_text(
409 GTK_LABEL(self->config_manuf), "-");
410 gtk_label_set_text(
411 GTK_LABEL(self->config_model), "-");
412 gtk_label_set_text(
413 GTK_LABEL(self->config_uploaded), "-");
414 gtk_label_set_text(
415 GTK_LABEL(self->config_download_count), "-");
416
417 IRRECO_RETURN
418 }
419
420 /**
421 * Have the childern of this item been loaded.
422 *
423 * @return TRUE if children have been loade, FALSE otherwise.
424 */
425 static gboolean irreco_webdb_dlg_row_is_loaded(IrrecoWebdbDlg *self,
426 GtkTreeIter *iter)
427 {
428 gint i;
429 IRRECO_ENTER
430
431 gtk_tree_model_get(GTK_TREE_MODEL(self->tree_store),
432 iter, FLAG_COL, &i, -1);
433 if (i & ROW_CHILDREN_LOADED) IRRECO_RETURN_BOOL(TRUE);
434 IRRECO_RETURN_BOOL(FALSE);
435 }
436
437 /**
438 * Enable / Disable ROW_CHILDREN_LOADED flag from a row.
439 *
440 * @param value If set, ROW_CHILDREN_LOADED will be enabled.
441 */
442 static void irreco_webdb_dlg_row_set_loaded(IrrecoWebdbDlg *self,
443 GtkTreeIter *iter,
444 gboolean value)
445 {
446 gint i;
447 IRRECO_ENTER
448
449 gtk_tree_model_get(GTK_TREE_MODEL(self->tree_store),
450 iter, FLAG_COL, &i, -1);
451 if (value) {
452 i = i | ROW_CHILDREN_LOADED;
453 } else {
454 i = i & ~ROW_CHILDREN_LOADED;
455 }
456 gtk_tree_store_set(self->tree_store, iter, FLAG_COL, i, -1);
457
458 IRRECO_RETURN
459 }
460
461 /**
462 * Get type of row.
463 */
464 static gint irreco_webdb_dlg_row_get_type(IrrecoWebdbDlg *self,
465 GtkTreeIter *iter)
466 {
467 gint i;
468 IRRECO_ENTER
469
470 gtk_tree_model_get(GTK_TREE_MODEL(self->tree_store),
471 iter, FLAG_COL, &i, -1);
472 if (i & ROW_TYPE_CATEGORY)
473 IRRECO_RETURN_ENUM(ROW_TYPE_CATEGORY);
474 if (i & ROW_TYPE_MANUFACTURER)
475 IRRECO_RETURN_ENUM(ROW_TYPE_MANUFACTURER);
476 if (i & ROW_TYPE_MODEL)
477 IRRECO_RETURN_ENUM(ROW_TYPE_MODEL);
478 if (i & ROW_TYPE_CONFIG)
479 IRRECO_RETURN_ENUM(ROW_TYPE_CONFIG);
480 if (i & ROW_TYPE_LOADING)
481 IRRECO_RETURN_ENUM(ROW_TYPE_LOADING);
482 IRRECO_RETURN_INT(0);
483 }
484
485 /**
486 * Show hildon progressbar banner.
487 *
488 * This function will create a new banner if one has not been created yet,
489 * if banner already exists, it's properties will be changed.
490 *
491 * @param text Text to show.
492 * @param fraction Value of progress.
493 */
494 static void irreco_webdb_dlg_set_banner(IrrecoWebdbDlg *self,
495 const gchar *text,
496 gdouble fraction)
497 {
498 IRRECO_ENTER
499 if (self->banner == NULL) {
500 self->banner = hildon_banner_show_progress(
501 GTK_WIDGET(self), NULL, "");
502 }
503
504 hildon_banner_set_text(HILDON_BANNER(self->banner), text);
505 hildon_banner_set_fraction(HILDON_BANNER(self->banner), fraction);
506 IRRECO_RETURN
507 }
508
509 /**
510 * Destroy banner, if it exists.
511 */
512 static void irreco_webdb_dlg_hide_banner(IrrecoWebdbDlg *self)
513 {
514 IRRECO_ENTER
515 if (self->banner) {
516 gtk_widget_destroy(self->banner);
517 self->banner = NULL;
518 }
519 IRRECO_RETURN
520 }
521
522 /**
523 * Start a loader state machine if one is not running already.
524 */
525 static void irreco_webdb_dlg_loader_start(IrrecoWebdbDlg *self,
526 GSourceFunc function,
527 GtkTreeIter *parent_iter)
528 {
529 IRRECO_ENTER
530
531 if (self->loader_func_id == 0) {
532 if (parent_iter) {
533 self->loader_parent_iter = gtk_tree_iter_copy(
534 parent_iter);
535 }
536
537 if (function) {
538 self->loader_func_id = g_idle_add(function, self);
539 } else {
540 IRRECO_ERROR("Loader function pointer not given.\n");
541 }
542 }
543
544 IRRECO_RETURN
545 }
546
547 /**
548 * Stop and cleanup loader if a loader is running.
549 */
550 static void irreco_webdb_dlg_loader_stop(IrrecoWebdbDlg *self)
551 {
552 IRRECO_ENTER
553 if (self->loader_func_id != 0) {
554 g_source_remove(self->loader_func_id);
555 self->loader_func_id = 0;
556 self->loader_state = 0;
557 if (self->loader_parent_iter) {
558 gtk_tree_iter_free(self->loader_parent_iter);
559 }
560 self->loader_parent_iter = NULL;
561 }
562 IRRECO_RETURN
563 }
564
565 /**
566 * Web Database Category loader.
567 *
568 * This loader will request a list of categories from the Web Database and
569 * update the TreeView accordingly. Every category row created by this loader
570 * will have row type ROW_TYPE_CATEGORY.
571 */
572 static gboolean irreco_webdb_dlg_loader_categ(IrrecoWebdbDlg *self)
573 {
574 IRRECO_ENTER
575
576 switch (self->loader_state) {
577 case LOADER_STATE_INIT:
578 irreco_webdb_dlg_set_banner(self, _("Loading ..."), 0);
579 self->loader_state = LOADER_STATE_LOOP;
580 irreco_webdb_dlg_clean_details(self);
581 IRRECO_RETURN_BOOL(TRUE);
582
583 case LOADER_STATE_LOOP: {
584 GtkTreeIter iter;
585 GtkTreeIter iter_loading;
586 IrrecoStringTable *categories = NULL;
587 IrrecoWebdbCache *webdb_cache = NULL;
588
589 webdb_cache = irreco_data_get_webdb_cache(self->irreco_data,
590 FALSE);
591 if(irreco_webdb_cache_get_categories(webdb_cache, &categories)){
592 IRRECO_STRING_TABLE_FOREACH_KEY(categories, key)
593
594 /* Append categogy. */
595 gtk_tree_store_append(self->tree_store,
596 &iter, NULL);
597 gtk_tree_store_set(self->tree_store,
598 &iter, TEXT_COL, key,
599 FLAG_COL, ROW_TYPE_CATEGORY,
600 DATA_COL, NULL, -1);
601
602 /* Add loading item into category. */
603 gtk_tree_store_append(self->tree_store,
604 &iter_loading, &iter);
605 gtk_tree_store_set(self->tree_store,
606 &iter_loading,
607 TEXT_COL, _("Loading ..."),
608 FLAG_COL, ROW_TYPE_LOADING,
609 DATA_COL, NULL, -1);
610 IRRECO_STRING_TABLE_FOREACH_END
611 } else {
612 irreco_error_dlg(GTK_WINDOW(self),
613 irreco_webdb_cache_get_error(
614 webdb_cache));
615 }
616
617 irreco_webdb_dlg_set_banner(self, _("Loading ..."), 1);
618 self->loader_state = LOADER_STATE_END;
619 IRRECO_RETURN_BOOL(TRUE);
620 }
621
622 case LOADER_STATE_END:
623 irreco_webdb_dlg_hide_banner(self);
624 irreco_webdb_dlg_loader_stop(self);
625 }
626
627 IRRECO_RETURN_BOOL(FALSE);
628 }
629
630 /**
631 * Web Database Manufacturer loader.
632 *
633 * @todo
634 */
635 static gboolean irreco_webdb_dlg_loader_manuf(IrrecoWebdbDlg *self)
636 {
637 IRRECO_ENTER
638
639 switch (self->loader_state) {
640 case LOADER_STATE_INIT:
641 irreco_webdb_dlg_set_banner(self, _("Loading ..."), 0);
642 self->loader_state = LOADER_STATE_LOOP;
643 IRRECO_RETURN_BOOL(TRUE);
644
645 case LOADER_STATE_LOOP: {
646 GtkTreeIter iter;
647 GtkTreeIter iter_loading;
648 IrrecoStringTable *manufacturers = NULL;
649 IrrecoWebdbCache *webdb_cache = NULL;
650 gchar *category;
651
652 gtk_tree_model_get(GTK_TREE_MODEL(self->tree_store),
653 self->loader_parent_iter,
654 TEXT_COL, &category, -1);
655
656 webdb_cache = irreco_data_get_webdb_cache(self->irreco_data,
657 FALSE);
658
659 if(irreco_webdb_cache_get_manufacturers(webdb_cache,
660 category,
661 &manufacturers)){
662
663 IRRECO_STRING_TABLE_FOREACH_KEY(manufacturers, key)
664
665 /* Add manufacturer item into category. */
666 gtk_tree_store_append(self->tree_store,
667 &iter, self->loader_parent_iter);
668 gtk_tree_store_set(self->tree_store,
669 &iter,
670 TEXT_COL, key,
671 FLAG_COL, ROW_TYPE_MANUFACTURER,
672 DATA_COL, NULL, -1);
673
674 /* Add loading item into manufacturer. */
675 gtk_tree_store_append(self->tree_store,
676 &iter_loading, &iter);
677 gtk_tree_store_set(self->tree_store,
678 &iter_loading,
679 TEXT_COL, _("Loading ..."),
680 FLAG_COL, ROW_TYPE_LOADING,
681 DATA_COL, NULL, -1);
682
683 IRRECO_STRING_TABLE_FOREACH_END
684 } else {
685 irreco_error_dlg(GTK_WINDOW(self),
686 irreco_webdb_cache_get_error(
687 webdb_cache));
688 }
689
690 g_free (category);
691
692 /* Delete loading item from category. */
693 gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(self->tree_store),
694 &iter,self->loader_parent_iter,0);
695 if(irreco_webdb_dlg_row_get_type(self,
696 &iter) == ROW_TYPE_LOADING) {
697 gtk_tree_store_remove(self->tree_store,&iter);
698 }
699 irreco_webdb_dlg_set_banner(self, _("Loading ..."), 1);
700 self->loader_state = LOADER_STATE_END;
701 IRRECO_RETURN_BOOL(TRUE);
702 }
703
704 case LOADER_STATE_END:
705 irreco_webdb_dlg_row_set_loaded(self, self->loader_parent_iter,
706 TRUE);
707 irreco_webdb_dlg_hide_banner(self);
708 irreco_webdb_dlg_loader_stop(self);
709 }
710
711 IRRECO_RETURN_BOOL(FALSE);
712 }
713
714 /**
715 * Web Database Model loader.
716 *
717 * @todo
718 */
719 static gboolean irreco_webdb_dlg_loader_model(IrrecoWebdbDlg *self)
720 {
721 IRRECO_ENTER
722
723 switch (self->loader_state) {
724 case LOADER_STATE_INIT:
725 irreco_webdb_dlg_set_banner(self, _("Loading ..."), 0);
726 self->loader_state = LOADER_STATE_LOOP;
727 IRRECO_RETURN_BOOL(TRUE);
728
729 case LOADER_STATE_LOOP: {
730 GtkTreeIter iter;
731 GtkTreeIter iter_loading;
732 GtkTreeIter category_iter;
733 IrrecoStringTable *models = NULL;
734 IrrecoWebdbCache *webdb_cache = NULL;
735 gchar *category;
736 gchar *manufacturer;
737
738 /*Get category and manufacturer*/
739
740 gtk_tree_model_get(GTK_TREE_MODEL(self->tree_store),
741 self->loader_parent_iter,
742 TEXT_COL, &manufacturer, -1);
743
744 gtk_tree_model_iter_parent(GTK_TREE_MODEL(self->tree_store),
745 &category_iter,
746 self->loader_parent_iter);
747
748 gtk_tree_model_get(GTK_TREE_MODEL(self->tree_store),
749 &category_iter,
750 TEXT_COL, &category, -1);
751
752 webdb_cache = irreco_data_get_webdb_cache(self->irreco_data,
753 FALSE);
754
755 if(irreco_webdb_cache_get_models(webdb_cache, category,
756 manufacturer, &models)){
757
758 IRRECO_STRING_TABLE_FOREACH_KEY(models, key)
759
760 /* Add model item into manufacturer. */
761 gtk_tree_store_append(self->tree_store,
762 &iter, self->loader_parent_iter);
763 gtk_tree_store_set(self->tree_store,
764 &iter,
765 TEXT_COL, key,
766 FLAG_COL, ROW_TYPE_MODEL,
767 DATA_COL, NULL, -1);
768
769 /* Add loading item into model. */
770 gtk_tree_store_append(self->tree_store,
771 &iter_loading, &iter);
772 gtk_tree_store_set(self->tree_store,
773 &iter_loading,
774 TEXT_COL, _("Loading ..."),
775 FLAG_COL, ROW_TYPE_LOADING,
776 DATA_COL, NULL, -1);
777
778 IRRECO_STRING_TABLE_FOREACH_END
779 } else {
780 irreco_error_dlg(GTK_WINDOW(self),
781 irreco_webdb_cache_get_error(
782 webdb_cache));
783 }
784 g_free (category);
785 g_free (manufacturer);
786
787 /* Delete loading item from manufacturer. */
788 gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(self->tree_store),
789 &iter, self->loader_parent_iter,
790 0);
791 if(irreco_webdb_dlg_row_get_type(self,
792 &iter) == ROW_TYPE_LOADING) {
793 gtk_tree_store_remove(self->tree_store, &iter);
794 }
795
796 irreco_webdb_dlg_set_banner(self, _("Loading ..."), 1);
797 self->loader_state = LOADER_STATE_END;
798
799 IRRECO_RETURN_BOOL(TRUE);
800 }
801 case LOADER_STATE_END:
802 irreco_webdb_dlg_row_set_loaded(self, self->loader_parent_iter,
803 TRUE);
804 irreco_webdb_dlg_hide_banner(self);
805 irreco_webdb_dlg_loader_stop(self);
806 }
807
808 IRRECO_RETURN_BOOL(FALSE);
809 }
810
811 /**
812 * Web Database Config loader.
813 *
814 * @todo
815 */
816 static gboolean irreco_webdb_dlg_loader_config(IrrecoWebdbDlg *self)
817 {
818 IRRECO_ENTER
819
820 switch (self->loader_state) {
821 case LOADER_STATE_INIT:
822 irreco_webdb_dlg_set_banner(self, _("Loading ..."), 0);
823 self->loader_state = LOADER_STATE_LOOP;
824 self->loader_pos = 0;
825 IRRECO_RETURN_BOOL(TRUE);
826
827 case LOADER_STATE_LOOP: {
828 GtkTreeIter iter;
829 GtkTreeIter manufacturer_iter;
830 GtkTreeIter category_iter;
831 IrrecoWebdbConf *config = NULL;
832 IrrecoStringTable *configs = NULL;
833 IrrecoWebdbCache *webdb_cache = NULL;
834 const gchar *config_id = NULL;
835 gpointer id_data;
836 gchar *category;
837 gchar *manufacturer;
838 gchar *model;
839 gint config_count;
840 gfloat banner;
841
842 /*Get manufacturer_iter and category_iter */
843
844 gtk_tree_model_iter_parent(GTK_TREE_MODEL(self->tree_store),
845 &manufacturer_iter,
846 self->loader_parent_iter);
847
848 gtk_tree_model_iter_parent(GTK_TREE_MODEL(self->tree_store),
849 &category_iter,
850 &manufacturer_iter);
851
852 /*Get category, manufacturer and model*/
853
854 gtk_tree_model_get(GTK_TREE_MODEL(self->tree_store),
855 &category_iter,
856 TEXT_COL, &category, -1);
857
858 gtk_tree_model_get(GTK_TREE_MODEL(self->tree_store),
859 &manufacturer_iter,
860 TEXT_COL, &manufacturer, -1);
861
862 gtk_tree_model_get(GTK_TREE_MODEL(self->tree_store),
863 self->loader_parent_iter,
864 TEXT_COL, &model, -1);
865
866
867 webdb_cache = irreco_data_get_webdb_cache(self->irreco_data,
868 FALSE);
869
870 if(irreco_webdb_cache_get_configs(webdb_cache,
871 category, manufacturer, model, &configs)){
872 gint id;
873 irreco_string_table_index(configs, self->loader_pos,
874 &config_id, &id_data);
875 id = atoi(config_id);
876 if(irreco_webdb_cache_get_configuration(webdb_cache,
877 id, &config)){
878
879 /* Add config item into model. */
880 gtk_tree_store_append(self->tree_store,
881 &iter, self->loader_parent_iter);
882 gtk_tree_store_set(self->tree_store,
883 &iter,
884 TEXT_COL, config->user->str,
885 FLAG_COL, ROW_TYPE_CONFIG,
886 DATA_COL, config_id, -1);
887 } else {
888 irreco_error_dlg(GTK_WINDOW(self),
889 irreco_webdb_cache_get_error(
890 webdb_cache));
891 }
892
893 } else {
894 irreco_error_dlg(GTK_WINDOW(self),
895 irreco_webdb_cache_get_error(
896 webdb_cache));
897 }
898 g_free (category);
899 g_free (manufacturer);
900 g_free (model);
901
902
903 /* Delete loading item from model. */
904 gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(self->tree_store),
905 &iter, self->loader_parent_iter,
906 0);
907 if(irreco_webdb_dlg_row_get_type(self,
908 &iter) == ROW_TYPE_LOADING) {
909 gtk_tree_store_remove(self->tree_store, &iter);
910 }
911
912 config_count = irreco_string_table_lenght(configs);
913
914 banner = ((float) self->loader_pos + 1) / (float) config_count;
915 irreco_webdb_dlg_set_banner(self, _("Loading ..."), banner);
916
917 if (self->loader_pos + 1 >= config_count) {
918 self->loader_state = LOADER_STATE_END;
919 IRRECO_RETURN_BOOL(TRUE);
920 } else {
921 self->loader_pos++;
922 IRRECO_RETURN_BOOL(TRUE);
923 }
924
925
926 IRRECO_RETURN_BOOL(TRUE);
927 }
928 case LOADER_STATE_END:
929 irreco_webdb_dlg_row_set_loaded(self, self->loader_parent_iter,
930 TRUE);
931 irreco_webdb_dlg_hide_banner(self);
932 irreco_webdb_dlg_loader_stop(self);
933 }
934
935 IRRECO_RETURN_BOOL(FALSE);
936 }
937
938 /**
939 * Web Database Configuration details loader.
940 *
941 * @todo
942 */
943 static gboolean irreco_webdb_dlg_display_config_detail(IrrecoWebdbDlg *self,
944 GtkTreeIter * iter)
945 {
946 IrrecoWebdbCache *webdb_cache = NULL;
947 const gchar *config_id = NULL;
948 GString *download_count = g_string_new("");
949 gint config_id_int;
950 IRRECO_ENTER
951
952 gtk_tree_model_get(GTK_TREE_MODEL(self->tree_store),
953 iter, DATA_COL, &config_id, -1);
954
955 config_id_int = atoi(config_id);
956
957 webdb_cache = irreco_data_get_webdb_cache(self->irreco_data,
958 FALSE);
959
960 irreco_webdb_cache_get_configuration(webdb_cache,
961 config_id_int, &self->config);
962
963 gtk_label_set_text(GTK_LABEL(self->config_user),
964 self->config->user->str);
965 gtk_label_set_text(GTK_LABEL(self->config_backend),
966 self->config->backend->str);
967 gtk_label_set_text(GTK_LABEL(self->config_category),
968 self->config->category->str);
969 gtk_label_set_text(GTK_LABEL(self->config_manuf),
970 self->config->manufacturer->str);
971 gtk_label_set_text(GTK_LABEL(self->config_model),
972 self->config->model->str);
973 gtk_label_set_text(GTK_LABEL(self->config_uploaded),
974 self->config->file_uploaded->str);
975
976 g_string_printf(download_count, "%s times",
977 self->config->file_download_count->str);
978 gtk_label_set_text(GTK_LABEL(self->config_download_count),
979 download_count->str);
980 g_string_free(download_count, TRUE);
981
982 IRRECO_RETURN_BOOL(TRUE);
983 }
984
985
986 /**
987 * Web Database File loader.
988 *
989 * @todo
990 */
991 static gboolean irreco_webdb_dlg_load_file(IrrecoWebdbDlg *self)
992 {
993 IrrecoWebdbCache *webdb_cache = NULL;
994 IrrecoBackendInstance *inst = NULL;
995 GString *error_msg = g_string_new("");
996 IrrecoBackendManager *manager;
997 IrrecoBackendFileContainer *file_container;
998 GString *file_data;
999 gchar *sha1 = NULL;
1000 gboolean success = TRUE;
1001 gboolean new_instance = FALSE;
1002 gint instances;
1003 IRRECO_ENTER
1004
1005 if(self->config == NULL) {
1006 g_string_printf(error_msg, "Select configuration first");
1007 goto end;
1008 }
1009
1010 /* Get file_data */
1011 webdb_cache = irreco_data_get_webdb_cache(self->irreco_data, FALSE);
1012 if (!irreco_webdb_cache_get_file(webdb_cache,
1013 self->config->file_hash->str,
1014 self->config->file_name->str,
1015 &file_data)) {
1016 g_string_printf(error_msg, irreco_webdb_cache_get_error(
1017 webdb_cache));
1018 goto end;
1019 }
1020
1021 sha1 = g_compute_checksum_for_string(G_CHECKSUM_SHA1,
1022 file_data->str, -1);
1023
1024 if (g_utf8_collate(self->config->file_hash->str, sha1) != 0) {
1025 g_string_printf(error_msg, "sha1 checksum failed.");
1026 goto end;
1027
1028 }
1029
1030 /* Search backend */
1031 manager = self->irreco_data->irreco_backend_manager;
1032 IRRECO_BACKEND_MANAGER_FOREACH_LIB(manager, lib)
1033 if (g_utf8_collate(lib->name, self->config->backend->str) != 0){
1034 continue;
1035 }
1036 if (!(lib->api->flags & IRRECO_BACKEND_EDITABLE_DEVICES)) {
1037 g_string_printf(error_msg,
1038 "\"%s\" backend is not editable...",
1039 self->config->backend->str);
1040 goto end;
1041 }
1042 else if (!(lib->api->flags &
1043 IRRECO_BACKEND_CONFIGURATION_EXPORT)) {
1044 g_string_printf(error_msg,
1045 "\"%s\" backend doesn't support "
1046 "exporting its configuration...",
1047 self->config->backend->str);
1048 goto end;
1049 }
1050 /* Check if many instances */
1051 instances = 0;
1052 IRRECO_BACKEND_MANAGER_FOREACH_INSTANCE(manager, instance)
1053 irreco_backend_instance_get_description(instance);
1054 if (g_utf8_collate(instance->lib->name,
1055 self->config->backend->str) == 0) {
1056 instances++;
1057
1058 /*if there is only one instance, then use it */
1059 inst = instance;
1060 }
1061 IRRECO_STRING_TABLE_FOREACH_END
1062 IRRECO_DEBUG("INSTACES: %d\n",instances);
1063
1064 /* Create new instance if it comes to the crunch */
1065 if (instances == 0 || lib->api->flags &
1066 IRRECO_BACKEND_NEW_INST_ON_CONF_IMPORT) {
1067 inst = irreco_backend_manager_create_instance(
1068 manager, lib, NULL, NULL);
1069 new_instance = TRUE;
1070 break;
1071 }
1072
1073 /* Select instace */
1074 if (instances > 1) {
1075 if (!irreco_show_select_instance_dlg(
1076 self->irreco_data, GTK_WINDOW(self),
1077 self->config->backend->str, &inst)) {
1078 g_string_printf(error_msg,
1079 "Operation aborted by user...");
1080 goto end;
1081 }
1082 }
1083 goto instance_ready;
1084 IRRECO_STRING_TABLE_FOREACH_END
1085
1086 if (inst == NULL) {
1087 g_string_printf(error_msg, "\"%s\" backend is not installed...",
1088 self->config->backend->str);
1089 goto end;
1090 }
1091
1092 irreco_backend_instance_configure(inst, GTK_WINDOW(self));
1093 irreco_backend_instance_save_to_conf(inst);
1094 irreco_config_save_backends(manager);
1095
1096 instance_ready:
1097 file_container = irreco_backend_file_container_new();
1098 irreco_backend_file_container_set(file_container,
1099 inst->lib->name,
1100 self->config->category->str,
1101 self->config->manufacturer->str,
1102 self->config->model->str,
1103 self->config->file_name->str,
1104 file_data->str);
1105
1106 if (irreco_backend_instance_check_conf(inst, file_container)) {
1107 GString *question = g_string_new("");
1108 g_string_printf(question, "\"%s\" backend already contains\n"
1109 "device \"%s\".\n"
1110 "Do you want to overwrite?",
1111 inst->lib->name,self->config->model->str);
1112 success = irreco_yes_no_dlg(GTK_WINDOW(self), question->str);
1113 g_string_free(question, TRUE);
1114
1115 if(success == FALSE) {
1116 goto end;
1117 }
1118 }
1119
1120 /* Send file_data for backend */
1121 if(irreco_backend_instance_import_conf(inst, file_container)) {
1122 irreco_info_dlg(GTK_WINDOW(self),
1123 "Configuration downloaded successfully!");
1124 irreco_backend_manager_get_devcmd_lists(
1125 self->irreco_data->irreco_backend_manager);
1126 } else {
1127 g_string_printf(error_msg, "Backend error");
1128
1129 if (new_instance) {
1130 irreco_backend_manager_destroy_instance(manager, inst);
1131 }
1132 goto end;
1133 }
1134
1135 end:
1136 if(error_msg->len > 0) {
1137 irreco_error_dlg(GTK_WINDOW(self), error_msg->str);
1138 success = FALSE;
1139 }
1140 g_string_free(error_msg, TRUE);
1141 if (sha1 != NULL) g_free(sha1);
1142 IRRECO_RETURN_BOOL(success);
1143 }
1144
1145 /** @} */
1146
1147
1148
1149 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
1150 /* Functions */
1151 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
1152
1153 /**
1154 * @name Public Functions
1155 * @{
1156 */
1157
1158 void irreco_webdb_dlg_set_irreco_data(IrrecoWebdbDlg *self,
1159 IrrecoData *irreco_data)
1160 {
1161 IRRECO_ENTER
1162 self->irreco_data = irreco_data;
1163 IRRECO_RETURN
1164 }
1165
1166 void irreco_show_webdb_dlg(IrrecoData *irreco_data, GtkWindow *parent)
1167 {
1168 IrrecoWebdbDlg *self;
1169 gint response;
1170 gboolean loop = TRUE;
1171 IRRECO_ENTER
1172
1173 self = IRRECO_WEBDB_DLG(irreco_webdb_dlg_new(irreco_data, parent));
1174
1175 do {
1176 response = gtk_dialog_run(GTK_DIALOG(self));
1177 switch (response) {
1178 case IRRECO_DEVICE_REFRESH:
1179 IRRECO_DEBUG("IRRECO_DEVICE_REFRESH\n");
1180 gtk_tree_store_clear(self->tree_store);
1181 irreco_data_get_webdb_cache(self->irreco_data, TRUE);
1182 irreco_webdb_dlg_loader_start(self,
1183 G_SOURCEFUNC(irreco_webdb_dlg_loader_categ),
1184 NULL);
1185 break;
1186
1187 case GTK_RESPONSE_DELETE_EVENT:
1188 IRRECO_DEBUG("GTK_RESPONSE_DELETE_EVENT\n");
1189 loop = FALSE;
1190 break;
1191
1192 case GTK_RESPONSE_OK:
1193 IRRECO_DEBUG("GTK_RESPONSE_OK\n");
1194 loop = !irreco_webdb_dlg_load_file(self);
1195 break;
1196
1197 }
1198 } while (loop);
1199
1200 gtk_widget_destroy(GTK_WIDGET(self));
1201 IRRECO_RETURN
1202 }
1203
1204 /** @} */
1205
1206
1207
1208 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
1209 /* Events and Callbacks */
1210 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
1211
1212 /**
1213 * @name Events and Callbacks
1214 * @{
1215 */
1216
1217 static gboolean irreco_show_webdb_dlg_map_event(IrrecoWebdbDlg *self,
1218 GdkEvent *event,
1219 gpointer user_data)
1220 {
1221 IRRECO_ENTER
1222 irreco_webdb_dlg_loader_start(
1223 self, G_SOURCEFUNC(irreco_webdb_dlg_loader_categ), NULL);
1224 IRRECO_RETURN_BOOL(FALSE);
1225 }
1226
1227 static void irreco_show_webdb_dlg_destroy_event(IrrecoWebdbDlg *self,
1228 gpointer user_data)
1229 {
1230 IRRECO_ENTER
1231 irreco_webdb_dlg_loader_stop(self);
1232 IRRECO_RETURN
1233 }
1234
1235 static void irreco_show_webdb_dlg_row_activated_event(GtkTreeView *tree_view,
1236 GtkTreePath *path,
1237 GtkTreeViewColumn *column,
1238 IrrecoWebdbDlg *self)
1239 {
1240 IRRECO_ENTER
1241
1242 if (gtk_tree_view_row_expanded(tree_view, path)) {
1243 gtk_tree_view_expand_row(tree_view, path, FALSE);
1244 } else {
1245 gtk_tree_view_collapse_row(tree_view, path);
1246 }
1247 IRRECO_RETURN
1248 }
1249
1250 static void irreco_show_webdb_dlg_row_expanded_event(GtkTreeView *tree_view,
1251 GtkTreeIter *iter,
1252 GtkTreePath *path,
1253 IrrecoWebdbDlg *self)
1254 {
1255 IRRECO_ENTER
1256
1257 irreco_webdb_dlg_clean_details(self);
1258
1259 if (self->loader_func_id != 0) {
1260 gtk_tree_view_collapse_row(tree_view, path);
1261 }
1262
1263 if (!irreco_webdb_dlg_row_is_loaded(self, iter)) {
1264 switch (irreco_webdb_dlg_row_get_type(self, iter)) {
1265 case ROW_TYPE_CATEGORY:
1266 irreco_webdb_dlg_loader_start(self,
1267 G_SOURCEFUNC(irreco_webdb_dlg_loader_manuf),
1268 iter);
1269 break;
1270
1271 case ROW_TYPE_MANUFACTURER:
1272 irreco_webdb_dlg_loader_start(self,
1273 G_SOURCEFUNC(irreco_webdb_dlg_loader_model),
1274 iter);
1275 break;
1276
1277 case ROW_TYPE_MODEL:
1278 irreco_webdb_dlg_loader_start(self,
1279 G_SOURCEFUNC(irreco_webdb_dlg_loader_config),
1280 iter);
1281 break;
1282 }
1283 }
1284
1285 IRRECO_RETURN
1286 }
1287
1288 static void irreco_show_webdb_dlg_row_collapsed_event(GtkTreeView *tree_view,
1289 GtkTreeIter *iter,
1290 GtkTreePath *path,
1291 IrrecoWebdbDlg *self)
1292 {
1293 IRRECO_ENTER
1294
1295 irreco_webdb_dlg_clean_details(self);
1296
1297 IRRECO_RETURN
1298 }
1299
1300 static void irreco_show_webdb_dlg_row_selected_event(GtkTreeSelection *sel,
1301 IrrecoWebdbDlg *self)
1302 {
1303 GtkTreeIter iter;
1304 GtkTreeModel *model;
1305
1306 IRRECO_ENTER
1307
1308 if (gtk_tree_selection_get_selected (sel, &model, &iter))
1309 {
1310 switch (irreco_webdb_dlg_row_get_type(self, &iter)) {
1311
1312 case ROW_TYPE_CONFIG:
1313 IRRECO_DEBUG("ROW_TYPE_CONFIG\n");
1314 irreco_webdb_dlg_display_config_detail(self, &iter);
1315 break;
1316
1317 default:
1318 irreco_webdb_dlg_clean_details(self);
1319 break;
1320 }
1321 }
1322
1323 IRRECO_RETURN
1324 }
1325
1326 /** @} */
1327 /** @} */
1328
Irreco is a remote control application for Nokia Internet Tablets.