osmocom
/
wireshark
11
0
Fork 1
Code Issues Pull Requests Projects Releases Wiki Activity

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

preferences, and menus to gtk subdirectory.

svn path=/trunk/; revision=623
This commit is contained in:
Gilbert Ramirez 1999-09-01 03:04:24 +00:00
parent 25502bc8fc
commit 65c3e8d9bf
18 changed files with 921 additions and 777 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
Makefile.am
View File

@ -32,10 +32,9 @@ ethereal_SOURCES = \
filter.h \
follow.c \
follow.h \
globals.h \
gtkpacket.c \
gtkpacket.h \
menu.c \
menu.h \
packet-aarp.c \
packet-arp.c \
packet-atalk.c \

4
capture.c
View File

@ -1,7 +1,7 @@
/* capture.c
* Routines for packet capture windows
*
* $Id: capture.c,v 1.62 1999/08/24 17:26:09 gram Exp $
* $Id: capture.c,v 1.63 1999/09/01 03:04:09 gram Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -80,7 +80,7 @@
#include "ethereal.h"
#include "packet.h"
#include "file.h"
#include "menu.h"
#include "gtk/menu.h"
#include "capture.h"
#include "util.h"
#include "prefs.h"

556
ethereal.c
View File

@ -1,6 +1,6 @@
/* ethereal.c
*
* $Id: ethereal.c,v 1.109 1999/08/28 01:51:58 guy Exp $
* $Id: ethereal.c,v 1.110 1999/09/01 03:04:09 gram Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -25,7 +25,6 @@
*
*
* To do:
* - Live browser/capture display
* - Graphs
* - Get AIX to work
* - Check for end of packet in dissect_* routines.
@ -33,7 +32,6 @@
* - Multiple window support
* - Add cut/copy/paste
* - Create header parsing routines
* - Check fopens, freads, fwrites
* - Make byte view scrollbars automatic?
* - Make byte view selections more fancy?
*
@ -87,7 +85,7 @@
#include "capture.h"
#include "summary.h"
#include "file.h"
#include "menu.h"
#include "gtk/menu.h"
#include "prefs.h"
#include "column.h"
#include "print.h"
@ -96,16 +94,7 @@
#include "util.h"
#include "gtkpacket.h"
#include "dfilter.h"
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);
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);
#include "gtk/keys.h"
FILE *data_out_file = NULL;
packet_info pi;
@ -136,8 +125,6 @@ int quit_after_cap; /* Makes a "capture only mode". Implies -k */
/* Specifies byte offsets for object selected in tree */
static gint tree_selected_start=-1, tree_selected_len=-1;
#define E_DFILTER_TE_KEY "display_filter_te"
#define E_RFILTER_TE_KEY "read_filter_te"
/* About Ethereal window */
void
@ -351,222 +338,6 @@ match_selected_cb(GtkWidget *w, gpointer data)
filter_packets(&cf);
}
/* 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? */
}
/* Run the current display filter on the current packet set, and
redisplay. */
static void
@ -588,327 +359,6 @@ filter_activate_cb(GtkWidget *w, gpointer data)
filter_packets(&cf);
}
/*
* Remember whether we printed to a printer or a file the last time we
* printed something.
*/
static int print_to_file;
/* Keys for gtk_object_set_data */
#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"
/* 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);
}
/* What to do when a list item is selected/unselected */
void
packet_list_select_cb(GtkWidget *w, gint row, gint col, gpointer evt) {

4
file.c
View File

@ -1,7 +1,7 @@
/* file.c
* File I/O routines
*
* $Id: file.c,v 1.85 1999/08/28 23:47:42 gram Exp $
* $Id: file.c,v 1.86 1999/09/01 03:04:10 gram Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -70,7 +70,7 @@
#include "ethereal.h"
#include "column.h"
#include "menu.h"
#include "gtk/menu.h"
#include "packet.h"
#include "print.h"
#include "file.h"

3
filter.c
View File

@ -1,7 +1,7 @@
/* filter.c
* Routines for managing filter sets
*
* $Id: filter.c,v 1.14 1999/07/13 03:08:05 gram Exp $
* $Id: filter.c,v 1.15 1999/09/01 03:04:11 gram Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -44,7 +44,6 @@
#include "filter.h"
#include "packet.h"
#include "file.h"
#include "menu.h"
#include "prefs.h"
#define E_FILT_NAME_KEY "filter_name"

50
globals.h Normal file
View File

@ -0,0 +1,50 @@
#ifndef __GLOBALS_H__
#define __GLOBALS_H__
#ifndef _STDIO_H_
#include <stdio.h>
#endif
#ifndef __PACKET_H__
#include "packet.h"
#endif
#ifndef __GTK_H__
#include <gtk/gtk.h>
#endif
#ifndef __FILE_H__
#include "file.h"
#endif
#ifndef __TIMESTAMP_H__
#include "timestamp.h"
#endif
extern FILE *data_out_file;
extern packet_info pi;
extern capture_file cf;
extern GtkWidget *file_sel, *packet_list, *tree_view, *byte_view, *prog_bar,
*info_bar;
extern GdkFont *m_r_font, *m_b_font;
extern guint main_ctx, file_ctx;
extern gint start_capture;
extern gchar comp_info_str[256];
extern gchar *ethereal_path;
extern gchar *medium_font;
extern gchar *bold_font;
extern gchar *last_open_dir;
extern ts_type timestamp_type;
extern GtkStyle *item_style;
#ifdef HAVE_LIBPCAP
extern int sync_mode; /* allow sync */
extern int sync_pipe[2]; /* used to sync father */
extern int fork_mode; /* fork a child to do the capture */
extern int sigusr2_received;
extern int quit_after_cap; /* Makes a "capture only mode". Implies -k */
#endif
#endif

9
gtk/Makefile.am
View File

@ -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

254
gtk/file_dlg.c Normal file
View File

@ -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? */
}

16
gtk/keys.h Normal file
View File

@ -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

2
menu.c → gtk/menu.c
View File

@ -1,7 +1,7 @@
/* menu.c
* Menu routines
*
* $Id: menu.c,v 1.34 1999/08/24 16:27:23 gram Exp $
* $Id: menu.c,v 1.1 1999/09/01 03:04:23 gram Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>

2
menu.h → gtk/menu.h
View File

@ -1,7 +1,7 @@
/* menu.h
* Menu definitions
*
* $Id: menu.h,v 1.5 1999/07/13 03:08:06 gram Exp $
* $Id: menu.h,v 1.1 1999/09/01 03:04:23 gram Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>

347
gtk/print_dlg.c Normal file
View File

@ -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);
}

223
gtk/print_prefs.c Normal file
View File

@ -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;
}
}

5
gtk/print_prefs.h Normal file
View File

@ -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);

3
prefs.c
View File

@ -1,7 +1,7 @@
/* prefs.c
* Routines for handling preferences
*
* $Id: prefs.c,v 1.19 1999/07/13 02:52:57 gram Exp $
* $Id: prefs.c,v 1.20 1999/09/01 03:04:12 gram Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -53,6 +53,7 @@
#include "prefs.h"
#include "column.h"
#include "print.h"
#include "gtk/print_prefs.h"
#include "filter.h"
#include "util.h"

208
print.c
View File

@ -1,7 +1,7 @@
/* print.c
* Routines for printing packet analysis trees.
*
* $Id: print.c,v 1.16 1999/07/23 21:09:23 guy Exp $
* $Id: print.c,v 1.17 1999/09/01 03:04:12 gram Exp $
*
* Gilbert Ramirez <gram@verdict.uthscsa.edu>
*
@ -29,26 +29,20 @@
# include "config.h"
#endif
#include <gtk/gtk.h>
#include <stdio.h>
#include <string.h>
#include <gtk/gtk.h>
#ifdef HAVE_SYS_TYPES_H
# include <sys/types.h>
#endif
#include "ethereal.h"
/*#include "ethereal.h"*/
#include "packet.h"
#include "gtkpacket.h"
#include "prefs.h"
#include "print.h"
#include "ps.h"
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);
static void proto_tree_print_node_text(GNode *node, gpointer data);
static void dumpit (FILE *fh, register const u_char *cp, register u_int length);
static void proto_tree_print_node_ps(GNode *node, gpointer data);
@ -58,202 +52,6 @@ static void dumpit_ps (FILE *fh, register const u_char *cp, register u_int lengt
extern int proto_data; /* in packet-data.c */
/* #include "ps.c" */
/* Key for gtk_object_set_data */
#define PRINT_CMD_TE_KEY "printer_command_entry"
#define PRINT_FILE_TE_KEY "printer_file_entry"
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;
}
}
/* ========================================================== */
typedef struct {
int level;

6
print.h
View File

@ -1,7 +1,7 @@
/* print.h
* Definitions for printing packet analysis trees.
*
* $Id: print.h,v 1.9 1999/07/23 21:09:23 guy Exp $
* $Id: print.h,v 1.10 1999/09/01 03:04:12 gram Exp $
*
* Gilbert Ramirez <gram@verdict.uthscsa.edu>
*
@ -30,10 +30,6 @@
/* 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);
FILE *open_print_dest(int to_file, const char *dest);
void close_print_dest(int to_file, FILE *fh);
void print_preamble(FILE *fh);

3
summary.c
View File

@ -1,7 +1,7 @@
/* summary.c
* Routines for capture file summary window
*
* $Id: summary.c,v 1.10 1999/08/24 17:26:16 gram Exp $
* $Id: summary.c,v 1.11 1999/09/01 03:04:12 gram Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -58,7 +58,6 @@
#include "ethereal.h"
#include "packet.h"
#include "file.h"
#include "menu.h"
#include "summary.h"
#include "capture.h"
#include "util.h"