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
-
-
-
-
+
-