* Added preference file saves and reads.
authorgerald <gerald@f5534014-38df-0310-8fa8-9805f1628bb7>
Wed, 28 Oct 1998 21:38:11 +0000 (21:38 +0000)
committergerald <gerald@f5534014-38df-0310-8fa8-9805f1628bb7>
Wed, 28 Oct 1998 21:38:11 +0000 (21:38 +0000)
git-svn-id: http://anonsvn.wireshark.org/wireshark/trunk@75 f5534014-38df-0310-8fa8-9805f1628bb7

capture.c
ethereal.c
menu.c
prefs.c
prefs.h
print.c
print.h

index 08995ef0fbb0d6dcdfa8228a38aac657d63d3222..d5664962542c057163874322401ded6ed653bc65 100644 (file)
--- a/capture.c
+++ b/capture.c
@@ -1,7 +1,7 @@
 /* capture.c
  * Routines for packet capture windows
  *
- * $Id: capture.c,v 1.7 1998/10/13 07:03:31 guy Exp $
+ * $Id: capture.c,v 1.8 1998/10/28 21:38:06 gerald Exp $
  *
  * Ethereal - Network traffic analyzer
  * By Gerald Combs <gerald@zing.org>
@@ -281,7 +281,7 @@ capture_prep_cb(GtkWidget *w, gpointer d) {
   cancel_bt = gtk_button_new_with_label ("Cancel");
   gtk_signal_connect_object(GTK_OBJECT(cancel_bt), "clicked",
     GTK_SIGNAL_FUNC(capture_prep_close_cb), GTK_OBJECT(cap_open_w));
-  GTK_WIDGET_SET_FLAGS(ok_bt, GTK_CAN_DEFAULT);
+  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);
 
index faec036d2f71a0ae3f2fb2c80c796d8c891c6168..fe12d4755ba1be2adf4aac966adc7b27c4ef54dd 100644 (file)
@@ -1,6 +1,6 @@
 /* ethereal.c
  *
- * $Id: ethereal.c,v 1.8 1998/10/16 06:44:32 guy Exp $
+ * $Id: ethereal.c,v 1.9 1998/10/28 21:38:07 gerald Exp $
  *
  * Ethereal - Network traffic analyzer
  * By Gerald Combs <gerald@zing.org>
 #include "file.h"
 #include "menu.h"
 #include "etypes.h"
+#include "prefs.h"
 #include "print.h"
 #include "resolv.h"
 #include "follow.h"
 #include "util.h"
-#include "prefs.h"
 
 FILE        *data_out_file = NULL;
 packet_info  pi;
@@ -76,8 +76,6 @@ guint        main_ctx, file_ctx;
 frame_data  *fd;
 gint         start_capture = 0;
 
-extern pr_opts printer_opts;
-
 ts_type timestamp_type = RELATIVE;
 
 #define E_DFILTER_TE_KEY "display_filter_te"
@@ -387,6 +385,8 @@ main(int argc, char *argv[])
   cf.save_file = NULL;
   cf.snap      = 68;
   cf.count     = 0;
+
+  read_prefs();
     
   /* Let GTK get its args */
   gtk_init (&argc, &argv);
@@ -465,13 +465,6 @@ main(int argc, char *argv[])
   sprintf(rc_file, "%s/%s", getenv("HOME"), RC_FILE);
   gtk_rc_parse(rc_file);
 
-  /* initialize printer options. temporary! we should only initialize
-   * if the options are not set in some ethereal initialization file */
-  printer_opts.output_format = 0;
-  printer_opts.output_dest = 0;
-  printer_opts.file = g_strdup("ethereal.out");
-  printer_opts.cmd = g_strdup("lpr");
-
   if ((m_r_font = gdk_font_load(medium_font)) == NULL) {
     fprintf(stderr, "Error font %s not found (use -m option)\n", medium_font);
     exit(1);
diff --git a/menu.c b/menu.c
index 301aed76c415c0fae5f0a43c375bbafa79e30706..5735fe13213211f9540ffa381a118052254e9711 100644 (file)
--- a/menu.c
+++ b/menu.c
@@ -1,7 +1,7 @@
 /* menu.c
  * Menu routines
  *
- * $Id: menu.c,v 1.8 1998/10/16 01:18:29 gerald Exp $
+ * $Id: menu.c,v 1.9 1998/10/28 21:38:08 gerald Exp $
  *
  * Ethereal - Network traffic analyzer
  * By Gerald Combs <gerald@zing.org>
@@ -38,9 +38,9 @@
 #include "ethereal.h"
 #include "capture.h"
 #include "packet.h"
+#include "prefs.h"
 #include "print.h"
 #include "follow.h"
-#include "prefs.h"
 
 /* Much of this was take from the GTK+ tuturial at http://www.gtk.org */
 
diff --git a/prefs.c b/prefs.c
index 052a3b6fe6e3570ac522ce9ed1b988ef79a55418..92f3f06f601fe2c0345a1fb496974488a94bc00c 100644 (file)
--- a/prefs.c
+++ b/prefs.c
@@ -1,7 +1,7 @@
 /* prefs.c
  * Routines for handling preferences
  *
- * $Id: prefs.c,v 1.7 1998/10/16 01:18:33 gerald Exp $
+ * $Id: prefs.c,v 1.8 1998/10/28 21:38:09 gerald Exp $
  *
  * Ethereal - Network traffic analyzer
  * By Gerald Combs <gerald@zing.org>
 #include "ethereal.h"
 #include "packet.h"
 #include "file.h"
+#include "prefs.h"
 #include "print.h"
 #include "filter.h"
-#include "prefs.h"
+#include "util.h"
+
+/* Internal functions */
+static int  set_prefs(gchar*, gchar*);
+static void write_prefs();
+static void prefs_main_ok_cb(GtkWidget *, gpointer);
+static void prefs_main_save_cb(GtkWidget *, gpointer);
+static void prefs_main_cancel_cb(GtkWidget *, gpointer);
+
+e_prefs prefs;
+static int init_prefs = 1;
+
+#define PF_NAME ".ethereal/preferences"
 
-extern capture_file  cf;
+static gchar *pf_path = NULL;
 
 void
 prefs_cb(GtkWidget *w, gpointer sp) {
@@ -137,7 +150,9 @@ prefs_main_ok_cb(GtkWidget *w, gpointer win) {
 
 void
 prefs_main_save_cb(GtkWidget *w, gpointer win) {
+  printer_prefs_save(gtk_object_get_data(GTK_OBJECT(win), E_PRINT_PAGE_KEY));
   filter_prefs_save(gtk_object_get_data(GTK_OBJECT(win), E_FILTER_PAGE_KEY));
+  write_prefs();
 }
 
 void
@@ -148,3 +163,201 @@ prefs_main_cancel_cb(GtkWidget *w, gpointer win) {
   gtk_widget_destroy(GTK_WIDGET(win));
 }
 
+/* Preferences file format:
+ * - Configuration directives start at the beginning of the line, and 
+ *   are terminated with a colon.
+ * - Directives can be continued on the next line by preceding them with
+ *   whitespace.
+ *
+ * Example:
+
+# This is a comment line
+print.command: lpr
+print.file: /a/very/long/path/
+       to/ethereal-out.ps
+ *
+ */
+
+#define MAX_VAR_LEN  32
+#define MAX_VAL_LEN 256
+void
+read_prefs() {
+  enum { START, IN_VAR, PRE_VAL, IN_VAL, IN_SKIP };
+  FILE   *pf;
+  gchar   cur_var[MAX_VAR_LEN], cur_val[MAX_VAL_LEN];
+  int     got_c, state = START;
+  gint    var_len = 0, val_len = 0, fline = 1, pline = 1;
+  
+  /* Initialize preferences.  With any luck, these values will be
+     overwritten below. */
+  if (init_prefs) {
+    init_prefs      = 0;
+    prefs.pr_format = PR_FMT_TEXT;
+    prefs.pr_dest   = PR_DEST_CMD;
+    prefs.pr_file   = g_strdup("ethereal.out");
+    prefs.pr_cmd    = g_strdup("lpr");
+  }
+
+  if (! pf_path) {
+    pf_path = (gchar *) g_malloc(strlen(getenv("HOME")) + strlen(PF_NAME) + 4);
+    sprintf(pf_path, "%s/%s", getenv("HOME"), PF_NAME);
+  }
+    
+  if ((pf = fopen(pf_path, "r")) == NULL) {
+    simple_dialog(ESD_TYPE_WARN, NULL,
+      "Can't open preferences file\n\"%s\".");
+    return;
+  }
+    
+  while ((got_c = getc(pf)) != EOF) {
+    if (got_c == '\n') {
+      state = START;
+      fline++;
+      continue;
+    }
+    if (var_len >= MAX_VAR_LEN) {
+      g_warning ("%s line %d: Variable too long", pf_path, fline);
+      state = IN_SKIP;
+      var_len = 0;
+      continue;
+    }
+    if (val_len >= MAX_VAL_LEN) {
+      g_warning ("%s line %d: Value too long", pf_path, fline);
+      state = IN_SKIP;
+      var_len = 0;
+      continue;
+    }
+    
+    switch (state) {
+      case START:
+        if (isalnum(got_c)) {
+          state = IN_VAR;
+          if (var_len > 0) {
+            cur_var[var_len] = '\0';
+            cur_val[val_len] = '\0';
+            if (! set_pref(cur_var, cur_val))
+              g_warning ("%s line %d: Bogus preference", pf_path, pline);
+          }
+          cur_var[0] = got_c;
+          var_len = 1;
+          pline = fline;
+        } else if (isspace(got_c) && var_len > 0) {
+          state = PRE_VAL;
+        } else if (got_c == '#') {
+          state = IN_SKIP;
+        } else {
+          g_warning ("%s line %d: Malformed line", pf_path, fline);
+        }
+        break;
+      case IN_VAR:
+        if (got_c != ':') {
+          cur_var[var_len] = got_c;
+          var_len++;
+        } else {
+          state = PRE_VAL;
+          val_len = 0;
+        }
+        break;
+      case PRE_VAL:
+        if (!isspace(got_c)) {
+          state = IN_VAL;
+          cur_val[val_len] = got_c;
+          val_len++;
+        }
+        break;
+      case IN_VAL:
+        cur_val[val_len] = got_c;
+        val_len++;
+        break;
+    }
+  }
+  if (var_len > 0) {
+    cur_var[var_len] = '\0';
+    cur_val[val_len] = '\0';
+    if (! set_pref(cur_var, cur_val))
+      g_warning ("%s line %d: Bogus preference", pf_path, pline);
+  }
+  fclose(pf);
+}
+
+#define PRS_PRINT_FMT  "print.format"
+#define PRS_PRINT_DEST "print.destination"
+#define PRS_PRINT_FILE "print.file"
+#define PRS_PRINT_CMD  "print.command"
+
+static gchar *pr_formats[] = { "text", "postscript" };
+static gchar *pr_dests[]   = { "command", "file" };
+
+int
+set_pref(gchar *pref, gchar *value) {
+
+  if (strcmp(pref, PRS_PRINT_FMT) == 0) {
+    if (strcmp(value, pr_formats[PR_FMT_TEXT]) == 0) {
+      prefs.pr_format = PR_FMT_TEXT;
+    } else if (strcmp(value, pr_formats[PR_FMT_PS]) == 0) {
+      prefs.pr_format = PR_FMT_PS;
+    } else {
+      return 0;
+    }
+  } else if (strcmp(pref, PRS_PRINT_DEST) == 0) {
+    if (strcmp(value, pr_dests[PR_DEST_CMD]) == 0) {
+      prefs.pr_dest = PR_DEST_CMD;
+    } else if (strcmp(value, pr_dests[PR_DEST_FILE]) == 0) {
+      prefs.pr_dest = PR_DEST_FILE;
+    } else {
+      return 0;
+    }
+  } else if (strcmp(pref, PRS_PRINT_FILE) == 0) {
+    if (prefs.pr_file) g_free(prefs.pr_file);
+    prefs.pr_file = g_strdup(value);
+  } else if (strcmp(pref, PRS_PRINT_CMD) == 0) {
+    if (prefs.pr_cmd) g_free(prefs.pr_cmd);
+    prefs.pr_cmd = g_strdup(value);
+  } else {
+    return 0;
+  }
+  
+  return 1;
+}
+
+void
+write_prefs() {
+  FILE   *pf;
+  
+  /* To do: Split output lines longer than MAX_VAL_LEN */
+
+  if (! pf_path) {
+    pf_path = (gchar *) g_malloc(strlen(getenv("HOME")) + strlen(PF_NAME) + 4);
+    sprintf(pf_path, "%s/%s", getenv("HOME"), PF_NAME);
+  }
+    
+  if ((pf = fopen(pf_path, "w")) == NULL) {
+     simple_dialog(ESD_TYPE_WARN, NULL,
+      "Can't open preferences file\n\"%s\".");
+   return;
+ }
+    
+  fputs("# Configuration file for Ethereal " VERSION ".\n"
+    "#\n"
+    "# This file is regenerated each time preferences are saved within\n"
+    "# Ethereal.  Making manual changes should be safe, however.\n"
+    "\n"
+    "######## Printing ########\n"
+    "\n", pf);
+
+  fprintf (pf, "# Can be one of \"text\" or \"postscript\".\n"
+    "print.format: %s\n\n", pr_formats[prefs.pr_format]);
+
+  fprintf (pf, "# Can be one of \"command\" or \"file\".\n"
+    "print.destination: %s\n\n", pr_dests[prefs.pr_dest]);
+
+  fprintf (pf, "# This is the file that gets written to when the "
+    "destination is set to \"file\"\n"
+    "%s: %s\n\n", PRS_PRINT_FILE, prefs.pr_file);
+
+  fprintf (pf, "# Output gets piped to this command when the destination "
+    "is set to \"command\"\n"
+    "%s: %s\n", PRS_PRINT_CMD, prefs.pr_cmd);
+
+  fclose(pf);
+}
diff --git a/prefs.h b/prefs.h
index bea70b73256a15f285449c67c226a5156d9b9b48..fe1036358392aaea77db6fdf73fa508df379487a 100644 (file)
--- a/prefs.h
+++ b/prefs.h
@@ -1,7 +1,7 @@
 /* prefs.h
  * Definitions for preference handling routines
  *
- * $Id: prefs.h,v 1.3 1998/10/12 01:40:55 gerald Exp $
+ * $Id: prefs.h,v 1.4 1998/10/28 21:38:10 gerald Exp $
  *
  * Ethereal - Network traffic analyzer
  * By Gerald Combs <gerald@zing.org>
 #ifndef __PREFS_H__
 #define __PREFS_H__
 
+#define PR_FMT_TEXT 0
+#define PR_FMT_PS   1
+
+#define PR_DEST_CMD  0
+#define PR_DEST_FILE 1
+
+typedef struct _e_prefs {
+  gint   pr_format;
+  gint   pr_dest;
+  gchar *pr_file;
+  gchar *pr_cmd;
+} e_prefs;
+
 #define E_PR_PG_NONE     -1
 #define E_PR_PG_PRINTING  0
 #define E_PR_PG_FILTER    1
@@ -36,8 +49,6 @@
 #define E_FILT_TE_PTR_KEY "filter_te_ptr"
 
 void prefs_cb(GtkWidget *, gpointer);
-void prefs_main_ok_cb(GtkWidget *, gpointer);
-void prefs_main_save_cb(GtkWidget *, gpointer);
-void prefs_main_cancel_cb(GtkWidget *, gpointer);
+void read_prefs();
 
 #endif /* prefs.h */
diff --git a/print.c b/print.c
index c45faff8c6a3f2729c044a1582137fabf86a9da8..144c48ab44f6ea9c219eb20ab9e174edf633d9f1 100644 (file)
--- a/print.c
+++ b/print.c
@@ -1,7 +1,7 @@
 /* print.c
  * Routines for printing packet analysis trees.
  *
- * $Id: print.c,v 1.7 1998/10/22 19:10:17 gram Exp $
+ * $Id: print.c,v 1.8 1998/10/28 21:38:11 gerald Exp $
  *
  * Gilbert Ramirez <gram@verdict.uthscsa.edu>
  *
@@ -39,6 +39,7 @@
 
 #include "ethereal.h"
 #include "packet.h"
+#include "prefs.h"
 #include "print.h"
 #include "ps.h"
 
@@ -52,200 +53,188 @@ static void dumpit_ps (FILE *fh, register const u_char *cp, register u_int lengt
 static void ps_clean_string(unsigned char *out, const unsigned char *in,
                        int outbuf_size);
 
-/* #include "ps.c" */
+extern e_prefs prefs;
 
-pr_opts printer_opts;
+/* #include "ps.c" */
 
 /* Key for gtk_object_set_data */
-const gchar *print_prefs_key = "printer_prefs_data";
+#define PRINT_CMD_TE_KEY  "printer_command_entry"
+#define PRINT_FILE_TE_KEY "printer_file_entry"
+
 GtkWidget * printer_prefs_show()
 {
-       GtkWidget       *main_vb, *button;
+       GtkWidget       *main_vb, *main_tb, *button;
        GtkWidget       *format_hb, *format_lb;
        GtkWidget       *dest_hb, *dest_lb;
-       GtkWidget       *cmd_hb, *cmd_lb, *cmd_te;
-       GtkWidget       *file_hb, *file_bt, *file_te;
+       GtkWidget       *cmd_lb, *cmd_te;
+       GtkWidget       *file_bt_hb, *file_bt, *file_te;
        GSList          *format_grp, *dest_grp;
-       pr_opts         *temp_pr_opts = g_malloc(sizeof(pr_opts));
 
-       /* Make a working copy of the printer data */
-       memcpy(temp_pr_opts, &printer_opts, sizeof(pr_opts));
-/*     temp_pr_opts->cmd = g_strdup(printer_opts->cmd);
-       temp_pr_opts->file = g_strdup(printer_opts->file);*/
+       /* Enclosing containers for each row of widgets */
+  main_vb = gtk_vbox_new(FALSE, 5);
+  gtk_container_border_width(GTK_CONTAINER(main_vb), 5);
 
-       /* Container for each row of widgets */
-       main_vb = gtk_vbox_new(FALSE, 3);
-       gtk_container_border_width(GTK_CONTAINER(main_vb), 5);
-       gtk_widget_show(main_vb);
-        gtk_object_set_data(GTK_OBJECT(main_vb), print_prefs_key,
-          temp_pr_opts);
+       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_hb = gtk_hbox_new(FALSE, 1);
-       gtk_container_add(GTK_CONTAINER(main_vb), format_hb);
-       gtk_widget_show(format_hb);
-
        format_lb = gtk_label_new("Format:");
-       gtk_box_pack_start(GTK_BOX(format_hb), format_lb, FALSE, FALSE, 3);
+  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 (printer_opts.output_format == 0) {
+       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, TRUE, TRUE, 0);
+       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 (printer_opts.output_format == 1) {
+       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),
-                       (gpointer)temp_pr_opts);
-       gtk_box_pack_start(GTK_BOX(format_hb), button, TRUE, TRUE, 0);
+                       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_hb = gtk_hbox_new(FALSE, 1);
-       gtk_container_add(GTK_CONTAINER(main_vb), dest_hb);
-       gtk_widget_show(dest_hb);
-
        dest_lb = gtk_label_new("Print to:");
-       gtk_box_pack_start(GTK_BOX(dest_hb), dest_lb, FALSE, FALSE, 3);
+  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 (printer_opts.output_dest == 0) {
+       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_toggle_button_set_state(GTK_TOGGLE_BUTTON(button), TRUE);
-       gtk_box_pack_start(GTK_BOX(dest_hb), button, TRUE, TRUE, 0);
+       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 (printer_opts.output_dest == 1) {
+       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),
-                       (gpointer)temp_pr_opts);
-       gtk_box_pack_start(GTK_BOX(dest_hb), button, TRUE, TRUE, 0);
+                       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_hb = gtk_hbox_new(FALSE, 1);
-       gtk_container_add(GTK_CONTAINER(main_vb), cmd_hb);
-       gtk_widget_show(cmd_hb);
-
        cmd_lb = gtk_label_new("Command:");
-       gtk_box_pack_start(GTK_BOX(cmd_hb), cmd_lb, FALSE, FALSE, 3);
+  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();
-       temp_pr_opts->cmd_te = cmd_te;
-       gtk_entry_set_text(GTK_ENTRY(cmd_te), printer_opts.cmd);
-       gtk_box_pack_start(GTK_BOX(cmd_hb), cmd_te, TRUE, TRUE, 3);
+       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_hb = gtk_hbox_new(FALSE, 1);
-       gtk_container_add(GTK_CONTAINER(main_vb), file_hb);
-       gtk_widget_show(file_hb);
+       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_start(GTK_BOX(file_hb), file_bt, FALSE, FALSE, 3);
+       gtk_box_pack_end(GTK_BOX(file_bt_hb), file_bt, FALSE, FALSE, 0);
        gtk_widget_show(file_bt);
 
        file_te = gtk_entry_new();
-       temp_pr_opts->file_te = file_te;
-       gtk_entry_set_text(GTK_ENTRY(file_te), printer_opts.file);
-       gtk_box_pack_start(GTK_BOX(file_hb), file_te, TRUE, TRUE, 3);
+       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_object(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 *w, gpointer te) {
-  GtkWidget *fs, **w_list;
+  GtkWidget *fs;
 
-  w_list = g_malloc(2 * sizeof(GtkWidget *));
-  
   fs = gtk_file_selection_new ("Ethereal: Print to a File");
-  w_list[0] = fs;
-  w_list[1] = (GtkWidget *) te;
+       gtk_object_set_data(GTK_OBJECT(fs), PRINT_FILE_TE_KEY, te);
 
   gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION(fs)->ok_button),
-    "clicked", (GtkSignalFunc) printer_opts_fs_ok_cb, w_list);
+    "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, w_list);
+    "clicked", (GtkSignalFunc) printer_opts_fs_cancel_cb, fs);
 
   gtk_widget_show(fs);
 }
 
 static void
 printer_opts_fs_ok_cb(GtkWidget *w, gpointer data) {
-       GtkWidget **w_list = (GtkWidget **) data;
          
-       gtk_entry_set_text(GTK_ENTRY(w_list[1]),
-               gtk_file_selection_get_filename (GTK_FILE_SELECTION(w_list[0])));
+       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) {
-       GtkWidget **w_list = (GtkWidget **) data;
          
-       gtk_widget_destroy(w_list[0]);
-       g_free(data);
+       gtk_widget_destroy(GTK_WIDGET(data));
 } 
 
 void
 printer_prefs_ok(GtkWidget *w)
 {
-       pr_opts *data = gtk_object_get_data(GTK_OBJECT(w), print_prefs_key);
-        
-       printer_opts.output_format = ((pr_opts*)data)->output_format;
-       printer_opts.output_dest = ((pr_opts*)data)->output_dest;
-
-       free(printer_opts.cmd);
-       printer_opts.cmd =
-               g_strdup(gtk_entry_get_text(GTK_ENTRY(((pr_opts*)data)->cmd_te)));
-
-       free(printer_opts.file);
-       printer_opts.file =
-               g_strdup(gtk_entry_get_text(GTK_ENTRY(((pr_opts*)data)->file_te)));
+       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))));
+}
 
-       g_free(data);
+void
+printer_prefs_save(GtkWidget *w)
+{
+       printer_prefs_ok(w);
 }
 
 void
 printer_prefs_cancel(GtkWidget *w)
 {
-       pr_opts *data = gtk_object_get_data(GTK_OBJECT(w), print_prefs_key);
-        
-       g_free(data);
 }
 
 static void
 printer_opts_toggle_format(GtkWidget *widget, gpointer data)
 {
                if (GTK_TOGGLE_BUTTON (widget)->active) {
-                       ((pr_opts*)data)->output_format = 1;
+                       prefs.pr_format = PR_FMT_PS;
                        /* toggle file/cmd */
                }
                else {
-                       ((pr_opts*)data)->output_format = 0;
+                       prefs.pr_format = PR_FMT_TEXT;
                        /* toggle file/cmd */
                }
 }
@@ -254,10 +243,10 @@ static void
 printer_opts_toggle_dest(GtkWidget *widget, gpointer data)
 {
                if (GTK_TOGGLE_BUTTON (widget)->active) {
-                       ((pr_opts*)data)->output_dest = 1;
+                       prefs.pr_dest = PR_DEST_FILE;
                }
                else {
-                       ((pr_opts*)data)->output_dest = 0;
+                       prefs.pr_dest = PR_DEST_CMD;
                }
 }
 
@@ -268,13 +257,13 @@ void print_tree(const u_char *pd, frame_data *fd, GtkTree *tree)
        char    *out;
 
        /* Open the file or command for output */
-       if (printer_opts.output_dest == 0) {
-               out = printer_opts.cmd;
-               fh = popen(printer_opts.cmd, "w");
+       if (prefs.pr_dest == PR_DEST_CMD) {
+               out = prefs.pr_cmd;
+               fh = popen(prefs.pr_cmd, "w");
        }
        else {
-               out = printer_opts.file;
-               fh = fopen(printer_opts.file, "w");
+               out = prefs.pr_file;
+               fh = fopen(prefs.pr_file, "w");
        }
 
        if (!fh) {
@@ -283,7 +272,7 @@ void print_tree(const u_char *pd, frame_data *fd, GtkTree *tree)
        }
 
        /* Create the output */
-       if (printer_opts.output_format == 0) {
+       if (prefs.pr_format == PR_FMT_TEXT) {
                print_tree_text(fh, pd, fd, tree);
        }
        else {
@@ -293,7 +282,7 @@ void print_tree(const u_char *pd, frame_data *fd, GtkTree *tree)
        }
 
        /* Close the file or command */
-       if (printer_opts.output_dest == 0) {
+       if (prefs.pr_dest == PR_DEST_CMD) {
                pclose(fh);
        }
        else {
diff --git a/print.h b/print.h
index 0bafbd74d64ff18b0a8555803d025c6f2654e9c0..60585b4fa0e2767004d3a7225386fbdebb370ee1 100644 (file)
--- a/print.h
+++ b/print.h
@@ -1,7 +1,7 @@
 /* print.h
  * Definitions for printing packet analysis trees.
  *
- * $Id: print.h,v 1.5 1998/10/10 03:32:20 gerald Exp $
+ * $Id: print.h,v 1.6 1998/10/28 21:38:11 gerald Exp $
  *
  * Gilbert Ramirez <gram@verdict.uthscsa.edu>
  *
 #ifndef __PRINT_H__
 #define __PRINT_H__
 
-typedef struct pr_opts {
-       int             output_format;  /* 0=text, 1=postscript */
-       int             output_dest;    /* 0=cmd, 1=file */
-       char    *file;
-       char    *cmd;
-
-       /* for the dialogue box */
-       GtkWidget       *cmd_te;
-       GtkWidget       *file_te;
-} pr_opts;
-
 /* Functions in print.h */
 
 GtkWidget *printer_prefs_show();
 void printer_prefs_ok(GtkWidget *w);
+void printer_prefs_save(GtkWidget *w);
 void printer_prefs_cancel(GtkWidget *w);
 void print_tree(const u_char *pd, frame_data *fd, GtkTree *tree);
 void print_tree_text(FILE *fh, const u_char *pd, frame_data *fd, GtkTree *tree);