import humanize import socket from datetime import datetime from PyQt6 import QtCore from PyQt6.QtCore import Qt, QSettings from PyQt6.QtGui import QIcon from PyQt6.QtWidgets import QApplication, QMainWindow, QListWidget, QListWidgetItem, QStackedWidget, QVBoxLayout, \ QWidget, QLabel, QCheckBox, QLineEdit, \ QComboBox, QPushButton, QHBoxLayout, QGroupBox, QTableWidget, QAbstractItemView, QTableWidgetItem, QHeaderView from api.server_proxy import RenderServerProxy from engines.engine_manager import EngineManager from utilities.misc_helper import launch_url from version import APP_AUTHOR, APP_NAME settings = QSettings(APP_AUTHOR, APP_NAME) class SettingsWindow(QMainWindow): def __init__(self): super().__init__() # declare objects we need to store settings self.check_for_engine_updates_checkbox = None # todo: add all here self.installed_engines_table = None self.setWindowTitle("Settings") # Create the main layout main_layout = QVBoxLayout() # Create the sidebar (QListWidget) for navigation self.sidebar = QListWidget() self.sidebar.setFixedWidth(150) # Set the icon size self.sidebar.setIconSize(QtCore.QSize(32, 32)) # Increase the icon size to 32x32 pixels # Adjust the font size for the sidebar items font = self.sidebar.font() font.setPointSize(12) # Increase the font size self.sidebar.setFont(font) # Add items with icons to the sidebar self.add_sidebar_item("General", "../../resources/Gear.png") self.add_sidebar_item("Network", "../../resources/Server.png") self.add_sidebar_item("Engines", "../../resources/Blender.png") self.sidebar.setCurrentRow(0) # Create the stacked widget to hold different settings pages self.stacked_widget = QStackedWidget() # Create pages for each section general_page = self.create_general_page() network_page = self.create_network_page() engines_page = self.create_engines_page() # Add pages to the stacked widget self.stacked_widget.addWidget(general_page) self.stacked_widget.addWidget(network_page) self.stacked_widget.addWidget(engines_page) # Connect the sidebar to the stacked widget self.sidebar.currentRowChanged.connect(self.stacked_widget.setCurrentIndex) # Create a horizontal layout to hold the sidebar and stacked widget content_layout = QHBoxLayout() content_layout.addWidget(self.sidebar) content_layout.addWidget(self.stacked_widget) # Add the content layout to the main layout main_layout.addLayout(content_layout) # Add the "OK" button at the bottom ok_button = QPushButton("OK") ok_button.clicked.connect(self.close) ok_button.setFixedWidth(80) ok_button.setDefault(True) main_layout.addWidget(ok_button, alignment=Qt.AlignmentFlag.AlignRight) # Create a central widget and set the layout central_widget = QWidget() central_widget.setLayout(main_layout) self.setCentralWidget(central_widget) self.setMinimumSize(700, 400) def add_sidebar_item(self, name, icon_path): """Add an item with an icon to the sidebar.""" item = QListWidgetItem(QIcon(icon_path), name) self.sidebar.addItem(item) def create_general_page(self): """Create the General settings page.""" page = QWidget() layout = QVBoxLayout() # Startup Settings Group startup_group = QGroupBox("Startup Settings") startup_layout = QVBoxLayout() # startup_layout.addWidget(QCheckBox("Start application on system startup")) check_for_updates_checkbox = QCheckBox("Check for updates automatically") check_for_updates_checkbox.setChecked(settings.value("auto_check_for_updates", True)) check_for_updates_checkbox.stateChanged.connect(lambda state: settings.setValue("auto_check_for_updates", bool(state))) startup_layout.addWidget(check_for_updates_checkbox) startup_group.setLayout(startup_layout) # Render Settings Group render_settings_group = QGroupBox("Render Settings") render_settings_layout = QVBoxLayout() render_settings_layout.addWidget(QLabel("Require same:")) require_same_engine_checkbox = QCheckBox("Renderer Version") require_same_engine_checkbox.setChecked(settings.value("render_require_same_engine_version")) require_same_engine_checkbox.stateChanged.connect(lambda state: settings.setValue("render_require_same_engine_version", bool(state))) render_settings_layout.addWidget(require_same_engine_checkbox) require_same_cpu_checkbox = QCheckBox("CPU Architecture") require_same_cpu_checkbox.setChecked(settings.value("render_require_same_cpu_type")) require_same_cpu_checkbox.stateChanged.connect(lambda state: settings.setValue("render_require_same_cpu_type", bool(state))) render_settings_layout.addWidget(require_same_cpu_checkbox) require_same_os_checkbox = QCheckBox("Operating System") require_same_os_checkbox.setChecked(settings.value("render_require_same_os")) require_same_os_checkbox.stateChanged.connect(lambda state: settings.setValue("render_require_same_os", bool(state))) render_settings_layout.addWidget(require_same_os_checkbox) render_settings_group.setLayout(render_settings_layout) layout.addWidget(startup_group) layout.addWidget(render_settings_group) layout.addStretch() # Add a stretch to push content to the top page.setLayout(layout) return page def create_network_page(self): """Create the Network settings page.""" page = QWidget() layout = QVBoxLayout() # Proxy Settings Group proxy_group = QGroupBox("Proxy Settings") proxy_layout = QVBoxLayout() proxy_layout.addWidget(QCheckBox("Use Proxy")) proxy_layout.addWidget(QLabel("Proxy Address")) proxy_layout.addWidget(QLineEdit()) proxy_layout.addWidget(QLabel("Proxy Port")) proxy_layout.addWidget(QLineEdit()) proxy_group.setLayout(proxy_layout) layout.addWidget(proxy_group) layout.addStretch() # Add a stretch to push content to the top page.setLayout(layout) return page def create_engines_page(self): """Create the Engines settings page.""" page = QWidget() layout = QVBoxLayout() # Installed Engines Group installed_group = QGroupBox("Installed Engines") installed_layout = QVBoxLayout() self.installed_engines_table = EngineTableWidget() installed_layout.addWidget(self.installed_engines_table) installed_buttons_layout = QHBoxLayout() launch_engine_button = QPushButton("Launch") launch_engine_button.clicked.connect(self.launch_selected_engine) delete_engine_button = QPushButton("Delete") delete_engine_button.clicked.connect(self.delete_selected_engine) installed_buttons_layout.addWidget(launch_engine_button) installed_buttons_layout.addWidget(delete_engine_button) installed_layout.addLayout(installed_buttons_layout) installed_group.setLayout(installed_layout) # Engine Updates Group engine_updates_group = QGroupBox("Auto-Install") engine_updates_layout = QVBoxLayout() engine_download_layout = QHBoxLayout() engine_download_layout.addWidget(QLabel("Enable Downloads for:")) at_least_one_downloadable = False for engine in EngineManager.downloadable_engines(): engine_download_check = QCheckBox(engine.name()) is_checked = settings.value(f"engine_download-{engine.name()}", False) at_least_one_downloadable |= is_checked engine_download_check.setChecked(is_checked) # Capture the checkbox correctly using a default argument in lambda engine_download_check.clicked.connect( lambda state, checkbox=engine_download_check: self.engine_download_settings_changed(state, checkbox.text()) ) engine_download_layout.addWidget(engine_download_check) engine_updates_layout.addLayout(engine_download_layout) self.check_for_engine_updates_checkbox = QCheckBox("Check for new versions on launch") self.check_for_engine_updates_checkbox.setChecked(settings.value('check_for_engine_updates_on_launch', True)) self.check_for_engine_updates_checkbox.setEnabled(at_least_one_downloadable) self.check_for_engine_updates_checkbox.stateChanged.connect( lambda state: settings.setValue("check_for_engine_updates_on_launch", bool(state))) engine_updates_layout.addWidget(self.check_for_engine_updates_checkbox) self.engines_last_update_label = QLabel() self.update_last_checked_label() self.engines_last_update_label.setEnabled(at_least_one_downloadable) engine_updates_layout.addWidget(self.engines_last_update_label) self.check_for_new_engines_button = QPushButton("Check for New Versions") self.check_for_new_engines_button.setEnabled(at_least_one_downloadable) self.check_for_new_engines_button.clicked.connect(self.check_for_new_engines) engine_updates_layout.addWidget(self.check_for_new_engines_button) engine_updates_group.setLayout(engine_updates_layout) layout.addWidget(installed_group) layout.addWidget(engine_updates_group) layout.addStretch() # Add a stretch to push content to the top page.setLayout(layout) return page def update_last_checked_label(self): """Retrieve the last check timestamp and return a human-friendly string.""" last_checked_str = settings.value("engines_last_update_time", None) if not last_checked_str: time_string = "Never" else: last_checked_dt = datetime.fromisoformat(last_checked_str) now = datetime.now() time_string = humanize.naturaltime(now - last_checked_dt) self.engines_last_update_label.setText(f"Last Updated: {time_string}") def engine_download_settings_changed(self, state, engine_name): settings.setValue(f"engine_download-{engine_name}", state) at_least_one_downloadable = False for engine in EngineManager.downloadable_engines(): at_least_one_downloadable |= settings.value(f"engine_download-{engine.name()}", False) self.check_for_new_engines_button.setEnabled(at_least_one_downloadable) self.check_for_engine_updates_checkbox.setEnabled(at_least_one_downloadable) self.engines_last_update_label.setEnabled(at_least_one_downloadable) def delete_selected_engine(self): pass def launch_selected_engine(self): engine_info = self.installed_engines_table.selected_engine_data() if engine_info: launch_url(engine_info['path']) def check_for_new_engines(self): settings.setValue("engines_last_update_time", datetime.now().isoformat()) self.update_last_checked_label() class EngineTableWidget(QWidget): def __init__(self): super().__init__() self.table = QTableWidget(0, 4) self.table.setHorizontalHeaderLabels(["Engine", "Version", "Type", "Path"]) self.table.setSelectionBehavior(QAbstractItemView.SelectionBehavior.SelectRows) self.table.verticalHeader().setVisible(False) # self.table_widget.itemSelectionChanged.connect(self.engine_picked) self.table.setEditTriggers(QAbstractItemView.EditTrigger.NoEditTriggers) layout = QVBoxLayout(self) layout.addWidget(self.table) def showEvent(self, event): """Runs when the widget is about to be shown.""" self.update_table() super().showEvent(event) # Ensure normal event processing def update_table(self): raw_server_data = RenderServerProxy(socket.gethostname()).get_renderer_info() if not raw_server_data: return table_data = [] # convert the data into a flat list for _, engine_data in raw_server_data.items(): table_data.extend(engine_data['versions']) self.table.clear() self.table.setRowCount(len(table_data)) self.table.setColumnCount(4) self.table.setHorizontalHeaderLabels(['Engine', 'Version', 'Type', 'Path']) self.table.horizontalHeader().setSectionResizeMode(0, QHeaderView.ResizeMode.Fixed) self.table.horizontalHeader().setSectionResizeMode(1, QHeaderView.ResizeMode.Fixed) self.table.horizontalHeader().setSectionResizeMode(2, QHeaderView.ResizeMode.Fixed) self.table.horizontalHeader().setSectionResizeMode(3, QHeaderView.ResizeMode.Stretch) for row, engine in enumerate(table_data): self.table.setItem(row, 0, QTableWidgetItem(engine['engine'])) self.table.setItem(row, 1, QTableWidgetItem(engine['version'])) self.table.setItem(row, 2, QTableWidgetItem(engine['type'])) self.table.setItem(row, 3, QTableWidgetItem(engine['path'])) self.table.selectRow(0) def selected_engine_data(self): """Returns the data from the selected row as a dictionary.""" row = self.table.currentRow() # Get the selected row index if row < 0: # No row selected return None data = { "engine": self.table.item(row, 0).text(), "version": self.table.item(row, 1).text(), "type": self.table.item(row, 2).text(), "path": self.table.item(row, 3).text(), } return data if __name__ == "__main__": app = QApplication([]) window = SettingsWindow() window.show() app.exec()