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          hc = g_list_last(hist);
 157       } else {
 158          hc = g_list_previous(hc);
 159       }
 160       if (!hc) {
 161          hc = g_list_first(hist);
 162       }
 163       gtk_entry_set_text((GtkEntry *)entry1, (gchar *)hc->data);
 164    } else if (event->keyval == KEY_Down) {
 165       if (!hc) {
 166          hc = g_list_first(hist);
 167       } else {
 168          hc = g_list_next(hc);
 169       }
 170       if (!hc) {
 171          hc = g_list_last(hist);
 172       }
 173       gtk_entry_set_text((GtkEntry *)entry1, (gchar *)hc->data);
 174    }
 175 // gtk_entry_set_position((GtkEntry *)entry1, -1);
 176 // gtk_window_set_focus((GtkWindow *)app1, entry1);
 177    return FALSE;
 178 }
 179
 180
 181 void
 182 on_app1_show(GtkWidget *widget, gpointer user_data)
 183 {
 184 }
 185
 186
 187
 188 void
 189 on_msgs_button_clicked(GtkButton *button, gpointer user_data)
 190 {
 191    write_director("messages");
 192 }
 193
 194 void
 195 on_msgs_activate(GtkMenuItem *menuitem, gpointer user_data)
 196 {
 197    write_director("messages");
 198 }
 199
 200 void
 201 on_about_button_clicked(GtkButton *button, gpointer user_data)
 202 {
 203    gtk_widget_hide(about1);
 204    gtk_main_quit();
 205    set_status_ready();
 206 }
 207
 208 void
 209 on_select_director_OK_clicked(GtkButton *button, gpointer user_data)
 210 {
 211    reply = OK;
 212    gtk_widget_hide(dir_dialog);
 213    gtk_main_quit();
 214    set_status_ready();
 215 }
 216
 217
 218 void
 219 on_select_director_cancel_clicked(GtkButton *button, gpointer user_data)
 220 {
 221    reply = CANCEL;
 222    gtk_widget_hide(dir_dialog);
 223    gtk_main_quit();
 224    set_status_ready();
 225 }
 226
 227 /*
 228  * Compare list string items
 229  */
 230 extern "C"
 231 gint compare_func(const void *data1, const void *data2)
 232 {
 233    return strcmp((const char *)data1, (const char *)data2);
 234 }
 235
 236 static GList *find_combo_list(char *name)
 237 {
 238    if (strcmp(name, "job") == 0) {
 239       return job_list;
 240    }
 241    if (strcmp(name, "pool") == 0) {
 242       return pool_list;
 243    }
 244    if (strcmp(name, "client") == 0) {
 245       return client_list;
 246    }
 247    if (strcmp(name, "storage") == 0) {
 248       return storage_list;
 249    }
 250    if (strcmp(name, "fileset") == 0) {
 251       return fileset_list;
 252    }
 253    if (strcmp(name, "messages") == 0) {
 254       return messages_list;
 255    }
 256    if (strcmp(name, "type") == 0) {
 257       return type_list;
 258    }
 259    if (strcmp(name, "level") == 0) {
 260       return level_list;
 261    }
 262    return NULL;
 263 }
 264
 265 /*
 266  * Set correct default values in the Run dialog box
 267  */
 268 static void set_run_defaults()
 269 {
 270    GtkWidget *combo, *entry;
 271    char *job, *def;
 272    GList *item, *list;
 273    char cmd[1000];
 274    int pos;
 275
 276    stop_director_reader(NULL);
 277
 278    combo = lookup_widget(run_dialog, "combo_job");
 279    job = (char *)gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(combo)->entry));
 280    bsnprintf(cmd, sizeof(cmd), ".defaults job=\"%s\"", job);
 281    write_director(cmd);
 282    while (bnet_recv(UA_sock) > 0) {
 283       def = strchr(UA_sock->msg, '=');
 284       if (!def) {
 285          continue;
 286       }
 287       *def++ = 0;
 288       if (strcmp(UA_sock->msg, "job") == 0 ||
 289           strcmp(UA_sock->msg, "when") == 0) {
 290          continue;
 291       }
 292       /* Where is an entry box */
 293       if (strcmp(UA_sock->msg, "where") == 0) {
 294          entry = lookup_widget(run_dialog, "entry_where");
 295          gtk_entry_set_text(GTK_ENTRY(entry), def);
 296          continue;
 297       }
 298
 299       /* Now handle combo boxes */
 300       list = find_combo_list(UA_sock->msg);
 301       if (!list) {
 302          continue;
 303       }
 304       item = g_list_find_custom(list, def, compare_func);
 305       bsnprintf(cmd, sizeof(cmd), "combo_%s", UA_sock->msg);
 306       combo = lookup_widget(run_dialog, cmd);
 307       if (!combo) {
 308          continue;
 309       }
 310       pos = g_list_position(list, item);
 311       gtk_list_select_item(GTK_LIST(GTK_COMBO(combo)->list), pos);
 312    }
 313    start_director_reader(NULL);
 314 }
 315
 316 void
 317 on_entry_job_changed(GtkEditable *editable, gpointer user_data)
 318 {
 319    set_run_defaults();
 320 }
 321
 322
 323 void
 324 on_run_button_clicked(GtkButton *button, gpointer user_data)
 325 {
 326    char dt[50];
 327    GtkWidget *entry;
 328
 329    bstrutime(dt, sizeof(dt), time(NULL));
 330    entry = lookup_widget(run_dialog, "entry_when");
 331    gtk_entry_set_text(GTK_ENTRY(entry), dt);
 332    set_run_defaults();
 333    gtk_widget_show(run_dialog);
 334    gtk_main();
 335 }
 336
 337
 338 static char *get_combo_text(GtkWidget *dialog, const char *combo_name)
 339 {
 340    GtkWidget *combo;
 341    combo = lookup_widget(dialog, combo_name);
 342    if (!combo) {
 343       return NULL;
 344    }
 345    return (char *)gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(combo)->entry));
 346 }
 347
 348 static char *get_entry_text(GtkWidget *dialog, const char *entry_name)
 349 {
 350    GtkWidget *entry;
 351    entry = lookup_widget(dialog, entry_name);
 352    if (!entry) {
 353       return NULL;
 354    }
 355    return (char *)gtk_entry_get_text(GTK_ENTRY(entry));
 356 }
 357
 358 static char *get_spin_text(GtkWidget *dialog, const char *spin_name)
 359 {
 360    GtkSpinButton *spin;
 361    spin = (GtkSpinButton *)lookup_widget(dialog, spin_name);
 362    if (!spin) {
 363       return NULL;
 364    }
 365    return (char *)gtk_entry_get_text(GTK_ENTRY(&spin->entry));
 366 }
 367
 368
 369
 370
 371 void
 372 on_run_ok_clicked(GtkButton *button, gpointer user_data)
 373 {
 374    char *job, *fileset, *level, *client, *pool, *when, *where, *storage;
 375
 376    gtk_widget_hide(run_dialog);
 377    gtk_main_quit();
 378
 379    job     = get_combo_text(run_dialog, "combo_job");
 380    fileset = get_combo_text(run_dialog, "combo_fileset");
 381    client  = get_combo_text(run_dialog, "combo_client");
 382    pool    = get_combo_text(run_dialog, "combo_pool");
 383    storage = get_combo_text(run_dialog, "combo_storage");
 384    level   = get_combo_text(run_dialog, "combo_level");
 385
 386    when    = get_entry_text(run_dialog, "entry_when");
 387    where   = get_entry_text(run_dialog, "entry_where");
 388
 389    if (!job || !fileset || !client || !pool || !storage ||
 390        !level || !when || !where) {
 391       set_status_ready();
 392       return;
 393    }
 394
 395    bsnprintf(cmd, sizeof(cmd),
 396              "run job=\"%s\" fileset=\"%s\" level=%s client=\"%s\" pool=\"%s\" "
 397              "when=\"%s\" where=\"%s\" storage=\"%s\"",
 398              job, fileset, level, client, pool, when, where, storage);
 399    write_director(cmd);
 400    set_text(cmd, strlen(cmd));
 401    write_director("yes");
 402    return;
 403 }
 404
 405
 406 void
 407 on_run_cancel_clicked(GtkButton *button, gpointer user_data)
 408 {
 409    gtk_widget_hide(run_dialog);
 410    gtk_main_quit();
 411    set_status_ready();
 412 }
 413
 414 gboolean
 415 on_entry1_key_release_event(GtkWidget *widget, GdkEventKey *event, gpointer user_data)
 416 {
 417   return FALSE;
 418 }
 419
 420 void
 421 on_restore_button_clicked(GtkButton *button, gpointer user_data)
 422 {
 423    gtk_widget_show(restore_dialog);
 424    gtk_main();
 425 }
 426
 427 void
 428 on_view_fileset_clicked(GtkButton *button, gpointer user_data)
 429 {
 430 }
 431
 432
 433 void
 434 on_restore_cancel_clicked(GtkButton *button, gpointer user_data)
 435 {
 436    gtk_widget_hide(restore_dialog);
 437    gtk_main_quit();
 438    set_status_ready();
 439 }
 440
 441
 442 void
 443 on_label_button_clicked(GtkButton *button, gpointer user_data)
 444 {
 445    gtk_widget_show(label_dialog);
 446    gtk_main();
 447 }
 448
 449 void
 450 on_label_ok_clicked(GtkButton *button, gpointer user_data)
 451 {
 452    char *pool, *volume, *storage, *slot;
 453
 454    gtk_widget_hide(label_dialog);
 455    gtk_main_quit();
 456
 457    pool    = get_combo_text(label_dialog, "label_combo_pool");
 458    storage = get_combo_text(label_dialog, "label_combo_storage");
 459
 460    volume  = get_entry_text(label_dialog, "label_entry_volume");
 461
 462    slot    = get_spin_text(label_dialog, "label_slot");
 463
 464    if (!pool || !storage || !volume || !(*volume)) {
 465       set_status_ready();
 466       return;
 467    }
 468
 469    bsnprintf(cmd, sizeof(cmd),
 470              "label name=\"%s\" pool=\"%s\" storage=\"%s\" slot=%s",
 471              volume, pool, storage, slot);
 472    write_director(cmd);
 473    set_text(cmd, strlen(cmd));
 474 }
 475
 476
 477 void
 478 on_label_cancel_clicked(GtkButton *button, gpointer user_data)
 479 {
 480    gtk_widget_hide(label_dialog);
 481    gtk_main_quit();
 482    set_status_ready();
 483 }
 484
 485
 486 void
 487 on_select_files_button_clicked(GtkButton *button, gpointer user_data)
 488 {
 489    char *job, *fileset, *client, *pool, *before, *storage;
 490
 491    gtk_widget_hide(restore_dialog);
 492
 493    job     = get_combo_text(restore_dialog, "combo_restore_job");
 494    fileset = get_combo_text(restore_dialog, "combo_restore_fileset");
 495    client  = get_combo_text(restore_dialog, "combo_restore_client");
 496    pool    = get_combo_text(restore_dialog, "combo_restore_pool");
 497    storage = get_combo_text(restore_dialog, "combo_restore_storage");
 498
 499    before  = get_entry_text(restore_dialog, "restore_before_entry");
 500
 501    if (!job || !fileset || !client || !pool || !storage || !before) {
 502       set_status_ready();
 503       return;
 504    }
 505
 506    bsnprintf(cmd, sizeof(cmd),
 507              "restore select current fileset=\"%s\" client=\"%s\" pool=\"%s\" "
 508              "storage=\"%s\"", fileset, client, pool, storage);
 509    write_director(cmd);
 510    set_text(cmd, strlen(cmd));
 511    gtk_widget_show(restore_file_selection);
 512    select_restore_files();            /* put up select files dialog */
 513 }
 514
 515 void
 516 on_restore_select_ok_clicked(GtkButton *button, gpointer user_data)
 517 {
 518    gtk_widget_hide(restore_file_selection);
 519    write_director("done");
 520    gtk_main_quit();
 521    set_status_ready();
 522 }
 523
 524
 525 void
 526 on_restore_select_cancel_clicked(GtkButton *button, gpointer user_data)
 527 {
 528    gtk_widget_hide(restore_file_selection);
 529    write_director("quit");
 530    gtk_main_quit();
 531    set_status_ready();
 532 }
 533
 534 gboolean
 535 on_restore_files_delete_event(GtkWidget *widget, GdkEvent *event, gpointer user_data)
 536 {
 537    gtk_widget_hide(restore_file_selection);
 538    gtk_main_quit();
 539    set_status_ready();
 540    return FALSE;
 541 }
 542
 543
 544 void
 545 on_new1_activate                       (GtkMenuItem     *menuitem,
 546                                         gpointer         user_data)
 547 {
 548
 549 }
 550
 551
 552 void
 553 on_open1_activate                      (GtkMenuItem     *menuitem,
 554                                         gpointer         user_data)
 555 {
 556
 557 }
 558
 559
 560 void
 561 on_save1_activate                      (GtkMenuItem     *menuitem,
 562                                         gpointer         user_data)
 563 {
 564
 565 }
 566
 567
 568 void
 569 on_save_as1_activate                   (GtkMenuItem     *menuitem,
 570                                         gpointer         user_data)
 571 {
 572
 573 }
 574
 575
 576 void
 577 on_quit1_activate                      (GtkMenuItem     *menuitem,
 578                                         gpointer         user_data)
 579 {
 580
 581 }
 582
 583
 584 void
 585 on_cut2_activate                       (GtkMenuItem     *menuitem,
 586                                         gpointer         user_data)
 587 {
 588
 589 }
 590
 591
 592 void
 593 on_copy2_activate                      (GtkMenuItem     *menuitem,
 594                                         gpointer         user_data)
 595 {
 596
 597 }
 598
 599
 600 void
 601 on_paste2_activate                     (GtkMenuItem     *menuitem,
 602                                         gpointer         user_data)
 603 {
 604
 605 }
 606
 607
 608 void
 609 on_clear2_activate                     (GtkMenuItem     *menuitem,
 610                                         gpointer         user_data)
 611 {
 612
 613 }
 614
 615
 616 void
 617 on_properties1_activate                (GtkMenuItem     *menuitem,
 618                                         gpointer         user_data)
 619 {
 620
 621 }
 622
 623
 624 void
 625 on_preferences2_activate               (GtkMenuItem     *menuitem,
 626                                         gpointer         user_data)
 627 {
 628
 629 }
 630
 631
 632 void
 633 on_about2_activate                     (GtkMenuItem     *menuitem,
 634                                         gpointer         user_data)
 635 {
 636
 637 }
 638
 639 /*
 640  * Set correct default values in the Restore dialog box
 641  */
 642 void set_restore_dialog_defaults()
 643 {
 644    GtkWidget *combo;
 645    char *job, *def;
 646    GList *item, *list;
 647    char cmd[1000];
 648    int pos;
 649
 650    stop_director_reader(NULL);
 651
 652    combo = lookup_widget(restore_dialog, "combo_restore_job");
 653    job = (char *)gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(combo)->entry));
 654    bsnprintf(cmd, sizeof(cmd), ".defaults job=\"%s\"", job);
 655    write_director(cmd);
 656    while (bnet_recv(UA_sock) > 0) {
 657       def = strchr(UA_sock->msg, '=');
 658       if (!def) {
 659          continue;
 660       }
 661       *def++ = 0;
 662       if (strcmp(UA_sock->msg, "job") == 0 ||
 663           strcmp(UA_sock->msg, "when") == 0 ||
 664           strcmp(UA_sock->msg, "where") == 0 ||
 665           strcmp(UA_sock->msg, "messages") == 0 ||
 666           strcmp(UA_sock->msg, "level") == 0 ||
 667           strcmp(UA_sock->msg, "type") == 0) {
 668          continue;
 669       }
 670
 671       /* Now handle combo boxes */
 672       list = find_combo_list(UA_sock->msg);
 673       if (!list) {
 674          continue;
 675       }
 676       item = g_list_find_custom(list, def, compare_func);
 677       bsnprintf(cmd, sizeof(cmd), "combo_restore_%s", UA_sock->msg);
 678       combo = lookup_widget(restore_dialog, cmd);
 679       if (!combo) {
 680          continue;
 681       }
 682       pos = g_list_position(list, item);
 683       gtk_list_select_item(GTK_LIST(GTK_COMBO(combo)->list), pos);
 684    }
 685    start_director_reader(NULL);
 686 }
 687
 688
 689 void
 690 on_restore_job_entry_changed(GtkEditable *editable, gpointer user_data)
 691 {
 692    /* Set defaults that correspond to new job selection */
 693    set_restore_dialog_defaults();
 694 }