not1mm 24.3.19__py3-none-any.whl → 24.3.21__py3-none-any.whl

not1mm/__main__.py

@@ -3,7 +3,7 @@
 NOT1MM Logger
 """
 # pylint: disable=unused-import, c-extension-no-member, no-member, invalid-name, too-many-lines, no-name-in-module
-# pylint: disable=logging-fstring-interpolation
+# pylint: disable=logging-fstring-interpolation, logging-not-lazy, line-too-long
 
 # alt cluster hamqth.com 7300
 
@@ -11,12 +11,14 @@ import datetime
 import importlib
 import locale
 import logging
+from logging.handlers import RotatingFileHandler
 import os
 
 import platform
 import re
 import socket
-import subprocess
+
+# import subprocess
 import sys
 import threading
 import uuid
@@ -32,7 +34,7 @@ import soundfile as sf
 from PyQt5 import QtCore, QtGui, QtWidgets, uic
 from PyQt5.QtCore import QDir, Qt
 from PyQt5.QtGui import QFontDatabase
-from PyQt5.QtWidgets import QFileDialog
+from PyQt5.QtWidgets import QFileDialog, QDockWidget
 
 from not1mm.lib.about import About
 from not1mm.lib.cat_interface import CAT
@@ -62,31 +64,15 @@ from not1mm.lib.settings import Settings
 from not1mm.lib.version import __version__
 from not1mm.lib.versiontest import VersionTest
 
-# DeprecationWarning: 'pkgutil.get_loader' is deprecated and slated for removal in Python 3.14
-# loader = pkgutil.get_loader("not1mm")
-# WORKING_PATH = os.path.dirname(loader.get_filename())
-WORKING_PATH = os.path.dirname(__loader__.get_filename())
-
-DATA_PATH = os.environ.get("XDG_DATA_HOME", str(Path.home() / ".local" / "share"))
-DATA_PATH += "/not1mm"
-
-try:
-    os.mkdir(DATA_PATH)
-except FileExistsError:
-    ...
-
-CONFIG_PATH = os.environ.get("XDG_CONFIG_HOME", str(Path.home() / ".config"))
-CONFIG_PATH += "/not1mm"
-
-try:
-    os.mkdir(CONFIG_PATH)
-except FileExistsError:
-    ...
-
+import not1mm.fsutils as fsutils
+from not1mm.logwindow import LogWindow
+from not1mm.checkwindow import CheckWindow
+from not1mm.bandmap import BandMapWindow
+from not1mm.vfo import VfoWindow
 
 CTYFILE = {}
 
-with open(WORKING_PATH + "/data/cty.json", "rt", encoding="utf-8") as c_file:
+with open(fsutils.APP_DATA_PATH / "cty.json", "rt", encoding="utf-8") as c_file:
     CTYFILE = loads(c_file.read())
 
 poll_time = datetime.datetime.now()
@@ -137,7 +123,7 @@ class MainWindow(QtWidgets.QMainWindow):
         "contest": "",
         "multicast_group": "239.1.1.1",
         "multicast_port": 2239,
-        "interface_ip": "0.0.0.0",
+        "interface_ip": "127.0.0.1",
         "send_n1mm_packets": False,
         "n1mm_station_name": "20M CW Tent",
         "n1mm_operator": "Bernie",
@@ -184,24 +170,33 @@ class MainWindow(QtWidgets.QMainWindow):
     contest_dialog = None
     configuration_dialog = None
     opon_dialog = None
-    dbname = DATA_PATH + "/ham.db"
+    dbname = fsutils.USER_DATA_PATH, "/ham.db"
     radio_state = {}
     rig_control = None
     worked_list = {}
     cw_entry_visible = False
     last_focus = None
     oldtext = ""
+    text_color = Qt.black
+    current_palette = None
+
+    log_window = None
+    check_window = None
+    bandmap_window = None
+    vfo_window = None
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         logger.info("MainWindow: __init__")
-        data_path = WORKING_PATH + "/data/main.ui"
+        self.setCorner(Qt.TopRightCorner, Qt.RightDockWidgetArea)
+        self.setCorner(Qt.BottomRightCorner, Qt.RightDockWidgetArea)
+        data_path = fsutils.APP_DATA_PATH / "main.ui"
         uic.loadUi(data_path, self)
         self.cw_entry.hide()
         self.leftdot.hide()
         self.rightdot.hide()
         self.n1mm = N1MM()
-        self.mscp = SCP(WORKING_PATH)
+        self.mscp = SCP(fsutils.APP_DATA_PATH)
         self.next_field = self.other_2
         self.dupe_indicator.hide()
         self.cw_speed.valueChanged.connect(self.cwspeed_spinbox_changed)
@@ -210,6 +205,7 @@ class MainWindow(QtWidgets.QMainWindow):
         self.cw_entry.returnPressed.connect(self.toggle_cw_entry)
 
         self.actionCW_Macros.triggered.connect(self.cw_macros_state_changed)
+        self.actionDark_Mode_2.triggered.connect(self.dark_mode_state_changed)
         self.actionCommand_Buttons.triggered.connect(self.command_buttons_state_change)
         self.actionLog_Window.triggered.connect(self.launch_log_window)
         self.actionBandmap.triggered.connect(self.launch_bandmap_window)
@@ -255,15 +251,15 @@ class MainWindow(QtWidgets.QMainWindow):
 
         self.sent.setText("59")
         self.receive.setText("59")
-        icon_path = WORKING_PATH + "/data/"
-        self.greendot = QtGui.QPixmap(icon_path + "greendot.png")
-        self.reddot = QtGui.QPixmap(icon_path + "reddot.png")
+        icon_path = fsutils.APP_DATA_PATH
+        self.greendot = QtGui.QPixmap(str(icon_path / "greendot.png"))
+        self.reddot = QtGui.QPixmap(str(icon_path / "reddot.png"))
         self.leftdot.setPixmap(self.greendot)
         self.rightdot.setPixmap(self.reddot)
 
-        self.radio_grey = QtGui.QPixmap(icon_path + "radio_grey.png")
-        self.radio_red = QtGui.QPixmap(icon_path + "radio_red.png")
-        self.radio_green = QtGui.QPixmap(icon_path + "radio_green.png")
+        self.radio_grey = QtGui.QPixmap(str(icon_path / "radio_grey.png"))
+        self.radio_red = QtGui.QPixmap(str(icon_path / "radio_red.png"))
+        self.radio_green = QtGui.QPixmap(str(icon_path / "radio_green.png"))
         self.radio_icon.setPixmap(self.radio_grey)
 
         self.F1.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
@@ -461,9 +457,14 @@ class MainWindow(QtWidgets.QMainWindow):
             "RTTY": self.band_indicators_rtty,
         }
 
+        self.setWindowIcon(
+            QtGui.QIcon(str(fsutils.APP_DATA_PATH / "k6gte.not1mm-64.png"))
+        )
         self.readpreferences()
-        self.dbname = DATA_PATH + "/" + self.pref.get("current_database", "ham.db")
-        self.database = DataBase(self.dbname, WORKING_PATH)
+        self.dbname = fsutils.USER_DATA_PATH / self.pref.get(
+            "current_database", "ham.db"
+        )
+        self.database = DataBase(self.dbname, fsutils.APP_DATA_PATH)
         self.station = self.database.fetch_station()
         if self.station is None:
             self.station = {}
@@ -480,11 +481,80 @@ class MainWindow(QtWidgets.QMainWindow):
         if self.pref.get("contest"):
             self.load_contest()
 
-        if VersionTest(__version__).test():
-            self.show_message_box(
-                "There is a newer version of not1mm available.\n"
-                "You can udate to the current version by using:\npip install -U not1mm"
+        if not DEBUG_ENABLED:
+            if VersionTest(__version__).test():
+                self.show_message_box(
+                    "There is a newer version of not1mm available.\n"
+                    "You can udate to the current version by using:\npip install -U not1mm"
+                )
+
+    def setDarkMode(self, dark):
+        """testing"""
+
+        logger.debug(f"Dark mode set to: {dark}")
+
+        cmd = {}
+        cmd["cmd"] = "DARKMODE"
+        cmd["state"] = dark
+        cmd["station"] = platform.node()
+        self.multicast_interface.send_as_json(cmd)
+
+        if dark:
+            darkPalette = QtGui.QPalette()
+            darkColor = QtGui.QColor(45, 45, 45)
+
+            disabledColor = QtGui.QColor(127, 127, 127)
+            darkPalette.setColor(QtGui.QPalette.Window, darkColor)
+            darkPalette.setColor(QtGui.QPalette.WindowText, Qt.white)
+            darkPalette.setColor(QtGui.QPalette.Base, QtGui.QColor(18, 18, 18))
+            darkPalette.setColor(QtGui.QPalette.AlternateBase, darkColor)
+            darkPalette.setColor(QtGui.QPalette.Text, Qt.white)
+            darkPalette.setColor(
+                QtGui.QPalette.Disabled, QtGui.QPalette.Text, disabledColor
+            )
+            darkPalette.setColor(QtGui.QPalette.Button, darkColor)
+            darkPalette.setColor(QtGui.QPalette.ButtonText, Qt.white)
+            darkPalette.setColor(
+                QtGui.QPalette.Disabled, QtGui.QPalette.ButtonText, disabledColor
             )
+            darkPalette.setColor(QtGui.QPalette.BrightText, Qt.red)
+            darkPalette.setColor(QtGui.QPalette.Link, QtGui.QColor(42, 130, 218))
+            darkPalette.setColor(QtGui.QPalette.Highlight, QtGui.QColor(42, 130, 218))
+            darkPalette.setColor(QtGui.QPalette.HighlightedText, Qt.black)
+            darkPalette.setColor(
+                QtGui.QPalette.Disabled, QtGui.QPalette.HighlightedText, disabledColor
+            )
+            self.current_palette = darkPalette
+            self.setPalette(darkPalette)
+            self.text_color = Qt.white
+            self.menuFile.setPalette(darkPalette)
+            self.menuHelp.setPalette(darkPalette)
+            self.menuOther.setPalette(darkPalette)
+            self.menuView.setPalette(darkPalette)
+            self.menuWindow.setPalette(darkPalette)
+            self.callsign.setPalette(darkPalette)
+            self.sent.setPalette(darkPalette)
+            self.receive.setPalette(darkPalette)
+            self.other_1.setPalette(darkPalette)
+            self.other_2.setPalette(darkPalette)
+            self.cw_entry.setPalette(darkPalette)
+
+        else:
+            palette = self.style().standardPalette()
+            self.current_palette = palette
+            self.setPalette(palette)
+            self.menuFile.setPalette(palette)
+            self.menuHelp.setPalette(palette)
+            self.menuOther.setPalette(palette)
+            self.menuView.setPalette(palette)
+            self.menuWindow.setPalette(palette)
+            self.callsign.setPalette(palette)
+            self.sent.setPalette(palette)
+            self.receive.setPalette(palette)
+            self.other_1.setPalette(palette)
+            self.other_2.setPalette(palette)
+            self.cw_entry.setPalette(palette)
+            self.text_color = Qt.black
 
     def set_radio_icon(self, state: int) -> None:
         """
@@ -624,6 +694,8 @@ class MainWindow(QtWidgets.QMainWindow):
         """
 
         message_box = QtWidgets.QMessageBox()
+        if self.current_palette:
+            message_box.setPalette(self.current_palette)
         message_box.setIcon(QtWidgets.QMessageBox.Information)
         message_box.setText(message)
         message_box.setWindowTitle("Information")
@@ -643,9 +715,12 @@ class MainWindow(QtWidgets.QMainWindow):
         None
         """
 
-        self.about_dialog = About(WORKING_PATH)
+        self.about_dialog = About(fsutils.APP_DATA_PATH)
+        if self.current_palette:
+            self.about_dialog.setPalette(self.current_palette)
+
         self.about_dialog.donors.setSource(
-            QtCore.QUrl.fromLocalFile(WORKING_PATH + "/data/donors.html")
+            QtCore.QUrl.fromLocalFile(f"{fsutils.APP_DATA_PATH / 'donors.html'}")
         )
         self.about_dialog.open()
 
@@ -662,11 +737,14 @@ class MainWindow(QtWidgets.QMainWindow):
         None
         """
 
-        self.about_dialog = About(WORKING_PATH)
+        self.about_dialog = About(fsutils.APP_DATA_PATH)
+        if self.current_palette:
+            self.about_dialog.setPalette(self.current_palette)
+
         self.about_dialog.setWindowTitle("Help")
         self.about_dialog.setGeometry(0, 0, 800, 600)
         self.about_dialog.donors.setSource(
-            QtCore.QUrl.fromLocalFile(WORKING_PATH + "/data/not1mm.html")
+            QtCore.QUrl.fromLocalFile(str(fsutils.APP_DATA_PATH / "not1mm.html"))
         )
         self.about_dialog.open()
 
@@ -703,7 +781,9 @@ class MainWindow(QtWidgets.QMainWindow):
         None
         """
 
-        self.configuration_dialog = Settings(WORKING_PATH, CONFIG_PATH, self.pref)
+        self.configuration_dialog = Settings(fsutils.APP_DATA_PATH, self.pref)
+        if self.current_palette:
+            self.configuration_dialog.setPalette(self.current_palette)
         self.configuration_dialog.usehamdb_radioButton.hide()
         self.configuration_dialog.show()
         self.configuration_dialog.accepted.connect(self.edit_configuration_return)
@@ -723,7 +803,7 @@ class MainWindow(QtWidgets.QMainWindow):
 
         self.configuration_dialog.save_changes()
         self.write_preference()
-        logger.debug("%s", f"{self.pref}")
+        # logger.debug("%s", f"{self.pref}")
         self.readpreferences()
 
     def new_database(self) -> None:
@@ -743,10 +823,12 @@ class MainWindow(QtWidgets.QMainWindow):
         if filename:
             if filename[-3:] != ".db":
                 filename += ".db"
-            self.pref["current_database"] = filename.split("/")[-1:][0]
+            self.pref["current_database"] = os.path.basename(filename)
             self.write_preference()
-            self.dbname = DATA_PATH + "/" + self.pref.get("current_database", "ham.db")
-            self.database = DataBase(self.dbname, WORKING_PATH)
+            self.dbname = fsutils.USER_DATA_PATH / self.pref.get(
+                "current_database", "ham.db"
+            )
+            self.database = DataBase(self.dbname, fsutils.APP_DATA_PATH)
             self.contact = self.database.empty_contact
             self.station = self.database.fetch_station()
             if self.station is None:
@@ -775,10 +857,12 @@ class MainWindow(QtWidgets.QMainWindow):
 
         filename = self.filepicker("open")
         if filename:
-            self.pref["current_database"] = filename.split("/")[-1:][0]
+            self.pref["current_database"] = os.path.basename(filename)
             self.write_preference()
-            self.dbname = DATA_PATH + "/" + self.pref.get("current_database", "ham.db")
-            self.database = DataBase(self.dbname, WORKING_PATH)
+            self.dbname = fsutils.USER_DATA_PATH / self.pref.get(
+                "current_database", "ham.db"
+            )
+            self.database = DataBase(self.dbname, fsutils.MODULE_PATH)
             self.contact = self.database.empty_contact
             self.station = self.database.fetch_station()
             if self.station is None:
@@ -814,7 +898,10 @@ class MainWindow(QtWidgets.QMainWindow):
         logger.debug("%s", f"{contests}")
 
         if contests:
-            self.contest_dialog = SelectContest(WORKING_PATH)
+            self.contest_dialog = SelectContest(fsutils.APP_DATA_PATH)
+            if self.current_palette:
+                self.contest_dialog.setPalette(self.current_palette)
+
             self.contest_dialog.contest_list.setRowCount(0)
             self.contest_dialog.contest_list.setColumnCount(4)
             self.contest_dialog.contest_list.verticalHeader().setVisible(False)
@@ -912,7 +999,14 @@ class MainWindow(QtWidgets.QMainWindow):
             return
         if self.contest_settings is None:
             return
-        self.contest_dialog = NewContest(WORKING_PATH)
+
+        self.contest_dialog = NewContest(fsutils.APP_DATA_PATH)
+        if self.current_palette:
+            self.contest_dialog.setPalette(self.current_palette)
+            self.contest_dialog.exchange.setPalette(self.current_palette)
+            self.contest_dialog.operators.setPalette(self.current_palette)
+            self.contest_dialog.contest.setPalette(self.current_palette)
+
         self.contest_dialog.setWindowTitle("Edit Contest")
         self.contest_dialog.title.setText("")
         self.contest_dialog.accepted.connect(self.save_edited_contest)
@@ -1078,7 +1172,7 @@ class MainWindow(QtWidgets.QMainWindow):
         """
 
         try:
-            cty = notctyparser.BigCty(WORKING_PATH + "/data/cty.json")
+            cty = notctyparser.BigCty(fsutils.APP_DATA_PATH / "cty.json")
             update_available = cty.check_update()
         except (AttributeError, ValueError, locale.Error) as the_error:
             logger.debug("cty parser returned an error: %s", the_error)
@@ -1092,10 +1186,10 @@ class MainWindow(QtWidgets.QMainWindow):
                 logger.debug("cty parser returned an error: %s", the_error)
                 return
             if updated:
-                cty.dump(WORKING_PATH + "/data/cty.json")
+                cty.dump(fsutils.APP_DATA_PATH / "cty.json")
                 self.show_message_box("cty file updated.")
                 with open(
-                    WORKING_PATH + "/data/cty.json", "rt", encoding="utf-8"
+                    fsutils.APP_DATA_PATH / "cty.json", "rt", encoding="utf-8"
                 ) as ctyfile:
                     globals()["CTYFILE"] = loads(ctyfile.read())
             else:
@@ -1198,7 +1292,7 @@ class MainWindow(QtWidgets.QMainWindow):
             file, _ = QFileDialog.getSaveFileName(
                 self,
                 "Choose a Database",
-                DATA_PATH,
+                str(fsutils.USER_DATA_PATH),
                 "Database (*.db)",
                 options=options,
             )
@@ -1206,7 +1300,7 @@ class MainWindow(QtWidgets.QMainWindow):
             file, _ = QFileDialog.getOpenFileName(
                 self,
                 "Choose a Database",
-                DATA_PATH,
+                str(fsutils.USER_DATA_PATH),
                 "Database (*.db)",
                 options=options,
             )
@@ -1218,24 +1312,38 @@ class MainWindow(QtWidgets.QMainWindow):
         self.clearinputs()
 
     def launch_log_window(self) -> None:
-        """launch the Log Window"""
-        if not check_process("logwindow.py"):
-            _ = subprocess.Popen([sys.executable, WORKING_PATH + "/logwindow.py"])
+        """Launch the log window"""
+        if not self.log_window:
+            log_widget = LogWindow()
+            self.log_window = QDockWidget(log_widget.property("windowTitle"), self)
+            self.log_window.setWidget(log_widget)
+            self.addDockWidget(Qt.BottomDockWidgetArea, self.log_window)
+        self.log_window.show()
 
     def launch_bandmap_window(self) -> None:
-        """launch the Log Window"""
-        if not check_process("bandmap.py"):
-            _ = subprocess.Popen([sys.executable, WORKING_PATH + "/bandmap.py"])
+        """Launch the bandmap window"""
+        if not self.bandmap_window:
+            self.bandmap_window = BandMapWindow()
+            self.addDockWidget(Qt.RightDockWidgetArea, self.bandmap_window)
+        self.bandmap_window.show()
 
     def launch_check_window(self) -> None:
-        """launch the Log Window"""
-        if not check_process("checkwindow.py"):
-            _ = subprocess.Popen([sys.executable, WORKING_PATH + "/checkwindow.py"])
+        """Launch the check window"""
+        if not self.check_window:
+            check_widget = CheckWindow()
+            self.check_window = QDockWidget(check_widget.property("windowTitle"), self)
+            self.check_window.setWidget(check_widget)
+            self.addDockWidget(Qt.RightDockWidgetArea, self.check_window)
+        self.check_window.show()
 
     def launch_vfo(self) -> None:
-        """launch the Log Window"""
-        if not check_process("vfo.py"):
-            _ = subprocess.Popen([sys.executable, WORKING_PATH + "/vfo.py"])
+        """Launch the VFO window"""
+        if not self.vfo_window:
+            vfo_widget = VfoWindow()
+            self.vfo_window = QDockWidget(vfo_widget.property("windowTitle"), self)
+            self.vfo_window.setWidget(vfo_widget)
+            self.addDockWidget(Qt.RightDockWidgetArea, self.vfo_window)
+        self.vfo_window.show()
 
     def clear_band_indicators(self) -> None:
         """
@@ -1252,7 +1360,12 @@ class MainWindow(QtWidgets.QMainWindow):
         for _, indicators in self.all_mode_indicators.items():
             for _, indicator in indicators.items():
                 indicator.setFrameShape(QtWidgets.QFrame.NoFrame)
-                indicator.setStyleSheet("font-family: JetBrains Mono;")
+                if self.text_color == Qt.black:
+                    indicator.setStyleSheet(
+                        "font-family: JetBrains Mono; color: black;"
+                    )
+                else:
+                    indicator.setStyleSheet("font-family: JetBrains Mono; color: white")
 
     def set_band_indicator(self, band: str) -> None:
         """
@@ -1739,7 +1852,13 @@ class MainWindow(QtWidgets.QMainWindow):
         """
 
         logger.debug("New contest Dialog")
-        self.contest_dialog = NewContest(WORKING_PATH)
+
+        self.contest_dialog = NewContest(fsutils.APP_DATA_PATH)
+        if self.current_palette:
+            self.contest_dialog.setPalette(self.current_palette)
+            self.contest_dialog.exchange.setPalette(self.current_palette)
+            self.contest_dialog.operators.setPalette(self.current_palette)
+
         self.contest_dialog.accepted.connect(self.save_contest)
         self.contest_dialog.dateTimeEdit.setDate(QtCore.QDate.currentDate())
         self.contest_dialog.dateTimeEdit.setCalendarPopup(True)
@@ -1804,7 +1923,11 @@ class MainWindow(QtWidgets.QMainWindow):
         """
 
         logger.debug("Station Settings selected")
-        self.settings_dialog = EditStation(WORKING_PATH)
+
+        self.settings_dialog = EditStation(fsutils.APP_DATA_PATH)
+        if self.current_palette:
+            self.settings_dialog.setPalette(self.current_palette)
+
         self.settings_dialog.accepted.connect(self.save_settings)
         self.settings_dialog.Call.setText(self.station.get("Call", ""))
         self.settings_dialog.Name.setText(self.station.get("Name", ""))
@@ -1892,7 +2015,11 @@ class MainWindow(QtWidgets.QMainWindow):
         None
         """
 
-        self.edit_macro_dialog = EditMacro(function_key, WORKING_PATH)
+        self.edit_macro_dialog = EditMacro(function_key, fsutils.APP_DATA_PATH)
+
+        if self.current_palette:
+            self.edit_macro_dialog.setPalette(self.current_palette)
+
         self.edit_macro_dialog.accepted.connect(self.edited_macro)
         self.edit_macro_dialog.open()
 
@@ -1965,7 +2092,7 @@ class MainWindow(QtWidgets.QMainWindow):
         """
 
         logger.debug("Voicing: %s", the_string)
-        op_path = Path(DATA_PATH) / self.current_op
+        op_path = fsutils.USER_DATA_PATH / self.current_op
         if "[" in the_string:
             sub_string = the_string.strip("[]").lower()
             filename = f"{str(op_path)}/{sub_string}.wav"
@@ -2093,11 +2220,9 @@ class MainWindow(QtWidgets.QMainWindow):
 
         logger.debug("writepreferences")
         try:
-            with open(
-                CONFIG_PATH + "/not1mm.json", "wt", encoding="utf-8"
-            ) as file_descriptor:
+            with open(fsutils.CONFIG_FILE, "wt", encoding="utf-8") as file_descriptor:
                 file_descriptor.write(dumps(self.pref, indent=4))
-                logger.info("writing: %s", self.pref)
+                # logger.info("writing: %s", self.pref)
         except IOError as exception:
             logger.critical("writepreferences: %s", exception)
 
@@ -2116,16 +2241,16 @@ class MainWindow(QtWidgets.QMainWindow):
 
         logger.debug("readpreferences")
         try:
-            if os.path.exists(CONFIG_PATH + "/not1mm.json"):
+            if os.path.exists(fsutils.CONFIG_FILE):
                 with open(
-                    CONFIG_PATH + "/not1mm.json", "rt", encoding="utf-8"
+                    fsutils.CONFIG_FILE, "rt", encoding="utf-8"
                 ) as file_descriptor:
                     self.pref = loads(file_descriptor.read())
                     logger.info("%s", self.pref)
             else:
                 logger.info("No preference file. Writing preference.")
                 with open(
-                    CONFIG_PATH + "/not1mm.json", "wt", encoding="utf-8"
+                    fsutils.CONFIG_FILE, "wt", encoding="utf-8"
                 ) as file_descriptor:
                     self.pref = self.pref_ref.copy()
                     file_descriptor.write(dumps(self.pref, indent=4))
@@ -2173,6 +2298,13 @@ class MainWindow(QtWidgets.QMainWindow):
         )
         self.multicast_interface.ready_read_connect(self.watch_udp)
 
+        if self.pref.get("darkmode"):
+            self.actionDark_Mode_2.setChecked(True)
+            self.setDarkMode(True)
+        else:
+            self.setDarkMode(False)
+            self.actionDark_Mode_2.setChecked(False)
+
         self.rig_control = None
 
         if self.pref.get("useflrig", False):
@@ -2300,6 +2432,24 @@ class MainWindow(QtWidgets.QMainWindow):
                     cmd["worked"] = result
                     self.multicast_interface.send_as_json(cmd)
 
+                if (
+                    json_data.get("cmd", "") == "GETCONTESTSTATUS"
+                    and json_data.get("station", "") == platform.node()
+                ):
+                    cmd = {
+                        "cmd": "CONTESTSTATUS",
+                        "station": platform.node(),
+                        "contest": self.contest_settings,
+                        "operator": self.current_op,
+                    }
+                    self.multicast_interface.send_as_json(cmd)
+
+    def dark_mode_state_changed(self) -> None:
+        """Called when the Dark Mode menu state is changed."""
+        self.pref["darkmode"] = self.actionDark_Mode_2.isChecked()
+        self.write_preference()
+        self.setDarkMode(self.actionDark_Mode_2.isChecked())
+
     def cw_macros_state_changed(self) -> None:
         """
         Menu item to show/hide macro buttons.
@@ -2769,7 +2919,11 @@ class MainWindow(QtWidgets.QMainWindow):
         None
         """
 
-        self.opon_dialog = OpOn(WORKING_PATH)
+        self.opon_dialog = OpOn(fsutils.APP_DATA_PATH)
+
+        if self.current_palette:
+            self.opon_dialog.setPalette(self.current_palette)
+
         self.opon_dialog.accepted.connect(self.new_op)
         self.opon_dialog.open()
 
@@ -2808,13 +2962,13 @@ class MainWindow(QtWidgets.QMainWindow):
         """
 
         if self.current_op:
-            op_path = Path(DATA_PATH) / self.current_op
+            op_path = fsutils.USER_DATA_PATH / self.current_op
             logger.debug("op_path: %s", str(op_path))
             if op_path.is_dir() is False:
                 logger.debug("Creating Op Directory: %s", str(op_path))
                 os.mkdir(str(op_path))
             if op_path.is_dir():
-                source_path = Path(WORKING_PATH) / "data" / "phonetics"
+                source_path = fsutils.APP_DATA_PATH / "phonetics"
                 logger.debug("source_path: %s", str(source_path))
                 for child in source_path.iterdir():
                     destination_file = op_path / child.name
@@ -2911,13 +3065,20 @@ class MainWindow(QtWidgets.QMainWindow):
         None
         """
         if self.radio_state.get("mode") == "CW":
-            macro_file = "/cwmacros.txt"
+            macro_file = "cwmacros.txt"
         else:
-            macro_file = "/ssbmacros.txt"
-        if not Path(DATA_PATH + macro_file).exists():
+            macro_file = "ssbmacros.txt"
+        if not (fsutils.USER_DATA_PATH / macro_file).exists():
             logger.debug("read_cw_macros: copying default macro file.")
-            copyfile(WORKING_PATH + "/data" + macro_file, DATA_PATH + macro_file)
-        os.system(f"xdg-open {DATA_PATH}{macro_file}")
+            copyfile(
+                fsutils.APP_DATA_PATH / macro_file, fsutils.USER_DATA_PATH / macro_file
+            )
+        try:
+            fsutils.openFileWithOS(fsutils.USER_DATA_PATH / macro_file)
+        except:
+            logger.exception(
+                f"Could not open file {fsutils.USER_DATA_PATH / macro_file}"
+            )
 
     def read_cw_macros(self) -> None:
         """
@@ -2927,14 +3088,18 @@ class MainWindow(QtWidgets.QMainWindow):
         """
 
         if self.radio_state.get("mode") == "CW":
-            macro_file = "/cwmacros.txt"
+            macro_file = "cwmacros.txt"
         else:
-            macro_file = "/ssbmacros.txt"
+            macro_file = "ssbmacros.txt"
 
-        if not Path(DATA_PATH + macro_file).exists():
+        if not (fsutils.USER_DATA_PATH / macro_file).exists():
             logger.debug("read_cw_macros: copying default macro file.")
-            copyfile(WORKING_PATH + "/data" + macro_file, DATA_PATH + macro_file)
-        with open(DATA_PATH + macro_file, "r", encoding="utf-8") as file_descriptor:
+            copyfile(
+                fsutils.APP_DATA_PATH / macro_file, fsutils.USER_DATA_PATH / macro_file
+            )
+        with open(
+            fsutils.USER_DATA_PATH / macro_file, "r", encoding="utf-8"
+        ) as file_descriptor:
             for line in file_descriptor:
                 try:
                     mode, fkey, buttonname, cwtext = line.split("|")
@@ -3043,17 +3208,19 @@ def install_icons() -> None:
     if sys.platform == "linux":
         os.system(
             "xdg-icon-resource install --size 32 --context apps --mode user "
-            f"{WORKING_PATH}/data/k6gte.not1mm-32.png k6gte-not1mm"
+            f"{fsutils.MODULE_PATH}/data/k6gte.not1mm-32.png k6gte-not1mm"
         )
         os.system(
             "xdg-icon-resource install --size 64 --context apps --mode user "
-            f"{WORKING_PATH}/data/k6gte.not1mm-64.png k6gte-not1mm"
+            f"{fsutils.MODULE_PATH}/data/k6gte.not1mm-64.png k6gte-not1mm"
         )
         os.system(
             "xdg-icon-resource install --size 128 --context apps --mode user "
-            f"{WORKING_PATH}/data/k6gte.not1mm-128.png k6gte-not1mm"
+            f"{fsutils.MODULE_PATH}/data/k6gte.not1mm-128.png k6gte-not1mm"
+        )
+        os.system(
+            f"xdg-desktop-menu install {fsutils.MODULE_PATH}/data/k6gte-not1mm.desktop"
         )
-        os.system(f"xdg-desktop-menu install {WORKING_PATH}/data/k6gte-not1mm.desktop")
 
 
 def doimp(modname) -> object:
@@ -3079,36 +3246,35 @@ def run() -> None:
     """
     Main Entry
     """
+    logger.debug(
+        f"Resolved OS file system paths: MODULE_PATH {fsutils.MODULE_PATH}, USER_DATA_PATH {fsutils.USER_DATA_PATH}, CONFIG_PATH {fsutils.CONFIG_PATH}"
+    )
     install_icons()
     timer.start(250)
     sys.exit(app.exec())
 
 
-logger = logging.getLogger("__main__")
-handler = logging.StreamHandler()
-formatter = logging.Formatter(
-    datefmt="%H:%M:%S",
-    fmt="[%(asctime)s] %(levelname)s %(module)s - %(funcName)s Line %(lineno)d: %(message)s",
-)
-handler.setFormatter(formatter)
-logger.addHandler(handler)
-
-BETA_TEST = False
-if Path("./betatest").exists():
-    BETA_TEST = True
-
+DEBUG_ENABLED = False
 if Path("./debug").exists():
-    logger.setLevel(logging.DEBUG)
-    logger.debug("debugging on")
-else:
-    logger.setLevel(logging.WARNING)
-    # logger.warning("debugging off")
+    DEBUG_ENABLED = True
 
+logger = logging.getLogger("__main__")
+
+logging.basicConfig(
+    level=logging.DEBUG if DEBUG_ENABLED else logging.CRITICAL,
+    format="[%(asctime)s] %(levelname)s %(name)s - %(funcName)s Line %(lineno)d: %(message)s",
+    handlers=[
+        RotatingFileHandler(fsutils.LOG_FILE, maxBytes=10490000, backupCount=20),
+        logging.StreamHandler(),
+    ],
+)
+logging.getLogger("PyQt5.uic.uiparser").setLevel("INFO")
+logging.getLogger("PyQt5.uic.properties").setLevel("INFO")
+os.environ["QT_QPA_PLATFORMTHEME"] = "gnome"
 app = QtWidgets.QApplication(sys.argv)
-app.setStyle("Adwaita-Dark")
-font_path = WORKING_PATH + "/data"
-families = load_fonts_from_dir(os.fspath(font_path))
-logger.info(families)
+
+families = load_fonts_from_dir(os.fspath(fsutils.APP_DATA_PATH))
+logger.info(f"font families {families}")
 window = MainWindow()
 height = window.pref.get("window_height", 300)
 width = window.pref.get("window_width", 700)