?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Clean code
[irreco.git] / irreco / src / core / irreco_cmd_dlg.c
blob928765793873dddf90910d13f75fcf3d97de23a8
1 /*
2 * irreco - Ir Remote Control
3 * Copyright (C) 2007 Arto Karppinen (arto.karppinen@iki.fi)
4 *
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License
7 * as published by the Free Software Foundation; either version 2
8 * of the License, or (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18 */
19
20 #include "irreco_cmd_dlg.h"
21 #include "irreco_backend_dlg.h"
22 #include "irreco_backend_instance.h"
23
24 /**
25 * @addtogroup IrrecoCmdDlg
26 * @ingroup Irreco
27 *
28 * Show a dialog where the user can select one command from a list of all
29 * possible commands
30 *
31 * @{
32 */
33
34 /**
35 * @file
36 * Source file of @ref IrrecoCmdDlg.
37 */
38
39
40 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
41 /* Types and definitions. */
42 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
43
44
45 #define IRRECO_SELECT_CMD_DLG_BUTTON_ROW_WIDTH 600
46 #define IRRECO_SELECT_CMD_DLG_BUTTON_PAD 5
47 #define IRRECO_SELECT_CMD_DLG_EXPAND_BUTTONS FALSE
48
49 enum
50 {
51 IRRECO_RESPONCE_EDIT = 1,
52 IRRECO_RESPONCE_REFRESH,
53 IRRECO_RESPONCE_COMMAND_SET
54 };
55
56 typedef struct _IrrecoButtonAppend IrrecoButtonAppend;
57 struct _IrrecoButtonAppend {
58 GtkWidget *vbox;
59 GtkWidget *hbox;
60 uint width;
61 uint count;
62 };
63
64 typedef struct _IrrecoSelectCmdDlg IrrecoSelectCmdDlg;
65 struct _IrrecoSelectCmdDlg {
66 IrrecoData *irreco_data;
67 IrrecoCmd *command;
68 GtkWidget *dialog;
69 GtkWidget *scrolled;
70 GtkWidget *vbox;
71 };
72
73
74
75 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
76 /* Prototypes. */
77 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
78
79
80 void irreco_cmd_dlg_create_command_list(IrrecoSelectCmdDlg * cmd_dlg);
81 void irreco_cmd_dlg_setup_scrollbars(GtkWidget * widget);
82 void irreco_cmd_dlg_append_device(IrrecoSelectCmdDlg * cmd_dlg,
83 IrrecoBackendDevice * device);
84 void irreco_cmd_dlg_append_special(IrrecoSelectCmdDlg * cmd_dlg);
85 void irreco_cmd_dlg_append_wait_button(IrrecoSelectCmdDlg * cmd_dlg,
86 IrrecoButtonAppend * button_append,
87 uint delay);
88 GtkWidget *irreco_cmd_dlg_append_hbox(GtkWidget *vbox,
89 guint padding_between,
90 guint padding_top,
91 guint padding_bottom,
92 guint padding_left,
93 guint padding_right,
94 gfloat x_expand_scale,
95 gfloat y_expand_scale);
96 GtkWidget *irreco_cmd_dlg_append_title_hbox(GtkWidget *vbox);
97 GtkWidget *irreco_cmd_dlg_append_command_hbox(GtkWidget *vbox);
98 void irreco_cmd_dlg_append_button_init(IrrecoButtonAppend * data,
99 GtkWidget *vbox);
100 GtkWidget *irreco_cmd_dlg_append_button(IrrecoButtonAppend * data,
101 const gchar *tite);
102
103
104
105 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
106 /* Run. */
107 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
108
109 /**
110 * @name Run
111 * @{
112 */
113
114
115 gboolean irreco_cmd_dlg_run(IrrecoData *irreco_data, IrrecoCmd * command,
116 GtkWindow *parent)
117 {
118 IrrecoSelectCmdDlg cmd_dlg;
119 gint rvalue = -1;
120 IRRECO_ENTER
121
122 memset(&cmd_dlg, '\0', sizeof(cmd_dlg));
123 cmd_dlg.irreco_data = irreco_data;
124 cmd_dlg.command = command;
125
126 /* Create objects. */
127 cmd_dlg.dialog = gtk_dialog_new_with_buttons(
128 _("Select command"), parent,
129 /*irreco_window_manager_get_gtk_window(
130 irreco_data->window_manager),*/
131 GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT /* |
132 GTK_DIALOG_NO_SEPARATOR*/,
133 _("Refresh"), IRRECO_RESPONCE_REFRESH,
134 GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
135 /*_("Device controllers"), IRRECO_RESPONCE_EDIT,*/
136 NULL);
137 cmd_dlg.scrolled = gtk_scrolled_window_new(0, 0);
138
139 /* Construct dialog. */
140 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(cmd_dlg.scrolled),
141 GTK_POLICY_NEVER,
142 GTK_POLICY_AUTOMATIC);
143 gtk_container_add(GTK_CONTAINER(GTK_DIALOG(cmd_dlg.dialog)->vbox),
144 cmd_dlg.scrolled);
145 irreco_cmd_dlg_create_command_list(&cmd_dlg);
146
147 /* Scrollbar setup signal. */
148 g_signal_connect(G_OBJECT(cmd_dlg.scrolled), "size-allocate",
149 G_CALLBACK(irreco_cmd_dlg_setup_scrollbars),
150 NULL);
151
152 /* Min width, max height. */
153 gtk_window_resize(GTK_WINDOW(cmd_dlg.dialog), 1, 999);
154 gtk_widget_show_all(cmd_dlg.dialog);
155
156 while (rvalue == -1) {
157 switch (gtk_dialog_run(GTK_DIALOG(cmd_dlg.dialog))) {
158 case GTK_RESPONSE_REJECT:
159 rvalue = FALSE;
160 break;
161
162 case IRRECO_RESPONCE_COMMAND_SET:
163 rvalue = TRUE;
164 break;
165
166 case IRRECO_RESPONCE_EDIT:
167 irreco_show_backend_dlg(irreco_data,
168 GTK_WINDOW(cmd_dlg.dialog));
169 irreco_cmd_dlg_create_command_list(&cmd_dlg);
170 break;
171
172 case IRRECO_RESPONCE_REFRESH:
173 irreco_backend_manager_get_devcmd_lists(
174 irreco_data->irreco_backend_manager);
175 irreco_cmd_dlg_create_command_list(&cmd_dlg);
176 break;
177 }
178 }
179
180 gtk_widget_destroy(cmd_dlg.dialog);
181 IRRECO_RETURN_INT(rvalue);
182 }
183
184 void irreco_cmd_dlg_create_command_list(IrrecoSelectCmdDlg * cmd_dlg)
185 {
186 const gchar *name = NULL;
187 IRRECO_ENTER
188
189 if (cmd_dlg->vbox != NULL) {
190 gtk_widget_destroy(cmd_dlg->vbox);
191 }
192 cmd_dlg->vbox = gtk_vbox_new(FALSE, 0);
193 gtk_scrolled_window_add_with_viewport(
194 GTK_SCROLLED_WINDOW(cmd_dlg->scrolled), cmd_dlg->vbox);
195
196 /* Iterate trough instance, device and command arrays. */
197 IRRECO_DEBUG("Generating command list\n");
198 IRRECO_BACKEND_MANAGER_FOREACH_INSTANCE(
199 cmd_dlg->irreco_data->irreco_backend_manager, instance)
200
201 name = irreco_backend_instance_get_name(instance);
202 IRRECO_DEBUG("Instance: \"%s\"\n", name);
203
204 IRRECO_BACKEND_INSTANCE_FOREACH(instance, device)
205 IRRECO_DEBUG("Device: \"%s\"\n", device->name);
206 irreco_cmd_dlg_append_device(cmd_dlg, device);
207 IRRECO_BACKEND_INSTANCE_FOREACH_END
208
209 IRRECO_STRING_TABLE_FOREACH_END
210
211 IRRECO_DEBUG("Special commands.\n");
212 irreco_cmd_dlg_append_special(cmd_dlg);
213 gtk_widget_show_all(cmd_dlg->dialog);
214
215 IRRECO_RETURN
216 }
217
218 /** @} */
219
220
221
222 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
223 /* Signal handlers. */
224 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
225
226 /**
227 * @name Signal handlers
228 * @{
229 */
230
231
232 void irreco_cmd_dlg_set_built_in(GtkButton * button,
233 IrrecoSelectCmdDlg * cmd_dlg)
234 {
235 gpointer type;
236 IRRECO_ENTER
237
238 type = g_object_get_data(G_OBJECT(button), "IrrecoCmdType");
239 irreco_cmd_set_builtin(cmd_dlg->command, (IrrecoCmdType) type);
240 gtk_dialog_response(GTK_DIALOG(cmd_dlg->dialog),
241 IRRECO_RESPONCE_COMMAND_SET);
242
243 IRRECO_RETURN
244 }
245
246 void irreco_cmd_dlg_set_layout(GtkButton * button,
247 IrrecoSelectCmdDlg * cmd_dlg)
248 {
249 gpointer name;
250 IRRECO_ENTER
251
252 name = g_object_get_data(G_OBJECT(button), "IrrecoCmdLayout");
253 irreco_cmd_set_layout(cmd_dlg->command, (const gchar *) name);
254 gtk_dialog_response(GTK_DIALOG(cmd_dlg->dialog),
255 IRRECO_RESPONCE_COMMAND_SET);
256
257 IRRECO_RETURN
258 }
259
260 void irreco_cmd_dlg_set_backend(GtkButton * button,
261 IrrecoSelectCmdDlg * cmd_dlg)
262 {
263 IrrecoBackendDevice *device;
264 const gchar *command;
265 IRRECO_ENTER
266
267 device = (IrrecoBackendDevice *) g_object_get_data(
268 G_OBJECT(button), "IrrecoCmdBackendDevice");
269 command = (const gchar *) g_object_get_data(
270 G_OBJECT(button), "IrrecoCmdBackendCommand");
271 irreco_cmd_set_backend(cmd_dlg->command,
272 device->backend_instance,
273 device->name,
274 command);
275 gtk_dialog_response(GTK_DIALOG(cmd_dlg->dialog),
276 IRRECO_RESPONCE_COMMAND_SET);
277
278 IRRECO_RETURN
279 }
280
281 void irreco_cmd_dlg_set_wait(GtkButton * button, IrrecoSelectCmdDlg * cmd_dlg)
282 {
283 gpointer delay;
284 IRRECO_ENTER
285
286 delay = g_object_get_data(G_OBJECT(button), "IrrecoCmdWaitDelay");
287 irreco_cmd_set_wait(cmd_dlg->command, (gulong) delay);
288 gtk_dialog_response(GTK_DIALOG(cmd_dlg->dialog),
289 IRRECO_RESPONCE_COMMAND_SET);
290
291 IRRECO_RETURN
292 }
293
294 /*
295 * Set up scrollbars so that a tap on the scrollbar will scroll almost one
296 * screen worth of space.
297 */
298 void irreco_cmd_dlg_setup_scrollbars(GtkWidget * widget)
299 {
300 GtkAdjustment *adjustment;
301 IRRECO_ENTER
302
303 adjustment = gtk_scrolled_window_get_vadjustment(
304 GTK_SCROLLED_WINDOW(widget));
305 adjustment->step_increment = adjustment->page_size * 0.65;
306 adjustment->page_increment = adjustment->page_size * 0.65;
307
308 IRRECO_DEBUG("value %f\n", adjustment->value);
309 IRRECO_DEBUG("lower %f\n", adjustment->lower);
310 IRRECO_DEBUG("upper %f\n", adjustment->upper);
311 IRRECO_DEBUG("step_increment %f\n", adjustment->step_increment);
312 IRRECO_DEBUG("page_increment %f\n", adjustment->page_increment);
313 IRRECO_DEBUG("page_size %f\n", adjustment->page_size);
314
315 IRRECO_RETURN
316 }
317
318 /** @} */
319
320
321
322 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
323 /* Dialog construction. */
324 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
325
326 /**
327 * @name Dialog construction
328 * @{
329 */
330
331
332 void irreco_cmd_dlg_append_commands(IrrecoSelectCmdDlg * cmd_dlg,
333 IrrecoBackendDevice * device)
334 {
335 IrrecoButtonAppend button_append;
336 GtkWidget *button;
337 IRRECO_ENTER
338
339 irreco_cmd_dlg_append_button_init(&button_append, cmd_dlg->vbox);
340 IRRECO_BACKEND_DEVICE_FOREACH(device, command)
341 button = irreco_cmd_dlg_append_button(&button_append,
342 command);
343 g_object_set_data(G_OBJECT(button),
344 "IrrecoCmdBackendDevice",
345 (gpointer) device);
346 g_object_set_data(G_OBJECT(button),
347 "IrrecoCmdBackendCommand",
348 (gpointer) command);
349 g_signal_connect(G_OBJECT(button), "clicked",
350 G_CALLBACK(irreco_cmd_dlg_set_backend),
351 cmd_dlg);
352 IRRECO_BACKEND_DEVICE_FOREACH_END
353 IRRECO_RETURN
354 }
355
356 void irreco_cmd_dlg_append_device(IrrecoSelectCmdDlg * cmd_dlg,
357 IrrecoBackendDevice * device)
358 {
359 GtkWidget *hbox;
360 GtkWidget *arrow;
361 GtkWidget *arrow_align;
362 GtkWidget *device_label;
363 GtkWidget *instance_label;
364 IRRECO_ENTER
365
366 hbox = irreco_cmd_dlg_append_title_hbox(cmd_dlg->vbox);
367 arrow = gtk_arrow_new(GTK_ARROW_RIGHT, GTK_SHADOW_NONE);
368 arrow_align = gtk_alignment_new(0.5, 0.5, 1, 1);
369 device_label = gtk_label_new(device->name);
370 instance_label = gtk_label_new(
371 irreco_backend_instance_get_name(device->backend_instance));
372
373 /*
374 instance_label = gtk_label_new(
375 irreco_backend_instance_get_name_and_description(
376 device->backend_instance));
377 */
378
379 /* Arrow: 25px width, auto height, 5px padding left and right.*/
380 gtk_widget_set_size_request(arrow, 25, 0);
381 gtk_misc_set_alignment(GTK_MISC(arrow), 0.5, 0.5);
382 gtk_alignment_set_padding(GTK_ALIGNMENT(arrow_align), 0, 0, 8, 8);
383
384 gtk_misc_set_alignment(GTK_MISC(device_label), 0, 0.5);
385 gtk_misc_set_alignment(GTK_MISC(instance_label), 0, 0.5);
386
387 gtk_container_add(GTK_CONTAINER(arrow_align), arrow);
388 gtk_box_pack_start(GTK_BOX(hbox), instance_label, 0, 0, 0);
389 gtk_box_pack_start(GTK_BOX(hbox), arrow_align, 0, 0, 0);
390 gtk_box_pack_start(GTK_BOX(hbox), device_label, 0, 0, 0);
391
392 if (irreco_backend_device_is_empty(device)) {
393 GtkWidget *label = gtk_label_new(_("This device does not "
394 "have any commands."));
395 hbox = irreco_cmd_dlg_append_command_hbox(cmd_dlg->vbox);
396 gtk_box_pack_start_defaults(GTK_BOX(hbox), label);
397 } else {
398 /*GtkWidget *command_vbox = gtk_vbox_new(FALSE, 10);*/
399 irreco_cmd_dlg_append_commands(cmd_dlg, device);
400 }
401
402 IRRECO_RETURN
403 }
404
405
406
407 void irreco_cmd_dlg_append_special(IrrecoSelectCmdDlg * cmd_dlg)
408 {
409 GtkWidget *hbox;
410 GtkWidget *label;
411 GtkWidget *button;
412 IrrecoButtonAppend button_append;
413 GString *string;
414 IRRECO_ENTER
415
416 hbox = irreco_cmd_dlg_append_title_hbox(cmd_dlg->vbox);
417 label = gtk_label_new(_("Special commands"));
418 gtk_box_pack_start(GTK_BOX(hbox), label, 0, 0, 0);
419
420 /* Create next remote button. */
421 irreco_cmd_dlg_append_button_init(&button_append, cmd_dlg->vbox);
422 button = irreco_cmd_dlg_append_button(
423 &button_append, _(IRRECO_COMMAND_NEXT_REMOTE_TITLE));
424 g_object_set_data(G_OBJECT(button), "IrrecoCmdType",
425 (gpointer) IRRECO_COMMAND_NEXT_REMOTE);
426 g_signal_connect(G_OBJECT(button), "clicked",
427 G_CALLBACK(irreco_cmd_dlg_set_built_in),
428 cmd_dlg);
429
430 /* Create previous remote button. */
431 button = irreco_cmd_dlg_append_button(
432 &button_append, _(IRRECO_COMMAND_PREVIOUS_REMOTE_TITLE));
433 g_object_set_data(G_OBJECT(button), "IrrecoCmdType",
434 (gpointer) IRRECO_COMMAND_PREVIOUS_REMOTE);
435 g_signal_connect(G_OBJECT(button), "clicked",
436 G_CALLBACK(irreco_cmd_dlg_set_built_in),
437 cmd_dlg);
438
439 /* Fullscreen toggle button. */
440 button = irreco_cmd_dlg_append_button(
441 &button_append, _(IRRECO_COMMAND_FULLSCREEN_TOGGLE_TITLE));
442 g_object_set_data(G_OBJECT(button), "IrrecoCmdType",
443 (gpointer) IRRECO_COMMAND_FULLSCREEN_TOGGLE);
444 g_signal_connect(G_OBJECT(button), "clicked",
445 G_CALLBACK(irreco_cmd_dlg_set_built_in),
446 cmd_dlg);
447
448 /* Create show remote buttons. */
449 string = g_string_new("");
450 IRRECO_STRING_TABLE_FOREACH_KEY(
451 cmd_dlg->irreco_data->irreco_layout_array, layout_name)
452 g_string_append(g_string_set_size(string, 0),
453 _(IRRECO_COMMAND_SHOW_LAYOUT_TITLE_PREFIX));
454 g_string_append(string, layout_name);
455 button = irreco_cmd_dlg_append_button(&button_append,
456 string->str);
457 g_object_set_data(G_OBJECT(button), "IrrecoCmdLayout",
458 (gpointer) layout_name);
459 g_signal_connect(G_OBJECT(button), "clicked",
460 G_CALLBACK(irreco_cmd_dlg_set_layout),
461 cmd_dlg);
462 IRRECO_STRING_TABLE_FOREACH_END
463 g_string_free(string, TRUE);
464
465 /* Append wait buttons. */
466 irreco_cmd_dlg_append_wait_button(cmd_dlg, &button_append,
467 IRRECO_SECONDS_TO_USEC(0.3));
468 irreco_cmd_dlg_append_wait_button(cmd_dlg, &button_append,
469 IRRECO_SECONDS_TO_USEC(0.6));
470 irreco_cmd_dlg_append_wait_button(cmd_dlg, &button_append,
471 IRRECO_SECONDS_TO_USEC(1));
472 irreco_cmd_dlg_append_wait_button(cmd_dlg, &button_append,
473 IRRECO_SECONDS_TO_USEC(1.5));
474 irreco_cmd_dlg_append_wait_button(cmd_dlg, &button_append,
475 IRRECO_SECONDS_TO_USEC(2));
476 irreco_cmd_dlg_append_wait_button(cmd_dlg, &button_append,
477 IRRECO_SECONDS_TO_USEC(3));
478 irreco_cmd_dlg_append_wait_button(cmd_dlg, &button_append,
479 IRRECO_SECONDS_TO_USEC(5));
480 irreco_cmd_dlg_append_wait_button(cmd_dlg, &button_append,
481 IRRECO_SECONDS_TO_USEC(7));
482 irreco_cmd_dlg_append_wait_button(cmd_dlg, &button_append,
483 IRRECO_SECONDS_TO_USEC(10));
484 IRRECO_RETURN
485 }
486
487 void irreco_cmd_dlg_append_wait_button(IrrecoSelectCmdDlg * cmd_dlg,
488 IrrecoButtonAppend * button_append,
489 uint delay)
490 {
491 GtkWidget *button;
492 IrrecoCmd *command;
493 IRRECO_ENTER
494
495 /* Set title. */
496 command = irreco_cmd_create();
497 irreco_cmd_set_wait(command, delay);
498 button = irreco_cmd_dlg_append_button(
499 button_append, irreco_cmd_get_short_name(command));
500 irreco_cmd_destroy(command);
501
502 /* Set title.
503 string = g_string_new(NULL);
504 g_string_printf(string, _(IRRECO_COMMAND_WAIT_TITLE_FORMAT),
505 (float)(delay) / 1000);
506
507 g_string_free(string, TRUE);
508 */
509
510 /* Set callback. */
511 g_object_set_data(G_OBJECT(button), "IrrecoCmdWaitDelay",
512 (gpointer) delay);
513 g_signal_connect(G_OBJECT(button), "clicked",
514 G_CALLBACK(irreco_cmd_dlg_set_wait),
515 cmd_dlg);
516 IRRECO_RETURN
517 }
518
519 /** @} */
520
521
522
523 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
524 /* GtkHBox utility functions. */
525 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
526
527 /**
528 * @name GtkHBox utility functions
529 * @{
530 */
531
532
533 GtkWidget *irreco_cmd_dlg_append_hbox(GtkWidget * vbox,
534 guint padding_between,
535 guint padding_top,
536 guint padding_bottom,
537 guint padding_left,
538 guint padding_right,
539 gfloat x_expand_scale,
540 gfloat y_expand_scale)
541 {
542 GtkWidget *hbox;
543 GtkWidget *align;
544 IRRECO_ENTER
545
546 hbox = gtk_hbox_new(FALSE, padding_between);
547 align = irreco_gtk_align(hbox, 0, 0, x_expand_scale, y_expand_scale,
548 padding_top, padding_bottom, padding_left,
549 padding_right);
550 gtk_box_pack_start(GTK_BOX(vbox), align, 0, 0, 0);
551 IRRECO_RETURN_PTR(hbox);
552 }
553
554 void irreco_cmd_dlg_append_separator(GtkWidget * vbox,
555 guint padding_top,
556 guint padding_bottom)
557 {
558 GtkWidget *align;
559 IRRECO_ENTER
560
561 align = irreco_gtk_align(gtk_hseparator_new(), 0, 0, 1, 1,
562 padding_top, padding_bottom, 20, 0);
563 gtk_box_pack_start(GTK_BOX(vbox), align, 0, 0, 0);
564 IRRECO_RETURN
565 }
566
567 GtkWidget *irreco_cmd_dlg_append_title_hbox(GtkWidget * vbox)
568 {
569 GtkWidget* hbox;
570 IRRECO_ENTER
571
572 hbox = irreco_cmd_dlg_append_hbox(vbox,
573 0, /*padding_between */
574 15, /*padding_top */
575 0, /*padding_bottom */
576 25, /*padding_left */
577 20, /*padding_right */
578 0, /* x_expand_scale */
579 0 /* y_expand_scale */
580 );
581 irreco_cmd_dlg_append_separator(vbox, 2, 6);
582 IRRECO_RETURN_PTR(hbox);
583 }
584
585 GtkWidget *irreco_cmd_dlg_append_command_hbox(GtkWidget * vbox)
586 {
587 return irreco_cmd_dlg_append_hbox(vbox,
588 IRRECO_SELECT_CMD_DLG_BUTTON_PAD, /* padding_between */
589 0, /* padding_top */
590 IRRECO_SELECT_CMD_DLG_BUTTON_PAD, /* padding_bottom */
591 25, /* padding_left */
592 20, /* padding_right */
593 IRRECO_SELECT_CMD_DLG_EXPAND_BUTTONS, /* x_expand_scale */
594 0 /* y_expand_scale */
595 );
596 }
597
598 /** @} */
599
600
601
602 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
603 /* Button adding to button rows. */
604 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
605
606 /**
607 * @name Button adding to button rows
608 * @{
609 */
610
611
612 /*
613 * Initialize IrrecoButtonAppend structure.
614 *
615 * There is no need to clean IrrecoButtonAppend structure because all
616 * created widgets will be attached to the vbox.
617 */
618 void irreco_cmd_dlg_append_button_init(IrrecoButtonAppend * data,
619 GtkWidget *vbox)
620 {
621 IRRECO_ENTER
622 data->vbox = vbox;
623 data->hbox = irreco_cmd_dlg_append_command_hbox(vbox);
624 data->width = 0;
625 data->count = 0;
626 IRRECO_RETURN
627 }
628
629 /*
630 * Add a button to button row. Creates a new button row if current is full.
631 *
632 * Returns: a new GtkButton.
633 */
634 GtkWidget *irreco_cmd_dlg_append_button(IrrecoButtonAppend * data,
635 const gchar * title)
636 {
637 GtkWidget *button;
638 GtkRequisition requisition;
639 IRRECO_ENTER
640
641 /* Because you cant get widget data->width without adding it to a
642 container, this code does thing a bit backwards. */
643 button = gtk_button_new_with_label(title);
644 gtk_box_pack_start_defaults(GTK_BOX(data->hbox), button);
645 gtk_widget_size_request(GTK_WIDGET(button), &requisition);
646 data->width += requisition.width + IRRECO_SELECT_CMD_DLG_BUTTON_PAD;
647
648 /* If we have too much buttons on one row, destroy button,
649 and create another button on a new row. */
650 if (data->width > IRRECO_SELECT_CMD_DLG_BUTTON_ROW_WIDTH
651 && data->count > 0) {
652 gtk_widget_destroy(button);
653 data->count = 0;
654 data->width = requisition.width +
655 IRRECO_SELECT_CMD_DLG_BUTTON_PAD;
656 data->hbox = irreco_cmd_dlg_append_command_hbox(data->vbox);
657 button = gtk_button_new_with_label(title);
658 gtk_box_pack_start_defaults(GTK_BOX(data->hbox), button);
659 }
660
661 data->count += 1;
662 IRRECO_RETURN_PTR(button);
663 }
664
665 /** @} */
666 /** @} */
667
668
Irreco is a remote control application for Nokia Internet Tablets.