/* prefs_dlg.c
* Routines for handling preferences
*
- * $Id$
- *
* Wireshark - Network traffic analyzer
* By Gerald Combs <gerald@wireshark.org>
* Copyright 1998 Gerald Combs
#include <gtk/gtk.h>
+#include <stdlib.h>
#include <string.h>
#include <epan/packet.h>
#include <epan/prefs.h>
-#include <epan/strutil.h>
#include <epan/prefs-int.h>
#include <epan/epan_dissect.h>
+#include <epan/decode_as.h>
-#include "../file.h"
-#include "../print.h"
#include "ui/preference_utils.h"
-#include "ui/simple_dialog.h"
+#include "ui/gtk/old-gtk-compat.h"
#include "ui/gtk/main.h"
#include "ui/gtk/prefs_column.h"
#include "ui/gtk/prefs_dlg.h"
#include "ui/gtk/help_dlg.h"
#include "ui/gtk/keys.h"
#include "ui/gtk/uat_gui.h"
-#include "ui/gtk/old-gtk-compat.h"
#include "ui/gtk/file_dlg.h"
-#include "ui/gtk/dlg_utils.h"
+#include "ui/gtk/packet_win.h"
+#include "simple_dialog.h"
#ifdef HAVE_LIBPCAP
#ifdef _WIN32
-#include "capture-wpcap.h"
+#include <caputils/capture-wpcap.h>
#endif /* _WIN32 */
#ifdef HAVE_AIRPCAP
-#include "airpcap.h"
-#include "airpcap_loader.h"
+#include <caputils/airpcap.h>
+#include <caputils/airpcap_loader.h>
#include "airpcap_gui_utils.h"
#endif
#endif
static void prefs_main_destroy_cb(GtkWidget *, gpointer);
static void prefs_tree_select_cb(GtkTreeSelection *, gpointer);
-static GtkWidget *create_preference_filename_entry(GtkWidget *, int,
- const gchar *, const gchar *, char *);
+static GtkWidget *create_preference_path_entry(GtkWidget *, int,
+ const gchar *, const gchar *, char *, gboolean);
#define E_PREFSW_SCROLLW_KEY "prefsw_scrollw"
#define E_PREFSW_TREE_KEY "prefsw_tree"
static guint
pref_show(pref_t *pref, gpointer user_data)
{
- GtkWidget *main_grid = user_data;
- module_t *module = g_object_get_data(G_OBJECT(main_grid), E_GRID_MODULE_KEY);
+ GtkWidget *main_grid = (GtkWidget *)user_data;
+ module_t *module = (module_t *)g_object_get_data(G_OBJECT(main_grid), E_GRID_MODULE_KEY);
const char *title;
const char *type_name = prefs_pref_type_name(pref);
char *label_string;
size_t label_len;
- char uint_str[10+1];
+ char *uint_str;
char *tooltip_txt;
/* Give this preference a label which is its title, followed by a colon,
and left-align it. */
- title = pref->title;
+ title = prefs_get_title(pref);
label_len = strlen(title) + 2;
- label_string = g_malloc(label_len);
+ label_string = (char *)g_malloc(label_len);
g_strlcpy(label_string, title, label_len);
- tooltip_txt = pref->description? g_strdup_printf("%s.%s: %s\n%s",
+ tooltip_txt = prefs_get_description(pref) ? g_strdup_printf("%s\n\nName: %s.%s\nType: %s",
+ prefs_get_description(pref),
module->name,
- pref->name,
- type_name ? type_name : "Unknown",
- pref->description): NULL;
+ prefs_get_name(pref),
+ type_name ? type_name : "Unknown"
+ ): NULL;
/*
* Sometimes we don't want to append a ':' after a static text string...
* If it is needed, we will specify it in the string itself.
*/
- if (pref->type != PREF_STATIC_TEXT)
+ if (prefs_get_type(pref) != PREF_STATIC_TEXT)
g_strlcat(label_string, ":", label_len);
pref_stash(pref, NULL);
-
+
/* 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) {
+ switch (prefs_get_type(pref)) {
case PREF_UINT:
+ case PREF_DECODE_AS_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. */
- switch (pref->info.base) {
-
- case 10:
- g_snprintf(uint_str, sizeof(uint_str), "%u", pref->stashed_val.uint);
- break;
-
- case 8:
- g_snprintf(uint_str, sizeof(uint_str), "%o", pref->stashed_val.uint);
- break;
-
- case 16:
- g_snprintf(uint_str, sizeof(uint_str), "%x", pref->stashed_val.uint);
- break;
- }
- pref->control = create_preference_entry(main_grid, pref->ordinal,
+ uint_str = prefs_pref_to_str(pref, pref_stashed);
+ prefs_set_control(pref, create_preference_entry(main_grid, prefs_get_ordinal(pref),
label_string, tooltip_txt,
- uint_str);
+ uint_str));
+ g_free(uint_str);
break;
case PREF_BOOL:
- pref->control = create_preference_check_button(main_grid, pref->ordinal,
+ prefs_set_control(pref, create_preference_check_button(main_grid, prefs_get_ordinal(pref),
label_string, tooltip_txt,
- pref->stashed_val.boolval);
+ prefs_get_bool_value(pref, pref_stashed)));
break;
case PREF_ENUM:
- if (pref->info.enum_info.radio_buttons) {
+ if (prefs_get_enum_radiobuttons(pref)) {
/* Show it as radio buttons. */
- pref->control = create_preference_radio_buttons(main_grid, pref->ordinal,
+ prefs_set_control(pref, create_preference_radio_buttons(main_grid, prefs_get_ordinal(pref),
label_string, tooltip_txt,
- pref->info.enum_info.enumvals,
- pref->stashed_val.enumval);
+ prefs_get_enumvals(pref),
+ prefs_get_enum_value(pref, pref_stashed)));
} else {
/* Show it as an option menu. */
- pref->control = create_preference_option_menu(main_grid, pref->ordinal,
+ prefs_set_control(pref, create_preference_option_menu(main_grid, prefs_get_ordinal(pref),
label_string, tooltip_txt,
- pref->info.enum_info.enumvals,
- pref->stashed_val.enumval);
+ prefs_get_enumvals(pref),
+ prefs_get_enum_value(pref, pref_stashed)));
}
break;
case PREF_STRING:
- pref->control = create_preference_entry(main_grid, pref->ordinal,
+ prefs_set_control(pref, create_preference_entry(main_grid, prefs_get_ordinal(pref),
label_string, tooltip_txt,
- pref->stashed_val.string);
+ prefs_get_string_value(pref, pref_stashed)));
break;
case PREF_FILENAME:
- pref->control = create_preference_filename_entry(main_grid, pref->ordinal,
+ prefs_set_control(pref, create_preference_path_entry(main_grid, prefs_get_ordinal(pref),
+ label_string,
+ tooltip_txt,
+ prefs_get_string_value(pref, pref_stashed), FALSE));
+ break;
+
+ case PREF_DIRNAME:
+ prefs_set_control(pref, create_preference_path_entry(main_grid, prefs_get_ordinal(pref),
label_string,
tooltip_txt,
- pref->stashed_val.string);
+ prefs_get_string_value(pref, pref_stashed), TRUE));
break;
case PREF_RANGE:
+ case PREF_DECODE_AS_RANGE:
{
char *range_str_p;
- range_str_p = range_convert_range(*pref->varp.range);
- pref->control = create_preference_entry(main_grid, pref->ordinal,
+ range_str_p = range_convert_range(NULL, prefs_get_range_value_real(pref, pref_current));
+ prefs_set_control(pref, create_preference_entry(main_grid, prefs_get_ordinal(pref),
label_string, tooltip_txt,
- range_str_p);
+ range_str_p));
+ wmem_free(NULL, range_str_p);
break;
}
case PREF_STATIC_TEXT:
{
- pref->control = create_preference_static_text(main_grid, pref->ordinal,
- label_string, tooltip_txt);
+ prefs_set_control(pref, create_preference_static_text(main_grid, prefs_get_ordinal(pref),
+ label_string, tooltip_txt));
break;
}
case PREF_UAT:
{
- pref->control = create_preference_uat(main_grid, pref->ordinal,
- label_string, tooltip_txt,
- pref->varp.uat);
+ if (prefs_get_gui_type(pref) == GUI_ALL || prefs_get_gui_type(pref) == GUI_GTK)
+ prefs_set_control(pref, create_preference_uat(main_grid, prefs_get_ordinal(pref),
+ label_string, tooltip_txt,
+ prefs_get_uat_value(pref)));
break;
}
{
prefs_tree_iter iter;
- gtk_tree_store_append(store, &iter, parent_iter);
- gtk_tree_store_set(store, &iter, 0, title, 1, page_nr, -1);
+ gtk_tree_store_append((GtkTreeStore *)store, &iter, parent_iter);
+ gtk_tree_store_set((GtkTreeStore *)store, &iter, 0, title, 1, page_nr, -1);
return iter;
}
frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_NONE);
gtk_container_set_border_width(GTK_CONTAINER(frame), DLG_OUTER_MARGIN);
+#if ! GTK_CHECK_VERSION(3,8,0)
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(sw), frame);
+#else
+ gtk_container_add(GTK_CONTAINER(sw), frame);
+#endif
gtk_widget_show(frame);
if (page) {
static guint
module_prefs_show(module_t *module, gpointer user_data)
{
- struct ct_struct *cts = user_data;
+ struct ct_struct *cts = (struct ct_struct *)user_data;
struct ct_struct child_cts;
GtkWidget *main_vb, *main_grid, *frame, *main_sw;
gchar label_str[MAX_TREE_NODE_NAME_LEN];
frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_NONE);
gtk_container_set_border_width(GTK_CONTAINER(frame), DLG_OUTER_MARGIN);
+#if ! GTK_CHECK_VERSION(3,8,0)
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(main_sw), frame);
+#else
+ gtk_container_add(GTK_CONTAINER(main_sw), frame);
+#endif
g_object_set_data(G_OBJECT(main_sw), E_PAGESW_FRAME_KEY, frame);
/* Main vertical box */
/* Main grid */
main_grid = ws_gtk_grid_new();
gtk_box_pack_start(GTK_BOX(main_vb), main_grid, FALSE, FALSE, 0);
+#if GTK_CHECK_VERSION(3,0,0)
+ gtk_widget_set_vexpand(GTK_WIDGET(main_grid), FALSE); /* Ignore VEXPAND requests from children */
+#endif
ws_gtk_grid_set_row_spacing(GTK_GRID(main_grid), 10);
ws_gtk_grid_set_column_spacing(GTK_GRID(main_grid), 15);
prefs_tree_page_add(label_str, cts.page, store, &gui_iter);
cts.page++;
- /* select the main GUI page as the default page and expand it's children */
+ /* select the main GUI page as the default page and expand its children */
gtk_tree_selection_select_iter(selection, &gui_iter);
/* (expand will only take effect, when at least one child exists) */
gtk_tree_view_expand_all(GTK_TREE_VIEW(cts.tree));
gtk_box_pack_start(GTK_BOX(cts.main_vb), bbox, FALSE, FALSE, 0);
gtk_widget_show(bbox);
- ok_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_OK);
+ ok_bt = (GtkWidget *)g_object_get_data(G_OBJECT(bbox), GTK_STOCK_OK);
g_signal_connect(ok_bt, "clicked", G_CALLBACK(prefs_main_ok_cb), prefs_w);
- apply_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_APPLY);
+ apply_bt = (GtkWidget *)g_object_get_data(G_OBJECT(bbox), GTK_STOCK_APPLY);
g_signal_connect(apply_bt, "clicked", G_CALLBACK(prefs_main_apply_cb), prefs_w);
- save_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_SAVE);
+ save_bt = (GtkWidget *)g_object_get_data(G_OBJECT(bbox), GTK_STOCK_SAVE);
g_signal_connect(save_bt, "clicked", G_CALLBACK(prefs_main_save_cb), prefs_w);
g_object_set_data(G_OBJECT(prefs_w), E_PREFSW_SAVE_BT_KEY, save_bt);
- cancel_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_CANCEL);
+ cancel_bt = (GtkWidget *)g_object_get_data(G_OBJECT(bbox), GTK_STOCK_CANCEL);
g_signal_connect(cancel_bt, "clicked", G_CALLBACK(prefs_main_cancel_cb), prefs_w);
window_set_cancel_button(prefs_w, cancel_bt, NULL);
gtk_widget_grab_default(ok_bt);
- help_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_HELP);
+ help_bt = (GtkWidget *)g_object_get_data(G_OBJECT(bbox), GTK_STOCK_HELP);
g_signal_connect(help_bt, "clicked", G_CALLBACK(topic_cb), (gpointer)HELP_PREFERENCES_DIALOG);
g_signal_connect(prefs_w, "delete_event", G_CALLBACK(prefs_main_delete_event_cb), NULL);
switch (prefs_page) {
case PREFS_PAGE_LAYOUT:
gtk_tree_selection_select_iter(selection, &layout_iter);
- gtk_notebook_set_current_page(g_object_get_data(G_OBJECT(prefs_w), E_PREFSW_NOTEBOOK_KEY), layout_page);
+ gtk_notebook_set_current_page((GtkNotebook *)g_object_get_data(G_OBJECT(prefs_w), E_PREFSW_NOTEBOOK_KEY), layout_page);
break;
case PREFS_PAGE_COLUMNS:
gtk_tree_selection_select_iter(selection, &columns_iter);
- gtk_notebook_set_current_page(g_object_get_data(G_OBJECT(prefs_w), E_PREFSW_NOTEBOOK_KEY), columns_page);
+ gtk_notebook_set_current_page((GtkNotebook *)g_object_get_data(G_OBJECT(prefs_w), E_PREFSW_NOTEBOOK_KEY), columns_page);
break;
case PREFS_PAGE_CAPTURE:
if (capture_page) {
gtk_tree_selection_select_iter(selection, &capture_iter);
- gtk_notebook_set_current_page(g_object_get_data(G_OBJECT(prefs_w), E_PREFSW_NOTEBOOK_KEY), capture_page);
+ gtk_notebook_set_current_page((GtkNotebook *)g_object_get_data(G_OBJECT(prefs_w), E_PREFSW_NOTEBOOK_KEY), capture_page);
}
break;
default:
button = NULL;
for (rb_entry = rb_group; rb_entry != NULL;
rb_entry = g_slist_next(rb_entry)) {
- button = rb_entry->data;
+ button = (GtkWidget *)rb_entry->data;
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button)))
break;
}
preference_filename_entry_cb(GtkWidget *button, GtkWidget *filename_te)
{
/* XXX - use a better browser dialog title */
- file_selection_browse(button, filename_te, "Wireshark: file preference",
+ file_selection_browse(button, filename_te, "Wireshark: File preference",
FILE_SELECTION_READ_BROWSE);
}
+static void
+preference_dirname_entry_cb(GtkWidget *button, GtkWidget *filename_te)
+{
+ /* XXX - use a better browser dialog title */
+ file_selection_browse(button, filename_te, "Wireshark: Directory preference",
+ FILE_SELECTION_CREATE_FOLDER);
+}
+
static GtkWidget *
-create_preference_filename_entry(GtkWidget *main_grid, int grid_position,
- const gchar *label_text, const gchar *tooltip_text, char *value)
+create_preference_path_entry(GtkWidget *main_grid, int grid_position,
+ const gchar *label_text, const gchar *tooltip_text, char *value, gboolean dir_only)
{
GtkWidget *entry;
GtkWidget *button, *file_bt_hb;
ws_gtk_grid_attach_defaults(GTK_GRID(main_grid), file_bt_hb, 1, grid_position, 1, 1);
gtk_widget_show(file_bt_hb);
- button = gtk_button_new_from_stock(WIRESHARK_STOCK_BROWSE);
+ button = ws_gtk_button_new_from_stock(WIRESHARK_STOCK_BROWSE);
gtk_box_pack_end(GTK_BOX(file_bt_hb), button, FALSE, FALSE, 0);
gtk_widget_show(button);
gtk_widget_set_tooltip_text(entry, tooltip_text);
gtk_widget_show(entry);
- g_signal_connect(button, "clicked", G_CALLBACK(preference_filename_entry_cb), entry);
-
+ if (dir_only) {
+ g_signal_connect(button, "clicked", G_CALLBACK(preference_dirname_entry_cb), entry);
+ } else {
+ g_signal_connect(button, "clicked", G_CALLBACK(preference_filename_entry_cb), entry);
+ }
return entry;
}
{
GtkWidget *label;
- if (label_text != NULL)
+ if (label_text != NULL) {
label = gtk_label_new(label_text);
- else
+ gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
+ gtk_label_set_width_chars (GTK_LABEL (label), 80);
+ } else {
label = gtk_label_new("");
+ }
ws_gtk_grid_attach_defaults(GTK_GRID(main_grid), label, 0, grid_position, 2, 1);
if (tooltip_text != NULL)
gtk_widget_set_tooltip_text(label, tooltip_text);
set_option_label(main_grid, grid_position, label_text, tooltip_text);
- button = gtk_button_new_from_stock(WIRESHARK_STOCK_EDIT);
+ button = ws_gtk_button_new_from_stock(WIRESHARK_STOCK_EDIT);
g_signal_connect(button, "clicked", G_CALLBACK(uat_window_cb), uat);
{
const char *str_val;
char *p;
- pref_t **badpref = user_data;
+ pref_t **badpref = (pref_t **)user_data;
/* Fetch the value of the preference, and check whether it's valid. */
- switch (pref->type) {
+ switch (prefs_get_type(pref)) {
case PREF_UINT:
- str_val = gtk_entry_get_text(GTK_ENTRY(pref->control));
+ case PREF_DECODE_AS_UINT:
+ str_val = gtk_entry_get_text(GTK_ENTRY(prefs_get_control(pref)));
errno = 0;
/* XXX: The following ugly hack prevents a gcc warning
and thus avoiding the need to check whether it's a valid number, would also be a good idea."
]
*/
- if (strtoul(str_val, &p, pref->info.base)){}
+ if (strtoul(str_val, &p, prefs_get_uint_base(pref))){}
if (p == str_val || *p != '\0' || errno != 0) {
*badpref = pref;
return PREFS_SET_SYNTAX_ERR; /* number was bad */
case PREF_STRING:
case PREF_FILENAME:
+ case PREF_DIRNAME:
/* Value can't be bad. */
break;
case PREF_RANGE:
- str_val = gtk_entry_get_text(GTK_ENTRY(pref->control));
+ case PREF_DECODE_AS_RANGE:
+ str_val = gtk_entry_get_text(GTK_ENTRY(prefs_get_control(pref)));
if (strlen(str_val) != 0) {
range_t *newrange;
- if (range_convert_str(&newrange, str_val, pref->info.max_value) != CVT_NO_ERROR) {
+ if (range_convert_str(NULL, &newrange, str_val, prefs_get_max_value(pref)) != CVT_NO_ERROR) {
*badpref = pref;
+ wmem_free(NULL, newrange);
return PREFS_SET_SYNTAX_ERR; /* range was bad */
}
- g_free(newrange);
+ wmem_free(NULL, newrange);
}
break;
{
const char *str_val;
char *p;
- guint uval;
+ guint uval, uval_stashed;
gboolean bval;
gint enumval;
- gboolean *pref_changed_p = user_data;
+ module_t *module = (module_t *)user_data;
+ pref_unstash_data_t unstash_data;
/* Fetch the value of the preference, and set the appropriate variable
to it. */
- switch (pref->type) {
+ switch (prefs_get_type(pref)) {
+
+ case PREF_DECODE_AS_UINT:
+ str_val = gtk_entry_get_text(GTK_ENTRY(prefs_get_control(pref)));
+ uval = (guint)strtoul(str_val, &p, prefs_get_uint_base(pref));
+#if 0
+ if (p == value || *p != '\0')
+ return PREFS_SET_SYNTAX_ERR; /* number was bad */
+#endif
+ /* Save stashed value to use pref_unstash and restore it later */
+ uval_stashed = prefs_get_uint_value_real(pref, pref_stashed);
+ prefs_set_uint_value(pref, uval, pref_stashed);
+
+ unstash_data.module = module;
+ unstash_data.handle_decode_as = TRUE;
+ pref_unstash(pref, (gpointer)&unstash_data);
+
+ /* Restore stashed value */
+ prefs_set_uint_value(pref, uval_stashed, pref_stashed);
+ break;
case PREF_UINT:
- str_val = gtk_entry_get_text(GTK_ENTRY(pref->control));
- uval = (guint)strtoul(str_val, &p, pref->info.base);
+ str_val = gtk_entry_get_text(GTK_ENTRY(prefs_get_control(pref)));
+ uval = (guint)strtoul(str_val, &p, prefs_get_uint_base(pref));
#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;
- }
+ module->prefs_changed |= prefs_set_uint_value(pref, uval, pref_current);
break;
case PREF_BOOL:
- bval = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(pref->control));
- if (*pref->varp.boolp != bval) {
- *pref_changed_p = TRUE;
- *pref->varp.boolp = bval;
- }
+ bval = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(prefs_get_control(pref)));
+ module->prefs_changed |= prefs_set_bool_value(pref, bval, pref_current);
break;
case PREF_ENUM:
- if (pref->info.enum_info.radio_buttons) {
- enumval = fetch_preference_radio_buttons_val(pref->control,
- pref->info.enum_info.enumvals);
+ if (prefs_get_enum_radiobuttons(pref)) {
+ enumval = fetch_preference_radio_buttons_val((GtkWidget *)prefs_get_control(pref),
+ prefs_get_enumvals(pref));
} else {
- enumval = fetch_preference_option_menu_val(pref->control,
- pref->info.enum_info.enumvals);
+ enumval = fetch_preference_option_menu_val((GtkWidget *)prefs_get_control(pref),
+ prefs_get_enumvals(pref));
}
- if (*pref->varp.enump != enumval) {
- *pref_changed_p = TRUE;
- *pref->varp.enump = enumval;
- }
+ module->prefs_changed |= prefs_set_enum_value(pref, enumval, pref_current);
break;
case PREF_STRING:
case PREF_FILENAME:
- str_val = gtk_entry_get_text(GTK_ENTRY(pref->control));
- if (strcmp(*pref->varp.string, str_val) != 0) {
- *pref_changed_p = TRUE;
- g_free((void *)*pref->varp.string);
- *pref->varp.string = g_strdup(str_val);
- }
+ case PREF_DIRNAME:
+ str_val = gtk_entry_get_text(GTK_ENTRY(prefs_get_control(pref)));
+ module->prefs_changed |= prefs_set_string_value(pref, str_val, pref_current);
break;
- case PREF_RANGE:
- {
- range_t *newrange;
- convert_ret_t ret;
+ case PREF_DECODE_AS_RANGE:
+ {
+ str_val = gtk_entry_get_text(GTK_ENTRY(prefs_get_control(pref)));
- str_val = gtk_entry_get_text(GTK_ENTRY(pref->control));
- ret = range_convert_str(&newrange, str_val, pref->info.max_value);
- if (ret != CVT_NO_ERROR)
+ module->prefs_changed |= prefs_set_stashed_range_value(pref, str_val);
+
+ unstash_data.module = module;
+ unstash_data.handle_decode_as = TRUE;
+ pref_unstash(pref, (gpointer)&unstash_data);
+ break;
+ }
+ case PREF_RANGE:
+ str_val = gtk_entry_get_text(GTK_ENTRY(prefs_get_control(pref)));
+ if (!prefs_set_range_value_work(pref, str_val, TRUE, &module->prefs_changed))
#if 0
return PREFS_SET_SYNTAX_ERR; /* range was bad */
#else
return 0; /* XXX - should fail */
#endif
- if (!ranges_are_equal(*pref->varp.range, newrange)) {
- *pref_changed_p = TRUE;
- g_free(*pref->varp.range);
- *pref->varp.range = newrange;
- } else
- g_free(newrange);
-
break;
- }
case PREF_STATIC_TEXT:
case PREF_UAT:
static guint
module_prefs_fetch(module_t *module, gpointer user_data)
{
- gboolean *must_redissect_p = user_data;
+ gboolean *must_redissect_p = (gboolean *)user_data;
/* Ignore any preferences with their own interface */
if (!module->use_gui) {
/* 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);
+ prefs_pref_foreach(module, pref_fetch, module);
/* If any of them changed, indicate that we must redissect and refilter
the current capture (if we have one), as the preference change
/* XXX - check the non-registered preferences too */
switch (prefs_modules_foreach(module_prefs_check, (gpointer)&badpref)) {
- case PREFS_SET_SYNTAX_ERR:
- switch (badpref->type) {
+ case PREFS_SET_SYNTAX_ERR:
+ switch (prefs_get_type(badpref)) {
case PREF_UINT:
+ case PREF_DECODE_AS_UINT:
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
"The value for \"%s\" isn't a valid number.",
- badpref->title);
+ prefs_get_title(badpref));
return FALSE;
case PREF_RANGE:
+ case PREF_DECODE_AS_RANGE:
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
"The value for \"%s\" isn't a valid range.",
- badpref->title);
+ prefs_get_title(badpref));
return FALSE;
default:
/* 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). */
- gui_prefs_fetch(g_object_get_data(G_OBJECT(dlg), E_GUI_PAGE_KEY));
- layout_prefs_fetch(g_object_get_data(G_OBJECT(dlg), E_GUI_LAYOUT_PAGE_KEY));
- column_prefs_fetch(g_object_get_data(G_OBJECT(dlg), E_GUI_COLUMN_PAGE_KEY));
- font_color_prefs_fetch(g_object_get_data(G_OBJECT(dlg), E_GUI_FONT_COLORS_PAGE_KEY));
+ gui_prefs_fetch((GtkWidget *)g_object_get_data(G_OBJECT(dlg), E_GUI_PAGE_KEY));
+ layout_prefs_fetch((GtkWidget *)g_object_get_data(G_OBJECT(dlg), E_GUI_LAYOUT_PAGE_KEY));
+ column_prefs_fetch((GtkWidget *)g_object_get_data(G_OBJECT(dlg), E_GUI_COLUMN_PAGE_KEY));
+ font_color_prefs_fetch((GtkWidget *)g_object_get_data(G_OBJECT(dlg), E_GUI_FONT_COLORS_PAGE_KEY));
#ifdef HAVE_LIBPCAP
#ifdef _WIN32
/* Is WPcap loaded? */
if (has_wpcap) {
#endif /* _WIN32 */
- capture_prefs_fetch(g_object_get_data(G_OBJECT(dlg), E_CAPTURE_PAGE_KEY));
+ capture_prefs_fetch((GtkWidget *)g_object_get_data(G_OBJECT(dlg), E_CAPTURE_PAGE_KEY));
#ifdef _WIN32
}
#endif /* _WIN32 */
#endif /* HAVE_LIBPCAP */
- filter_expressions_prefs_fetch(g_object_get_data(G_OBJECT(dlg),
+ filter_expressions_prefs_fetch((GtkWidget *)g_object_get_data(G_OBJECT(dlg),
E_FILTER_EXPRESSIONS_PAGE_KEY));
prefs_modules_foreach(module_prefs_fetch, must_redissect);
*/
prefs_apply_all();
- gui_prefs_apply(g_object_get_data(G_OBJECT(dlg), E_GUI_PAGE_KEY));
- layout_prefs_apply(g_object_get_data(G_OBJECT(dlg), E_GUI_LAYOUT_PAGE_KEY));
- column_prefs_apply(g_object_get_data(G_OBJECT(dlg), E_GUI_COLUMN_PAGE_KEY));
- font_color_prefs_apply(g_object_get_data(G_OBJECT(dlg), E_GUI_FONT_COLORS_PAGE_KEY), redissect);
+ gui_prefs_apply((GtkWidget *)g_object_get_data(G_OBJECT(dlg), E_GUI_PAGE_KEY));
+ layout_prefs_apply((GtkWidget *)g_object_get_data(G_OBJECT(dlg), E_GUI_LAYOUT_PAGE_KEY));
+ column_prefs_apply((GtkWidget *)g_object_get_data(G_OBJECT(dlg), E_GUI_COLUMN_PAGE_KEY));
+ font_color_prefs_apply((GtkWidget *)g_object_get_data(G_OBJECT(dlg), E_GUI_FONT_COLORS_PAGE_KEY), redissect);
#ifdef HAVE_LIBPCAP
#ifdef _WIN32
/* Is WPcap loaded? */
if (has_wpcap) {
#endif /* _WIN32 */
- capture_prefs_apply(g_object_get_data(G_OBJECT(dlg), E_CAPTURE_PAGE_KEY));
+ capture_prefs_apply((GtkWidget *)g_object_get_data(G_OBJECT(dlg), E_CAPTURE_PAGE_KEY));
#ifdef _WIN32
}
#endif /* _WIN32 */
#endif /* HAVE_LIBPCAP */
/* show/hide the Save button - depending on setting */
- save_bt = g_object_get_data(G_OBJECT(prefs_w), E_PREFSW_SAVE_BT_KEY);
+ save_bt = (GtkWidget *)g_object_get_data(G_OBJECT(prefs_w), E_PREFSW_SAVE_BT_KEY);
if (prefs.gui_use_pref_save) {
gtk_widget_show(save_bt);
} else {
GtkWidget *frame;
for (page_num = 0;
- (frame = gtk_notebook_get_nth_page(g_object_get_data(G_OBJECT(prefs_w), E_PREFSW_NOTEBOOK_KEY), page_num)) != NULL;
+ (frame = gtk_notebook_get_nth_page((GtkNotebook *)g_object_get_data(G_OBJECT(prefs_w), E_PREFSW_NOTEBOOK_KEY), page_num)) != NULL;
page_num++) {
if (g_object_get_data(G_OBJECT(frame), E_PAGE_ITER_KEY))
- gtk_tree_iter_free(g_object_get_data(G_OBJECT(frame), E_PAGE_ITER_KEY));
+ gtk_tree_iter_free((GtkTreeIter *)g_object_get_data(G_OBJECT(frame), E_PAGE_ITER_KEY));
}
- gui_prefs_destroy(g_object_get_data(G_OBJECT(dlg), E_GUI_PAGE_KEY));
- layout_prefs_destroy(g_object_get_data(G_OBJECT(dlg), E_GUI_LAYOUT_PAGE_KEY));
- column_prefs_destroy(g_object_get_data(G_OBJECT(dlg), E_GUI_COLUMN_PAGE_KEY));
- font_color_prefs_destroy(g_object_get_data(G_OBJECT(dlg), E_GUI_FONT_COLORS_PAGE_KEY));
+ gui_prefs_destroy((GtkWidget *)g_object_get_data(G_OBJECT(dlg), E_GUI_PAGE_KEY));
+ layout_prefs_destroy((GtkWidget *)g_object_get_data(G_OBJECT(dlg), E_GUI_LAYOUT_PAGE_KEY));
+ column_prefs_destroy((GtkWidget *)g_object_get_data(G_OBJECT(dlg), E_GUI_COLUMN_PAGE_KEY));
+ font_color_prefs_destroy((GtkWidget *)g_object_get_data(G_OBJECT(dlg), E_GUI_FONT_COLORS_PAGE_KEY));
#ifdef HAVE_LIBPCAP
#ifdef _WIN32
/* Is WPcap loaded? */
if (has_wpcap) {
#endif /* _WIN32 */
- capture_prefs_destroy(g_object_get_data(G_OBJECT(dlg), E_CAPTURE_PAGE_KEY));
+ capture_prefs_destroy((GtkWidget *)g_object_get_data(G_OBJECT(dlg), E_CAPTURE_PAGE_KEY));
#ifdef _WIN32
}
#endif /* _WIN32 */
prefs_modules_foreach(module_prefs_copy, NULL);
}
+static void
+overwrite_existing_prefs_cb(gpointer dialog _U_, gint btn, gpointer parent_w _U_)
+{
+ gchar* err = NULL;
+
+ switch (btn) {
+ case(ESD_BTN_SAVE):
+ prefs_main_write();
+ prefs.unknown_prefs = FALSE;
+
+ if (save_decode_as_entries(&err) < 0)
+ {
+ simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", err);
+ g_free(err);
+ }
+ break;
+ case(ESD_BTN_DONT_SAVE):
+ break;
+ default:
+ g_assert_not_reached();
+ }
+}
+static void
+prefs_main_save(gpointer parent_w)
+{
+ gchar* err = NULL;
+
+ if (prefs.unknown_prefs) {
+ gpointer dialog;
+ const gchar *msg =
+ "Obsolete or unrecognized preferences have been detected and will be "
+ "discarded when saving this profile. If you would like to preserve "
+ "these preferences for a different Wireshark version, click "
+ "'Continue without Saving' and save this profile under a different name.";
+
+ if (prefs.saved_at_version) {
+ dialog = simple_dialog(ESD_TYPE_CONFIRMATION, ESD_BTNS_SAVE_DONTSAVE,
+ "These preferences were last saved at version \"%s\".\n%s",
+ prefs.saved_at_version, msg);
+ } else {
+ dialog = simple_dialog(ESD_TYPE_CONFIRMATION, ESD_BTNS_SAVE_DONTSAVE,
+ "%s", msg);
+ }
+
+ simple_dialog_set_cb(dialog, overwrite_existing_prefs_cb, parent_w);
+ } else {
+ prefs_main_write();
+
+ if (save_decode_as_entries(&err) < 0)
+ {
+ simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", err);
+ g_free(err);
+ }
+ }
+}
+
static void
prefs_main_ok_cb(GtkWidget *ok_bt _U_, gpointer parent_w)
{
gboolean must_redissect = FALSE;
- if (!prefs_main_fetch_all(parent_w, &must_redissect))
+ if (!prefs_main_fetch_all((GtkWidget *)parent_w, &must_redissect))
return; /* Errors in some preference setting - already reported */
/* if we don't have a Save button, just save the settings now */
if (!prefs.gui_use_pref_save) {
- prefs_main_write();
+ prefs_main_save(parent_w);
}
#ifdef HAVE_AIRPCAP
* Load the Wireshark decryption keys (just set) and save
* the changes to the adapters' registry
*/
- airpcap_load_decryption_keys(airpcap_if_list);
+ airpcap_load_decryption_keys(g_airpcap_if_list);
#endif
- prefs_main_apply_all(parent_w, must_redissect);
+ prefs_main_apply_all((GtkWidget *)parent_w, must_redissect);
/* Fill in capture options with values from the preferences */
prefs_to_capture_opts();
if (must_redissect) {
/* Redissect all the packets, and re-evaluate the display filter. */
redissect_packets();
+ redissect_all_packet_windows();
}
}
{
gboolean must_redissect = FALSE;
- if (!prefs_main_fetch_all(parent_w, &must_redissect))
+ if (!prefs_main_fetch_all((GtkWidget *)parent_w, &must_redissect))
return; /* Errors in some preference setting - already reported */
/* if we don't have a Save button, just save the settings now */
if (!prefs.gui_use_pref_save) {
- prefs_main_write();
+ prefs_main_save(parent_w);
prefs_copy(); /* save prefs for reverting if Cancel */
}
- prefs_main_apply_all(parent_w, must_redissect);
+ prefs_main_apply_all((GtkWidget *)parent_w, must_redissect);
/* Fill in capture options with values from the preferences */
prefs_to_capture_opts();
if (must_redissect) {
/* Redissect all the packets, and re-evaluate the display filter. */
redissect_packets();
+ redissect_all_packet_windows();
}
}
{
gboolean must_redissect = FALSE;
- if (!prefs_main_fetch_all(parent_w, &must_redissect))
+ if (!prefs_main_fetch_all((GtkWidget *)parent_w, &must_redissect))
return; /* Errors in some preference setting - already reported */
- prefs_main_write();
+ prefs_main_save(parent_w);
prefs_copy(); /* save prefs for reverting if Cancel */
/* Now apply those preferences.
"Apply" after this, we know we have to redissect;
4) we did apply the protocol preferences, at least, in the past. */
- prefs_main_apply_all(parent_w, must_redissect);
+ prefs_main_apply_all((GtkWidget *)parent_w, must_redissect);
/* Fill in capture options with values from the preferences */
prefs_to_capture_opts();
if (must_redissect) {
/* Redissect all the packets, and re-evaluate the display filter. */
redissect_packets();
+ redissect_all_packet_windows();
}
}
static guint
module_prefs_revert(module_t *module, gpointer user_data)
{
- gboolean *must_redissect_p = user_data;
+ gboolean *must_redissect_p = (gboolean *)user_data;
+ pref_unstash_data_t unstashed_data;
/* Ignore any preferences with their own interface */
if (!module->use_gui) {
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_unstash, &module->prefs_changed);
+ unstashed_data.module = module;
+ unstashed_data.handle_decode_as = FALSE;
+ prefs_pref_foreach(module, pref_unstash, &unstashed_data);
/* If any of them changed, indicate that we must redissect and refilter
the current capture (if we have one), as the preference change
prefs_modules_foreach(module_prefs_revert, &must_redissect);
/* Now apply the reverted-to preferences. */
- prefs_main_apply_all(parent_w, must_redissect);
+ prefs_main_apply_all((GtkWidget *)parent_w, must_redissect);
window_destroy(GTK_WIDGET(parent_w));
if (must_redissect) {
/* Redissect all the packets, and re-evaluate the display filter. */
redissect_packets();
+ redissect_all_packet_windows();
}
}
static void
prefs_main_destroy_cb(GtkWidget *win _U_, gpointer parent_w)
{
- prefs_main_destroy_all(parent_w);
+ prefs_main_destroy_all((GtkWidget *)parent_w);
/* Note that we no longer have a "Preferences" dialog box. */
prefs_w = NULL;
for (i = ga->len - 1; i > 0 ; i -= 1) {
- v = g_ptr_array_index (ga, i);
+ v = (field_info *)g_ptr_array_index (ga, i);
hfinfo = v->hfinfo;
if (!g_str_has_prefix(hfinfo->abbrev, "text") &&
- !g_str_has_prefix(hfinfo->abbrev, "expert") &&
- !g_str_has_prefix(hfinfo->abbrev, "malformed")) {
+ !g_str_has_prefix(hfinfo->abbrev, "_ws.expert") &&
+ !g_str_has_prefix(hfinfo->abbrev, "_ws.malformed")) {
if (hfinfo->parent == -1) {
abbrev = hfinfo->abbrev;
} else {
/* Search all the pages in that window for the one with the specified
module. */
for (page_num = 0;
- (sw = gtk_notebook_get_nth_page(g_object_get_data(G_OBJECT(prefs_w), E_PREFSW_NOTEBOOK_KEY), page_num)) != NULL;
+ (sw = gtk_notebook_get_nth_page((GtkNotebook *)g_object_get_data(G_OBJECT(prefs_w), E_PREFSW_NOTEBOOK_KEY), page_num)) != NULL;
page_num++) {
/* Get the frame from the scrollable window */
- frame = g_object_get_data(G_OBJECT(sw), E_PAGESW_FRAME_KEY);
+ frame = (GtkWidget *)g_object_get_data(G_OBJECT(sw), E_PAGESW_FRAME_KEY);
/* Get the module for this page (non-protocol prefs don't have one). */
if (frame) {
- page_module = g_object_get_data(G_OBJECT(frame), E_PAGE_MODULE_KEY);
+ page_module = (module_t *)g_object_get_data(G_OBJECT(frame), E_PAGE_MODULE_KEY);
if (page_module != NULL) {
if (page_module == p.module) {
tree_select_node(
- g_object_get_data(G_OBJECT(prefs_w), E_PREFSW_TREE_KEY),
- g_object_get_data(G_OBJECT(frame), E_PAGE_ITER_KEY));
+ (GtkWidget *)g_object_get_data(G_OBJECT(prefs_w), E_PREFSW_TREE_KEY),
+ (GtkTreeIter *)g_object_get_data(G_OBJECT(frame), E_PAGE_ITER_KEY));
return;
}
}
{
gtk_tree_model_get(model, &iter, 1, &page, -1);
if (page >= 0)
- gtk_notebook_set_current_page(g_object_get_data(G_OBJECT(prefs_w), E_PREFSW_NOTEBOOK_KEY), page);
+ gtk_notebook_set_current_page((GtkNotebook *)g_object_get_data(G_OBJECT(prefs_w), E_PREFSW_NOTEBOOK_KEY), page);
}
}
git.samba.org / metze / wireshark / wip.git / blobdiff