feat: optimize add and remove game

Signed-off-by: Boris Yumankulov <boria138@altlinux.org>

portprotonqt/game_library_manager.py

@@ -6,6 +6,7 @@ from portprotonqt.custom_widgets import FlowLayout
 from portprotonqt.config_utils import read_favorites, read_sort_method, read_card_size, save_card_size
 from portprotonqt.image_utils import load_pixmap_async
 from portprotonqt.context_menu_manager import ContextMenuManager, CustomLineEdit
+from collections import deque
 
 class MainWindowProtocol(Protocol):
     """Protocol defining the interface that MainWindow must implement for GameLibraryManager."""
@@ -48,6 +49,10 @@ class GameLibraryManager:
         self.gamesListWidget: QWidget | None = None
         self.gamesListLayout: FlowLayout | None = None
         self.sizeSlider: QSlider | None = None
+        self._update_timer: QTimer | None = None
+        self._pending_update = False
+        self.pending_deletions = deque()  # Queue for deferred widget deletion
+        self.dirty = False  # Flag for when full resort is needed
 
     def create_games_library_widget(self):
         """Creates the games library widget with search, grid, and slider."""
@@ -91,6 +96,12 @@ class GameLibraryManager:
 
         layout.addLayout(sliderLayout)
 
+        # Initialize update timer
+        self._update_timer = QTimer()
+        self._update_timer.setSingleShot(True)
+        self._update_timer.setInterval(100)  # 100ms debounce
+        self._update_timer.timeout.connect(self._perform_update)
+
         # Calculate initial card width
         def calculate_card_width():
             if self.gamesListLayout is None:
@@ -183,56 +194,161 @@ class GameLibraryManager:
             if self.main_window.current_hovered_card == card:
                 self.main_window.current_hovered_card = None
 
+    def _perform_update(self):
+        """Performs the actual grid update."""
+        if not self._pending_update:
+            return
+        self._pending_update = False
+        self._update_game_grid_immediate()
+
     def update_game_grid(self, games_list: list[tuple] | None = None):
+        """Schedules a game grid update with debouncing."""
+        if games_list is not None:
+            self.filtered_games = games_list
+        self._pending_update = True
+
+        if self._update_timer is not None:
+            self._update_timer.start()
+        else:
+            self._update_game_grid_immediate()
+
+    def _update_game_grid_immediate(self):
         """Updates the game grid with the provided or current game list."""
         if self.gamesListLayout is None or self.gamesListWidget is None:
             return
-        games_list = games_list if games_list is not None else self.games
+
+        games_list = self.filtered_games if self.filtered_games else self.games
         search_text = self.main_window.searchEdit.text().strip().lower()
         favorites = read_favorites()
         sort_method = read_sort_method()
 
-        def sort_key(game):
-            name = game[0]
-            fav_order = 0 if name in favorites else 1
-            if sort_method == "playtime":
-                return (fav_order, -game[11], -game[10])
-            elif sort_method == "alphabetical":
-                return (fav_order, name.lower())
-            elif sort_method == "favorites":
-                return (fav_order,)
+        # Batch layout updates (extended scope)
+        self.gamesListWidget.setUpdatesEnabled(False)
+        if self.gamesListLayout is not None:
+            self.gamesListLayout.setEnabled(False)  # Disable layout during batch
+
+        try:
+            # Optimized sorting: Partition favorites first, then sort subgroups
+            def partition_sort_key(game):
+                name = game[0]
+                is_fav = name in favorites
+                fav_order = 0 if is_fav else 1
+                if sort_method == "playtime":
+                    return (fav_order, -game[11] if game[11] else 0, -game[10] if game[10] else 0)
+                elif sort_method == "alphabetical":
+                    return (fav_order, name.lower())
+                elif sort_method == "favorites":
+                    return (fav_order,)
+                else:
+                    return (fav_order, -game[10] if game[10] else 0, -game[11] if game[11] else 0)
+
+            # Quick partition: Sort favorites and non-favorites separately, then merge
+            fav_games = [g for g in games_list if g[0] in favorites]
+            non_fav_games = [g for g in games_list if g[0] not in favorites]
+            sorted_fav = sorted(fav_games, key=partition_sort_key)
+            sorted_non_fav = sorted(non_fav_games, key=partition_sort_key)
+            sorted_games = sorted_fav + sorted_non_fav
+
+            # Build set of current game keys for faster lookup
+            current_game_keys = {(game[0], game[4]) for game in sorted_games}
+
+            # Remove cards that no longer exist (batch)
+            cards_to_remove = []
+            for card_key in list(self.game_card_cache.keys()):
+                if card_key not in current_game_keys:
+                    cards_to_remove.append(card_key)
+
+            for card_key in cards_to_remove:
+                card = self.game_card_cache.pop(card_key)
+                if self.gamesListLayout is not None:
+                    self.gamesListLayout.removeWidget(card)
+                self.pending_deletions.append(card)  # Defer
+                if card_key in self.pending_images:
+                    del self.pending_images[card_key]
+
+            # Track current layout order (only if dirty/full update needed)
+            if self.dirty and self.gamesListLayout is not None:
+                current_layout_order = []
+                for i in range(self.gamesListLayout.count()):
+                    item = self.gamesListLayout.itemAt(i)
+                    if item is not None:
+                        widget = item.widget()
+                        if widget:
+                            for key, card in self.game_card_cache.items():
+                                if card == widget:
+                                    current_layout_order.append(key)
+                                    break
             else:
-                return (fav_order, -game[10], -game[11])
+                current_layout_order = None  # Skip reorg if not dirty
 
-        sorted_games = sorted(games_list, key=sort_key)
-        new_card_order = []
+            new_card_order = []
+            cards_to_add = []
 
-        for game_data in sorted_games:
-            game_name = game_data[0]
-            exec_line = game_data[4]
-            game_key = (game_name, exec_line)
-            should_be_visible = not search_text or search_text in game_name.lower()
+            for game_data in sorted_games:
+                game_name = game_data[0]
+                exec_line = game_data[4]
+                game_key = (game_name, exec_line)
+                should_be_visible = not search_text or search_text in game_name.lower()
 
-            if game_key in self.game_card_cache:
-                card = self.game_card_cache[game_key]
-                card.setVisible(should_be_visible)
-                new_card_order.append((game_key, card))
-                continue
+                if game_key in self.game_card_cache:
+                    card = self.game_card_cache[game_key]
+                    if card.isVisible() != should_be_visible:
+                        card.setVisible(should_be_visible)
+                    new_card_order.append(game_key)
+                else:
+                    if self.context_menu_manager is None:
+                        continue
 
-            if self.context_menu_manager is None:
-                continue  # Skip card creation if context_menu_manager is None
+                    card = self._create_game_card(game_data)
+                    self.game_card_cache[game_key] = card
+                    card.setVisible(should_be_visible)
+                    new_card_order.append(game_key)
+                    cards_to_add.append((game_key, card))
 
-            card = GameCard(
-                *game_data,
-                select_callback=self.main_window.openGameDetailPage,
-                theme=self.theme,
-                card_width=self.card_width,
-                context_menu_manager=self.context_menu_manager
-            )
+            # Only reorganize if order changed AND dirty
+            if self.dirty and self.gamesListLayout is not None and (current_layout_order is None or new_card_order != current_layout_order):
+                # Remove all widgets from layout (batch)
+                while self.gamesListLayout.count():
+                    self.gamesListLayout.takeAt(0)
 
-            card.hoverChanged.connect(self._on_card_hovered)
-            card.focusChanged.connect(self._on_card_focused)
+                # Add widgets in new order (batch)
+                for game_key in new_card_order:
+                    card = self.game_card_cache[game_key]
+                    self.gamesListLayout.addWidget(card)
 
+            self.dirty = False  # Reset flag
+
+            # Deferred deletions (run in timer to avoid stack overflow)
+            if self.pending_deletions:
+                QTimer.singleShot(0, lambda: self._flush_deletions())
+
+            # Load visible images for new cards only
+            if cards_to_add:
+                self.load_visible_images()
+
+        finally:
+            if self.gamesListLayout is not None:
+                self.gamesListLayout.setEnabled(True)
+            self.gamesListWidget.setUpdatesEnabled(True)
+            if self.gamesListLayout is not None:
+                self.gamesListLayout.update()
+            self.gamesListWidget.updateGeometry()
+            self.main_window._last_card_width = self.card_width
+
+    def _create_game_card(self, game_data: tuple) -> GameCard:
+        """Creates a new game card with all necessary connections."""
+        card = GameCard(
+            *game_data,
+            select_callback=self.main_window.openGameDetailPage,
+            theme=self.theme,
+            card_width=self.card_width,
+            context_menu_manager=self.context_menu_manager
+        )
+
+        card.hoverChanged.connect(self._on_card_hovered)
+        card.focusChanged.connect(self._on_card_focused)
+
+        if self.context_menu_manager:
             card.editShortcutRequested.connect(self.context_menu_manager.edit_game_shortcut)
             card.deleteGameRequested.connect(self.context_menu_manager.delete_game)
             card.addToMenuRequested.connect(self.context_menu_manager.add_to_menu)
@@ -243,33 +359,13 @@ class GameLibraryManager:
             card.removeFromSteamRequested.connect(self.context_menu_manager.remove_from_steam)
             card.openGameFolderRequested.connect(self.context_menu_manager.open_game_folder)
 
-            self.game_card_cache[game_key] = card
-            new_card_order.append((game_key, card))
-            card.setVisible(should_be_visible)
+        return card
 
-        while self.gamesListLayout.count():
-            child = self.gamesListLayout.takeAt(0)
-            if child.widget():
-                child.widget().setParent(None)
-
-        for _game_key, card in new_card_order:
-            self.gamesListLayout.addWidget(card)
-            if card.isVisible():
-                self.load_visible_images()
-
-        existing_keys = {game_key for game_key, card in new_card_order}
-        for card_key in list(self.game_card_cache.keys()):
-            if card_key not in existing_keys:
-                card = self.game_card_cache.pop(card_key)
-                card.deleteLater()
-                if card_key in self.pending_images:
-                    del self.pending_images[card_key]
-
-        self.gamesListLayout.update()
-        self.gamesListWidget.updateGeometry()
-        self.gamesListWidget.update()
-
-        self.main_window._last_card_width = self.card_width
+    def _flush_deletions(self):
+        """Delete pending widgets off the main update cycle."""
+        for card in list(self.pending_deletions):
+            card.deleteLater()
+            self.pending_deletions.remove(card)
 
     def clear_layout(self, layout):
         """Clears all widgets from the layout."""
@@ -290,6 +386,28 @@ class GameLibraryManager:
         """Sets the games list and updates the filtered games."""
         self.games = games
         self.filtered_games = self.games
+        self.dirty = True  # Full resort needed
+        self.update_game_grid()
+
+    def add_game_incremental(self, game_data: tuple):
+        """Add a single game without full reload."""
+        self.games.append(game_data)
+        self.filtered_games.append(game_data)  # Assume no filter active; adjust if needed
+        self.dirty = True
+        self.update_game_grid()
+
+    def remove_game_incremental(self, game_name: str, exec_line: str):
+        """Remove a single game without full reload."""
+        key = (game_name, exec_line)
+        self.games = [g for g in self.games if (g[0], g[4]) != key]
+        self.filtered_games = [g for g in self.filtered_games if (g[0], g[4]) != key]
+        if key in self.game_card_cache and self.gamesListLayout is not None:
+            card = self.game_card_cache.pop(key)
+            self.gamesListLayout.removeWidget(card)
+            self.pending_deletions.append(card)  # Defer deleteLater
+            if key in self.pending_images:
+                del self.pending_images[key]
+        self.dirty = True
         self.update_game_grid()
 
     def filter_games_delayed(self):