ui/gtk/progress_dlg.c

   1 /* progress_dlg.c
   2  * Routines for progress-bar (modal) dialog
   3  *
   4  * $Id$
   5  *
   6  * Wireshark - Network traffic analyzer
   7  * By Gerald Combs <gerald@wireshark.org>
   8  * Copyright 1998 Gerald Combs
   9  *
  10  * This program is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU General Public License
  12  * as published by the Free Software Foundation; either version 2
  13  * of the License, or (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  23  */
  24
  25 #include "config.h"
  26
  27 #include <string.h>
  28
  29 #include <gtk/gtk.h>
  30
  31 #include "ui/progress_dlg.h"
  32
  33 #include "ui/gtk/gtkglobals.h"
  34 #include "ui/gtk/dlg_utils.h"
  35 #include "ui/gtk/gui_utils.h"
  36
  37
  38 #define PROG_BAR_KEY    "progress_bar"
  39
  40 static gboolean delete_event_cb(GtkWidget *w, GdkEvent *event, gpointer data);
  41 static void stop_cb(GtkWidget *w, gpointer data);
  42
  43 /*
  44  * Define the structure describing a progress dialog.
  45  */
  46 struct progdlg {
  47         GtkWidget *dlg_w;       /* top-level window widget */
  48         GTimeVal   start_time;
  49         GTimeVal   last_time;   /* last time it was updated */
  50
  51         GtkLabel  *status_lb;
  52         GtkLabel  *elapsed_lb;
  53         GtkLabel  *time_left_lb;
  54         GtkLabel  *percentage_lb;
  55         gchar     *title;
  56 };
  57
  58 /*
  59  * Create and pop up the progress dialog; allocate a "progdlg_t"
  60  * and initialize it to contain all information the implementation
  61  * needs in order to manipulate the dialog, and return a pointer to
  62  * it.
  63  *
  64  * The first argument is the task to do, e.g. "Loading".
  65  * The second argument is the item to do, e.g. "capture.cap".
  66  * The third argument is TRUE if the "terminate this operation" button should
  67  * be a "Stop" button (meaning that the operation is stopped, but not undone),
  68  * and FALSE if it should be a "Cancel" button (meaning that it's stopped
  69  * and anything it's done would be undone)
  70  * The fourth argument is a pointer to a Boolean variable that will be
  71  *   set to TRUE if the user hits that button.
  72  *
  73  * XXX - provide a way to specify the progress in units, with the total
  74  * number of units specified as an argument when the progress dialog
  75  * is created; updates would be given in units, with the progress dialog
  76  * code computing the percentage, and the progress bar would have a
  77  * label "0" on the left and <total number of units> on the right, with
  78  * a label in the middle giving the number of units we've processed
  79  * so far.  This could be used when filtering packets, for example; we
  80  * wouldn't always use it, as we have no idea how many packets are to
  81  * be read.
  82  */
  83 progdlg_t *
  84 create_progress_dlg(const gpointer top_level_window _U_, const gchar *task_title, const gchar *item_title,
  85                     gboolean terminate_is_stop, gboolean *stop_flag)
  86 {
  87     progdlg_t *dlg;
  88     GtkWidget *dlg_w, *main_vb, *title_lb, *status_lb, *elapsed_lb, *time_left_lb, *percentage_lb;
  89     GtkWidget *prog_bar, *bbox, *cancel_bt;
  90     GtkWidget *static_vb, *tmp_lb, *main_hb, *dynamic_vb, *percentage_hb;
  91     gchar     *task_title_dup;
  92     gchar     *item_title_dup;
  93
  94     dlg = (progdlg_t *)g_malloc(sizeof (progdlg_t));
  95
  96     /* limit the item_title to some reasonable length */
  97     item_title_dup = g_strdup(item_title);
  98     if (strlen(item_title_dup) > 110) {
  99         g_strlcpy(&item_title_dup[100], "...", 4);
 100     }
 101
 102     dlg->title = g_strdup_printf("%s: %s", task_title, item_title_dup);
 103
 104     dlg_w = dlg_window_new(dlg->title);
 105     gtk_window_set_modal(GTK_WINDOW(dlg_w), TRUE);
 106
 107     /*
 108      * Container for dialog widgets.
 109      */
 110     main_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 1, FALSE);
 111     gtk_container_set_border_width(GTK_CONTAINER(main_vb), 5);
 112     gtk_container_add(GTK_CONTAINER(dlg_w), main_vb);
 113
 114     /*
 115      * Static labels (left dialog side, labels aligned to the right)
 116      */
 117     static_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 1, FALSE);
 118     task_title_dup = g_strdup_printf ("%s:", task_title);
 119     tmp_lb = gtk_label_new(task_title_dup);
 120     gtk_misc_set_alignment(GTK_MISC(tmp_lb), 1.0f, 0.0f);
 121     gtk_box_pack_start(GTK_BOX(static_vb), tmp_lb, FALSE, TRUE, 3);
 122     tmp_lb = gtk_label_new("Status:");
 123     gtk_misc_set_alignment(GTK_MISC(tmp_lb), 1.0f, 0.0f);
 124     gtk_box_pack_start(GTK_BOX(static_vb), tmp_lb, FALSE, TRUE, 3);
 125     tmp_lb = gtk_label_new("Elapsed Time:");
 126     gtk_misc_set_alignment(GTK_MISC(tmp_lb), 1.0f, 0.0f);
 127     gtk_box_pack_start(GTK_BOX(static_vb), tmp_lb, FALSE, TRUE, 3);
 128     tmp_lb = gtk_label_new("Time Left:");
 129     gtk_misc_set_alignment(GTK_MISC(tmp_lb), 1.0f, 0.0f);
 130     gtk_box_pack_start(GTK_BOX(static_vb), tmp_lb, FALSE, TRUE, 3);
 131     tmp_lb = gtk_label_new("Progress:");
 132     gtk_misc_set_alignment(GTK_MISC(tmp_lb), 1.0f, 0.0f);
 133     gtk_box_pack_start(GTK_BOX(static_vb), tmp_lb, FALSE, TRUE, 3);
 134
 135
 136     /*
 137      * Dynamic labels (right dialog side, labels aligned to the left)
 138      */
 139     dynamic_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 1, FALSE);
 140
 141     /*
 142      * Put the item_title here as a label indicating what we're
 143      * doing; set its alignment and padding so it's aligned on the
 144      * left.
 145      */
 146     title_lb = gtk_label_new(item_title_dup);
 147     gtk_box_pack_start(GTK_BOX(dynamic_vb), title_lb, FALSE, TRUE, 3);
 148     gtk_misc_set_alignment(GTK_MISC(title_lb), 0.0f, 0.0f);
 149     gtk_misc_set_padding(GTK_MISC(title_lb), 0, 0);
 150
 151     /* same for "Status" */
 152     status_lb = gtk_label_new("");
 153     gtk_box_pack_start(GTK_BOX(dynamic_vb), status_lb, FALSE, TRUE, 3);
 154     gtk_misc_set_alignment(GTK_MISC(status_lb), 0.0f, 0.0f);
 155     gtk_misc_set_padding(GTK_MISC(status_lb), 0, 0);
 156     dlg->status_lb = (GtkLabel *) status_lb;
 157
 158     /* same for "Elapsed Time" */
 159     elapsed_lb = gtk_label_new("00:00");
 160     gtk_box_pack_start(GTK_BOX(dynamic_vb), elapsed_lb, FALSE, TRUE, 3);
 161     gtk_misc_set_alignment(GTK_MISC(elapsed_lb), 0.0f, 0.0f);
 162     gtk_misc_set_padding(GTK_MISC(elapsed_lb), 0, 0);
 163     dlg->elapsed_lb = (GtkLabel *) elapsed_lb;
 164
 165     /* same for "Time Left" */
 166     time_left_lb = gtk_label_new("--:--");
 167     gtk_box_pack_start(GTK_BOX(dynamic_vb), time_left_lb, FALSE, TRUE, 3);
 168     gtk_misc_set_alignment(GTK_MISC(time_left_lb), 0.0f, 0.0f);
 169     gtk_misc_set_padding(GTK_MISC(time_left_lb), 0, 0);
 170     dlg->time_left_lb = (GtkLabel *) time_left_lb;
 171
 172     /*
 173      * The progress bar (in its own horizontal box, including
 174      * percentage value)
 175      */
 176     percentage_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 1, FALSE);
 177     gtk_box_pack_start(GTK_BOX(dynamic_vb), percentage_hb, FALSE, TRUE, 3);
 178
 179     prog_bar = gtk_progress_bar_new();
 180     gtk_box_pack_start(GTK_BOX(percentage_hb), prog_bar, FALSE, TRUE, 3);
 181
 182     percentage_lb = gtk_label_new("  0%");
 183     gtk_misc_set_alignment(GTK_MISC(percentage_lb), 0.0f, 0.0f);
 184     gtk_box_pack_start(GTK_BOX(percentage_hb), percentage_lb, FALSE, TRUE, 3);
 185     dlg->percentage_lb = (GtkLabel *) percentage_lb;
 186
 187     /*
 188      * Attach a pointer to the progress bar widget to the top-level widget.
 189      */
 190     g_object_set_data(G_OBJECT(dlg_w), PROG_BAR_KEY, prog_bar);
 191
 192     /*
 193      * Static and dynamic boxes are now complete
 194      */
 195     main_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 1, FALSE);
 196     gtk_box_pack_start(GTK_BOX(main_hb), static_vb, FALSE, TRUE, 3);
 197     gtk_box_pack_start(GTK_BOX(main_hb), dynamic_vb, FALSE, TRUE, 3);
 198     gtk_box_pack_start(GTK_BOX(main_vb), main_hb, FALSE, TRUE, 3);
 199
 200     /* Button row */
 201     bbox = dlg_button_row_new(terminate_is_stop ? GTK_STOCK_STOP :
 202                               GTK_STOCK_CANCEL, NULL);
 203     gtk_container_add(GTK_CONTAINER(main_vb), bbox);
 204     gtk_widget_show(bbox);
 205
 206     cancel_bt = (GtkWidget *)g_object_get_data(G_OBJECT(bbox), terminate_is_stop ? GTK_STOCK_STOP :
 207                                 GTK_STOCK_CANCEL);
 208     gtk_widget_grab_default(cancel_bt);
 209
 210     /*
 211      * Allow user to either click the "Cancel"/"Stop" button, or
 212      * the close button on the window, to stop an operation in
 213      * progress.
 214      */
 215     g_signal_connect(cancel_bt, "clicked", G_CALLBACK(stop_cb), stop_flag);
 216     g_signal_connect(dlg_w, "delete_event", G_CALLBACK(delete_event_cb), stop_flag);
 217
 218     gtk_widget_show_all(dlg_w);
 219
 220     dlg->dlg_w = dlg_w;
 221
 222     g_get_current_time(&dlg->start_time);
 223     memset(&dlg->last_time, 0, sizeof(dlg->last_time));
 224
 225     g_free(task_title_dup);
 226     g_free(item_title_dup);
 227
 228     return dlg;
 229 }
 230
 231 progdlg_t *
 232 delayed_create_progress_dlg(const gpointer top_level_window, const gchar *task_title,
 233                             const gchar *item_title, gboolean terminate_is_stop,
 234                             gboolean *stop_flag, const GTimeVal *start_time, gfloat progress)
 235 {
 236     GTimeVal    time_now;
 237     gdouble     delta_time;
 238     gdouble     min_display;
 239     progdlg_t  *dlg;
 240
 241 #define INIT_DELAY          0.1 * 1e6 /* .1 second = 0.1e6 microseconds */
 242 #define MIN_DISPLAY_DEFAULT 2.0 * 1e6
 243
 244     /* Create a progress dialog, but only if it's not likely to disappear
 245      * immediately, which can be disconcerting for the user.
 246      *
 247      * Arguments are as for create_progress_dlg(), plus:
 248      *
 249      * (a) A pointer to a GTimeVal structure which holds the time at which
 250      *     the caller started to process the data.
 251      * (b) The current progress as a real number between 0 and 1.
 252      */
 253
 254     g_get_current_time(&time_now);
 255
 256     /* Get the time elapsed since the caller started processing the data */
 257
 258     delta_time = (time_now.tv_sec - start_time->tv_sec) * 1e6 +
 259         time_now.tv_usec - start_time->tv_usec;
 260
 261     /* Do nothing for the first INIT_DELAY microseconds */
 262
 263     if (delta_time < INIT_DELAY)
 264         return NULL;
 265
 266     /* If we create the progress dialog we want it to be displayed for a
 267      * minimum of MIN_DISPLAY_DEFAULT microseconds.  However, if we
 268      * previously estimated that the progress dialog didn't need to be
 269      * created and the caller's processing is slowing down (perhaps due
 270      * to the action of the operating system's scheduler on a compute-
 271      * intensive task), we tail off the minimum display time such that
 272      * the progress dialog will always be created after
 273      * 2*MIN_DISPLAY_DEFAULT microseconds.
 274      */
 275
 276     if (delta_time <= INIT_DELAY + MIN_DISPLAY_DEFAULT)
 277         min_display = MIN_DISPLAY_DEFAULT;
 278     else
 279         min_display = 2 * MIN_DISPLAY_DEFAULT - delta_time;
 280     /* = MIN_DISPLAY_DEFAULT - (delta_time - MIN_DISPLAY_DEFAULT) */
 281
 282     /* Assuming the progress increases linearly, see if the progress
 283      * dialog would be displayed for at least min_display microseconds if
 284      * we created it now.
 285      */
 286
 287     if (progress >= (delta_time / (delta_time + min_display)))
 288         return NULL;
 289
 290     dlg = create_progress_dlg(top_level_window, task_title, item_title, terminate_is_stop,
 291                               stop_flag);
 292
 293     /*
 294      * Flush out the dialog so we don't see an "empty" one until first update.
 295      */
 296     while (gtk_events_pending())
 297             gtk_main_iteration();
 298
 299     /* set dialog start_time to the start of processing, not box creation */
 300     dlg->start_time = *start_time;
 301
 302     return dlg;
 303 }
 304
 305 /*
 306  * Called when the dialog box is to be deleted.
 307  * Set the "stop" flag to TRUE, and return TRUE - we don't want the dialog
 308  * box deleted now, our caller will do so when they see that the
 309  * "stop" flag is TRUE and abort the operation.
 310  */
 311 static gboolean
 312 delete_event_cb(GtkWidget *w _U_, GdkEvent *event _U_, gpointer data)
 313 {
 314         gboolean *stop_flag = (gboolean *) data;
 315
 316         *stop_flag = TRUE;
 317         return TRUE;
 318 }
 319
 320 /*
 321  * Called when the "stop this operation" button is clicked.
 322  * Set the "stop" flag to TRUE; we don't have to destroy the dialog
 323  * box, as our caller will do so when they see that the "stop" flag is
 324  * true and abort the operation.
 325  */
 326 static void
 327 stop_cb(GtkWidget *w _U_, gpointer data)
 328 {
 329         gboolean *stop_flag = (gboolean *) data;
 330
 331         *stop_flag = TRUE;
 332 }
 333
 334 /*
 335  * Update the progress information of the progress dialog box.
 336  */
 337 void
 338 update_progress_dlg(progdlg_t *dlg, gfloat percentage, const gchar *status)
 339 {
 340         GtkWidget *dlg_w = dlg->dlg_w;
 341         GtkWidget *prog_bar;
 342         GTimeVal   time_now;
 343         gdouble    delta_time;
 344         gulong     ul_left;
 345         gulong     ul_elapsed;
 346         gulong     ul_percentage;
 347         gchar      tmp[100];
 348
 349
 350         /* calculate some timing values */
 351         g_get_current_time(&time_now);
 352
 353         delta_time = (time_now.tv_sec - dlg->last_time.tv_sec) * 1e6 +
 354                 time_now.tv_usec - dlg->last_time.tv_usec;
 355
 356         /* after the first time don't update more than every 100ms */
 357         if (dlg->last_time.tv_sec && delta_time < 100*1000)
 358                 return;
 359
 360         dlg->last_time = time_now;
 361         delta_time = (time_now.tv_sec - dlg->start_time.tv_sec) * 1e6 +
 362                 time_now.tv_usec - dlg->start_time.tv_usec;
 363
 364         ul_percentage = (gulong) (percentage * 100);
 365         ul_elapsed = (gulong) (delta_time / 1000 / 1000);
 366
 367         /* update labels */
 368         g_snprintf(tmp, sizeof(tmp), "%lu%% of %s", ul_percentage, dlg->title);
 369         gtk_window_set_title(GTK_WINDOW(dlg_w), tmp);
 370
 371         gtk_label_set_text(dlg->status_lb, status);
 372
 373         g_snprintf(tmp, sizeof(tmp), "%lu%%", ul_percentage);
 374         gtk_label_set_text(dlg->percentage_lb, tmp);
 375
 376         g_snprintf(tmp, sizeof(tmp), "%02lu:%02lu", ul_elapsed / 60,
 377                    ul_elapsed % 60);
 378         gtk_label_set_text(dlg->elapsed_lb, tmp);
 379
 380         /* show "Time Left" only,
 381          * if at least 5% and 3 seconds running (to get a useful estimation) */
 382         if (ul_percentage >= 5 && delta_time >= 3 * 1e6) {
 383                 ul_left = (gulong) ((delta_time / percentage - delta_time) / 1000 / 1000);
 384
 385                 g_snprintf(tmp, sizeof(tmp), "%02lu:%02lu", ul_left / 60,
 386                            ul_left % 60);
 387                 gtk_label_set_text(dlg->time_left_lb, tmp);
 388         }
 389
 390         /* update progress bar */
 391         prog_bar = (GtkWidget *)g_object_get_data(G_OBJECT(dlg_w), PROG_BAR_KEY);
 392         gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(prog_bar), percentage);
 393
 394         /*
 395          * Flush out the update and process any input events.
 396          */
 397         while (gtk_events_pending())
 398                 gtk_main_iteration();
 399 }
 400
 401 /*
 402  * Destroy the progress dialog.
 403  */
 404 void
 405 destroy_progress_dlg(progdlg_t *dlg)
 406 {
 407     GtkWidget *dlg_w = dlg->dlg_w;
 408
 409     window_destroy(GTK_WIDGET(dlg_w));
 410     g_free(dlg->title);
 411     g_free(dlg);
 412 }