From a15a2fbbe2e25247fa79986775a40a38edfcba21 Mon Sep 17 00:00:00 2001 From: loathingKernel <142770+loathingKernel@users.noreply.github.com> Date: Thu, 18 Jan 2024 16:31:21 +0200 Subject: [PATCH] OverlaySettings: Refactor to be more event-driven complaint --- .../tabs/settings/widgets/overlay.py | 495 ++++++++++-------- .../tabs/settings/widgets/overlay.py | 8 +- .../tabs/settings/widgets/overlay.ui | 21 +- 3 files changed, 294 insertions(+), 230 deletions(-) diff --git a/rare/components/tabs/settings/widgets/overlay.py b/rare/components/tabs/settings/widgets/overlay.py index 40bea104..303be8b2 100644 --- a/rare/components/tabs/settings/widgets/overlay.py +++ b/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): - return self.text() + def getValue(self) -> Optional[str]: + 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: - option: str - widget: Union[OverlayLineEdit, OverlayComboBox] + def setValue(self, options: Dict[str, str]): + if (value := options.get(self.option, None)) is not None: + 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 - def number_input(cls, option: str, placeholder: Any, is_float: bool = False): - tmp = cls() - tmp.option = option - tmp.widget = OverlayLineEdit() - tmp.widget.setPlaceholderText(str(placeholder)) - validator = QDoubleValidator() if is_float else QIntValidator() - tmp.widget.setValidator(validator) - return tmp +class OverlayCheckBox(QCheckBox): + def __init__(self, option: str, title: str, desc: str = "", default_enabled: bool = False, parent=None): + self.option = option + super().__init__(title, parent=parent) + self.setChecked(default_enabled) + self.default_enabled = default_enabled + self.setToolTip(desc) - @classmethod - def select_input(cls, option: str, values: List[str]): - """options: default value in options[0]""" - tmp = cls() - tmp.option = option - tmp.widget = OverlayComboBox() - tmp.widget.addItems(values) - return tmp + def setDefault(self): + self.setChecked(self.default_enabled) + + def getValue(self) -> Optional[str]: + # lk: return the check state in case of non-default, otherwise None + checked = self.isChecked() + value = f"{self.option}={int(checked)}" if self.default_enabled else self.option + 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 - HIDDEN = 0 - ENABLED = 1 + GLOBAL = -1 + DISABLED = 0 + 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.envvar_name: str = None + self.ui.show_overlay_combo.addItem(self.tr("Global"), ActivationStates.GLOBAL) + 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]], - custom_map: List[Tuple[CustomOption, str]], - envvar_name: str, + grid_map: List[OverlayCheckBox], + form_map: List[Tuple[Union[OverlayLineEdit, OverlayComboBox], 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): - checkbox = QCheckBox(text) - self.ui.options_grid.addWidget(checkbox, i // 4, i % 4) - self.checkboxes[variable] = checkbox - checkbox.stateChanged.connect(self.update_settings) + for i, widget in enumerate(grid_map): + widget.setParent(self.ui.options_group) + self.ui.options_grid.addWidget(widget, i // 4, i % 4) + # self.checkboxes[widget.option] = widget + self.option_widgets.append(widget) + widget.stateChanged.connect(self.update_settings) - for option, text in custom_map: - widget = option.widget - self.ui.options_form.addRow(text, widget) - self.values[option.option] = widget + for widget, label in form_map: + widget.setParent(self.ui.options_group) + self.ui.options_form.addRow(label, 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: - # System default - 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 + current_state = self.ui.show_overlay_combo.currentData(Qt.UserRole) + self.ui.options_group.setEnabled(current_state == ActivationStates.CUSTOM) - 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) - self.environ_changed.emit(self.envvar_name) - self.ui.options_group.setDisabled(True) - self.set_activation_state(ActivationStates.HIDDEN) - return - elif self.ui.show_overlay_combo.currentIndex() == 2: + config.set_envvar(self.app_name, self.envvar, self.force_disabled) + + elif current_state == ActivationStates.DEFAULTS: + config.set_envvar(self.app_name, self.envvar, self.force_defaults) + + elif current_state == ActivationStates.CUSTOM: self.ui.options_group.setDisabled(False) # custom options - var_names = [] - for var_name, cb in self.checkboxes.items(): - if cb.isChecked(): - var_names.append(var_name) + options = [widget.getValue() for widget in self.option_widgets] - for var_name, widget in self.values.items(): - text = widget.getValue() - if text not in ["default", ""]: - var_names.append(f"{var_name}={text}") + # options = [] + # for var_name, cb in self.checkboxes.items(): + # options.append(cb.getValue()) + # + # for var_name, widget in self.values.items(): + # options.append(widget.getValue()) - if not var_names: - list(self.checkboxes.values())[0].setChecked(True) - var_names.append(list(self.checkboxes.keys())[0]) + options = [name for name in options if name is not None] - config.set_envvar(self.app_name, self.envvar_name, ",".join(var_names)) - self.environ_changed.emit(self.envvar_name) - self.set_activation_state(ActivationStates.ENABLED) + config.set_envvar(self.app_name, self.envvar, ",".join(options)) + + 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(): - checkbox.setChecked(False) - for widget in self.values.values(): - widget.setDefault() + # for checkbox in self.checkboxes.values(): + # checkbox.setChecked(False) + # for widget in self.values.values(): + # widget.setDefault() - options = config.get_envvar(self.app_name, self.envvar_name, fallback=None) - if options is None: - logger.debug(f"No Overlay settings found {self.envvar_name}") - self.ui.show_overlay_combo.setCurrentIndex(0) - self.ui.options_group.setDisabled(True) + config_options = config.get_envvar(self.app_name, self.envvar, fallback=None) + if config_options is None: + logger.debug("Overlay setting %s is not present", self.envvar) + self.setCurrentState(ActivationStates.GLOBAL) - elif options == self.force_disabled: - # not visible - self.ui.options_group.setDisabled(True) - self.ui.show_overlay_combo.setCurrentIndex(1) + elif config_options == self.force_disabled: + self.setCurrentState(ActivationStates.DISABLED) + + elif config_options == self.force_defaults: + self.setCurrentState(ActivationStates.DEFAULTS) else: - self.ui.show_overlay_combo.setCurrentIndex(2) - for option in options.split(","): - 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.setCurrentState(ActivationStates.CUSTOM) + opts = {} + for o in config_options.split(","): + if "=" in o: + k, v = o.split("=") + opts[k] = v + else: + # lk: The value doesn't matter other than not being None + opts[o] = "enable" - 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( - [ - ("fps", QCoreApplication.translate("DxvkSettings", "FPS")), - ("frametime", QCoreApplication.translate("DxvkSettings", "Frametime")), - ("memory", QCoreApplication.translate("DxvkSettings", "Memory usage")), - ("gpuload", QCoreApplication.translate("DxvkSettings", "GPU usage")), - ("devinfo", QCoreApplication.translate("DxvkSettings", "Show Device info")), - ("version", QCoreApplication.translate("DxvkSettings", "DXVK Version")), - ("api", QCoreApplication.translate("DxvkSettings", "D3D feature level")), - ("compiler", QCoreApplication.translate("DxvkSettings", "Compiler activity")), - ], - [ - ( - CustomOption.number_input("scale", 1, True), - QCoreApplication.translate("DxvkSettings", "Scale"), - ) - ], - "DXVK_HUD", - "0", - ) + grid = [ + OverlayCheckBox("fps", self.tr("FPS")), + OverlayCheckBox("frametime", self.tr("Frametime")), + OverlayCheckBox("memory", self.tr("Memory usage")), + OverlayCheckBox("gpuload", self.tr("GPU usage")), + OverlayCheckBox("devinfo", self.tr("Device info")), + OverlayCheckBox("version", self.tr("DXVK version")), + OverlayCheckBox("api", self.tr("D3D feature level")), + OverlayCheckBox("compiler", self.tr("Compiler activity")), + ] + form = [(OverlayNumberInput("scale", 1.0), self.tr("Scale"))] + self.setupWidget(grid, form, "DXVK_HUD", "0", "1") - 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( - [ - ("fps", QCoreApplication.translate("MangoSettings", "FPS")), - ("frame_timing", QCoreApplication.translate("MangoSettings", "Frame Time")), - ("cpu_stats", QCoreApplication.translate("MangoSettings", "CPU Load")), - ("gpu_stats", QCoreApplication.translate("MangoSettings", "GPU Load")), - ("cpu_temp", QCoreApplication.translate("MangoSettings", "CPU Temp")), - ("gpu_temp", QCoreApplication.translate("MangoSettings", "GPU Temp")), - ("ram", QCoreApplication.translate("MangoSettings", "Memory usage")), - ("vram", QCoreApplication.translate("MangoSettings", "VRAM usage")), - ("time", QCoreApplication.translate("MangoSettings", "Local Time")), - ("version", QCoreApplication.translate("MangoSettings", "MangoHud Version")), - ("arch", QCoreApplication.translate("MangoSettings", "System architecture")), - ("histogram", QCoreApplication.translate("MangoSettings", "FPS Graph")), - ("gpu_name", QCoreApplication.translate("MangoSettings", "GPU Name")), - ("cpu_power", QCoreApplication.translate("MangoSettings", "CPU Power consumption")), - ("gpu_power", QCoreApplication.translate("MangoSettings", "GPU Power consumption")), - ], - [ - ( - CustomOption.number_input("font_size", 24, is_float=False), - QCoreApplication.translate("MangoSettings", "Font size"), - ), - ( - CustomOption.select_input("position", mangohud_position), - QCoreApplication.translate("MangoSettings", "Position"), - ), - ], - "MANGOHUD_CONFIG", - "no_display", - ) + grid = [ + OverlayCheckBox("read_cfg", self.tr("Read config")), + OverlayCheckBox("fps", self.tr("FPS"), default_enabled=True), + OverlayCheckBox("frame_timing", self.tr("Frame time"), default_enabled=True), + OverlayCheckBox("cpu_stats", self.tr("CPU load"), default_enabled=True), + OverlayCheckBox("gpu_stats", self.tr("GPU load"), default_enabled=True), + OverlayCheckBox("cpu_temp", self.tr("CPU temperature")), + OverlayCheckBox("gpu_temp", self.tr("GPU temperature")), + OverlayCheckBox("ram", self.tr("Memory usage")), + OverlayCheckBox("vram", self.tr("VRAM usage")), + OverlayCheckBox("time", self.tr("Local time")), + OverlayCheckBox("version", self.tr("MangoHud version")), + OverlayCheckBox("arch", self.tr("System architecture")), + OverlayCheckBox("histogram", self.tr("FPS graph")), + OverlayCheckBox("gpu_name", self.tr("GPU name")), + OverlayCheckBox("cpu_power", self.tr("CPU power consumption")), + OverlayCheckBox("gpu_power", self.tr("GPU power consumption")), + ] + form = [ + (OverlayNumberInput("font_size", 24), self.tr("Font size")), + (OverlaySelectInput("position", mangohud_position), self.tr("Position")), + ] + + self.setupWidget(grid, form, "MANGOHUD_CONFIG", "no_display", "read_cfg") 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)) - mango_config = config.get_envvar(self.app_name, "MANGOHUD_CONFIG", fallback="") - if not activated: - self.ui.options_group.setDisabled(True) - for i, checkbox in enumerate(list(self.checkboxes.values())): - checkbox.setChecked(i < 4) - self.ui.show_overlay_combo.setCurrentIndex(0) - 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) + # activated = config.get_envvar(self.app_name, "MANGOHUD", None) + # mango_config = config.get_envvar(self.app_name, "MANGOHUD_CONFIG", fallback="") + # if activated is None: + # self.setCurrentState(ActivationStates.SYSTEM) + # else: + # if activated == "1": + # if not activated: + # self.ui.options_group.setDisabled(True) + # for i, checkbox in enumerate(list(self.checkboxes.values())): + # checkbox.setChecked(i < 4) + # self.ui.show_overlay_combo.setCurrentIndex(0) + # 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 - if state == ActivationStates.DEFAULT: + def update_settings_override(self, state: IntEnum): # pylint: disable=E0202 + 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: - mango_config = config.get_envvar(self.app_name, "MANGOHUD_CONFIG", fallback="") + elif state == ActivationStates.CUSTOM: + config.set_envvar(self.app_name, "MANGOHUD", "1") + # mango_config = config.get_envvar(self.app_name, self.envvar, fallback="") + # mango_config = f"read_cfg,{mango_config}" if mango_config else "read_cfg" + # config.set_envvar(self.app_name, self.envvar, mango_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) + # 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") - # 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) diff --git a/rare/ui/components/tabs/settings/widgets/overlay.py b/rare/ui/components/tabs/settings/widgets/overlay.py index 075320a4..661d8fd8 100644 --- a/rare/ui/components/tabs/settings/widgets/overlay.py +++ b/rare/ui/components/tabs/settings/widgets/overlay.py @@ -15,7 +15,7 @@ class Ui_OverlaySettings(object): def setupUi(self, OverlaySettings): OverlaySettings.setObjectName("OverlaySettings") OverlaySettings.resize(555, 188) - OverlaySettings.setWindowTitle("Overlay Settings") + OverlaySettings.setWindowTitle("OverlaySettings") OverlaySettings.setTitle("") self.main_layout = QtWidgets.QGridLayout(OverlaySettings) self.main_layout.setObjectName("main_layout") @@ -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__": diff --git a/rare/ui/components/tabs/settings/widgets/overlay.ui b/rare/ui/components/tabs/settings/widgets/overlay.ui index b8ba286a..44b2c7dc 100644 --- a/rare/ui/components/tabs/settings/widgets/overlay.ui +++ b/rare/ui/components/tabs/settings/widgets/overlay.ui @@ -11,10 +11,10 @@ - Overlay Settings + OverlaySettings - + @@ -38,27 +38,12 @@ 0 - - - System Default - - - - - Hidden - - - - - Visible - - - +