Moved GTK-dependent routines for file dialogues, print dialogues, print

preferences, and menus to gtk subdirectory.

svn path=/trunk/; revision=623

8 files changed, 1072 insertions, 1 deletions

diff --git a/gtk/Makefile.am b/gtk/Makefile.am
index 3915a73d81..50241b3c5a 100644
--- a/gtk/Makefile.am
+++ b/gtk/Makefile.am
@@ -5,8 +5,15 @@ CLEANFILES = \
 	*~
 
 libui_a_SOURCES = \
+	file_dlg.c	\
 	gtkbindings.h	\
 	gtkclist.c	\
 	gtkclist.h	\
 	gtkdnd.h	\
-	gtkmain.h
+	gtkmain.h	\
+	keys.h		\
+	menu.c		\
+	menu.h		\
+	print_dlg.c	\
+	print_prefs.c   \
+	print_prefs.h
diff --git a/gtk/file_dlg.c b/gtk/file_dlg.c
new file mode 100644
index 0000000000..91e1057d59
--- /dev/null
+++ b/gtk/file_dlg.c
@@ -0,0 +1,254 @@
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+#ifdef HAVE_DIRECT_H
+#include <direct.h>
+#endif
+
+#include <string.h>
+
+#ifndef __GLOBALS_H__
+#include "globals.h"
+#endif
+
+#ifndef __KEYS_H__
+#include "keys.h"
+#endif
+
+#ifndef __PREFS_H__
+#include "prefs.h"
+#endif
+
+#ifndef __UTIL_H__
+#include "util.h"
+#endif
+
+#ifndef __MENU_H__
+#include "menu.h"
+#endif
+
+static void file_open_ok_cb(GtkWidget *w, GtkFileSelection *fs);
+static void file_save_ok_cb(GtkWidget *w, GtkFileSelection *fs);
+static void file_save_as_ok_cb(GtkWidget *w, GtkFileSelection *fs);
+
+/* Open a file */
+void
+file_open_cmd_cb(GtkWidget *w, gpointer data) {
+  GtkWidget *filter_hbox, *filter_bt, *filter_te;
+
+  if (last_open_dir)
+	  chdir(last_open_dir);
+
+  file_sel = gtk_file_selection_new ("Ethereal: Open Capture File");
+  
+  /* Connect the ok_button to file_open_ok_cb function and pass along a
+     pointer to the file selection box widget */
+  gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (file_sel)->ok_button),
+    "clicked", (GtkSignalFunc) file_open_ok_cb, file_sel );
+
+  gtk_object_set_data(GTK_OBJECT(GTK_FILE_SELECTION(file_sel)->ok_button),
+      E_DFILTER_TE_KEY, gtk_object_get_data(GTK_OBJECT(w), E_DFILTER_TE_KEY));
+
+  filter_hbox = gtk_hbox_new(FALSE, 1);
+  gtk_container_border_width(GTK_CONTAINER(filter_hbox), 0);
+  gtk_box_pack_start(GTK_BOX(GTK_FILE_SELECTION(file_sel)->action_area),
+    filter_hbox, FALSE, FALSE, 0);
+  gtk_widget_show(filter_hbox);
+
+  filter_bt = gtk_button_new_with_label("Filter:");
+  gtk_signal_connect(GTK_OBJECT(filter_bt), "clicked",
+    GTK_SIGNAL_FUNC(prefs_cb), (gpointer) E_PR_PG_FILTER);
+  gtk_box_pack_start(GTK_BOX(filter_hbox), filter_bt, FALSE, TRUE, 0);
+  gtk_widget_show(filter_bt);
+  
+  filter_te = gtk_entry_new();
+  gtk_object_set_data(GTK_OBJECT(filter_bt), E_FILT_TE_PTR_KEY, filter_te);
+  gtk_box_pack_start(GTK_BOX(filter_hbox), filter_te, TRUE, TRUE, 3);
+  gtk_widget_show(filter_te);
+
+  gtk_object_set_data(GTK_OBJECT(GTK_FILE_SELECTION(file_sel)->ok_button),
+    E_RFILTER_TE_KEY, filter_te);
+
+  /* Connect the cancel_button to destroy the widget */
+  gtk_signal_connect_object(GTK_OBJECT (GTK_FILE_SELECTION
+    (file_sel)->cancel_button), "clicked", (GtkSignalFunc)
+    gtk_widget_destroy, GTK_OBJECT (file_sel));
+
+#ifdef HAVE_LIBPCAP
+  if( fork_mode && (cf.save_file != NULL) )
+#else
+  if( cf.save_file != NULL )
+#endif
+    gtk_file_selection_set_filename(GTK_FILE_SELECTION(file_sel), cf.save_file);
+  else
+    gtk_file_selection_set_filename(GTK_FILE_SELECTION(file_sel), "");
+
+  gtk_widget_show(file_sel);
+}
+
+static void
+file_open_ok_cb(GtkWidget *w, GtkFileSelection *fs) {
+  gchar     *cf_name, *rfilter, *s;
+  GtkWidget *filter_te;
+  dfilter   *rfcode = NULL;
+  int        err;
+
+  cf_name = g_strdup(gtk_file_selection_get_filename(GTK_FILE_SELECTION (fs)));
+  filter_te = gtk_object_get_data(GTK_OBJECT(w), E_RFILTER_TE_KEY);
+  rfilter = gtk_entry_get_text(GTK_ENTRY(filter_te));
+  if (rfilter[0] != '\0') {
+	rfcode = dfilter_new();
+	if (dfilter_compile(rfcode, rfilter) != 0) {
+		simple_dialog(ESD_TYPE_WARN, NULL, dfilter_error_msg);
+		dfilter_destroy(rfcode);
+		return;
+	}
+  }
+
+  /* Try to open the capture file. */
+  if ((err = open_cap_file(cf_name, &cf)) != 0) {
+    /* We couldn't open it; don't dismiss the open dialog box,
+       just leave it around so that the user can, after they
+       dismiss the alert box popped up for the open error,
+       try again. */
+    if (rfcode != NULL)
+      dfilter_destroy(rfcode);
+    return;
+  }
+
+  /* Attach the new read filter to "cf" ("open_cap_file()" succeeded, so
+     it closed the previous capture file, and thus destroyed any
+     previous read filter attached to "cf"). */
+  cf.rfcode = rfcode;
+
+  /* We've crossed the Rubicon; get rid of the file selection box. */
+  gtk_widget_hide(GTK_WIDGET (fs));
+  gtk_widget_destroy(GTK_WIDGET (fs));
+
+  err = read_cap_file(&cf);
+  /* Save the directory name; we can write over cf_name. */
+  s = strrchr(cf_name, '/');
+  if (s && last_open_dir) {
+	  *s = '\0';
+	  if (strcmp(last_open_dir, cf_name) != 0) {
+		  g_free(last_open_dir);
+		  last_open_dir = g_strdup(cf_name);
+	  }
+  }
+  else if (s) { /* ! last_open_dir */
+	  *s = '\0';
+	  last_open_dir = g_strdup(cf_name);
+  }
+  else {
+	  last_open_dir = NULL;
+  }
+  set_menu_sensitivity("/File/Save", FALSE);
+  set_menu_sensitivity("/File/Save As...", TRUE);
+  g_free(cf_name);
+}
+
+/* Close a file */
+void
+file_close_cmd_cb(GtkWidget *widget, gpointer data) {
+  close_cap_file(&cf, info_bar, file_ctx);
+}
+
+void
+file_save_cmd_cb(GtkWidget *w, gpointer data) {
+  file_sel = gtk_file_selection_new ("Ethereal: Save Capture File");
+ 
+  /* Connect the ok_button to file_save_ok_cb function and pass along a
+     pointer to the file selection box widget */
+  gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (file_sel)->ok_button),
+    "clicked", (GtkSignalFunc) file_save_ok_cb, file_sel );
+
+  /* Connect the cancel_button to destroy the widget */
+  gtk_signal_connect_object(GTK_OBJECT (GTK_FILE_SELECTION
+    (file_sel)->cancel_button), "clicked", (GtkSignalFunc)
+    gtk_widget_destroy, GTK_OBJECT (file_sel));
+
+  gtk_file_selection_set_filename(GTK_FILE_SELECTION(file_sel), "");
+
+  gtk_widget_show(file_sel);
+}
+
+void
+file_save_as_cmd_cb(GtkWidget *w, gpointer data) {
+  file_sel = gtk_file_selection_new ("Ethereal: Save Capture File As");
+
+  /* Connect the ok_button to file_save_as_ok_cb function and pass along a
+     pointer to the file selection box widget */
+  gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (file_sel)->ok_button),
+    "clicked", (GtkSignalFunc) file_save_as_ok_cb, file_sel );
+
+  /* Connect the cancel_button to destroy the widget */
+  gtk_signal_connect_object(GTK_OBJECT (GTK_FILE_SELECTION
+    (file_sel)->cancel_button), "clicked", (GtkSignalFunc)
+    gtk_widget_destroy, GTK_OBJECT (file_sel));
+
+  gtk_file_selection_set_filename(GTK_FILE_SELECTION(file_sel), "");
+  gtk_widget_show(file_sel);
+}
+
+static void
+file_save_ok_cb(GtkWidget *w, GtkFileSelection *fs) {
+	gchar	*cf_name;
+	int	err;
+
+	cf_name = g_strdup(gtk_file_selection_get_filename(GTK_FILE_SELECTION(fs)));
+	gtk_widget_hide(GTK_WIDGET (fs));
+	gtk_widget_destroy(GTK_WIDGET (fs));
+
+	if (!file_mv(cf.save_file, cf_name))
+		return;
+
+	g_free(cf.save_file);
+	cf.save_file = g_strdup(cf_name);
+	cf.user_saved = 1;
+        if ((err = open_cap_file(cf_name, &cf)) == 0) {
+		err = read_cap_file(&cf);
+		set_menu_sensitivity("/File/Save", FALSE);
+		set_menu_sensitivity("/File/Save As...", TRUE);
+	}
+}
+
+static void
+file_save_as_ok_cb(GtkWidget *w, GtkFileSelection *fs) {
+	gchar	*cf_name;
+	int	err;
+
+	cf_name = g_strdup(gtk_file_selection_get_filename(GTK_FILE_SELECTION(fs)));
+	gtk_widget_hide(GTK_WIDGET (fs));
+	gtk_widget_destroy(GTK_WIDGET (fs));
+	if (!file_cp(cf.filename, cf_name))
+		return;
+	g_free(cf.filename);
+	cf.filename = g_strdup(cf_name);
+	cf.user_saved = 1;
+        if ((err = open_cap_file(cf.filename, &cf)) == 0) {
+		err = read_cap_file(&cf);
+		set_menu_sensitivity("/File/Save", FALSE);
+		set_menu_sensitivity("/File/Save As...", TRUE);
+	}
+}
+
+/* Reload a file using the current read and display filters */
+void
+file_reload_cmd_cb(GtkWidget *w, gpointer data) {
+  /*GtkWidget *filter_te = gtk_object_get_data(GTK_OBJECT(w), E_DFILTER_TE_KEY);*/
+  GtkWidget *filter_te;
+
+  filter_te = gtk_object_get_data(GTK_OBJECT(w), E_DFILTER_TE_KEY);
+
+  if (cf.dfilter) g_free(cf.dfilter);
+  cf.dfilter = g_strdup(gtk_entry_get_text(GTK_ENTRY(filter_te)));
+  if (open_cap_file(cf.filename, &cf) == 0)
+    read_cap_file(&cf);
+  /* XXX - change the menu if the open fails? */
+}
+
diff --git a/gtk/keys.h b/gtk/keys.h
new file mode 100644
index 0000000000..fc3bb32c2f
--- /dev/null
+++ b/gtk/keys.h
@@ -0,0 +1,16 @@
+#ifndef __KEYS_H__
+#define __KEYS_H__
+
+/* Keys for gtk_object_set_data */
+
+#define E_DFILTER_TE_KEY "display_filter_te"
+#define E_RFILTER_TE_KEY "read_filter_te"
+
+#define PRINT_CMD_LB_KEY  "printer_command_label"
+#define PRINT_CMD_TE_KEY  "printer_command_entry"
+#define PRINT_FILE_BT_KEY "printer_file_button"
+#define PRINT_FILE_TE_KEY "printer_file_entry"
+#define PRINT_DEST_RB_KEY "printer_destination_radio_button"
+
+
+#endif
diff --git a/gtk/menu.c b/gtk/menu.c
new file mode 100644
index 0000000000..97a37883d1
--- /dev/null
+++ b/gtk/menu.c
@@ -0,0 +1,172 @@
+/* menu.c
+ * Menu routines
+ *
+ * $Id: menu.c,v 1.1 1999/09/01 03:04:23 gram Exp $
+ *
+ * Ethereal - Network traffic analyzer
+ * By Gerald Combs <gerald@zing.org>
+ * Copyright 1998 Gerald Combs
+ *
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <gtk/gtk.h>
+
+#include <string.h>
+#include <stdio.h>
+
+#ifdef HAVE_SYS_TYPES_H
+# include <sys/types.h>
+#endif
+
+#include "ethereal.h"
+#include "menu.h"
+#include "packet.h"
+#include "capture.h"
+#include "summary.h"
+#include "display.h"
+#include "prefs.h"
+#include "print.h"
+#include "follow.h"
+#include "colors.h"
+
+
+GtkAccelGroup *grp;
+/* This is the GtkItemFactoryEntry structure used to generate new menus.
+       Item 1: The menu path. The letter after the underscore indicates an
+               accelerator key once the menu is open.
+       Item 2: The accelerator key for the entry
+       Item 3: The callback function.
+       Item 4: The callback action.  This changes the parameters with
+               which the function is called.  The default is 0.
+       Item 5: The item type, used to define what kind of an item it is.
+               Here are the possible values:
+
+               NULL               -> "<Item>"
+               ""                 -> "<Item>"
+               "<Title>"          -> create a title item
+               "<Item>"           -> create a simple item
+               "<CheckItem>"      -> create a check item
+               "<ToggleItem>"     -> create a toggle item
+               "<RadioItem>"      -> create a radio item
+               <path>             -> path of a radio item to link against
+               "<Separator>"      -> create a separator
+               "<Branch>"         -> create an item to hold sub items (optional)
+               "<LastBranch>"     -> create a right justified branch 
+    */
+
+static GtkItemFactoryEntry menu_items[] =
+{
+  {"/_File", NULL, NULL, 0, "<Branch>" },
+  {"/File/_Open...", "<control>O", GTK_MENU_FUNC(file_open_cmd_cb), 0, NULL},
+  {"/File/_Close", "<control>W", GTK_MENU_FUNC(file_close_cmd_cb), 0, NULL},
+  {"/File/_Save", "<control>S", GTK_MENU_FUNC(file_save_cmd_cb), 0, NULL},
+  {"/File/Save _As...", NULL, GTK_MENU_FUNC(file_save_as_cmd_cb), 0, NULL},
+  {"/File/_Reload", "<control>R", GTK_MENU_FUNC(file_reload_cmd_cb), 0, NULL},
+  {"/File/<separator>", NULL, NULL, 0, "<Separator>"},
+  {"/File/Print...", NULL, GTK_MENU_FUNC(file_print_cmd_cb), 0, NULL},
+  {"/File/Print Pac_ket", "<control>P", GTK_MENU_FUNC(file_print_packet_cmd_cb), 0, NULL},
+  {"/File/<separator>", NULL, NULL, 0, "<Separator>"},
+  {"/File/_Quit", "<control>Q", GTK_MENU_FUNC(file_quit_cmd_cb), 0, NULL},
+  {"/_Edit", NULL, NULL, 0, "<Branch>" },
+  {"/Edit/Cut", "<control>X", NULL, 0, NULL},
+  {"/Edit/Copy", "<control>C", NULL, 0, NULL},
+  {"/Edit/Paste", "<control>V", NULL, 0, NULL},
+  {"/Edit/<separator>", NULL, NULL, 0, "<Separator>"},
+  {"/Edit/Find", "<control>F", NULL, 0, NULL},
+  {"/Edit/<separator>", NULL, NULL, 0, "<Separator>"},
+  {"/Edit/_Preferences...", NULL, GTK_MENU_FUNC(prefs_cb), E_PR_PG_NONE, NULL},
+#ifdef HAVE_LIBPCAP
+  {"/_Capture", NULL, NULL, 0, "<Branch>" },
+  {"/Capture/_Start...", "<control>K", GTK_MENU_FUNC(capture_prep_cb), 0, NULL},
+#endif
+  {"/_Display", NULL, NULL, 0, "<Branch>" },
+  {"/Display/_Options...", NULL, GTK_MENU_FUNC(display_opt_cb), 0, NULL},
+  {"/Display/_Match Selected", NULL, GTK_MENU_FUNC(match_selected_cb), 0, NULL},
+  {"/Display/_Colorize Display...", NULL, GTK_MENU_FUNC(color_display_cb), 0, NULL},
+  {"/_Tools", NULL, NULL, 0, "<Branch>" },
+  {"/Tools/_Follow TCP Stream", NULL, GTK_MENU_FUNC(follow_stream_cb), 0, NULL},
+/*  {"/Tools/Graph", NULL, NULL, 0, NULL}, future use */
+  {"/Tools/_Summary", NULL, GTK_MENU_FUNC(summary_prep_cb), 0, NULL},
+  {"/_Help", NULL, NULL, 0, "<LastBranch>" },
+  {"/Help/_About Ethereal...", NULL, GTK_MENU_FUNC(about_ethereal), 0, NULL}
+};
+
+/* calculate the number of menu_items */
+static int nmenu_items = sizeof(menu_items) / sizeof(menu_items[0]);
+
+static int initialize = TRUE;
+static GtkItemFactory *factory = NULL;
+
+void
+get_main_menu(GtkWidget ** menubar, GtkAccelGroup ** table) {
+
+  grp = gtk_accel_group_new();
+
+  if (initialize)
+    menus_init();
+
+  if (menubar)
+    *menubar = factory->widget;
+
+  if (table)
+    *table = grp;
+}
+
+void
+menus_init(void) {
+
+  if (initialize) {
+    initialize = FALSE;
+
+    factory = gtk_item_factory_new(GTK_TYPE_MENU_BAR, "<main>", grp);
+    gtk_item_factory_create_items_ac(factory, nmenu_items, menu_items, NULL,2);
+    set_menu_sensitivity("/File/Close", FALSE);
+    set_menu_sensitivity("/File/Save", FALSE);
+    set_menu_sensitivity("/File/Save As...", FALSE);
+    set_menu_sensitivity("/File/Reload", FALSE);
+    set_menu_sensitivity("/File/Print...", FALSE);
+    set_menu_sensitivity("/File/Print Packet", FALSE);
+    set_menu_sensitivity("/Edit/Cut", FALSE);
+    set_menu_sensitivity("/Edit/Copy", FALSE);
+    set_menu_sensitivity("/Edit/Paste", FALSE);
+    set_menu_sensitivity("/Edit/Find", FALSE);
+    set_menu_sensitivity("/Tools/Graph", FALSE);
+    set_menu_sensitivity("/Tools/Summary", FALSE);
+  }
+}
+
+void
+set_menu_sensitivity (gchar *path, gint val) {
+  GtkWidget *menu;
+
+  if ((menu = gtk_item_factory_get_widget(factory, path)) != NULL)
+    gtk_widget_set_sensitive(menu, val);
+}
+
+void
+set_menu_object_data (gchar *path, gchar *key, gpointer data) {
+  GtkWidget *menu;
+  
+  if ((menu = gtk_item_factory_get_widget(factory, path)) != NULL)
+    gtk_object_set_data(GTK_OBJECT(menu), key, data);
+}
+
+
diff --git a/gtk/menu.h b/gtk/menu.h
new file mode 100644
index 0000000000..f3559fa723
--- /dev/null
+++ b/gtk/menu.h
@@ -0,0 +1,47 @@
+/* menu.h
+ * Menu definitions
+ *
+ * $Id: menu.h,v 1.1 1999/09/01 03:04:23 gram Exp $
+ *
+ * Ethereal - Network traffic analyzer
+ * By Gerald Combs <gerald@zing.org>
+ * Copyright 1998 Gerald Combs
+ *
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ */
+
+#ifndef __MENU_H__
+#define __MENU_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#define GTK_MENU_FUNC(a) ((GtkItemFactoryCallback)(a))
+
+void menus_init(void);
+
+void get_main_menu (GtkWidget **, GtkAccelGroup **);
+void set_menu_sensitivity (gchar *, gint);
+void set_menu_object_data (gchar *path, gchar *key, gpointer data);
+void menus_create (GtkMenuEntry *, int);
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __MENU_H__ */
diff --git a/gtk/print_dlg.c b/gtk/print_dlg.c
new file mode 100644
index 0000000000..5a7fcf5c0d
--- /dev/null
+++ b/gtk/print_dlg.c
@@ -0,0 +1,347 @@
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <errno.h>
+
+#ifndef __GLOBALS_H__
+#include "globals.h"
+#endif
+
+#ifndef __KEYS_H__
+#include "keys.h"
+#endif
+
+#ifndef __PRINT_H__
+#include "print.h"
+#endif
+
+#ifndef __PREFS_H__
+#include "prefs.h"
+#endif
+
+#ifndef __UTIL_H__
+#include "util.h"
+#endif
+
+static void print_cmd_toggle_dest(GtkWidget *widget, gpointer data);
+static void print_file_cb(GtkWidget *file_bt, gpointer file_te);
+static void print_fs_ok_cb(GtkWidget *w, gpointer data);
+static void print_fs_cancel_cb(GtkWidget *w, gpointer data);
+static void print_ok_cb(GtkWidget *ok_bt, gpointer parent_w);
+static void print_close_cb(GtkWidget *close_bt, gpointer parent_w);
+
+/*
+ * Remember whether we printed to a printer or a file the last time we
+ * printed something.
+ */
+static int     print_to_file;
+
+/* Print the capture */
+void
+file_print_cmd_cb(GtkWidget *widget, gpointer data)
+{
+  GtkWidget     *print_w;
+  GtkWidget     *main_vb, *main_tb, *button;
+#if 0
+  GtkWidget     *format_hb, *format_lb;
+  GSList        *format_grp;
+#endif
+  GtkWidget     *dest_rb;
+  GtkWidget     *dest_hb, *dest_lb;
+  GtkWidget     *cmd_lb, *cmd_te;
+  GtkWidget     *file_bt_hb, *file_bt, *file_te;
+  GSList        *dest_grp;
+  GtkWidget     *bbox, *ok_bt, *cancel_bt;
+
+  /* XXX - don't pop up one if there's already one open; instead,
+       give it the input focus if that's possible. */
+
+  print_w = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+  gtk_window_set_title(GTK_WINDOW(print_w), "Ethereal: Print");
+
+  /* Enclosing containers for each row of widgets */
+  main_vb = gtk_vbox_new(FALSE, 5);
+  gtk_container_border_width(GTK_CONTAINER(main_vb), 5);
+  gtk_container_add(GTK_CONTAINER(print_w), main_vb);
+  gtk_widget_show(main_vb);
+  
+  main_tb = gtk_table_new(4, 2, FALSE);
+  gtk_box_pack_start(GTK_BOX(main_vb), main_tb, FALSE, FALSE, 0);
+  gtk_table_set_row_spacings(GTK_TABLE(main_tb), 10);
+  gtk_table_set_col_spacings(GTK_TABLE(main_tb), 15);
+  gtk_widget_show(main_tb);
+
+  /* XXX - printing multiple frames in PostScript looks as if it's
+     tricky - you have to deal with page boundaries, I think -
+     and I'll have to spend some time learning enough about
+     PostScript to figure it out, so, for now, we only print
+     multiple frames as text. */
+#if 0
+  /* Output format */
+  format_lb = gtk_label_new("Format:");
+  gtk_misc_set_alignment(GTK_MISC(format_lb), 1.0, 0.5);
+  gtk_table_attach_defaults(GTK_TABLE(main_tb), format_lb, 0, 1, 0, 1);
+  gtk_widget_show(format_lb);
+
+  format_hb = gtk_hbox_new(FALSE, 0);
+  gtk_table_attach_defaults(GTK_TABLE(main_tb), format_hb, 1, 2, 0, 1);
+  gtk_widget_show(format_hb);
+
+  button = gtk_radio_button_new_with_label(NULL, "Plain Text");
+  if (prefs.pr_format == PR_FMT_TEXT)
+    gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(button), TRUE);
+  format_grp = gtk_radio_button_group(GTK_RADIO_BUTTON(button));
+  gtk_box_pack_start(GTK_BOX(format_hb), button, FALSE, FALSE, 10);
+  gtk_widget_show(button);
+
+  button = gtk_radio_button_new_with_label(format_grp, "PostScript");
+  if (prefs.pr_format == PR_FMT_PS)
+    gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(button), TRUE);
+  gtk_box_pack_start(GTK_BOX(format_hb), button, FALSE, FALSE, 10);
+  gtk_widget_show(button);
+#endif
+
+  /* Output destination */
+  dest_lb = gtk_label_new("Print to:");
+  gtk_misc_set_alignment(GTK_MISC(dest_lb), 1.0, 0.5);
+  gtk_table_attach_defaults(GTK_TABLE(main_tb), dest_lb, 0, 1, 1, 2);
+  gtk_widget_show(dest_lb);
+
+  dest_hb = gtk_hbox_new(FALSE, 0);
+  gtk_table_attach_defaults(GTK_TABLE(main_tb), dest_hb, 1, 2, 1, 2);
+  gtk_widget_show(dest_hb);
+
+  button = gtk_radio_button_new_with_label(NULL, "Command");
+  if (!print_to_file)
+    gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(button), TRUE);
+  dest_grp = gtk_radio_button_group(GTK_RADIO_BUTTON(button));
+  gtk_box_pack_start(GTK_BOX(dest_hb), button, FALSE, FALSE, 10);
+  gtk_widget_show(button);
+
+  dest_rb = gtk_radio_button_new_with_label(dest_grp, "File");
+  if (print_to_file)
+    gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(dest_rb), TRUE);
+  gtk_signal_connect(GTK_OBJECT(dest_rb), "toggled",
+			GTK_SIGNAL_FUNC(print_cmd_toggle_dest), NULL);
+  gtk_box_pack_start(GTK_BOX(dest_hb), dest_rb, FALSE, FALSE, 10);
+  gtk_widget_show(dest_rb);
+
+  /* Command text entry */
+  cmd_lb = gtk_label_new("Command:");
+  gtk_object_set_data(GTK_OBJECT(dest_rb), PRINT_CMD_LB_KEY, cmd_lb);
+  gtk_misc_set_alignment(GTK_MISC(cmd_lb), 1.0, 0.5);
+  gtk_table_attach_defaults(GTK_TABLE(main_tb), cmd_lb, 0, 1, 2, 3);
+  gtk_widget_set_sensitive(cmd_lb, !print_to_file);
+  gtk_widget_show(cmd_lb);
+
+  cmd_te = gtk_entry_new();
+  gtk_object_set_data(GTK_OBJECT(dest_rb), PRINT_CMD_TE_KEY, cmd_te);
+  if (prefs.pr_cmd)
+    gtk_entry_set_text(GTK_ENTRY(cmd_te), prefs.pr_cmd);
+  gtk_table_attach_defaults(GTK_TABLE(main_tb), cmd_te, 1, 2, 2, 3);
+  gtk_widget_set_sensitive(cmd_te, !print_to_file);
+  gtk_widget_show(cmd_te);
+
+  /* File button and text entry */
+  file_bt_hb = gtk_hbox_new(FALSE, 0);
+  gtk_table_attach_defaults(GTK_TABLE(main_tb), file_bt_hb, 0, 1, 3, 4);
+  gtk_widget_show(file_bt_hb);
+
+  file_bt = gtk_button_new_with_label("File:");
+  gtk_object_set_data(GTK_OBJECT(dest_rb), PRINT_FILE_BT_KEY, file_bt);
+  gtk_box_pack_end(GTK_BOX(file_bt_hb), file_bt, FALSE, FALSE, 0);
+  gtk_widget_set_sensitive(file_bt, print_to_file);
+  gtk_widget_show(file_bt);
+
+  file_te = gtk_entry_new();
+  gtk_object_set_data(GTK_OBJECT(dest_rb), PRINT_FILE_TE_KEY, file_te);
+  gtk_table_attach_defaults(GTK_TABLE(main_tb), file_te, 1, 2, 3, 4);
+  gtk_widget_set_sensitive(file_te, print_to_file);
+  gtk_widget_show(file_te);
+
+  gtk_signal_connect(GTK_OBJECT(file_bt), "clicked",
+		GTK_SIGNAL_FUNC(print_file_cb), GTK_OBJECT(file_te));
+
+  /* Button row: OK and Cancel buttons */
+  bbox = gtk_hbutton_box_new();
+  gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_END);
+  gtk_button_box_set_spacing(GTK_BUTTON_BOX(bbox), 5);
+  gtk_container_add(GTK_CONTAINER(main_vb), bbox);
+  gtk_widget_show(bbox);
+
+  ok_bt = gtk_button_new_with_label ("OK");
+  gtk_object_set_data(GTK_OBJECT(ok_bt), PRINT_DEST_RB_KEY, dest_rb);
+  gtk_object_set_data(GTK_OBJECT(ok_bt), PRINT_CMD_TE_KEY, cmd_te);
+  gtk_object_set_data(GTK_OBJECT(ok_bt), PRINT_FILE_TE_KEY, file_te);
+  gtk_signal_connect(GTK_OBJECT(ok_bt), "clicked",
+    GTK_SIGNAL_FUNC(print_ok_cb), GTK_OBJECT(print_w));
+  GTK_WIDGET_SET_FLAGS(ok_bt, GTK_CAN_DEFAULT);
+  gtk_box_pack_start (GTK_BOX (bbox), ok_bt, TRUE, TRUE, 0);
+  gtk_widget_grab_default(ok_bt);
+  gtk_widget_show(ok_bt);
+
+  cancel_bt = gtk_button_new_with_label ("Cancel");
+  gtk_signal_connect(GTK_OBJECT(cancel_bt), "clicked",
+    GTK_SIGNAL_FUNC(print_close_cb), GTK_OBJECT(print_w));
+  GTK_WIDGET_SET_FLAGS(cancel_bt, GTK_CAN_DEFAULT);
+  gtk_box_pack_start (GTK_BOX (bbox), cancel_bt, TRUE, TRUE, 0);
+  gtk_widget_show(cancel_bt);
+
+#if 0
+  display_opt_window_active = TRUE;
+#endif
+  gtk_widget_show(print_w);
+}
+
+static void
+print_cmd_toggle_dest(GtkWidget *widget, gpointer data)
+{
+  GtkWidget     *cmd_lb, *cmd_te, *file_bt, *file_te;
+  int            to_file;
+
+  cmd_lb = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(widget),
+    PRINT_CMD_LB_KEY));
+  cmd_te = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(widget),
+    PRINT_CMD_TE_KEY));
+  file_bt = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(widget),
+    PRINT_FILE_BT_KEY));
+  file_te = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(widget),
+    PRINT_FILE_TE_KEY));
+  if (GTK_TOGGLE_BUTTON (widget)->active) {
+    /* They selected "Print to File" */
+    to_file = TRUE;
+  } else {
+    /* They selected "Print to Command" */
+    to_file = FALSE;
+  }
+  gtk_widget_set_sensitive(cmd_lb, !to_file);
+  gtk_widget_set_sensitive(cmd_te, !to_file);
+  gtk_widget_set_sensitive(file_bt, to_file);
+  gtk_widget_set_sensitive(file_te, to_file);
+}
+
+static void
+print_file_cb(GtkWidget *file_bt, gpointer file_te)
+{
+  GtkWidget *fs;
+
+  fs = gtk_file_selection_new ("Ethereal: Print to File");
+	gtk_object_set_data(GTK_OBJECT(fs), PRINT_FILE_TE_KEY, file_te);
+
+  gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION(fs)->ok_button),
+    "clicked", (GtkSignalFunc) print_fs_ok_cb, fs);
+
+  /* Connect the cancel_button to destroy the widget */
+  gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION(fs)->cancel_button),
+    "clicked", (GtkSignalFunc) print_fs_cancel_cb, fs);
+
+  gtk_widget_show(fs);
+}
+
+static void
+print_fs_ok_cb(GtkWidget *w, gpointer data)
+{
+  
+  gtk_entry_set_text(GTK_ENTRY(gtk_object_get_data(GTK_OBJECT(data),
+      PRINT_FILE_TE_KEY)),
+      gtk_file_selection_get_filename (GTK_FILE_SELECTION(data)));
+  gtk_widget_destroy(GTK_WIDGET(data));
+}
+
+static void
+print_fs_cancel_cb(GtkWidget *w, gpointer data)
+{
+  gtk_widget_destroy(GTK_WIDGET(data));
+}
+
+static void
+print_ok_cb(GtkWidget *ok_bt, gpointer parent_w)
+{
+  GtkWidget *button;
+  char *dest;
+
+  button = (GtkWidget *) gtk_object_get_data(GTK_OBJECT(ok_bt),
+                                              PRINT_DEST_RB_KEY);
+  if (GTK_TOGGLE_BUTTON (button)->active)
+    print_to_file = TRUE;
+  else
+    print_to_file = FALSE;
+
+  if (print_to_file)
+    dest = g_strdup(gtk_entry_get_text(GTK_ENTRY(gtk_object_get_data(GTK_OBJECT(ok_bt),
+      PRINT_FILE_TE_KEY))));
+  else
+    dest = g_strdup(gtk_entry_get_text(GTK_ENTRY(gtk_object_get_data(GTK_OBJECT(ok_bt),
+      PRINT_CMD_TE_KEY))));
+
+  gtk_widget_destroy(GTK_WIDGET(parent_w));
+#if 0
+  display_opt_window_active = FALSE;
+#endif
+
+  /* Now print the packets */
+  if (!print_packets(&cf, print_to_file, dest)) {
+    if (print_to_file)
+      simple_dialog(ESD_TYPE_WARN, NULL,
+        file_write_error_message(errno), dest);
+    else
+      simple_dialog(ESD_TYPE_WARN, NULL, "Couldn't run print command %s.",
+        prefs.pr_cmd);
+  }
+
+  g_free(dest);
+}
+
+static void
+print_close_cb(GtkWidget *close_bt, gpointer parent_w)
+{
+
+  gtk_grab_remove(GTK_WIDGET(parent_w));
+  gtk_widget_destroy(GTK_WIDGET(parent_w));
+#if 0
+  display_opt_window_active = FALSE;
+#endif
+}
+
+/* Print a packet */
+void
+file_print_packet_cmd_cb(GtkWidget *widget, gpointer data) {
+  FILE *fh;
+
+  switch (prefs.pr_dest) {
+
+  case PR_DEST_CMD:
+    fh = popen(prefs.pr_cmd, "w");
+    break;
+
+  case PR_DEST_FILE:
+    fh = fopen(prefs.pr_file, "w");
+    break;
+
+  default:
+    fh = NULL;	/* XXX - "can't happen" */
+    break;
+  }
+  if (fh == NULL) {
+    switch (prefs.pr_dest) {
+
+    case PR_DEST_CMD:
+      simple_dialog(ESD_TYPE_WARN, NULL, "Couldn't run print command %s.",
+        prefs.pr_cmd);
+      break;
+
+    case PR_DEST_FILE:
+      simple_dialog(ESD_TYPE_WARN, NULL, file_write_error_message(errno),
+        prefs.pr_file);
+      break;
+    }
+    return;
+  }
+
+  print_preamble(fh);
+  proto_tree_print(-1, (GNode*) cf.protocol_tree, cf.pd, cf.fd, fh);
+  print_finale(fh);
+  close_print_dest(prefs.pr_dest == PR_DEST_FILE, fh);
+}
+
diff --git a/gtk/print_prefs.c b/gtk/print_prefs.c
new file mode 100644
index 0000000000..3cbbd6fff1
--- /dev/null
+++ b/gtk/print_prefs.c
@@ -0,0 +1,223 @@
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <errno.h>
+
+#ifndef __GLOBALS_H__
+#include "globals.h"
+#endif
+
+#ifndef __KEYS_H__
+#include "keys.h"
+#endif
+
+#ifndef __PRINT_H__
+#include "print.h"
+#endif
+
+#ifndef __PREFS_H__
+#include "prefs.h"
+#endif
+
+#ifndef __UTIL_H__
+#include "util.h"
+#endif
+
+static void printer_opts_file_cb(GtkWidget *w, gpointer te);
+static void printer_opts_fs_cancel_cb(GtkWidget *w, gpointer data);
+static void printer_opts_fs_ok_cb(GtkWidget *w, gpointer data);
+static void printer_opts_toggle_format(GtkWidget *widget, gpointer data);
+static void printer_opts_toggle_dest(GtkWidget *widget, gpointer data);
+
+
+GtkWidget * printer_prefs_show()
+{
+	GtkWidget	*main_vb, *main_tb, *button;
+	GtkWidget	*format_hb, *format_lb;
+	GtkWidget	*dest_hb, *dest_lb;
+	GtkWidget	*cmd_lb, *cmd_te;
+	GtkWidget	*file_bt_hb, *file_bt, *file_te;
+	GSList		*format_grp, *dest_grp;
+
+	/* Enclosing containers for each row of widgets */
+  main_vb = gtk_vbox_new(FALSE, 5);
+  gtk_container_border_width(GTK_CONTAINER(main_vb), 5);
+
+	main_tb = gtk_table_new(4, 2, FALSE);
+	gtk_box_pack_start(GTK_BOX(main_vb), main_tb, FALSE, FALSE, 0);
+  gtk_table_set_row_spacings(GTK_TABLE(main_tb), 10);
+  gtk_table_set_col_spacings(GTK_TABLE(main_tb), 15);
+  gtk_widget_show(main_tb);
+
+	/* Output format */
+	format_lb = gtk_label_new("Format:");
+  gtk_misc_set_alignment(GTK_MISC(format_lb), 1.0, 0.5);
+  gtk_table_attach_defaults(GTK_TABLE(main_tb), format_lb, 0, 1, 0, 1);
+	gtk_widget_show(format_lb);
+
+	format_hb = gtk_hbox_new(FALSE, 0);
+  gtk_table_attach_defaults(GTK_TABLE(main_tb), format_hb, 1, 2, 0, 1);
+	gtk_widget_show(format_hb);
+
+	button = gtk_radio_button_new_with_label(NULL, "Plain Text");
+	if (prefs.pr_format == PR_FMT_TEXT) {
+		gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(button), TRUE);
+	}
+	format_grp = gtk_radio_button_group(GTK_RADIO_BUTTON(button));
+	gtk_box_pack_start(GTK_BOX(format_hb), button, FALSE, FALSE, 10);
+	gtk_widget_show(button);
+
+	button = gtk_radio_button_new_with_label(format_grp, "PostScript");
+	if (prefs.pr_format == PR_FMT_PS) {
+		gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(button), TRUE);
+	}
+	gtk_signal_connect(GTK_OBJECT(button), "toggled",
+			GTK_SIGNAL_FUNC(printer_opts_toggle_format), NULL);
+	gtk_box_pack_start(GTK_BOX(format_hb), button, FALSE, FALSE, 10);
+	gtk_widget_show(button);
+
+	/* Output destination */
+	dest_lb = gtk_label_new("Print to:");
+  gtk_misc_set_alignment(GTK_MISC(dest_lb), 1.0, 0.5);
+  gtk_table_attach_defaults(GTK_TABLE(main_tb), dest_lb, 0, 1, 1, 2);
+	gtk_widget_show(dest_lb);
+
+	dest_hb = gtk_hbox_new(FALSE, 0);
+  gtk_table_attach_defaults(GTK_TABLE(main_tb), dest_hb, 1, 2, 1, 2);
+	gtk_widget_show(dest_hb);
+
+	button = gtk_radio_button_new_with_label(NULL, "Command");
+	if (prefs.pr_dest == PR_DEST_CMD) {
+		gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(button), TRUE);
+	}
+	dest_grp = gtk_radio_button_group(GTK_RADIO_BUTTON(button));
+	gtk_box_pack_start(GTK_BOX(dest_hb), button, FALSE, FALSE, 10);
+	gtk_widget_show(button);
+
+	button = gtk_radio_button_new_with_label(dest_grp, "File");
+	if (prefs.pr_dest == PR_DEST_FILE) {
+		gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(button), TRUE);
+	}
+	gtk_signal_connect(GTK_OBJECT(button), "toggled",
+			GTK_SIGNAL_FUNC(printer_opts_toggle_dest), NULL);
+	gtk_box_pack_start(GTK_BOX(dest_hb), button, FALSE, FALSE, 10);
+	gtk_widget_show(button);
+
+	/* Command text entry */
+	cmd_lb = gtk_label_new("Command:");
+  gtk_misc_set_alignment(GTK_MISC(cmd_lb), 1.0, 0.5);
+  gtk_table_attach_defaults(GTK_TABLE(main_tb), cmd_lb, 0, 1, 2, 3);
+	gtk_widget_show(cmd_lb);
+
+	cmd_te = gtk_entry_new();
+	gtk_object_set_data(GTK_OBJECT(main_vb), PRINT_CMD_TE_KEY, cmd_te);
+	if (prefs.pr_cmd) gtk_entry_set_text(GTK_ENTRY(cmd_te), prefs.pr_cmd);
+  gtk_table_attach_defaults(GTK_TABLE(main_tb), cmd_te, 1, 2, 2, 3);
+	gtk_widget_show(cmd_te);
+
+	/* File button and text entry */
+	file_bt_hb = gtk_hbox_new(FALSE, 0);
+  gtk_table_attach_defaults(GTK_TABLE(main_tb), file_bt_hb, 0, 1, 3, 4);
+	gtk_widget_show(file_bt_hb);
+
+	file_bt = gtk_button_new_with_label("File:");
+	gtk_box_pack_end(GTK_BOX(file_bt_hb), file_bt, FALSE, FALSE, 0);
+	gtk_widget_show(file_bt);
+
+	file_te = gtk_entry_new();
+	gtk_object_set_data(GTK_OBJECT(main_vb), PRINT_FILE_TE_KEY, file_te);
+	if (prefs.pr_file) gtk_entry_set_text(GTK_ENTRY(file_te), prefs.pr_file);
+  gtk_table_attach_defaults(GTK_TABLE(main_tb), file_te, 1, 2, 3, 4);
+	gtk_widget_show(file_te);
+
+	gtk_signal_connect(GTK_OBJECT(file_bt), "clicked",
+			GTK_SIGNAL_FUNC(printer_opts_file_cb), GTK_OBJECT(file_te));
+
+	gtk_widget_show(main_vb);
+	return(main_vb);
+}
+
+
+static void
+printer_opts_file_cb(GtkWidget *file_bt, gpointer file_te) {
+  GtkWidget *fs;
+
+  fs = gtk_file_selection_new ("Ethereal: Print to a File");
+	gtk_object_set_data(GTK_OBJECT(fs), PRINT_FILE_TE_KEY, file_te);
+
+  gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION(fs)->ok_button),
+    "clicked", (GtkSignalFunc) printer_opts_fs_ok_cb, fs);
+
+  /* Connect the cancel_button to destroy the widget */
+  gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION(fs)->cancel_button),
+    "clicked", (GtkSignalFunc) printer_opts_fs_cancel_cb, fs);
+
+  gtk_widget_show(fs);
+}
+
+static void
+printer_opts_fs_ok_cb(GtkWidget *w, gpointer data) {
+	  
+	gtk_entry_set_text(GTK_ENTRY(gtk_object_get_data(GTK_OBJECT(data),
+  	PRINT_FILE_TE_KEY)),
+		gtk_file_selection_get_filename (GTK_FILE_SELECTION(data)));
+	printer_opts_fs_cancel_cb(w, data);
+}
+
+static void
+printer_opts_fs_cancel_cb(GtkWidget *w, gpointer data) {
+	  
+	gtk_widget_destroy(GTK_WIDGET(data));
+} 
+
+void
+printer_prefs_ok(GtkWidget *w)
+{
+	if(prefs.pr_cmd) g_free(prefs.pr_cmd);
+	prefs.pr_cmd =  
+		g_strdup(gtk_entry_get_text(GTK_ENTRY(gtk_object_get_data(GTK_OBJECT(w),
+    PRINT_CMD_TE_KEY))));
+
+	if(prefs.pr_file) g_free(prefs.pr_file);
+	prefs.pr_file =  
+		g_strdup(gtk_entry_get_text(GTK_ENTRY(gtk_object_get_data(GTK_OBJECT(w),
+    PRINT_FILE_TE_KEY))));
+}
+
+void
+printer_prefs_save(GtkWidget *w)
+{
+	printer_prefs_ok(w);
+}
+
+void
+printer_prefs_cancel(GtkWidget *w)
+{
+}
+
+static void
+printer_opts_toggle_format(GtkWidget *widget, gpointer data)
+{
+		if (GTK_TOGGLE_BUTTON (widget)->active) {
+			prefs.pr_format = PR_FMT_PS;
+			/* toggle file/cmd */
+		}
+		else {
+			prefs.pr_format = PR_FMT_TEXT;
+			/* toggle file/cmd */
+		}
+}
+
+static void
+printer_opts_toggle_dest(GtkWidget *widget, gpointer data)
+{
+		if (GTK_TOGGLE_BUTTON (widget)->active) {
+			prefs.pr_dest = PR_DEST_FILE;
+		}
+		else {
+			prefs.pr_dest = PR_DEST_CMD;
+		}
+}
+
diff --git a/gtk/print_prefs.h b/gtk/print_prefs.h
new file mode 100644
index 0000000000..5ce73c3ea3
--- /dev/null
+++ b/gtk/print_prefs.h
@@ -0,0 +1,5 @@
+
+GtkWidget *printer_prefs_show();
+void printer_prefs_ok(GtkWidget *w);
+void printer_prefs_save(GtkWidget *w);
+void printer_prefs_cancel(GtkWidget *w);