def load_description(self):
description = ""
lang = Config.get("lang")
if self.gamesdb_info["summary"]:
desc_lang = "*"
for summary_key in self.gamesdb_info["summary"].keys():
if lang in summary_key:
desc_lang = summary_key
description_len = 470
if len(self.gamesdb_info["summary"][desc_lang]) > description_len:
description = "{}...".format(
self.gamesdb_info["summary"][desc_lang][:description_len])
else:
description = self.gamesdb_info["summary"][desc_lang]
if "*" in self.gamesdb_info["genre"]:
genre = self.gamesdb_info["genre"]["*"]
else:
genre = _("unknown")
for genre_key, genre_value in self.gamesdb_info["genre"].items():
if lang in genre_key:
genre = genre_value
description = "{}: {}\n{}".format(_("Genre"), genre, description)
if self.game.is_installed():
description = "{}: {}\n{}".format(_("Version"),
self.game.get_info("version"),
description)
GLib.idle_add(self.label_game_description.set_text, description)
def __download_update(self) -> None:
finish_func = self.__update
cancel_to_state = self.state.UPDATABLE
result, download_info = self.get_download_info(self.game.platform)
if result:
result = self.__download(download_info, finish_func, cancel_to_state)
if not result:
GLib.idle_add(self.update_to_state, cancel_to_state)
def __download_game(self) -> None:
finish_func = self.__install_game
cancel_to_state = self.state.DOWNLOADABLE
result, download_info = self.get_download_info()
if result:
result = self.__download(download_info, finish_func, cancel_to_state)
if not result:
GLib.idle_add(self.update_to_state, cancel_to_state)
def __check_for_update_dlc(self):
if self.game.is_installed() and self.game.id and not self.offline:
game_info = self.api.get_info(self.game)
game_version = self.api.get_version(self.game, gameinfo=game_info)
update_available = self.game.is_update_available(game_version)
if update_available:
GLib.idle_add(self.update_to_state, self.state.UPDATABLE)
self.__check_for_dlc(game_info)
if self.offline:
GLib.idle_add(self.menu_button_dlc.hide)
def get_async_image_dlc_icon(self, dlc_id, image, icon, title):
dlc_icon_path = os.path.join(ICON_DIR, "{}.jpg".format(dlc_id))
if icon:
if os.path.isfile(dlc_icon_path):
GLib.idle_add(image.set_from_file, dlc_icon_path)
else:
url = "http:{}".format(icon)
dlc_icon = os.path.join(ICON_DIR, "{}.jpg".format(dlc_id))
download = Download(url, dlc_icon)
DownloadManager.download_now(download)
GLib.idle_add(image.set_from_file, dlc_icon_path)
def __check_for_dlc(self, game_info):
dlcs = game_info["expanded_dlcs"]
for dlc in dlcs:
if dlc["is_installable"] and dlc["id"] in self.parent.owned_products_ids:
d_installer = dlc["downloads"]["installers"]
d_icon = dlc["images"]["sidebarIcon"]
d_name = dlc["title"]
GLib.idle_add(self.update_gtk_box_for_dlc, d_icon, d_name, d_installer)
if dlc not in self.game.dlcs:
self.game.dlcs.append(dlc)
if self.game.dlcs:
GLib.idle_add(self.menu_button_dlc.show)
def get_download_info(self, platform="linux"):
try:
download_info = self.api.get_download_info(self.game, platform)
result = True
except NoDownloadLinkFound as e:
print(e)
if Config.get("current_download") == self.game.id:
Config.unset("current_download")
GLib.idle_add(self.parent.parent.show_error, _("Download error"),
_("There was an error when trying to fetch the download link!\n{}".format(e)))
download_info = False
result = False
return result, download_info
def __download_dlc(self, dlc_installers) -> None:
def finish_func(save_location):
self.__install_dlc(save_location, dlc_title=dlc_title)
download_info = self.api.get_download_info(self.game, dlc_installers=dlc_installers)
dlc_title = self.game.name
for dlc in self.game.dlcs:
if dlc["downloads"]["installers"] == dlc_installers:
dlc_title = dlc["title"]
cancel_to_state = self.state.INSTALLED
result = self.__download(download_info, finish_func, cancel_to_state)
if not result:
GLib.idle_add(self.update_to_state, cancel_to_state)
def __install(self, save_location, update=False, dlc_title=""):
if update:
processing_state = self.state.UPDATING
failed_state = self.state.INSTALLED
else:
processing_state = self.state.INSTALLING
failed_state = self.state.DOWNLOADABLE
success_state = self.state.INSTALLED
GLib.idle_add(self.update_to_state, processing_state)
err_msg = install_game(self.game, save_location)
if not err_msg:
GLib.idle_add(self.update_to_state, success_state)
install_success = True
if dlc_title:
self.game.set_dlc_info(
"version",
self.api.get_version(self.game, dlc_name=dlc_title),
dlc_title)
else:
self.game.set_info("version", self.api.get_version(self.game))
else:
GLib.idle_add(self.parent.parent.show_error,
_("Failed to install {}").format(self.game.name),
err_msg)
GLib.idle_add(self.update_to_state, failed_state)
install_success = False
return install_success
def __set_image(self, save_location):
set_result = False
self.game.set_install_dir()
thumbnail_install_dir = os.path.join(self.game.install_dir, "thumbnail.jpg")
if os.path.isfile(thumbnail_install_dir):
GLib.idle_add(self.image.set_from_file, thumbnail_install_dir)
set_result = True
elif save_location and os.path.isfile(save_location):
GLib.idle_add(self.image.set_from_file, save_location)
# Copy image to
if os.path.isdir(os.path.dirname(thumbnail_install_dir)):
shutil.copy2(save_location, thumbnail_install_dir)
set_result = True
return set_result
def load_thumbnail(self):
if self.gamesdb_info["cover"]:
response = urllib.request.urlopen(self.gamesdb_info["cover"])
input_stream = Gio.MemoryInputStream.new_from_data(
response.read(), None)
pixbuf = GdkPixbuf.Pixbuf.new_from_stream(input_stream, None)
pixbuf = pixbuf.scale_simple(340, 480,
GdkPixbuf.InterpType.BILINEAR)
GLib.idle_add(self.image.set_from_pixbuf, pixbuf)
else:
thumbnail_path = os.path.join(THUMBNAIL_DIR,
"{}.jpg".format(self.game.id))
if not os.path.isfile(thumbnail_path) and self.game.is_installed:
thumbnail_path = os.path.join(self.game.install_dir,
"thumbnail.jpg")
GLib.idle_add(self.image.set_from_file, thumbnail_path)
def __add_games_from_api(self):
retrieved_games, err_msg = self.api.get_library()
if not err_msg:
self.offline = False
else:
self.offline = True
GLib.idle_add(self.parent.show_error,
_("Failed to retrieve library"), _(err_msg))
for game in retrieved_games:
if game not in self.games:
self.games.append(game)
elif self.games[self.games.index(game)].id == 0 or self.games[
self.games.index(game)].name != game.name:
self.games[self.games.index(game)].id = game.id
self.games[self.games.index(game)].name = game.name
self.games[self.games.index(game)].image_url = game.image_url
self.games[self.games.index(game)].url = game.url
def __update_library(self):
GLib.idle_add(self.__load_tile_states)
self.owned_products_ids = self.api.get_owned_products_ids()
# Get already installed games first
self.games = self.__get_installed_games()
GLib.idle_add(self.__create_gametiles)
# Get games from the API
self.__add_games_from_api()
GLib.idle_add(self.__create_gametiles)
GLib.idle_add(self.filter_library)
def set_progress(self, percentage: int):
if self.current_state in [self.state.QUEUED, self.state.INSTALLED]:
GLib.idle_add(self.update_to_state, self.state.DOWNLOADING)
self.__create_progress_bar()
if self.progress_bar:
GLib.idle_add(self.progress_bar.set_fraction, percentage / 100)
GLib.idle_add(self.progress_bar.set_tooltip_text, "{}%".format(percentage))
def __download(self, download_info, finish_func, cancel_to_state):
download_success = True
GLib.idle_add(self.update_to_state, self.state.QUEUED)
Config.set("current_download", self.game.id)
# Start the download for all files
self.download_list = []
number_of_files = len(download_info['files'])
total_file_size = 0
executable_path = None
download_files = []
for key, file_info in enumerate(download_info['files']):
try:
download_url = self.api.get_real_download_link(
file_info["downlink"])
except ValueError as e:
print(e)
GLib.idle_add(self.parent.parent.show_error,
_("Download error"), _(str(e)))
download_success = False
break
total_file_size += self.api.get_file_size(file_info["downlink"])
try:
# Extract the filename from the download url (filename is between %2F and &token)
filename = urllib.parse.unquote(
re.search('%2F(((?!%2F).)*)&t', download_url).group(1))
except AttributeError:
filename = "{}-{}.bin".format(self.game.get_stripped_name(),
key)
download_path = os.path.join(self.download_dir, filename)
if key == 0:
# If key = 0, denote the file as the executable's path
executable_path = download_path
md5sum = self.api.get_download_file_md5(file_info["downlink"])
if md5sum:
self.game.md5sum[os.path.basename(download_path)] = md5sum
download = Download(
url=download_url,
save_location=download_path,
finish_func=finish_func
if download_path == executable_path else None,
progress_func=self.set_progress,
cancel_func=lambda: self.__cancel(to_state=cancel_to_state),
number=number_of_files - key,
out_of_amount=number_of_files,
game=self.game)
download_files.insert(0, download)
self.download_list.extend(download_files)
if check_diskspace(total_file_size, Config.get("install_dir")):
DownloadManager.download(download_files)
ds_msg_title = ""
ds_msg_text = ""
else:
ds_msg_title = "Download error"
ds_msg_text = "Not enough disk space to install game."
download_success = False
if ds_msg_title:
GLib.idle_add(self.parent.parent.show_error, _(ds_msg_title),
_(ds_msg_text))
return download_success
def __uninstall_game(self):
GLib.idle_add(self.update_to_state, self.state.UNINSTALLING)
uninstall_game(self.game)
GLib.idle_add(self.update_to_state, self.state.DOWNLOADABLE)
GLib.idle_add(self.reload_state)
def __install_dlc(self, save_location, dlc_title):
install_success = self.__install(save_location, dlc_title=dlc_title)
if not install_success:
GLib.idle_add(self.update_to_state, self.state.INSTALLED)
self.__check_for_update_dlc()
def __cancel(self, to_state):
self.download_list = []
GLib.idle_add(self.update_to_state, to_state)
GLib.idle_add(self.reload_state)
def __cancel(self, to_state):
GLib.idle_add(self.update_to_state, to_state)
GLib.idle_add(self.reload_state)
def set_progress(self, percentage: int):
if self.current_state == self.state.QUEUED:
GLib.idle_add(self.update_to_state, self.state.DOWNLOADING)
if self.progress_bar:
GLib.idle_add(self.progress_bar.set_fraction, percentage / 100)
