git.sur5r.net Git - bacula/bacula/blob - bacula/src/gnome2-console/callbacks.c

   1 /*
   2  *    Version $Id$
   3  */
   4
   5 #ifdef HAVE_CONFIG_H
   6 #  include <config.h>
   7 #endif
   8
   9 #include "bacula.h"
  10 #include "console.h"
  11
  12 #include "callbacks.h"
  13 #include "interface.h"
  14 #include "support.h"
  15
  16 #define KEY_Enter 65293
  17 #define KEY_Up    65362
  18 #define KEY_Down  65364
  19 #define KEY_Left  65361
  20 #define KEY_Right 65363
  21
  22 void terminate_console(int sig);
  23
  24 extern "C" gint compare_func(const void *data1, const void *data2);
  25
  26 gboolean
  27 on_console_delete_event(GtkWidget *widget, GdkEvent *event, gpointer user_data)
  28 {
  29    gtk_main_quit();
  30    terminate_console(0);
  31    return TRUE;
  32 }
  33
  34 void
  35 on_connect_activate(GtkMenuItem *menuitem, gpointer user_data)
  36 {
  37    if (connect_to_director(user_data)) {
  38       start_director_reader(user_data);
  39    }
  40 }
  41
  42
  43 void
  44 on_disconnect_activate(GtkMenuItem *menuitem, gpointer user_data)
  45 {
  46    if (disconnect_from_director(user_data)) {
  47       stop_director_reader(user_data);
  48    }
  49 }
  50
  51
  52 void
  53 on_exit_activate(GtkMenuItem *menuitem, gpointer user_data)
  54 {
  55    gtk_main_quit();
  56 }
  57
  58
  59 void
  60 on_cut1_activate(GtkMenuItem *menuitem, gpointer user_data)
  61 {
  62
  63 }
  64
  65
  66 void
  67 on_copy1_activate(GtkMenuItem *menuitem, gpointer user_data)
  68 {
  69
  70 }
  71
  72
  73 void
  74 on_paste1_activate(GtkMenuItem *menuitem, gpointer user_data)
  75 {
  76
  77 }
  78
  79
  80 void
  81 on_clear1_activate(GtkMenuItem *menuitem, gpointer user_data)
  82 {
  83
  84 }
  85
  86 void
  87 on_preferences1_activate(GtkMenuItem *menuitem, gpointer user_data)
  88 {
  89 }
  90
  91
  92 void
  93 on_about_activate(GtkMenuItem *menuitem, gpointer user_data)
  94 {
  95    gtk_widget_show(about1);
  96    gtk_main();
  97 }
  98
  99
 100 void
 101 on_connect_button_clicked(GtkButton *button, gpointer user_data)
 102 {
 103    if (connect_to_director(user_data)) {
 104       start_director_reader(user_data);
 105    }
 106 }
 107
 108 /* Define max length of history and how many to delete when it gets there.
 109  * If you make HIST_DEL > HIST_MAX, you shoot yourself in the foot.
 110  */
 111 #define HIST_MAX 2500
 112 #define HIST_DEL  500
 113
 114 static GList *hist = NULL;
 115 static GList *hc = NULL;
 116 static int hist_len = 0;
 117
 118 static void add_to_history(gchar *ecmd)
 119 {
 120    int len = strlen(ecmd);
 121
 122    if (len > 0) {
 123       hist = g_list_append(hist, bstrdup(ecmd));
 124       hist_len++;
 125    }
 126    if (hist_len >= HIST_MAX) {
 127       int i;
 128       GList *hp;
 129       for (i=0; i<HIST_DEL; i++) {
 130          hp = g_list_next(hist);
 131          free(hp->data);
 132          hist = g_list_remove(hist, hp->data);
 133       }
 134       hist_len -= HIST_DEL;
 135    }
 136    hc = NULL;
 137 }
 138
 139 /*
 140  * Note, apparently there is a bug in GNOME where some of the
 141  *  key press events are lost -- at least it loses every other
 142  *  up arrow!
 143  */
 144 gboolean
 145 on_entry1_key_press_event(GtkWidget *widget, GdkEventKey *event, gpointer user_data)
 146 {
 147    if (event->keyval == KEY_Enter) {
 148       char *ecmd = (char *)gtk_entry_get_text((GtkEntry *)entry1);
 149       set_text(ecmd, strlen(ecmd));
 150       set_text("\n", 1);
 151       add_to_history(ecmd);
 152       write_director(ecmd);
 153       gtk_entry_set_text((GtkEntry *)entry1, "");
 154    } else if (event->keyval == KEY_Up) {
 155       if (!hc) {
 156          if (!hist) {
 157             return FALSE;
 158          }
 159          hc = g_list_last(hist);
 160       } else {
 161          hc = g_list_previous(hc);
 162       }
 163       if (!hc) {
 164          if (!hist) {
 165             return FALSE;
 166          }
 167          hc = g_list_first(hist);
 168       }
 169       gtk_entry_set_text((GtkEntry *)entry1, (gchar *)hc->data);
 170    } else if (event->keyval == KEY_Down) {
 171       if (!hc) {
 172          if (!hist) {
 173             return FALSE;
 174          }
 175          hc = g_list_first(hist);
 176       } else {
 177          hc = g_list_next(hc);
 178       }
 179       if (!hc) {
 180          if (!hist) {
 181             return FALSE;
 182          }
 183          hc = g_list_last(hist);
 184       }
 185       gtk_entry_set_text((GtkEntry *)entry1, (gchar *)hc->data);
 186    }
 187 // gtk_entry_set_position((GtkEntry *)entry1, -1);
 188 // gtk_window_set_focus((GtkWindow *)app1, entry1);
 189    return FALSE;
 190 }
 191
 192
 193 void
 194 on_app1_show(GtkWidget *widget, gpointer user_data)
 195 {
 196 }
 197
 198
 199
 200 void
 201 on_msgs_button_clicked(GtkButton *button, gpointer user_data)
 202 {
 203    write_director("messages");
 204 }
 205
 206 void
 207 on_msgs_activate(GtkMenuItem *menuitem, gpointer user_data)
 208 {
 209    write_director("messages");
 210 }
 211
 212 void
 213 on_about_button_clicked(GtkButton *button, gpointer user_data)
 214 {
 215    gtk_widget_hide(about1);
 216    gtk_main_quit();
 217    set_status_ready();
 218 }
 219
 220 void
 221 on_select_director_OK_clicked(GtkButton *button, gpointer user_data)
 222 {
 223    reply = OK;
 224    gtk_widget_hide(dir_dialog);
 225    gtk_main_quit();
 226    set_status_ready();
 227 }
 228
 229
 230 void
 231 on_select_director_cancel_clicked(GtkButton *button, gpointer user_data)
 232 {
 233    reply = CANCEL;
 234    gtk_widget_hide(dir_dialog);
 235    gtk_main_quit();
 236    set_status_ready();
 237 }
 238
 239 /*
 240  * Compare list string items
 241  */
 242 extern "C"
 243 gint compare_func(const void *data1, const void *data2)
 244 {
 245    return strcmp((const char *)data1, (const char *)data2);
 246 }
 247
 248 static GList *find_combo_list(char *name)
 249 {
 250    if (strcmp(name, "job") == 0) {
 251       return job_list;
 252    }
 253    if (strcmp(name, "pool") == 0) {
 254       return pool_list;
 255    }
 256    if (strcmp(name, "client") == 0) {
 257       return client_list;
 258    }
 259    if (strcmp(name, "storage") == 0) {
 260       return storage_list;
 261    }
 262    if (strcmp(name, "fileset") == 0) {
 263       return fileset_list;
 264    }
 265    if (strcmp(name, "messages") == 0) {
 266       return messages_list;
 267    }
 268    if (strcmp(name, "type") == 0) {
 269       return type_list;
 270    }
 271    if (strcmp(name, "level") == 0) {
 272       return level_list;
 273    }
 274    return NULL;
 275 }
 276
 277 /*
 278  * Set correct default values in the Run dialog box
 279  */
 280 static void set_run_defaults()
 281 {
 282    GtkWidget *combo, *entry;
 283    char *job, *def;
 284    GList *item, *list;
 285    char cmd[1000];
 286    int pos;
 287
 288    stop_director_reader(NULL);
 289
 290    combo = lookup_widget(run_dialog, "combo_job");
 291    job = (char *)gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(combo)->entry));
 292    bsnprintf(cmd, sizeof(cmd), ".defaults job=\"%s\"", job);
 293    write_director(cmd);
 294    while (bnet_recv(UA_sock) > 0) {
 295       def = strchr(UA_sock->msg, '=');
 296       if (!def) {
 297          continue;
 298       }
 299       *def++ = 0;
 300       if (strcmp(UA_sock->msg, "job") == 0 ||
 301           strcmp(UA_sock->msg, "when") == 0) {
 302          continue;
 303       }
 304       /* Where is an entry box */
 305       if (strcmp(UA_sock->msg, "where") == 0) {
 306          entry = lookup_widget(run_dialog, "entry_where");
 307          gtk_entry_set_text(GTK_ENTRY(entry), def);
 308          continue;
 309       }
 310
 311       /* Now handle combo boxes */
 312       list = find_combo_list(UA_sock->msg);
 313       if (!list) {
 314          continue;
 315       }
 316       item = g_list_find_custom(list, def, compare_func);
 317       bsnprintf(cmd, sizeof(cmd), "combo_%s", UA_sock->msg);
 318       combo = lookup_widget(run_dialog, cmd);
 319       if (!combo) {
 320          continue;
 321       }
 322       pos = g_list_position(list, item);
 323       gtk_list_select_item(GTK_LIST(GTK_COMBO(combo)->list), pos);
 324    }
 325    start_director_reader(NULL);
 326 }
 327
 328 void
 329 on_entry_job_changed(GtkEditable *editable, gpointer user_data)
 330 {
 331    set_run_defaults();
 332 }
 333
 334
 335 void
 336 on_run_button_clicked(GtkButton *button, gpointer user_data)
 337 {
 338    char dt[50];
 339    GtkWidget *entry;
 340
 341    bstrutime(dt, sizeof(dt), time(NULL));
 342    entry = lookup_widget(run_dialog, "entry_when");
 343    gtk_entry_set_text(GTK_ENTRY(entry), dt);
 344    set_run_defaults();
 345    gtk_widget_show(run_dialog);
 346    gtk_main();
 347 }
 348
 349
 350 static char *get_combo_text(GtkWidget *dialog, const char *combo_name)
 351 {
 352    GtkWidget *combo;
 353    combo = lookup_widget(dialog, combo_name);
 354    if (!combo) {
 355       return NULL;
 356    }
 357    return (char *)gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(combo)->entry));
 358 }
 359
 360 static char *get_entry_text(GtkWidget *dialog, const char *entry_name)
 361 {
 362    GtkWidget *entry;
 363    entry = lookup_widget(dialog, entry_name);
 364    if (!entry) {
 365       return NULL;
 366    }
 367    return (char *)gtk_entry_get_text(GTK_ENTRY(entry));
 368 }
 369
 370 static char *get_spin_text(GtkWidget *dialog, const char *spin_name)
 371 {
 372    GtkSpinButton *spin;
 373    spin = (GtkSpinButton *)lookup_widget(dialog, spin_name);
 374    if (!spin) {
 375       return NULL;
 376    }
 377    return (char *)gtk_entry_get_text(GTK_ENTRY(&spin->entry));
 378 }
 379
 380
 381
 382
 383 void
 384 on_run_ok_clicked(GtkButton *button, gpointer user_data)
 385 {
 386    char *job, *fileset, *level, *client, *pool, *when, *where, *storage;
 387
 388    gtk_widget_hide(run_dialog);
 389    gtk_main_quit();
 390
 391    job     = get_combo_text(run_dialog, "combo_job");
 392    fileset = get_combo_text(run_dialog, "combo_fileset");
 393    client  = get_combo_text(run_dialog, "combo_client");
 394    pool    = get_combo_text(run_dialog, "combo_pool");
 395    storage = get_combo_text(run_dialog, "combo_storage");
 396    level   = get_combo_text(run_dialog, "combo_level");
 397
 398    when    = get_entry_text(run_dialog, "entry_when");
 399    where   = get_entry_text(run_dialog, "entry_where");
 400
 401    if (!job || !fileset || !client || !pool || !storage ||
 402        !level || !when || !where) {
 403       set_status_ready();
 404       return;
 405    }
 406
 407    bsnprintf(cmd, sizeof(cmd),
 408              "run job=\"%s\" fileset=\"%s\" level=%s client=\"%s\" pool=\"%s\" "
 409              "when=\"%s\" where=\"%s\" storage=\"%s\"",
 410              job, fileset, level, client, pool, when, where, storage);
 411    write_director(cmd);
 412    set_text(cmd, strlen(cmd));
 413    write_director("yes");
 414    return;
 415 }
 416
 417
 418 void
 419 on_run_cancel_clicked(GtkButton *button, gpointer user_data)
 420 {
 421    gtk_widget_hide(run_dialog);
 422    gtk_main_quit();
 423    set_status_ready();
 424 }
 425
 426 gboolean
 427 on_entry1_key_release_event(GtkWidget *widget, GdkEventKey *event, gpointer user_data)
 428 {
 429   return FALSE;
 430 }
 431
 432 void
 433 on_restore_button_clicked(GtkButton *button, gpointer user_data)
 434 {
 435    gtk_widget_show(restore_dialog);
 436    gtk_main();
 437 }
 438
 439 void
 440 on_view_fileset_clicked(GtkButton *button, gpointer user_data)
 441 {
 442 }
 443
 444
 445 void
 446 on_restore_cancel_clicked(GtkButton *button, gpointer user_data)
 447 {
 448    gtk_widget_hide(restore_dialog);
 449    gtk_main_quit();
 450    set_status_ready();
 451 }
 452
 453
 454 void
 455 on_label_button_clicked(GtkButton *button, gpointer user_data)
 456 {
 457    gtk_widget_show(label_dialog);
 458    gtk_main();
 459 }
 460
 461 void
 462 on_label_ok_clicked(GtkButton *button, gpointer user_data)
 463 {
 464    char *pool, *volume, *storage, *slot;
 465
 466    gtk_widget_hide(label_dialog);
 467    gtk_main_quit();
 468
 469    pool    = get_combo_text(label_dialog, "label_combo_pool");
 470    storage = get_combo_text(label_dialog, "label_combo_storage");
 471
 472    volume  = get_entry_text(label_dialog, "label_entry_volume");
 473
 474    slot    = get_spin_text(label_dialog, "label_slot");
 475
 476    if (!pool || !storage || !volume || !(*volume)) {
 477       set_status_ready();
 478       return;
 479    }
 480
 481    bsnprintf(cmd, sizeof(cmd),
 482              "label volume=\"%s\" pool=\"%s\" storage=\"%s\" slot=%s",
 483              volume, pool, storage, slot);
 484    write_director(cmd);
 485    set_text(cmd, strlen(cmd));
 486 }
 487
 488
 489 void
 490 on_label_cancel_clicked(GtkButton *button, gpointer user_data)
 491 {
 492    gtk_widget_hide(label_dialog);
 493    gtk_main_quit();
 494    set_status_ready();
 495 }
 496
 497
 498 void
 499 on_select_files_button_clicked(GtkButton *button, gpointer user_data)
 500 {
 501    char *job, *fileset, *client, *pool, *before, *storage;
 502
 503    gtk_widget_hide(restore_dialog);
 504
 505    job     = get_combo_text(restore_dialog, "combo_restore_job");
 506    fileset = get_combo_text(restore_dialog, "combo_restore_fileset");
 507    client  = get_combo_text(restore_dialog, "combo_restore_client");
 508    pool    = get_combo_text(restore_dialog, "combo_restore_pool");
 509    storage = get_combo_text(restore_dialog, "combo_restore_storage");
 510
 511    before  = get_entry_text(restore_dialog, "restore_before_entry");
 512
 513    if (!job || !fileset || !client || !pool || !storage || !before) {
 514       set_status_ready();
 515       return;
 516    }
 517
 518    bsnprintf(cmd, sizeof(cmd),
 519              "restore select current fileset=\"%s\" client=\"%s\" pool=\"%s\" "
 520              "storage=\"%s\"", fileset, client, pool, storage);
 521    write_director(cmd);
 522    set_text(cmd, strlen(cmd));
 523    gtk_widget_show(restore_file_selection);
 524    select_restore_files();            /* put up select files dialog */
 525 }
 526
 527 void
 528 on_restore_select_ok_clicked(GtkButton *button, gpointer user_data)
 529 {
 530    gtk_widget_hide(restore_file_selection);
 531    write_director("done");
 532    gtk_main_quit();
 533    set_status_ready();
 534 }
 535
 536
 537 void
 538 on_restore_select_cancel_clicked(GtkButton *button, gpointer user_data)
 539 {
 540    gtk_widget_hide(restore_file_selection);
 541    write_director("quit");
 542    gtk_main_quit();
 543    set_status_ready();
 544 }
 545
 546 gboolean
 547 on_restore_files_delete_event(GtkWidget *widget, GdkEvent *event, gpointer user_data)
 548 {
 549    gtk_widget_hide(restore_file_selection);
 550    gtk_main_quit();
 551    set_status_ready();
 552    return FALSE;
 553 }
 554
 555
 556 void
 557 on_new1_activate                       (GtkMenuItem     *menuitem,
 558                                         gpointer         user_data)
 559 {
 560
 561 }
 562
 563
 564 void
 565 on_open1_activate                      (GtkMenuItem     *menuitem,
 566                                         gpointer         user_data)
 567 {
 568
 569 }
 570
 571
 572 void
 573 on_save1_activate                      (GtkMenuItem     *menuitem,
 574                                         gpointer         user_data)
 575 {
 576
 577 }
 578
 579
 580 void
 581 on_save_as1_activate                   (GtkMenuItem     *menuitem,
 582                                         gpointer         user_data)
 583 {
 584
 585 }
 586
 587
 588 void
 589 on_quit1_activate                      (GtkMenuItem     *menuitem,
 590                                         gpointer         user_data)
 591 {
 592
 593 }
 594
 595
 596 void
 597 on_cut2_activate                       (GtkMenuItem     *menuitem,
 598                                         gpointer         user_data)
 599 {
 600
 601 }
 602
 603
 604 void
 605 on_copy2_activate                      (GtkMenuItem     *menuitem,
 606                                         gpointer         user_data)
 607 {
 608
 609 }
 610
 611
 612 void
 613 on_paste2_activate                     (GtkMenuItem     *menuitem,
 614                                         gpointer         user_data)
 615 {
 616
 617 }
 618
 619
 620 void
 621 on_clear2_activate                     (GtkMenuItem     *menuitem,
 622                                         gpointer         user_data)
 623 {
 624
 625 }
 626
 627
 628 void
 629 on_properties1_activate                (GtkMenuItem     *menuitem,
 630                                         gpointer         user_data)
 631 {
 632
 633 }
 634
 635
 636 void
 637 on_preferences2_activate               (GtkMenuItem     *menuitem,
 638                                         gpointer         user_data)
 639 {
 640
 641 }
 642
 643
 644 void
 645 on_about2_activate                     (GtkMenuItem     *menuitem,
 646                                         gpointer         user_data)
 647 {
 648
 649 }
 650
 651 /*
 652  * Set correct default values in the Restore dialog box
 653  */
 654 void set_restore_dialog_defaults()
 655 {
 656    GtkWidget *combo;
 657    char *job, *def;
 658    GList *item, *list;
 659    char cmd[1000];
 660    int pos;
 661
 662    stop_director_reader(NULL);
 663
 664    combo = lookup_widget(restore_dialog, "combo_restore_job");
 665    job = (char *)gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(combo)->entry));
 666    bsnprintf(cmd, sizeof(cmd), ".defaults job=\"%s\"", job);
 667    write_director(cmd);
 668    while (bnet_recv(UA_sock) > 0) {
 669       def = strchr(UA_sock->msg, '=');
 670       if (!def) {
 671          continue;
 672       }
 673       *def++ = 0;
 674       if (strcmp(UA_sock->msg, "job") == 0 ||
 675           strcmp(UA_sock->msg, "when") == 0 ||
 676           strcmp(UA_sock->msg, "where") == 0 ||
 677           strcmp(UA_sock->msg, "messages") == 0 ||
 678           strcmp(UA_sock->msg, "level") == 0 ||
 679           strcmp(UA_sock->msg, "type") == 0) {
 680          continue;
 681       }
 682
 683       /* Now handle combo boxes */
 684       list = find_combo_list(UA_sock->msg);
 685       if (!list) {
 686          continue;
 687       }
 688       item = g_list_find_custom(list, def, compare_func);
 689       bsnprintf(cmd, sizeof(cmd), "combo_restore_%s", UA_sock->msg);
 690       combo = lookup_widget(restore_dialog, cmd);
 691       if (!combo) {
 692          continue;
 693       }
 694       pos = g_list_position(list, item);
 695       gtk_list_select_item(GTK_LIST(GTK_COMBO(combo)->list), pos);
 696    }
 697    start_director_reader(NULL);
 698 }
 699
 700
 701 void
 702 on_restore_job_entry_changed(GtkEditable *editable, gpointer user_data)
 703 {
 704    /* Set defaults that correspond to new job selection */
 705    set_restore_dialog_defaults();
 706 }