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