Remove some GTK+-only code.
[metze/wireshark/wip.git] / epan / prefs.c
index ac2f25bc0811fa13f2e5eb43d0b9f2c36b017e3a..c2d1dfc9ddd4891dcc034889e6aa596db1f08473 100644 (file)
@@ -5,23 +5,13 @@
  * By Gerald Combs <gerald@wireshark.org>
  * Copyright 1998 Gerald Combs
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ * SPDX-License-Identifier: GPL-2.0-or-later
  */
 
 #include "config.h"
 
+#include "ws_diag_control.h"
+
 #include <stdlib.h>
 #include <string.h>
 #include <errno.h>
@@ -33,9 +23,7 @@
 #include <epan/address.h>
 #include <epan/addr_resolv.h>
 #include <epan/oids.h>
-#ifdef HAVE_GEOIP
-#include <epan/geoip_db.h>
-#endif
+#include <epan/maxmind_db.h>
 #include <epan/packet.h>
 #include <epan/prefs.h>
 #include <epan/proto.h>
@@ -45,6 +33,7 @@
 #include "print.h"
 #include <wsutil/file_util.h>
 #include <wsutil/ws_printf.h> /* ws_g_warning */
+#include <wsutil/report_message.h>
 
 #include <epan/prefs-int.h>
 #include <epan/uat-int.h>
@@ -66,6 +55,8 @@ static void pre_init_prefs(void);
 static gboolean prefs_is_column_visible(const gchar *cols_hidden, fmt_data *cfmt);
 static gboolean parse_column_format(fmt_data *cfmt, const char *fmt);
 static void try_convert_to_custom_column(gpointer *el_data);
+static guint prefs_module_list_foreach(wmem_tree_t *module_list, module_cb callback,
+                          gpointer user_data, gboolean skip_obsolete);
 
 #define IS_PREF_OBSOLETE(p) ((p) & PREF_OBSOLETE)
 #define SET_PREF_OBSOLETE(p) ((p) |= PREF_OBSOLETE)
@@ -77,6 +68,7 @@ static void try_convert_to_custom_column(gpointer *el_data);
 static gboolean prefs_initialized = FALSE;
 static gchar *gpf_path = NULL;
 static gchar *cols_hidden_list = NULL;
+static gboolean gui_theme_is_dark = FALSE;
 
 /*
  * XXX - variables to allow us to attempt to interpret the first
@@ -105,12 +97,6 @@ static const enum_val_t gui_ptree_expander_style[] = {
     {NULL, NULL, -1}
 };
 
-static const enum_val_t gui_hex_dump_highlight_style[] = {
-    {"BOLD", "BOLD", 0},
-    {"INVERSE", "INVERSE", 1},
-    {NULL, NULL, -1}
-};
-
 static const enum_val_t gui_console_open_type[] = {
     {"NEVER", "NEVER", console_open_never},
     {"AUTOMATIC", "AUTOMATIC", console_open_auto},
@@ -132,8 +118,6 @@ static const enum_val_t gui_fileopen_style[] = {
     {NULL, NULL, -1}
 };
 
-/* GTK knows of two ways representing "both", vertical and horizontal aligned.
- * as this may not work on other guis, we use only "both" in general here */
 static const enum_val_t gui_toolbar_style[] = {
     {"ICONS", "ICONS", 0},
     {"TEXT", "TEXT", 1},
@@ -211,6 +195,8 @@ struct preference {
     const char *description;         /**< human-readable description of preference */
     int ordinal;                     /**< ordinal number of this preference */
     int type;                        /**< type of that preference */
+    unsigned int effect_flags;       /**< Flags of types effected by preference (PREF_TYPE_DISSECTION, PREF_EFFECT_CAPTURE, etc).
+                                          Flags must be non-zero to ensure saving to disk */
     gui_type_t gui;                  /**< type of the GUI (QT, GTK or both) the preference is registered for */
     union {                          /* The Qt preference code assumes that these will all be pointers (and unique) */
         guint *uint;
@@ -285,21 +271,6 @@ guint32 prefs_get_max_value(pref_t *pref)
     return pref->info.max_value;
 }
 
-void* prefs_get_control(pref_t *pref)
-{
-    return pref->control;
-}
-
-void prefs_set_control(pref_t *pref, void* control)
-{
-    pref->control = control;
-}
-
-int prefs_get_ordinal(pref_t *pref)
-{
-    return pref->ordinal;
-}
-
 /*
  * List of all modules with preference settings.
  */
@@ -326,7 +297,9 @@ prefs_init(void)
 static void
 free_string_like_preference(pref_t *pref)
 {
-    g_free(*pref->varp.string);
+DIAG_OFF(cast-qual)
+    g_free((char *)*pref->varp.string);
+DIAG_ON(cast-qual)
     *pref->varp.string = NULL;
     g_free(pref->default_val.string);
     pref->default_val.string = NULL;
@@ -351,12 +324,10 @@ free_pref(gpointer data, gpointer user_data _U_)
     case PREF_COLOR:
         break;
     case PREF_STRING:
-    case PREF_FILENAME:
+    case PREF_SAVE_FILENAME:
+    case PREF_OPEN_FILENAME:
     case PREF_DIRNAME:
-        g_free(*pref->varp.string);
-        *pref->varp.string = NULL;
-        g_free(pref->default_val.string);
-        pref->default_val.string = NULL;
+        free_string_like_preference(pref);
         break;
     case PREF_RANGE:
     case PREF_DECODE_AS_RANGE:
@@ -385,7 +356,7 @@ free_module_prefs(module_t *module, gpointer data _U_)
     module->prefs = NULL;
     module->numprefs = 0;
     if (module->submodules) {
-        prefs_modules_foreach_submodules(module, free_module_prefs, NULL);
+        prefs_module_list_foreach(module->submodules, free_module_prefs, NULL, FALSE);
     }
     /*  We don't free the actual module: its submodules pointer points to
         a wmem_tree and the module itself is stored in a wmem_tree
@@ -401,16 +372,24 @@ prefs_cleanup(void)
     /*  This isn't strictly necessary since we're exiting anyway, but let's
      *  do what clean up we can.
      */
-    prefs_modules_foreach(free_module_prefs, NULL);
+    prefs_module_list_foreach(prefs_modules, free_module_prefs, NULL, FALSE);
 
     /* Clean the uats */
     uat_cleanup();
 
+    /* Shut down mmdbresolve */
+    maxmind_db_pref_cleanup();
+
     g_free(prefs.saved_at_version);
     g_free(gpf_path);
     gpf_path = NULL;
 }
 
+void prefs_set_gui_theme_is_dark(gboolean is_dark)
+{
+    gui_theme_is_dark = is_dark;
+}
+
 /*
  * Register a module that will have preferences.
  * Specify the module under which to register it or NULL to register it
@@ -418,7 +397,7 @@ prefs_cleanup(void)
  * the title used in the tab for it in a preferences dialog box, and a
  * routine to call back when we apply the preferences.
  */
-module_t *
+static module_t *
 prefs_register_module(module_t *parent, const char *name, const char *title,
                       const char *description, void (*apply_cb)(void),
                       const gboolean use_gui)
@@ -454,7 +433,7 @@ prefs_deregister_module(module_t *parent, const char *name, const char *title)
  * at the top level and the title used in the tab for it in a preferences
  * dialog box.
  */
-module_t *
+static module_t *
 prefs_register_subtree(module_t *parent, const char *title, const char *description,
                        void (*apply_cb)(void))
 {
@@ -497,9 +476,11 @@ prefs_register_module_or_subtree(module_t *parent, const char *name,
     module->parent = parent;
     module->submodules = NULL;    /* no submodules, to start */
     module->numprefs = 0;
-    module->prefs_changed = FALSE;
+    module->prefs_changed_flags = 0;
     module->obsolete = FALSE;
     module->use_gui = use_gui;
+    /* A module's preferences affects dissection unless otherwise told */
+    module->effect_flags = PREF_EFFECT_DISSECTION;
 
     /*
      * Do we have a module name?
@@ -516,9 +497,11 @@ prefs_register_module_or_subtree(module_t *parent, const char *name,
          * on the command line, and shouldn't require quoting,
          * shifting, etc.
          */
-        for (p = name; (c = *p) != '\0'; p++)
-            g_assert(g_ascii_islower(c) || g_ascii_isdigit(c) || c == '_' ||
-                 c == '-' || c == '.');
+        for (p = name; (c = *p) != '\0'; p++) {
+            if (!(g_ascii_islower(c) || g_ascii_isdigit(c) || c == '_' ||
+                  c == '-' || c == '.'))
+                g_error("Preference module \"%s\" contains invalid characters", name);
+        }
 
         /*
          * Make sure there's not already a module with that
@@ -591,6 +574,8 @@ prefs_register_protocol(int id, void (*apply_cb)(void))
         prefs_register_modules();
     }
     protocol = find_protocol_by_id(id);
+    if (protocol == NULL)
+        g_error("Protocol preferences being registered with an invalid protocol ID");
     return prefs_register_module(protocols_module,
                                  proto_get_protocol_filter_name(id),
                                  proto_get_protocol_short_name(protocol),
@@ -601,6 +586,8 @@ void
 prefs_deregister_protocol (int id)
 {
     protocol_t *protocol = find_protocol_by_id(id);
+    if (protocol == NULL)
+        g_error("Protocol preferences being de-registered with an invalid protocol ID");
     prefs_deregister_module (protocols_module,
                              proto_get_protocol_filter_name(id),
                              proto_get_protocol_short_name(protocol));
@@ -646,7 +633,7 @@ prefs_register_protocol_subtree(const char *subtree, int id, void (*apply_cb)(vo
                  * being the name (if it's later registered explicitly
                  * with a description, that will override it).
                  */
-                ptr = wmem_strdup(wmem_epan_scope(), ptr),
+                ptr = wmem_strdup(wmem_epan_scope(), ptr);
                 new_module = prefs_register_subtree(subtree_module, ptr, ptr, NULL);
             }
 
@@ -659,6 +646,8 @@ prefs_register_protocol_subtree(const char *subtree, int id, void (*apply_cb)(vo
     }
 
     protocol = find_protocol_by_id(id);
+    if (protocol == NULL)
+        g_error("Protocol subtree being registered with an invalid protocol ID");
     return prefs_register_module(subtree_module,
                                  proto_get_protocol_filter_name(id),
                                  proto_get_protocol_short_name(protocol),
@@ -688,6 +677,8 @@ prefs_register_protocol_obsolete(int id)
         prefs_register_modules();
     }
     protocol = find_protocol_by_id(id);
+    if (protocol == NULL)
+        g_error("Protocol being registered with an invalid protocol ID");
     module = prefs_register_module(protocols_module,
                                    proto_get_protocol_filter_name(id),
                                    proto_get_protocol_short_name(protocol),
@@ -728,6 +719,38 @@ prefs_register_stat(const char *name, const char *title,
                                  apply_cb, TRUE);
 }
 
+/*
+ * Register that a codec has preferences.
+ *
+ * "name" is a name for the codec to use on the command line with "-o"
+ * and in preference files.
+ *
+ * "title" is a short human-readable name for the codec.
+ *
+ * "description" is a longer human-readable description of the codec.
+ */
+module_t *codecs_module = NULL;
+
+module_t *
+prefs_register_codec(const char *name, const char *title,
+                     const char *description, void (*apply_cb)(void))
+{
+    /*
+     * Have we yet created the "Codecs" subtree?
+     */
+    if (codecs_module == NULL) {
+        /*
+         * No.  Register Codecs subtree as well as any preferences
+         * for non-dissector modules.
+         */
+        pre_init_prefs();
+        prefs_register_modules();
+    }
+
+    return prefs_register_module(codecs_module, name, title, description,
+                                 apply_cb, TRUE);
+}
+
 module_t *
 prefs_find_module(const char *name)
 {
@@ -747,7 +770,7 @@ find_subtree(module_t *parent, const char *name)
  * non-zero value, we stop and return that value, otherwise we
  * return 0.
  *
- * Ignores "obsolete" modules; their sole purpose is to allow old
+ * Normally "obsolete" modules are ignored; their sole purpose is to allow old
  * preferences for dissectors that no longer have preferences to be
  * silently ignored in preference files.  Does not ignore subtrees,
  * as this can be used when walking the display tree of modules.
@@ -757,6 +780,7 @@ typedef struct {
     module_cb callback;
     gpointer user_data;
     guint ret;
+    gboolean skip_obsolete;
 } call_foreach_t;
 
 static gboolean
@@ -765,7 +789,7 @@ call_foreach_cb(const void *key _U_, void *value, void *data)
     module_t *module = (module_t*)value;
     call_foreach_t *call_data = (call_foreach_t*)data;
 
-    if (!module->obsolete)
+    if (!call_data->skip_obsolete || !module->obsolete)
         call_data->ret = (*call_data->callback)(module, call_data->user_data);
 
     return (call_data->ret != 0);
@@ -773,7 +797,7 @@ call_foreach_cb(const void *key _U_, void *value, void *data)
 
 static guint
 prefs_module_list_foreach(wmem_tree_t *module_list, module_cb callback,
-                          gpointer user_data)
+                          gpointer user_data, gboolean skip_obsolete)
 {
     call_foreach_t call_data;
 
@@ -783,6 +807,7 @@ prefs_module_list_foreach(wmem_tree_t *module_list, module_cb callback,
     call_data.callback = callback;
     call_data.user_data = user_data;
     call_data.ret = 0;
+    call_data.skip_obsolete = skip_obsolete;
     wmem_tree_foreach(module_list, call_foreach_cb, &call_data);
     return call_data.ret;
 }
@@ -815,7 +840,7 @@ prefs_module_has_submodules(module_t *module)
 guint
 prefs_modules_foreach(module_cb callback, gpointer user_data)
 {
-    return prefs_module_list_foreach(prefs_modules, callback, user_data);
+    return prefs_module_list_foreach(prefs_modules, callback, user_data, TRUE);
 }
 
 /*
@@ -832,7 +857,7 @@ guint
 prefs_modules_foreach_submodules(module_t *module, module_cb callback,
                                  gpointer user_data)
 {
-    return prefs_module_list_foreach((module)?module->submodules:prefs_top_level_modules, callback, user_data);
+    return prefs_module_list_foreach((module)?module->submodules:prefs_top_level_modules, callback, user_data, TRUE);
 }
 
 static gboolean
@@ -842,10 +867,10 @@ call_apply_cb(const void *key _U_, void *value, void *data _U_)
 
     if (module->obsolete)
         return FALSE;
-    if (module->prefs_changed) {
+    if (module->prefs_changed_flags) {
         if (module->apply_cb != NULL)
             (*module->apply_cb)();
-        module->prefs_changed = FALSE;
+        module->prefs_changed_flags = 0;
     }
     if (module->submodules)
         wmem_tree_foreach(module->submodules, call_apply_cb, NULL);
@@ -873,7 +898,7 @@ prefs_apply_all(void)
 void
 prefs_apply(module_t *module)
 {
-    if (module && module->prefs_changed)
+    if (module && module->prefs_changed_flags)
         call_apply_cb(NULL, module, NULL);
 }
 
@@ -897,6 +922,9 @@ register_preference(module_t *module, const char *name, const char *title,
     preference->title = title;
     preference->description = description;
     preference->type = type;
+    /* Default to module's preference effects */
+    preference->effect_flags = module->effect_flags;
+
     preference->gui = GUI_ALL;  /* default */
     if (title != NULL)
         preference->ordinal = module->numprefs;
@@ -915,7 +943,7 @@ register_preference(module_t *module, const char *name, const char *title,
      */
     for (p = name; *p != '\0'; p++)
         if (!(g_ascii_islower(*p) || g_ascii_isdigit(*p) || *p == '_' || *p == '.'))
-            g_error("Preference %s.%s contains invalid characters", module->name, name);
+            g_error("Preference \"%s.%s\" contains invalid characters", module->name, name);
 
     /*
      * Make sure there's not already a preference with that
@@ -1136,28 +1164,28 @@ prefs_register_bool_preference(module_t *module, const char *name,
     preference->default_val.boolval = *var;
 }
 
-gboolean prefs_set_bool_value(pref_t *pref, gboolean value, pref_source_t source)
+unsigned int prefs_set_bool_value(pref_t *pref, gboolean value, pref_source_t source)
 {
-    gboolean changed = FALSE;
+    unsigned int changed = 0;
 
     switch (source)
     {
     case pref_default:
         if (pref->default_val.boolval != value) {
             pref->default_val.boolval = value;
-            changed = TRUE;
+            changed = prefs_get_effect_flags(pref);
         }
         break;
     case pref_stashed:
         if (pref->stashed_val.boolval != value) {
             pref->stashed_val.boolval = value;
-            changed = TRUE;
+            changed = prefs_get_effect_flags(pref);
         }
         break;
     case pref_current:
         if (*pref->varp.boolp != value) {
             *pref->varp.boolp = value;
-            changed = TRUE;
+            changed = prefs_get_effect_flags(pref);
         }
         break;
     default:
@@ -1231,28 +1259,28 @@ prefs_register_enum_preference(module_t *module, const char *name,
     preference->info.enum_info.radio_buttons = radio_buttons;
 }
 
-gboolean prefs_set_enum_value(pref_t *pref, gint value, pref_source_t source)
+unsigned int prefs_set_enum_value(pref_t *pref, gint value, pref_source_t source)
 {
-    gboolean changed = FALSE;
+    unsigned int changed = 0;
 
     switch (source)
     {
     case pref_default:
         if (pref->default_val.enumval != value) {
             pref->default_val.enumval = value;
-            changed = TRUE;
+            changed = prefs_get_effect_flags(pref);
         }
         break;
     case pref_stashed:
         if (pref->stashed_val.enumval != value) {
             pref->stashed_val.enumval = value;
-            changed = TRUE;
+            changed = prefs_get_effect_flags(pref);
         }
         break;
     case pref_current:
         if (*pref->varp.enump != value) {
             *pref->varp.enump = value;
-            changed = TRUE;
+            changed = prefs_get_effect_flags(pref);
         }
         break;
     default:
@@ -1333,20 +1361,32 @@ register_string_like_preference(module_t *module, const char *name,
     }
 }
 
+/*
+ * Assign to a string preference.
+ */
+static void
+pref_set_string_like_pref_value(pref_t *pref, const gchar *value)
+{
+DIAG_OFF(cast-qual)
+    g_free((void *)*pref->varp.string);
+DIAG_ON(cast-qual)
+    *pref->varp.string = g_strdup(value);
+}
+
 /*
  * For use by UI code that sets preferences.
  */
-gboolean
+unsigned int
 prefs_set_string_value(pref_t *pref, const char* value, pref_source_t source)
 {
-    gboolean changed = FALSE;
+    unsigned int changed = 0;
 
     switch (source)
     {
     case pref_default:
         if (*pref->default_val.string) {
             if (strcmp(pref->default_val.string, value) != 0) {
-                changed = TRUE;
+                changed = prefs_get_effect_flags(pref);
                 g_free(pref->default_val.string);
                 pref->default_val.string = g_strdup(value);
             }
@@ -1357,7 +1397,7 @@ prefs_set_string_value(pref_t *pref, const char* value, pref_source_t source)
     case pref_stashed:
         if (pref->stashed_val.string) {
             if (strcmp(pref->stashed_val.string, value) != 0) {
-                changed = TRUE;
+                changed = prefs_get_effect_flags(pref);
                 g_free(pref->stashed_val.string);
                 pref->stashed_val.string = g_strdup(value);
             }
@@ -1368,12 +1408,11 @@ prefs_set_string_value(pref_t *pref, const char* value, pref_source_t source)
     case pref_current:
         if (*pref->varp.string) {
             if (strcmp(*pref->varp.string, value) != 0) {
-                changed = TRUE;
-                g_free(*pref->varp.string);
-                *pref->varp.string = g_strdup(value);
+                changed = prefs_get_effect_flags(pref);
+                pref_set_string_like_pref_value(pref, value);
             }
         } else if (value) {
-            *pref->varp.string = g_strdup(value);
+            pref_set_string_like_pref_value(pref, value);
         }
         break;
     default:
@@ -1432,11 +1471,11 @@ DIAG_ON(cast-qual)
 void
 prefs_register_filename_preference(module_t *module, const char *name,
                                    const char *title, const char *description,
-                                   const char **var)
+                                   const char **var, gboolean for_writing)
 {
 DIAG_OFF(cast-qual)
-    register_string_like_preference(module, name, title, description,
-                                    (char **)var, PREF_FILENAME, NULL, FALSE);
+    register_string_like_preference(module, name, title, description, (char **)var,
+                                    for_writing ? PREF_SAVE_FILENAME : PREF_OPEN_FILENAME, NULL, FALSE);
 DIAG_ON(cast-qual)
 }
 
@@ -1494,7 +1533,7 @@ prefs_register_range_preference(module_t *module, const char *name,
 
 gboolean
 prefs_set_range_value_work(pref_t *pref, const gchar *value,
-                           gboolean return_range_errors, gboolean *changed)
+                           gboolean return_range_errors, unsigned int *changed_flags)
 {
     range_t *newrange;
 
@@ -1504,7 +1543,7 @@ prefs_set_range_value_work(pref_t *pref, const gchar *value,
     }
 
     if (!ranges_are_equal(*pref->varp.range, newrange)) {
-        *changed = TRUE;
+        *changed_flags |= prefs_get_effect_flags(pref);
         wmem_free(wmem_epan_scope(), *pref->varp.range);
         *pref->varp.range = newrange;
     } else {
@@ -1516,14 +1555,14 @@ prefs_set_range_value_work(pref_t *pref, const gchar *value,
 /*
  * For use by UI code that sets preferences.
  */
-gboolean
+unsigned int
 prefs_set_stashed_range_value(pref_t *pref, const gchar *value)
 {
     range_t *newrange;
 
     if (range_convert_str_work(wmem_epan_scope(), &newrange, value, pref->info.max_value,
                                TRUE) != CVT_NO_ERROR) {
-        return FALSE;        /* number was bad */
+        return 0;        /* number was bad */
     }
 
     if (!ranges_are_equal(pref->stashed_val.range, newrange)) {
@@ -1532,7 +1571,7 @@ prefs_set_stashed_range_value(pref_t *pref, const gchar *value)
     } else {
         wmem_free(wmem_epan_scope(), newrange);
     }
-    return TRUE;
+    return prefs_get_effect_flags(pref);
 
 }
 
@@ -1903,7 +1942,8 @@ pref_stash(pref_t *pref, gpointer unused _U_)
         break;
 
     case PREF_STRING:
-    case PREF_FILENAME:
+    case PREF_SAVE_FILENAME:
+    case PREF_OPEN_FILENAME:
     case PREF_DIRNAME:
         g_free(pref->stashed_val.string);
         pref->stashed_val.string = g_strdup(*pref->varp.string);
@@ -1943,7 +1983,7 @@ pref_unstash(pref_t *pref, gpointer unstash_data_p)
 
     case PREF_DECODE_AS_UINT:
         if (*pref->varp.uint != pref->stashed_val.uint) {
-            unstash_data->module->prefs_changed = TRUE;
+            unstash_data->module->prefs_changed_flags |= prefs_get_effect_flags(pref);
 
             if (unstash_data->handle_decode_as) {
                 if (*pref->varp.uint != pref->default_val.uint) {
@@ -1956,7 +1996,7 @@ pref_unstash(pref_t *pref, gpointer unstash_data_p)
             if (unstash_data->handle_decode_as) {
                 sub_dissectors = find_dissector_table(pref->name);
                 if (sub_dissectors != NULL) {
-                    handle = dissector_table_get_dissector_handle(sub_dissectors, (gchar*)unstash_data->module->title);
+                    handle = dissector_table_get_dissector_handle(sub_dissectors, unstash_data->module->title);
                     if (handle != NULL) {
                         dissector_change_uint(pref->name, *pref->varp.uint, handle);
                     }
@@ -1967,30 +2007,31 @@ pref_unstash(pref_t *pref, gpointer unstash_data_p)
 
     case PREF_UINT:
         if (*pref->varp.uint != pref->stashed_val.uint) {
-            unstash_data->module->prefs_changed = TRUE;
+            unstash_data->module->prefs_changed_flags |= prefs_get_effect_flags(pref);
             *pref->varp.uint = pref->stashed_val.uint;
         }
         break;
 
     case PREF_BOOL:
         if (*pref->varp.boolp != pref->stashed_val.boolval) {
-            unstash_data->module->prefs_changed = TRUE;
+            unstash_data->module->prefs_changed_flags |= prefs_get_effect_flags(pref);
             *pref->varp.boolp = pref->stashed_val.boolval;
         }
         break;
 
     case PREF_ENUM:
         if (*pref->varp.enump != pref->stashed_val.enumval) {
-            unstash_data->module->prefs_changed = TRUE;
+            unstash_data->module->prefs_changed_flags |= prefs_get_effect_flags(pref);
             *pref->varp.enump = pref->stashed_val.enumval;
         }
         break;
 
     case PREF_STRING:
-    case PREF_FILENAME:
+    case PREF_SAVE_FILENAME:
+    case PREF_OPEN_FILENAME:
     case PREF_DIRNAME:
         if (strcmp(*pref->varp.string, pref->stashed_val.string) != 0) {
-            unstash_data->module->prefs_changed = TRUE;
+            unstash_data->module->prefs_changed_flags |= prefs_get_effect_flags(pref);
             g_free(*pref->varp.string);
             *pref->varp.string = g_strdup(pref->stashed_val.string);
         }
@@ -1999,12 +2040,12 @@ pref_unstash(pref_t *pref, gpointer unstash_data_p)
     case PREF_DECODE_AS_RANGE:
         if (!ranges_are_equal(*pref->varp.range, pref->stashed_val.range)) {
             guint32 i, j;
-            unstash_data->module->prefs_changed = TRUE;
+            unstash_data->module->prefs_changed_flags |= prefs_get_effect_flags(pref);
 
             if (unstash_data->handle_decode_as) {
                 sub_dissectors = find_dissector_table(pref->name);
                 if (sub_dissectors != NULL) {
-                    handle = dissector_table_get_dissector_handle(sub_dissectors, (gchar*)unstash_data->module->title);
+                    handle = dissector_table_get_dissector_handle(sub_dissectors, unstash_data->module->title);
                     if (handle != NULL) {
                         /* Delete all of the old values from the dissector table */
                         for (i = 0; i < (*pref->varp.range)->nranges; i++) {
@@ -2044,14 +2085,19 @@ pref_unstash(pref_t *pref, gpointer unstash_data_p)
 
     case PREF_RANGE:
         if (!ranges_are_equal(*pref->varp.range, pref->stashed_val.range)) {
-            unstash_data->module->prefs_changed = TRUE;
+            unstash_data->module->prefs_changed_flags |= prefs_get_effect_flags(pref);
             wmem_free(wmem_epan_scope(), *pref->varp.range);
             *pref->varp.range = range_copy(wmem_epan_scope(), pref->stashed_val.range);
         }
     break;
 
     case PREF_COLOR:
-        *pref->varp.colorp = pref->stashed_val.color;
+        if ((pref->varp.colorp->blue != pref->stashed_val.color.blue) ||
+            (pref->varp.colorp->red != pref->stashed_val.color.red) ||
+            (pref->varp.colorp->green != pref->stashed_val.color.green)) {
+            unstash_data->module->prefs_changed_flags |= prefs_get_effect_flags(pref);
+            *pref->varp.colorp = pref->stashed_val.color;
+        }
         break;
 
     case PREF_STATIC_TEXT:
@@ -2087,7 +2133,8 @@ reset_stashed_pref(pref_t *pref) {
         break;
 
     case PREF_STRING:
-    case PREF_FILENAME:
+    case PREF_SAVE_FILENAME:
+    case PREF_OPEN_FILENAME:
     case PREF_DIRNAME:
         g_free(pref->stashed_val.string);
         pref->stashed_val.string = g_strdup(pref->default_val.string);
@@ -2130,7 +2177,8 @@ pref_clean_stash(pref_t *pref, gpointer unused _U_)
         break;
 
     case PREF_STRING:
-    case PREF_FILENAME:
+    case PREF_SAVE_FILENAME:
+    case PREF_OPEN_FILENAME:
     case PREF_DIRNAME:
         if (pref->stashed_val.string != NULL) {
             g_free(pref->stashed_val.string);
@@ -2238,12 +2286,6 @@ stats_callback(void)
     if (prefs.tap_update_interval < 100 || prefs.tap_update_interval > 10000)
         prefs.tap_update_interval = TAP_UPDATE_DEFAULT_INTERVAL;
 
-#ifdef HAVE_LIBPORTAUDIO
-    /* Test for a sane max channels entry */
-    if (prefs.rtp_player_max_visible < 1 || prefs.rtp_player_max_visible > 10)
-        prefs.rtp_player_max_visible = RTP_PLAYER_DEFAULT_VISIBLE;
-#endif
-
     /* burst resolution can't be less than 1 (ms) */
     if (prefs.st_burst_resolution < 1) {
         prefs.st_burst_resolution = 1;
@@ -2301,14 +2343,14 @@ console_log_level_reset_cb(pref_t* pref)
 }
 
 static prefs_set_pref_e
-console_log_level_set_cb(pref_t* pref, const gchar* value, gboolean* changed)
+console_log_level_set_cb(pref_t* pref, const gchar* value, unsigned int* changed_flags)
 {
     guint    uval;
 
     uval = (guint)strtoul(value, NULL, 10);
 
     if (*pref->varp.uint != uval) {
-        *changed = TRUE;
+        *changed_flags = prefs_get_effect_flags(pref);
         *pref->varp.uint = uval;
     }
 
@@ -2356,13 +2398,13 @@ static char * console_log_level_to_str_cb(pref_t* pref, gboolean default_val) {
 static module_t *gui_column_module = NULL;
 
 static prefs_set_pref_e
-column_hidden_set_cb(pref_t* pref, const gchar* value, gboolean* changed)
+column_hidden_set_cb(pref_t* pref, const gchar* value, unsigned int* changed_flags)
 {
     GList       *clp;
     fmt_data    *cfmt;
     pref_t  *format_pref;
 
-    (*changed) |= prefs_set_string_value(pref, value, pref_current);
+    (*changed_flags) |= prefs_set_string_value(pref, value, pref_current);
 
     /*
      * Set the "visible" flag for the existing columns; we need to
@@ -2449,7 +2491,7 @@ column_num_reset_cb(pref_t* pref)
 }
 
 static prefs_set_pref_e
-column_num_set_cb(pref_t* pref _U_, const gchar* value _U_, gboolean* changed _U_)
+column_num_set_cb(pref_t* pref _U_, const gchar* value _U_, unsigned int* changed_flags _U_)
 {
     /* Don't write this to the preferences file */
     return PREFS_SET_OK;
@@ -2549,7 +2591,7 @@ column_format_reset_cb(pref_t* pref)
 }
 
 static prefs_set_pref_e
-column_format_set_cb(pref_t* pref, const gchar* value, gboolean* changed _U_)
+column_format_set_cb(pref_t* pref, const gchar* value, unsigned int* changed_flags _U_)
 {
     GList    *col_l, *col_l_elt;
     fmt_data *cfmt;
@@ -2753,7 +2795,7 @@ capture_column_reset_cb(pref_t* pref)
 }
 
 static prefs_set_pref_e
-capture_column_set_cb(pref_t* pref, const gchar* value, gboolean* changed _U_)
+capture_column_set_cb(pref_t* pref, const gchar* value, unsigned int* changed_flags _U_)
 {
     GList *col_l  = prefs_get_string_list(value);
     GList *col_l_elt;
@@ -2873,9 +2915,9 @@ capture_column_to_str_cb(pref_t* pref, gboolean default_val)
 }
 
 static prefs_set_pref_e
-colorized_frame_set_cb(pref_t* pref, const gchar* value, gboolean* changed)
+colorized_frame_set_cb(pref_t* pref, const gchar* value, unsigned int* changed_flags)
 {
-    (*changed) |= prefs_set_string_value(pref, value, pref_current);
+    (*changed_flags) |= prefs_set_string_value(pref, value, pref_current);
     return PREFS_SET_OK;
 }
 
@@ -2924,10 +2966,8 @@ prefs_register_modules(void)
 {
     module_t *printing, *capture_module, *console_module,
         *gui_layout_module, *gui_font_module;
-#ifdef HAVE_EXTCAP
     module_t *extcap_module;
-#endif
-
+    unsigned int layout_gui_flags;
     struct pref_custom_cbs custom_cbs;
 
     if (protocols_module != NULL) {
@@ -2935,7 +2975,6 @@ prefs_register_modules(void)
         return;
     }
 
-#ifdef HAVE_EXTCAP
     /* GUI
      * These are "simple" GUI preferences that can be read/written using the
      * preference module API.  These preferences still use their own
@@ -2951,7 +2990,6 @@ prefs_register_modules(void)
                                    "Save arguments on start of capture",
                                    "Save arguments on start of capture",
                                    &prefs.extcap_save_on_start);
-#endif
 
     /* GUI
      * These are "simple" GUI preferences that can be read/written using the
@@ -2973,11 +3011,7 @@ prefs_register_modules(void)
     prefs_register_obsolete_preference(gui_module, "scrollbar_on_right");
     prefs_register_obsolete_preference(gui_module, "packet_list_sel_browse");
     prefs_register_obsolete_preference(gui_module, "protocol_tree_sel_browse");
-
-    prefs_register_bool_preference(gui_module, "tree_view_altern_colors",
-                                   "Alternating colors in TreeViews",
-                                   "Alternating colors in TreeViews?",
-                                   &prefs.gui_altern_colors);
+    prefs_register_obsolete_preference(gui_module, "tree_view_altern_colors");
 
     prefs_register_bool_preference(gui_module, "expert_composite_eyecandy",
                                    "Display Icons on Expert Composite Dialog Tabs",
@@ -2989,6 +3023,11 @@ prefs_register_modules(void)
                                    "Place filter toolbar inside the statusbar?",
                                    &prefs.filter_toolbar_show_in_statusbar);
 
+    prefs_register_bool_preference(gui_module, "restore_filter_after_following_stream",
+                                   "Restore current display filter after following a stream",
+                                   "Restore current display filter after following a stream?",
+                                   &prefs.restore_filter_after_following_stream);
+
     prefs_register_enum_preference(gui_module, "protocol_tree_line_style",
                        "Protocol-tree line style",
                        "Protocol-tree line style",
@@ -2999,10 +3038,7 @@ prefs_register_modules(void)
                        "Protocol-tree expander style",
                        &prefs.gui_ptree_expander_style, gui_ptree_expander_style, FALSE);
 
-    prefs_register_enum_preference(gui_module, "hex_dump_highlight_style",
-                       "Hex dump highlight style",
-                       "Hex dump highlight style",
-                       &prefs.gui_hex_dump_highlight_style, gui_hex_dump_highlight_style, FALSE);
+    prefs_register_obsolete_preference(gui_module, "hex_dump_highlight_style");
 
     gui_column_module = prefs_register_subtree(gui_module, "Columns", "Columns", NULL);
 
@@ -3047,9 +3083,7 @@ prefs_register_modules(void)
 
     prefs_register_obsolete_preference(gui_font_module, "font_name");
 
-    register_string_like_preference(gui_font_module, "gtk2.font_name", "Font name",
-        "Font name for packet list, protocol tree, and hex dump panes. (GTK+)",
-        &prefs.gui_gtk2_font_name, PREF_STRING, NULL, TRUE);
+    prefs_register_obsolete_preference(gui_font_module, "gtk2.font_name");
 
     register_string_like_preference(gui_font_module, "qt.font_name", "Font name",
         "Font name for packet list, protocol tree, and hex dump panes. (Qt)",
@@ -3172,11 +3206,7 @@ prefs_register_modules(void)
                                    "Save window maximized state at exit?",
                                    &prefs.gui_geometry_save_maximized);
 
-    /* GTK+ only */
-    prefs_register_bool_preference(gui_module, "macosx_style",
-                                   "Use OS X style",
-                                   "Use OS X style (OS X with native GTK only)?",
-                                   &prefs.gui_macosx_style);
+    prefs_register_obsolete_preference(gui_module, "macosx_style");
 
     prefs_register_obsolete_preference(gui_module, "geometry.main.x");
     prefs_register_obsolete_preference(gui_module, "geometry.main.y");
@@ -3231,48 +3261,56 @@ prefs_register_modules(void)
                        "Show version in the start page and/or main screen's title bar",
                        (gint*)(void*)(&prefs.gui_version_placement), gui_version_placement_type, FALSE);
 
-    prefs_register_bool_preference(gui_module, "auto_scroll_on_expand",
-                                   "Automatically scroll packet details",
-                                   "When selecting a new packet, automatically scroll"
-                                   "to the packet detail item that matches the most"
-                                   "recently selected item",
-                                   &prefs.gui_auto_scroll_on_expand);
-
-    prefs_register_uint_preference(gui_module, "auto_scroll_percentage",
-                                   "Packet detail scroll percentage",
-                                   "The percentage down the view the recently expanded detail item should be scrolled",
-                                   10,
-                                   &prefs.gui_auto_scroll_percentage);
+    prefs_register_obsolete_preference(gui_module, "auto_scroll_on_expand");
+    prefs_register_obsolete_preference(gui_module, "auto_scroll_percentage");
 
     /* User Interface : Layout */
     gui_layout_module = prefs_register_subtree(gui_module, "Layout", "Layout", gui_layout_callback);
+    /* Adjust the preference effects of layout GUI for better handling of preferences at Wireshark (GUI) level */
+    layout_gui_flags = prefs_get_module_effect_flags(gui_layout_module);
+    layout_gui_flags |= PREF_EFFECT_GUI_LAYOUT;
+    layout_gui_flags &= (~PREF_EFFECT_DISSECTION);
 
     prefs_register_uint_preference(gui_layout_module, "layout_type",
                                    "Layout type",
                                    "Layout type (1-6)",
                                    10,
                                    (guint*)(void*)(&prefs.gui_layout_type));
+    prefs_set_effect_flags_by_name(gui_layout_module, "layout_type", layout_gui_flags);
 
     prefs_register_enum_preference(gui_layout_module, "layout_content_1",
                        "Layout content of the pane 1",
                        "Layout content of the pane 1",
                        (gint*)(void*)(&prefs.gui_layout_content_1), gui_layout_content, FALSE);
+    prefs_set_effect_flags_by_name(gui_layout_module, "layout_content_1", layout_gui_flags);
 
     prefs_register_enum_preference(gui_layout_module, "layout_content_2",
                        "Layout content of the pane 2",
                        "Layout content of the pane 2",
                        (gint*)(void*)(&prefs.gui_layout_content_2), gui_layout_content, FALSE);
+    prefs_set_effect_flags_by_name(gui_layout_module, "layout_content_2", layout_gui_flags);
 
     prefs_register_enum_preference(gui_layout_module, "layout_content_3",
                        "Layout content of the pane 3",
                        "Layout content of the pane 3",
                        (gint*)(void*)(&prefs.gui_layout_content_3), gui_layout_content, FALSE);
+    prefs_set_effect_flags_by_name(gui_layout_module, "layout_content_3", layout_gui_flags);
 
     prefs_register_bool_preference(gui_layout_module, "packet_list_separator.enabled",
                                    "Enable Packet List Separator",
                                    "Enable Packet List Separator",
                                    &prefs.gui_qt_packet_list_separator);
 
+    prefs_register_bool_preference(gui_layout_module, "show_selected_packet.enabled",
+                                   "Show selected packet in the Status Bar",
+                                   "Show selected packet in the Status Bar",
+                                   &prefs.gui_qt_show_selected_packet);
+
+    prefs_register_bool_preference(gui_layout_module, "show_file_load_time.enabled",
+                                   "Show file load time in the Status Bar",
+                                   "Show file load time in the Status Bar",
+                                   &prefs.gui_qt_show_file_load_time);
+
     prefs_register_bool_preference(gui_module, "packet_editor.enabled",
                                    "Enable Packet Editor",
                                    "Enable Packet Editor (Experimental)",
@@ -3334,6 +3372,14 @@ prefs_register_modules(void)
                                    "Look for dissectors that left some bytes undecoded (debug)",
                                    &prefs.incomplete_dissectors_check_debug);
 
+    /* Display filter Expressions
+     * This used to be an array of individual fields that has now been
+     * converted to a UAT.  Just make it part of the GUI category even
+     * though the name of the preference will never be seen in preference
+     * file
+     */
+    filter_expression_register_uat(gui_module);
+
     /* Capture
      * These are preferences that can be read/written using the
      * preference module API.  These preferences still use their own
@@ -3342,6 +3388,8 @@ prefs_register_modules(void)
      */
     capture_module = prefs_register_module(NULL, "capture", "Capture",
         "Capture preferences", NULL, FALSE);
+    /* Capture preferences don't affect dissection */
+    prefs_set_module_effect_flags(capture_module, PREF_EFFECT_CAPTURE);
 
     register_string_like_preference(capture_module, "device", "Default capture device",
         "Default capture device",
@@ -3384,17 +3432,20 @@ prefs_register_modules(void)
         "Interface capture filter (Ex: en0(tcp),en1(udp),...)",
         &prefs.capture_devices_filter, PREF_STRING, NULL, FALSE);
 
-    prefs_register_bool_preference(capture_module, "pcap_ng", "Capture in Pcap-NG format",
-        "Capture in Pcap-NG format?", &prefs.capture_pcap_ng);
+    prefs_register_bool_preference(capture_module, "pcap_ng", "Capture in pcapng format",
+        "Capture in pcapng format?", &prefs.capture_pcap_ng);
 
     prefs_register_bool_preference(capture_module, "real_time_update", "Update packet list in real time during capture",
         "Update packet list in real time during capture?", &prefs.capture_real_time);
 
+    prefs_register_bool_preference(capture_module, "no_extcap", "Disable external capture interfaces",
+        "Disable external capture modules (extcap)", &prefs.capture_no_extcap);
+
     /* We might want to make this a "recent" setting. */
     prefs_register_bool_preference(capture_module, "auto_scroll", "Scroll packet list during capture",
         "Scroll packet list during capture?", &prefs.capture_auto_scroll);
 
-    /* GTK+ only */
+    /* GTK+ only, but we might implement this in Qt */
     prefs_register_bool_preference(capture_module, "show_info", "Show capture info dialog while capturing",
         "Show capture info dialog while capturing?", &prefs.capture_show_info);
 
@@ -3415,9 +3466,7 @@ prefs_register_modules(void)
         "Name Resolution", NULL, TRUE);
     addr_resolve_pref_init(nameres_module);
     oid_pref_init(nameres_module);
-#ifdef HAVE_GEOIP
-    geoip_db_pref_init(nameres_module);
-#endif
+    maxmind_db_pref_init(nameres_module);
 
     /* Printing */
     printing = prefs_register_module(NULL, "print", "Printing",
@@ -3439,7 +3488,11 @@ prefs_register_modules(void)
 
     register_string_like_preference(printing, "file", "File",
         "This is the file that gets written to when the destination is set to \"file\"",
-        &prefs.pr_file, PREF_FILENAME, NULL, TRUE);
+        &prefs.pr_file, PREF_SAVE_FILENAME, NULL, TRUE);
+
+    /* Codecs */
+    codecs_module = prefs_register_module(NULL, "codecs", "Codecs",
+        "Codecs", NULL, TRUE);
 
     /* Statistics */
     stats_module = prefs_register_module(NULL, "statistics", "Statistics",
@@ -3451,13 +3504,7 @@ prefs_register_modules(void)
                                    10,
                                    &prefs.tap_update_interval);
 
-#ifdef HAVE_LIBPORTAUDIO
-    prefs_register_uint_preference(stats_module, "rtp_player_max_visible",
-                                   "Max visible channels in RTP Player",
-                                   "Determines maximum height of RTP Player window",
-                                   10,
-                                   &prefs.rtp_player_max_visible);
-#endif
+    prefs_register_obsolete_preference(stats_module, "rtp_player_max_visible");
 
     prefs_register_bool_preference(stats_module, "st_enable_burstinfo",
             "Enable the calculation of burst information",
@@ -3546,6 +3593,12 @@ prefs_register_modules(void)
                                    "Look for dissectors that left some bytes undecoded.",
                                    &prefs.enable_incomplete_dissectors_check);
 
+    prefs_register_bool_preference(protocols_module, "strict_conversation_tracking_heuristics",
+                                   "Enable stricter conversation tracking heuristics",
+                                   "Protocols may use things like VLAN ID or interface ID to narrow the potential for duplicate conversations."
+                                   "Currently only ICMP and ICMPv6 use this preference to add VLAN ID to conversation tracking",
+                                   &prefs.strict_conversation_tracking_heuristics);
+
     /* Obsolete preferences
      * These "modules" were reorganized/renamed to correspond to their GUI
      * configuration screen within the preferences dialog
@@ -3590,7 +3643,10 @@ prefs_get_string_list(const gchar *str)
                 return NULL;
             }
             slstr[j] = '\0';
-            sl = g_list_append(sl, slstr);
+            if (j > 0)
+                sl = g_list_append(sl, slstr);
+            else
+                g_free(slstr);
             break;
         }
         if (cur_c == '"' && ! backslash) {
@@ -3626,11 +3682,13 @@ prefs_get_string_list(const gchar *str)
                and it wasn't preceded by a backslash; it's the end of
                the string we were working on...  */
             slstr[j] = '\0';
-            sl = g_list_append(sl, slstr);
+            if (j > 0) {
+                sl = g_list_append(sl, slstr);
+                slstr = (gchar *) g_malloc(sizeof(gchar) * COL_MAX_LEN);
+            }
 
             /* ...and the beginning of a new string.  */
             state = PRE_STRING;
-            slstr = (gchar *) g_malloc(sizeof(gchar) * COL_MAX_LEN);
             j = 0;
         } else if (!g_ascii_isspace(cur_c) || state != PRE_STRING) {
             /* Either this isn't a white-space character, or we've started a
@@ -3866,8 +3924,6 @@ init_prefs(void)
 
     prefs_register_modules();
 
-    filter_expression_init();
-
     prefs_initialized = TRUE;
 }
 
@@ -3892,28 +3948,20 @@ pre_init_prefs(void)
 
     prefs.pr_format  = PR_FMT_TEXT;
     prefs.pr_dest    = PR_DEST_CMD;
-    if (prefs.pr_file) g_free(prefs.pr_file);
+    g_free(prefs.pr_file);
     prefs.pr_file    = g_strdup("wireshark.out");
-    if (prefs.pr_cmd) g_free(prefs.pr_cmd);
+    g_free(prefs.pr_cmd);
     prefs.pr_cmd     = g_strdup("lpr");
 
-    prefs.gui_altern_colors = FALSE;
     prefs.gui_expert_composite_eyecandy = FALSE;
     prefs.gui_ptree_line_style = 0;
     prefs.gui_ptree_expander_style = 1;
-    prefs.gui_hex_dump_highlight_style = 1;
     prefs.filter_toolbar_show_in_statusbar = FALSE;
+    prefs.restore_filter_after_following_stream = FALSE;
     prefs.gui_toolbar_main_style = TB_STYLE_ICONS;
     prefs.gui_toolbar_filter_style = TB_STYLE_TEXT;
-    /* These will be g_freed, so they must be g_mallocated. */
-    if (prefs.gui_gtk2_font_name) g_free(prefs.gui_gtk2_font_name);
-#ifdef _WIN32
-    prefs.gui_gtk2_font_name         = g_strdup("Lucida Console 10");
-#else
-    prefs.gui_gtk2_font_name         = g_strdup("Monospace 10");
-#endif
     /* We try to find the best font in the Qt code */
-    if (prefs.gui_qt_font_name) g_free(prefs.gui_qt_font_name);
+    g_free(prefs.gui_qt_font_name);
     prefs.gui_qt_font_name           = g_strdup("");
     prefs.gui_marked_fg.red          =     65535;
     prefs.gui_marked_fg.green        =     65535;
@@ -3927,9 +3975,9 @@ pre_init_prefs(void)
     prefs.gui_ignored_bg.red         =     65535;
     prefs.gui_ignored_bg.green       =     65535;
     prefs.gui_ignored_bg.blue        =     65535;
-    if (prefs.gui_colorized_fg) g_free(prefs.gui_colorized_fg);
+    g_free(prefs.gui_colorized_fg);
     prefs.gui_colorized_fg           = g_strdup("000000,000000,000000,000000,000000,000000,000000,000000,000000,000000");
-    if (prefs.gui_colorized_bg) g_free(prefs.gui_colorized_bg);
+    g_free(prefs.gui_colorized_bg);
     prefs.gui_colorized_bg           = g_strdup("ffc0c0,ffc0ff,e0c0e0,c0c0ff,c0e0e0,c0ffff,c0ffc0,ffffc0,e0e0c0,e0e0e0");
     prefs.st_client_fg.red           = 32767;
     prefs.st_client_fg.green         =     0;
@@ -3943,24 +3991,39 @@ pre_init_prefs(void)
     prefs.st_server_bg.red           = 60909;
     prefs.st_server_bg.green         = 60909;
     prefs.st_server_bg.blue          = 64507;
-    prefs.gui_text_valid.red         = 0xAFFF; /* light green */
-    prefs.gui_text_valid.green       = 0xFFFF;
-    prefs.gui_text_valid.blue        = 0xAFFF;
-    prefs.gui_text_invalid.red       = 0xFFFF; /* light red */
-    prefs.gui_text_invalid.green     = 0xAFFF;
-    prefs.gui_text_invalid.blue      = 0xAFFF;
-    prefs.gui_text_deprecated.red    = 0xFFFF; /* light yellow */
-    prefs.gui_text_deprecated.green  = 0xFFFF;
-    prefs.gui_text_deprecated.blue   = 0xAFFF;
+
+    if (gui_theme_is_dark) {
+        // Green, red and yellow with HSV V = 84
+        prefs.gui_text_valid.red         = 0x0000; /* dark green */
+        prefs.gui_text_valid.green       = 0x66ff;
+        prefs.gui_text_valid.blue        = 0x0000;
+        prefs.gui_text_invalid.red       = 0x66FF; /* dark red */
+        prefs.gui_text_invalid.green     = 0x0000;
+        prefs.gui_text_invalid.blue      = 0x0000;
+        prefs.gui_text_deprecated.red    = 0x66FF; /* dark yellow / olive */
+        prefs.gui_text_deprecated.green  = 0x66FF;
+        prefs.gui_text_deprecated.blue   = 0x0000;
+    } else {
+        // Green, red and yellow with HSV V = 20
+        prefs.gui_text_valid.red         = 0xAFFF; /* light green */
+        prefs.gui_text_valid.green       = 0xFFFF;
+        prefs.gui_text_valid.blue        = 0xAFFF;
+        prefs.gui_text_invalid.red       = 0xFFFF; /* light red */
+        prefs.gui_text_invalid.green     = 0xAFFF;
+        prefs.gui_text_invalid.blue      = 0xAFFF;
+        prefs.gui_text_deprecated.red    = 0xFFFF; /* light yellow */
+        prefs.gui_text_deprecated.green  = 0xFFFF;
+        prefs.gui_text_deprecated.blue   = 0xAFFF;
+    }
+
     prefs.gui_geometry_save_position = TRUE;
     prefs.gui_geometry_save_size     = TRUE;
     prefs.gui_geometry_save_maximized= TRUE;
-    prefs.gui_macosx_style           = TRUE;
     prefs.gui_console_open           = console_open_never;
     prefs.gui_fileopen_style         = FO_STYLE_LAST_OPENED;
     prefs.gui_recent_df_entries_max  = 10;
     prefs.gui_recent_files_count_max = 10;
-    if (prefs.gui_fileopen_dir) g_free(prefs.gui_fileopen_dir);
+    g_free(prefs.gui_fileopen_dir);
     prefs.gui_fileopen_dir           = g_strdup(get_persdatafile_dir());
     prefs.gui_fileopen_preview       = 3;
     prefs.gui_ask_unsaved            = TRUE;
@@ -3969,17 +4032,15 @@ pre_init_prefs(void)
     prefs.gui_update_enabled         = TRUE;
     prefs.gui_update_channel         = UPDATE_CHANNEL_STABLE;
     prefs.gui_update_interval        = 60*60*24; /* Seconds */
-    if (prefs.gui_webbrowser) g_free(prefs.gui_webbrowser);
+    g_free(prefs.gui_webbrowser);
     prefs.gui_webbrowser             = g_strdup("");
-    if (prefs.gui_window_title) g_free(prefs.gui_window_title);
+    g_free(prefs.gui_window_title);
     prefs.gui_window_title           = g_strdup("");
-    if (prefs.gui_prepend_window_title) g_free(prefs.gui_prepend_window_title);
+    g_free(prefs.gui_prepend_window_title);
     prefs.gui_prepend_window_title   = g_strdup("");
-    if (prefs.gui_start_title) g_free(prefs.gui_start_title);
+    g_free(prefs.gui_start_title);
     prefs.gui_start_title            = g_strdup("The World's Most Popular Network Protocol Analyzer");
     prefs.gui_version_placement      = version_both;
-    prefs.gui_auto_scroll_on_expand  = FALSE;
-    prefs.gui_auto_scroll_percentage = 0;
     prefs.gui_layout_type            = layout_type_5;
     prefs.gui_layout_content_1       = layout_pane_content_plist;
     prefs.gui_layout_content_2       = layout_pane_content_pdetails;
@@ -3988,7 +4049,7 @@ pre_init_prefs(void)
     prefs.gui_packet_list_elide_mode = ELIDE_RIGHT;
     prefs.gui_packet_list_show_related = TRUE;
     prefs.gui_packet_list_show_minimap = TRUE;
-    if (prefs.gui_interfaces_hide_types) g_free (prefs.gui_interfaces_hide_types);
+    g_free (prefs.gui_interfaces_hide_types);
     prefs.gui_interfaces_hide_types = g_strdup("");
     prefs.gui_interfaces_show_hidden = FALSE;
 #ifdef HAVE_PCAP_REMOTE
@@ -3996,6 +4057,8 @@ pre_init_prefs(void)
 #endif
 
     prefs.gui_qt_packet_list_separator = FALSE;
+    prefs.gui_qt_show_selected_packet = FALSE;
+    prefs.gui_qt_show_file_load_time = FALSE;
 
     if (prefs.col_list) {
         free_col_info(prefs.col_list);
@@ -4021,6 +4084,7 @@ pre_init_prefs(void)
     prefs.capture_pcap_ng               = FALSE;
 #endif
     prefs.capture_real_time             = TRUE;
+    prefs.capture_no_extcap             = FALSE;
     prefs.capture_auto_scroll           = TRUE;
     prefs.capture_show_info             = FALSE;
 
@@ -4037,7 +4101,6 @@ pre_init_prefs(void)
 
 /* set the default values for the tap/statistics dialog box */
     prefs.tap_update_interval    = TAP_UPDATE_DEFAULT_INTERVAL;
-    prefs.rtp_player_max_visible = RTP_PLAYER_DEFAULT_VISIBLE;
     prefs.st_enable_burstinfo = TRUE;
     prefs.st_burst_showcount = FALSE;
     prefs.st_burst_resolution = ST_DEF_BURSTRES;
@@ -4097,7 +4160,8 @@ reset_pref(pref_t *pref)
         break;
 
     case PREF_STRING:
-    case PREF_FILENAME:
+    case PREF_SAVE_FILENAME:
+    case PREF_OPEN_FILENAME:
     case PREF_DIRNAME:
         reset_string_like_preference(pref);
         break;
@@ -4165,12 +4229,6 @@ prefs_reset(void)
      */
     oids_cleanup();
 
-    /*
-     * Free the filter expression list.
-     */
-    filter_expression_free(*pfilter_expression_head);
-    *pfilter_expression_head = NULL;
-
     /*
      * Reset the non-dissector preferences.
      */
@@ -4184,19 +4242,10 @@ prefs_reset(void)
 
 /* Read the preferences file, fill in "prefs", and return a pointer to it.
 
-   If we got an error (other than "it doesn't exist") trying to read
-   the global preferences file, stuff the errno into "*gpf_errno_return"
-   and a pointer to the path of the file into "*gpf_path_return", and
-   return NULL.
-
-   If we got an error (other than "it doesn't exist") trying to read
-   the user's preferences file, stuff the errno into "*pf_errno_return"
-   and a pointer to the path of the file into "*pf_path_return", and
-   return NULL. */
+   If we got an error (other than "it doesn't exist") we report it through
+   the UI. */
 e_prefs *
-read_prefs(int *gpf_errno_return, int *gpf_read_errno_return,
-           char **gpf_path_return, int *pf_errno_return,
-           int *pf_read_errno_return, char **pf_path_return)
+read_prefs(void)
 {
     int         err;
     char        *pf_path;
@@ -4237,7 +4286,6 @@ read_prefs(int *gpf_errno_return, int *gpf_read_errno_return,
      * XXX - if it failed for a reason other than "it doesn't exist",
      * report the error.
      */
-    *gpf_path_return = NULL;
     if (pf != NULL) {
         /*
          * Start out the counters of "mgcp.{tcp,udp}.port" entries we've
@@ -4249,21 +4297,19 @@ read_prefs(int *gpf_errno_return, int *gpf_read_errno_return,
         /* We succeeded in opening it; read it. */
         err = read_prefs_file(gpf_path, pf, set_pref, NULL);
         if (err != 0) {
-            /* We had an error reading the file; return the errno and the
-               pathname, so our caller can report the error. */
-            *gpf_errno_return = 0;
-            *gpf_read_errno_return = err;
-            *gpf_path_return = gpf_path;
+            /* We had an error reading the file; report it. */
+            report_warning("Error reading global preferences file \"%s\": %s.",
+                           gpf_path, g_strerror(err));
         }
         fclose(pf);
     } else {
         /* We failed to open it.  If we failed for some reason other than
-           "it doesn't exist", return the errno and the pathname, so our
-           caller can report the error. */
+           "it doesn't exist", report the error. */
         if (errno != ENOENT) {
-            *gpf_errno_return = errno;
-            *gpf_read_errno_return = 0;
-            *gpf_path_return = gpf_path;
+            if (errno != 0) {
+                report_warning("Can't open global preferences file \"%s\": %s.",
+                               gpf_path, g_strerror(errno));
+            }
         }
     }
 
@@ -4271,7 +4317,6 @@ read_prefs(int *gpf_errno_return, int *gpf_read_errno_return,
     pf_path = get_persconffile_path(PF_NAME, TRUE);
 
     /* Read the user's preferences file, if it exists. */
-    *pf_path_return = NULL;
     if ((pf = ws_fopen(pf_path, "r")) != NULL) {
         /*
          * Start out the counters of "mgcp.{tcp,udp}.port" entries we've
@@ -4283,11 +4328,9 @@ read_prefs(int *gpf_errno_return, int *gpf_read_errno_return,
         /* We succeeded in opening it; read it. */
         err = read_prefs_file(pf_path, pf, set_pref, NULL);
         if (err != 0) {
-            /* We had an error reading the file; return the errno and the
-               pathname, so our caller can report the error. */
-            *pf_errno_return = 0;
-            *pf_read_errno_return = err;
-            *pf_path_return = pf_path;
+            /* We had an error reading the file; report it. */
+            report_warning("Error reading your preferences file \"%s\": %s.",
+                           pf_path, g_strerror(err));
         } else
             g_free(pf_path);
         fclose(pf);
@@ -4296,9 +4339,8 @@ read_prefs(int *gpf_errno_return, int *gpf_read_errno_return,
            "it doesn't exist", return the errno and the pathname, so our
            caller can report the error. */
         if (errno != ENOENT) {
-            *pf_errno_return = errno;
-            *pf_read_errno_return = 0;
-            *pf_path_return = pf_path;
+            report_warning("Can't open your preferences file \"%s\": %s.",
+                           pf_path, g_strerror(errno));
         } else
             g_free(pf_path);
     }
@@ -4509,10 +4551,9 @@ read_prefs_file(const char *pf_path, FILE *pf,
  * a valid uat entry.
  */
 static gboolean
-prefs_set_uat_pref(char *uat_entry) {
+prefs_set_uat_pref(char *uat_entry, char **errmsg) {
     gchar *p, *colonp;
     uat_t *uat;
-    gchar *err = NULL;
     gboolean ret;
 
     colonp = strchr(uat_entry, ':');
@@ -4542,11 +4583,11 @@ prefs_set_uat_pref(char *uat_entry) {
     uat = uat_find(uat_entry);
     *colonp = ':';
     if (uat == NULL) {
+        *errmsg = g_strdup("Unknown preference");
         return FALSE;
     }
 
-    ret = uat_load_str(uat, p, &err);
-    g_free(err);
+    ret = uat_load_str(uat, p, errmsg);
     return ret;
 }
 
@@ -4557,7 +4598,7 @@ prefs_set_uat_pref(char *uat_entry) {
  * in some fashion.
  */
 prefs_set_pref_e
-prefs_set_pref(char *prefarg)
+prefs_set_pref(char *prefarg, char **errmsg)
 {
     gchar *p, *colonp;
     prefs_set_pref_e ret;
@@ -4572,6 +4613,8 @@ prefs_set_pref(char *prefarg)
     mgcp_tcp_port_count = -1;
     mgcp_udp_port_count = -1;
 
+    *errmsg = NULL;
+
     colonp = strchr(prefarg, ':');
     if (colonp == NULL)
         return PREFS_SET_SYNTAX_ERR;
@@ -4598,7 +4641,7 @@ prefs_set_pref(char *prefarg)
     if (strcmp(prefarg, "uat")) {
         ret = set_pref(prefarg, p, NULL, TRUE);
     } else {
-        ret = prefs_set_uat_pref(p) ? PREFS_SET_OK : PREFS_SET_SYNTAX_ERR;
+        ret = prefs_set_uat_pref(p, errmsg) ? PREFS_SET_OK : PREFS_SET_SYNTAX_ERR;
     }
     *colonp = ':';    /* put the colon back */
     return ret;
@@ -4630,27 +4673,27 @@ guint prefs_get_uint_value(const char *module_name, const char* pref_name)
     return prefs_get_uint_value_real(prefs_find_preference(prefs_find_module(module_name), pref_name), pref_current);
 }
 
-gboolean prefs_set_uint_value(pref_t *pref, guint value, pref_source_t source)
+unsigned int prefs_set_uint_value(pref_t *pref, guint value, pref_source_t source)
 {
-    gboolean changed = FALSE;
+    unsigned int changed = 0;
     switch (source)
     {
     case pref_default:
         if (pref->default_val.uint != value) {
             pref->default_val.uint = value;
-            changed = TRUE;
+            changed = prefs_get_effect_flags(pref);
         }
         break;
     case pref_stashed:
         if (pref->stashed_val.uint != value) {
             pref->stashed_val.uint = value;
-            changed = TRUE;
+            changed = prefs_get_effect_flags(pref);
         }
         break;
     case pref_current:
         if (*pref->varp.uint != value) {
             *pref->varp.uint = value;
-            changed = TRUE;
+            changed = prefs_get_effect_flags(pref);
         }
         break;
     default:
@@ -4812,6 +4855,14 @@ prefs_capture_options_dialog_column_is_visible(const gchar *column)
     return FALSE;
 }
 
+gboolean
+prefs_has_layout_pane_content (layout_pane_content_e layout_pane_content)
+{
+    return ((prefs.gui_layout_content_1 == layout_pane_content) ||
+            (prefs.gui_layout_content_2 == layout_pane_content) ||
+            (prefs.gui_layout_content_3 == layout_pane_content));
+}
+
 #define PRS_GUI_FILTER_LABEL             "gui.filter_expressions.label"
 #define PRS_GUI_FILTER_EXPR              "gui.filter_expressions.expr"
 #define PRS_GUI_FILTER_ENABLED           "gui.filter_expressions.enabled"
@@ -5141,11 +5192,11 @@ deprecated_port_pref(gchar *pref_name, const gchar *value)
             if (p == value || *p != '\0')
                 return FALSE;        /* number was bad */
 
-            module = prefs_find_module((gchar*)port_prefs[i].module_name);
+            module = prefs_find_module(port_prefs[i].module_name);
             pref = prefs_find_preference(module, port_prefs[i].table_name);
             if (pref != NULL)
             {
-                module->prefs_changed = TRUE;
+                module->prefs_changed_flags |= prefs_get_effect_flags(pref);
                 *pref->varp.uint = uval;
             }
 
@@ -5154,7 +5205,7 @@ deprecated_port_pref(gchar *pref_name, const gchar *value)
             {
                 sub_dissectors = find_dissector_table(port_prefs[i].table_name);
                 if (sub_dissectors != NULL) {
-                    handle = dissector_table_get_dissector_handle(sub_dissectors, (gchar*)port_prefs[i].module_name);
+                    handle = dissector_table_get_dissector_handle(sub_dissectors, port_prefs[i].module_name);
                     if (handle != NULL) {
                         dissector_change_uint(port_prefs[i].table_name, uval, handle);
                         decode_build_reset_list(port_prefs[i].table_name, dissector_table_get_type(sub_dissectors), GUINT_TO_POINTER(uval), NULL, NULL);
@@ -5186,16 +5237,16 @@ deprecated_port_pref(gchar *pref_name, const gchar *value)
                     g_assert_not_reached();
                 }
 
-                module = prefs_find_module((gchar*)port_range_prefs[i].module_name);
+                module = prefs_find_module(port_range_prefs[i].module_name);
                 pref = prefs_find_preference(module, port_range_prefs[i].table_name);
                 if (pref != NULL)
                 {
-                    if (!prefs_set_range_value_work(pref, value, TRUE, &module->prefs_changed))
+                    if (!prefs_set_range_value_work(pref, value, TRUE, &module->prefs_changed_flags))
                     {
                         return FALSE;        /* number was bad */
                     }
 
-                    handle = dissector_table_get_dissector_handle(sub_dissectors, (gchar*)port_range_prefs[i].module_name);
+                    handle = dissector_table_get_dissector_handle(sub_dissectors, port_range_prefs[i].module_name);
                     if (handle != NULL) {
 
                         for (range_i = 0; range_i < (*pref->varp.range)->nranges; range_i++) {
@@ -5265,13 +5316,16 @@ set_pref(gchar *pref_name, const gchar *value, void *private_data _U_,
     pref_t   *pref;
     int type;
 
+    //The PRS_GUI field names are here for backwards compatibility
+    //display filters have been converted to a UAT.
     if (strcmp(pref_name, PRS_GUI_FILTER_LABEL) == 0) {
         filter_label = g_strdup(value);
     } else if (strcmp(pref_name, PRS_GUI_FILTER_ENABLED) == 0) {
         filter_enabled = (strcmp(value, "TRUE") == 0) ? TRUE : FALSE;
     } else if (strcmp(pref_name, PRS_GUI_FILTER_EXPR) == 0) {
         filter_expr = g_strdup(value);
-        filter_expression_new(filter_label, filter_expr, filter_enabled);
+        /* Comments not supported for "old" preference style */
+        filter_expression_new(filter_label, filter_expr, "", filter_enabled);
         g_free(filter_label);
         g_free(filter_expr);
     } else if (strcmp(pref_name, "gui.version_in_start_page") == 0) {
@@ -5642,8 +5696,7 @@ set_pref(gchar *pref_name, const gchar *value, void *private_data _U_,
                 }
             } else if (strcmp(module->name, "taps") == 0) {
                 /* taps preferences moved to "statistics" module */
-                if (strcmp(dotp, "update_interval") == 0 ||
-                    strcmp(dotp, "rtp_player_max_visible") == 0)
+                if (strcmp(dotp, "update_interval") == 0)
                     pref = prefs_find_preference(stats_module, dotp);
             } else if (strcmp(module->name, "packet_list") == 0) {
                 /* packet_list preferences moved to protocol module */
@@ -5684,7 +5737,7 @@ set_pref(gchar *pref_name, const gchar *value, void *private_data _U_,
             if (p == value || *p != '\0')
                 return PREFS_SET_SYNTAX_ERR;        /* number was bad */
             if (*pref->varp.uint != uval) {
-                containing_module->prefs_changed = TRUE;
+                containing_module->prefs_changed_flags |= prefs_get_effect_flags(pref);
                 *pref->varp.uint = uval;
             }
             break;
@@ -5703,13 +5756,13 @@ set_pref(gchar *pref_name, const gchar *value, void *private_data _U_,
                 return PREFS_SET_SYNTAX_ERR;        /* number was bad */
 
             if (*pref->varp.uint != uval) {
-                containing_module->prefs_changed = TRUE;
+                containing_module->prefs_changed_flags |= prefs_get_effect_flags(pref);
                 *pref->varp.uint = uval;
 
                 /* Name of preference is the dissector table */
                 sub_dissectors = find_dissector_table(pref->name);
                 if (sub_dissectors != NULL) {
-                    handle = dissector_table_get_dissector_handle(sub_dissectors, (gchar*)module->title);
+                    handle = dissector_table_get_dissector_handle(sub_dissectors, module->title);
                     if (handle != NULL) {
                         if (uval != 0) {
                             dissector_change_uint(pref->name, uval, handle);
@@ -5732,7 +5785,7 @@ set_pref(gchar *pref_name, const gchar *value, void *private_data _U_,
             else
                 bval = FALSE;
             if (*pref->varp.boolp != bval) {
-                containing_module->prefs_changed = TRUE;
+                containing_module->prefs_changed_flags |= prefs_get_effect_flags(pref);
                 *pref->varp.boolp = bval;
             }
             break;
@@ -5742,21 +5795,22 @@ set_pref(gchar *pref_name, const gchar *value, void *private_data _U_,
             enum_val = find_val_for_string(value, pref->info.enum_info.enumvals,
                                            *pref->varp.enump);
             if (*pref->varp.enump != enum_val) {
-                containing_module->prefs_changed = TRUE;
+                containing_module->prefs_changed_flags |= prefs_get_effect_flags(pref);
                 *pref->varp.enump = enum_val;
             }
             break;
 
         case PREF_STRING:
-        case PREF_FILENAME:
+        case PREF_SAVE_FILENAME:
+        case PREF_OPEN_FILENAME:
         case PREF_DIRNAME:
-            containing_module->prefs_changed |= prefs_set_string_value(pref, value, pref_current);
+            containing_module->prefs_changed_flags |= prefs_set_string_value(pref, value, pref_current);
             break;
 
         case PREF_RANGE:
         {
             if (!prefs_set_range_value_work(pref, value, return_range_errors,
-                                            &containing_module->prefs_changed))
+                                            &containing_module->prefs_changed_flags))
                 return PREFS_SET_SYNTAX_ERR;        /* number was bad */
             break;
         }
@@ -5778,12 +5832,12 @@ set_pref(gchar *pref_name, const gchar *value, void *private_data _U_,
             if (!ranges_are_equal(*pref->varp.range, newrange)) {
                 wmem_free(wmem_epan_scope(), *pref->varp.range);
                 *pref->varp.range = newrange;
-                containing_module->prefs_changed = TRUE;
+                containing_module->prefs_changed_flags |= prefs_get_effect_flags(pref);
 
                 /* Name of preference is the dissector table */
                 sub_dissectors = find_dissector_table(pref->name);
                 if (sub_dissectors != NULL) {
-                    handle = dissector_table_get_dissector_handle(sub_dissectors, (gchar*)module->title);
+                    handle = dissector_table_get_dissector_handle(sub_dissectors, module->title);
                     if (handle != NULL) {
                         /* Delete all of the old values from the dissector table */
                                for (i = 0; i < (*pref->varp.range)->nranges; i++) {
@@ -5822,7 +5876,7 @@ set_pref(gchar *pref_name, const gchar *value, void *private_data _U_,
             if ((pref->varp.colorp->red != RED_COMPONENT(cval)) ||
                 (pref->varp.colorp->green != GREEN_COMPONENT(cval)) ||
                 (pref->varp.colorp->blue != BLUE_COMPONENT(cval))) {
-                containing_module->prefs_changed = TRUE;
+                containing_module->prefs_changed_flags |= prefs_get_effect_flags(pref);
                 pref->varp.colorp->red   = RED_COMPONENT(cval);
                 pref->varp.colorp->green = GREEN_COMPONENT(cval);
                 pref->varp.colorp->blue  = BLUE_COMPONENT(cval);
@@ -5831,7 +5885,7 @@ set_pref(gchar *pref_name, const gchar *value, void *private_data _U_,
         }
 
         case PREF_CUSTOM:
-            return pref->custom_cbs.set_cb(pref, value, &containing_module->prefs_changed);
+            return pref->custom_cbs.set_cb(pref, value, &containing_module->prefs_changed_flags);
 
         case PREF_STATIC_TEXT:
         case PREF_UAT:
@@ -5898,7 +5952,8 @@ prefs_pref_type_name(pref_t *pref)
         type_name = "String";
         break;
 
-    case PREF_FILENAME:
+    case PREF_SAVE_FILENAME:
+    case PREF_OPEN_FILENAME:
         type_name = "Filename";
         break;
 
@@ -5939,6 +5994,46 @@ prefs_pref_type_name(pref_t *pref)
     return type_name;
 }
 
+unsigned int
+prefs_get_effect_flags(pref_t *pref)
+{
+    if (pref == NULL)
+        return 0;
+
+    return pref->effect_flags;
+}
+
+void
+prefs_set_effect_flags(pref_t *pref, unsigned int flags)
+{
+    if (pref != NULL) {
+        pref->effect_flags = flags;
+    }
+}
+
+void
+prefs_set_effect_flags_by_name(module_t * module, const char *pref, unsigned int flags)
+{
+    prefs_set_effect_flags(prefs_find_preference(module, pref), flags);
+}
+
+unsigned int
+prefs_get_module_effect_flags(module_t * module)
+{
+    if (module == NULL)
+        return 0;
+
+    return module->effect_flags;
+}
+
+void
+prefs_set_module_effect_flags(module_t * module, unsigned int flags)
+{
+    if (module != NULL) {
+        module->effect_flags = flags;
+    }
+}
+
 char *
 prefs_pref_type_description(pref_t *pref)
 {
@@ -5999,7 +6094,8 @@ prefs_pref_type_description(pref_t *pref)
         type_desc = "A string";
         break;
 
-    case PREF_FILENAME:
+    case PREF_SAVE_FILENAME:
+    case PREF_OPEN_FILENAME:
         type_desc = "A path to a file";
         break;
 
@@ -6083,7 +6179,8 @@ prefs_pref_is_default(pref_t *pref)
         break;
 
     case PREF_STRING:
-    case PREF_FILENAME:
+    case PREF_SAVE_FILENAME:
+    case PREF_OPEN_FILENAME:
     case PREF_DIRNAME:
         if (!(g_strcmp0(pref->default_val.string, *pref->varp.string)))
             return TRUE;
@@ -6200,7 +6297,8 @@ prefs_pref_to_str(pref_t *pref, pref_source_t source) {
     }
 
     case PREF_STRING:
-    case PREF_FILENAME:
+    case PREF_SAVE_FILENAME:
+    case PREF_OPEN_FILENAME:
     case PREF_DIRNAME:
         return g_strdup(*(const char **) valp);
 
@@ -6331,6 +6429,35 @@ write_pref(gpointer data, gpointer user_data)
 
 }
 
+static void
+count_non_uat_pref(gpointer data, gpointer user_data)
+{
+    pref_t *pref = (pref_t *)data;
+    int *arg = (int *)user_data;
+
+    switch (pref->type)
+    {
+    case PREF_UAT:
+    case PREF_OBSOLETE:
+    case PREF_DECODE_AS_UINT:
+    case PREF_DECODE_AS_RANGE:
+        //These types are not written in preference file
+        break;
+    default:
+        (*arg)++;
+        break;
+    }
+}
+
+static int num_non_uat_prefs(module_t *module)
+{
+    int num = 0;
+
+    g_list_foreach(module->prefs, count_non_uat_pref, &num);
+
+    return num;
+}
+
 /*
  * Write out all preferences for a module.
  */
@@ -6348,7 +6475,7 @@ write_module_prefs(module_t *module, gpointer user_data)
     /* Write a header for the main modules and GUI sub-modules */
     if (((module->parent == NULL) || (module->parent == gui_module)) &&
         ((prefs_module_has_submodules(module)) ||
-         (module->numprefs > 0) ||
+         (num_non_uat_prefs(module) > 0) ||
          (module->name == NULL))) {
          if ((module->name == NULL) && (module->parent != NULL)) {
             fprintf(gui_pref_arg->pf, "\n####### %s: %s ########\n", module->parent->title, module->title);
@@ -6418,23 +6545,6 @@ write_prefs(char **pf_path_return)
 
     write_module_prefs(gui_module, &write_gui_pref_info);
 
-    {
-        struct filter_expression *fe = *(struct filter_expression **)prefs.filter_expressions;
-
-        if (fe != NULL)
-            fprintf(pf, "\n####### Filter Expressions ########\n\n");
-
-        while (fe != NULL) {
-            if (fe->deleted == FALSE) {
-                fprintf(pf, "%s: %s\n", PRS_GUI_FILTER_LABEL, fe->label);
-                fprintf(pf, "%s: %s\n", PRS_GUI_FILTER_ENABLED,
-                        fe->enabled == TRUE ? "TRUE" : "FALSE");
-                fprintf(pf, "%s: %s\n", PRS_GUI_FILTER_EXPR, fe->expression);
-            }
-            fe = fe->next;
-        }
-    }
-
     write_gui_pref_info.is_gui_module = FALSE;
     prefs_modules_foreach_submodules(NULL, write_module_prefs, &write_gui_pref_info);