c4e38346f63402bf37f71b6f51de6b7becd426a7
[metze/wireshark/wip.git] / ui / gtk / about_dlg.c
1 /* about_dlg.c
2  *
3  * $Id$
4  *
5  * Ulf Lamping <ulf.lamping@web.de>
6  *
7  * Wireshark - Network traffic analyzer
8  * By Gerald Combs <gerald@wireshark.org>
9  * Copyright 1998 Gerald Combs
10  *
11  * This program is free software; you can redistribute it and/or
12  * modify it under the terms of the GNU General Public License
13  * as published by the Free Software Foundation; either version 2
14  * of the License, or (at your option) any later version.
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  * GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program; if not, write to the Free Software
23  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
24  */
25
26 #include "config.h"
27
28 #include <string.h>
29
30 #include <gtk/gtk.h>
31
32 #include <wsutil/filesystem.h>
33 #include <wsutil/plugins.h>
34 #ifdef HAVE_LIBSMI
35 #include <epan/oids.h>
36 #endif
37 #ifdef HAVE_GEOIP
38 #include <epan/geoip_db.h>
39 #endif
40 #ifdef HAVE_LUA
41 #include <epan/wslua/init_wslua.h>
42 #endif
43
44 #include "../log.h"
45 #include "../version_info.h"
46 #include "../register.h"
47
48 #include "ui/last_open_dir.h"
49
50 #include "ui/gtk/about_dlg.h"
51 #include "ui/gtk/gui_utils.h"
52 #include "ui/gtk/dlg_utils.h"
53 #include "ui/gtk/file_dlg.h"
54 #include "ui/gtk/text_page_utils.h"
55 #include "ui/gtk/gtkglobals.h"
56 #include "ui/gtk/main.h"
57 #include "ui/gtk/plugins_dlg.h"
58 #include "ui/gtk/gui_utils.h"
59 #include "ui/gtk/wssplash.h"
60
61 #include "webbrowser.h"
62
63 /*
64  * Update frequence for the splash screen, given in milliseconds.
65  */
66 int info_update_freq = 100;
67
68 static void about_wireshark_destroy_cb(GtkWidget *, gpointer);
69
70
71 /*
72  * Keep a static pointer to the current "About Wireshark" window, if any, so
73  * that if somebody tries to do "About Wireshark" while there's already an
74  * "About Wireshark" window up, we just pop up the existing one, rather than
75  * creating a new one.
76  */
77 static GtkWidget *about_wireshark_w;
78
79
80 static void
81 about_wireshark(GtkWidget *parent _U_, GtkWidget *main_vb)
82 {
83   GtkWidget   *msg_label, *icon;
84   gchar       *message;
85   const char  *title = "Network Protocol Analyzer";
86
87   /*icon = xpm_to_widget_from_parent(parent, wssplash_xpm);*/
88   icon = pixbuf_to_widget(wssplash_pb_data);
89
90   gtk_box_pack_start(GTK_BOX(main_vb), icon, TRUE, TRUE, 0);
91
92
93   msg_label = gtk_label_new(title);
94   message = g_strdup_printf("<span size=\"x-large\" weight=\"bold\">%s</span>", title);
95   gtk_label_set_markup(GTK_LABEL(msg_label), message);
96   g_free(message);
97   gtk_box_pack_start(GTK_BOX(main_vb), msg_label, TRUE, TRUE, 0);
98 }
99
100 static void
101 splash_update_label(GtkWidget *win, const char *message)
102 {
103     GtkWidget *main_lb;
104
105     if (win == NULL) return;
106
107     main_lb = (GtkWidget *)g_object_get_data(G_OBJECT(win), "splash_label");
108     gtk_label_set_text(GTK_LABEL(main_lb), message);
109
110     /* Process all pending GUI events before continuing, so that
111        the splash screen window gets updated. */
112     while (gtk_events_pending()) gtk_main_iteration();
113 }
114
115 GtkWidget*
116 splash_new(const char *message)
117 {
118     GtkWidget *win;
119     GtkWidget *main_lb;
120
121     GtkWidget *main_box;
122     GtkWidget *percentage_box;
123     GtkWidget *prog_bar;
124     GtkWidget *percentage_lb;
125
126     win = splash_window_new();
127
128     /* When calling about_wireshark(), we must realize the top-level
129        widget for the window, otherwise GTK will throw a warning
130        because we don't have a colormap associated with that window and
131        can't handle the pixmap. */
132     gtk_widget_realize(win);
133
134     main_box = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 6, FALSE);
135     gtk_container_set_border_width(GTK_CONTAINER(main_box), 24);
136     gtk_container_add(GTK_CONTAINER(win), main_box);
137
138
139     about_wireshark(win, main_box);
140
141     main_lb = gtk_label_new(message);
142     gtk_box_pack_start(GTK_BOX(main_box), main_lb, TRUE, TRUE, 0);
143     g_object_set_data(G_OBJECT(win), "splash_label", main_lb);
144
145     main_lb = gtk_label_new("");
146     gtk_box_pack_start(GTK_BOX(main_box), main_lb, TRUE, TRUE, 0);
147     g_object_set_data(G_OBJECT(win), "protocol_label", main_lb);
148
149     percentage_box = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 1, FALSE);
150     gtk_box_pack_start(GTK_BOX(main_box), percentage_box, TRUE, TRUE, 3);
151
152     prog_bar = gtk_progress_bar_new();
153     gtk_box_pack_start(GTK_BOX(percentage_box), prog_bar, TRUE, TRUE, 3);
154     g_object_set_data(G_OBJECT(win), "progress_bar", prog_bar);
155
156     percentage_lb = gtk_label_new("  0%");
157     gtk_misc_set_alignment(GTK_MISC(percentage_lb), 0.0f, 0.0f);
158     gtk_box_pack_start(GTK_BOX(percentage_box), percentage_lb, FALSE, TRUE, 3);
159     g_object_set_data(G_OBJECT(win), "percentage_label", percentage_lb);
160
161     gtk_widget_show_all(win);
162
163     splash_update_label(win, message);
164
165     return win;
166 }
167
168 void
169 splash_update(register_action_e action, const char *message, gpointer client_data)
170 {
171     GtkWidget  *win;
172     GtkWidget  *main_lb;
173     GtkWidget  *prog_bar;
174     GtkWidget  *percentage_lb;
175     gfloat     percentage;
176     gulong     ul_percentage;
177     gchar      tmp[100];
178     const char *action_msg;
179
180     static gulong ul_sofar = 0;
181     static gulong ul_count = 0;
182
183     static register_action_e last_action = RA_NONE;
184
185     static GTimeVal cur_tv;
186     static GTimeVal next_tv = {0, 0};
187
188     win = (GtkWidget *)client_data;
189
190     if (win == NULL) return;
191
192     g_get_current_time(&cur_tv);
193     if (last_action == action && cur_tv.tv_sec <= next_tv.tv_sec && cur_tv.tv_usec <= next_tv.tv_usec && ul_sofar < ul_count - 1) {
194       /* Only update every splash_register_freq milliseconds */
195       ul_sofar++;
196       return;
197     }
198     memcpy(&next_tv, &cur_tv, sizeof(next_tv));
199     next_tv.tv_usec += info_update_freq * 1000;
200     if (next_tv.tv_usec >= 1000000) {
201         next_tv.tv_sec++;
202         next_tv.tv_usec -= 1000000;
203     }
204
205     if(last_action != action) {
206       /* the action has changed */
207       switch(action) {
208       case RA_DISSECTORS:
209         action_msg = "Initializing dissectors ...";
210         break;
211       case RA_LISTENERS:
212         action_msg = "Initializing tap listeners ...";
213         break;
214       case RA_REGISTER:
215         action_msg = "Registering dissector ...";
216         break;
217       case RA_PLUGIN_REGISTER:
218         action_msg = "Registering plugins ...";
219         break;
220       case RA_PYTHON_REGISTER:
221         action_msg = "Registering Python dissectors ...";
222         break;
223       case RA_HANDOFF:
224         action_msg = "Handing off dissector ...";
225         break;
226       case RA_PLUGIN_HANDOFF:
227         action_msg = "Handing off plugins ...";
228         break;
229       case RA_PYTHON_HANDOFF:
230         action_msg = "Handing off Python dissectors ...";
231         break;
232       case RA_LUA_PLUGINS:
233         action_msg = "Loading Lua plugins ...";
234         break;
235       case RA_PREFERENCES:
236         action_msg = "Loading module preferences ...";
237         break;
238       case RA_CONFIGURATION:
239         action_msg = "Loading configuration files ...";
240         break;
241       default:
242         action_msg = "(Unknown action)";
243         break;
244       }
245       splash_update_label(win, action_msg);
246       last_action = action;
247     }
248
249     if(ul_count == 0) { /* get the count of dissectors */
250       ul_count = register_count() + 6; /* additional 6 for:
251                                           dissectors, listeners,
252                                           registering plugins, handingoff plugins,
253                                           preferences and configuration */
254 #ifdef HAVE_LUA
255       ul_count += wslua_count_plugins (); /* get count of lua plugins */
256 #endif
257 #ifdef HAVE_PYTHON
258       ul_count += 2;   /* additional 2 for python register and handoff */
259 #endif
260     }
261
262     main_lb = (GtkWidget *)g_object_get_data(G_OBJECT(win), "protocol_label");
263     /* make_dissector_reg.py changed -
264        so we need to strip off the leading elements to get back to the protocol */
265     if(message) {
266       if(!strncmp(message, "proto_register_", 15))
267         message += 15;
268       else if(!strncmp(message, "proto_reg_handoff_", 18))
269         message += 18;
270     }
271     gtk_label_set_text(GTK_LABEL(main_lb), message ? message : "");
272
273     ul_sofar++;
274
275     g_assert (ul_sofar <= ul_count);
276
277     percentage = (gfloat)ul_sofar/(gfloat)ul_count;
278     ul_percentage = (gulong)(percentage * 100);
279
280     /* update progress bar */
281     prog_bar = (GtkWidget *)g_object_get_data(G_OBJECT(win), "progress_bar");
282     gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(prog_bar), percentage);
283
284     percentage_lb = (GtkWidget *)g_object_get_data(G_OBJECT(win), "percentage_label");
285     g_snprintf(tmp, sizeof(tmp), "%lu%%", ul_percentage);
286     gtk_label_set_text((GtkLabel*)percentage_lb, tmp);
287
288     /* Process all pending GUI events before continuing, so that
289        the splash screen window gets updated. */
290     while (gtk_events_pending()) gtk_main_iteration();
291
292 }
293
294 gboolean
295 splash_destroy(GtkWidget *win)
296 {
297     if (win == NULL)
298         return FALSE;
299
300     gtk_widget_destroy(win);
301     return FALSE;
302 }
303
304 static GtkWidget *
305 about_wireshark_page_new(void)
306 {
307   GtkWidget   *main_box, *msg_label /*, *icon*/;
308   gchar       *message;
309
310   main_box = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 6, FALSE);
311   gtk_container_set_border_width(GTK_CONTAINER(main_box), 12);
312
313   g_object_set(gtk_widget_get_settings(main_box),
314     "gtk-label-select-on-focus", FALSE, NULL);
315
316   about_wireshark(top_level, main_box);
317
318   /* Construct the message string */
319   message = g_strdup_printf(
320        "Version " VERSION "%s\n"
321        "\n"
322        "%s"
323        "\n"
324        "%s"
325        "\n"
326        "%s"
327        "\n"
328        "Wireshark is Open Source Software released under the GNU General Public License.\n"
329        "\n"
330        "Check the man page and http://www.wireshark.org for more information.",
331        wireshark_svnversion, get_copyright_info(), comp_info_str->str,
332        runtime_info_str->str);
333
334   msg_label = gtk_label_new(message);
335   g_free(message);
336   gtk_label_set_justify(GTK_LABEL(msg_label), GTK_JUSTIFY_FILL);
337   gtk_label_set_selectable(GTK_LABEL(msg_label), TRUE);
338   gtk_box_pack_start(GTK_BOX (main_box), msg_label, TRUE, TRUE, 0);
339
340
341   return main_box;
342 }
343
344 static GtkWidget *
345 about_authors_page_new(void)
346 {
347   GtkWidget   *page;
348   char *absolute_path;
349
350   absolute_path = get_datafile_path("AUTHORS-SHORT");
351   page = text_page_new(absolute_path);
352
353   return page;
354 }
355
356 static gboolean about_folders_callback(GtkWidget *widget, GdkEventButton *event, gint id _U_)
357 {
358   GtkTreeSelection *tree_selection;
359   GtkTreeModel *model;
360   GtkTreeIter  iter;
361   gchar        *path;
362
363   tree_selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(widget));
364
365   if(gtk_tree_selection_count_selected_rows(tree_selection) == 0)
366     return FALSE;
367
368   if(event->type != GDK_2BUTTON_PRESS)
369     /* not a double click */
370     return FALSE;
371
372   if(gtk_tree_selection_get_selected (tree_selection, &model, &iter)) {
373     gtk_tree_model_get(model, &iter, 1, &path, -1);
374     filemanager_open_directory(path);
375     g_free(path);
376   }
377
378   return TRUE;
379 }
380
381 static void
382 about_folders_row(GtkWidget *table, const char *label, const char *dir, const char *tip)
383 {
384   simple_list_append(table, 0, label, 1, dir, 2, tip, -1);
385 }
386
387 static GtkWidget *
388 about_folders_page_new(void)
389 {
390   GtkWidget   *table;
391   const char *constpath;
392   char *path;
393   static const gchar *titles[] = { "Name", "Folder", "Typical Files"};
394   GtkWidget *scrolledwindow;
395 #if defined (HAVE_LIBSMI) || defined (HAVE_GEOIP)
396   gint i;
397   gchar **resultArray;
398 #endif
399 #if 0
400   const gchar * const *dirs;
401 #endif
402
403   scrolledwindow = scrolled_window_new(NULL, NULL);
404   gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwindow),
405                                    GTK_SHADOW_IN);
406
407   /* Container for our data */
408   table = simple_list_new(3, titles);
409
410   /* connect a callback so we can spot a double-click */
411   g_signal_connect(table, "button_press_event",
412                      G_CALLBACK(about_folders_callback), NULL);
413
414   simple_list_url_col(table, 1);
415
416   /* "file open" */
417   about_folders_row(table, "\"File\" dialogs", get_last_open_dir(),
418       "capture files");
419
420   /* temp */
421   about_folders_row(table, "Temp", g_get_tmp_dir(),
422       "untitled capture files");
423
424   /* pers conf */
425   path = get_persconffile_path("", FALSE);
426   about_folders_row(table, "Personal configuration", path,
427       "\"dfilters\", \"preferences\", \"ethers\", ...");
428   g_free(path);
429
430   /* global conf */
431   constpath = get_datafile_dir();
432   if (constpath != NULL) {
433     about_folders_row(table, "Global configuration", constpath,
434         "\"dfilters\", \"preferences\", \"manuf\", ...");
435   }
436 #if 0
437   dirs = g_get_system_data_dirs ();
438   for (i = 0; dirs[i]; i++){
439           g_warning("glibs data path %u %s",i+1,dirs[i]);
440   }
441 #endif
442   /* system */
443   constpath = get_systemfile_dir();
444   about_folders_row(table, "System", constpath,
445       "\"ethers\", \"ipxnets\"");
446
447   /* program */
448   constpath = get_progfile_dir();
449   about_folders_row(table, "Program", constpath,
450       "program files");
451
452 #if defined(HAVE_PLUGINS) || defined(HAVE_LUA)
453   /* pers plugins */
454   path = get_plugins_pers_dir();
455   about_folders_row(table, "Personal Plugins", path,
456       "dissector plugins");
457   g_free(path);
458
459   /* global plugins */
460   about_folders_row(table, "Global Plugins", get_plugin_dir(),
461       "dissector plugins");
462 #endif
463
464 #ifdef HAVE_PYTHON
465   /* global python bindings */
466   about_folders_row(table, "Python Bindings", get_wspython_dir(),
467       "python bindings");
468 #endif
469
470 #ifdef HAVE_GEOIP
471   /* GeoIP */
472   path = geoip_db_get_paths();
473
474   resultArray = g_strsplit(path, G_SEARCHPATH_SEPARATOR_S, 10);
475
476   for(i = 0; resultArray[i]; i++)
477     about_folders_row(table, "GeoIP path", g_strstrip(resultArray[i]),
478                       "GeoIP database search path");
479   g_strfreev(resultArray);
480   g_free(path);
481 #endif
482
483 #ifdef HAVE_LIBSMI
484   /* SMI MIBs/PIBs */
485   path = oid_get_default_mib_path();
486
487   resultArray = g_strsplit(path, G_SEARCHPATH_SEPARATOR_S, 10);
488
489   for(i = 0; resultArray[i]; i++)
490     about_folders_row(table, "MIB/PIB path", g_strstrip(resultArray[i]),
491                       "SMI MIB/PIB search path");
492   g_strfreev(resultArray);
493   g_free(path);
494 #endif
495
496   gtk_container_add(GTK_CONTAINER(scrolledwindow), table);
497
498   return scrolledwindow;
499 }
500
501 static GtkWidget *
502 about_license_page_new(void)
503 {
504   GtkWidget   *page;
505   char *absolute_path;
506
507 #if defined(_WIN32)
508   absolute_path = get_datafile_path("COPYING.txt");
509 #else
510   absolute_path = get_datafile_path("COPYING");
511 #endif
512   page = text_page_new(absolute_path);
513
514   return page;
515 }
516
517 void
518 about_wireshark_cb( GtkWidget *w _U_, gpointer data _U_ )
519 {
520   GtkWidget   *main_box, *main_nb, *bbox, *ok_btn;
521   GtkWidget   *page_lb, *about_page, *folders_page;
522
523 #if defined(HAVE_PLUGINS) || defined(HAVE_LUA)
524   GtkWidget   *plugins_page;
525 #endif
526
527   GtkWidget   *authors_page, *license_page;
528
529   if (about_wireshark_w != NULL) {
530     /* There's already an "About Wireshark" dialog box; reactivate it. */
531     reactivate_window(about_wireshark_w);
532     return;
533   }
534
535   /*
536    * XXX - use GtkDialog?  The GNOME 2.x GnomeAbout widget does.
537    * Should we use GtkDialog for simple_dialog() as well?  Or
538    * is the GTK+ 2.x GtkDialog appropriate but the 1.2[.x] one
539    * not?  (The GNOME 1.x GnomeAbout widget uses GnomeDialog.)
540    */
541   about_wireshark_w = dlg_window_new("About Wireshark");
542   /* set the initial position (must be done, before show is called!) */
543   /* default position is not appropriate for the about dialog */
544   gtk_window_set_position(GTK_WINDOW(about_wireshark_w), GTK_WIN_POS_CENTER_ON_PARENT);
545   gtk_window_set_default_size(GTK_WINDOW(about_wireshark_w), 600, 400);
546   gtk_container_set_border_width(GTK_CONTAINER(about_wireshark_w), 6);
547
548   main_box = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 12, FALSE);
549   gtk_container_set_border_width(GTK_CONTAINER(main_box), 6);
550   gtk_container_add(GTK_CONTAINER(about_wireshark_w), main_box);
551
552   main_nb = gtk_notebook_new();
553   gtk_box_pack_start(GTK_BOX(main_box), main_nb, TRUE, TRUE, 0);
554
555   about_page = about_wireshark_page_new();
556   page_lb = gtk_label_new("Wireshark");
557   gtk_notebook_append_page(GTK_NOTEBOOK(main_nb), about_page, page_lb);
558
559   authors_page = about_authors_page_new();
560   page_lb = gtk_label_new("Authors");
561   gtk_notebook_append_page(GTK_NOTEBOOK(main_nb), authors_page, page_lb);
562
563   folders_page = about_folders_page_new();
564   page_lb = gtk_label_new("Folders");
565   gtk_notebook_append_page(GTK_NOTEBOOK(main_nb), folders_page, page_lb);
566
567 #if defined(HAVE_PLUGINS) || defined(HAVE_LUA)
568   plugins_page = about_plugins_page_new();
569   page_lb = gtk_label_new("Plugins");
570   gtk_notebook_append_page(GTK_NOTEBOOK(main_nb), plugins_page, page_lb);
571 #endif
572
573   license_page = about_license_page_new();
574   page_lb = gtk_label_new("License");
575   /* set a minmum width to avoid a lot of line breaks at the wrong places */
576   gtk_widget_set_size_request(license_page, 600, -1);
577   gtk_notebook_append_page(GTK_NOTEBOOK(main_nb), license_page, page_lb);
578
579   /* Button row */
580   bbox = dlg_button_row_new(GTK_STOCK_OK, NULL);
581   gtk_box_pack_start(GTK_BOX(main_box), bbox, FALSE, FALSE, 0);
582
583   ok_btn = (GtkWidget *)g_object_get_data(G_OBJECT(bbox), GTK_STOCK_OK);
584   gtk_widget_grab_focus(ok_btn);
585   gtk_widget_grab_default(ok_btn);
586   window_set_cancel_button(about_wireshark_w, ok_btn, window_cancel_button_cb);
587
588   g_signal_connect(about_wireshark_w, "delete_event", G_CALLBACK(window_delete_event_cb), NULL);
589   g_signal_connect(about_wireshark_w, "destroy", G_CALLBACK(about_wireshark_destroy_cb), NULL);
590
591   gtk_widget_show_all(about_wireshark_w);
592   window_present(about_wireshark_w);
593 }
594
595 static void
596 about_wireshark_destroy_cb(GtkWidget *win _U_, gpointer user_data _U_)
597 {
598   /* Note that we no longer have an "About Wireshark" dialog box. */
599   about_wireshark_w = NULL;
600 }