irreco/src/core/irreco_cmd_dlg.c

   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 #include <hildon/hildon-pannable-area.h>
  24
  25 /**
  26  * @addtogroup IrrecoCmdDlg
  27  * @ingroup Irreco
  28  *
  29  * Show a dialog where the user can select one command from a list of all
  30  * possible commands
  31  *
  32  * @{
  33  */
  34
  35 /**
  36  * @file
  37  * Source file of @ref IrrecoCmdDlg.
  38  */
  39
  40
  41 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  42 /* Types and definitions.                                                     */
  43 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  44
  45
  46 #define IRRECO_SELECT_CMD_DLG_BUTTON_ROW_WIDTH          520
  47 #define IRRECO_SELECT_CMD_DLG_BUTTON_PAD                5
  48 #define IRRECO_SELECT_CMD_DLG_EXPAND_BUTTONS            FALSE
  49
  50 enum
  51 {
  52         IRRECO_RESPONCE_EDIT = 1,
  53         IRRECO_RESPONCE_REFRESH,
  54         IRRECO_RESPONCE_COMMAND_SET
  55 };
  56
  57 typedef struct _IrrecoButtonAppend IrrecoButtonAppend;
  58 struct _IrrecoButtonAppend {
  59         GtkWidget *vbox;
  60         GtkWidget *hbox;
  61         uint width;
  62         uint count;
  63 };
  64
  65 typedef struct _IrrecoSelectCmdDlg IrrecoSelectCmdDlg;
  66 struct _IrrecoSelectCmdDlg {
  67         IrrecoData      *irreco_data;
  68         IrrecoCmd       *command;
  69         GtkWidget       *dialog;
  70         GtkWidget       *scrolled;
  71         GtkWidget       *vbox;
  72 };
  73
  74
  75
  76 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  77 /* Prototypes.                                                                */
  78 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  79
  80
  81 void irreco_cmd_dlg_create_command_list(IrrecoSelectCmdDlg * cmd_dlg);
  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                 /*_("Device controllers"), IRRECO_RESPONCE_EDIT,*/
 135                 NULL);
 136         cmd_dlg.scrolled = hildon_pannable_area_new();
 137
 138         gtk_container_add(GTK_CONTAINER(GTK_DIALOG(cmd_dlg.dialog)->vbox),
 139                           cmd_dlg.scrolled);
 140         irreco_cmd_dlg_create_command_list(&cmd_dlg);
 141
 142         /* Min width, max height. */
 143         gtk_window_resize(GTK_WINDOW(cmd_dlg.dialog), 1, 300);
 144         gtk_widget_show_all(cmd_dlg.dialog);
 145
 146         while (rvalue == -1) {
 147                 switch (gtk_dialog_run(GTK_DIALOG(cmd_dlg.dialog))) {
 148                 case GTK_RESPONSE_DELETE_EVENT:
 149                         rvalue = FALSE;
 150                         break;
 151
 152                 case IRRECO_RESPONCE_COMMAND_SET:
 153                         rvalue = TRUE;
 154                         break;
 155
 156                 case IRRECO_RESPONCE_EDIT:
 157                         irreco_show_backend_dlg(irreco_data,
 158                                                GTK_WINDOW(cmd_dlg.dialog));
 159                         irreco_cmd_dlg_create_command_list(&cmd_dlg);
 160                         break;
 161
 162                 case IRRECO_RESPONCE_REFRESH:
 163                         irreco_backend_manager_get_devcmd_lists(
 164                                 irreco_data->irreco_backend_manager);
 165                         irreco_cmd_dlg_create_command_list(&cmd_dlg);
 166                         break;
 167                 }
 168         }
 169
 170         gtk_widget_destroy(cmd_dlg.dialog);
 171         IRRECO_RETURN_INT(rvalue);
 172 }
 173
 174 void irreco_cmd_dlg_create_command_list(IrrecoSelectCmdDlg * cmd_dlg)
 175 {
 176         const gchar *name = NULL;
 177         IRRECO_ENTER
 178
 179         if (cmd_dlg->vbox != NULL) {
 180                 gtk_widget_destroy(cmd_dlg->vbox);
 181         }
 182         cmd_dlg->vbox = gtk_vbox_new(FALSE, 0);
 183         hildon_pannable_area_add_with_viewport(HILDON_PANNABLE_AREA(cmd_dlg->scrolled),
 184                                                GTK_WIDGET(cmd_dlg->vbox));
 185
 186
 187         /* Iterate trough instance, device and command arrays. */
 188         IRRECO_DEBUG("Generating command list\n");
 189         IRRECO_BACKEND_MANAGER_FOREACH_INSTANCE(
 190             cmd_dlg->irreco_data->irreco_backend_manager, instance)
 191
 192                 name = irreco_backend_instance_get_name(instance);
 193                 IRRECO_DEBUG("Instance: \"%s\"\n", name);
 194
 195                 IRRECO_BACKEND_INSTANCE_FOREACH(instance, device)
 196                         IRRECO_DEBUG("Device: \"%s\"\n", device->name);
 197                         irreco_cmd_dlg_append_device(cmd_dlg, device);
 198                 IRRECO_BACKEND_INSTANCE_FOREACH_END
 199
 200         IRRECO_STRING_TABLE_FOREACH_END
 201
 202         IRRECO_DEBUG("Special commands.\n");
 203         irreco_cmd_dlg_append_special(cmd_dlg);
 204         gtk_widget_show_all(cmd_dlg->dialog);
 205
 206         IRRECO_RETURN
 207 }
 208
 209 /** @} */
 210
 211
 212
 213 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 214 /* Signal handlers.                                                           */
 215 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 216
 217 /**
 218  * @name Signal handlers
 219  * @{
 220  */
 221
 222
 223 void irreco_cmd_dlg_set_built_in(GtkButton * button,
 224                                  IrrecoSelectCmdDlg * cmd_dlg)
 225 {
 226         gpointer type;
 227         IRRECO_ENTER
 228
 229         type = g_object_get_data(G_OBJECT(button), "IrrecoCmdType");
 230         irreco_cmd_set_builtin(cmd_dlg->command, (IrrecoCmdType) type);
 231         gtk_dialog_response(GTK_DIALOG(cmd_dlg->dialog),
 232                             IRRECO_RESPONCE_COMMAND_SET);
 233
 234         IRRECO_RETURN
 235 }
 236
 237 void irreco_cmd_dlg_set_layout(GtkButton * button,
 238                                IrrecoSelectCmdDlg * cmd_dlg)
 239 {
 240         gpointer name;
 241         IRRECO_ENTER
 242
 243         name = g_object_get_data(G_OBJECT(button), "IrrecoCmdLayout");
 244         irreco_cmd_set_layout(cmd_dlg->command, (const gchar *) name);
 245         gtk_dialog_response(GTK_DIALOG(cmd_dlg->dialog),
 246                             IRRECO_RESPONCE_COMMAND_SET);
 247
 248         IRRECO_RETURN
 249 }
 250
 251 void irreco_cmd_dlg_set_backend(GtkButton * button,
 252                                IrrecoSelectCmdDlg * cmd_dlg)
 253 {
 254         IrrecoBackendDevice *device;
 255         const gchar *command;
 256         IRRECO_ENTER
 257
 258         device = (IrrecoBackendDevice *) g_object_get_data(
 259                 G_OBJECT(button), "IrrecoCmdBackendDevice");
 260         command = (const gchar *) g_object_get_data(
 261                 G_OBJECT(button), "IrrecoCmdBackendCommand");
 262         irreco_cmd_set_backend(cmd_dlg->command,
 263                                   device->backend_instance,
 264                                   device->name,
 265                                   command);
 266         gtk_dialog_response(GTK_DIALOG(cmd_dlg->dialog),
 267                             IRRECO_RESPONCE_COMMAND_SET);
 268
 269         IRRECO_RETURN
 270 }
 271
 272 void irreco_cmd_dlg_set_wait(GtkButton * button, IrrecoSelectCmdDlg * cmd_dlg)
 273 {
 274         gpointer delay;
 275         IRRECO_ENTER
 276
 277         delay = g_object_get_data(G_OBJECT(button), "IrrecoCmdWaitDelay");
 278         irreco_cmd_set_wait(cmd_dlg->command, (gulong) delay);
 279         gtk_dialog_response(GTK_DIALOG(cmd_dlg->dialog),
 280                             IRRECO_RESPONCE_COMMAND_SET);
 281
 282         IRRECO_RETURN
 283 }
 284
 285
 286 /** @} */
 287
 288
 289
 290 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 291 /* Dialog construction.                                                       */
 292 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 293
 294 /**
 295  * @name Dialog construction
 296  * @{
 297  */
 298
 299
 300 void irreco_cmd_dlg_append_commands(IrrecoSelectCmdDlg * cmd_dlg,
 301                                     IrrecoBackendDevice * device)
 302 {
 303         IrrecoButtonAppend button_append;
 304         GtkWidget *button;
 305         IRRECO_ENTER
 306
 307         irreco_cmd_dlg_append_button_init(&button_append, cmd_dlg->vbox);
 308         IRRECO_BACKEND_DEVICE_FOREACH(device, command)
 309                 button = irreco_cmd_dlg_append_button(&button_append,
 310                                                              command);
 311                 g_object_set_data(G_OBJECT(button),
 312                                   "IrrecoCmdBackendDevice",
 313                                   (gpointer) device);
 314                 g_object_set_data(G_OBJECT(button),
 315                                   "IrrecoCmdBackendCommand",
 316                                   (gpointer) command);
 317                 g_signal_connect(G_OBJECT(button), "clicked",
 318                                  G_CALLBACK(irreco_cmd_dlg_set_backend),
 319                                  cmd_dlg);
 320         IRRECO_BACKEND_DEVICE_FOREACH_END
 321         IRRECO_RETURN
 322 }
 323
 324 void irreco_cmd_dlg_append_device(IrrecoSelectCmdDlg * cmd_dlg,
 325                                   IrrecoBackendDevice * device)
 326 {
 327         GtkWidget *hbox;
 328         GtkWidget *arrow;
 329         GtkWidget *arrow_align;
 330         GtkWidget *device_label;
 331         GtkWidget *instance_label;
 332         IRRECO_ENTER
 333
 334         hbox = irreco_cmd_dlg_append_title_hbox(cmd_dlg->vbox);
 335         arrow = gtk_arrow_new(GTK_ARROW_RIGHT, GTK_SHADOW_NONE);
 336         arrow_align = gtk_alignment_new(0.5, 0.5, 1, 1);
 337         device_label = gtk_label_new(device->name);
 338         instance_label = gtk_label_new(
 339                 irreco_backend_instance_get_name(device->backend_instance));
 340
 341         /*
 342         instance_label = gtk_label_new(
 343                 irreco_backend_instance_get_name_and_description(
 344                         device->backend_instance));
 345         */
 346
 347         /* Arrow: 25px width, auto height, 5px padding left and right.*/
 348         gtk_widget_set_size_request(arrow, 25, 0);
 349         gtk_misc_set_alignment(GTK_MISC(arrow), 0.5, 0.5);
 350         gtk_alignment_set_padding(GTK_ALIGNMENT(arrow_align), 0, 0, 8, 8);
 351
 352         gtk_misc_set_alignment(GTK_MISC(device_label), 0, 0.5);
 353         gtk_misc_set_alignment(GTK_MISC(instance_label), 0, 0.5);
 354
 355         gtk_container_add(GTK_CONTAINER(arrow_align), arrow);
 356         gtk_box_pack_start(GTK_BOX(hbox), instance_label, 0, 0, 0);
 357         gtk_box_pack_start(GTK_BOX(hbox), arrow_align, 0, 0, 0);
 358         gtk_box_pack_start(GTK_BOX(hbox), device_label, 0, 0, 0);
 359
 360         if (irreco_backend_device_is_empty(device)) {
 361                 GtkWidget *label = gtk_label_new(_("This device does not "
 362                                                  "have any commands."));
 363                 hbox = irreco_cmd_dlg_append_command_hbox(cmd_dlg->vbox);
 364                 gtk_box_pack_start_defaults(GTK_BOX(hbox), label);
 365         } else {
 366                 /*GtkWidget *command_vbox = gtk_vbox_new(FALSE, 10);*/
 367                 irreco_cmd_dlg_append_commands(cmd_dlg, device);
 368         }
 369
 370         IRRECO_RETURN
 371 }
 372
 373
 374
 375 void irreco_cmd_dlg_append_special(IrrecoSelectCmdDlg * cmd_dlg)
 376 {
 377         GtkWidget *hbox;
 378         GtkWidget *label;
 379         GtkWidget *button;
 380         IrrecoButtonAppend button_append;
 381         GString *string;
 382         IRRECO_ENTER
 383
 384         hbox = irreco_cmd_dlg_append_title_hbox(cmd_dlg->vbox);
 385         label = gtk_label_new(_("Special commands"));
 386         gtk_box_pack_start(GTK_BOX(hbox), label, 0, 0, 0);
 387
 388         /* Create next remote button. */
 389         irreco_cmd_dlg_append_button_init(&button_append, cmd_dlg->vbox);
 390         button = irreco_cmd_dlg_append_button(
 391                 &button_append, _(IRRECO_COMMAND_NEXT_REMOTE_TITLE));
 392         g_object_set_data(G_OBJECT(button), "IrrecoCmdType",
 393                           (gpointer) IRRECO_COMMAND_NEXT_REMOTE);
 394         g_signal_connect(G_OBJECT(button), "clicked",
 395                          G_CALLBACK(irreco_cmd_dlg_set_built_in),
 396                          cmd_dlg);
 397
 398         /* Create previous remote button. */
 399         button = irreco_cmd_dlg_append_button(
 400                 &button_append, _(IRRECO_COMMAND_PREVIOUS_REMOTE_TITLE));
 401         g_object_set_data(G_OBJECT(button), "IrrecoCmdType",
 402                           (gpointer) IRRECO_COMMAND_PREVIOUS_REMOTE);
 403         g_signal_connect(G_OBJECT(button), "clicked",
 404                          G_CALLBACK(irreco_cmd_dlg_set_built_in),
 405                          cmd_dlg);
 406
 407         /* Fullscreen toggle button. */
 408 /*      button = irreco_cmd_dlg_append_button(
 409                 &button_append, _(IRRECO_COMMAND_FULLSCREEN_TOGGLE_TITLE));
 410         g_object_set_data(G_OBJECT(button), "IrrecoCmdType",
 411                           (gpointer) IRRECO_COMMAND_FULLSCREEN_TOGGLE);
 412         g_signal_connect(G_OBJECT(button), "clicked",
 413                          G_CALLBACK(irreco_cmd_dlg_set_built_in),
 414                          cmd_dlg);*/
 415
 416         /* Create show remote buttons. */
 417         string = g_string_new("");
 418         IRRECO_STRING_TABLE_FOREACH_KEY(
 419             cmd_dlg->irreco_data->irreco_layout_array, layout_name)
 420                 g_string_append(g_string_set_size(string, 0),
 421                                 _(IRRECO_COMMAND_SHOW_LAYOUT_TITLE_PREFIX));
 422                 g_string_append(string, layout_name);
 423                 button = irreco_cmd_dlg_append_button(&button_append,
 424                                                              string->str);
 425                 g_object_set_data(G_OBJECT(button), "IrrecoCmdLayout",
 426                                   (gpointer) layout_name);
 427                 g_signal_connect(G_OBJECT(button), "clicked",
 428                                  G_CALLBACK(irreco_cmd_dlg_set_layout),
 429                                  cmd_dlg);
 430         IRRECO_STRING_TABLE_FOREACH_END
 431         g_string_free(string, TRUE);
 432
 433         /* Append wait buttons. */
 434         irreco_cmd_dlg_append_wait_button(cmd_dlg, &button_append,
 435                                           IRRECO_SECONDS_TO_USEC(0.3));
 436         irreco_cmd_dlg_append_wait_button(cmd_dlg, &button_append,
 437                                           IRRECO_SECONDS_TO_USEC(0.6));
 438         irreco_cmd_dlg_append_wait_button(cmd_dlg, &button_append,
 439                                           IRRECO_SECONDS_TO_USEC(1));
 440         irreco_cmd_dlg_append_wait_button(cmd_dlg, &button_append,
 441                                           IRRECO_SECONDS_TO_USEC(1.5));
 442         irreco_cmd_dlg_append_wait_button(cmd_dlg, &button_append,
 443                                           IRRECO_SECONDS_TO_USEC(2));
 444         irreco_cmd_dlg_append_wait_button(cmd_dlg, &button_append,
 445                                           IRRECO_SECONDS_TO_USEC(3));
 446         irreco_cmd_dlg_append_wait_button(cmd_dlg, &button_append,
 447                                           IRRECO_SECONDS_TO_USEC(5));
 448         irreco_cmd_dlg_append_wait_button(cmd_dlg, &button_append,
 449                                           IRRECO_SECONDS_TO_USEC(7));
 450         irreco_cmd_dlg_append_wait_button(cmd_dlg, &button_append,
 451                                           IRRECO_SECONDS_TO_USEC(10));
 452         IRRECO_RETURN
 453 }
 454
 455 void irreco_cmd_dlg_append_wait_button(IrrecoSelectCmdDlg * cmd_dlg,
 456                                        IrrecoButtonAppend * button_append,
 457                                        uint delay)
 458 {
 459         GtkWidget *button;
 460         IrrecoCmd *command;
 461         IRRECO_ENTER
 462
 463         /* Set title. */
 464         command = irreco_cmd_create();
 465         irreco_cmd_set_wait(command, delay);
 466         button = irreco_cmd_dlg_append_button(
 467                 button_append, irreco_cmd_get_short_name(command));
 468         irreco_cmd_destroy(command);
 469
 470         /* Set title.
 471         string = g_string_new(NULL);
 472         g_string_printf(string, _(IRRECO_COMMAND_WAIT_TITLE_FORMAT),
 473                         (float)(delay) / 1000);
 474
 475         g_string_free(string, TRUE);
 476         */
 477
 478         /* Set callback. */
 479         g_object_set_data(G_OBJECT(button), "IrrecoCmdWaitDelay",
 480                           (gpointer) delay);
 481         g_signal_connect(G_OBJECT(button), "clicked",
 482                          G_CALLBACK(irreco_cmd_dlg_set_wait),
 483                          cmd_dlg);
 484         IRRECO_RETURN
 485 }
 486
 487 /** @} */
 488
 489
 490
 491 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 492 /* GtkHBox utility functions.                                                 */
 493 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 494
 495 /**
 496  * @name GtkHBox utility functions
 497  * @{
 498  */
 499
 500
 501 GtkWidget *irreco_cmd_dlg_append_hbox(GtkWidget * vbox,
 502                                       guint padding_between,
 503                                       guint padding_top,
 504                                       guint padding_bottom,
 505                                       guint padding_left,
 506                                       guint padding_right,
 507                                       gfloat x_expand_scale,
 508                                       gfloat y_expand_scale)
 509 {
 510         GtkWidget *hbox;
 511         GtkWidget *align;
 512         IRRECO_ENTER
 513
 514         hbox = gtk_hbox_new(FALSE, padding_between);
 515         align = irreco_gtk_align(hbox, 0, 0, x_expand_scale, y_expand_scale,
 516                                  padding_top, padding_bottom, padding_left,
 517                                  padding_right);
 518         gtk_box_pack_start(GTK_BOX(vbox), align, 0, 0, 0);
 519         IRRECO_RETURN_PTR(hbox);
 520 }
 521
 522 void irreco_cmd_dlg_append_separator(GtkWidget * vbox,
 523                                      guint padding_top,
 524                                      guint padding_bottom)
 525 {
 526         GtkWidget *align;
 527         IRRECO_ENTER
 528
 529         align = irreco_gtk_align(gtk_hseparator_new(), 0, 0, 1, 1,
 530                                  padding_top, padding_bottom, 20, 0);
 531         gtk_box_pack_start(GTK_BOX(vbox), align, 0, 0, 0);
 532         IRRECO_RETURN
 533 }
 534
 535 GtkWidget *irreco_cmd_dlg_append_title_hbox(GtkWidget * vbox)
 536 {
 537         GtkWidget* hbox;
 538         IRRECO_ENTER
 539
 540         hbox = irreco_cmd_dlg_append_hbox(vbox,
 541                 0,      /*padding_between       */
 542                 15,     /*padding_top           */
 543                 0,      /*padding_bottom        */
 544                 25,     /*padding_left          */
 545                 20,     /*padding_right         */
 546                 0,      /* x_expand_scale       */
 547                 0       /* y_expand_scale       */
 548                 );
 549         irreco_cmd_dlg_append_separator(vbox, 2, 6);
 550         IRRECO_RETURN_PTR(hbox);
 551 }
 552
 553 GtkWidget *irreco_cmd_dlg_append_command_hbox(GtkWidget * vbox)
 554 {
 555         return irreco_cmd_dlg_append_hbox(vbox,
 556                 IRRECO_SELECT_CMD_DLG_BUTTON_PAD,       /* padding_between */
 557                 0,                                      /* padding_top     */
 558                 IRRECO_SELECT_CMD_DLG_BUTTON_PAD,       /* padding_bottom  */
 559                 25,                                     /* padding_left    */
 560                 20,                                     /* padding_right   */
 561                 IRRECO_SELECT_CMD_DLG_EXPAND_BUTTONS,   /* x_expand_scale  */
 562                 0                                       /* y_expand_scale  */
 563                 );
 564 }
 565
 566 /** @} */
 567
 568
 569
 570 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 571 /* Button adding to button rows.                                              */
 572 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 573
 574 /**
 575  * @name Button adding to button rows
 576  * @{
 577  */
 578
 579
 580 /*
 581  * Initialize IrrecoButtonAppend structure.
 582  *
 583  * There is no need to clean IrrecoButtonAppend structure because all
 584  * created widgets will be attached to the vbox.
 585  */
 586 void irreco_cmd_dlg_append_button_init(IrrecoButtonAppend * data,
 587                                        GtkWidget *vbox)
 588 {
 589         IRRECO_ENTER
 590         data->vbox = vbox;
 591         data->hbox = irreco_cmd_dlg_append_command_hbox(vbox);
 592         data->width = 0;
 593         data->count = 0;
 594         IRRECO_RETURN
 595 }
 596
 597 /*
 598  * Add a button to button row. Creates a new button row if current is full.
 599  *
 600  * Returns: a new GtkButton.
 601  */
 602 GtkWidget *irreco_cmd_dlg_append_button(IrrecoButtonAppend * data,
 603                                         const gchar * title)
 604 {
 605         GtkWidget *button;
 606         GtkRequisition requisition;
 607         IRRECO_ENTER
 608
 609         /* Because you cant get widget data->width without adding it to a
 610            container, this code does thing a bit backwards. */
 611         button = gtk_button_new_with_label(title);
 612         gtk_box_pack_start_defaults(GTK_BOX(data->hbox), button);
 613         gtk_widget_size_request(GTK_WIDGET(button), &requisition);
 614         data->width += requisition.width + IRRECO_SELECT_CMD_DLG_BUTTON_PAD;
 615
 616         /* If we have too much buttons on one row, destroy button,
 617            and create another button on a new row. */
 618         if (data->width > IRRECO_SELECT_CMD_DLG_BUTTON_ROW_WIDTH
 619             && data->count > 0) {
 620                 gtk_widget_destroy(button);
 621                 data->count = 0;
 622                 data->width = requisition.width +
 623                               IRRECO_SELECT_CMD_DLG_BUTTON_PAD;
 624                 data->hbox = irreco_cmd_dlg_append_command_hbox(data->vbox);
 625                 button = gtk_button_new_with_label(title);
 626                 gtk_box_pack_start_defaults(GTK_BOX(data->hbox), button);
 627         }
 628
 629         data->count += 1;
 630         IRRECO_RETURN_PTR(button);
 631 }
 632
 633 /** @} */
 634 /** @} */
 635
 636