484 lines
17 KiB
Python
484 lines
17 KiB
Python
import json
|
|
import math
|
|
import os
|
|
import platform
|
|
import shutil
|
|
import subprocess
|
|
import sys
|
|
from logging import getLogger
|
|
from typing import Tuple, List
|
|
|
|
import qtawesome
|
|
import requests
|
|
from PyQt5.QtCore import pyqtSignal, pyqtSlot, QObject, QRunnable, QSettings, Qt, QFile, QDir
|
|
from PyQt5.QtGui import QPalette, QColor, QPixmap, QImage
|
|
from PyQt5.QtWidgets import QApplication, QStyleFactory
|
|
from requests.exceptions import HTTPError
|
|
|
|
from legendary.models.game import Game
|
|
from .models import PathSpec
|
|
|
|
# Windows
|
|
|
|
if platform.system() == "Windows":
|
|
# noinspection PyUnresolvedReferences
|
|
from win32com.client import Dispatch # pylint: disable=E0401
|
|
|
|
from rare import image_dir, shared, resources_path
|
|
# Mac not supported
|
|
|
|
from legendary.core import LegendaryCore
|
|
|
|
logger = getLogger("Utils")
|
|
settings = QSettings("Rare", "Rare")
|
|
|
|
|
|
def download_images(progress: pyqtSignal, results: pyqtSignal, core: LegendaryCore):
|
|
if not os.path.isdir(image_dir):
|
|
os.makedirs(image_dir)
|
|
logger.info("Create Image dir")
|
|
|
|
# Download Images
|
|
games, dlcs = core.get_game_and_dlc_list(True)
|
|
results.emit((games, dlcs), "gamelist")
|
|
dlc_list = []
|
|
for i in dlcs.values():
|
|
dlc_list.append(i[0])
|
|
|
|
no_assets = core.get_non_asset_library_items()[0]
|
|
results.emit(no_assets, "no_assets")
|
|
|
|
game_list = games + dlc_list + no_assets
|
|
for i, game in enumerate(game_list):
|
|
try:
|
|
download_image(game)
|
|
except json.decoder.JSONDecodeError:
|
|
shutil.rmtree(f"{image_dir}/{game.app_name}")
|
|
download_image(game)
|
|
progress.emit(i * 100 // len(game_list))
|
|
|
|
|
|
def download_image(game, force=False):
|
|
if force and os.path.exists(f"{image_dir}/{game.app_name}"):
|
|
shutil.rmtree(f"{image_dir}/{game.app_name}")
|
|
if not os.path.isdir(f"{image_dir}/" + game.app_name):
|
|
os.mkdir(f"{image_dir}/" + game.app_name)
|
|
|
|
# to get picture updates
|
|
if not os.path.isfile(f"{image_dir}/{game.app_name}/image.json"):
|
|
json_data = {"DieselGameBoxTall": None, "DieselGameBoxLogo": None, "Thumbnail": None}
|
|
else:
|
|
json_data = json.load(open(f"{image_dir}/{game.app_name}/image.json", "r"))
|
|
# Download
|
|
for image in game.metadata["keyImages"]:
|
|
if image["type"] == "DieselGameBoxTall" or image["type"] == "DieselGameBoxLogo" or image["type"] == "Thumbnail":
|
|
if image["type"] not in json_data.keys():
|
|
json_data[image["type"]] = None
|
|
if json_data[image["type"]] != image["md5"] or not os.path.isfile(
|
|
f"{image_dir}/{game.app_name}/{image['type']}.png"):
|
|
# Download
|
|
json_data[image["type"]] = image["md5"]
|
|
# os.remove(f"{image_dir}/{game.app_name}/{image['type']}.png")
|
|
json.dump(json_data, open(f"{image_dir}/{game.app_name}/image.json", "w"))
|
|
logger.info(f"Download Image for Game: {game.app_title}")
|
|
url = image["url"]
|
|
resp = requests.get(url)
|
|
img = QImage()
|
|
img.loadFromData(resp.content)
|
|
img = img.scaled(200, 200 * 4 // 3, Qt.KeepAspectRatio, transformMode=Qt.SmoothTransformation)
|
|
img.save(os.path.join(image_dir, game.app_name, image["type"] + ".png"), format="PNG")
|
|
|
|
|
|
color_role_map = {
|
|
0: "WindowText",
|
|
1: "Button",
|
|
2: "Light",
|
|
3: "Midlight",
|
|
4: "Dark",
|
|
5: "Mid",
|
|
6: "Text",
|
|
7: "BrightText",
|
|
8: "ButtonText",
|
|
9: "Base",
|
|
10: "Window",
|
|
11: "Shadow",
|
|
12: "Highlight",
|
|
13: "HighlightedText",
|
|
14: "Link",
|
|
15: "LinkVisited",
|
|
16: "AlternateBase",
|
|
# 17: "NoRole",
|
|
18: "ToolTipBase",
|
|
19: "ToolTipText",
|
|
20: "PlaceholderText",
|
|
# 21: "NColorRoles",
|
|
}
|
|
|
|
color_group_map = {
|
|
0: "Active",
|
|
1: "Disabled",
|
|
2: "Inactive",
|
|
}
|
|
|
|
|
|
def load_color_scheme(path: str) -> QPalette:
|
|
palette = QPalette()
|
|
scheme = QSettings(path, QSettings.IniFormat)
|
|
try:
|
|
scheme.beginGroup("ColorScheme")
|
|
for g in color_group_map:
|
|
scheme.beginGroup(color_group_map[g])
|
|
group = QPalette.ColorGroup(g)
|
|
for r in color_role_map:
|
|
role = QPalette.ColorRole(r)
|
|
color = scheme.value(color_role_map[r], None)
|
|
if color is not None:
|
|
palette.setColor(group, role, QColor(color))
|
|
else:
|
|
palette.setColor(group, role, palette.color(QPalette.Active, role))
|
|
scheme.endGroup()
|
|
scheme.endGroup()
|
|
except:
|
|
palette = None
|
|
return palette
|
|
|
|
|
|
def set_color_pallete(color_scheme: str):
|
|
if not color_scheme:
|
|
QApplication.instance().setStyle(QStyleFactory.create(QApplication.instance().property('rareDefaultQtStyle')))
|
|
QApplication.instance().setStyleSheet("")
|
|
QApplication.instance().setPalette(QApplication.instance().style().standardPalette())
|
|
return
|
|
QApplication.instance().setStyle(QStyleFactory.create("Fusion"))
|
|
custom_palette = load_color_scheme(f":/schemes/{color_scheme}")
|
|
if custom_palette is not None:
|
|
QApplication.instance().setPalette(custom_palette)
|
|
qtawesome.set_defaults(color=custom_palette.color(QPalette.Text))
|
|
|
|
|
|
def get_color_schemes() -> List[str]:
|
|
colors = []
|
|
for file in QDir(":/schemes"):
|
|
if file.endswith(".scheme"):
|
|
colors.append(file.replace(".scheme", ""))
|
|
return colors
|
|
|
|
|
|
def set_style_sheet(style_sheet: str):
|
|
if not style_sheet:
|
|
QApplication.instance().setStyle(QStyleFactory.create(QApplication.instance().property('rareDefaultQtStyle')))
|
|
QApplication.instance().setStyleSheet("")
|
|
return
|
|
QApplication.instance().setStyle(QStyleFactory.create("Fusion"))
|
|
file = QFile(f":/stylesheets/{style_sheet}")
|
|
file.open(QFile.ReadOnly)
|
|
stylesheet = file.readAll().data().decode("utf-8")
|
|
|
|
QApplication.instance().setStyleSheet(stylesheet)
|
|
qtawesome.set_defaults(color="white")
|
|
|
|
|
|
def get_style_sheets() -> List[str]:
|
|
styles = []
|
|
for file in QDir(":/stylesheets/"):
|
|
styles.append(file)
|
|
return styles
|
|
|
|
|
|
def get_translations():
|
|
langs = ["en"]
|
|
for i in os.listdir(os.path.join(resources_path, "languages")):
|
|
if i.endswith(".qm") and not i.startswith("qt_"):
|
|
langs.append(i.split(".")[0])
|
|
return langs
|
|
|
|
|
|
def get_latest_version():
|
|
try:
|
|
resp = requests.get("https://api.github.com/repos/Dummerle/Rare/releases/latest")
|
|
tag = resp.json()["tag_name"]
|
|
return tag
|
|
except requests.exceptions.ConnectionError:
|
|
return "0.0.0"
|
|
|
|
|
|
def get_size(b: int) -> str:
|
|
for i in ['', 'K', 'M', 'G', 'T', 'P', 'E']:
|
|
if b < 1024:
|
|
return f"{b:.2f}{i}B"
|
|
b /= 1024
|
|
|
|
|
|
def create_rare_desktop_link(type_of_link):
|
|
# Linux
|
|
if platform.system() == "Linux":
|
|
if type_of_link == "desktop":
|
|
path = os.path.expanduser("~/Desktop/")
|
|
elif type_of_link == "start_menu":
|
|
path = os.path.expanduser("~/.local/share/applications/")
|
|
else:
|
|
return
|
|
|
|
if p := os.environ.get("APPIMAGE"):
|
|
executable = p
|
|
else:
|
|
executable = f"{sys.executable} {os.path.abspath(sys.argv[0])}"
|
|
with open(os.path.join(path, "Rare.desktop"), "w") as desktop_file:
|
|
desktop_file.write("[Desktop Entry]\n"
|
|
f"Name=Rare\n"
|
|
f"Type=Application\n"
|
|
f"Icon={os.path.join(resources_path, 'images', 'Rare.png')}\n"
|
|
f"Exec={executable}\n"
|
|
"Terminal=false\n"
|
|
"StartupWMClass=rare\n"
|
|
)
|
|
desktop_file.close()
|
|
os.chmod(os.path.expanduser(os.path.join(path, "Rare.desktop")), 0o755)
|
|
|
|
elif platform.system() == "Windows":
|
|
# Target of shortcut
|
|
if type_of_link == "desktop":
|
|
target_folder = os.path.expanduser('~/Desktop/')
|
|
elif type_of_link == "start_menu":
|
|
target_folder = os.path.expandvars("%appdata%/Microsoft/Windows/Start Menu")
|
|
else:
|
|
logger.warning("No valid type of link")
|
|
return
|
|
linkName = "Rare.lnk"
|
|
|
|
# Path to location of link file
|
|
pathLink = os.path.join(target_folder, linkName)
|
|
|
|
executable = sys.executable
|
|
executable = executable.replace("python.exe", "pythonw.exe")
|
|
logger.debug(executable)
|
|
# Add shortcut
|
|
shell = Dispatch('WScript.Shell')
|
|
shortcut = shell.CreateShortCut(pathLink)
|
|
shortcut.Targetpath = executable
|
|
if not sys.executable.endswith("Rare.exe"):
|
|
shortcut.Arguments = os.path.abspath(sys.argv[0])
|
|
|
|
# Icon
|
|
shortcut.IconLocation = os.path.join(resources_path, "images", "Rare.ico")
|
|
|
|
shortcut.save()
|
|
|
|
|
|
def create_desktop_link(app_name, core: LegendaryCore, type_of_link="desktop") -> bool:
|
|
igame = core.get_installed_game(app_name)
|
|
|
|
if os.path.exists(p := os.path.join(image_dir, igame.app_name, 'Thumbnail.png')):
|
|
icon = p
|
|
elif os.path.exists(p := os.path.join(image_dir, igame.app_name, "DieselGameBoxLogo.png")):
|
|
icon = p
|
|
else:
|
|
icon = os.path.join(os.path.join(image_dir, igame.app_name, "DieselGameBoxTall.png"))
|
|
icon = icon.replace(".png", "")
|
|
|
|
# Linux
|
|
if platform.system() == "Linux":
|
|
if type_of_link == "desktop":
|
|
path = os.path.expanduser(f"~/Desktop/")
|
|
elif type_of_link == "start_menu":
|
|
path = os.path.expanduser("~/.local/share/applications/")
|
|
else:
|
|
return False
|
|
if not os.path.exists(path):
|
|
return False
|
|
if p := os.environ.get("APPIMAGE"):
|
|
executable = p
|
|
else:
|
|
executable = f"{sys.executable} {os.path.abspath(sys.argv[0])}"
|
|
with open(f"{path}{igame.title}.desktop", "w") as desktop_file:
|
|
desktop_file.write("[Desktop Entry]\n"
|
|
f"Name={igame.title}\n"
|
|
f"Type=Application\n"
|
|
f"Icon={icon}.png\n"
|
|
f"Exec={executable} launch {app_name}\n"
|
|
"Terminal=false\n"
|
|
"StartupWMClass=rare-game\n"
|
|
)
|
|
desktop_file.close()
|
|
os.chmod(os.path.expanduser(f"{path}{igame.title}.desktop"), 0o755)
|
|
|
|
# Windows
|
|
elif platform.system() == "Windows":
|
|
# Target of shortcut
|
|
if type_of_link == "desktop":
|
|
target_folder = os.path.expanduser('~/Desktop/')
|
|
elif type_of_link == "start_menu":
|
|
target_folder = os.path.expandvars("%appdata%/Microsoft/Windows/Start Menu")
|
|
else:
|
|
logger.warning("No valid type of link")
|
|
return False
|
|
if not os.path.exists(target_folder):
|
|
return False
|
|
|
|
# Name of link file
|
|
linkName = igame.title
|
|
for c in r'<>?":|\/*':
|
|
linkName.replace(c, "")
|
|
|
|
linkName = linkName.strip() + '.lnk'
|
|
|
|
# Path to location of link file
|
|
pathLink = os.path.join(target_folder, linkName)
|
|
|
|
# Add shortcut
|
|
shell = Dispatch('WScript.Shell')
|
|
shortcut = shell.CreateShortCut(pathLink)
|
|
if sys.executable.endswith("Rare.exe"):
|
|
executable = sys.executable
|
|
else:
|
|
executable = f"{sys.executable} {os.path.abspath(sys.argv[0])}"
|
|
shortcut.Targetpath = executable
|
|
shortcut.Arguments = f'launch {app_name}'
|
|
shortcut.WorkingDirectory = os.getcwd()
|
|
|
|
# Icon
|
|
if not os.path.exists(icon + ".ico"):
|
|
img = QImage()
|
|
img.load(icon + ".png")
|
|
img.save(icon + ".ico")
|
|
logger.info("Create Icon")
|
|
shortcut.IconLocation = os.path.join(icon + ".ico")
|
|
|
|
shortcut.save()
|
|
return True
|
|
|
|
elif platform.system() == "Darwin":
|
|
return False
|
|
|
|
|
|
def get_pixmap(app_name: str) -> QPixmap:
|
|
for img in ["FinalArt.png", "DieselGameBoxTall.png", "DieselGameBoxLogo.png"]:
|
|
if os.path.exists(image := os.path.join(image_dir, app_name, img)):
|
|
pixmap = QPixmap(image)
|
|
break
|
|
else:
|
|
pixmap = QPixmap()
|
|
return pixmap
|
|
|
|
|
|
def get_uninstalled_pixmap(app_name: str) -> QPixmap:
|
|
pm = get_pixmap(app_name)
|
|
grey_image = pm.toImage().convertToFormat(QImage.Format_Grayscale8)
|
|
return QPixmap.fromImage(grey_image)
|
|
|
|
|
|
def optimal_text_background(image: list) -> Tuple[int, int, int]:
|
|
"""
|
|
Finds an optimal background color for text on the image by calculating the
|
|
average color of the image and inverting it.
|
|
|
|
The image list is supposed to be a one-dimensional list of arbitrary length
|
|
containing RGB tuples, ranging from 0 to 255.
|
|
"""
|
|
# cursed, I know
|
|
average = map(lambda value: value // len(image), map(sum, zip(*image)))
|
|
inverted = map(lambda value: 255 - value, average)
|
|
return tuple(inverted)
|
|
|
|
|
|
def text_color_for_background(background: Tuple[int, int, int]) -> Tuple[int,
|
|
int,
|
|
int]:
|
|
"""
|
|
Calculates whether a black or white text color would fit better for the
|
|
given background, and returns that color. This is done by calculating the
|
|
luminance and simple comparing of bounds
|
|
"""
|
|
# see https://alienryderflex.com/hsp.html
|
|
(red, green, blue) = background
|
|
luminance = math.sqrt(
|
|
0.299 * red ** 2 +
|
|
0.587 * green ** 2 +
|
|
0.114 * blue ** 2)
|
|
if luminance < 127:
|
|
return 255, 255, 255
|
|
else:
|
|
return 0, 0, 0
|
|
|
|
|
|
class WineResolverSignals(QObject):
|
|
result_ready = pyqtSignal(str)
|
|
|
|
|
|
class WineResolver(QRunnable):
|
|
|
|
def __init__(self, path: str, app_name: str, core: LegendaryCore):
|
|
super(WineResolver, self).__init__()
|
|
self.setAutoDelete(True)
|
|
self.signals = WineResolverSignals()
|
|
self.wine_env = os.environ.copy()
|
|
self.wine_env.update(core.get_app_environment(app_name))
|
|
self.wine_env['WINEDLLOVERRIDES'] = 'winemenubuilder=d;mscoree=d;mshtml=d;'
|
|
self.wine_env['DISPLAY'] = ''
|
|
self.wine_binary = core.lgd.config.get(
|
|
app_name, 'wine_executable',
|
|
fallback=core.lgd.config.get('default', 'wine_executable', fallback='wine'))
|
|
self.winepath_binary = os.path.join(os.path.dirname(self.wine_binary), 'winepath')
|
|
self.path = PathSpec(core, app_name).cook(path)
|
|
|
|
@pyqtSlot()
|
|
def run(self):
|
|
if 'WINEPREFIX' not in self.wine_env or not os.path.exists(self.wine_env['WINEPREFIX']):
|
|
# pylint: disable=E1136
|
|
self.signals.result_ready[str].emit(str())
|
|
return
|
|
if not os.path.exists(self.wine_binary) or not os.path.exists(self.winepath_binary):
|
|
# pylint: disable=E1136
|
|
self.signals.result_ready[str].emit(str())
|
|
return
|
|
path = self.path.strip().replace('/', '\\')
|
|
# lk: if path does not exist form
|
|
cmd = [self.wine_binary, 'cmd', '/c', 'echo', path]
|
|
# lk: if path exists and needs a case sensitive interpretation form
|
|
# cmd = [self.wine_binary, 'cmd', '/c', f'cd {path} & cd']
|
|
proc = subprocess.Popen(cmd,
|
|
stdout=subprocess.PIPE, stderr=subprocess.PIPE,
|
|
env=self.wine_env, shell=False, text=True)
|
|
out, err = proc.communicate()
|
|
# Clean wine output
|
|
out = out.strip().strip('"')
|
|
proc = subprocess.Popen([self.winepath_binary, '-u', out],
|
|
stdout=subprocess.PIPE, stderr=subprocess.PIPE,
|
|
env=self.wine_env, shell=False, text=True)
|
|
out, err = proc.communicate()
|
|
real_path = os.path.realpath(out.strip())
|
|
# pylint: disable=E1136
|
|
self.signals.result_ready[str].emit(real_path)
|
|
return
|
|
|
|
|
|
class CloudResultSignal(QObject):
|
|
result_ready = pyqtSignal(list) # List[SaveGameFile]
|
|
|
|
|
|
class CloudWorker(QRunnable):
|
|
def __init__(self):
|
|
super(CloudWorker, self).__init__()
|
|
self.signals = CloudResultSignal()
|
|
self.setAutoDelete(True)
|
|
|
|
def run(self) -> None:
|
|
try:
|
|
result = shared.core.get_save_games()
|
|
except HTTPError():
|
|
result = None
|
|
self.signals.result_ready.emit(result)
|
|
|
|
|
|
def get_raw_save_path(game: Game):
|
|
if game.supports_cloud_saves:
|
|
return game.metadata.get("customAttributes", {}).get("CloudSaveFolder", {}).get("value")
|
|
|
|
|
|
def get_default_platform(app_name):
|
|
if platform.system() != "Darwin" or app_name not in shared.api_results.mac_games:
|
|
return "Windows"
|
|
|
|
else:
|
|
return "Mac"
|