OverlaySettings: Refactor to be more event-driven complaint

rare/components/tabs/settings/widgets/overlay.py

@@ -1,13 +1,12 @@
 from abc import abstractmethod
-from enum import Enum, IntEnum
+from enum import IntEnum
 from logging import getLogger
-from typing import List, Dict, Tuple, Any, Union
+from typing import List, Dict, Tuple, Union, Optional
 
-from PyQt5.QtCore import QCoreApplication, pyqtSignal
+from PyQt5.QtCore import pyqtSignal, Qt
 from PyQt5.QtGui import QIntValidator, QDoubleValidator, QShowEvent
 from PyQt5.QtWidgets import QGroupBox, QCheckBox, QLineEdit, QComboBox
 
-from rare.shared import LegendaryCoreSingleton
 from rare.ui.components.tabs.settings.widgets.overlay import Ui_OverlaySettings
 from rare.utils import config_helper as config
 
@@ -15,65 +14,95 @@ logger = getLogger("GameOverlays")
 
 
 class OverlayLineEdit(QLineEdit):
-    def __init__(self, parent=None):
+    def __init__(self, option: str, placeholder: str, parent=None):
+        self.option = option
         super(OverlayLineEdit, self).__init__(parent=parent)
         self.valueChanged = self.textChanged
-        self.setValue = self.setText
+
+        self.setPlaceholderText(placeholder)
 
     def setDefault(self):
         self.setText("")
 
-    def getValue(self):
+    def getValue(self) -> Optional[str]:
-        return self.text()
+        return f"{self.option}={text}" if (text := self.text()) else None
+
+    def setValue(self, options: Dict[str, str]):
+        if (value := options.get(self.option, None)) is not None:
+            self.setText(value)
+            options.pop(self.option)
+        else:
+            self.setDefault()
 
 
 class OverlayComboBox(QComboBox):
-    def __init__(self, parent=None):
+    def __init__(self, option: str, parent=None):
+        self.option = option
         super(OverlayComboBox, self).__init__(parent=parent)
         self.valueChanged = self.currentIndexChanged
-        self.setValue = self.setCurrentText
-        self.getValue = self.currentText
 
     def setDefault(self):
         self.setCurrentIndex(0)
 
+    def getValue(self) -> Optional[str]:
+        return f"{self.option}={self.currentText()}" if self.currentIndex() > 0 else None
 
-class CustomOption:
+    def setValue(self, options: Dict[str, str]):
-    option: str
+        if (value := options.get(self.option, None)) is not None:
-    widget: Union[OverlayLineEdit, OverlayComboBox]
+            self.setCurrentText(value)
+            options.pop(self.option)
+        else:
+            self.setDefault()
 
-    @classmethod
-    def string_input(cls, option: str, placeholder: str):
-        tmp = cls()
-        tmp.option = option
-        tmp.widget = OverlayLineEdit()
-        tmp.widget.setPlaceholderText(placeholder)
-        return tmp
 
-    @classmethod
+class OverlayCheckBox(QCheckBox):
-    def number_input(cls, option: str, placeholder: Any, is_float: bool = False):
+    def __init__(self, option: str, title: str, desc: str = "", default_enabled: bool = False, parent=None):
-        tmp = cls()
+        self.option = option
-        tmp.option = option
+        super().__init__(title, parent=parent)
-        tmp.widget = OverlayLineEdit()
+        self.setChecked(default_enabled)
-        tmp.widget.setPlaceholderText(str(placeholder))
+        self.default_enabled = default_enabled
-        validator = QDoubleValidator() if is_float else QIntValidator()
+        self.setToolTip(desc)
-        tmp.widget.setValidator(validator)
-        return tmp
 
-    @classmethod
+    def setDefault(self):
-    def select_input(cls, option: str, values: List[str]):
+        self.setChecked(self.default_enabled)
-        """options: default value in options[0]"""
+
-        tmp = cls()
+    def getValue(self) -> Optional[str]:
-        tmp.option = option
+        # lk: return the check state in case of non-default, otherwise None
-        tmp.widget = OverlayComboBox()
+        checked = self.isChecked()
-        tmp.widget.addItems(values)
+        value = f"{self.option}={int(checked)}" if self.default_enabled else self.option
-        return tmp
+        return value if checked ^ self.default_enabled else None
+
+    def setValue(self, options: Dict[str, str]):
+        if options.get(self.option, None) is not None:
+            self.setChecked(not self.default_enabled)
+            options.pop(self.option)
+        else:
+            self.setChecked(self.default_enabled)
+
+
+class OverlayStringInput(OverlayLineEdit):
+    def __init__(self, option: str, placeholder: str, parent=None):
+        super().__init__(option, placeholder, parent=parent)
+
+
+class OverlayNumberInput(OverlayLineEdit):
+    def __init__(self, option: str, placeholder: Union[int, float], parent=None):
+        super().__init__(option, str(placeholder), parent=parent)
+        validator = QDoubleValidator(self) if isinstance(placeholder, float) else QIntValidator(self)
+        self.setValidator(validator)
+
+
+class OverlaySelectInput(OverlayComboBox):
+    def __init__(self, option: str, values: List, parent=None):
+        super().__init__(option, parent=parent)
+        self.addItems([str(v) for v in values])
 
 
 class ActivationStates(IntEnum):
-    DEFAULT = -1
+    GLOBAL = -1
-    HIDDEN = 0
+    DISABLED = 0
-    ENABLED = 1
+    DEFAULTS = 1
+    CUSTOM = 2
 
 
 class OverlaySettings(QGroupBox):
@@ -85,116 +114,150 @@ class OverlaySettings(QGroupBox):
         self.ui = Ui_OverlaySettings()
         self.ui.setupUi(self)
 
-        self.core = LegendaryCoreSingleton()
+        self.ui.show_overlay_combo.addItem(self.tr("Global"), ActivationStates.GLOBAL)
-        self.envvar_name: str = None
+        self.ui.show_overlay_combo.addItem(self.tr("Disabled"), ActivationStates.DISABLED)
+        self.ui.show_overlay_combo.addItem(self.tr("Enabled (defaults)"), ActivationStates.DEFAULTS)
+        self.ui.show_overlay_combo.addItem(self.tr("Enabled (custom)"), ActivationStates.CUSTOM)
+
+        self.envvar: str = None
         self.force_disabled: str = None
+        self.force_defaults: str = None
         self.app_name: str = "default"
-        self.checkboxes: Dict[str, QCheckBox] = {}
+
-        self.values: Dict[str, Union[OverlayLineEdit, OverlayComboBox]] = {}
+        self.option_widgets: List[Union[OverlayCheckBox, OverlayLineEdit, OverlayComboBox]] = []
+        # self.checkboxes: Dict[str, OverlayCheckBox] = {}
+        # self.values: Dict[str, Union[OverlayLineEdit, OverlayComboBox]] = {}
 
         self.ui.options_group.setTitle(self.tr("Custom options"))
         self.ui.show_overlay_combo.currentIndexChanged.connect(self.update_settings)
 
     def setupWidget(
         self,
-        checkbox_map: List[Tuple[str, str]],
+        grid_map: List[OverlayCheckBox],
-        custom_map: List[Tuple[CustomOption, str]],
+        form_map: List[Tuple[Union[OverlayLineEdit, OverlayComboBox], str]],
-        envvar_name: str,
+        envvar: str,
         force_disabled: str,
+        force_defaults: str,
     ):
-        self.envvar_name = envvar_name
+        self.envvar = envvar
         self.force_disabled = force_disabled
+        self.force_defaults = force_defaults
 
-        for i, (variable, text) in enumerate(checkbox_map):
+        for i, widget in enumerate(grid_map):
-            checkbox = QCheckBox(text)
+            widget.setParent(self.ui.options_group)
-            self.ui.options_grid.addWidget(checkbox, i // 4, i % 4)
+            self.ui.options_grid.addWidget(widget, i // 4, i % 4)
-            self.checkboxes[variable] = checkbox
+            # self.checkboxes[widget.option] = widget
-            checkbox.stateChanged.connect(self.update_settings)
+            self.option_widgets.append(widget)
+            widget.stateChanged.connect(self.update_settings)
 
-        for option, text in custom_map:
+        for widget, label in form_map:
-            widget = option.widget
+            widget.setParent(self.ui.options_group)
-            self.ui.options_form.addRow(text, widget)
+            self.ui.options_form.addRow(label, widget)
-            self.values[option.option] = widget
+            # self.values[widget.option] = widget
+            self.option_widgets.append(widget)
             widget.valueChanged.connect(self.update_settings)
 
     @abstractmethod
-    def set_activation_state(self, state: ActivationStates):
+    def update_settings_override(self, state: ActivationStates):
         raise NotImplementedError
 
     def update_settings(self):
-        if self.ui.show_overlay_combo.currentIndex() == 0:
+        current_state = self.ui.show_overlay_combo.currentData(Qt.UserRole)
-            # System default
+        self.ui.options_group.setEnabled(current_state == ActivationStates.CUSTOM)
-            config.remove_envvar(self.app_name, self.envvar_name)
-            self.environ_changed.emit(self.envvar_name)
-            self.ui.options_group.setDisabled(True)
-            self.set_activation_state(ActivationStates.DEFAULT)
-            return
 
-        elif self.ui.show_overlay_combo.currentIndex() == 1:
+        if current_state == ActivationStates.GLOBAL:
+            # System default (don't add any env variables)
+            config.remove_envvar(self.app_name, self.envvar)
+
+        elif current_state == ActivationStates.DISABLED:
             # hidden
-            config.set_envvar(self.app_name, self.envvar_name, self.force_disabled)
+            config.set_envvar(self.app_name, self.envvar, self.force_disabled)
-            self.environ_changed.emit(self.envvar_name)
+
-            self.ui.options_group.setDisabled(True)
+        elif current_state == ActivationStates.DEFAULTS:
-            self.set_activation_state(ActivationStates.HIDDEN)
+            config.set_envvar(self.app_name, self.envvar, self.force_defaults)
-            return
+
-        elif self.ui.show_overlay_combo.currentIndex() == 2:
+        elif current_state == ActivationStates.CUSTOM:
             self.ui.options_group.setDisabled(False)
             # custom options
-            var_names = []
+            options = [widget.getValue() for widget in self.option_widgets]
-            for var_name, cb in self.checkboxes.items():
-                if cb.isChecked():
-                    var_names.append(var_name)
 
-            for var_name, widget in self.values.items():
+            # options = []
-                text = widget.getValue()
+            # for var_name, cb in self.checkboxes.items():
-                if text not in ["default", ""]:
+            #     options.append(cb.getValue())
-                    var_names.append(f"{var_name}={text}")
+            #
+            # for var_name, widget in self.values.items():
+            #     options.append(widget.getValue())
 
-            if not var_names:
+            options = [name for name in options if name is not None]
-                list(self.checkboxes.values())[0].setChecked(True)
-                var_names.append(list(self.checkboxes.keys())[0])
 
-            config.set_envvar(self.app_name, self.envvar_name, ",".join(var_names))
+            config.set_envvar(self.app_name, self.envvar, ",".join(options))
-            self.environ_changed.emit(self.envvar_name)
+
-            self.set_activation_state(ActivationStates.ENABLED)
+        self.environ_changed.emit(self.envvar)
+        self.update_settings_override(current_state)
+
+        print(f"{self.envvar} = {config.get_envvar(self.app_name, self.envvar)}")
+
+    def setCurrentState(self, state: ActivationStates):
+        self.ui.show_overlay_combo.setCurrentIndex(self.ui.show_overlay_combo.findData(state, Qt.UserRole))
+        self.ui.options_group.setEnabled(state == ActivationStates.CUSTOM)
 
     def showEvent(self, a0: QShowEvent):
         if a0.spontaneous():
             return super().showEvent(a0)
+        self.ui.options_group.blockSignals(True)
 
-        for checkbox in self.checkboxes.values():
+        # for checkbox in self.checkboxes.values():
-            checkbox.setChecked(False)
+        #     checkbox.setChecked(False)
-        for widget in self.values.values():
+        # for widget in self.values.values():
-            widget.setDefault()
+        #     widget.setDefault()
 
-        options = config.get_envvar(self.app_name, self.envvar_name, fallback=None)
+        config_options = config.get_envvar(self.app_name, self.envvar, fallback=None)
-        if options is None:
+        if config_options is None:
-            logger.debug(f"No Overlay settings found {self.envvar_name}")
+            logger.debug("Overlay setting %s is not present", self.envvar)
-            self.ui.show_overlay_combo.setCurrentIndex(0)
+            self.setCurrentState(ActivationStates.GLOBAL)
-            self.ui.options_group.setDisabled(True)
 
-        elif options == self.force_disabled:
+        elif config_options == self.force_disabled:
-            # not visible
+            self.setCurrentState(ActivationStates.DISABLED)
-            self.ui.options_group.setDisabled(True)
+
-            self.ui.show_overlay_combo.setCurrentIndex(1)
+        elif config_options == self.force_defaults:
+            self.setCurrentState(ActivationStates.DEFAULTS)
 
         else:
-            self.ui.show_overlay_combo.setCurrentIndex(2)
+            self.setCurrentState(ActivationStates.CUSTOM)
-            for option in options.split(","):
+            opts = {}
-                try:
+            for o in config_options.split(","):
-                    if "=" in option:
+                if "=" in o:
-                        key, value = option.split("=")
+                    k, v = o.split("=")
-                        if key in self.checkboxes.keys():
+                    opts[k] = v
-                            self.checkboxes[key].setChecked(False)
                 else:
-                            self.values[key].setValue(value)
+                    # lk: The value doesn't matter other than not being None
-                    else:
+                    opts[o] = "enable"
-                        self.checkboxes[option].setChecked(True)
-                except Exception as e:
-                    logger.warning(e)
 
-            self.ui.options_group.setDisabled(False)
+            for widget in self.option_widgets:
+                print(opts)
+                widget.setValue(opts)
+            # for checkbox in self.checkboxes.values():
+            #     print(opts)
+            #     checkbox.setValue(opts)
+            #
+            # for values in self.values.values():
+            #     print(opts)
+            #     values.setValue(opts)
 
+            print(opts)
+            # try:
+            #     if "=" in option:
+            #         key, value = option.split("=")
+            #         if key in self.checkboxes.keys():
+            #             self.checkboxes[key].setChecked(False)
+            #         else:
+            #             self.values[key].setValue(value)
+            #     else:
+            #         self.checkboxes[option].setChecked(True)
+            # except Exception as e:
+            #     logger.warning(e)
+
+        self.ui.options_group.blockSignals(False)
         return super().showEvent(a0)
 
 
@@ -202,28 +265,20 @@ class DxvkSettings(OverlaySettings):
     def __init__(self, parent=None):
         super(DxvkSettings, self).__init__(parent=parent)
         self.setTitle(self.tr("DXVK settings"))
-        self.setupWidget(
+        grid = [
-            [
+            OverlayCheckBox("fps", self.tr("FPS")),
-                ("fps", QCoreApplication.translate("DxvkSettings", "FPS")),
+            OverlayCheckBox("frametime", self.tr("Frametime")),
-                ("frametime", QCoreApplication.translate("DxvkSettings", "Frametime")),
+            OverlayCheckBox("memory", self.tr("Memory usage")),
-                ("memory", QCoreApplication.translate("DxvkSettings", "Memory usage")),
+            OverlayCheckBox("gpuload", self.tr("GPU usage")),
-                ("gpuload", QCoreApplication.translate("DxvkSettings", "GPU usage")),
+            OverlayCheckBox("devinfo", self.tr("Device info")),
-                ("devinfo", QCoreApplication.translate("DxvkSettings", "Show Device info")),
+            OverlayCheckBox("version", self.tr("DXVK version")),
-                ("version", QCoreApplication.translate("DxvkSettings", "DXVK Version")),
+            OverlayCheckBox("api", self.tr("D3D feature level")),
-                ("api", QCoreApplication.translate("DxvkSettings", "D3D feature level")),
+            OverlayCheckBox("compiler", self.tr("Compiler activity")),
-                ("compiler", QCoreApplication.translate("DxvkSettings", "Compiler activity")),
+        ]
-            ],
+        form = [(OverlayNumberInput("scale", 1.0), self.tr("Scale"))]
-            [
+        self.setupWidget(grid, form, "DXVK_HUD", "0", "1")
-                (
-                    CustomOption.number_input("scale", 1, True),
-                    QCoreApplication.translate("DxvkSettings", "Scale"),
-                )
-            ],
-            "DXVK_HUD",
-            "0",
-        )
 
-    def set_activation_state(self, state: ActivationStates):
+    def update_settings_override(self, state: ActivationStates):
         pass
 
 
@@ -243,89 +298,119 @@ class MangoHudSettings(OverlaySettings):
     def __init__(self, parent=None):
         super(MangoHudSettings, self).__init__(parent=parent)
         self.setTitle(self.tr("MangoHud settings"))
-        self.setupWidget(
+        grid = [
-            [
+            OverlayCheckBox("read_cfg", self.tr("Read config")),
-                ("fps", QCoreApplication.translate("MangoSettings", "FPS")),
+            OverlayCheckBox("fps", self.tr("FPS"), default_enabled=True),
-                ("frame_timing", QCoreApplication.translate("MangoSettings", "Frame Time")),
+            OverlayCheckBox("frame_timing", self.tr("Frame time"), default_enabled=True),
-                ("cpu_stats", QCoreApplication.translate("MangoSettings", "CPU Load")),
+            OverlayCheckBox("cpu_stats", self.tr("CPU load"), default_enabled=True),
-                ("gpu_stats", QCoreApplication.translate("MangoSettings", "GPU Load")),
+            OverlayCheckBox("gpu_stats", self.tr("GPU load"), default_enabled=True),
-                ("cpu_temp", QCoreApplication.translate("MangoSettings", "CPU Temp")),
+            OverlayCheckBox("cpu_temp", self.tr("CPU temperature")),
-                ("gpu_temp", QCoreApplication.translate("MangoSettings", "GPU Temp")),
+            OverlayCheckBox("gpu_temp", self.tr("GPU temperature")),
-                ("ram", QCoreApplication.translate("MangoSettings", "Memory usage")),
+            OverlayCheckBox("ram", self.tr("Memory usage")),
-                ("vram", QCoreApplication.translate("MangoSettings", "VRAM usage")),
+            OverlayCheckBox("vram", self.tr("VRAM usage")),
-                ("time", QCoreApplication.translate("MangoSettings", "Local Time")),
+            OverlayCheckBox("time", self.tr("Local time")),
-                ("version", QCoreApplication.translate("MangoSettings", "MangoHud Version")),
+            OverlayCheckBox("version", self.tr("MangoHud version")),
-                ("arch", QCoreApplication.translate("MangoSettings", "System architecture")),
+            OverlayCheckBox("arch", self.tr("System architecture")),
-                ("histogram", QCoreApplication.translate("MangoSettings", "FPS Graph")),
+            OverlayCheckBox("histogram", self.tr("FPS graph")),
-                ("gpu_name", QCoreApplication.translate("MangoSettings", "GPU Name")),
+            OverlayCheckBox("gpu_name", self.tr("GPU name")),
-                ("cpu_power", QCoreApplication.translate("MangoSettings", "CPU Power consumption")),
+            OverlayCheckBox("cpu_power", self.tr("CPU power consumption")),
-                ("gpu_power", QCoreApplication.translate("MangoSettings", "GPU Power consumption")),
+            OverlayCheckBox("gpu_power", self.tr("GPU power consumption")),
-            ],
+        ]
-            [
+        form = [
-                (
+            (OverlayNumberInput("font_size", 24), self.tr("Font size")),
-                    CustomOption.number_input("font_size", 24, is_float=False),
+            (OverlaySelectInput("position", mangohud_position), self.tr("Position")),
-                    QCoreApplication.translate("MangoSettings", "Font size"),
+        ]
-                ),
+
-                (
+        self.setupWidget(grid, form, "MANGOHUD_CONFIG", "no_display", "read_cfg")
-                    CustomOption.select_input("position", mangohud_position),
-                    QCoreApplication.translate("MangoSettings", "Position"),
-                ),
-            ],
-            "MANGOHUD_CONFIG",
-            "no_display",
-        )
 
     def showEvent(self, a0: QShowEvent):
         if a0.spontaneous():
             return super().showEvent(a0)
+        self.ui.options_group.blockSignals(True)
 
         # override
-        activated = bool(config.get_envvar(self.app_name, "MANGOHUD", None))
+        # activated = config.get_envvar(self.app_name, "MANGOHUD", None)
-        mango_config = config.get_envvar(self.app_name, "MANGOHUD_CONFIG", fallback="")
+        # mango_config = config.get_envvar(self.app_name, "MANGOHUD_CONFIG", fallback="")
-        if not activated:
+        # if activated is None:
-            self.ui.options_group.setDisabled(True)
+        #     self.setCurrentState(ActivationStates.SYSTEM)
-            for i, checkbox in enumerate(list(self.checkboxes.values())):
+        # else:
-                checkbox.setChecked(i < 4)
+        #     if activated == "1":
-            self.ui.show_overlay_combo.setCurrentIndex(0)
+        # if not activated:
-            return
+        #     self.ui.options_group.setDisabled(True)
-        self.ui.show_overlay_combo.setCurrentIndex(2)
+        #     for i, checkbox in enumerate(list(self.checkboxes.values())):
-        self.ui.options_group.setDisabled(False)
+        #         checkbox.setChecked(i < 4)
-        for var_name, checkbox in list(self.checkboxes.items())[:4]:
+        #     self.ui.show_overlay_combo.setCurrentIndex(0)
-            checkbox.setChecked(f"{var_name}=0" not in mango_config)
+        #     return
+        # self.ui.show_overlay_combo.setCurrentIndex(2)
+        # self.ui.options_group.setDisabled(False)
+        # for var_name, checkbox in list(self.checkboxes.items())[:4]:
+        #     checkbox.setChecked(f"{var_name}=0" not in mango_config)
 
+        self.ui.options_group.blockSignals(False)
         return super().showEvent(a0)
 
-    def set_activation_state(self, state: IntEnum):  # pylint: disable=E0202
+    def update_settings_override(self, state: IntEnum):  # pylint: disable=E0202
-        if state == ActivationStates.DEFAULT:
+        if state == ActivationStates.GLOBAL:
             config.remove_envvar(self.app_name, "MANGOHUD")
-            config.remove_envvar(self.app_name, "MANGOHUD_CONFIG")
-            self.ui.options_group.setDisabled(True)
 
-        elif state == ActivationStates.HIDDEN:
+        elif state == ActivationStates.DISABLED:
+            config.set_envvar(self.app_name, "MANGOHUD", "0")
+
+        elif state == ActivationStates.DEFAULTS:
             config.set_envvar(self.app_name, "MANGOHUD", "1")
-            config.set_envvar(self.app_name, "MANGOHUD_CONFIG", self.force_disabled)
 
-        elif state == ActivationStates.ENABLED:
+        elif state == ActivationStates.CUSTOM:
-            mango_config = config.get_envvar(self.app_name, "MANGOHUD_CONFIG", fallback="")
-
-            split_config = mango_config.split(",")
-            for name in list(self.checkboxes.keys())[:4]:
-                if name in split_config:
-                    split_config.remove(name)
-            mango_config = ",".join(split_config)
-
-            # first three are activated by default
-            for var_name, checkbox in list(self.checkboxes.items())[:4]:
-                if not checkbox.isChecked():
-                    if mango_config:
-                        mango_config += f",{var_name}=0"
-                    else:
-                        mango_config = f"{var_name}=0"
-            if mango_config:
             config.set_envvar(self.app_name, "MANGOHUD", "1")
-                config.set_envvar(self.app_name, "MANGOHUD_CONFIG", mango_config)
+            # mango_config = config.get_envvar(self.app_name, self.envvar, fallback="")
-            else:
+            # mango_config = f"read_cfg,{mango_config}" if mango_config else "read_cfg"
-                config.remove_envvar(self.app_name, "MANGOHUD")
+            # config.set_envvar(self.app_name, self.envvar, mango_config)
-                config.remove_envvar(self.app_name, "MANGOHUD_CONFIG")
+            # self.environ_changed.emit("MANGOHUD_CONFIG")
+
+            # split_config = mango_config.split(",")
+            # for name in list(self.checkboxes.keys())[:4]:
+            #     if name in split_config:
+            #         split_config.remove(name)
+            # mango_config = ",".join(split_config)
+            #
+            # # first three are activated by default
+            # for var_name, checkbox in list(self.checkboxes.items())[:4]:
+            #     if not checkbox.isChecked():
+            #         if mango_config:
+            #             mango_config += f",{var_name}=0"
+            #         else:
+            #             mango_config = f"{var_name}=0"
+            # if mango_config:
+            #     config.set_envvar(self.app_name, "MANGOHUD", "1")
+            #     config.set_envvar(self.app_name, "MANGOHUD_CONFIG", mango_config)
+            # else:
+            #     config.remove_envvar(self.app_name, "MANGOHUD")
+            #     config.remove_envvar(self.app_name, "MANGOHUD_CONFIG")
+
         self.environ_changed.emit("MANGOHUD")
-        self.environ_changed.emit("MANGOHUD_CONFIG")
+
+        print(f"MANGOHUD = {config.get_envvar(self.app_name, 'MANGOHUD')}")
+
+
+if __name__ == "__main__":
+    import sys
+    from PyQt5.QtWidgets import QApplication, QDialog, QVBoxLayout
+
+    from legendary.core import LegendaryCore
+
+    core = LegendaryCore()
+    config.init_config_handler(core)
+
+    app = QApplication(sys.argv)
+    dlg = QDialog()
+
+    dxvk = DxvkSettings(dlg)
+    mangohud = MangoHudSettings(dlg)
+
+    layout = QVBoxLayout(dlg)
+    layout.addWidget(dxvk)
+    layout.addWidget(mangohud)
+
+    dlg.show()
+    ret = app.exec()
+    config.save_config()
+    sys.exit(ret)

rare/ui/components/tabs/settings/widgets/overlay.py

@@ -34,9 +34,6 @@ class Ui_OverlaySettings(object):
         sizePolicy.setHeightForWidth(self.show_overlay_combo.sizePolicy().hasHeightForWidth())
         self.show_overlay_combo.setSizePolicy(sizePolicy)
         self.show_overlay_combo.setObjectName("show_overlay_combo")
-        self.show_overlay_combo.addItem("")
-        self.show_overlay_combo.addItem("")
-        self.show_overlay_combo.addItem("")
         self.main_layout.addWidget(self.show_overlay_combo, 0, 1, 1, 2)
         self.options_group = QtWidgets.QGroupBox(OverlaySettings)
         self.options_group.setTitle("")
@@ -59,9 +56,6 @@ class Ui_OverlaySettings(object):
     def retranslateUi(self, OverlaySettings):
         _translate = QtCore.QCoreApplication.translate
         self.show_overlay_label.setText(_translate("OverlaySettings", "Show HUD"))
-        self.show_overlay_combo.setItemText(0, _translate("OverlaySettings", "System Default"))
-        self.show_overlay_combo.setItemText(1, _translate("OverlaySettings", "Hidden"))
-        self.show_overlay_combo.setItemText(2, _translate("OverlaySettings", "Visible"))
 
 
 if __name__ == "__main__":

rare/ui/components/tabs/settings/widgets/overlay.ui

@@ -14,7 +14,7 @@
    <string notr="true">OverlaySettings</string>
   </property>
   <property name="title">
-   <string/>
+   <string notr="true"/>
   </property>
   <layout class="QGridLayout" name="main_layout">
    <item row="0" column="0">
@@ -38,27 +38,12 @@
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
-     <item>
-      <property name="text">
-       <string>System Default</string>
-      </property>
-     </item>
-     <item>
-      <property name="text">
-       <string>Hidden</string>
-      </property>
-     </item>
-     <item>
-      <property name="text">
-       <string>Visible</string>
-      </property>
-     </item>
     </widget>
    </item>
    <item row="2" column="0" colspan="3">
     <widget class="QGroupBox" name="options_group">
      <property name="title">
-      <string/>
+      <string notr="true"/>
      </property>
      <layout class="QGridLayout" name="options_layout">
       <item row="1" column="0">