forked from osmocom/wireshark
d453f6d992
Data\Ethereal" directory under the user's profile, as that appears to be the Windows 2000 standard. svn path=/trunk/; revision=4071
889 lines
29 KiB
C
889 lines
29 KiB
C
/* prefs_dlg.c
|
|
* Routines for handling preferences
|
|
*
|
|
* $Id: prefs_dlg.c,v 1.32 2001/10/24 06:13:07 guy Exp $
|
|
*
|
|
* Ethereal - Network traffic analyzer
|
|
* By Gerald Combs <gerald@ethereal.com>
|
|
* 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
|
|
|
|
#ifdef HAVE_SYS_TYPES_H
|
|
#include <sys/types.h>
|
|
#endif
|
|
|
|
#include <gtk/gtk.h>
|
|
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <ctype.h>
|
|
#include <errno.h>
|
|
|
|
#ifdef HAVE_UNISTD_H
|
|
#include <unistd.h>
|
|
#endif
|
|
|
|
#ifdef HAVE_SYS_STAT_H
|
|
#include <sys/stat.h>
|
|
#endif
|
|
|
|
#include <epan/filesystem.h>
|
|
|
|
#include "main.h"
|
|
#include "gtkglobals.h"
|
|
#include "packet.h"
|
|
#include "file.h"
|
|
#include "prefs.h"
|
|
#include "column_prefs.h"
|
|
#include "print.h"
|
|
#include "prefs_dlg.h"
|
|
#include "print_prefs.h"
|
|
#include "stream_prefs.h"
|
|
#include "gui_prefs.h"
|
|
#include "ui_util.h"
|
|
#include "dlg_utils.h"
|
|
#include "simple_dialog.h"
|
|
|
|
#include "prefs-int.h"
|
|
|
|
static void prefs_main_ok_cb(GtkWidget *, gpointer);
|
|
static void prefs_main_apply_cb(GtkWidget *, gpointer);
|
|
static void prefs_main_save_cb(GtkWidget *, gpointer);
|
|
static void prefs_main_cancel_cb(GtkWidget *, gpointer);
|
|
static gboolean prefs_main_delete_cb(GtkWidget *, gpointer);
|
|
static void prefs_main_destroy_cb(GtkWidget *, gpointer);
|
|
static void prefs_tree_select_cb(GtkCTree *, GtkCTreeNode *, gint, gpointer);
|
|
|
|
#define E_PRINT_PAGE_KEY "printer_options_page"
|
|
#define E_COLUMN_PAGE_KEY "column_options_page"
|
|
#define E_STREAM_PAGE_KEY "tcp_stream_options_page"
|
|
#define E_GUI_PAGE_KEY "gui_options_page"
|
|
|
|
#define FIRST_PROTO_PREFS_PAGE 4
|
|
|
|
/*
|
|
* Keep a static pointer to the notebook to be able to choose the
|
|
* displayed page.
|
|
*/
|
|
static GtkWidget *notebook;
|
|
|
|
/*
|
|
* Keep a static pointer to the current "Preferences" window, if any, so that
|
|
* if somebody tries to do "Edit:Preferences" while there's already a
|
|
* "Preferences" window up, we just pop up the existing one, rather than
|
|
* creating a new one.
|
|
*/
|
|
static GtkWidget *prefs_w;
|
|
|
|
/*
|
|
* Save the value of the preferences as of when the preferences dialog
|
|
* box was first popped up, so we can revert to those values if the
|
|
* user selects "Cancel".
|
|
*/
|
|
static e_prefs saved_prefs;
|
|
|
|
struct ct_struct {
|
|
GtkWidget *notebook;
|
|
GtkWidget *ctree;
|
|
GtkCTreeNode *node;
|
|
gint page;
|
|
};
|
|
|
|
static void
|
|
pref_show(pref_t *pref, gpointer user_data)
|
|
{
|
|
GtkWidget *main_tb = user_data;
|
|
const char *title;
|
|
char *label_string;
|
|
GtkWidget *label, *menu, *menu_item, *widget, *button;
|
|
GSList *rb_group;
|
|
char uint_str[10+1];
|
|
const enum_val_t *enum_valp;
|
|
int menu_index, index;
|
|
|
|
/* Give this preference a label which is its title, followed by a colon,
|
|
and left-align it. */
|
|
title = pref->title;
|
|
label_string = g_malloc(strlen(title) + 2);
|
|
strcpy(label_string, title);
|
|
strcat(label_string, ":");
|
|
label = gtk_label_new(label_string);
|
|
g_free(label_string);
|
|
gtk_misc_set_alignment(GTK_MISC(label), 1.0, 0.5);
|
|
|
|
/* Attach it to the table. */
|
|
gtk_table_attach_defaults(GTK_TABLE(main_tb), label, 0, 1, pref->ordinal,
|
|
pref->ordinal+1);
|
|
|
|
/* Save the current value of the preference, so that we can revert it if
|
|
the user does "Apply" and then "Cancel", and create the control for
|
|
editing the preference. */
|
|
switch (pref->type) {
|
|
|
|
case PREF_UINT:
|
|
pref->saved_val.uint = *pref->varp.uint;
|
|
|
|
/* XXX - there are no uint spinbuttons, so we can't use a spinbutton.
|
|
Even more annoyingly, even if there were, GLib doesn't define
|
|
G_MAXUINT - but I think ANSI C may define UINT_MAX, so we could
|
|
use that. */
|
|
widget = gtk_entry_new();
|
|
switch (pref->info.base) {
|
|
|
|
case 10:
|
|
sprintf(uint_str, "%u", pref->saved_val.uint);
|
|
break;
|
|
|
|
case 8:
|
|
sprintf(uint_str, "%o", pref->saved_val.uint);
|
|
break;
|
|
|
|
case 16:
|
|
sprintf(uint_str, "%x", pref->saved_val.uint);
|
|
break;
|
|
}
|
|
gtk_entry_set_text(GTK_ENTRY(widget), uint_str);
|
|
pref->control = widget;
|
|
break;
|
|
|
|
case PREF_BOOL:
|
|
pref->saved_val.bool = *pref->varp.bool;
|
|
widget = gtk_check_button_new();
|
|
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(widget), pref->saved_val.bool);
|
|
pref->control = widget;
|
|
break;
|
|
|
|
case PREF_ENUM:
|
|
pref->saved_val.enumval = *pref->varp.enump;
|
|
if (pref->info.enum_info.radio_buttons) {
|
|
/* Show it as radio buttons. */
|
|
widget = gtk_hbox_new(FALSE, 0);
|
|
rb_group = NULL;
|
|
for (enum_valp = pref->info.enum_info.enumvals, index = 0;
|
|
enum_valp->name != NULL; enum_valp++, index++) {
|
|
button = gtk_radio_button_new_with_label(rb_group, enum_valp->name);
|
|
if (rb_group == NULL)
|
|
rb_group = gtk_radio_button_group(GTK_RADIO_BUTTON(button));
|
|
gtk_box_pack_start(GTK_BOX(widget), button, FALSE, FALSE, 10);
|
|
if (enum_valp->value == pref->saved_val.enumval)
|
|
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(button), TRUE);
|
|
pref->control = button;
|
|
}
|
|
} else {
|
|
/* Show it as an option menu. */
|
|
menu = gtk_menu_new();
|
|
menu_index = -1;
|
|
for (enum_valp = pref->info.enum_info.enumvals, index = 0;
|
|
enum_valp->name != NULL; enum_valp++, index++) {
|
|
menu_item = gtk_menu_item_new_with_label(enum_valp->name);
|
|
gtk_menu_append(GTK_MENU(menu), menu_item);
|
|
if (enum_valp->value == pref->saved_val.enumval)
|
|
menu_index = index;
|
|
gtk_widget_show(menu_item);
|
|
}
|
|
|
|
/* Create the option menu from the option */
|
|
widget = gtk_option_menu_new();
|
|
gtk_option_menu_set_menu(GTK_OPTION_MENU(widget), menu);
|
|
|
|
/* Set its current value to the variable's current value */
|
|
if (menu_index != -1)
|
|
gtk_option_menu_set_history(GTK_OPTION_MENU(widget), menu_index);
|
|
pref->control = widget;
|
|
}
|
|
break;
|
|
|
|
case PREF_STRING:
|
|
widget = gtk_entry_new();
|
|
if (pref->saved_val.string != NULL)
|
|
g_free(pref->saved_val.string);
|
|
pref->saved_val.string = g_strdup(*pref->varp.string);
|
|
gtk_entry_set_text(GTK_ENTRY(widget), pref->saved_val.string);
|
|
pref->control = widget;
|
|
break;
|
|
|
|
default:
|
|
g_assert_not_reached();
|
|
widget = NULL;
|
|
break;
|
|
}
|
|
|
|
gtk_table_attach_defaults(GTK_TABLE(main_tb), widget, 1, 2, pref->ordinal,
|
|
pref->ordinal+1);
|
|
}
|
|
|
|
#define MAX_TREE_NODE_NAME_LEN 64
|
|
static void
|
|
module_prefs_show(module_t *module, gpointer user_data)
|
|
{
|
|
struct ct_struct *cts = user_data;
|
|
GtkWidget *main_vb, *main_tb, *frame;
|
|
gchar label_str[MAX_TREE_NODE_NAME_LEN], *label_ptr = label_str;
|
|
GtkCTreeNode *ct_node;
|
|
|
|
/* Frame */
|
|
frame = gtk_frame_new(module->title);
|
|
gtk_widget_show(frame);
|
|
|
|
/* Main vertical box */
|
|
main_vb = gtk_vbox_new(FALSE, 5);
|
|
gtk_container_border_width(GTK_CONTAINER(main_vb), 5);
|
|
gtk_container_add(GTK_CONTAINER(frame), main_vb);
|
|
|
|
/* Main table */
|
|
main_tb = gtk_table_new(module->numprefs, 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);
|
|
|
|
/* Add items for each of the preferences */
|
|
prefs_pref_foreach(module, pref_show, main_tb);
|
|
|
|
gtk_notebook_append_page(GTK_NOTEBOOK(cts->notebook), frame, NULL);
|
|
strcpy(label_str, module->title);
|
|
ct_node = gtk_ctree_insert_node(GTK_CTREE(cts->ctree), cts->node, NULL,
|
|
&label_ptr, 5, NULL, NULL, NULL, NULL, TRUE, TRUE);
|
|
gtk_ctree_node_set_row_data(GTK_CTREE(cts->ctree), ct_node,
|
|
GINT_TO_POINTER(cts->page));
|
|
cts->page++;
|
|
|
|
/* Show 'em what we got */
|
|
gtk_widget_show_all(main_vb);
|
|
}
|
|
|
|
void
|
|
prefs_cb(GtkWidget *w, gpointer dummy) {
|
|
GtkWidget *main_vb, *top_hb, *bbox, *prefs_nb, *ct_sb, *frame,
|
|
*ok_bt, *apply_bt, *save_bt, *cancel_bt;
|
|
GtkWidget *print_pg, *column_pg, *stream_pg, *gui_pg;
|
|
gchar label_str[MAX_TREE_NODE_NAME_LEN], *label_ptr = label_str;
|
|
GtkCTreeNode *ct_node;
|
|
struct ct_struct cts;
|
|
|
|
|
|
if (prefs_w != NULL) {
|
|
/* There's already a "Preferences" dialog box; reactivate it. */
|
|
reactivate_window(prefs_w);
|
|
return;
|
|
}
|
|
|
|
/* Save the current preferences, so we can revert to those values
|
|
if the user presses "Cancel". */
|
|
copy_prefs(&saved_prefs, &prefs);
|
|
|
|
prefs_w = dlg_window_new("Ethereal: Preferences");
|
|
gtk_signal_connect(GTK_OBJECT(prefs_w), "delete_event",
|
|
GTK_SIGNAL_FUNC(prefs_main_delete_cb), NULL);
|
|
gtk_signal_connect(GTK_OBJECT(prefs_w), "destroy",
|
|
GTK_SIGNAL_FUNC(prefs_main_destroy_cb), NULL);
|
|
|
|
/* Container 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(prefs_w), main_vb);
|
|
gtk_widget_show(main_vb);
|
|
|
|
/* Top row: Preferences tree and notebook */
|
|
top_hb = gtk_hbox_new(FALSE, 10);
|
|
gtk_container_add(GTK_CONTAINER(main_vb), top_hb);
|
|
gtk_widget_show(top_hb);
|
|
|
|
/* Place a Ctree on the left for preference categories */
|
|
ct_sb = gtk_scrolled_window_new(NULL, NULL);
|
|
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(ct_sb),
|
|
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
|
|
set_scrollbar_placement_scrollw(ct_sb, prefs.gui_scrollbar_on_right);
|
|
remember_scrolled_window(ct_sb);
|
|
gtk_container_add(GTK_CONTAINER(top_hb), ct_sb);
|
|
gtk_widget_show(ct_sb);
|
|
|
|
cts.ctree = gtk_ctree_new(1, 0);
|
|
cts.page = 0;
|
|
gtk_container_add(GTK_CONTAINER(ct_sb), cts.ctree);
|
|
|
|
/* Be consistent with our line/expander styles */
|
|
g_assert(prefs.gui_ptree_line_style >= GTK_CTREE_LINES_NONE &&
|
|
prefs.gui_ptree_line_style <= GTK_CTREE_LINES_TABBED);
|
|
gtk_ctree_set_line_style(GTK_CTREE(cts.ctree), prefs.gui_ptree_line_style);
|
|
g_assert(prefs.gui_ptree_expander_style >= GTK_CTREE_EXPANDER_NONE &&
|
|
prefs.gui_ptree_expander_style <= GTK_CTREE_EXPANDER_CIRCULAR);
|
|
gtk_ctree_set_expander_style(GTK_CTREE(cts.ctree),
|
|
prefs.gui_ptree_expander_style);
|
|
|
|
gtk_clist_set_column_auto_resize(GTK_CLIST(cts.ctree), 0, TRUE);
|
|
gtk_signal_connect(GTK_OBJECT(cts.ctree), "tree-select-row",
|
|
GTK_SIGNAL_FUNC(prefs_tree_select_cb), NULL);
|
|
gtk_widget_show(cts.ctree);
|
|
|
|
/* A notebook widget sans tabs is used to flip between prefs */
|
|
notebook = prefs_nb = gtk_notebook_new();
|
|
gtk_notebook_set_show_tabs(GTK_NOTEBOOK(notebook), FALSE);
|
|
gtk_notebook_set_show_border(GTK_NOTEBOOK(notebook), FALSE);
|
|
gtk_container_add(GTK_CONTAINER(top_hb), prefs_nb);
|
|
gtk_widget_show(prefs_nb);
|
|
|
|
/* Printing prefs */
|
|
frame = gtk_frame_new("Printing");
|
|
gtk_widget_show(GTK_WIDGET(frame));
|
|
print_pg = printer_prefs_show();
|
|
gtk_container_add(GTK_CONTAINER(frame), print_pg);
|
|
gtk_object_set_data(GTK_OBJECT(prefs_w), E_PRINT_PAGE_KEY, print_pg);
|
|
gtk_notebook_append_page (GTK_NOTEBOOK(prefs_nb), frame, NULL);
|
|
strcpy(label_str, "Printing");
|
|
ct_node = gtk_ctree_insert_node(GTK_CTREE(cts.ctree), NULL, NULL,
|
|
&label_ptr, 5, NULL, NULL, NULL, NULL, TRUE, TRUE);
|
|
gtk_ctree_node_set_row_data(GTK_CTREE(cts.ctree), ct_node,
|
|
GINT_TO_POINTER(cts.page));
|
|
cts.page++;
|
|
|
|
/* Column prefs */
|
|
frame = gtk_frame_new("Columns");
|
|
gtk_widget_show(GTK_WIDGET(frame));
|
|
column_pg = column_prefs_show();
|
|
gtk_container_add(GTK_CONTAINER(frame), column_pg);
|
|
gtk_object_set_data(GTK_OBJECT(prefs_w), E_COLUMN_PAGE_KEY, column_pg);
|
|
gtk_notebook_append_page (GTK_NOTEBOOK(prefs_nb), frame, NULL);
|
|
strcpy(label_str, "Columns");
|
|
ct_node = gtk_ctree_insert_node(GTK_CTREE(cts.ctree), NULL, NULL,
|
|
&label_ptr, 5, NULL, NULL, NULL, NULL, TRUE, TRUE);
|
|
gtk_ctree_node_set_row_data(GTK_CTREE(cts.ctree), ct_node,
|
|
GINT_TO_POINTER(cts.page));
|
|
cts.page++;
|
|
|
|
/* TCP Streams prefs */
|
|
frame = gtk_frame_new("TCP Streams");
|
|
gtk_widget_show(GTK_WIDGET(frame));
|
|
stream_pg = stream_prefs_show();
|
|
gtk_container_add(GTK_CONTAINER(frame), stream_pg);
|
|
gtk_object_set_data(GTK_OBJECT(prefs_w), E_STREAM_PAGE_KEY, stream_pg);
|
|
gtk_notebook_append_page (GTK_NOTEBOOK(prefs_nb), frame, NULL);
|
|
strcpy(label_str, "TCP Streams");
|
|
ct_node = gtk_ctree_insert_node(GTK_CTREE(cts.ctree), NULL, NULL,
|
|
&label_ptr, 5, NULL, NULL, NULL, NULL, TRUE, TRUE);
|
|
gtk_ctree_node_set_row_data(GTK_CTREE(cts.ctree), ct_node,
|
|
GINT_TO_POINTER(cts.page));
|
|
cts.page++;
|
|
|
|
/* GUI prefs */
|
|
frame = gtk_frame_new("User Interface");
|
|
gtk_widget_show(GTK_WIDGET(frame));
|
|
gui_pg = gui_prefs_show();
|
|
gtk_container_add(GTK_CONTAINER(frame), gui_pg);
|
|
gtk_object_set_data(GTK_OBJECT(prefs_w), E_GUI_PAGE_KEY, gui_pg);
|
|
gtk_notebook_append_page (GTK_NOTEBOOK(prefs_nb), frame, NULL);
|
|
strcpy(label_str, "User Interface");
|
|
ct_node = gtk_ctree_insert_node(GTK_CTREE(cts.ctree), NULL, NULL,
|
|
&label_ptr, 5, NULL, NULL, NULL, NULL, TRUE, TRUE);
|
|
gtk_ctree_node_set_row_data(GTK_CTREE(cts.ctree), ct_node,
|
|
GINT_TO_POINTER(cts.page));
|
|
cts.page++;
|
|
|
|
|
|
/* Registered prefs */
|
|
cts.notebook = prefs_nb;
|
|
strcpy(label_str, "Protocols");
|
|
cts.node = gtk_ctree_insert_node(GTK_CTREE(cts.ctree), NULL, NULL,
|
|
&label_ptr, 5, NULL, NULL, NULL, NULL, FALSE, FALSE);
|
|
gtk_ctree_node_set_row_data(GTK_CTREE(cts.ctree), cts.node,
|
|
GINT_TO_POINTER(-1));
|
|
gtk_ctree_node_set_selectable(GTK_CTREE(cts.ctree), cts.node, FALSE);
|
|
|
|
prefs_module_foreach(module_prefs_show, &cts);
|
|
|
|
|
|
/* 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_signal_connect(GTK_OBJECT(ok_bt), "clicked",
|
|
GTK_SIGNAL_FUNC(prefs_main_ok_cb), GTK_OBJECT(prefs_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);
|
|
|
|
apply_bt = gtk_button_new_with_label ("Apply");
|
|
gtk_signal_connect(GTK_OBJECT(apply_bt), "clicked",
|
|
GTK_SIGNAL_FUNC(prefs_main_apply_cb), GTK_OBJECT(prefs_w));
|
|
GTK_WIDGET_SET_FLAGS(apply_bt, GTK_CAN_DEFAULT);
|
|
gtk_box_pack_start(GTK_BOX (bbox), apply_bt, TRUE, TRUE, 0);
|
|
gtk_widget_show(apply_bt);
|
|
|
|
save_bt = gtk_button_new_with_label ("Save");
|
|
gtk_signal_connect(GTK_OBJECT(save_bt), "clicked",
|
|
GTK_SIGNAL_FUNC(prefs_main_save_cb), GTK_OBJECT(prefs_w));
|
|
GTK_WIDGET_SET_FLAGS(save_bt, GTK_CAN_DEFAULT);
|
|
gtk_box_pack_start (GTK_BOX (bbox), save_bt, TRUE, TRUE, 0);
|
|
gtk_widget_show(save_bt);
|
|
|
|
cancel_bt = gtk_button_new_with_label ("Cancel");
|
|
gtk_signal_connect(GTK_OBJECT(cancel_bt), "clicked",
|
|
GTK_SIGNAL_FUNC(prefs_main_cancel_cb), GTK_OBJECT(prefs_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);
|
|
|
|
/* Catch the "key_press_event" signal in the window, so that we can catch
|
|
the ESC key being pressed and act as if the "Cancel" button had
|
|
been selected. */
|
|
dlg_set_cancel(prefs_w, cancel_bt);
|
|
|
|
gtk_widget_show(prefs_w);
|
|
}
|
|
|
|
static void
|
|
pref_fetch(pref_t *pref, gpointer user_data)
|
|
{
|
|
GtkWidget *label;
|
|
char *label_string;
|
|
char *str_val;
|
|
char *p;
|
|
guint uval;
|
|
gboolean bval;
|
|
GSList *rb_entry;
|
|
GtkWidget *button;
|
|
gint enumval;
|
|
gboolean *pref_changed_p = user_data;
|
|
|
|
/* Fetch the value of the preference, and set the appropriate variable
|
|
to it. */
|
|
switch (pref->type) {
|
|
|
|
case PREF_UINT:
|
|
str_val = gtk_entry_get_text(GTK_ENTRY(pref->control));
|
|
uval = strtoul(str_val, &p, pref->info.base);
|
|
#if 0
|
|
if (p == value || *p != '\0')
|
|
return PREFS_SET_SYNTAX_ERR; /* number was bad */
|
|
#endif
|
|
if (*pref->varp.uint != uval) {
|
|
*pref_changed_p = TRUE;
|
|
*pref->varp.uint = uval;
|
|
}
|
|
break;
|
|
|
|
case PREF_BOOL:
|
|
bval = GTK_TOGGLE_BUTTON(pref->control)->active;
|
|
if (*pref->varp.bool != bval) {
|
|
*pref_changed_p = TRUE;
|
|
*pref->varp.bool = bval;
|
|
}
|
|
break;
|
|
|
|
case PREF_ENUM:
|
|
if (pref->info.enum_info.radio_buttons) {
|
|
/* Go through the list of of radio buttons in the group, and find
|
|
the first one that's active. */
|
|
button = NULL;
|
|
for (rb_entry = gtk_radio_button_group(GTK_RADIO_BUTTON(pref->control));
|
|
rb_entry != NULL;
|
|
rb_entry = g_slist_next(rb_entry)) {
|
|
button = rb_entry->data;
|
|
if (GTK_TOGGLE_BUTTON(button)->active)
|
|
break;
|
|
}
|
|
/* OK, now find that button's label. */
|
|
label = GTK_BIN(button)->child;
|
|
} else {
|
|
/* Get the label for the currently active entry in the option menu.
|
|
Yes, this is how you do it. See FAQ 6.8 in the GTK+ FAQ. */
|
|
label = GTK_BIN(pref->control)->child;
|
|
}
|
|
|
|
/* Get the label, and translate it to a value. */
|
|
gtk_label_get(GTK_LABEL(label), &label_string);
|
|
enumval = find_val_for_string(label_string,
|
|
pref->info.enum_info.enumvals, 1);
|
|
if (*pref->varp.enump != enumval) {
|
|
*pref_changed_p = TRUE;
|
|
*pref->varp.enump = enumval;
|
|
}
|
|
break;
|
|
|
|
case PREF_STRING:
|
|
str_val = gtk_entry_get_text(GTK_ENTRY(pref->control));
|
|
if (*pref->varp.string == NULL || strcmp(*pref->varp.string, str_val) != 0) {
|
|
*pref_changed_p = TRUE;
|
|
if (*pref->varp.string != NULL)
|
|
g_free(*pref->varp.string);
|
|
*pref->varp.string = g_strdup(str_val);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void
|
|
module_prefs_fetch(module_t *module, gpointer user_data)
|
|
{
|
|
gboolean *must_redissect_p = user_data;
|
|
|
|
/* For all preferences in this module, fetch its value from this
|
|
module's notebook page. Find out whether any of them changed. */
|
|
module->prefs_changed = FALSE; /* assume none of them changed */
|
|
prefs_pref_foreach(module, pref_fetch, &module->prefs_changed);
|
|
|
|
/* If any of them changed, indicate that we must redissect and refilter
|
|
the current capture (if we have one), as the preference change
|
|
could cause packets to be dissected differently. */
|
|
if (module->prefs_changed)
|
|
*must_redissect_p = TRUE;
|
|
}
|
|
|
|
static void
|
|
pref_clean(pref_t *pref, gpointer user_data)
|
|
{
|
|
switch (pref->type) {
|
|
|
|
case PREF_UINT:
|
|
break;
|
|
|
|
case PREF_BOOL:
|
|
break;
|
|
|
|
case PREF_ENUM:
|
|
break;
|
|
|
|
case PREF_STRING:
|
|
if (pref->saved_val.string != NULL) {
|
|
g_free(pref->saved_val.string);
|
|
pref->saved_val.string = NULL;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void
|
|
module_prefs_clean(module_t *module, gpointer user_data)
|
|
{
|
|
/* For all preferences in this module, clean up any cruft allocated for
|
|
use by the GUI code. */
|
|
prefs_pref_foreach(module, pref_clean, NULL);
|
|
}
|
|
|
|
static void
|
|
prefs_main_ok_cb(GtkWidget *ok_bt, gpointer parent_w)
|
|
{
|
|
gboolean must_redissect = FALSE;
|
|
|
|
/* Fetch the preferences (i.e., make sure all the values set in all of
|
|
the preferences panes have been copied to "prefs" and the registered
|
|
preferences). */
|
|
printer_prefs_fetch(gtk_object_get_data(GTK_OBJECT(parent_w), E_PRINT_PAGE_KEY));
|
|
column_prefs_fetch(gtk_object_get_data(GTK_OBJECT(parent_w), E_COLUMN_PAGE_KEY));
|
|
stream_prefs_fetch(gtk_object_get_data(GTK_OBJECT(parent_w), E_STREAM_PAGE_KEY));
|
|
gui_prefs_fetch(gtk_object_get_data(GTK_OBJECT(parent_w), E_GUI_PAGE_KEY));
|
|
prefs_module_foreach(module_prefs_fetch, &must_redissect);
|
|
|
|
/* Now apply those preferences. */
|
|
printer_prefs_apply(gtk_object_get_data(GTK_OBJECT(parent_w), E_PRINT_PAGE_KEY));
|
|
column_prefs_apply(gtk_object_get_data(GTK_OBJECT(parent_w), E_COLUMN_PAGE_KEY));
|
|
stream_prefs_apply(gtk_object_get_data(GTK_OBJECT(parent_w), E_STREAM_PAGE_KEY));
|
|
gui_prefs_apply(gtk_object_get_data(GTK_OBJECT(parent_w), E_GUI_PAGE_KEY));
|
|
prefs_apply_all();
|
|
|
|
/* Now destroy the "Preferences" dialog. */
|
|
gtk_widget_destroy(GTK_WIDGET(parent_w));
|
|
|
|
if (must_redissect) {
|
|
/* Redissect all the packets, and re-evaluate the display filter. */
|
|
redissect_packets(&cfile);
|
|
}
|
|
}
|
|
|
|
static void
|
|
prefs_main_apply_cb(GtkWidget *apply_bt, gpointer parent_w)
|
|
{
|
|
gboolean must_redissect = FALSE;
|
|
|
|
/* Fetch the preferences (i.e., make sure all the values set in all of
|
|
the preferences panes have been copied to "prefs" and the registered
|
|
preferences). */
|
|
printer_prefs_fetch(gtk_object_get_data(GTK_OBJECT(parent_w), E_PRINT_PAGE_KEY));
|
|
column_prefs_fetch(gtk_object_get_data(GTK_OBJECT(parent_w), E_COLUMN_PAGE_KEY));
|
|
stream_prefs_fetch(gtk_object_get_data(GTK_OBJECT(parent_w), E_STREAM_PAGE_KEY));
|
|
gui_prefs_fetch(gtk_object_get_data(GTK_OBJECT(parent_w), E_GUI_PAGE_KEY));
|
|
prefs_module_foreach(module_prefs_fetch, &must_redissect);
|
|
|
|
/* Now apply those preferences. */
|
|
printer_prefs_apply(gtk_object_get_data(GTK_OBJECT(parent_w), E_PRINT_PAGE_KEY));
|
|
column_prefs_apply(gtk_object_get_data(GTK_OBJECT(parent_w), E_COLUMN_PAGE_KEY));
|
|
stream_prefs_apply(gtk_object_get_data(GTK_OBJECT(parent_w), E_STREAM_PAGE_KEY));
|
|
gui_prefs_apply(gtk_object_get_data(GTK_OBJECT(parent_w), E_GUI_PAGE_KEY));
|
|
prefs_module_foreach(module_prefs_fetch, &must_redissect);
|
|
prefs_apply_all();
|
|
|
|
if (must_redissect) {
|
|
/* Redissect all the packets, and re-evaluate the display filter. */
|
|
redissect_packets(&cfile);
|
|
}
|
|
}
|
|
|
|
static void
|
|
prefs_main_save_cb(GtkWidget *save_bt, gpointer parent_w)
|
|
{
|
|
gboolean must_redissect = FALSE;
|
|
int err;
|
|
char *pf_dir_path;
|
|
const char *pf_path;
|
|
|
|
/* Fetch the preferences (i.e., make sure all the values set in all of
|
|
the preferences panes have been copied to "prefs" and the registered
|
|
preferences). */
|
|
printer_prefs_fetch(gtk_object_get_data(GTK_OBJECT(parent_w), E_PRINT_PAGE_KEY));
|
|
column_prefs_fetch(gtk_object_get_data(GTK_OBJECT(parent_w), E_COLUMN_PAGE_KEY));
|
|
stream_prefs_fetch(gtk_object_get_data(GTK_OBJECT(parent_w), E_STREAM_PAGE_KEY));
|
|
gui_prefs_fetch(gtk_object_get_data(GTK_OBJECT(parent_w), E_GUI_PAGE_KEY));
|
|
prefs_module_foreach(module_prefs_fetch, &must_redissect);
|
|
|
|
/* Create the directory that holds personal configuration files, if
|
|
necessary. */
|
|
if (create_persconffile_dir(&pf_dir_path) == -1) {
|
|
simple_dialog(ESD_TYPE_WARN, NULL,
|
|
"Can't create directory\n\"%s\"\nfor preferences file: %s.", pf_dir_path,
|
|
strerror(errno));
|
|
g_free(pf_dir_path);
|
|
} else {
|
|
/* Write the preferencs out. */
|
|
err = write_prefs(&pf_path);
|
|
if (err != 0) {
|
|
simple_dialog(ESD_TYPE_WARN, NULL,
|
|
"Can't open preferences file\n\"%s\": %s.", pf_path,
|
|
strerror(err));
|
|
}
|
|
}
|
|
|
|
/* Now apply those preferences.
|
|
XXX - should we do this? The user didn't click "OK" or "Apply".
|
|
However:
|
|
|
|
1) by saving the preferences they presumably indicate that they
|
|
like them;
|
|
|
|
2) the next time they fire Ethereal up, those preferences will
|
|
apply;
|
|
|
|
3) we'd have to buffer "must_redissect" so that if they do
|
|
"Apply" after this, we know we have to redissect;
|
|
|
|
4) we did apply the protocol preferences, at least, in the past. */
|
|
printer_prefs_apply(gtk_object_get_data(GTK_OBJECT(parent_w), E_PRINT_PAGE_KEY));
|
|
column_prefs_apply(gtk_object_get_data(GTK_OBJECT(parent_w), E_COLUMN_PAGE_KEY));
|
|
stream_prefs_apply(gtk_object_get_data(GTK_OBJECT(parent_w), E_STREAM_PAGE_KEY));
|
|
gui_prefs_apply(gtk_object_get_data(GTK_OBJECT(parent_w), E_GUI_PAGE_KEY));
|
|
prefs_module_foreach(module_prefs_fetch, &must_redissect);
|
|
prefs_apply_all();
|
|
|
|
if (must_redissect) {
|
|
/* Redissect all the packets, and re-evaluate the display filter. */
|
|
redissect_packets(&cfile);
|
|
}
|
|
}
|
|
|
|
static void
|
|
pref_revert(pref_t *pref, gpointer user_data)
|
|
{
|
|
gboolean *pref_changed_p = user_data;
|
|
|
|
/* Revert the preference to its saved value. */
|
|
switch (pref->type) {
|
|
|
|
case PREF_UINT:
|
|
if (*pref->varp.uint != pref->saved_val.uint) {
|
|
*pref_changed_p = TRUE;
|
|
*pref->varp.uint = pref->saved_val.uint;
|
|
}
|
|
break;
|
|
|
|
case PREF_BOOL:
|
|
if (*pref->varp.bool != pref->saved_val.bool) {
|
|
*pref_changed_p = TRUE;
|
|
*pref->varp.bool = pref->saved_val.bool;
|
|
}
|
|
break;
|
|
|
|
case PREF_ENUM:
|
|
if (*pref->varp.enump != pref->saved_val.enumval) {
|
|
*pref_changed_p = TRUE;
|
|
*pref->varp.enump = pref->saved_val.enumval;
|
|
}
|
|
break;
|
|
|
|
case PREF_STRING:
|
|
if (*pref->varp.string != pref->saved_val.string &&
|
|
(*pref->varp.string == NULL ||
|
|
pref->saved_val.string == NULL ||
|
|
strcmp(*pref->varp.string, pref->saved_val.string) != 0)) {
|
|
*pref_changed_p = TRUE;
|
|
if (*pref->varp.string != NULL)
|
|
g_free(*pref->varp.string);
|
|
*pref->varp.string = g_strdup(pref->saved_val.string);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void
|
|
module_prefs_revert(module_t *module, gpointer user_data)
|
|
{
|
|
gboolean *must_redissect_p = user_data;
|
|
|
|
/* For all preferences in this module, revert its value to the value
|
|
it had when we popped up the Preferences dialog. Find out whether
|
|
this changes any of them. */
|
|
module->prefs_changed = FALSE; /* assume none of them changed */
|
|
prefs_pref_foreach(module, pref_revert, &module->prefs_changed);
|
|
|
|
/* If any of them changed, indicate that we must redissect and refilter
|
|
the current capture (if we have one), as the preference change
|
|
could cause packets to be dissected differently. */
|
|
if (module->prefs_changed)
|
|
*must_redissect_p = TRUE;
|
|
}
|
|
|
|
static void
|
|
prefs_main_cancel_cb(GtkWidget *cancel_bt, gpointer parent_w)
|
|
{
|
|
gboolean must_redissect = FALSE;
|
|
|
|
/* Free up the current preferences and copy the saved preferences to the
|
|
current preferences. */
|
|
free_prefs(&prefs);
|
|
copy_prefs(&prefs, &saved_prefs);
|
|
|
|
/* Now revert the registered preferences. */
|
|
prefs_module_foreach(module_prefs_revert, &must_redissect);
|
|
|
|
/* Now apply the reverted-to preferences. */
|
|
printer_prefs_apply(gtk_object_get_data(GTK_OBJECT(parent_w), E_PRINT_PAGE_KEY));
|
|
column_prefs_apply(gtk_object_get_data(GTK_OBJECT(parent_w), E_COLUMN_PAGE_KEY));
|
|
stream_prefs_apply(gtk_object_get_data(GTK_OBJECT(parent_w), E_STREAM_PAGE_KEY));
|
|
gui_prefs_apply(gtk_object_get_data(GTK_OBJECT(parent_w), E_GUI_PAGE_KEY));
|
|
prefs_apply_all();
|
|
|
|
gtk_widget_destroy(GTK_WIDGET(parent_w));
|
|
|
|
if (must_redissect) {
|
|
/* Redissect all the packets, and re-evaluate the display filter. */
|
|
redissect_packets(&cfile);
|
|
}
|
|
}
|
|
|
|
/* Treat this as a cancel, by calling "prefs_main_cancel_cb()".
|
|
XXX - that'll destroy the Preferences dialog; will that upset
|
|
a higher-level handler that says "OK, we've been asked to delete
|
|
this, so destroy it"? */
|
|
static gboolean
|
|
prefs_main_delete_cb(GtkWidget *prefs_w, gpointer dummy)
|
|
{
|
|
prefs_main_cancel_cb(NULL, prefs_w);
|
|
return FALSE;
|
|
}
|
|
|
|
static void
|
|
prefs_main_destroy_cb(GtkWidget *win, gpointer user_data)
|
|
{
|
|
/* Let the preference tabs clean up anything they've done. */
|
|
printer_prefs_destroy(gtk_object_get_data(GTK_OBJECT(prefs_w), E_PRINT_PAGE_KEY));
|
|
column_prefs_destroy(gtk_object_get_data(GTK_OBJECT(prefs_w), E_COLUMN_PAGE_KEY));
|
|
stream_prefs_destroy(gtk_object_get_data(GTK_OBJECT(prefs_w), E_STREAM_PAGE_KEY));
|
|
gui_prefs_destroy(gtk_object_get_data(GTK_OBJECT(prefs_w), E_GUI_PAGE_KEY));
|
|
|
|
/* Free up the saved preferences (both for "prefs" and for registered
|
|
preferences). */
|
|
free_prefs(&saved_prefs);
|
|
prefs_module_foreach(module_prefs_clean, NULL);
|
|
|
|
/* Note that we no longer have a "Preferences" dialog box. */
|
|
prefs_w = NULL;
|
|
}
|
|
|
|
struct properties_data {
|
|
GtkWidget *w;
|
|
int page_num;
|
|
char *title;
|
|
};
|
|
|
|
/* XXX this way of searching the correct page number is really ugly ... */
|
|
static void
|
|
module_search_properties(module_t *module, gpointer user_data)
|
|
{
|
|
struct properties_data *p = (struct properties_data *)user_data;
|
|
|
|
if (p->title == NULL) return;
|
|
if (strcmp(module->title, p->title) == 0) {
|
|
/* found it */
|
|
gtk_notebook_set_page(GTK_NOTEBOOK(p->w), p->page_num);
|
|
p->title = NULL;
|
|
} else {
|
|
p->page_num++;
|
|
}
|
|
}
|
|
|
|
void
|
|
properties_cb(GtkWidget *w, gpointer dummy)
|
|
{
|
|
gchar *title = NULL;
|
|
struct properties_data p;
|
|
|
|
if (finfo_selected) {
|
|
header_field_info *hfinfo = finfo_selected->hfinfo;
|
|
if (hfinfo->parent == -1) {
|
|
title = (gchar *)prefs_get_title_by_name(hfinfo->abbrev);
|
|
} else {
|
|
title = (gchar *)
|
|
prefs_get_title_by_name(proto_registrar_get_abbrev(hfinfo->parent));
|
|
}
|
|
} else {
|
|
return;
|
|
}
|
|
|
|
if (!title) return;
|
|
|
|
if (prefs_w != NULL) {
|
|
reactivate_window(prefs_w);
|
|
} else {
|
|
prefs_cb(w, dummy);
|
|
}
|
|
|
|
p.w = notebook;
|
|
p.page_num = FIRST_PROTO_PREFS_PAGE;
|
|
p.title = title;
|
|
|
|
prefs_module_foreach(module_search_properties, &p);
|
|
|
|
}
|
|
|
|
/* Prefs tree selection callback. The node data has been loaded with
|
|
the proper notebook page to load. */
|
|
static void
|
|
prefs_tree_select_cb(GtkCTree *ct, GtkCTreeNode *node, gint col, gpointer dummy)
|
|
{
|
|
gint page = GPOINTER_TO_INT(gtk_ctree_node_get_row_data(ct, node));
|
|
|
|
if (page >= 0)
|
|
gtk_notebook_set_page(GTK_NOTEBOOK(notebook), page);
|
|
}
|
|
|