backend/irtrans/src/irtrans_command_dlg.c

   1 /*
   2  Irtrans_config_dlg - part of Ir Remote Control for N800
   3  Copyright (C) 2007 Jussi Pyykkö (jupyykko@netti.fi)
   4
   5  This is based on the irreco_button_dlg by Arto Karppinen
   6                                                         (arto.karppinen@iki.fi)
   7
   8  This program is free software; you can redistribute it and/or modify
   9  it under the terms of the GNU General Public License as published by
  10  the Free Software Foundation; either version 2 of the License, or
  11  (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
  20  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  */
  22
  23 #include "irtrans_command_dlg.h"
  24
  25 static IrTransCommandDlg *irtrans_command_dlg_create(void)
  26 {
  27         IRRECO_ENTER
  28         IRRECO_RETURN_PTR(g_slice_new0(IrTransCommandDlg));
  29 }
  30
  31 static void irtrans_command_dlg_destroy(IrTransCommandDlg * command_dialog)
  32 {
  33         IRRECO_ENTER
  34
  35         g_slice_free(IrTransCommandDlg, command_dialog);
  36
  37         IRRECO_RETURN
  38 }
  39
  40 static gboolean
  41 irtrans_learn_command_callback(IrTransCommandDlg *command_dialog)
  42 {
  43         IrrecoBackendStatus status;
  44         GtkWindow *parent;
  45         IRRECO_ENTER
  46
  47         status = irtrans_wrap_learn_command(
  48                 command_dialog->plugin->irtrans_wrap,
  49                 command_dialog->plugin->remote,
  50                 command_dialog->plugin->command,
  51                 IRTRANS_LEARN_TIMEOUT);
  52
  53         if (command_dialog->learn_dialog != NULL) {
  54                 parent = GTK_WINDOW(command_dialog->learn_dialog);
  55         } else {
  56                 parent = GTK_WINDOW(command_dialog->relearn_dialog);
  57         }
  58
  59         gtk_widget_set_sensitive(GTK_WIDGET(parent), TRUE);
  60
  61         if (command_dialog->hildon_banner != NULL) {
  62                 gtk_widget_destroy(GTK_WIDGET(command_dialog->hildon_banner));
  63                 command_dialog->hildon_banner = NULL;
  64         }
  65
  66         /* TODO: For some reason the UI will freeze if we dont close the UI.*/
  67         gtk_dialog_response(GTK_DIALOG(parent), GTK_RESPONSE_REJECT);
  68
  69         /*
  70         if (status == IRRECO_BACKEND_OK) {
  71                 gtk_dialog_response(GTK_DIALOG(parent), GTK_RESPONSE_REJECT);
  72         } else {
  73                 irreco_info_dlg(parent, _("IR code was not recieved."));
  74         }
  75         */
  76
  77         IRRECO_RETURN_BOOL(FALSE)
  78 }
  79
  80 static void irtrans_learn_command(IrTransCommandDlg *command_dialog)
  81 {
  82         GString *message;
  83         GtkWindow *parent;
  84         IRRECO_ENTER
  85
  86         if (command_dialog->learn_dialog != NULL) {
  87                 parent = GTK_WINDOW(command_dialog->learn_dialog);
  88         } else {
  89                 parent = GTK_WINDOW(command_dialog->relearn_dialog);
  90         }
  91
  92         message = g_string_new(NULL);
  93         g_string_printf(message,
  94                         _("Press a button on your remote once!\n"
  95                         "Waiting button press for %.0f seconds."),
  96                         IRRECO_MSEC_TO_SECONDS(IRTRANS_LEARN_TIMEOUT));
  97         if (command_dialog->hildon_banner == NULL) {
  98                 command_dialog->hildon_banner =
  99                         HILDON_BANNER(hildon_banner_show_information(
 100                                 GTK_WIDGET(parent), NULL, message->str));
 101         }
 102         g_string_free(message, TRUE);
 103
 104         gtk_widget_set_sensitive(GTK_WIDGET(parent), FALSE);
 105         g_idle_add((GSourceFunc) irtrans_learn_command_callback,
 106                    command_dialog);
 107
 108         IRRECO_RETURN
 109 }
 110
 111 #if 0
 112 /*
 113  * Sends command name to the irserver which creates config-file (name.rem)
 114  * in to the remotes-folder.
 115  */
 116 static void *irtrans_set_command(void * pointer)
 117 {
 118         IrTransCommandDlg *command_dialog = pointer;
 119         IrrecoBackendStatus status;
 120         IRRECO_ENTER
 121
 122         status = irtrans_wrap_connect(command_dialog->plugin->irtrans_wrap);
 123         if (status != IRRECO_BACKEND_OK) IRRECO_RETURN_PTR(0);
 124
 125         status = irtrans_wrap_learn_command(
 126                 command_dialog->plugin->irtrans_wrap,
 127                 command_dialog->plugin->remote,
 128                 command_dialog->plugin->command,
 129                 TIMEOUT);
 130
 131         /* send "exit-signal" for gtk_dialog */
 132         if(command_dialog->learn_dialog != NULL){
 133                 gtk_dialog_response(GTK_DIALOG(command_dialog->learn_dialog),
 134                                                         GTK_RESPONSE_REJECT);
 135         } else {
 136                 gtk_dialog_response(GTK_DIALOG(command_dialog->relearn_dialog),
 137                                                         GTK_RESPONSE_REJECT);
 138         }
 139
 140         IRRECO_RETURN_PTR(0);
 141 }
 142 #endif
 143
 144
 145 /*
 146  * Get chosen command from the list pointed by selection_index.
 147  */
 148 static gchar *get_command_iter(GtkWidget *treeview, gint selection_index)
 149 {
 150         GtkTreeIter iter;
 151         GtkTreeModel *model = NULL;
 152         GtkTreePath *path = NULL;
 153         gchar *str_data = NULL;
 154
 155         IRRECO_ENTER
 156
 157         model = gtk_tree_view_get_model(GTK_TREE_VIEW(treeview));
 158         path = gtk_tree_path_new_from_indices(selection_index, -1);
 159         gtk_tree_model_get_iter(model, &iter, path);
 160         gtk_tree_model_get(model, &iter, COMMAND_COLUMN, &str_data, -1);
 161         gtk_tree_path_free(path);
 162
 163         IRRECO_RETURN_PTR(str_data);
 164 }
 165
 166 static void command_list_selection_changed(GtkTreeSelection * selection,
 167                                         IrTransCommandDlg * command_dialog)
 168 {
 169         GtkTreeIter iter;
 170         GtkTreeModel *model = NULL;
 171         GtkTreePath *path = NULL;
 172         gint *path_indices = NULL;
 173
 174         IRRECO_ENTER
 175
 176         if(gtk_tree_selection_get_selected(selection, &model, &iter)){
 177
 178                 path = gtk_tree_model_get_path(model, &iter);
 179                 path_indices = gtk_tree_path_get_indices(path);
 180                 command_dialog->command_selection_index = path_indices[0];
 181                 gtk_tree_path_free(path);
 182         } else {
 183                 command_dialog->command_selection_index = -1;
 184         }
 185
 186         IRRECO_RETURN
 187 }
 188
 189 static gboolean irtrans_load_command_list(IrTransCommandDlg * command_dialog)
 190 {
 191         GtkTreeIter iter;
 192         IrrecoBackendStatus status;
 193         const gchar *command;
 194         IRRECO_ENTER
 195
 196         status = irtrans_wrap_get_command_list(
 197                 command_dialog->plugin->irtrans_wrap,
 198                 command_dialog->plugin->remote,
 199                 NULL);
 200         if (status != IRRECO_BACKEND_OK) IRRECO_RETURN_BOOL(FALSE);
 201
 202         while (irtrans_wrap_get_from_list(
 203                         command_dialog->plugin->irtrans_wrap, &command)) {
 204                 gtk_tree_store_append(command_dialog->command_treestore,
 205                                       &iter, NULL);
 206                 gtk_tree_store_set(command_dialog->command_treestore,
 207                                    &iter, COMMAND_COLUMN, command, -1);
 208         }
 209
 210         IRRECO_RETURN_BOOL(TRUE);
 211 }
 212
 213 static gboolean irtrans_create_command_list(IrTransCommandDlg * command_dialog)
 214 {
 215         GtkTreeSelection *select = NULL;
 216         GtkTreeViewColumn *column = NULL;
 217         GtkCellRenderer *renderer = NULL;
 218         gboolean success;
 219
 220         IRRECO_ENTER
 221
 222         /* if former widget exists destroy it */
 223         if(command_dialog->command_treeview != NULL){
 224
 225                 gtk_widget_destroy(command_dialog->command_treeview);
 226         }
 227
 228         /* create GtkTreeStore and GtkTreeView */
 229         command_dialog->command_treestore = gtk_tree_store_new(
 230                                                         NRO_COLUMNS,
 231                                                         G_TYPE_STRING);
 232         /* fill the treestore with data */
 233         success = irtrans_load_command_list(command_dialog);
 234
 235         if (success){
 236
 237                 command_dialog->command_treeview = gtk_tree_view_new_with_model(
 238                                                         GTK_TREE_MODEL(
 239                                                         command_dialog->
 240                                                         command_treestore));
 241                 g_object_unref(G_OBJECT(command_dialog->command_treestore));
 242
 243                 /* setup column */
 244                 renderer = gtk_cell_renderer_text_new();
 245                 column = gtk_tree_view_column_new_with_attributes(
 246                                                                 NULL, renderer,
 247                                                                 "text", 0, NULL);
 248                 gtk_tree_view_append_column(GTK_TREE_VIEW(command_dialog->
 249                                                         command_treeview),
 250                                                         column);
 251                 /* set selection callback */
 252                 select = gtk_tree_view_get_selection(GTK_TREE_VIEW(
 253                                                         command_dialog->
 254                                                         command_treeview));
 255                 gtk_tree_selection_set_mode(select, GTK_SELECTION_SINGLE);
 256                 g_signal_connect(G_OBJECT(select), "changed", G_CALLBACK(
 257                                                 command_list_selection_changed),
 258                                                 command_dialog);
 259                 IRRECO_RETURN_BOOL(TRUE);
 260         } else {
 261                 IRRECO_RETURN_BOOL(FALSE);
 262         }
 263 }
 264
 265 /*
 266 static void show_command_learn_banner(IrTransCommandDlg * command_dialog,
 267                                                         GtkWindow * parent)
 268 {
 269         IRRECO_ENTER
 270
 271         command_dialog->hildon_banner = HILDON_BANNER(
 272                                                 hildon_banner_show_animation(
 273                                                 GTK_WIDGET(parent), NULL,
 274                                 _("Press the button of your remote once!")));
 275         IRRECO_RETURN
 276 }
 277 */
 278
 279         /****************************************************************/
 280         /*                                                              */
 281         /*                                                              */
 282         /*                         DIALOGS                              */
 283         /*                                                              */
 284         /*                                                              */
 285         /****************************************************************/
 286
 287 static gboolean irtrans_command_learn_dlg(IrTransCommandDlg *command_dialog,
 288                                                         GtkWindow * parent)
 289 {
 290         GtkWidget *command_table = NULL;
 291         GtkWidget *command_entry = NULL;
 292         gchar *command_buffer = NULL;
 293         /*GThread *thread = NULL;*/
 294         gint rvalue = -1;
 295
 296         IRRECO_ENTER
 297
 298         /* create objects */
 299         command_dialog->learn_dialog = gtk_dialog_new_with_buttons(
 300                 _("Command learn dialog"), parent,
 301                 GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT |
 302                 GTK_DIALOG_NO_SEPARATOR,
 303                 _("Learn Command"), IRTRANS_LEARN_CMD,
 304                 GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL);
 305         command_table = gtk_table_new(2, 2, FALSE);
 306         command_entry = gtk_entry_new();
 307         gtk_table_attach_defaults(GTK_TABLE(command_table),
 308                                   gtk_label_new(_("Insert command name: ")),
 309                                   0, 1, 0, 1);
 310         gtk_table_attach_defaults(GTK_TABLE(command_table),
 311                                   command_entry,
 312                                   1, 2, 0, 1);
 313         gtk_table_set_row_spacings(GTK_TABLE(command_table), 5);
 314         gtk_table_set_col_spacings(GTK_TABLE(command_table), 5);
 315         gtk_container_add(GTK_CONTAINER(GTK_DIALOG(
 316                 command_dialog->learn_dialog)->vbox), command_table);
 317         gtk_widget_show_all(command_dialog->learn_dialog);
 318
 319         while(rvalue == -1){
 320                 switch(gtk_dialog_run(GTK_DIALOG(command_dialog->learn_dialog))){
 321                 case GTK_RESPONSE_REJECT:
 322
 323                         rvalue = FALSE;
 324                         break;
 325
 326                 case IRTRANS_LEARN_CMD:
 327
 328                         /* get command name */
 329                         command_buffer = g_strdup(gtk_entry_get_text
 330                                                         (GTK_ENTRY(
 331                                                         command_entry)));
 332
 333                         if(g_utf8_strlen(command_buffer, -1) < 1){
 334                                 irreco_info_dlg(parent,
 335                                         _("Insert valid command name!"));
 336                                 g_free(command_buffer);
 337                                 break;
 338                         } else {
 339                                 /* convert all characters to lowercase */
 340                                 command_dialog->plugin->command =
 341                                                 g_utf8_strdown(
 342                                                 command_buffer,
 343                                                 strlen(command_buffer));
 344
 345                                 g_free(command_buffer);
 346
 347                                 /*IRRECO_PRINTF("Remote: %s\n",
 348                                 command_dialog->plugin->remote);
 349                                 IRRECO_PRINTF("Command: %s\n",
 350                                 command_dialog->plugin->command);*/
 351
 352                                 if(command_dialog->plugin->remote!=NULL){
 353
 354                                         irtrans_learn_command(command_dialog);
 355
 356                                         /*
 357                                         #if 0
 358                                         show_command_learn_banner(
 359                                                 command_dialog, parent);
 360                                         */
 361                                         /* create thread for */
 362                                         /* set_command function */
 363                                         /*
 364                                         if((thread = g_thread_create(
 365                                                 (GThreadFunc)
 366                                                 irtrans_set_command,
 367                                                 (void *)command_dialog,
 368                                                 FALSE, NULL)) == NULL){
 369
 370                                                 }
 371                                         **/
 372                                 } else {
 373                                         irreco_info_dlg(parent,
 374                                                         _("Choose device!"));
 375                                         rvalue = TRUE;
 376                                 }
 377                                 break;
 378                         }
 379                 }
 380         }
 381
 382         /* destroy hildon_banner */
 383         /*
 384         if(command_dialog->hildon_banner != NULL){
 385
 386                 gtk_widget_destroy(GTK_WIDGET(command_dialog->hildon_banner));
 387         }
 388         */
 389
 390         gtk_widget_destroy(command_dialog->learn_dialog);
 391         IRRECO_RETURN_BOOL(rvalue);
 392 }
 393
 394 static gboolean irtrans_command_relearn_dlg(IrTransCommandDlg *command_dialog,
 395                                                         GtkWindow * parent)
 396 {
 397         /*GThread *thread = NULL;*/
 398         gchar *header = NULL;
 399         gint rvalue = -1;
 400
 401         command_dialog->learn_dialog = NULL;
 402
 403         IRRECO_ENTER
 404
 405         header = g_strjoin(" ", "Confirm relearn: ", command_dialog->
 406                                                         plugin->command,
 407                                                         "?", NULL);
 408
 409         /* create objects */
 410         command_dialog->relearn_dialog = gtk_dialog_new_with_buttons(
 411                 header, parent,
 412                 GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT |
 413                 GTK_DIALOG_NO_SEPARATOR,
 414                 GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
 415                 GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL);
 416
 417         gtk_window_resize(GTK_WINDOW(command_dialog->relearn_dialog), 400, 1);
 418
 419         gtk_widget_show_all(command_dialog->relearn_dialog);
 420
 421         while(rvalue == -1){
 422                 switch(gtk_dialog_run(GTK_DIALOG(
 423                                         command_dialog->relearn_dialog))){
 424
 425                 case GTK_RESPONSE_REJECT:
 426                         rvalue = FALSE;
 427                         break;
 428
 429                 case GTK_RESPONSE_ACCEPT:
 430
 431                         irtrans_learn_command(command_dialog);
 432                         /*
 433                         #if 0
 434                         show_command_learn_banner(command_dialog, parent);
 435                         */
 436                         /* create thread for */
 437                         /* set_command function */
 438                         /*
 439                         if((thread = g_thread_create(
 440                                 (GThreadFunc)irtrans_set_command,
 441                                 (void *)command_dialog,
 442                                 FALSE, NULL)) == NULL){
 443                         }
 444                         */
 445                         break;
 446                 }
 447         }
 448
 449         /* destroy hildon_banner */
 450         /*
 451         if(command_dialog->hildon_banner != NULL){
 452
 453                 gtk_widget_destroy(GTK_WIDGET(command_dialog->hildon_banner));
 454         }
 455         */
 456
 457         g_free(header);
 458         gtk_widget_destroy(command_dialog->relearn_dialog);
 459         IRRECO_RETURN_BOOL(rvalue);
 460 }
 461
 462 gboolean irtrans_command_dlg(IrTransPlugin * plugin, GtkWindow * parent)
 463 {
 464         IrTransCommandDlg *command_dialog;
 465
 466         GtkWidget *dialog = NULL;
 467         GtkWidget *sw = NULL;
 468         gint rvalue = -1;
 469         gboolean success;
 470         /*gboolean start;*/
 471
 472         IRRECO_ENTER
 473
 474         command_dialog = irtrans_command_dlg_create();
 475         command_dialog->plugin = plugin;
 476
 477         /* create objects. */
 478         dialog = gtk_dialog_new_with_buttons(
 479                 plugin->remote, parent,
 480                 GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT |
 481                 GTK_DIALOG_NO_SEPARATOR,
 482                 _("New Command"), IRTRANS_NEW_CMD,
 483                 _("Command Relearn"), IRTRANS_RELEARN_CMD,
 484                 _("Delete"), IRTRANS_DEL_CMD,
 485                 _("Done"), GTK_RESPONSE_ACCEPT, NULL);
 486         sw = gtk_scrolled_window_new (NULL, NULL);
 487         gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw),
 488                                                         GTK_SHADOW_ETCHED_IN);
 489         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw),
 490                                                         GTK_POLICY_AUTOMATIC,
 491                                                         GTK_POLICY_AUTOMATIC);
 492
 493         /* create tree model */
 494         success = irtrans_create_command_list(command_dialog);
 495
 496         if (success){
 497
 498                 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(sw),
 499                                                         command_dialog->
 500                                                         command_treeview);
 501         } else {
 502                 irreco_error_dlg(parent, _("Unable to load commands list!"));
 503         }
 504
 505         gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), sw);
 506         gtk_widget_show_all(dialog);
 507
 508         while(rvalue == -1){
 509                 switch(gtk_dialog_run(GTK_DIALOG(dialog))){
 510
 511                         case GTK_RESPONSE_ACCEPT:
 512
 513                                 rvalue = TRUE;
 514                                 break;
 515
 516                         case IRTRANS_NEW_CMD:
 517
 518                                 /* learn dialog for new button */
 519                                 irtrans_command_learn_dlg(
 520                                                         command_dialog,
 521                                                         parent);
 522
 523                                 /* refresh command list */
 524                                 success = irtrans_create_command_list(
 525                                                         command_dialog);
 526                                 if (success){
 527
 528                                         gtk_scrolled_window_add_with_viewport(
 529                                                         GTK_SCROLLED_WINDOW(sw),
 530                                                         command_dialog->
 531                                                         command_treeview);
 532                                         gtk_widget_show_all(dialog);
 533                                 } else {
 534                                         irreco_error_dlg(parent,
 535                                                 _("Unable to load command list!"));
 536                                 }
 537                                 break;
 538
 539                         case IRTRANS_RELEARN_CMD:
 540
 541                                 if(command_dialog->command_selection_index != 0) {
 542                                 command_dialog->plugin->command = g_strdup(
 543                                                         get_command_iter(
 544                                                         command_dialog->
 545                                                         command_treeview,
 546                                                         command_dialog->
 547                                                         command_selection_index));
 548                                 }
 549                                 /*IRRECO_PRINTF("Cmd_dlg command: %s\n",
 550                                         command_dialog->plugin->command);*/
 551                                 if(command_dialog->plugin->command != NULL){
 552
 553                                         irtrans_command_relearn_dlg(
 554                                                                 command_dialog,
 555                                                                 parent);
 556                                         break;
 557                                 } else {
 558                                         irreco_info_dlg(parent,
 559                                                 _("No reteachable commands!"));
 560                                         break;
 561                                 }
 562
 563                         case IRTRANS_DEL_CMD:
 564
 565                                 irreco_info_dlg(parent, _("IRTrans does not "
 566                                                 "support deleting commands."));
 567                                 break;
 568                 }
 569         }
 570
 571         gtk_widget_destroy(dialog);
 572         irtrans_command_dlg_destroy(command_dialog);
 573         IRRECO_RETURN_BOOL(rvalue);
 574 }
 575
 576