diff --git a/README.adoc b/README.adoc
index edc49d97f..a0f6762ee 100644
--- a/README.adoc
+++ b/README.adoc
@@ -40,7 +40,7 @@ Likewise, the current version of wxPython, is 4.2.2, but RIDE is known to work w
 
 `pip install -U robotframework-ride`
 
-(3.8 <= python <= 3.12) Install current development version (**2.1b1**) with:
+(3.8 <= python <= 3.12) Install current development version (**2.1dev82**) with:
 
 `pip install -U https://github.com/robotframework/RIDE/archive/master.zip`
 
diff --git a/src/robotide/application/application.py b/src/robotide/application/application.py
index 1f0dd19e3..2d51a8812 100644
--- a/src/robotide/application/application.py
+++ b/src/robotide/application/application.py
@@ -143,13 +143,14 @@ class Message:
         self.SetTopWindow(self.frame)
         self.frame.aui_mgr.Update()
         if self._updatecheck:
-            wx.CallAfter(UpdateNotifierController(self.settings).notify_update_if_needed, UpdateDialog)
+            wx.CallAfter(UpdateNotifierController(self.settings, self.frame.notebook).notify_update_if_needed,
+                         UpdateDialog)
         self.Bind(wx.EVT_ACTIVATE_APP, self.on_app_activate)
         PUBLISHER.subscribe(self.SetGlobalColour, RideSettingsChanged)
         PUBLISHER.subscribe(self.update_excludes, RideSettingsChanged)
         RideSettingsChanged(keys=('Excludes', 'init'), old=None, new=None).publish()
         PUBLISHER.subscribe(self.change_locale, RideSettingsChanged)
-        RideSettingsChanged(keys=('General', 'ui interface'), old=None, new=None).publish()
+        RideSettingsChanged(keys=('General', 'ui language'), old=None, new=None).publish()
         wx.CallLater(600, ReleaseNotes(self).bring_to_front)
         return True
 
@@ -174,9 +175,9 @@ def _ApplyThemeToWidget(widget, fore_color=wx.BLUE, back_color=wx.LIGHT_GREY, th
             aui_default_tool_bar_art = AuiDefaultToolBarArt()
             aui_default_tool_bar_art.SetDefaultColours(wx.GREEN)
             widget.SetBackgroundColour(background)
-            widget.SetOwnBackgroundColour(background)
+            # widget.SetOwnBackgroundColour(background)
             widget.SetForegroundColour(foreground)
-            widget.SetOwnForegroundColour(foreground)
+            # widget.SetOwnForegroundColour(foreground)
             """
             widget.SetBackgroundColour(Colour(200, 222, 40))
             widget.SetOwnBackgroundColour(Colour(200, 222, 40))
@@ -188,13 +189,13 @@ def _ApplyThemeToWidget(widget, fore_color=wx.BLUE, back_color=wx.LIGHT_GREY, th
             if not isinstance(widget, (wx.Button, wx.BitmapButton, ButtonWithHandler)):
                 widget.SetForegroundColour(foreground)
                 widget.SetBackgroundColour(background)
-                widget.SetOwnBackgroundColour(background)
-                widget.SetOwnForegroundColour(foreground)
+                # widget.SetOwnBackgroundColour(background)
+                # widget.SetOwnForegroundColour(foreground)
             else:
                 widget.SetForegroundColour(secondary_foreground)
                 widget.SetBackgroundColour(secondary_background)
-                widget.SetOwnBackgroundColour(secondary_background)
-                widget.SetOwnForegroundColour(secondary_foreground)
+                # widget.SetOwnBackgroundColour(secondary_background)
+                # widget.SetOwnForegroundColour(secondary_foreground)
         elif isinstance(widget, (wx.TextCtrl, TabFrame, AuiTabCtrl)):
             widget.SetForegroundColour(foreground_text)  # or fore_color
             widget.SetBackgroundColour(background_help)  # or back_color
@@ -207,9 +208,9 @@ def _ApplyThemeToWidget(widget, fore_color=wx.BLUE, back_color=wx.LIGHT_GREY, th
             # print(f"DEBUG: Application ApplyTheme wx.MenuItem {type(widget)}")
         else:
             widget.SetBackgroundColour(background)
-            widget.SetOwnBackgroundColour(background)
+            # widget.SetOwnBackgroundColour(background)
             widget.SetForegroundColour(foreground)
-            widget.SetOwnForegroundColour(foreground)
+            # widget.SetOwnForegroundColour(foreground)
 
     def _WalkWidgets(self, widget, indent=0, indent_level=4, theme=None):
         # print(' ' * indent + widget.__class__.__name__)
@@ -333,8 +334,8 @@ def change_locale(self, message):
             from multiprocessing import shared_memory
             from .restartutil import restart_dialog
             new_locale = self._locale.GetName()
+            # print(f"DEBUG: application.py RIDE change_locale from {initial_locale} to {new_locale}")
             if initial_locale != new_locale:
-                # print(f"DEBUG: application.py RIDE change_locale CHANGED from {initial_locale} to {new_locale}")
                 if restart_dialog():  # DEBUG: See the in implementation why we don't restart
                     # print("DEBUG: application.py RIDE change_locale Restart accepted.")
                     # Shared memory to store language definition
diff --git a/src/robotide/application/releasenotes.py b/src/robotide/application/releasenotes.py
index 10e719fea..416e8a13e 100644
--- a/src/robotide/application/releasenotes.py
+++ b/src/robotide/application/releasenotes.py
@@ -335,7 +335,7 @@ def set_content(self, html_win, content):
 <pre class="literal-block">python -m robotide.postinstall -install</pre>
 <p>or</p>
 <pre class="literal-block">ride_postinstall.py -install</pre>
-<p>RIDE {VERSION} was released on 22/September/2024.</p>
+<p>RIDE {VERSION} was released on 29/September/2024.</p>
 <!-- <br/>
 <h3>May The Fourth Be With You!</h3>
 <h3>Celebrate the bank holiday, 10th June, Day of Portugal, Portuguese Communities and Camões!!</h3>
diff --git a/src/robotide/application/restartutil.py b/src/robotide/application/restartutil.py
index 1c7daa399..7fa4ac495 100644
--- a/src/robotide/application/restartutil.py
+++ b/src/robotide/application/restartutil.py
@@ -32,7 +32,7 @@ def restart_dialog():
             f"{SPC}{_('Language change will only be correct after re-opening RIDE.')}"
             f"{SPC}\n{SPC}{_('Do you want to CLOSE RIDE now?')}\n{SPC}"
             # f"{_('After restarting RIDE you will see another dialog informing to close this RIDE instance.')}"
-            f"{SPC}\n", wx.GetActiveWindow(), no_default=True):
+            f"{SPC}\n", wx.GetTopLevelWindows()[0], no_default=True):
         return False
     else:
         # do_restart()
diff --git a/src/robotide/application/updatenotifier.py b/src/robotide/application/updatenotifier.py
index e4e84a3ad..1f8c1adf7 100644
--- a/src/robotide/application/updatenotifier.py
+++ b/src/robotide/application/updatenotifier.py
@@ -22,6 +22,7 @@
 import time
 import urllib.request as urllib2
 import xmlrpc.client as xmlrpclib
+from dataclasses import dataclass
 
 import psutil
 import wx
@@ -45,8 +46,9 @@ class UpdateNotifierController(object):
     VERSION = version.VERSION
     SECONDS_IN_WEEK = 60*60*24*7
 
-    def __init__(self, settings):
+    def __init__(self, settings, notebook):
         self._settings = settings
+        self._notebook = notebook
 
     def notify_update_if_needed(self, update_notification_callback, ignore_check_condition=False, show_no_update=False):
         if ignore_check_condition:
@@ -55,9 +57,10 @@ def notify_update_if_needed(self, update_notification_callback, ignore_check_con
             checking_version = self._should_check()
             dev_version = parse_version(self.VERSION).is_devrelease
         if checking_version and self._is_new_version_available():
-            update_notification_callback(self._newest_version, self._download_url, self._settings)
+            update_notification_callback(self._newest_version, self._download_url, self._settings, self._notebook)
         if checking_version and dev_version:
-            upgrade_from_dev_dialog(version_installed=self.VERSION, show_no_update=show_no_update)
+            upgrade_from_dev_dialog(version_installed=self.VERSION, notebook=self._notebook,
+                                    show_no_update=show_no_update)
 
     def _should_check(self):
         if self._settings.get(_CHECK_FOR_UPDATES_SETTING, None) is None:
@@ -98,7 +101,7 @@ def _get_response(params, method):
         return xml
 
 
-def upgrade_from_dev_dialog(version_installed, show_no_update=False):
+def upgrade_from_dev_dialog(version_installed, notebook, show_no_update=False):
     dev_version = urllib2.urlopen('https://raw.githubusercontent.com/robotframework/'
                                   'RIDE/master/src/robotide/version.py', timeout=1).read().decode('utf-8')
     matches = re.findall(r"VERSION\s*=\s*'([\w.]*)'", dev_version)
@@ -114,7 +117,7 @@ def upgrade_from_dev_dialog(version_installed, show_no_update=False):
                                         f"{SPC}\n", wx.GetActiveWindow(),  no_default=True):
             return False
         else:
-            do_upgrade(command)
+            do_upgrade(command, notebook)
             return True
     else:
         if show_no_update:
@@ -147,9 +150,29 @@ def _add_content_to_clipboard(content):
     wx.TheClipboard.Close()
 
 
-def do_upgrade(command):
+@dataclass
+class Command:
+    def __init__(self, name, command, documentation):
+        self.name = name
+        self.command = command
+        self.documentation = documentation
+
+
+def do_upgrade(command, notebook):
     _add_content_to_clipboard(command)
-    # print("DEBUG: Here will be the installation step.")
+    # print("DEBUG: Here will be the installation step.") # DEBUG 'pip list'
+    from ..run import ui
+    config = Command('Upgrade RIDE', command, 'Uses pip to upgrade RIDE.')
+    result = ui.Runner(config, notebook).run()
+
+    # result = _askyesno(_("Completed Upgrade"), f"\n{SPC}{_('You should close this RIDE (Process ID = ')}{result}){SPC}",
+    #           wx.GetActiveWindow())
+
+    print(f"DEBUG: do_upgrade result={result}")
+    result = 0
+    time.sleep(10)
+    # wx.Exit()
+    """
     my_pid = psutil.Process()
     my_pip = subprocess.Popen(command.split(' '), stdout=subprocess.PIPE, stderr=subprocess.PIPE)
     result = None
@@ -165,16 +188,8 @@ def do_upgrade(command):
         result = my_pip.returncode
         if result == 0:
             break
-        """ DEBUG: need to get outs line by line
-        except subprocess.SubprocessError:
-            my_pip.kill()
-            outs, errs = my_pip.communicate()
-            result = False
-            # DEBUG: Add output to a notebook tab
-            print(f"{outs}\n")
-            print(f"{errs}\n")
-        """
         time.sleep(1)
+    """
     if result != 0:
         _askyesno(_("Failed to Upgrade"), f"{SPC}{_('An error occurred when installing new version')}",
                   wx.GetActiveWindow())
@@ -185,8 +200,13 @@ def do_upgrade(command):
     """ Not working well:
     wx.CallLater(10000, psutil.Process.kill, my_pid.pid)
     """
-    _askyesno(_("Completed Upgrade"), f"\n{SPC}{_('You should close this RIDE (Process ID = ')}{my_pid.pid}){SPC}",
-              wx.GetActiveWindow())
+    result = _askyesno(_("Completed Upgrade"), f"\n{SPC}{_('You should close this RIDE (Process ID = ')}{result}){SPC}",
+                       wx.GetActiveWindow())
+    if result:
+        time.sleep(10)
+        wx.App.Get().OnExit()
+    # _askyesno(_("Completed Upgrade"), f"\n{SPC}{_('You should close this RIDE (Process ID = ')}{my_pid.pid}){SPC}",
+    #           wx.GetActiveWindow())
 
 
 class LocalHtmlWindow(HtmlWindow):
@@ -201,8 +221,9 @@ def OnLinkClicked(self, link):  # Overrides wx method
 
 class UpdateDialog(RIDEDialog):
 
-    def __init__(self, uversion, url, settings, modal=True):
+    def __init__(self, uversion, url, settings, notebook, modal=True):
         self._settings = settings
+        self._notebook = notebook
         self._command = sys.executable + f" -m pip install -U robotframework-ride=={uversion}"
         _add_content_to_clipboard(self._command)
         RIDEDialog.__init__(self, title=_("Update available"), size=(600, 400),
@@ -262,4 +283,4 @@ def on_checkbox_change(self, event):
     def on_upgrade_now(self, event):
         __ = event
         _add_content_to_clipboard(self._command)
-        do_upgrade(self._command)
+        do_upgrade(self._command, self._notebook)
diff --git a/src/robotide/contrib/testrunner/runprofiles.py b/src/robotide/contrib/testrunner/runprofiles.py
index 50d4898c8..6e01f3025 100644
--- a/src/robotide/contrib/testrunner/runprofiles.py
+++ b/src/robotide/contrib/testrunner/runprofiles.py
@@ -427,9 +427,12 @@ def _get_log_options_panel(self, parent):
                               self.on_collapsible_pane_changed,
                               collapsible_pane)
         pane = collapsible_pane.GetPane()
+        pane.SetThemeEnabled(False)
         pane.SetBackgroundColour(self._mysettings.color_background)
         pane.SetForegroundColour(self._mysettings.color_foreground)
         label = Label(pane, label=_("Output directory: "))
+        label.SetBackgroundColour(self._mysettings.color_background)
+        label.SetForegroundColour(self._mysettings.color_foreground)
         self._output_directory_text_ctrl = \
             self._create_text_ctrl(pane, self.output_directory,
                                    "removed due unicode_error (delete this)",
@@ -499,6 +502,7 @@ def _get_arguments_panel(self, parent):
                               self.on_collapsible_pane_changed,
                               collapsible_pane)
         pane = collapsible_pane.GetPane()
+        pane.SetThemeEnabled(False)
         pane.SetBackgroundColour(self._mysettings.color_background)
         pane.SetForegroundColour(self._mysettings.color_foreground)
         self._args_text_ctrl = \
@@ -567,6 +571,7 @@ def _get_tags_panel(self, parent):
                               self.on_collapsible_pane_changed,
                               collapsible_pane)
         pane = collapsible_pane.GetPane()
+        pane.SetThemeEnabled(False)
         pane.SetBackgroundColour(self._mysettings.color_background)
         pane.SetForegroundColour(self._mysettings.color_foreground)
         include_cb = self._create_checkbox(pane, self.apply_include_tags,
@@ -620,20 +625,22 @@ def on_exclude_tags_changed(self, evt):
         _ = evt
         self.set_setting("exclude_tags", self._exclude_tags_text_ctrl.GetValue())
 
-    @staticmethod
-    def _create_checkbox(parent, value, title, handler):
+    def _create_checkbox(self, parent, value, title, handler):
         checkbox = wx.CheckBox(parent, wx.ID_ANY, title)
         checkbox.SetValue(value)
+        checkbox.SetBackgroundColour(self._mysettings.color_background)
+        checkbox.SetForegroundColour(self._mysettings.color_foreground)
         parent.Bind(wx.EVT_CHECKBOX, handler, checkbox)
         return checkbox
 
-    @staticmethod
-    def _create_text_ctrl(parent, value, value_for_error,
+    def _create_text_ctrl(self, parent, value, value_for_error,
                           text_change_handler, enable=True):
         try:
             text_ctrl = wx.TextCtrl(parent, wx.ID_ANY, value=value)
         except UnicodeError:
             text_ctrl = wx.TextCtrl(parent, wx.ID_ANY, value=value_for_error)
+        text_ctrl.SetBackgroundColour(self._mysettings.color_background)
+        text_ctrl.SetForegroundColour(self._mysettings.color_foreground)
         text_ctrl.Bind(wx.EVT_TEXT, text_change_handler)
         text_ctrl.Enable(enable)
         return text_ctrl
diff --git a/src/robotide/editor/contentassist.py b/src/robotide/editor/contentassist.py
index 8297ee9fb..d19b2fbc0 100755
--- a/src/robotide/editor/contentassist.py
+++ b/src/robotide/editor/contentassist.py
@@ -360,9 +360,9 @@ def __init__(self, parent, suggestion_source, size=wx.DefaultSize):
         super().__init__(suggestion_source, parent=parent,
                          size=size, style=wx.WANTS_CHARS | wx.TE_NOHIDESEL)
         self.SetBackgroundColour(Colour(self.color_background_help))
-        self.SetOwnBackgroundColour(Colour(self.color_background_help))
+        # self.SetOwnBackgroundColour(Colour(self.color_background_help))
         self.SetForegroundColour(Colour(self.color_foreground_text))
-        self.SetOwnForegroundColour(Colour(self.color_foreground_text))
+        # self.SetOwnForegroundColour(Colour(self.color_foreground_text))
 
 
 class ContentAssistTextEditor(_ContentAssistTextCtrlBase):
@@ -373,9 +373,9 @@ def __init__(self, parent, suggestion_source, pos, size=wx.DefaultSize):
                          style=wx.WANTS_CHARS | wx.BORDER_NONE | wx.WS_EX_TRANSIENT | wx.TE_PROCESS_ENTER |
                          wx.TE_NOHIDESEL)
         self.SetBackgroundColour(Colour(self.color_background_help))
-        self.SetOwnBackgroundColour(Colour(self.color_background_help))
+        # self.SetOwnBackgroundColour(Colour(self.color_background_help))
         self.SetForegroundColour(Colour(self.color_foreground_text))
-        self.SetOwnForegroundColour(Colour(self.color_foreground_text))
+        # self.SetOwnForegroundColour(Colour(self.color_foreground_text))
 
 
 class ContentAssistFileButton(FileBrowseButton):
@@ -389,9 +389,9 @@ def __init__(self, parent, suggestion_source, label, controller, size=wx.Default
         self._browsed = False
 
         self.SetBackgroundColour(Colour(context.POPUP_BACKGROUND))
-        self.SetOwnBackgroundColour(Colour(context.POPUP_BACKGROUND))
+        # self.SetOwnBackgroundColour(Colour(context.POPUP_BACKGROUND))
         self.SetForegroundColour(Colour(context.POPUP_FOREGROUND))
-        self.SetOwnForegroundColour(Colour(context.POPUP_FOREGROUND))
+        # self.SetOwnForegroundColour(Colour(context.POPUP_FOREGROUND))
 
     def Bind(self, *args):
         self.textControl.Bind(*args)
diff --git a/src/robotide/editor/editordialogs.py b/src/robotide/editor/editordialogs.py
index 2bcc13199..5805268bd 100644
--- a/src/robotide/editor/editordialogs.py
+++ b/src/robotide/editor/editordialogs.py
@@ -91,9 +91,9 @@ def _create_buttons(self, **kwargs):
         for item in self.GetChildren():
             if isinstance(item, (wx.Button, wx.BitmapButton, ButtonWithHandler)):
                 item.SetBackgroundColour(Colour(self.color_secondary_background))
-                item.SetOwnBackgroundColour(Colour(self.color_secondary_background))
+                # item.SetOwnBackgroundColour(Colour(self.color_secondary_background))
                 item.SetForegroundColour(Colour(self.color_secondary_foreground))
-                item.SetOwnForegroundColour(Colour(self.color_secondary_foreground))
+                # item.SetOwnForegroundColour(Colour(self.color_secondary_foreground))
         self._sizer.Add(buttons, 0, wx.ALIGN_CENTER | wx.ALL, 5)
         self._sizer.Fit(self)
 
diff --git a/src/robotide/editor/fieldeditors.py b/src/robotide/editor/fieldeditors.py
index 819176292..6bbe52d9a 100644
--- a/src/robotide/editor/fieldeditors.py
+++ b/src/robotide/editor/fieldeditors.py
@@ -71,9 +71,9 @@ def _create_editor(self, value, label, settings):
     def _get_text_ctrl(self):
         editor = wx.TextCtrl(self, size=(600, -1))
         editor.SetBackgroundColour(Colour(self.color_secondary_background))
-        editor.SetOwnBackgroundColour(Colour(self.color_secondary_background))
+        # editor.SetOwnBackgroundColour(Colour(self.color_secondary_background))
         editor.SetForegroundColour(Colour(self.color_secondary_foreground))
-        editor.SetOwnForegroundColour(Colour(self.color_secondary_foreground))
+        # editor.SetOwnForegroundColour(Colour(self.color_secondary_foreground))
         return editor
 
     def set_validator(self, validator):
@@ -199,9 +199,9 @@ def _create_column_selector(self, cols):
         tool_tip.GetWindow().SetForegroundColour(Colour(self.color_foreground_text))
         # DEBUG attributes = self.GetClassDefaultAttributes()
         combo.SetBackgroundColour(Colour(self.color_secondary_background))
-        combo.SetOwnBackgroundColour(Colour(self.color_secondary_background))
+        # combo.SetOwnBackgroundColour(Colour(self.color_secondary_background))
         combo.SetForegroundColour(Colour(self.color_secondary_foreground))
-        combo.SetOwnForegroundColour(Colour(self.color_secondary_foreground))
+        # combo.SetOwnForegroundColour(Colour(self.color_secondary_foreground))
         self.Bind(wx.EVT_COMBOBOX, self.on_columns, source=combo)
         sizer.Add(combo)
         # DEBUG children = self.GetChildren()
diff --git a/src/robotide/editor/listeditor.py b/src/robotide/editor/listeditor.py
index 4d99ba943..a383b671c 100644
--- a/src/robotide/editor/listeditor.py
+++ b/src/robotide/editor/listeditor.py
@@ -195,9 +195,9 @@ def __init__(self, parent, columns, color_foreground='black',
         self.color_foreground = color_foreground
         self.color_background = color_background
         self.SetBackgroundColour(Colour(color_background))
-        self.SetOwnBackgroundColour(Colour(color_background))
+        # self.SetOwnBackgroundColour(Colour(color_background))
         self.SetForegroundColour(Colour(color_foreground))
-        self.SetOwnForegroundColour(Colour(color_foreground))
+        # self.SetOwnForegroundColour(Colour(color_foreground))
         # self.EnableAlternateRowColours(True)
         self._parent = parent
         self._doc_language = None
diff --git a/src/robotide/editor/settingeditors.py b/src/robotide/editor/settingeditors.py
index 66978eaa3..976bd48bb 100755
--- a/src/robotide/editor/settingeditors.py
+++ b/src/robotide/editor/settingeditors.py
@@ -57,9 +57,9 @@ def __init__(self, parent, controller, plugin, tree):
         self.font_face = self.general_settings.get('font face', '')
         self.font_size = self.general_settings.get('font size', 11)
         self.SetBackgroundColour(Colour(self.color_background))
-        self.SetOwnBackgroundColour(Colour(self.color_background))
+        # self.SetOwnBackgroundColour(Colour(self.color_background))
         self.SetForegroundColour(Colour(self.color_foreground))
-        self.SetOwnForegroundColour(Colour(self.color_foreground))
+        # self.SetOwnForegroundColour(Colour(self.color_foreground))
         self._controller = controller
         try:
             set_lang = shared_memory.ShareableList(name="language")
@@ -577,9 +577,9 @@ def __init__(self, parent, tree, controller, lang=None):
             self._language = ['en']
         _AbstractListEditor.__init__(self, parent, tree, controller)
         self.SetBackgroundColour(Colour(self.color_background))
-        self.SetOwnBackgroundColour(Colour(self.color_background))
+        # self.SetOwnBackgroundColour(Colour(self.color_background))
         self.SetForegroundColour(Colour(self.color_foreground))
-        self.SetOwnForegroundColour(Colour(self.color_foreground))
+        # self.SetOwnForegroundColour(Colour(self.color_foreground))
 
     def _create_buttons(self):
         sizer = wx.BoxSizer(wx.VERTICAL)
diff --git a/src/robotide/postinstall/__init__.py b/src/robotide/postinstall/__init__.py
index c941a3513..ecf2be305 100644
--- a/src/robotide/postinstall/__init__.py
+++ b/src/robotide/postinstall/__init__.py
@@ -128,9 +128,9 @@ def _create_buttons(self, sizer, no_default=False):
         for item in self.GetChildren():
             if isinstance(item, (wx.Button, wx.BitmapButton)):
                 item.SetBackgroundColour(Colour(self.color_secondary_background))
-                item.SetOwnBackgroundColour(Colour(self.color_secondary_background))
+                # item.SetOwnBackgroundColour(Colour(self.color_secondary_background))
                 item.SetForegroundColour(Colour(self.color_secondary_foreground))
-                item.SetOwnForegroundColour(Colour(self.color_secondary_foreground))
+                # item.SetOwnForegroundColour(Colour(self.color_secondary_foreground))
         self.Sizer.Add(buttons, flag=wx.ALIGN_CENTER | wx.ALL, border=5)
 
 
diff --git a/src/robotide/preferences/editor.py b/src/robotide/preferences/editor.py
index b86eaeffc..bfa1f0723 100644
--- a/src/robotide/preferences/editor.py
+++ b/src/robotide/preferences/editor.py
@@ -64,9 +64,11 @@ def __init__(self, parent, title, preferences, style="auto"):
         self.font.SetPointSize(self._general_settings[FONT_SIZE])
         self.SetFont(self.font)
         self.SetBackgroundColour(Colour(self._general_settings['background']))
-        self.SetOwnBackgroundColour(Colour(self._general_settings['secondary background']))
+        ## self.SetOwnBackgroundColour(Colour(200, 222, 40))
+        ## self.SetOwnForegroundColour(Colour(7, 0, 70))
+        # self.SetOwnBackgroundColour(Colour(self._general_settings['secondary background']))
         self.SetForegroundColour(Colour(self._general_settings['foreground']))
-        self.SetOwnForegroundColour(Colour(self._general_settings['secondary foreground']))
+        # self.SetOwnForegroundColour(Colour(self._general_settings['secondary foreground']))
         self._closing = False
 
         panels = preferences.preference_panels
@@ -222,6 +224,10 @@ def __init__(self, *args, **kwargs):
         self.title.SetFont(font)
         self.title.SetForegroundColour(self.settings['foreground'])
         self.title.SetBackgroundColour(self.settings['background'])
+        # self.title.SetBackgroundColour(Colour(200, 222, 40))
+        # self.title.SetForegroundColour(Colour(7, 0, 70))
+        # self.SetBackgroundColour(Colour(200, 222, 40))
+        # self.SetForegroundColour(Colour(7, 0, 70))
         self.SetForegroundColour(self.settings['foreground'])
         self.SetBackgroundColour(self.settings['background'])
 
@@ -236,10 +242,17 @@ def ShowPanel(self, panel):
         if self._current_panel is not None:
             self._current_panel.Hide()
         self._current_panel = panel
-        self.SetForegroundColour(self.settings['foreground'])
-        self.SetBackgroundColour(self.settings['background'])
-        panel.SetForegroundColour(self.settings['foreground'])
-        panel.SetBackgroundColour(self.settings['background'])
+        ## self.SetForegroundColour(self.settings['foreground'])
+        ## self.SetOwnBackgroundColour(self.settings['background'])
+        ## self.SetOwnForegroundColour(Colour(255, 255, 255))
+        ## self.SetBackgroundColour(self.settings['background'])
+        panel.SetForegroundColour(self.settings['foreground'])  # Critical text all black on
+        panel.SetBackgroundColour(self.settings['background'])  # Black background
+        ## self.SetBackgroundColour(Colour(200, 222, 40))
+        ## self.SetForegroundColour(Colour(7, 0, 70))
+        ## panel.SetBackgroundColour(Colour(200, 222, 40))
+        ## panel.SetForegroundColour(Colour(255, 255, 255))
+        ## panel.SetForegroundColour(Colour(7, 0, 70))
         panel.Show()
         sizer = self.panels_container.GetSizer()
         item = sizer.GetItem(panel)
diff --git a/src/robotide/preferences/editors.py b/src/robotide/preferences/editors.py
index 018c4291d..cfe87851b 100644
--- a/src/robotide/preferences/editors.py
+++ b/src/robotide/preferences/editors.py
@@ -19,6 +19,7 @@
 from wx import Colour
 from wx.lib.masked import NumCtrl
 
+from .settings import RideSettings
 from ..ui.preferences_dialogs import (PreferencesPanel, SpinChoiceEditor, IntegerChoiceEditor, boolean_editor,
                                       StringChoiceEditor, PreferencesColorPicker)
 from ..widgets import Label
@@ -57,9 +58,9 @@ def read_fonts(fixed=False):
 
 def set_colors(element, bk_color, fg_color):
     element.SetBackgroundColour(bk_color)
-    element.SetOwnBackgroundColour(bk_color)
+    # element.SetOwnBackgroundColour(bk_color)
     element.SetForegroundColour(fg_color)
-    element.SetOwnForegroundColour(fg_color)
+    # element.SetOwnForegroundColour(fg_color)
 
 
 class EditorPreferences(PreferencesPanel):
@@ -70,6 +71,9 @@ def __init__(self, settings, *args, **kwargs):
         self._color_pickers = []
         self.name = None
 
+        self._gsettings = RideSettings()
+        self.settings = self._gsettings['General']
+
         # what would make this UI much more usable is if there were a
         # preview window in the dialog that showed all the colors. I
         # don't have the time to do that right now, so this will have
@@ -81,6 +85,8 @@ def __init__(self, settings, *args, **kwargs):
         buttons_sizer = wx.BoxSizer(orient=wx.HORIZONTAL)
         reset = wx.Button(self, wx.ID_ANY, _('Reset colors to default'))
         saveloadsettings = wx.Button(self, ID_SAVELOADSETTINGS, _('Save or Load settings'))
+        set_colors(reset, self.secondary_background_color, self.secondary_foreground_color)
+        set_colors(saveloadsettings, self.secondary_background_color, self.secondary_foreground_color)
         main_sizer.Add(font_editor)
         main_sizer.Add(colors_sizer)
         buttons_sizer.Add(reset)
@@ -95,6 +101,8 @@ def on_save_load_settings(self, event):
         raise NotImplementedError('Implement me')
 
     def on_reset(self, event):
+        if not self.name:
+            self.name = "Grid"
         defaults = self._read_defaults()
         for picker in self._color_pickers:
             picker.SetColour(defaults[picker.key])
@@ -107,7 +115,7 @@ def _read_defaults(self, plugin=False):
         for line in settings[start_index:]:
             if line.startswith('['):
                 break
-            if not line:
+            if not line or line.startswith(';') or line.startswith('#'):
                 continue
             key, value = [s.strip().strip('\'') for s in line.split("=")]
             defaults[key] = value
@@ -123,30 +131,24 @@ def _create_font_editor(self):
             [str(i) for i in range(8, 16)])
         sizer = wx.FlexGridSizer(rows=4, cols=2, vgap=10, hgap=30)
         l_size = f.label(self)
-        background_color = Colour(LIGHT_GRAY)
-        foreground_color = Colour("black")
-        if IS_WINDOWS:
-            set_colors(l_size, background_color, foreground_color)
+        set_colors(l_size, self.background_color, self.foreground_color)
         sizer.AddMany([l_size, f.chooser(self)])
         fixed_font = False
         if 'zoom factor' in self._settings:
             z = SpinChoiceEditor(
                 self._settings, 'zoom factor', _('Zoom Factor'), (-10, 20))
             l_zoom = z.label(self)
-            if IS_WINDOWS:
-                set_colors(l_zoom, background_color, foreground_color)
+            set_colors(l_zoom, self.background_color, self.foreground_color)
             sizer.AddMany([l_zoom, z.chooser(self)])
         if FIXED_FONT in self._settings:
             l_ff, editor = boolean_editor(self, self._settings, FIXED_FONT, _('Use fixed width font'))
-            if IS_WINDOWS:
-                set_colors(l_ff, background_color, foreground_color)
+            set_colors(l_ff, self.background_color, self.foreground_color)
             sizer.AddMany([l_ff, editor])
             fixed_font = self._settings[FIXED_FONT]
         if 'font face' in self._settings:
             s = StringChoiceEditor(self._settings, 'font face', _('Font Face'), read_fonts(fixed_font))
             l_font = s.label(self)
-            if IS_WINDOWS:
-                set_colors(l_font, background_color, foreground_color)
+            set_colors(l_font, self.background_color, self.foreground_color)
             sizer.AddMany([l_font, s.chooser(self)])
         return sizer
 
@@ -189,15 +191,12 @@ def create_colors_sizer(self):
                 ('setting', _('Text foreground')),
                 ('background', TEXT_BACKGROUND),
             )
-        background_color = Colour(LIGHT_GRAY)
-        foreground_color = Colour("black")
         for settings_key, label_text in settings:
             if column == 4:
                 column = 0
                 row += 1
             label = wx.StaticText(self, wx.ID_ANY, label_text)
-            if IS_WINDOWS:
-                set_colors(label, background_color, foreground_color)
+            set_colors(label, self.background_color, self.foreground_color)
             button = PreferencesColorPicker(
                 self, wx.ID_ANY, self._settings, settings_key)
             container.Add(button, (row, column),
@@ -220,6 +219,8 @@ def on_save_load_settings(self, event):
             picker.SetColour(self._settings[picker.key])
 
     def on_reset(self, event):
+        if not self.name:
+            self.name = "Text Edit"
         defaults = self._read_defaults()
         for picker in self._color_pickers:
             picker.SetColour(defaults[picker.key])
@@ -227,12 +228,9 @@ def on_reset(self, event):
     def _create_text_config_editor(self):
         settings = self._settings
         sizer = wx.FlexGridSizer(rows=2, cols=2, vgap=10, hgap=10)
-        background_color = Colour(LIGHT_GRAY)
-        foreground_color = Colour("black")
         l_auto_suggest, editor = boolean_editor(self, settings, 'enable auto suggestions',
                                                 _('Enable auto suggestions'))
-        if IS_WINDOWS:
-            set_colors(l_auto_suggest, background_color, foreground_color)
+        set_colors(l_auto_suggest, self.background_color, self.foreground_color)
         sizer.AddMany([l_auto_suggest, editor])
         return sizer
 
@@ -252,29 +250,22 @@ def _create_grid_config_editor(self):
         settings = self._settings
         sizer = wx.FlexGridSizer(rows=6, cols=2, vgap=10, hgap=10)
         l_col_size = self._label_for(_('Default column size'))
-        background_color = Colour(LIGHT_GRAY)
-        foreground_color = Colour("black")
-        if IS_WINDOWS:
-            set_colors(l_col_size, background_color, foreground_color)
+        set_colors(l_col_size, self.background_color, self.foreground_color)
         sizer.Add(l_col_size)
         sizer.Add(self._number_editor(settings, 'col size'))
         l_auto_size, editor = boolean_editor(self, settings, 'auto size cols', _('Auto size columns'))
-        if IS_WINDOWS:
-            set_colors(l_auto_size, background_color, foreground_color)
+        set_colors(l_auto_size, self.background_color, self.foreground_color)
         sizer.AddMany([l_auto_size, editor])
         l_max_size = self._label_for(_('Max column size\n(applies when auto size is on)'))
-        if IS_WINDOWS:
-            set_colors(l_max_size, background_color, foreground_color)
+        set_colors(l_max_size, self.background_color, self.foreground_color)
         sizer.Add(l_max_size)
         sizer.Add(self._number_editor(settings, 'max col size'))
         l_word_wrap, editor = boolean_editor(self, settings, 'word wrap', _('Word wrap and auto size rows'))
-        if IS_WINDOWS:
-            set_colors(l_word_wrap, background_color, foreground_color)
+        set_colors(l_word_wrap, self.background_color, self.foreground_color)
         sizer.AddMany([l_word_wrap, editor])
         l_auto_suggest, editor = boolean_editor(self, settings, 'enable auto suggestions',
                                                 _('Enable auto suggestions'))
-        if IS_WINDOWS:
-            set_colors(l_auto_suggest, background_color, foreground_color)
+        set_colors(l_auto_suggest, self.background_color, self.foreground_color)
         sizer.AddMany([l_auto_suggest, editor])
         return sizer
 
@@ -285,12 +276,7 @@ def _label_for(self, name):
     def _number_editor(self, settings, name):
         initial_value = settings[name]
         editor = NumCtrl(self, value=initial_value, integerWidth=3, allowNone=True)
-        """
-        editor.SetBackgroundColour(Colour(200, 222, 40))
-        editor.SetOwnBackgroundColour(Colour(200, 222, 40))
-        editor.SetForegroundColour(Colour(7, 0, 70))
-        editor.SetOwnForegroundColour(Colour(7, 0, 70))
-        """
+        set_colors(editor, self.background_color, self.foreground_color)
         editor.Bind(wx.EVT_TEXT, lambda evt: self._set_value(editor, name))
         return editor
 
@@ -319,10 +305,7 @@ def _create_foreground_pickers(self, colors_sizer):
             ('text empty', _('Empty Foreground')),
         ):
             lbl = wx.StaticText(self, wx.ID_ANY, label)
-            if IS_WINDOWS:
-                background_color = Colour(LIGHT_GRAY)
-                foreground_color = Colour("black")
-                set_colors(lbl, background_color, foreground_color)
+            set_colors(lbl, self.background_color, self.foreground_color)
             btn = PreferencesColorPicker(
                 self, wx.ID_ANY, self._settings, key)
             self._color_pickers.append(btn)
@@ -334,8 +317,6 @@ def _create_foreground_pickers(self, colors_sizer):
 
     def _create_background_pickers(self, colors_sizer):
         row = 0
-        background_color = Colour(LIGHT_GRAY)
-        foreground_color = Colour("black")
         for key, label in (
                 ('background assign', _('Variable Background')),
                 ('background keyword', _('Keyword Background')),
@@ -347,8 +328,7 @@ def _create_background_pickers(self, colors_sizer):
                 ('background highlight', _('Highlight Background'))
         ):
             lbl = wx.StaticText(self, wx.ID_ANY, label)
-            if IS_WINDOWS:
-                set_colors(lbl, background_color, foreground_color)
+            set_colors(lbl, self.background_color, self.foreground_color)
             btn = PreferencesColorPicker(
                 self, wx.ID_ANY, self._settings, key)
             self._color_pickers.append(btn)
@@ -378,7 +358,9 @@ def __init__(self, settings, *args, **kwargs):
         self.name = "Test Runner"
         super(TestRunnerPreferences, self).__init__(
             settings['Plugins'][self.name], *args, **kwargs)
-        self.Sizer.Add(wx.StaticText(self, wx.ID_ANY, _("Colors will be active after next RIDE restart.")))
+        help_color = wx.StaticText(self, wx.ID_ANY, _("Colors will be active after next RIDE restart."))
+        set_colors(help_color, self.background_color, self.foreground_color)
+        self.Sizer.Add(help_color)
         self.Sizer.Add(self._create_test_runner_config_editor())
 
     def _create_test_runner_config_editor(self):
@@ -395,11 +377,8 @@ def _create_test_runner_config_editor(self):
                                               f"{_('Shows console colors set by')} {add_colors} ")
         l_confirm, editor = boolean_editor(self, settings, 'confirm run',
                                            _('Asks for confirmation to run all tests if none selected '))
-        if IS_WINDOWS:
-            background_color = Colour(LIGHT_GRAY)
-            foreground_color = Colour("black")
-            set_colors(l_confirm, background_color, foreground_color)
-            set_colors(l_usecolor, background_color, foreground_color)
+        set_colors(l_confirm, self.background_color, self.foreground_color)
+        set_colors(l_usecolor, self.background_color, self.foreground_color)
         sizer.AddMany([l_usecolor, usecolor])
         sizer.AddMany([l_confirm, editor])
         return sizer
@@ -408,8 +387,6 @@ def create_colors_sizer(self):
         container = wx.GridBagSizer()
         row = 0
         column = 0
-        background_color = Colour(LIGHT_GRAY)
-        foreground_color = Colour("black")
         for settings_key, label_text in (
                 ('foreground', _('Text foreground')),
                 ('background', TEXT_BACKGROUND),
@@ -422,8 +399,7 @@ def create_colors_sizer(self):
                 column = 0
                 row += 1
             label = wx.StaticText(self, wx.ID_ANY, label_text)
-            if IS_WINDOWS:
-                set_colors(label, background_color, foreground_color)
+            set_colors(label, self.background_color, self.foreground_color)
             button = PreferencesColorPicker(
                 self, wx.ID_ANY, self._settings, settings_key)
             container.Add(button, (row, column),
@@ -446,6 +422,8 @@ def on_save_load_settings(self, event):
             picker.SetColour(self._settings[picker.key])
 
     def on_reset(self, event):
+        if not self.name:
+            self.name = "Test Runner"
         defaults = self._read_defaults(plugin=True)
         for picker in self._color_pickers:
             picker.SetColour(defaults[picker.key])
diff --git a/src/robotide/preferences/general.py b/src/robotide/preferences/general.py
index 26a491382..36fe333fd 100644
--- a/src/robotide/preferences/general.py
+++ b/src/robotide/preferences/general.py
@@ -20,8 +20,6 @@
 from ..ui.preferences_dialogs import (boolean_editor, PreferencesPanel, IntegerChoiceEditor, SpinChoiceEditor,
                                       StringChoiceEditor, PreferencesColorPicker)
 from .managesettingsdialog import SaveLoadSettings
-from wx import Colour
-from ..context import IS_WINDOWS
 try:
     from robot.conf import languages
 except ImportError:
@@ -66,9 +64,9 @@ def read_languages():
 
 def set_colors(element, bk_color, fg_color):
     element.SetBackgroundColour(bk_color)
-    element.SetOwnBackgroundColour(bk_color)
+    # element.SetOwnBackgroundColour(bk_color)
     element.SetForegroundColour(fg_color)
-    element.SetOwnForegroundColour(fg_color)
+    # element.SetOwnForegroundColour(fg_color)
 
 
 class GeneralPreferences(PreferencesPanel):
@@ -79,7 +77,10 @@ def __init__(self, settings, *args, **kwargs):
         self._color_pickers = []
         self.name = 'General'
         self._apply_to_panels = self._settings.get('apply to panels', False)
-
+        self.background_color = self.settings['background']
+        self.foreground_color = self.settings['foreground']
+        self.sbackground_color = self.settings['secondary background']
+        self.sforeground_color = self.settings['secondary foreground']
         # what would make this UI much more usable is if there were a
         # preview window in the dialog that showed all the colors. I
         # don't have the time to do that right now, so this will have
@@ -96,10 +97,9 @@ def __init__(self, settings, *args, **kwargs):
                                               label=_("Apply to Project and File Explorer panels"))
         self.cb_apply_to_panels.Enable()
         self.cb_apply_to_panels.SetValue(self._apply_to_panels)
-        if IS_WINDOWS:
-            background_color = Colour(LIGHT_GRAY)
-            foreground_color = Colour("black")
-            set_colors(self.cb_apply_to_panels, background_color, foreground_color)
+        set_colors(self.cb_apply_to_panels, self.background_color, self.foreground_color)
+        set_colors(reset, self.sbackground_color, self.sforeground_color)
+        set_colors(saveloadsettings, self.sbackground_color, self.sforeground_color)
         # set_colors(ui_language, Colour(self.color_background), Colour(self.color_foreground))
         main_sizer.Add(font_editor)
         main_sizer.Add(colors_sizer)
@@ -152,7 +152,7 @@ def _reload_settings(self):
         for line in settings[start_index:]:
             if line.startswith('['):
                 break
-            if not line:
+            if not line or line.startswith(';') or line.startswith('#'):
                 continue
             key, value = [s.strip().strip('\'') for s in line.split("=")]
             # print(f"DEBUG: Preferences General default value type {type(value)} {value}")
@@ -174,8 +174,9 @@ def _read_defaults(self, plugin=False):
         for line in settings[start_index:]:
             if line.startswith('['):
                 break
-            if not line:
+            if not line or line.startswith(';') or line.startswith('#'):
                 continue
+            # print(f"DEBUG: Preferences General RESET default line {line} \nLine Split: {line.split("=")}")
             key, value = [s.strip().strip('\'') for s in line.split("=")]
             # print(f"DEBUG: Preferences General default value type {type(value)} {value}")
             if len(value) > 0 and value[0] == '(' and value[-1] == ')':
@@ -194,43 +195,34 @@ def _create_font_editor(self):
             [str(i) for i in range(8, 16)])
         sizer = wx.FlexGridSizer(rows=3, cols=2, vgap=10, hgap=30)
         l_size = f.label(self)
-        background_color = Colour(LIGHT_GRAY)
-        foreground_color = Colour("black")
-        if IS_WINDOWS:
-            set_colors(l_size, background_color, foreground_color)
+        set_colors(l_size, self.background_color, self.foreground_color)
         sizer.AddMany([l_size, f.chooser(self)])
         fixed_font = False
         if 'zoom factor' in self._settings:
             z = SpinChoiceEditor(
                 self._settings, 'zoom factor', _('Zoom Factor'), (-10, 20))
             l_zoom = z.label(self)
-            if IS_WINDOWS:
-                set_colors(l_zoom, background_color, foreground_color)
+            set_colors(l_zoom, self.background_color, self.foreground_color)
             sizer.AddMany([l_zoom, z.chooser(self)])
         if FIXED_FONT in self._settings:
             l_ff, editor = boolean_editor(self, self._settings, FIXED_FONT, _('Use fixed width font'))
-            if IS_WINDOWS:
-                set_colors(l_ff, background_color, foreground_color)
+            set_colors(l_ff, self.background_color, self.foreground_color)
             sizer.AddMany([l_ff, editor])
             fixed_font = self._settings[FIXED_FONT]
         if 'font face' in self._settings:
             s = StringChoiceEditor(self._settings, 'font face', _('Font Face'), read_fonts(fixed_font))
             l_font = s.label(self)
-            if IS_WINDOWS:
-                set_colors(l_font, background_color, foreground_color)
+            set_colors(l_font, self.background_color, self.foreground_color)
             sizer.AddMany([l_font, s.chooser(self)])
         sizer.Layout()
         return sizer
 
     def _select_ui_language(self):
         sizer = wx.FlexGridSizer(rows=3, cols=2, vgap=10, hgap=30)
-        background_color = Colour(LIGHT_GRAY)
-        foreground_color = Colour("black")
         if 'ui language' in self._settings:
             ll = StringChoiceEditor(self._settings, 'ui language', _('Language'), read_languages())
             l_lang = ll.label(self)
-            if IS_WINDOWS:
-                set_colors(l_lang, background_color, foreground_color)
+            set_colors(l_lang, self.background_color, self.foreground_color)
             sizer.AddMany([l_lang, ll.chooser(self)])
         sizer.Layout()
         return sizer
@@ -260,15 +252,12 @@ def create_colors_sizer(self):
             ('foreground text', _('Text Foreground')),
             ('background help', _('Help Background'))
         )
-        background_color = Colour(LIGHT_GRAY)
-        foreground_color = Colour("black")
         for settings_key, label_text in settings:
             if column == 4:
                 column = 0
                 row += 1
             label = wx.StaticText(self, wx.ID_ANY, label_text)
-            if IS_WINDOWS:
-                set_colors(label, background_color, foreground_color)
+            set_colors(label, self.background_color, self.foreground_color)
             button = PreferencesColorPicker(
                 self, wx.ID_ANY, self._settings, settings_key)
             container.Add(button, (row, column), flag=wx.ALL | wx.ALIGN_CENTER_VERTICAL, border=4)
diff --git a/src/robotide/preferences/imports.py b/src/robotide/preferences/imports.py
index 2c2e31057..534d3a464 100644
--- a/src/robotide/preferences/imports.py
+++ b/src/robotide/preferences/imports.py
@@ -16,9 +16,8 @@
 import builtins
 import wx
 
-from ..context import IS_WINDOWS
+from .settings import RideSettings
 from ..ui.preferences_dialogs import PreferencesPanel, comma_separated_value_editor
-from wx import Colour
 
 _ = wx.GetTranslation  # To keep linter/code analyser happy
 builtins.__dict__['_'] = wx.GetTranslation
@@ -33,8 +32,10 @@ def __init__(self, parent, settings):
         super(PreferencesPanel, self).__init__(parent)
         self.SetSizer(wx.FlexGridSizer(rows=4, cols=2, vgap=10, hgap=5))
         self.Sizer.AddGrowableCol(1, proportion=1)
-        self.background_color = Colour("light gray")
-        self.foreground_color = Colour("black")
+        self._gsettings = RideSettings()
+        self.csettings = self._gsettings['General']
+        self.background_color = self.csettings['background']
+        self.foreground_color = self.csettings['foreground']
         self._add_settings(settings)
 
     def _add_settings(self, settings):
@@ -51,10 +52,7 @@ def _add_settings(self, settings):
 
     def _create_list_setting_editor(self, settings, name, _help):
         label, editor = comma_separated_value_editor(self, settings, name, name.capitalize(), _help)
-        if IS_WINDOWS:
-            label.SetForegroundColour(self.foreground_color)
-            label.SetBackgroundColour(self.background_color)
-            label.SetOwnBackgroundColour(self.background_color)
-            label.SetOwnForegroundColour(self.foreground_color)
+        label.SetForegroundColour(self.foreground_color)
+        label.SetBackgroundColour(self.background_color)
         self.Sizer.Add(label)
-        self.Sizer.Add(editor, flag=wx.EXPAND)
+        self.Sizer.Add(editor)  #, flag=wx.EXPAND)
diff --git a/src/robotide/preferences/managesettingsdialog.py b/src/robotide/preferences/managesettingsdialog.py
index cf3857885..7c280cd04 100644
--- a/src/robotide/preferences/managesettingsdialog.py
+++ b/src/robotide/preferences/managesettingsdialog.py
@@ -49,6 +49,10 @@ def __init__(self, parent, settings):
         self.SetSizer(VerticalSizer())
         self.SetBackgroundColour(Colour(self.color_background))
         self.SetForegroundColour(Colour(self.color_foreground))
+        load.SetBackgroundColour(Colour(self.color_secondary_background))
+        load.SetForegroundColour(Colour(self.color_secondary_foreground))
+        save.SetBackgroundColour(Colour(self.color_secondary_background))
+        save.SetForegroundColour(Colour(self.color_secondary_foreground))
         self._default_path = os.path.join(SETTINGS_DIRECTORY, 'settings.cfg')
         directory = wx.StaticText(self, label=f"{_('Current directory:')} {SETTINGS_DIRECTORY}")
         buttons_sizer.Add(load)
diff --git a/src/robotide/preferences/saving.py b/src/robotide/preferences/saving.py
index d09940334..58cc8a9a4 100644
--- a/src/robotide/preferences/saving.py
+++ b/src/robotide/preferences/saving.py
@@ -16,9 +16,8 @@
 import builtins
 import wx
 
-from ..context import IS_WINDOWS
+from .settings import RideSettings
 from ..ui.preferences_dialogs import PreferencesPanel, IntegerChoiceEditor, StringChoiceEditor, boolean_editor
-from wx import Colour
 
 _ = wx.GetTranslation  # To keep linter/code analyser happy
 builtins.__dict__['_'] = wx.GetTranslation
@@ -34,29 +33,27 @@ def __init__(self, settings, *args, **kwargs):
         super(SavingPreferences, self).__init__(name_tr=_('Saving'), *args, **kwargs)
         self._settings = settings
         self.SetSizer(wx.FlexGridSizer(cols=2))
-        self.background_color = Colour("light gray")
-        self.foreground_color = Colour("black")
+        self._gsettings = RideSettings()
+        self.csettings = self._gsettings['General']
+        self.background_color = self.csettings['background']
+        self.foreground_color = self.csettings['foreground']
         for editor in self._create_editors(settings):
             self._add_editor(editor)
         label, selector = boolean_editor(self, settings, 'tasks', _("Is Task?"),
                                          _("Default for Tasks or Tests sections."))
         l_reformat, editor = boolean_editor(self, settings, 'reformat', _('Reformat?'),
                                             _('Should it recalculate identation on Save?'))
-        if IS_WINDOWS:
-            label.SetForegroundColour(self.foreground_color)
-            label.SetBackgroundColour(self.background_color)
-            label.SetOwnBackgroundColour(self.background_color)
-            label.SetOwnForegroundColour(self.foreground_color)
-            l_reformat.SetForegroundColour(self.foreground_color)
-            l_reformat.SetBackgroundColour(self.background_color)
-            l_reformat.SetOwnBackgroundColour(self.background_color)
-            l_reformat.SetOwnForegroundColour(self.foreground_color)
+        label.SetForegroundColour(self.foreground_color)
+        label.SetBackgroundColour(self.background_color)
+        l_reformat.SetForegroundColour(self.foreground_color)
+        l_reformat.SetBackgroundColour(self.background_color)
         self.Sizer.AddMany([label, selector])
         self.Sizer.AddMany([l_reformat, editor])
         self.Sizer.Layout()
         self.Update()
 
-    def _create_editors(self, settings):
+    @staticmethod
+    def _create_editors(settings):
         return [
             StringChoiceEditor(settings, 'default file format', _('Default file format:'),
                                ('txt', 'tsv', 'html', 'robot', 'resource')
@@ -76,10 +73,7 @@ def _create_editors(self, settings):
 
     def _add_editor(self, editor):
         l_editor = editor.label(self)
-        if IS_WINDOWS:
-            l_editor.SetForegroundColour(self.foreground_color)
-            l_editor.SetBackgroundColour(self.background_color)
-            l_editor.SetOwnBackgroundColour(self.background_color)
-            l_editor.SetOwnForegroundColour(self.foreground_color)
+        l_editor.SetForegroundColour(self.foreground_color)
+        l_editor.SetBackgroundColour(self.background_color)
         self.Sizer.AddMany([l_editor, (editor.chooser(self),)])
         self.Sizer.AddMany([(editor.help(self), 0, wx.BOTTOM, 10), wx.Window(self)])
diff --git a/src/robotide/preferences/settings.cfg b/src/robotide/preferences/settings.cfg
index 76efc80d7..a54aa2430 100644
--- a/src/robotide/preferences/settings.cfg
+++ b/src/robotide/preferences/settings.cfg
@@ -67,6 +67,7 @@ enable auto suggestions = True
 [Grid]
 font size = 10
 font face = ''
+zoom factor = 0
 fixed font = False
 col size = 150
 max col size = 450
diff --git a/src/robotide/run/configmanagerui.py b/src/robotide/run/configmanagerui.py
index 10446266c..f8e722808 100644
--- a/src/robotide/run/configmanagerui.py
+++ b/src/robotide/run/configmanagerui.py
@@ -46,9 +46,9 @@ def __init__(self, configs, plugin):
         # set Left to Right direction (while we don't have localization)
 
         self.SetBackgroundColour(Colour(self.color_background))
-        self.SetOwnBackgroundColour(Colour(self.color_background))
+        # self.SetOwnBackgroundColour(Colour(self.color_background))
         self.SetForegroundColour(Colour(self.color_foreground))
-        self.SetOwnForegroundColour(Colour(self.color_foreground))
+        # self.SetOwnForegroundColour(Colour(self.color_foreground))
 
         self.SetLayoutDirection(wx.Layout_LeftToRight)
         self.plugin = plugin
@@ -86,9 +86,9 @@ def _create_buttons(self, sizer=None):
         for item in self.GetChildren():
             if isinstance(item, (wx.Button, wx.BitmapButton, ButtonWithHandler)):
                 item.SetBackgroundColour(Colour(self.color_secondary_background))
-                item.SetOwnBackgroundColour(Colour(self.color_secondary_background))
+                # item.SetOwnBackgroundColour(Colour(self.color_secondary_background))
                 item.SetForegroundColour(Colour(self.color_secondary_foreground))
-                item.SetOwnForegroundColour(Colour(self.color_secondary_foreground))
+                # item.SetOwnForegroundColour(Colour(self.color_secondary_foreground))
         self.Sizer.Add(buttons, flag=wx.ALIGN_CENTER | wx.ALL, border=5)
 
     def get_data(self):
diff --git a/src/robotide/ui/mainframe.py b/src/robotide/ui/mainframe.py
index 9bd36202d..22cf37383 100644
--- a/src/robotide/ui/mainframe.py
+++ b/src/robotide/ui/mainframe.py
@@ -613,7 +613,7 @@ def on_about(event):
     def on_check_for_upgrade(self, event):
         __ = event
         from ..application.updatenotifier import UpdateNotifierController, UpdateDialog
-        wx.CallAfter(UpdateNotifierController(self.general_settings).notify_update_if_needed,
+        wx.CallAfter(UpdateNotifierController(self.general_settings, self.notebook).notify_update_if_needed,
                      UpdateDialog, ignore_check_condition=True, show_no_update=True)
 
     @staticmethod
diff --git a/src/robotide/ui/preferences_dialogs.py b/src/robotide/ui/preferences_dialogs.py
index b0f77ee2a..62bbadf26 100644
--- a/src/robotide/ui/preferences_dialogs.py
+++ b/src/robotide/ui/preferences_dialogs.py
@@ -19,6 +19,7 @@
 import wx
 from wx import Colour
 
+from ..preferences.settings import RideSettings
 from ..context import IS_LINUX
 from ..widgets import HelpLabel, Label, TextField
 
@@ -35,12 +36,14 @@ def __init__(self, parent=None, name_tr=None, *args, **kwargs):
         # self.location = (_("Preferences"),)
         # self.title = _("Preferences")
         wx.Panel.__init__(self, parent, *args, **kwargs)
-        """
-        self.SetBackgroundColour(Colour(200, 222, 40))
-        self.SetOwnBackgroundColour(Colour(200, 222, 40))
-        self.SetForegroundColour(Colour(7, 0, 70))
-        self.SetOwnForegroundColour(Colour(7, 0, 70))
-        """
+        self._gsettings = RideSettings()
+        self.settings = self._gsettings['General']
+        self.background_color = self.settings['background']
+        self.foreground_color = self.settings['foreground']
+        self.secondary_background_color = self.settings['secondary background']
+        self.secondary_foreground_color = self.settings['secondary foreground']
+        self.SetBackgroundColour(self.background_color)
+        self.SetForegroundColour(self.foreground_color)
 
     def GetTitle(self):
         return getattr(self, "title", self.location[-1])
@@ -49,19 +52,11 @@ def Separator(self, parent, title):
         """Creates a simple horizontal separator with title"""
         container = wx.Panel(parent, wx.ID_ANY)
         label = wx.StaticText(container, wx.ID_ANY, label=title)
-        """
-        label.SetBackgroundColour(Colour(200, 222, 40))
-        label.SetOwnBackgroundColour(Colour(200, 222, 40))
-        label.SetForegroundColour(Colour(7, 0, 70))
-        label.SetOwnForegroundColour(Colour(7, 0, 70))
-        """
+        label.SetBackgroundColour(self.background_color)
+        label.SetForegroundColour(self.foreground_color)
         sep = wx.StaticLine(container, wx.ID_ANY)
-        """
-        sep.SetBackgroundColour(Colour(200, 222, 40))
-        sep.SetOwnBackgroundColour(Colour(200, 222, 40))
-        sep.SetForegroundColour(Colour(7, 0, 70))
-        sep.SetOwnForegroundColour(Colour(7, 0, 70))
-        """
+        sep.SetBackgroundColour(self.secondary_background_color)
+        sep.SetForegroundColour(self.secondary_foreground_color)
         sizer = wx.BoxSizer(wx.VERTICAL)
         sizer.Add(label, 0, wx.EXPAND|wx.TOP, 8)
         sizer.Add(sep, 0, wx.EXPAND|wx.TOP|wx.BOTTOM, 2)
@@ -79,12 +74,12 @@ def __init__(self, parent, id, settings, key, choices):
         super(PreferencesComboBox, self).__init__(parent, id, self._get_value(),
                                                   size=self._get_size(choices),
                                                   choices=choices, style=wx.CB_READONLY)
-        """
-        self.SetBackgroundColour(Colour(200, 222, 40))
-        self.SetOwnBackgroundColour(Colour(200, 222, 40))
-        self.SetForegroundColour(Colour(7, 0, 70))
-        self.SetOwnForegroundColour(Colour(7, 0, 70))
-        """
+        self._gsettings = RideSettings()
+        self.gsettings = self._gsettings['General']
+        background_color = self.gsettings['secondary background']
+        foreground_color = self.gsettings['secondary foreground']
+        self.SetBackgroundColour(background_color)
+        self.SetForegroundColour(foreground_color)
         self.Bind(wx.EVT_COMBOBOX, self.on_select)
 
     def _get_value(self):
@@ -126,14 +121,15 @@ def __init__(self, parent, id, settings, key, choices):
         self.key = key
         super(PreferencesSpinControl, self).__init__(parent, id,
             size=self._get_size(choices[-1]))
+
+        self._gsettings = RideSettings()
+        self.psettings = self._gsettings['General']
+        background_color = self.psettings['background']
+        foreground_color = self.psettings['foreground']
+        self.SetBackgroundColour(background_color)
+        self.SetForegroundColour(foreground_color)
         self.SetRange(*choices)
         self.SetValue(self._get_value())
-        """
-        self.SetBackgroundColour(Colour(200, 222, 40))
-        self.SetOwnBackgroundColour(Colour(200, 222, 40))
-        self.SetForegroundColour(Colour(7, 0, 70))
-        self.SetOwnForegroundColour(Colour(7, 0, 70))
-        """
         self.Bind(wx.EVT_SPINCTRL, self.on_change)
         self.Bind(wx.EVT_TEXT, self.on_change)
 
@@ -166,12 +162,12 @@ def __init__(self, parent, id, settings, key):
         # print(f"DEBUG: Preferences ColourPicker value type {type(settings[key])}")
         value = Colour(settings[key])
         super(PreferencesColorPicker, self).__init__(parent, id, colour=value)
-        """
-        self.SetBackgroundColour(Colour(200, 222, 40))
-        self.SetOwnBackgroundColour(Colour(200, 222, 40))
-        self.SetForegroundColour(Colour(7, 0, 70))
-        self.SetOwnForegroundColour(Colour(7, 0, 70))
-        """
+        self._gsettings = RideSettings()
+        self.psettings = self._gsettings['General']
+        background_color = self.psettings['background']
+        foreground_color = self.psettings['foreground']
+        self.SetBackgroundColour(background_color)
+        self.SetForegroundColour(foreground_color)
         self.Bind(wx.EVT_COLOURPICKER_CHANGED, self.on_pick_color)
 
     def on_pick_color(self, event):
@@ -196,13 +192,23 @@ def __init__(self, settings, setting_name, label, choices, help=''):
         self._label = label
         self._choices = choices
         self._help = help
+        self._gsettings = RideSettings()
+        self.csettings = self._gsettings['General']
+        self.background_color = self.csettings['background']
+        self.foreground_color = self.csettings['foreground']
 
     def chooser(self, parent):
-        return self._editor_class(parent, wx.NewId(), self._settings,
-                                  key=self._setting_name, choices=self._choices)
+        element = self._editor_class(parent, wx.NewId(), self._settings,
+                                     key=self._setting_name, choices=self._choices)
+        element.SetBackgroundColour(self.background_color)
+        element.SetForegroundColour(self.foreground_color)
+        return element
 
     def label(self, parent):
-        return wx.StaticText(parent, wx.NewId(), self._label)
+        llabel = wx.StaticText(parent, wx.NewId(), self._label)
+        llabel.SetBackgroundColour(self.background_color)
+        llabel.SetForegroundColour(self.foreground_color)
+        return llabel
 
     def help(self, parent):
         return HelpLabel(parent, '\n'.join(textwrap.wrap(self._help, 60)))
@@ -225,14 +231,16 @@ class SpinChoiceEditor(_ChoiceEditor):
 
 def boolean_editor(parent, settings, name, label, help=''):
     editor = _create_checkbox_editor(parent, settings, name, help)
-    """
-    editor.SetBackgroundColour(Colour(200, 222, 40))
-    editor.SetOwnBackgroundColour(Colour(200, 222, 40))
-    editor.SetForegroundColour(Colour(7, 0, 70))
-    editor.SetOwnForegroundColour(Colour(7, 0, 70))
-    """
-    label = Label(parent, label=label)
-    return label, editor
+    _gsettings = RideSettings()
+    bsettings = _gsettings['General']
+    background_color = bsettings['background']
+    foreground_color = bsettings['foreground']
+    editor.SetBackgroundColour(background_color)
+    editor.SetForegroundColour(foreground_color)
+    blabel = Label(parent, label=label)
+    blabel.SetBackgroundColour(background_color)
+    blabel.SetForegroundColour(foreground_color)
+    return blabel, editor
 
 
 def _create_checkbox_editor(parent, settings, name, help):
@@ -244,16 +252,16 @@ def _create_checkbox_editor(parent, settings, name, help):
     return editor
 
 
-def comma_separated_value_editor(parent, settings, name, label, help=''):
+def comma_separated_value_editor(parent, settings, name, label, thelp=''):
     initial_value = ', '.join(settings.get(name, ""))
     editor = TextField(parent, initial_value)
-    """
-    editor.SetBackgroundColour(Colour(200, 222, 40))
-    editor.SetOwnBackgroundColour(Colour(200, 222, 40))
-    editor.SetForegroundColour(Colour(7, 0, 70))
-    editor.SetOwnForegroundColour(Colour(7, 0, 70))
-    """
-    editor.SetToolTip(help)
+    _gsettings = RideSettings()
+    esettings = _gsettings['General']
+    background_color = esettings['background']
+    foreground_color = esettings['foreground']
+    editor.SetBackgroundColour(background_color)
+    editor.SetForegroundColour(foreground_color)
+    editor.SetToolTip(thelp)
 
     def set_value(evt):
         new_value = [token.strip() for token in editor.GetValue().split(',')
@@ -261,5 +269,9 @@ def set_value(evt):
         settings.set(name, new_value)
         evt.Skip()
     editor.Bind(wx.EVT_KILL_FOCUS, lambda evt: set_value(evt))
-
-    return Label(parent, label=label), editor
+    elabel = Label(parent, label=label)
+    # background_color = esettings['background']
+    # foreground_color = esettings['foreground']
+    elabel.SetBackgroundColour(background_color)
+    elabel.SetForegroundColour(foreground_color)
+    return elabel, editor
diff --git a/src/robotide/version.py b/src/robotide/version.py
index c0f24caee..3b0a02176 100644
--- a/src/robotide/version.py
+++ b/src/robotide/version.py
@@ -15,4 +15,4 @@
 #
 # Automatically generated by `tasks.py`.
 
-VERSION = 'v2.1b1'
+VERSION = 'v2.1dev82'
diff --git a/src/robotide/widgets/button.py b/src/robotide/widgets/button.py
index 9f18c3a13..7df54cb1d 100644
--- a/src/robotide/widgets/button.py
+++ b/src/robotide/widgets/button.py
@@ -28,9 +28,9 @@ def __init__(self, parent, label, mk_handler=None, handler=None, width=-1,
         wx.Button.__init__(self, parent, label=label,
                            size=size)
         self.SetBackgroundColour(Colour(color_secondary_background))
-        self.SetOwnBackgroundColour(Colour(color_secondary_background))
+        # self.SetOwnBackgroundColour(Colour(color_secondary_background))
         self.SetForegroundColour(Colour(color_secondary_foreground))
-        self.SetOwnForegroundColour(Colour(color_secondary_foreground))
+        # self.SetOwnForegroundColour(Colour(color_secondary_foreground))
         if not handler or mk_handler:
             if not mk_handler:
                 name = 'on_%s' % label.strip().replace(' ', '_').lower()
diff --git a/src/robotide/widgets/dialog.py b/src/robotide/widgets/dialog.py
index 755ffd6ce..7aaf466fa 100644
--- a/src/robotide/widgets/dialog.py
+++ b/src/robotide/widgets/dialog.py
@@ -129,9 +129,9 @@ def _create_buttons(self, sizer):
         for item in self.GetChildren():
             if isinstance(item, (wx.Button, wx.BitmapButton, ButtonWithHandler)):
                 item.SetBackgroundColour(Colour(self.color_secondary_background))
-                item.SetOwnBackgroundColour(Colour(self.color_secondary_background))
+                # item.SetOwnBackgroundColour(Colour(self.color_secondary_background))
                 item.SetForegroundColour(Colour(self.color_secondary_foreground))
-                item.SetOwnForegroundColour(Colour(self.color_secondary_foreground))
+                # item.SetOwnForegroundColour(Colour(self.color_secondary_foreground))
         sizer.Add(buttons, flag=wx.ALIGN_CENTER | wx.ALL, border=5)
         sizer.Fit(self)
 
diff --git a/src/robotide/widgets/htmlwnd.py b/src/robotide/widgets/htmlwnd.py
index 2e48a4c68..8147ebc3b 100644
--- a/src/robotide/widgets/htmlwnd.py
+++ b/src/robotide/widgets/htmlwnd.py
@@ -34,8 +34,8 @@ def __init__(self, parent, size=wx.DefaultSize, text=None):
         self.SetBorders(2)
         self.SetStandardFonts(size=9)
         self.SetBackgroundColour(Colour(200, 222, 40))
-        self.SetOwnBackgroundColour(Colour(200, 222, 40))
-        self.SetOwnForegroundColour(Colour(7, 0, 70))
+        # self.SetOwnBackgroundColour(Colour(200, 222, 40))
+        # self.SetOwnForegroundColour(Colour(7, 0, 70))
         if text:
             self.set_content(text)
         self.SetHTMLBackgroundColour(Colour(general_settings[BACKGROUND_HELP]))
diff --git a/utest/application/test_updatenotifier.py b/utest/application/test_updatenotifier.py
index b1cc1ee00..04b5ee46c 100644
--- a/utest/application/test_updatenotifier.py
+++ b/utest/application/test_updatenotifier.py
@@ -17,14 +17,92 @@
 import time
 import urllib
 
-import pytest
-import wx
-
 from robotide.application.updatenotifier import UpdateNotifierController, UpdateDialog
 
 CHECKFORUPDATES = 'check for updates'
 LASTUPDATECHECK = 'last update check'
 
+import wx
+from wx.lib.agw.aui import AuiManager
+import wx.lib.agw.aui as aui
+from multiprocessing import shared_memory
+from utest.resources import datafilereader, MessageRecordingLoadObserver
+from robotide.ui.mainframe import ActionRegisterer, ToolBar
+from robotide.ui.actiontriggers import MenuBar, ShortcutRegistry
+from robotide.application import Project
+from utest.resources import FakeSettings
+from robotide.publish import PUBLISHER
+from robotide.ui.treeplugin import Tree
+from robotide.ui.notebook import NoteBook
+from robotide.editor import texteditor
+from robotide.namespace.namespace import Namespace
+
+app = wx.App()
+nb_style = aui.AUI_NB_DEFAULT_STYLE | aui.AUI_NB_WINDOWLIST_BUTTON | aui.AUI_NB_TAB_EXTERNAL_MOVE \
+           | aui.AUI_NB_SUB_NOTEBOOK | aui.AUI_NB_SMART_TABS
+MYTESTOVERRIDE = 'My Overriding Test Teardown'
+
+
+class MainFrame(wx.Frame):
+    book = None
+
+    def __init__(self):
+        wx.Frame.__init__(self, parent=None, title='Test App')
+
+        self.CreateStatusBar()
+
+
+class MyApp(wx.App):
+    frame = None
+    namespace = None
+    project = None
+    settings = None
+    book = None
+    panel = None
+    tree = None
+
+    def __init__(self, redirect=False, filename=None, usebestvisual=False, clearsigint=True):
+        super().__init__(redirect, filename, usebestvisual, clearsigint)
+        self.actions = None
+        self.toolbar = None
+        self._mgr = None
+
+    def OnInit(self):  # Overrides wx method
+        self.frame = MainFrame()
+        self.SetTopWindow(self.frame)
+        self.settings = FakeSettings()
+        # self.settings.add_section("Text Edit")
+        self.namespace = Namespace(self.settings)
+        self.book = NoteBook(self.frame, self, nb_style)
+        self._mgr = aui.AuiManager()
+
+        # tell AuiManager to manage this frame
+        self._mgr.SetManagedWindow(self.frame)
+        self.book.SetBackgroundColour((255, 255, 255))
+        self.book.SetForegroundColour((0, 0, 0))
+        self._mgr.AddPane(self.book,
+                          aui.AuiPaneInfo().Name("notebook_editors").
+                          CenterPane().PaneBorder(False))
+        mb = MenuBar(self.frame)
+        self.toolbar = ToolBar(self.frame)
+        self.toolbar.SetMinSize(wx.Size(100, 60))
+        self.toolbar.SetBackgroundColour((255, 255, 255))
+        self.toolbar.SetForegroundColour((0, 0, 0))
+        mb.m_frame.SetBackgroundColour((255, 255, 255))
+        mb.m_frame.SetForegroundColour((0, 0, 0))
+        self._mgr.AddPane(self.toolbar, aui.AuiPaneInfo().Name("maintoolbar").
+                          ToolbarPane().Top())
+        self.frame.actions = ActionRegisterer(self._mgr, mb, self.toolbar, ShortcutRegistry(self.frame))
+        self.tree = Tree(self.frame, self.frame.actions, self.settings)
+        self.tree.SetMinSize(wx.Size(275, 250))
+        self.frame.SetMinSize(wx.Size(600, 400))
+        self._mgr.AddPane(self.tree,
+                          aui.AuiPaneInfo().Name("tree_content").Caption("Test Suites").CloseButton(False).
+                          LeftDockable())
+        mb.take_menu_bar_into_use()
+        self._mgr.Update()
+        return True
+
 
 class UpdateNotifierTestCase(unittest.TestCase):
 
@@ -32,8 +110,35 @@ def setUp(self):
         self._callback_called = False
         self._version = None
         self._url = None
-
-    def _callback(self, version, url, settings):
+        self.app = MyApp()
+        settings = self.app.settings
+        self.frame = self.app.frame
+        self.frame.actions = ActionRegisterer(AuiManager(self.frame), MenuBar(self.frame), ToolBar(self.frame),
+                                              ShortcutRegistry(self.frame))
+        self.frame.tree = Tree(self.frame, self.frame.actions, settings)
+        self.app.project = Project(self.app.namespace, self.app.settings)
+        self.plugin = texteditor.TextEditorPlugin(self.app)
+        self.app.project.load_datafile(datafilereader.SIMPLE_PROJECT, MessageRecordingLoadObserver())
+        self.notebook = self.app.book
+        self.app.tree.populate(self.app.project)
+        self.source = self.app.tree.controller
+        self.app.frame.SetStatusText("File:" + self.app.project.data.source)
+        # Uncomment next line (and MainLoop in tests) if you want to see the app
+        self.frame.Show()
+
+    def tearDown(self):
+        self.plugin.unsubscribe_all()
+        PUBLISHER.unsubscribe_all()
+        self.app.project.close()
+        wx.CallAfter(self.app.ExitMainLoop)
+        self.app.MainLoop()  # With this here, there is no Segmentation fault
+        # wx.CallAfter(wx.Exit)
+        self.app.Destroy()
+        self.app = None
+
+
+    def _callback(self, version, url, settings, notebook):
+        __ = notebook
         self.assertFalse(self._callback_called)
         self._callback_called = True
         self.assertNotEqual(None, version)
@@ -43,8 +148,8 @@ def _callback(self, version, url, settings):
         self.assertEqual(dict, type(settings))
 
     @staticmethod
-    def _update_notifier_controller(settings, current, new, url='some url'):
-        ctrl = UpdateNotifierController(settings)
+    def _update_notifier_controller(settings, notebook, current, new, url='some url'):
+        ctrl = UpdateNotifierController(settings, notebook)
         ctrl.VERSION = current
         ctrl._get_newest_version = lambda: new
         ctrl._get_download_url = lambda v: url if v == new else None
@@ -58,17 +163,20 @@ def internal_settings(check_for_updates: typing.Union[bool, None] = True,
 
     def test_normal_update(self):
         settings = self.internal_settings()
-        ctrl = self._update_notifier_controller(settings, '0', '1', 'http://xyz.abc.efg.di')
+        ctrl = self._update_notifier_controller(settings, self.notebook, '0', '1', 'http://xyz.abc.efg.di')
         ctrl.notify_update_if_needed(self._callback)
         self.assertEqual('1', self._version)
         self.assertEqual('http://xyz.abc.efg.di', self._url)
         self.assertTrue(self._callback_called)
         self.assertTrue(settings[CHECKFORUPDATES])
         self.assertTrue(settings[LASTUPDATECHECK] > time.time() - 1)
+        # Uncomment next lines if you want to see the app
+        # wx.CallLater(5000, self.app.ExitMainLoop)
+        # self.app.MainLoop()
 
     def test_update_when_trunk_version(self):
         settings = self.internal_settings()
-        ctrl = self._update_notifier_controller(settings, '2.0', '2.0.1')
+        ctrl = self._update_notifier_controller(settings, self.notebook, '2.0', '2.0.1')
         ctrl.notify_update_if_needed(self._callback)
         self.assertTrue(self._callback_called)
         self.assertEqual('2.0.1', self._version)
@@ -78,7 +186,7 @@ def test_update_when_trunk_version(self):
     def test_last_update_done_less_than_a_week_ago(self):
         original_time = time.time() - 60 * 60 * 24 * 3
         settings = self.internal_settings(last_update_check=original_time)
-        ctrl = UpdateNotifierController(settings)
+        ctrl = UpdateNotifierController(settings, self.notebook)
         ctrl.notify_update_if_needed(self._callback)
         self.assertTrue(settings[CHECKFORUPDATES])
         self.assertEqual(original_time, settings[LASTUPDATECHECK])
@@ -87,7 +195,7 @@ def test_last_update_done_less_than_a_week_ago(self):
     def test_check_for_updates_is_false(self):
         settings = self.internal_settings(check_for_updates=False)
         original_time = settings[LASTUPDATECHECK]
-        ctrl = UpdateNotifierController(settings)
+        ctrl = UpdateNotifierController(settings, self.notebook)
         ctrl.notify_update_if_needed(self._callback)
         self.assertFalse(settings[CHECKFORUPDATES])
         self.assertEqual(original_time, settings[LASTUPDATECHECK])
@@ -95,29 +203,27 @@ def test_check_for_updates_is_false(self):
 
     def test_no_update_found(self):
         settings = self.internal_settings()
-        ctrl = self._update_notifier_controller(settings, '0.55', '0.55')
+        ctrl = self._update_notifier_controller(settings, self.notebook, '0.55', '0.55')
         ctrl.notify_update_if_needed(self._callback)
         self.assertTrue(settings[LASTUPDATECHECK] > time.time() - 1)
         self.assertFalse(self._callback_called)
 
     def test_no_update_found_dev(self):
-        app = wx.App()
         settings = self.internal_settings()
-        ctrl = self._update_notifier_controller(settings, '0.56', '0.56')
+        ctrl = self._update_notifier_controller(settings, self.notebook, '0.56', '0.56')
         ctrl.notify_update_if_needed(self._callback, ignore_check_condition=False, show_no_update=False)
         self.assertTrue(settings[LASTUPDATECHECK] > time.time() - 1)
         self.assertFalse(self._callback_called)
 
     def test_no_update_found_dev_notify(self):
-        app = wx.App()
         settings = self.internal_settings()
-        ctrl = self._update_notifier_controller(settings, '0.55', '0.55')
+        ctrl = self._update_notifier_controller(settings, self.notebook, '0.55', '0.55')
         ctrl.notify_update_if_needed(self._callback, ignore_check_condition=True, show_no_update=True)
         self.assertFalse(self._callback_called)
 
     def test_first_run_sets_settings_correctly_and_checks_for_updates(self):
         settings = self.internal_settings(check_for_updates=None, last_update_check=None)
-        ctrl = self._update_notifier_controller(settings, '1.0.2', '1.0.2')
+        ctrl = self._update_notifier_controller(settings, self.notebook,'1.0.2', '1.0.2')
         ctrl.notify_update_if_needed(self._callback)
         self.assertTrue(settings[LASTUPDATECHECK] > time.time() - 1)
         self.assertTrue(settings[CHECKFORUPDATES])
@@ -125,16 +231,15 @@ def test_first_run_sets_settings_correctly_and_checks_for_updates(self):
 
     def test_first_run_sets_settings_correctly_and_finds_an_update(self):
         settings = self.internal_settings(check_for_updates=None, last_update_check=None)
-        ctrl = self._update_notifier_controller(settings, '1.2', '2.0')
+        ctrl = self._update_notifier_controller(settings, self.notebook, '1.2', '2.0')
         ctrl.notify_update_if_needed(self._callback)
         self.assertTrue(settings[LASTUPDATECHECK] > time.time() - 1)
         self.assertTrue(settings[CHECKFORUPDATES])
         self.assertTrue(self._callback_called)
 
     def test_checking_timeouts(self):
-        app = wx.App()
         settings = self.internal_settings()
-        ctrl = UpdateNotifierController(settings)
+        ctrl = UpdateNotifierController(settings, self.notebook)
 
         def throw_timeout_error():
             raise urllib.error.URLError('timeout')
@@ -146,7 +251,7 @@ def throw_timeout_error():
 
     def test_download_url_checking_timeouts(self):
         settings = self.internal_settings()
-        ctrl = UpdateNotifierController(settings)
+        ctrl = UpdateNotifierController(settings, self.notebook)
         ctrl.VERSION = '0'
         ctrl._get_newest_version = lambda: '1'
 
@@ -161,7 +266,7 @@ def throw_timeout_error(*args):
 
     def test_server_returns_no_versions(self):
         settings = self.internal_settings()
-        ctrl = self._update_notifier_controller(settings, '1.2.2', None)
+        ctrl = self._update_notifier_controller(settings, self.notebook, '1.2.2', None)
         ctrl.notify_update_if_needed(self._callback)
         self.assertTrue(settings[LASTUPDATECHECK] > time.time() - 1)
         self.assertTrue(settings[CHECKFORUPDATES])
@@ -169,34 +274,31 @@ def test_server_returns_no_versions(self):
 
     def test_server_returns_older_version(self):
         settings = self.internal_settings()
-        ctrl = self._update_notifier_controller(settings, '0.44', '0.43.1')
+        ctrl = self._update_notifier_controller(settings, self.notebook, '0.44', '0.43.1')
         ctrl.notify_update_if_needed(self._callback)
         self.assertTrue(settings[LASTUPDATECHECK] > time.time() - 1)
         self.assertTrue(settings[CHECKFORUPDATES])
         self.assertFalse(self._callback_called)
 
     def test_forced_check_released(self):
-        app = wx.App()
         settings = self.internal_settings()
-        ctrl = self._update_notifier_controller(settings, '0.43.0', '0.43.1')
+        ctrl = self._update_notifier_controller(settings, self.notebook, '0.43.0', '0.43.1')
         ctrl.notify_update_if_needed(self._callback, ignore_check_condition=True)
         self.assertTrue(settings[LASTUPDATECHECK] > time.time() - 19)  # The dialog timeout in 20 seconds
         self.assertTrue(settings[CHECKFORUPDATES])
         self.assertTrue(self._callback_called)
 
     def test_forced_check_development(self):
-        app = wx.App()
         settings = self.internal_settings()
-        ctrl = self._update_notifier_controller(settings, '0.44dev12', '0.44.dev14')
+        ctrl = self._update_notifier_controller(settings, self.notebook, '0.44dev12', '0.44.dev14')
         ctrl.notify_update_if_needed(self._callback, ignore_check_condition=True)
         self.assertTrue(settings[LASTUPDATECHECK] > time.time() - 20)  # The dialog timeout in 20 seconds
         self.assertTrue(settings[CHECKFORUPDATES])
         self.assertTrue(self._callback_called)
 
     def test_forced_check_development_ok(self):
-        app = wx.App()
         settings = self.internal_settings()
-        ctrl = self._update_notifier_controller(settings, '0.44dev12', '0.44.dev12')
+        ctrl = self._update_notifier_controller(settings, self.notebook, '0.44dev12', '0.44.dev12')
         ctrl.notify_update_if_needed(self._callback, ignore_check_condition=False)
         self.assertTrue(settings[LASTUPDATECHECK] > time.time() - 20)  # The dialog timeout in 20 seconds
         self.assertTrue(settings[CHECKFORUPDATES])
@@ -204,9 +306,8 @@ def test_forced_check_development_ok(self):
 
     def test_normal_update_dialog(self):
         """ This is not actually doing a test """
-        app = wx.App()
         settings = self.internal_settings()
-        ctrl=UpdateDialog('1.0.0', 'http://localhost', settings, False)
+        ctrl=UpdateDialog('1.0.0', 'http://localhost', settings, self.notebook,False)
         wx.CallLater(3000, ctrl.EndModal,wx.CANCEL)
         ctrl.ShowModal()
         ctrl.Destroy()