Add a threaded mode listener

This will automatically make the necessary color adjustments when the
system mode changes.

src/nexpy/gui/consoleapp.py

@@ -13,32 +13,28 @@
 import logging
 import logging.handlers
 import os
-import pkg_resources
 import shutil
 import signal
 import sys
 import tempfile
-from pkg_resources import parse_version
-
-
-from .pyqt import QtCore, QtGui, QtWidgets, QtVersion
 
+import pkg_resources
 from IPython import __version__ as ipython_version
 from jupyter_client.consoleapp import JupyterConsoleApp, app_aliases, app_flags
 from jupyter_core.application import JupyterApp, base_aliases, base_flags
 from matplotlib import __version__ as mpl_version
+from nexusformat.nexus import NXroot, nxclasses, nxversion
 from qtconsole import __version__
 from qtconsole.jupyter_widget import JupyterWidget
 from qtconsole.rich_jupyter_widget import RichJupyterWidget
 from traitlets import Any, CBool, Dict, Unicode
 from traitlets.config.application import boolean_flag, catch_config_error
 
-from nexusformat.nexus import NXroot, nxclasses, nxversion
-
 from .. import __version__ as nexpy_version
 from .mainwindow import MainWindow
+from .pyqt import QtCore, QtGui, QtVersion, QtWidgets
 from .treeview import NXtree
-from .utils import (NXConfigParser, NXGarbageCollector, NXLogger, in_dark_mode,
+from .utils import (NXConfigParser, NXGarbageCollector, NXLogger, define_mode,
                     initialize_settings, report_exception, timestamp_age)
 
 # -----------------------------------------------------------------------------
@@ -319,12 +315,7 @@ def init_shell(self, args):
 
     def init_colors(self):
         """Configure the coloring of the widget"""
-        if in_dark_mode():
-            self.window.console.set_default_style('linux')
-            if parse_version(QtCore.__version__) <= parse_version('5.15'):
-                self.window.statusBar().setStyleSheet('color: black')
-        else:
-            self.window.console.set_default_style()
+        define_mode()
 
     def init_signal(self):
         """allow clean shutdown on sigint"""

src/nexpy/gui/datadialogs.py

@@ -4412,14 +4412,17 @@ def mouseReleaseEvent(self, event):
         self.show_log()
 
     def show_log(self):
+        self.format_log()
+        self.setVisible(True)
+        self.raise_()
+        self.activateWindow()
+
+    def format_log(self):
         with open(self.file_name, 'r') as f:
             self.text_box.setText(convertHTML(f.read()))
         self.text_box.verticalScrollBar().setValue(
             self.text_box.verticalScrollBar().maximum())
         self.setWindowTitle(f"Log File: {self.file_name}")
-        self.setVisible(True)
-        self.raise_()
-        self.activateWindow()
 
     def reject(self):
         super().reject()

src/nexpy/gui/mainwindow.py

@@ -51,9 +51,10 @@
 from .pyqt import QtCore, QtGui, QtWidgets, getOpenFileName, getSaveFileName
 from .scripteditor import NXScriptWindow
 from .treeview import NXTreeView
-from .utils import (confirm_action, display_message, get_colors, get_name,
-                    import_plugin, is_file_locked, load_image, natural_sort,
-                    report_error, timestamp)
+from .utils import (NXListener, confirm_action, define_mode, display_message,
+                    get_colors, get_name, import_plugin, is_file_locked,
+                    load_image, mode_listener, natural_sort, report_error,
+                    timestamp)
 
 
 class NXRichJupyterWidget(RichJupyterWidget):
@@ -195,6 +196,10 @@ def new_stb(etype, evalue, stb):
         self.setWindowTitle('NeXpy v'+__version__)
         self.statusBar().showMessage('Ready')
 
+        listener = NXListener()
+        listener.change_signal.connect(self.change_mode)
+        listener.start(mode_listener)
+
         self.treeview.selection_changed()
         self.shellview.setFocus()
 
@@ -208,6 +213,9 @@ def active_plotview(self):
         from .plotview import active_plotview
         return active_plotview
 
+    def change_mode(self, mode=None):
+        define_mode(mode)
+
     # Populate the menu bar with common actions and shortcuts
     def add_menu_action(self, menu, action, defer_shortcut=False):
         """Add action to menu as well as self

src/nexpy/gui/utils.py

@@ -15,11 +15,14 @@
 import os
 import re
 import sys
+import time
 import traceback as tb
 from configparser import ConfigParser
 from datetime import datetime
+from threading import Thread
 
 import numpy as np
+from darkdetect import isDark, theme
 from IPython.core.ultratb import ColorTB
 from matplotlib import __version__ as mplversion
 from matplotlib import rcParams
@@ -704,16 +707,57 @@ def in_dark_mode():
     if sys.version_info < (3, 9):
         return False
     try:
-        import darkdetect
-        if darkdetect.isDark():
+        if isDark():
             return True
         else:
             return False
     except ImportError:
         return False
 
 
-class NXimporter:
+def mode_listener(listener):
+    old_mode = theme()
+    while True:
+        current_mode = theme()
+        if current_mode != old_mode:
+            old_mode = current_mode
+            listener.respond(current_mode)
+        time.sleep(5)
+
+
+def define_mode(mode=None):
+    from .consoleapp import _mainwindow
+    if mode is None:
+        mode = theme()
+    if mode == 'Dark':
+        _mainwindow.console.set_default_style('linux')
+        if parse_version(QtCore.__version__) <= parse_version('5.15'):
+            _mainwindow.statusBar().setStyleSheet('color: black')
+    else:
+        _mainwindow.console.set_default_style()
+    for dialog in _mainwindow.dialogs:
+        if dialog.windowTitle() == 'Script Editor':
+            for tab in dialog.tabs:
+                dialog.tabs[tab].define_style()
+        elif dialog.windowTitle().startswith('Log File'):
+            dialog.format_log()
+
+
+class NXListener(QtCore.QObject):
+
+    change_signal = QtCore.Signal(str)
+
+    def start(self, fn):
+        Thread(target=self._execute, args=(fn,), daemon=True).start()
+
+    def _execute(self, fn):
+        fn(self)
+
+    def respond(self, signal):
+        self.change_signal.emit(signal)
+
+
+class NXImporter:
     def __init__(self, paths):
         self.paths = [str(p) for p in paths]
 
@@ -727,7 +771,7 @@ def __exit__(self, exc_type, exc_value, traceback):
 
 
 def import_plugin(name, paths):
-    with NXimporter(paths):
+    with NXImporter(paths):
         plugin_module = importlib.import_module(name)
         if hasattr(plugin_module, '__file__'):  # Not a namespace module
             return plugin_module