490 lines
20 KiB
Python
490 lines
20 KiB
Python
from logging import getLogger
|
|
from typing import Tuple, Dict, Union, List, Set
|
|
|
|
from PyQt5.QtCore import QSettings, Qt, pyqtSlot
|
|
from PyQt5.QtWidgets import QStackedWidget, QVBoxLayout, QWidget, QScrollArea, QFrame
|
|
from legendary.models.game import InstalledGame, Game
|
|
|
|
from rare.shared import (
|
|
LegendaryCoreSingleton,
|
|
GlobalSignalsSingleton,
|
|
ArgumentsSingleton,
|
|
ApiResultsSingleton,
|
|
ImageManagerSingleton,
|
|
)
|
|
from rare.widgets.library_layout import LibraryLayout
|
|
from rare.widgets.sliding_stack import SlidingStackedWidget
|
|
from .cloud_save_utils import CloudSaveUtils
|
|
from .game_info import GameInfoTabs
|
|
from .game_info.uninstalled_info import UninstalledInfoTabs
|
|
from .game_utils import GameUtils
|
|
from .game_widgets.base_installed_widget import BaseInstalledWidget
|
|
from .game_widgets.base_uninstalled_widget import BaseUninstalledWidget
|
|
from .game_widgets.installed_icon_widget import InstalledIconWidget
|
|
from .game_widgets.installed_list_widget import InstalledListWidget
|
|
from .game_widgets.installing_game_widget import InstallingGameWidget
|
|
from .game_widgets.uninstalled_icon_widget import UninstalledIconWidget
|
|
from .game_widgets.uninstalled_list_widget import UninstalledListWidget
|
|
from .head_bar import GameListHeadBar
|
|
from .integrations import IntegrationsTabs
|
|
|
|
logger = getLogger("GamesTab")
|
|
|
|
|
|
class GamesTab(QStackedWidget):
|
|
def __init__(self, parent=None):
|
|
super(GamesTab, self).__init__(parent=parent)
|
|
self.core = LegendaryCoreSingleton()
|
|
self.signals = GlobalSignalsSingleton()
|
|
self.args = ArgumentsSingleton()
|
|
self.api_results = ApiResultsSingleton()
|
|
self.image_manager = ImageManagerSingleton()
|
|
self.settings = QSettings()
|
|
|
|
self.widgets: Dict[str, Tuple[
|
|
Union[InstalledIconWidget, UninstalledIconWidget], Union[InstalledListWidget, UninstalledListWidget]]] = {}
|
|
self.updates: Set = set()
|
|
self.active_filter: int = 0
|
|
self.uninstalled_games: List[Game] = []
|
|
|
|
self.game_list: List[Game] = self.api_results.game_list
|
|
self.dlcs = self.api_results.dlcs
|
|
self.bit32 = self.api_results.bit32_games
|
|
self.mac_games = self.api_results.mac_games
|
|
self.no_assets = self.api_results.no_asset_games
|
|
|
|
self.game_utils = GameUtils(parent=self)
|
|
|
|
self.games = QWidget(parent=self)
|
|
self.games.setLayout(QVBoxLayout())
|
|
self.addWidget(self.games)
|
|
|
|
self.head_bar = GameListHeadBar(parent=self.games)
|
|
self.head_bar.goto_import.connect(self.show_import)
|
|
self.head_bar.goto_egl_sync.connect(self.show_egl_sync)
|
|
self.head_bar.goto_eos_ubisoft.connect(self.show_eos_ubisoft)
|
|
self.games.layout().addWidget(self.head_bar)
|
|
|
|
self.game_info_tabs = GameInfoTabs(self.dlcs, self.game_utils, self)
|
|
self.game_info_tabs.back_clicked.connect(lambda: self.setCurrentWidget(self.games))
|
|
self.addWidget(self.game_info_tabs)
|
|
|
|
self.game_info_tabs.info.verification_finished.connect(
|
|
self.verification_finished
|
|
)
|
|
self.game_info_tabs.info.uninstalled.connect(lambda x: self.setCurrentWidget(self.games))
|
|
|
|
self.integrations_tabs = IntegrationsTabs(self)
|
|
self.integrations_tabs.back_clicked.connect(lambda: self.setCurrentWidget(self.games))
|
|
self.addWidget(self.integrations_tabs)
|
|
|
|
for i in self.game_list:
|
|
if i.app_name.startswith("UE_4"):
|
|
pixmap = self.image_manager.get_pixmap(i.app_name)
|
|
if pixmap.isNull():
|
|
continue
|
|
self.ue_name = i.app_name
|
|
logger.debug(f"Found Unreal AppName {self.ue_name}")
|
|
break
|
|
else:
|
|
logger.warning("No Unreal engine in library found")
|
|
self.ue_name = ""
|
|
|
|
self.uninstalled_info_tabs = UninstalledInfoTabs(self)
|
|
self.uninstalled_info_tabs.back_clicked.connect(lambda: self.setCurrentWidget(self.games))
|
|
self.addWidget(self.uninstalled_info_tabs)
|
|
|
|
self.no_asset_names = []
|
|
if not self.args.offline:
|
|
for game in self.no_assets:
|
|
self.no_asset_names.append(game.app_name)
|
|
else:
|
|
self.no_assets = []
|
|
|
|
self.installed = self.core.get_installed_list()
|
|
|
|
self.view_stack = SlidingStackedWidget(self.games)
|
|
self.view_stack.setFrameStyle(QFrame.NoFrame)
|
|
self.icon_view_scroll = QScrollArea(self.view_stack)
|
|
self.icon_view_scroll.setWidgetResizable(True)
|
|
self.icon_view_scroll.setFrameShape(QFrame.StyledPanel)
|
|
self.icon_view_scroll.horizontalScrollBar().setDisabled(True)
|
|
self.list_view_scroll = QScrollArea(self.view_stack)
|
|
self.list_view_scroll.setWidgetResizable(True)
|
|
self.list_view_scroll.setFrameShape(QFrame.StyledPanel)
|
|
self.list_view_scroll.horizontalScrollBar().setDisabled(True)
|
|
self.icon_view = QWidget(self.icon_view_scroll)
|
|
self.icon_view.setLayout(LibraryLayout(self.icon_view))
|
|
self.icon_view.layout().setContentsMargins(0, 13, 0, 0)
|
|
self.icon_view.layout().setAlignment(Qt.AlignTop)
|
|
self.list_view = QWidget(self.list_view_scroll)
|
|
self.list_view.setLayout(QVBoxLayout(self.list_view))
|
|
self.list_view.layout().setContentsMargins(3, 3, 9, 3)
|
|
self.list_view.layout().setAlignment(Qt.AlignTop)
|
|
self.icon_view_scroll.setWidget(self.icon_view)
|
|
self.list_view_scroll.setWidget(self.list_view)
|
|
self.view_stack.addWidget(self.icon_view_scroll)
|
|
self.view_stack.addWidget(self.list_view_scroll)
|
|
self.games.layout().addWidget(self.view_stack)
|
|
|
|
# add installing game widget for icon view: List view not supported
|
|
self.installing_widget = InstallingGameWidget()
|
|
self.icon_view.layout().addWidget(self.installing_widget)
|
|
self.installing_widget.setVisible(False)
|
|
|
|
if not self.settings.value("icon_view", True, bool):
|
|
self.view_stack.setCurrentWidget(self.list_view_scroll)
|
|
self.head_bar.view.list()
|
|
else:
|
|
self.view_stack.setCurrentWidget(self.icon_view_scroll)
|
|
|
|
self.head_bar.search_bar.textChanged.connect(lambda x: self.filter_games("", x))
|
|
self.head_bar.search_bar.textChanged.connect(
|
|
lambda x: self.icon_view_scroll.verticalScrollBar().setSliderPosition(
|
|
self.icon_view_scroll.verticalScrollBar().minimum()
|
|
)
|
|
)
|
|
self.head_bar.search_bar.textChanged.connect(
|
|
lambda x: self.list_view_scroll.verticalScrollBar().setSliderPosition(
|
|
self.list_view_scroll.verticalScrollBar().minimum()
|
|
)
|
|
)
|
|
self.head_bar.filterChanged.connect(self.filter_games)
|
|
self.head_bar.refresh_list.clicked.connect(self.update_list)
|
|
self.head_bar.view.toggled.connect(self.toggle_view)
|
|
|
|
f = self.settings.value("filter", 0, int)
|
|
if f >= len(self.head_bar.available_filters):
|
|
f = 0
|
|
self.active_filter = self.head_bar.available_filters[f]
|
|
|
|
# signals
|
|
self.signals.dl_progress.connect(self.installing_widget.set_status)
|
|
self.signals.installation_started.connect(self.installation_started)
|
|
self.signals.update_gamelist.connect(self.update_list)
|
|
self.signals.installation_finished.connect(
|
|
self.installation_finished
|
|
)
|
|
self.signals.game_uninstalled.connect(lambda name: self.update_list([name]))
|
|
|
|
self.game_utils.update_list.connect(self.update_list)
|
|
|
|
self.setup_game_list()
|
|
|
|
def installation_finished(self, app_name: str):
|
|
self.installing_widget.setVisible(False)
|
|
self.installing_widget.set_game("")
|
|
self.filter_games("")
|
|
|
|
def installation_started(self, app_name: str):
|
|
self.installing_widget.set_game(app_name)
|
|
|
|
i_widget, l_widget = self.widgets.get(app_name, (None, None))
|
|
if not i_widget or not l_widget:
|
|
return
|
|
i_widget.setVisible(False)
|
|
l_widget.setVisible(False)
|
|
|
|
def verification_finished(self, igame: InstalledGame):
|
|
# only if igame needs verification
|
|
i_widget, l_widget = self.widgets[igame.app_name]
|
|
i_widget.igame = igame
|
|
l_widget.igame = igame
|
|
|
|
i_widget.leaveEvent(None)
|
|
l_widget.update_text()
|
|
|
|
@pyqtSlot()
|
|
def show_import(self):
|
|
self.setCurrentWidget(self.integrations_tabs)
|
|
self.integrations_tabs.show_import()
|
|
|
|
@pyqtSlot()
|
|
def show_egl_sync(self):
|
|
self.setCurrentWidget(self.integrations_tabs)
|
|
self.integrations_tabs.show_egl_sync()
|
|
|
|
@pyqtSlot()
|
|
def show_eos_ubisoft(self):
|
|
self.setCurrentWidget(self.integrations_tabs)
|
|
self.integrations_tabs.show_eos_ubisoft()
|
|
|
|
def show_game_info(self, app_name):
|
|
self.game_info_tabs.update_game(app_name)
|
|
self.setCurrentWidget(self.game_info_tabs)
|
|
|
|
def show_uninstalled_info(self, game):
|
|
self.uninstalled_info_tabs.update_game(game)
|
|
self.setCurrentWidget(self.uninstalled_info_tabs)
|
|
|
|
@pyqtSlot()
|
|
def update_count_games_label(self):
|
|
self.head_bar.set_games_count(len(self.core.get_installed_list()), len(self.game_list))
|
|
|
|
def setup_game_list(self):
|
|
self.update_count_games_label()
|
|
|
|
# add installed games
|
|
for igame in sorted(self.core.get_installed_list(), key=lambda x: x.title):
|
|
icon_widget, list_widget = self.add_installed_widget(igame.app_name)
|
|
self.icon_view.layout().addWidget(icon_widget)
|
|
self.list_view.layout().addWidget(list_widget)
|
|
|
|
for game in self.no_assets:
|
|
if not game.metadata.get("customAttributes", {}).get("ThirdPartyManagedApp", {}).get("value") == "Origin":
|
|
icon_widget, list_widget = self.add_uninstalled_widget(game)
|
|
else:
|
|
icon_widget, list_widget = self.add_installed_widget(game.app_name)
|
|
if not icon_widget or not list_widget:
|
|
logger.warning(f"Ignoring {game.app_name} in game list")
|
|
continue
|
|
self.icon_view.layout().addWidget(icon_widget)
|
|
self.list_view.layout().addWidget(list_widget)
|
|
|
|
for game in sorted(self.game_list, key=lambda x: x.app_title):
|
|
if not self.core.is_installed(game.app_name):
|
|
self.uninstalled_games.append(game)
|
|
icon_widget, list_widget = self.add_uninstalled_widget(game)
|
|
self.icon_view.layout().addWidget(icon_widget)
|
|
self.list_view.layout().addWidget(list_widget)
|
|
self.filter_games(self.active_filter)
|
|
|
|
def add_installed_widget(self, app_name):
|
|
pixmap = self.image_manager.get_pixmap(app_name)
|
|
try:
|
|
if pixmap.isNull():
|
|
logger.info(f"{app_name} has a corrupt image.")
|
|
if app_name in self.no_asset_names and self.core.get_asset(app_name).namespace != "ue":
|
|
self.image_manager.download_image_blocking(self.core.get_game(app_name), force=True)
|
|
pixmap = self.image_manager.get_pixmap(app_name)
|
|
elif self.ue_name:
|
|
pixmap = self.image_manager.get_pixmap(self.ue_name)
|
|
|
|
icon_widget = InstalledIconWidget(app_name, pixmap, self.game_utils)
|
|
list_widget = InstalledListWidget(app_name, pixmap, self.game_utils)
|
|
except Exception as e:
|
|
logger.error(f"{app_name} is broken. Don't add it to game list: {e}")
|
|
return None, None
|
|
|
|
self.widgets[app_name] = (icon_widget, list_widget)
|
|
|
|
icon_widget.show_info.connect(self.show_game_info)
|
|
list_widget.show_info.connect(self.show_game_info)
|
|
|
|
if icon_widget.update_available:
|
|
self.updates.add(app_name)
|
|
return icon_widget, list_widget
|
|
|
|
def add_uninstalled_widget(self, game):
|
|
pixmap = self.image_manager.get_pixmap(game.app_name, color=False)
|
|
try:
|
|
if pixmap.isNull():
|
|
if self.core.get_asset(game.app_name).namespace != "ue":
|
|
logger.warning(f"{game.app_title} has a corrupt image. Reloading...")
|
|
self.image_manager.download_image_blocking(game, force=True)
|
|
pixmap = self.image_manager.get_pixmap(game.app_name, color=False)
|
|
elif self.ue_name:
|
|
pixmap = self.image_manager.get_pixmap(self.ue_name, color=False)
|
|
|
|
icon_widget = UninstalledIconWidget(game, self.core, pixmap)
|
|
list_widget = UninstalledListWidget(self.core, game, pixmap)
|
|
except Exception as e:
|
|
logger.error(f"{game.app_name} is broken. Don't add it to game list: {e}")
|
|
return None, None
|
|
|
|
icon_widget.show_uninstalled_info.connect(self.show_uninstalled_info)
|
|
list_widget.show_uninstalled_info.connect(self.show_uninstalled_info)
|
|
|
|
self.widgets[game.app_name] = (icon_widget, list_widget)
|
|
|
|
return icon_widget, list_widget
|
|
|
|
def filter_games(self, filter_name="all", search_text: str = ""):
|
|
if not search_text and (t := self.head_bar.search_bar.text()):
|
|
search_text = t
|
|
|
|
if filter_name:
|
|
self.active_filter = filter_name
|
|
if not filter_name and (t := self.active_filter):
|
|
filter_name = t
|
|
|
|
def get_visibility(widget) -> Tuple[bool, float]:
|
|
app_name = widget.game.app_name
|
|
|
|
if not isinstance(widget,
|
|
InstallingGameWidget) and self.installing_widget.game and self.installing_widget.game.app_name == app_name:
|
|
visible = False
|
|
elif filter_name == "installed":
|
|
visible = self.core.is_installed(app_name)
|
|
elif filter_name == "offline":
|
|
if self.core.is_installed(app_name) and not isinstance(widget, InstallingGameWidget):
|
|
visible = widget.igame.can_run_offline
|
|
else:
|
|
visible = False
|
|
elif filter_name == "32bit" and self.bit32:
|
|
visible = app_name in self.bit32
|
|
elif filter_name == "mac" and self.mac_games:
|
|
visible = app_name in self.mac_games
|
|
elif filter_name == "installable":
|
|
visible = app_name not in self.no_asset_names
|
|
elif filter_name == "include_ue":
|
|
visible = True
|
|
elif filter_name == "all":
|
|
# All visible except ue
|
|
try:
|
|
visible = self.core.get_asset(app_name, update=False).namespace != "ue"
|
|
except ValueError:
|
|
visible = True
|
|
else:
|
|
visible = True
|
|
|
|
if (
|
|
search_text.lower() not in widget.game.app_name.lower()
|
|
and search_text.lower() not in widget.game.app_title.lower()
|
|
):
|
|
opacity = 0.25
|
|
else:
|
|
opacity = 1.0
|
|
return visible, opacity
|
|
|
|
for t in self.widgets.values():
|
|
visible, opacity = get_visibility(t[0])
|
|
for w in t:
|
|
w.setVisible(visible)
|
|
w.image.setOpacity(opacity)
|
|
|
|
self.sort_list(search_text)
|
|
|
|
if self.installing_widget.game:
|
|
self.installing_widget.setVisible(get_visibility(self.installing_widget)[0])
|
|
|
|
@pyqtSlot()
|
|
def sort_list(self, sort_by: str = ""):
|
|
# lk: this is the existing sorting implemenation
|
|
# lk: it sorts by installed then by title
|
|
installing_widget = self.icon_view.layout().remove(type(self.installing_widget).__name__)
|
|
if sort_by:
|
|
self.icon_view.layout().sort(lambda x: (sort_by.lower() not in x.widget().game.app_title.lower(),))
|
|
else:
|
|
self.icon_view.layout().sort(
|
|
lambda x: (
|
|
not x.widget().is_installed,
|
|
x.widget().is_non_asset,
|
|
x.widget().app_title,
|
|
)
|
|
)
|
|
self.icon_view.layout().insert(0, installing_widget)
|
|
list_widgets = self.list_view.findChildren(InstalledListWidget) + self.list_view.findChildren(
|
|
UninstalledListWidget)
|
|
if sort_by:
|
|
list_widgets.sort(key=lambda x: (sort_by not in x.game.app_title.lower(),))
|
|
else:
|
|
list_widgets.sort(
|
|
key=lambda x: (not x.is_installed, x.is_non_asset, x.app_title)
|
|
)
|
|
for idx, wl in enumerate(list_widgets):
|
|
self.list_view.layout().insertWidget(idx, wl)
|
|
|
|
def __remove_from_layout(self, app_name):
|
|
self.icon_view.layout().removeWidget(self.widgets[app_name][0])
|
|
self.list_view.layout().removeWidget(self.widgets[app_name][1])
|
|
self.widgets[app_name][0].deleteLater()
|
|
self.widgets[app_name][1].deleteLater()
|
|
self.widgets.pop(app_name)
|
|
|
|
def __update_installed(self, app_name):
|
|
self.__remove_from_layout(app_name)
|
|
icon_widget, list_widget = self.add_installed_widget(app_name)
|
|
self.icon_view.layout().addWidget(icon_widget)
|
|
self.list_view.layout().addWidget(list_widget)
|
|
|
|
def __update_uninstalled(self, app_name):
|
|
self.__remove_from_layout(app_name)
|
|
game = self.core.get_game(app_name, False)
|
|
try:
|
|
icon_widget, list_widget = self.add_uninstalled_widget(game)
|
|
self.icon_view.layout().addWidget(icon_widget)
|
|
self.list_view.layout().addWidget(list_widget)
|
|
except Exception:
|
|
pass
|
|
|
|
def update_list(self, app_names: list = None):
|
|
logger.debug(f"Updating list for {app_names}")
|
|
if app_names:
|
|
update_list = False
|
|
for app_name in app_names:
|
|
if widgets := self.widgets.get(app_name):
|
|
|
|
# from update
|
|
if self.core.is_installed(widgets[0].game.app_name) and isinstance(
|
|
widgets[0], BaseInstalledWidget
|
|
):
|
|
logger.debug(f"Update Gamelist: Updated: {app_name}")
|
|
igame = self.core.get_installed_game(app_name)
|
|
for w in widgets:
|
|
w.igame = igame
|
|
w.update_available = (
|
|
self.core.get_asset(
|
|
w.game.app_name, w.igame.platform, False
|
|
).build_version
|
|
!= igame.version
|
|
)
|
|
widgets[0].leaveEvent(None)
|
|
# new installed
|
|
elif self.core.is_installed(app_name) and isinstance(
|
|
widgets[0], BaseUninstalledWidget
|
|
):
|
|
logger.debug(f"Update Gamelist: New installed {app_name}")
|
|
self.__update_installed(app_name)
|
|
update_list = True
|
|
|
|
# uninstalled
|
|
elif not self.core.is_installed(
|
|
widgets[0].game.app_name
|
|
) and isinstance(widgets[0], BaseInstalledWidget):
|
|
logger.debug(f"Update list: Uninstalled: {app_name}")
|
|
self.__update_uninstalled(app_name)
|
|
update_list = True
|
|
|
|
# do not update, if only update finished
|
|
if update_list:
|
|
self.sort_list()
|
|
|
|
else:
|
|
installed_names = [i.app_name for i in self.core.get_installed_list()]
|
|
# get Uninstalled games
|
|
uninstalled_names = []
|
|
games = self.core.get_game_list(True)
|
|
for game in sorted(games, key=lambda x: x.app_title):
|
|
if not game.app_name in installed_names:
|
|
uninstalled_names.append(game.app_name)
|
|
|
|
new_installed_games = list(
|
|
set(installed_names) - set([i.app_name for i in self.installed])
|
|
)
|
|
new_uninstalled_games = list(
|
|
set(uninstalled_names)
|
|
- set([i.app_name for i in self.uninstalled_games])
|
|
)
|
|
|
|
if (not new_uninstalled_games) and (not new_installed_games):
|
|
return
|
|
|
|
if new_installed_games:
|
|
for name in new_installed_games:
|
|
self.__update_installed(name)
|
|
|
|
for name in new_uninstalled_games:
|
|
self.__update_uninstalled(name)
|
|
|
|
self.sort_list()
|
|
self.update_count_games_label()
|
|
|
|
def toggle_view(self):
|
|
self.settings.setValue("icon_view", not self.head_bar.view.isChecked())
|
|
|
|
if not self.head_bar.view.isChecked():
|
|
self.view_stack.slideInWidget(self.icon_view_scroll)
|
|
else:
|
|
self.view_stack.slideInWidget(self.list_view_scroll)
|