gtk/main_statusbar.c

   1 /* main_statusbar.c
   2  *
   3  * $Id$
   4  *
   5  * Wireshark - Network traffic analyzer
   6  * By Gerald Combs <gerald@wireshark.org>
   7  * Copyright 1998 Gerald Combs
   8  *
   9  * This program is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU General Public License
  11  * as published by the Free Software Foundation; either version 2
  12  * of the License, or (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  22  */
  23
  24
  25 #ifdef HAVE_CONFIG_H
  26 #include "config.h"
  27 #endif
  28
  29 #ifdef HAVE_UNISTD_H
  30 #include <unistd.h>
  31 #endif
  32
  33 #include <gtk/gtk.h>
  34
  35 #include <epan/epan.h>
  36 #include <epan/filesystem.h>
  37 #include <epan/epan_dissect.h>
  38 #include <epan/expert.h>
  39 #include <epan/prefs.h>
  40
  41 #include "../cfile.h"
  42 #include "../file.h"
  43 #ifdef HAVE_LIBPCAP
  44 #include "../capture_opts.h"
  45 #include "../capture_ui_utils.h"
  46 #include "../capture.h"
  47 #endif
  48
  49 #include "gtk/recent.h"
  50 #include "gtk/main.h"
  51 #include "gtk/main_statusbar_private.h"
  52 #include "gtk/gui_utils.h"
  53 #include "gtk/gtkglobals.h"
  54 #include "gtk/expert_comp_dlg.h"
  55 #include "gtk/profile_dlg.h"
  56 #include "gtk/main_welcome.h"
  57 #include "gtk/expert_indicators.h"
  58 #include "gtk/keys.h"
  59 #include "gtk/menus.h"
  60
  61 #include "main_statusbar.h"
  62
  63 /*
  64  * The order below defines the priority of info bar contexts.
  65  */
  66 typedef enum {
  67     STATUS_LEVEL_MAIN,
  68     STATUS_LEVEL_FILE,
  69     STATUS_LEVEL_FILTER,
  70     STATUS_LEVEL_HELP,
  71     NUM_STATUS_LEVELS
  72 } status_level_e;
  73
  74
  75 #ifdef HAVE_LIBPCAP
  76 #define DEF_READY_MESSAGE " Ready to load or capture"
  77 #else
  78 #define DEF_READY_MESSAGE " Ready to load file"
  79 #endif
  80
  81
  82 static GtkWidget    *status_pane_left, *status_pane_right;
  83 static GtkWidget    *info_bar, *info_bar_event, *packets_bar, *profile_bar, *profile_bar_event;
  84 static GtkWidget    *expert_info_error, *expert_info_warn, *expert_info_note;
  85 static GtkWidget    *expert_info_chat, *expert_info_none;
  86
  87 static guint         main_ctx, file_ctx, help_ctx, filter_ctx, packets_ctx, profile_ctx;
  88 static guint         status_levels[NUM_STATUS_LEVELS];
  89 static gchar        *packets_str = NULL;
  90 static gchar        *profile_str = NULL;
  91
  92
  93 static void info_bar_new(void);
  94 static void packets_bar_new(void);
  95 static void profile_bar_new(void);
  96 static void status_expert_new(void);
  97
  98 /* Temporary message timeouts */
  99 #define TEMPORARY_MSG_TIMEOUT (7 * 1000)
 100 #define TEMPORARY_FLASH_TIMEOUT (1 * 1000)
 101 #define TEMPORARY_FLASH_INTERVAL (TEMPORARY_FLASH_TIMEOUT / 4)
 102 static gint flash_time;
 103 static gboolean flash_highlight = FALSE;
 104
 105 static void
 106 statusbar_push_file_msg(const gchar *msg_format, ...)
 107     G_GNUC_PRINTF(1, 2);
 108
 109 /*
 110  * Push a formatted message referring to file access onto the statusbar.
 111  */
 112 static void
 113 statusbar_push_file_msg(const gchar *msg_format, ...)
 114 {
 115     va_list ap;
 116     gchar *msg;
 117     int i;
 118
 119     /*g_warning("statusbar_push: %s", msg);*/
 120     for (i = STATUS_LEVEL_FILE + 1; i < NUM_STATUS_LEVELS; i++) {
 121         if (status_levels[i])
 122             return;
 123     }
 124     status_levels[STATUS_LEVEL_FILE]++;
 125
 126     va_start(ap, msg_format);
 127     msg = g_strdup_vprintf(msg_format, ap);
 128     va_end(ap);
 129
 130     gtk_statusbar_push(GTK_STATUSBAR(info_bar), file_ctx, msg);
 131     g_free(msg);
 132 }
 133
 134 /*
 135  * Pop a message referring to file access off the statusbar.
 136  */
 137 static void
 138 statusbar_pop_file_msg(void)
 139 {
 140     /*g_warning("statusbar_pop");*/
 141     if (status_levels[STATUS_LEVEL_FILE] > 0) {
 142         status_levels[STATUS_LEVEL_FILE]--;
 143     }
 144     gtk_statusbar_pop(GTK_STATUSBAR(info_bar), file_ctx);
 145 }
 146
 147 /*
 148  * Push a formatted message referring to the currently-selected field onto
 149  * the statusbar.
 150  */
 151 void
 152 statusbar_push_field_msg(const gchar *msg_format, ...)
 153 {
 154     va_list ap;
 155     gchar *msg;
 156     int i;
 157
 158     for (i = STATUS_LEVEL_HELP + 1; i < NUM_STATUS_LEVELS; i++) {
 159         if (status_levels[i])
 160             return;
 161     }
 162     status_levels[STATUS_LEVEL_HELP]++;
 163
 164     va_start(ap, msg_format);
 165     msg = g_strdup_vprintf(msg_format, ap);
 166     va_end(ap);
 167
 168     gtk_statusbar_push(GTK_STATUSBAR(info_bar), help_ctx, msg);
 169     g_free(msg);
 170 }
 171
 172 /*
 173  * Pop a message referring to the currently-selected field off the statusbar.
 174  */
 175 void
 176 statusbar_pop_field_msg(void)
 177 {
 178     if (status_levels[STATUS_LEVEL_HELP] > 0) {
 179         status_levels[STATUS_LEVEL_HELP]--;
 180     }
 181     gtk_statusbar_pop(GTK_STATUSBAR(info_bar), help_ctx);
 182 }
 183
 184 /*
 185  * Push a formatted message referring to the current filter onto the statusbar.
 186  */
 187 void
 188 statusbar_push_filter_msg(const gchar *msg_format, ...)
 189 {
 190     va_list ap;
 191     gchar *msg;
 192     int i;
 193
 194     for (i = STATUS_LEVEL_FILTER + 1; i < NUM_STATUS_LEVELS; i++) {
 195         if (status_levels[i])
 196             return;
 197     }
 198     status_levels[STATUS_LEVEL_FILTER]++;
 199
 200     va_start(ap, msg_format);
 201     msg = g_strdup_vprintf(msg_format, ap);
 202     va_end(ap);
 203
 204     gtk_statusbar_push(GTK_STATUSBAR(info_bar), filter_ctx, msg);
 205     g_free(msg);
 206 }
 207
 208 /*
 209  * Pop a message referring to the current filter off the statusbar.
 210  */
 211 void
 212 statusbar_pop_filter_msg(void)
 213 {
 214     if (status_levels[STATUS_LEVEL_FILTER] > 0) {
 215         status_levels[STATUS_LEVEL_FILTER]--;
 216     }
 217     gtk_statusbar_pop(GTK_STATUSBAR(info_bar), filter_ctx);
 218 }
 219
 220 /*
 221  * Timeout callbacks for statusbar_push_temporary_msg
 222  */
 223 static gboolean
 224 statusbar_remove_temporary_msg(gpointer data)
 225 {
 226     guint msg_id = GPOINTER_TO_UINT(data);
 227
 228     gtk_statusbar_remove(GTK_STATUSBAR(info_bar), main_ctx, msg_id);
 229
 230     return FALSE;
 231 }
 232
 233 static gboolean
 234 statusbar_flash_temporary_msg(gpointer data _U_)
 235 {
 236     gboolean retval = TRUE;
 237
 238     if (flash_time > 0) {
 239         flash_highlight = !flash_highlight;
 240     } else {
 241         flash_highlight = FALSE;
 242         retval = FALSE;
 243     }
 244
 245     /*
 246      * As of 2.18.3 gtk_drag_highlight just draws a border around the widget
 247      * so we can abuse it here.
 248      */
 249     if (flash_highlight) {
 250         gtk_drag_highlight(info_bar);
 251     } else {
 252         gtk_drag_unhighlight(info_bar);
 253     }
 254
 255     flash_time -= TEMPORARY_FLASH_INTERVAL;
 256
 257     return retval;
 258 }
 259
 260 /*
 261  * Push a formatted temporary message onto the statusbar.
 262  */
 263 void
 264 statusbar_push_temporary_msg(const gchar *msg_format, ...)
 265 {
 266     va_list ap;
 267     gchar *msg;
 268     guint msg_id;
 269
 270     va_start(ap, msg_format);
 271     msg = g_strdup_vprintf(msg_format, ap);
 272     va_end(ap);
 273
 274     msg_id = gtk_statusbar_push(GTK_STATUSBAR(info_bar), main_ctx, msg);
 275     g_free(msg);
 276
 277     flash_time = TEMPORARY_FLASH_TIMEOUT - 1;
 278     g_timeout_add(TEMPORARY_FLASH_INTERVAL, statusbar_flash_temporary_msg, NULL);
 279
 280     g_timeout_add(TEMPORARY_MSG_TIMEOUT, statusbar_remove_temporary_msg, GUINT_TO_POINTER(msg_id));
 281 }
 282
 283
 284 GtkWidget *
 285 statusbar_new(void)
 286 {
 287     GtkWidget *status_hbox;
 288
 289     /* Status hbox */
 290     status_hbox = gtk_hbox_new(FALSE, 1);
 291     gtk_container_set_border_width(GTK_CONTAINER(status_hbox), 0);
 292
 293     /* info (main) statusbar */
 294     info_bar_new();
 295
 296     /* packets statusbar */
 297     packets_bar_new();
 298
 299     /* profile statusbar */
 300     profile_bar_new();
 301
 302     /* expert info indicator */
 303     status_expert_new();
 304
 305     /* Pane for the statusbar */
 306     status_pane_left = gtk_hpaned_new();
 307     gtk_widget_show(status_pane_left);
 308     status_pane_right = gtk_hpaned_new();
 309     gtk_widget_show(status_pane_right);
 310
 311     return status_hbox;
 312 }
 313
 314 void
 315 statusbar_load_window_geometry(void)
 316 {
 317     if (recent.has_gui_geometry_status_pane && recent.gui_geometry_status_pane_left)
 318         gtk_paned_set_position(GTK_PANED(status_pane_left), recent.gui_geometry_status_pane_left);
 319     if (recent.has_gui_geometry_status_pane && recent.gui_geometry_status_pane_right)
 320         gtk_paned_set_position(GTK_PANED(status_pane_right), recent.gui_geometry_status_pane_right);
 321 }
 322
 323 void
 324 statusbar_save_window_geometry(void)
 325 {
 326     recent.gui_geometry_status_pane_left    = gtk_paned_get_position(GTK_PANED(status_pane_left));
 327     recent.gui_geometry_status_pane_right   = gtk_paned_get_position(GTK_PANED(status_pane_right));
 328 }
 329
 330
 331 /*
 332  * Helper for statusbar_widgets_emptying()
 333  */
 334 static void
 335 foreach_remove_a_child(GtkWidget *widget, gpointer data) {
 336     gtk_container_remove(GTK_CONTAINER(data), widget);
 337 }
 338
 339 void
 340 statusbar_widgets_emptying(GtkWidget *statusbar)
 341 {
 342     g_object_ref(G_OBJECT(info_bar));
 343     g_object_ref(G_OBJECT(info_bar_event));
 344     g_object_ref(G_OBJECT(packets_bar));
 345     g_object_ref(G_OBJECT(profile_bar));
 346     g_object_ref(G_OBJECT(profile_bar_event));
 347     g_object_ref(G_OBJECT(status_pane_left));
 348     g_object_ref(G_OBJECT(status_pane_right));
 349     g_object_ref(G_OBJECT(expert_info_error));
 350     g_object_ref(G_OBJECT(expert_info_warn));
 351     g_object_ref(G_OBJECT(expert_info_note));
 352     g_object_ref(G_OBJECT(expert_info_chat));
 353     g_object_ref(G_OBJECT(expert_info_none));
 354
 355     /* empty all containers participating */
 356     gtk_container_foreach(GTK_CONTAINER(statusbar),     foreach_remove_a_child, statusbar);
 357     gtk_container_foreach(GTK_CONTAINER(status_pane_left),   foreach_remove_a_child, status_pane_left);
 358     gtk_container_foreach(GTK_CONTAINER(status_pane_right),   foreach_remove_a_child, status_pane_right);
 359 }
 360
 361 void
 362 statusbar_widgets_pack(GtkWidget *statusbar)
 363 {
 364     gtk_box_pack_start(GTK_BOX(statusbar), expert_info_error, FALSE, FALSE, 2);
 365     gtk_box_pack_start(GTK_BOX(statusbar), expert_info_warn, FALSE, FALSE, 2);
 366     gtk_box_pack_start(GTK_BOX(statusbar), expert_info_note, FALSE, FALSE, 2);
 367     gtk_box_pack_start(GTK_BOX(statusbar), expert_info_chat, FALSE, FALSE, 2);
 368     gtk_box_pack_start(GTK_BOX(statusbar), expert_info_none, FALSE, FALSE, 2);
 369     gtk_box_pack_start(GTK_BOX(statusbar), status_pane_left, TRUE, TRUE, 0);
 370     gtk_paned_pack1(GTK_PANED(status_pane_left), info_bar_event, FALSE, FALSE);
 371     gtk_paned_pack2(GTK_PANED(status_pane_left), status_pane_right, TRUE, FALSE);
 372     gtk_paned_pack1(GTK_PANED(status_pane_right), packets_bar, TRUE, FALSE);
 373     gtk_paned_pack2(GTK_PANED(status_pane_right), profile_bar_event, FALSE, FALSE);
 374 }
 375
 376 void
 377 statusbar_widgets_show_or_hide(GtkWidget *statusbar)
 378 {
 379     /*
 380      * Show the status hbox if either:
 381      *
 382      *    1) we're showing the filter toolbar and we want it in the status
 383      *       line
 384      *
 385      * or
 386      *
 387      *    2) we're showing the status bar.
 388      */
 389     if ((recent.filter_toolbar_show && prefs.filter_toolbar_show_in_statusbar) ||
 390          recent.statusbar_show) {
 391         gtk_widget_show(statusbar);
 392     } else {
 393         gtk_widget_hide(statusbar);
 394     }
 395
 396     if (recent.statusbar_show) {
 397         gtk_widget_show(status_pane_left);
 398     } else {
 399         gtk_widget_hide(status_pane_left);
 400     }
 401 }
 402
 403
 404 static void
 405 info_bar_new(void)
 406 {
 407     int i;
 408
 409     info_bar_event = gtk_event_box_new();
 410     info_bar = gtk_statusbar_new();
 411     gtk_container_add(GTK_CONTAINER(info_bar_event), info_bar);
 412     main_ctx = gtk_statusbar_get_context_id(GTK_STATUSBAR(info_bar), "main");
 413     file_ctx = gtk_statusbar_get_context_id(GTK_STATUSBAR(info_bar), "file");
 414     help_ctx = gtk_statusbar_get_context_id(GTK_STATUSBAR(info_bar), "help");
 415     filter_ctx = gtk_statusbar_get_context_id(GTK_STATUSBAR(info_bar), "filter");
 416     gtk_statusbar_set_has_resize_grip(GTK_STATUSBAR(info_bar), FALSE);
 417     gtk_statusbar_push(GTK_STATUSBAR(info_bar), main_ctx, DEF_READY_MESSAGE);
 418
 419     for (i = 0; i < NUM_STATUS_LEVELS; i++) {
 420         status_levels[i] = 0;
 421     }
 422
 423     gtk_widget_show(info_bar);
 424     gtk_widget_show(info_bar_event);
 425 }
 426
 427 static void
 428 packets_bar_new(void)
 429 {
 430     /* tip: tooltips don't work on statusbars! */
 431     packets_bar = gtk_statusbar_new();
 432     packets_ctx = gtk_statusbar_get_context_id(GTK_STATUSBAR(packets_bar), "packets");
 433     packets_bar_update();
 434     gtk_statusbar_set_has_resize_grip(GTK_STATUSBAR(packets_bar), FALSE);
 435
 436     gtk_widget_show(packets_bar);
 437 }
 438
 439 static void
 440 profile_bar_new(void)
 441 {
 442     GtkTooltips   *tooltips;
 443
 444     tooltips = gtk_tooltips_new();
 445
 446     profile_bar_event = gtk_event_box_new();
 447     profile_bar = gtk_statusbar_new();
 448     gtk_container_add(GTK_CONTAINER(profile_bar_event), profile_bar);
 449     g_signal_connect(profile_bar_event, "button_press_event", G_CALLBACK(profile_show_popup_cb), NULL);
 450     g_signal_connect(profile_bar_event, "button_press_event", G_CALLBACK(popup_menu_handler),
 451                      g_object_get_data(G_OBJECT(popup_menu_object), PM_STATUSBAR_PROFILES_KEY));
 452     profile_ctx = gtk_statusbar_get_context_id(GTK_STATUSBAR(profile_bar), "profile");
 453     gtk_tooltips_set_tip (tooltips, profile_bar_event,
 454                           "Click to change configuration profile", NULL);
 455     profile_bar_update();
 456
 457     gtk_widget_show(profile_bar);
 458     gtk_widget_show(profile_bar_event);
 459 }
 460
 461
 462 /*
 463  * Update the packets statusbar to the current values
 464  */
 465 void
 466 packets_bar_update(void)
 467 {
 468     if(packets_bar) {
 469         /* Remove old status */
 470         if(packets_str) {
 471             g_free(packets_str);
 472             gtk_statusbar_pop(GTK_STATUSBAR(packets_bar), packets_ctx);
 473         }
 474
 475         /* Do we have any packets? */
 476         if(cfile.count) {
 477             if(cfile.drops_known) {
 478                 packets_str = g_strdup_printf(" Packets: %u Displayed: %u Marked: %u Dropped: %u",
 479                     cfile.count, cfile.displayed_count, cfile.marked_count, cfile.drops);
 480             } else if (cfile.ignored_count > 0) {
 481                 packets_str = g_strdup_printf(" Packets: %u Displayed: %u Marked: %u Ignored: %u",
 482                     cfile.count, cfile.displayed_count, cfile.marked_count, cfile.ignored_count);
 483             } else {
 484                 if(cfile.is_tempfile){
 485                     /* Live capture */
 486                     packets_str = g_strdup_printf(" Packets: %u Displayed: %u Marked: %u",
 487                                                   cfile.count, cfile.displayed_count, cfile.marked_count);
 488                 }else{
 489                     /* Loading an existing file */
 490                     gulong computed_elapsed = cf_get_computed_elapsed();
 491                     packets_str = g_strdup_printf(" Packets: %u Displayed: %u Marked: %u Load time: %lu:%02lu.%03lu",
 492                                                   cfile.count, cfile.displayed_count, cfile.marked_count,
 493                                                   computed_elapsed/60000,
 494                                                   computed_elapsed%60000/1000,
 495                                                   computed_elapsed%1000);
 496                 }
 497             }
 498         } else {
 499             packets_str = g_strdup(" No Packets");
 500         }
 501         gtk_statusbar_push(GTK_STATUSBAR(packets_bar), packets_ctx, packets_str);
 502     }
 503 }
 504
 505 /*
 506  * Update the packets statusbar to the current values
 507  */
 508 void
 509 profile_bar_update(void)
 510 {
 511     if (profile_bar) {
 512         /* remove old status */
 513         if(profile_str) {
 514             g_free(profile_str);
 515             gtk_statusbar_pop(GTK_STATUSBAR(profile_bar), profile_ctx);
 516         }
 517
 518         profile_str = g_strdup_printf (" Profile: %s", get_profile_name ());
 519         gtk_statusbar_push(GTK_STATUSBAR(profile_bar), profile_ctx, profile_str);
 520
 521         set_menus_for_profiles(is_default_profile());
 522     }
 523 }
 524
 525 static gboolean
 526 expert_comp_dlg_event_cb(GtkWidget *w _U_, GdkEventButton *event _U_, gpointer user_data _U_)
 527 {
 528     expert_comp_dlg_launch();
 529     return TRUE;
 530 }
 531
 532 static void
 533 status_expert_new(void)
 534 {
 535     GtkWidget *expert_image;
 536     GtkTooltips   *tooltips;
 537
 538     tooltips = gtk_tooltips_new();
 539
 540     expert_image = pixbuf_to_widget(expert_error_pb_data);
 541     gtk_tooltips_set_tip(tooltips, expert_image, "ERROR is the highest expert info level", NULL);
 542     gtk_widget_show(expert_image);
 543     expert_info_error = gtk_event_box_new();
 544     gtk_container_add(GTK_CONTAINER(expert_info_error), expert_image);
 545     g_signal_connect(expert_info_error, "button_press_event", G_CALLBACK(expert_comp_dlg_event_cb), NULL);
 546
 547     expert_image = pixbuf_to_widget(expert_warn_pb_data);
 548     gtk_tooltips_set_tip(tooltips, expert_image, "WARNING is the highest expert info level", NULL);
 549     gtk_widget_show(expert_image);
 550     expert_info_warn = gtk_event_box_new();
 551     gtk_container_add(GTK_CONTAINER(expert_info_warn), expert_image);
 552     g_signal_connect(expert_info_warn, "button_press_event", G_CALLBACK(expert_comp_dlg_event_cb), NULL);
 553
 554     expert_image = pixbuf_to_widget(expert_note_pb_data);
 555     gtk_tooltips_set_tip(tooltips, expert_image, "NOTE is the highest expert info level", NULL);
 556     gtk_widget_show(expert_image);
 557     expert_info_note = gtk_event_box_new();
 558     gtk_container_add(GTK_CONTAINER(expert_info_note), expert_image);
 559     g_signal_connect(expert_info_note, "button_press_event", G_CALLBACK(expert_comp_dlg_event_cb), NULL);
 560
 561     expert_image = pixbuf_to_widget(expert_chat_pb_data);
 562     gtk_tooltips_set_tip(tooltips, expert_image, "CHAT is the highest expert info level", NULL);
 563     gtk_widget_show(expert_image);
 564     expert_info_chat = gtk_event_box_new();
 565     gtk_container_add(GTK_CONTAINER(expert_info_chat), expert_image);
 566     g_signal_connect(expert_info_chat, "button_press_event", G_CALLBACK(expert_comp_dlg_event_cb), NULL);
 567
 568     expert_image = pixbuf_to_widget(expert_none_pb_data);
 569     gtk_tooltips_set_tip(tooltips, expert_image, "No expert info", NULL);
 570     gtk_widget_show(expert_image);
 571     expert_info_none = gtk_event_box_new();
 572     gtk_container_add(GTK_CONTAINER(expert_info_none), expert_image);
 573     g_signal_connect(expert_info_none, "button_press_event", G_CALLBACK(expert_comp_dlg_event_cb), NULL);
 574     gtk_widget_show(expert_info_none);
 575 }
 576
 577 static void
 578 status_expert_hide(void)
 579 {
 580     /* reset expert info indicator */
 581     gtk_widget_hide(expert_info_error);
 582     gtk_widget_hide(expert_info_warn);
 583     gtk_widget_hide(expert_info_note);
 584     gtk_widget_hide(expert_info_chat);
 585     gtk_widget_hide(expert_info_none);
 586 }
 587
 588 void
 589 status_expert_update(void)
 590 {
 591     status_expert_hide();
 592
 593     switch(expert_get_highest_severity()) {
 594     case(PI_ERROR):
 595         gtk_widget_show(expert_info_error);
 596         break;
 597     case(PI_WARN):
 598         gtk_widget_show(expert_info_warn);
 599         break;
 600     case(PI_NOTE):
 601         gtk_widget_show(expert_info_note);
 602         break;
 603     case(PI_CHAT):
 604         gtk_widget_show(expert_info_chat);
 605         break;
 606     default:
 607         gtk_widget_show(expert_info_none);
 608         break;
 609     }
 610 }
 611
 612 static void
 613 statusbar_set_filename(const char *file_name, gint64 file_length, nstime_t *file_elapsed_time)
 614 {
 615     gchar       *size_str;
 616
 617     /* expert info indicator */
 618     status_expert_update();
 619
 620     /* statusbar */
 621     /* convert file size */
 622     if (file_length/1024/1024 > 10) {
 623         size_str = g_strdup_printf("%" G_GINT64_MODIFIER "d MB", file_length/1024/1024);
 624     } else if (file_length/1024 > 10) {
 625         size_str = g_strdup_printf("%" G_GINT64_MODIFIER "d KB", file_length/1024);
 626     } else {
 627         size_str = g_strdup_printf("%" G_GINT64_MODIFIER "d Bytes", file_length);
 628     }
 629
 630     statusbar_push_file_msg(" File: \"%s\" %s %02lu:%02lu:%02lu",
 631                             (file_name) ? file_name : "", size_str,
 632                             (long)file_elapsed_time->secs/3600,
 633                             (long)file_elapsed_time->secs%3600/60,
 634                             (long)file_elapsed_time->secs%60);
 635     g_free(size_str);
 636 }
 637
 638
 639 static void
 640 statusbar_cf_file_closing_cb(capture_file *cf _U_)
 641 {
 642     /* Clear any file-related status bar messages.
 643        XXX - should be "clear *ALL* file-related status bar messages;
 644        will there ever be more than one on the stack? */
 645     statusbar_pop_file_msg();
 646
 647     /* reset expert info indicator */
 648     status_expert_hide();
 649     gtk_widget_show(expert_info_none);
 650 }
 651
 652
 653 static void
 654 statusbar_cf_file_closed_cb(capture_file *cf _U_)
 655 {
 656     /* go back to "No packets" */
 657     packets_bar_update();
 658 }
 659
 660
 661 static void
 662 statusbar_cf_file_read_started_cb(capture_file *cf)
 663 {
 664     const gchar *name_ptr;
 665
 666     /* Ensure we pop any previous loaded filename */
 667     statusbar_pop_file_msg();
 668
 669     name_ptr = get_basename(cf->filename);
 670
 671     statusbar_push_file_msg(" Loading: %s", name_ptr);
 672 }
 673
 674
 675 static void
 676 statusbar_cf_file_read_finished_cb(capture_file *cf)
 677 {
 678     statusbar_pop_file_msg();
 679     statusbar_set_filename(cf->filename, cf->f_datalen, &(cf->elapsed_time));
 680 }
 681
 682
 683 #ifdef HAVE_LIBPCAP
 684 static void
 685 statusbar_capture_prepared_cb(capture_options *capture_opts _U_)
 686 {
 687     static const gchar msg[] = " Waiting for capture input data ...";
 688     statusbar_push_file_msg(msg);
 689     welcome_header_push_msg(msg);
 690 }
 691
 692 static void
 693 statusbar_capture_update_started_cb(capture_options *capture_opts)
 694 {
 695     statusbar_pop_file_msg();
 696     welcome_header_pop_msg();
 697
 698     if(capture_opts->iface) {
 699         statusbar_push_file_msg(" %s: <live capture in progress> to file: %s",
 700                                 get_iface_description(capture_opts),
 701                                 (capture_opts->save_file) ? capture_opts->save_file : "");
 702     } else {
 703         statusbar_push_file_msg(" <live capture in progress> to file: %s",
 704                                 (capture_opts->save_file) ? capture_opts->save_file : "");
 705     }
 706 }
 707
 708 static void
 709 statusbar_capture_update_continue_cb(capture_options *capture_opts)
 710 {
 711     capture_file *cf = capture_opts->cf;
 712
 713     status_expert_update();
 714
 715     statusbar_pop_file_msg();
 716
 717     if (cf->f_datalen/1024/1024 > 10) {
 718         statusbar_push_file_msg(" %s: <live capture in progress> File: %s %" G_GINT64_MODIFIER "d MB",
 719                                 get_iface_description(capture_opts),
 720                                 capture_opts->save_file,
 721                                 cf->f_datalen/1024/1024);
 722     } else if (cf->f_datalen/1024 > 10) {
 723         statusbar_push_file_msg(" %s: <live capture in progress> File: %s %" G_GINT64_MODIFIER "d KB",
 724                                 get_iface_description(capture_opts),
 725                                 capture_opts->save_file,
 726                                 cf->f_datalen/1024);
 727     } else {
 728         statusbar_push_file_msg(" %s: <live capture in progress> File: %s %" G_GINT64_MODIFIER "d Bytes",
 729                                 get_iface_description(capture_opts),
 730                                 capture_opts->save_file,
 731                                 cf->f_datalen);
 732     }
 733 }
 734
 735 static void
 736 statusbar_capture_update_finished_cb(capture_options *capture_opts)
 737 {
 738     capture_file *cf = capture_opts->cf;
 739
 740     /* Pop the "<live capture in progress>" message off the status bar. */
 741     statusbar_pop_file_msg();
 742     statusbar_set_filename(cf->filename, cf->f_datalen, &(cf->elapsed_time));
 743     packets_bar_update();
 744 }
 745
 746 static void
 747 statusbar_capture_fixed_started_cb(capture_options *capture_opts)
 748 {
 749     statusbar_pop_file_msg();
 750
 751     statusbar_push_file_msg(" %s: <live capture in progress> to file: %s",
 752                             get_iface_description(capture_opts),
 753                             (capture_opts->save_file) ? capture_opts->save_file : "");
 754
 755     gtk_statusbar_push(GTK_STATUSBAR(packets_bar), packets_ctx, " Packets: 0");
 756 }
 757
 758 static void
 759 statusbar_capture_fixed_continue_cb(capture_options *capture_opts)
 760 {
 761     capture_file *cf = capture_opts->cf;
 762     gchar *capture_msg;
 763
 764
 765     gtk_statusbar_pop(GTK_STATUSBAR(packets_bar), packets_ctx);
 766     capture_msg = g_strdup_printf(" Packets: %u", cf_get_packet_count(cf));
 767     gtk_statusbar_push(GTK_STATUSBAR(packets_bar), packets_ctx, capture_msg);
 768     g_free(capture_msg);
 769 }
 770
 771
 772 static void
 773 statusbar_capture_fixed_finished_cb(capture_options *capture_opts _U_)
 774 {
 775 #if 0
 776     capture_file *cf = capture_opts->cf;
 777 #endif
 778
 779     /* Pop the "<live capture in progress>" message off the status bar. */
 780     statusbar_pop_file_msg();
 781     welcome_header_pop_msg();
 782
 783     /* Pop the "<capturing>" message off the status bar */
 784     gtk_statusbar_pop(GTK_STATUSBAR(packets_bar), packets_ctx);
 785 }
 786
 787 #endif /* HAVE_LIBPCAP */
 788
 789
 790 static void
 791 statusbar_cf_field_unselected_cb(capture_file *cf _U_)
 792 {
 793     statusbar_pop_field_msg();
 794 }
 795
 796 static void
 797 statusbar_cf_file_save_started_cb(gchar *filename)
 798 {
 799     statusbar_pop_file_msg();
 800     statusbar_push_file_msg(" Saving: %s...", get_basename(filename));
 801 }
 802
 803 static void
 804 statusbar_cf_file_save_finished_cb(gpointer data _U_)
 805 {
 806     /* Pop the "Saving:" message off the status bar. */
 807     statusbar_pop_file_msg();
 808 }
 809
 810 static void
 811 statusbar_cf_file_reload_finished_cb(capture_file *cf)
 812 {
 813     statusbar_pop_file_msg();
 814     statusbar_set_filename(cf->filename, cf->f_datalen, &(cf->elapsed_time));
 815 }
 816
 817
 818 static void
 819 statusbar_cf_file_save_failed_cb(gpointer data _U_)
 820 {
 821     /* Pop the "Saving:" message off the status bar. */
 822     statusbar_pop_file_msg();
 823 }
 824
 825
 826
 827 void
 828 statusbar_cf_callback(gint event, gpointer data, gpointer user_data _U_)
 829 {
 830     switch(event) {
 831     case(cf_cb_file_closing):
 832         statusbar_cf_file_closing_cb(data);
 833         break;
 834     case(cf_cb_file_closed):
 835         statusbar_cf_file_closed_cb(data);
 836         break;
 837     case(cf_cb_file_read_started):
 838         statusbar_cf_file_read_started_cb(data);
 839         break;
 840     case(cf_cb_file_read_finished):
 841         statusbar_cf_file_read_finished_cb(data);
 842         break;
 843     case(cf_cb_packet_selected):
 844         break;
 845     case(cf_cb_packet_unselected):
 846         break;
 847     case(cf_cb_field_unselected):
 848         statusbar_cf_field_unselected_cb(data);
 849         break;
 850     case(cf_cb_file_save_started):
 851         statusbar_cf_file_save_started_cb(data);
 852         break;
 853     case(cf_cb_file_save_finished):
 854         statusbar_cf_file_save_finished_cb(data);
 855         break;
 856     case(cf_cb_file_save_reload_finished):
 857         statusbar_cf_file_reload_finished_cb(data);
 858         break;
 859     case(cf_cb_file_save_failed):
 860         statusbar_cf_file_save_failed_cb(data);
 861         break;
 862     default:
 863         g_warning("statusbar_cf_callback: event %u unknown", event);
 864         g_assert_not_reached();
 865     }
 866 }
 867
 868 #ifdef HAVE_LIBPCAP
 869 void
 870 statusbar_capture_callback(gint event, capture_options *capture_opts,
 871                            gpointer user_data _U_)
 872 {
 873     switch(event) {
 874     case(capture_cb_capture_prepared):
 875         statusbar_capture_prepared_cb(capture_opts);
 876         break;
 877     case(capture_cb_capture_update_started):
 878         statusbar_capture_update_started_cb(capture_opts);
 879         break;
 880     case(capture_cb_capture_update_continue):
 881         statusbar_capture_update_continue_cb(capture_opts);
 882         break;
 883     case(capture_cb_capture_update_finished):
 884         statusbar_capture_update_finished_cb(capture_opts);
 885         break;
 886     case(capture_cb_capture_fixed_started):
 887         statusbar_capture_fixed_started_cb(capture_opts);
 888         break;
 889     case(capture_cb_capture_fixed_continue):
 890         statusbar_capture_fixed_continue_cb(capture_opts);
 891         break;
 892     case(capture_cb_capture_fixed_finished):
 893         statusbar_capture_fixed_finished_cb(capture_opts);
 894         break;
 895     case(capture_cb_capture_stopping):
 896         /* Beware: this state won't be called, if the capture child
 897          * closes the capturing on it's own! */
 898         break;
 899     default:
 900         g_warning("statusbar_capture_callback: event %u unknown", event);
 901         g_assert_not_reached();
 902     }
 903 }
 904 #endif