Update main_window.py

Author: michal92299

main_window.py

@@ -9,19 +9,31 @@
 from game_manager import GameManager
 from config_manager import ConfigManager
 
+class CancelledError(Exception):
+    pass
+
 class InstallThread(QThread):
     update_progress = Signal(str, int, int)
     finished = Signal(bool, str)
+
     def __init__(self, manager, version, proton_type, custom_path=None, custom_type=None):
         super().__init__()
         self.manager = manager
         self.version = version
         self.proton_type = proton_type
         self.custom_path = custom_path
         self.custom_type = custom_type
+        self._is_canceled = False
+
+    def cancel(self):
+        self._is_canceled = True
+
     def run(self):
         def progress_callback(stage, value, total):
             self.update_progress.emit(stage, value, total)
+            if self._is_canceled:
+                raise CancelledError("Installation cancelled")
+
         try:
             if self.proton_type in ['GE', 'Official', 'Experimental']:
                 success, message = self.manager.install_proton(self.version, self.proton_type if self.proton_type != 'Experimental' else 'Official', progress_callback)
@@ -31,14 +43,18 @@ def progress_callback(stage, value, total):
                 else:
                     success, message = self.manager.install_custom_folder(self.custom_path, self.version)
             self.finished.emit(success, message)
+        except CancelledError as e:
+            self.finished.emit(False, str(e))
         except Exception as e:
             self.finished.emit(False, str(e))
 
 class LoadProtonsThread(QThread):
     protons_loaded = Signal(list)
+
     def __init__(self, manager):
         super().__init__()
         self.manager = manager
+
     def run(self):
         try:
             protons = self.manager.get_installed_protons()
@@ -346,6 +362,13 @@ def add_game(self):
         app_id_widget.setVisible(runner_combo.currentText() == 'Steam')
         dlg_layout.addWidget(app_id_widget, row, 0, 1, 3)
         row += 1
+        fps_label = QLabel('FPS Limit:')
+        fps_edit = QLineEdit()
+        fps_edit.setPlaceholderText("Enter FPS limit (e.g., 60)")
+        dlg_layout.addWidget(fps_label, row, 0)
+        dlg_layout.addWidget(fps_edit, row, 1, 1, 2)
+        row += 1
+
         def update_visibility(text):
             proton_widget.setVisible(text == 'Proton')
             prefix_widget.setVisible(text in ['Wine', 'Proton'])
@@ -355,6 +378,7 @@ def update_visibility(text):
             esync_check.setVisible(text in ['Wine', 'Proton'])
             fsync_check.setVisible(text in ['Wine', 'Proton'])
             dxvk_async_check.setVisible(text in ['Wine', 'Proton'])
+
         runner_combo.currentTextChanged.connect(update_visibility)
         button_layout = QHBoxLayout()
         ok_btn = QPushButton(QIcon.fromTheme("dialog-ok"), 'Add Game')
@@ -378,6 +402,7 @@ def update_visibility(text):
             enable_dxvk_async = dxvk_async_check.isChecked()
             app_id = app_id_edit.text() if runner == 'Steam' else ''
             prefix = prefix_edit.text() if runner in ['Wine', 'Proton'] else ''
+            fps_limit = fps_edit.text()
             if runner == 'Proton':
                 runner = proton_combo.currentText()
             if not name or (runner != 'Steam' and not exe) or (runner == 'Steam' and not app_id):
@@ -399,7 +424,8 @@ def update_visibility(text):
                 'enable_esync': enable_esync,
                 'enable_fsync': enable_fsync,
                 'enable_dxvk_async': enable_dxvk_async,
-                'app_id': app_id
+                'app_id': app_id,
+                'fps_limit': fps_limit
             }
             self.game_manager.add_game(game)
             self.load_games()
@@ -414,6 +440,12 @@ def launch_game(self):
         game = next((g for g in self.games if g['name'] == name), None)
         if game:
             try:
+                # Dodaj fps limit do launch_options jeśli gamescope jest używany
+                launch_options = game.get('launch_options', '').split()
+                fps_limit = game.get('fps_limit', '')
+                if fps_limit and '--gamescope' in launch_options:
+                    launch_options.append(f'--framerate-limit={fps_limit}')
+                game['launch_options'] = ' '.join(launch_options)
                 self.game_manager.launch_game(game, '--gamescope' in game.get('launch_options', ''))
             except Exception as e:
                 logging.error(f"Error launching {name}: {e}")
@@ -436,23 +468,107 @@ def configure_game(self):
             return
         name = self.games_list.item(selected, 0).text()
         game = next((g for g in self.games if g['name'] == name), None)
-        if not game or game['runner'] in ['Native', 'Flatpak', 'Steam']:
-            QMessageBox.information(self, 'Info', 'No configuration needed for this runner')
+        if not game:
             return
-        if not shutil.which('winetricks'):
-            QMessageBox.warning(self, 'Error', 'Winetricks not installed. Please install it.')
-            return
-        tricks_dialog = QDialog(self)
-        tricks_dialog.setWindowTitle("Install Winetricks Libraries")
-        tricks_layout = QVBoxLayout()
+        config_dialog = QDialog(self)
+        config_dialog.setWindowTitle("Configure Game")
+        dlg_layout = QGridLayout()
+        row = 0
+        # Podstawowe pola
+        name_label = QLabel('Game Name:')
+        name_edit = QLineEdit(game['name'])
+        dlg_layout.addWidget(name_label, row, 0)
+        dlg_layout.addWidget(name_edit, row, 1, 1, 2)
+        row += 1
+        exe_label = QLabel('Executable / App ID:')
+        exe_edit = QLineEdit(game['exe'])
+        browse_btn = QPushButton(QIcon.fromTheme("folder"), 'Browse')
+        browse_btn.clicked.connect(lambda: exe_edit.setText(QFileDialog.getOpenFileName(self, 'Select Executable', '/', 'Executables (*.exe *.bat);;All Files (*)')[0]))
+        dlg_layout.addWidget(exe_label, row, 0)
+        dlg_layout.addWidget(exe_edit, row, 1)
+        dlg_layout.addWidget(browse_btn, row, 2)
+        row += 1
+        runner_label = QLabel('Runner:')
+        runner_combo = QComboBox()
+        runner_combo.addItems(['Native', 'Wine', 'Proton', 'Flatpak', 'Steam'])
+        runner_combo.setCurrentText('Proton' if 'Proton' in game['runner'] else game['runner'])
+        dlg_layout.addWidget(runner_label, row, 0)
+        dlg_layout.addWidget(runner_combo, row, 1, 1, 2)
+        row += 1
+        proton_label = QLabel('Proton Version:')
+        proton_combo = QComboBox()
+        proton_combo.addItems([p['version'] for p in self.proton_manager.get_installed_protons()])
+        proton_combo.setCurrentText(game['runner'] if 'Proton' in game['runner'] else '')
+        proton_widget = QWidget()
+        proton_layout = QHBoxLayout()
+        proton_layout.addWidget(proton_label)
+        proton_layout.addWidget(proton_combo)
+        proton_widget.setLayout(proton_layout)
+        proton_widget.setVisible(runner_combo.currentText() == 'Proton')
+        dlg_layout.addWidget(proton_widget, row, 0, 1, 3)
+        row += 1
+        prefix_label = QLabel('Wine/Proton Prefix:')
+        prefix_edit = QLineEdit(game['prefix'])
+        prefix_browse_btn = QPushButton(QIcon.fromTheme("folder"), 'Browse')
+        prefix_browse_btn.clicked.connect(lambda: prefix_edit.setText(QFileDialog.getExistingDirectory(self, 'Select Prefix Directory')))
+        prefix_widget = QWidget()
+        prefix_layout = QHBoxLayout()
+        prefix_layout.addWidget(prefix_label)
+        prefix_layout.addWidget(prefix_edit)
+        prefix_layout.addWidget(prefix_browse_btn)
+        prefix_widget.setLayout(prefix_layout)
+        prefix_widget.setVisible(runner_combo.currentText() in ['Wine', 'Proton'])
+        dlg_layout.addWidget(prefix_widget, row, 0, 1, 3)
+        row += 1
+        launch_label = QLabel('Launch Options:')
+        launch_edit = QLineEdit(game.get('launch_options', ''))
+        dlg_layout.addWidget(launch_label, row, 0)
+        dlg_layout.addWidget(launch_edit, row, 1, 1, 2)
+        row += 1
+        dxvk_check = QCheckBox("Enable DXVK/VKD3D")
+        dxvk_check.setChecked(game.get('enable_dxvk', False))
+        dxvk_check.setVisible(runner_combo.currentText() in ['Wine', 'Proton'])
+        dlg_layout.addWidget(dxvk_check, row, 0)
+        row += 1
+        esync_check = QCheckBox("Enable Esync (Override)")
+        esync_check.setChecked(game.get('enable_esync', False))
+        esync_check.setVisible(runner_combo.currentText() in ['Wine', 'Proton'])
+        dlg_layout.addWidget(esync_check, row, 0)
+        row += 1
+        fsync_check = QCheckBox("Enable Fsync (Override)")
+        fsync_check.setChecked(game.get('enable_fsync', False))
+        fsync_check.setVisible(runner_combo.currentText() in ['Wine', 'Proton'])
+        dlg_layout.addWidget(fsync_check, row, 0)
+        row += 1
+        dxvk_async_check = QCheckBox("Enable DXVK Async (Override)")
+        dxvk_async_check.setChecked(game.get('enable_dxvk_async', False))
+        dxvk_async_check.setVisible(runner_combo.currentText() in ['Wine', 'Proton'])
+        dlg_layout.addWidget(dxvk_async_check, row, 0)
+        row += 1
+        app_id_widget = QWidget()
+        app_id_layout = QHBoxLayout()
+        app_id_label = QLabel('Steam App ID:')
+        app_id_edit = QLineEdit(game.get('app_id', ''))
+        app_id_layout.addWidget(app_id_label)
+        app_id_layout.addWidget(app_id_edit)
+        app_id_widget.setLayout(app_id_layout)
+        app_id_widget.setVisible(runner_combo.currentText() == 'Steam')
+        dlg_layout.addWidget(app_id_widget, row, 0, 1, 3)
+        row += 1
+        fps_label = QLabel('FPS Limit:')
+        fps_edit = QLineEdit(game.get('fps_limit', ''))
+        dlg_layout.addWidget(fps_label, row, 0)
+        dlg_layout.addWidget(fps_edit, row, 1, 1, 2)
+        row += 1
+        # Sekcja winetricks
         tricks_label = QLabel("Select libraries to install:")
         tricks_list = QComboBox()
         popular_tricks = ['dotnet48', 'vcrun2019', 'dxvk', 'vkd3d', 'corefonts', 'd3dcompiler_47', 'physx', 'msls31']
         tricks_list.addItems(popular_tricks)
         install_btn = QPushButton('Install Selected')
         def install_trick():
             trick = tricks_list.currentText()
-            prefix = game['prefix']
+            prefix = prefix_edit.text()
             env = os.environ.copy()
             env['WINEPREFIX'] = prefix
             try:
@@ -461,14 +577,80 @@ def install_trick():
             except Exception as e:
                 QMessageBox.warning(self, 'Error', str(e))
         install_btn.clicked.connect(install_trick)
-        tricks_layout.addWidget(tricks_label)
-        tricks_layout.addWidget(tricks_list)
-        tricks_layout.addWidget(install_btn)
-        tricks_dialog.setLayout(tricks_layout)
-        tricks_dialog.exec()
-        env = os.environ.copy()
-        env['WINEPREFIX'] = game['prefix']
-        subprocess.Popen(['winetricks'], env=env)
+        dlg_layout.addWidget(tricks_label, row, 0)
+        dlg_layout.addWidget(tricks_list, row, 1)
+        dlg_layout.addWidget(install_btn, row, 2)
+        row += 1
+        winetricks_btn = QPushButton('Open Winetricks')
+        def open_winetricks():
+            prefix = prefix_edit.text()
+            env = os.environ.copy()
+            env['WINEPREFIX'] = prefix
+            subprocess.Popen(['winetricks'], env=env)
+        winetricks_btn.clicked.connect(open_winetricks)
+        dlg_layout.addWidget(winetricks_btn, row, 0, 1, 3)
+        row += 1
+
+        def update_visibility(text):
+            proton_widget.setVisible(text == 'Proton')
+            prefix_widget.setVisible(text in ['Wine', 'Proton'])
+            app_id_widget.setVisible(text == 'Steam')
+            browse_btn.setVisible(text != 'Steam')
+            dxvk_check.setVisible(text in ['Wine', 'Proton'])
+            esync_check.setVisible(text in ['Wine', 'Proton'])
+            fsync_check.setVisible(text in ['Wine', 'Proton'])
+            dxvk_async_check.setVisible(text in ['Wine', 'Proton'])
+
+        runner_combo.currentTextChanged.connect(update_visibility)
+        button_layout = QHBoxLayout()
+        ok_btn = QPushButton(QIcon.fromTheme("dialog-ok"), 'Save Changes')
+        cancel_btn = QPushButton(QIcon.fromTheme("dialog-cancel"), 'Cancel')
+        ok_btn.clicked.connect(config_dialog.accept)
+        cancel_btn.clicked.connect(config_dialog.reject)
+        button_layout.addStretch()
+        button_layout.addWidget(ok_btn)
+        button_layout.addWidget(cancel_btn)
+        dlg_layout.addLayout(button_layout, row, 0, 1, 3)
+        config_dialog.setLayout(dlg_layout)
+        config_dialog.resize(600, 600)
+        if config_dialog.exec() == QDialog.Accepted:
+            new_name = name_edit.text()
+            exe = exe_edit.text()
+            runner = runner_combo.currentText()
+            launch_options = launch_edit.text()
+            enable_dxvk = dxvk_check.isChecked()
+            enable_esync = esync_check.isChecked()
+            enable_fsync = fsync_check.isChecked()
+            enable_dxvk_async = dxvk_async_check.isChecked()
+            app_id = app_id_edit.text() if runner == 'Steam' else ''
+            prefix = prefix_edit.text() if runner in ['Wine', 'Proton'] else ''
+            fps_limit = fps_edit.text()
+            if runner == 'Proton':
+                runner = proton_combo.currentText()
+            if not new_name or (runner != 'Steam' and not exe) or (runner == 'Steam' and not app_id):
+                QMessageBox.warning(self, 'Error', 'Name and Executable/App ID required')
+                return
+            if runner in ['Wine', 'Proton'] and not prefix:
+                prefix = os.path.join(self.config_manager.prefixes_dir, new_name.replace(' ', '_'))
+            if prefix:
+                os.makedirs(prefix, exist_ok=True)
+            if os.name == 'posix' and ':' in exe:
+                exe = exe.replace('\\', '/').replace('C:', '/drive_c')
+            # Aktualizuj game
+            game['name'] = new_name
+            game['exe'] = exe
+            game['runner'] = runner
+            game['prefix'] = prefix
+            game['launch_options'] = launch_options
+            game['enable_dxvk'] = enable_dxvk
+            game['enable_esync'] = enable_esync
+            game['enable_fsync'] = enable_fsync
+            game['enable_dxvk_async'] = enable_dxvk_async
+            game['app_id'] = app_id
+            game['fps_limit'] = fps_limit
+            self.config_manager.save_games(self.games)
+            self.load_games()
+            QMessageBox.information(self, 'Success', 'Game configured successfully!')
 
     def install_proton(self):
         install_dialog = QDialog(self)
@@ -510,6 +692,7 @@ def install_proton(self):
         custom_widget.setLayout(custom_layout)
         custom_widget.setVisible(False)
         layout.addWidget(custom_widget)
+
         def update_ui(text):
             if text == 'Custom':
                 version_widget.setVisible(False)
@@ -525,8 +708,10 @@ def update_ui(text):
                     available = self.proton_manager.get_available_official(stable=False)
                 version_combo.clear()
                 version_combo.addItems(available or ["No versions available"])
+
         type_combo.currentTextChanged.connect(update_ui)
         update_ui(type_combo.currentText())
+
         def browse_custom():
             if custom_type_combo.currentText() == 'Tar.gz File':
                 path = QFileDialog.getOpenFileName(self, 'Select Tar.gz', '', 'Tar.gz (*.tar.gz)')[0]
@@ -536,6 +721,7 @@ def browse_custom():
                 path_edit.setText(path)
                 if not name_edit.text():
                     name_edit.setText(os.path.basename(path).replace('.tar.gz', ''))
+
         browse_btn.clicked.connect(browse_custom)
         button_layout = QHBoxLayout()
         ok_btn = QPushButton(QIcon.fromTheme("dialog-ok"), 'Install')
@@ -552,7 +738,7 @@ def browse_custom():
             proton_type = type_combo.currentText()
             progress = QProgressDialog(f"Installing {proton_type} Proton...", "Cancel", 0, 100, self)
             progress.setWindowModality(Qt.WindowModal)
-            progress.setAutoClose(True)
+            progress.setAutoClose(False)  # Zmiana na False, aby ręcznie zamykać
             version = version_combo.currentText() if proton_type != 'Custom' else name_edit.text()
             custom_path = path_edit.text() if proton_type == 'Custom' else None
             custom_type = custom_type_combo.currentText() if proton_type == 'Custom' else None
@@ -563,14 +749,15 @@ def browse_custom():
             thread.update_progress.connect(lambda stage, value, total: progress.setLabelText(stage) or progress.setValue(int(value * 100 / total) if total else 0))
             thread.finished.connect(lambda success, message: self.install_finished(success, message, version, progress))
             thread.start()
-            progress.canceled.connect(thread.terminate)
+            progress.canceled.connect(thread.cancel)
 
     def install_finished(self, success, message, version, progress):
         progress.setValue(100)
         if success:
             QMessageBox.information(self, 'Success', f'Proton {version} installed')
         else:
             QMessageBox.warning(self, 'Error', f'Failed to install Proton {version}: {message}')
+        progress.close()
         self.start_proton_loading()
 
     def update_proton(self):
@@ -590,12 +777,12 @@ def update_proton(self):
             return
         progress = QProgressDialog(f"Updating {proton_type} Proton to {new_version}...", "Cancel", 0, 100, self)
         progress.setWindowModality(Qt.WindowModal)
-        progress.setAutoClose(True)
+        progress.setAutoClose(False)
         thread = InstallThread(self.proton_manager, new_version, new_type)
         thread.update_progress.connect(lambda stage, value, total: progress.setLabelText(stage) or progress.setValue(int(value * 100 / total) if total else 0))
         thread.finished.connect(lambda success, message: self.update_finished(success, message, new_version, version, progress))
         thread.start()
-        progress.canceled.connect(thread.terminate)
+        progress.canceled.connect(thread.cancel)
 
     def update_finished(self, success, message, new_version, old_version, progress):
         progress.setValue(100)
@@ -604,6 +791,7 @@ def update_finished(self, success, message, new_version, old_version, progress):
             QMessageBox.information(self, 'Success', f'Updated to {new_version}')
         else:
             QMessageBox.warning(self, 'Error', f'Failed to update to {new_version}: {message}')
+        progress.close()
         self.start_proton_loading()
 
     def remove_proton(self):