pp-games-lib

#!/usr/bin/env python3

import os
import re
import shlex
import shutil
import logging
from configparser import RawConfigParser
from pathlib import Path
from subprocess import run
from types import SimpleNamespace
try:
    from PyQt6.QtCore import * # type: ignore
    from PyQt6.QtGui import * # type: ignore
    from PyQt6.QtWidgets import * # type: ignore
except ModuleNotFoundError:
    from PyQt5.QtCore import * # type: ignore
    from PyQt5.QtGui import * # type: ignore
    from PyQt5.QtWidgets import * # type: ignore

settings = QSettings('PPGL', 'PortProtonGamesLib')
g = SimpleNamespace(locale = '')

class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()

        self.resize(QSize(800, 600))
        geometry = settings.value('geometry_main')
        if geometry:
            self.restoreGeometry(geometry)

        shortcut = RawConfigParser()
        shortcut.read(os.getenv('HOME') + '/.local/share/applications/PortProton.desktop')
        scripts_dir = shortcut.get('Desktop Entry', 'Path', fallback=os.getenv('HOME') + '/.local/share/PortWINE/PortProton/data/scripts')
        if not scripts_dir or not Path(scripts_dir).is_dir():
            QMessageBox.critical(self, 'Error', 'Can not find installed PortProton')
            exit(1)
        g.scripts_dir = scripts_dir.rstrip('/')
        g.pp_icon = shortcut.get('Desktop Entry', 'Icon', fallback='/usr/share/pixmaps/portproton.png')
        pp_icon = QIcon(g.pp_icon)
        self.setWindowIcon(pp_icon)
        self.setWindowTitle('PortProton games library')

        g.base_dir = str(Path(scripts_dir + '/../..').resolve())
        g.install_pfx = g.base_dir + '/data/prefixes/INSTALL'
        g.shortcuts_dir = g.base_dir + '/shortcuts'
        g.games_dir = g.base_dir + '/games'

        loc_path = Path(g.base_dir + '/data/tmp/PortProton_loc')
        if loc_path.exists():
            g.locale = loc_path.read_text().strip()

        Path(g.shortcuts_dir).mkdir(parents=True, exist_ok=True)
        Path(g.games_dir).mkdir(parents=True, exist_ok=True)

        sep = QFrame(self)
        sep.setFrameShape(QFrame.Shape.VLine)
        sep.setFrameShadow(QFrame.Shadow.Sunken)
        self._status_size = QLabel(self)
        self._status_dir = QLabel(self)
        self._status_wine = QLabel(self)
        self.statusBar().setVisible(False)
        self.statusBar().addWidget(self._status_dir, 1)
        self.statusBar().addWidget(self._status_wine)
        self.statusBar().addWidget(sep)
        self.statusBar().addWidget(self._status_size)


        self.game_list = GameList(self)
        self.setCentralWidget(self.game_list)

        self.toolbar = self.addToolBar('Main')
        self.toolbar.setIconSize(QSize(32, 32))
        self.toolbar.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonTextBesideIcon)
        self.toolbar.setMovable(False)
        action = QAction(self.style().standardIcon(QStyle.StandardPixmap.SP_FileDialogNewFolder), _tr('Install new game'), self)
        action.triggered.connect(self.install_game)
        self.toolbar.addAction(action)
        action = QAction(self.style().standardIcon(QStyle.StandardPixmap.SP_FileLinkIcon), _tr('Add game entry'), self)
        action.triggered.connect(self.add_game)
        self.toolbar.addAction(action)
        action = QAction(self.style().standardIcon(QStyle.StandardPixmap.SP_BrowserReload), _tr('Reload list'), self)
        action.triggered.connect(self.reload_list)
        self.toolbar.addAction(action)
        action = QAction(self.style().standardIcon(QStyle.StandardPixmap.SP_TrashIcon), _tr('Drop install prefix'), self)
        action.triggered.connect(self.drop_prefix)
        self.toolbar.addAction(action)
        spacer = QWidget(self)
        spacer.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Preferred)
        self.toolbar.addWidget(spacer)
        action = QAction(pp_icon, 'PortProton', self)
        action.triggered.connect(self.run_pp)
        self.toolbar.addAction(action)

    def install_game(self):
        InstallGame(self)

    def add_game(self):
        InstallGame(self, False)

    def reload_list(self):
        self.game_list.reload()

    def drop_prefix(self):
        res = QMessageBox.question(self, _tr('Are you sure ?'), _tr('Do you really want to remove<br/><b>{0}</b> ?', g.install_pfx))
        if res == QMessageBox.StandardButton.Yes:
            shutil.rmtree(g.install_pfx, True)

    def run_pp(self):
        self.setDisabled(True)
        app.processEvents()
        run([g.scripts_dir + '/start.sh'])
        self.setDisabled(False)

    def set_status(self, item):
        self.statusBar().setVisible(bool(item))
        if item:
            self._status_size.setText('Size: ' + item.dir_size_human)
            self._status_dir.setText(' ' + item.game_dir)
            self._status_wine.setText(item.wine_use)

    def closeEvent(self, event):
        geometry = self.saveGeometry()
        settings.setValue('geometry_main', geometry)
        super().closeEvent(event)

class LoadListThread(QThread):
    completed = pyqtSignal(list)
    def __init__(self, parent, install_dir):
        super().__init__(parent)
        self.install_dir = install_dir
    def run(self):
        exe_list = list(Path(self.install_dir).glob('**/*.exe'))
        self.completed.emit(exe_list)

class InstallGame(QDialog):
    def __init__(self, parent, installing=True):
        super().__init__(parent)
        self._installing = installing
        self.install_dir = g.install_pfx + '/drive_c/Games' if installing else g.games_dir
        self._exe_list_widget = QListWidget(self)
        self._exe_list_widget.setIconSize(QSize(16, 16))
        self._exe_list_widget.itemDoubleClicked.connect(self._handleDoubleClick)
        layout = QVBoxLayout()
        layout.addWidget(self._exe_list_widget)

        self._pbar = QProgressBar(self)
        self._pbar.setMaximum(0)
        layout.addWidget(self._pbar)
        thread = LoadListThread(self, self.install_dir)
        thread.completed.connect(self.load)
        thread.start()

        if self._installing:
            setup_btn = QPushButton(self)
            setup_btn.setIcon(self.style().standardIcon(QStyle.StandardPixmap.SP_FileDialogStart))
            setup_btn.setText(_tr('Run another setup'))
            setup_btn.clicked.connect(self._runSetup)
            layout.addWidget(setup_btn)
        self.setLayout(layout)
        self.resize(400, 300)
        self.setModal(True)
        self.setWindowTitle(_tr('Select game exe file'))
        geometry = settings.value('geometry_install')
        if geometry:
            self.restoreGeometry(geometry)
        self.show()

    def load(self, exe_list):
        if self._installing and len(exe_list) == 0:
            self._runSetup()
            exe_list = list(Path(self.install_dir).glob('**/*.exe'))
        if len(exe_list) == 0:
            return self.close()
        def render_list():
            pixmap = QPixmap(16, 16)
            pixmap.fill(Qt.GlobalColor.transparent)
            empty_icon = QIcon(pixmap)
            for exe in sorted(exe_list):
                ico_file = str(exe) + '.ico'
                item = QListWidgetItem(self._exe_list_widget)
                item.setText(str(exe)[len(self.install_dir)+1:])
                try:
                    if not Path(ico_file).exists():
                        run(['wrestool', '-x', '-t14', '-o', ico_file, exe], capture_output=True)
                    item.setIcon(QIcon(ico_file))
                except Exception:
                    pass
                if item.icon().pixmap(16, 16).isNull():
                    item.setIcon(empty_icon)
                self._exe_list_widget.addItem(item)
            self._pbar.setVisible(False)
        thread = QThread(self)
        thread.run = render_list
        thread.start()

    def _runSetup(self):
        downloads_dir = QStandardPaths.writableLocation(QStandardPaths.StandardLocation.DownloadLocation)
        exe_file, _ = QFileDialog.getOpenFileName(self, caption=_tr('Choose setup file'), filter='Exe files (*.exe)', directory=downloads_dir)
        if not exe_file:
            return
        ppdb = shlex.quote(exe_file + '.ppdb')
        script = f"""
            mkdir -p {shlex.quote(g.install_pfx + '/drive_c/Games')}
            echo '
                export PW_VULKAN_USE=1
                export PW_GUI_DISABLED_CS=1
                export PW_PREFIX_NAME=INSTALL
                export PW_DLL_INSTALL=mfc42
            ' > {ppdb}
            {shlex.quote(g.scripts_dir + '/start.sh')} {shlex.quote(exe_file)}
            rm -f {ppdb}
        """
        self.setDisabled(True)
        app.processEvents()
        run(['bash', '-c', script])
        self.setDisabled(False)

    def _handleDoubleClick(self, item):
        game_dir = item.text().split('/')[0]
        dlg = QInputDialog(self)
        dlg.setWindowTitle(_tr('Please enter game entry name'))
        dlg.setLabelText(_tr('New game entry'))
        dlg.setTextValue(game_dir)
        dlg.resize(300, 0)
        ok = dlg.exec()
        shortcut_name = dlg.textValue()
        if not ok or not shortcut_name:
            return
        file_name = re.sub(r'[<>:/\\|?*]', '_', shortcut_name)
        shortcut = f"{g.shortcuts_dir}/{file_name}.desktop"
        if Path(shortcut).exists():
            res = QMessageBox.question(self, _tr('Shortcut already exists'), _tr('Shortcut <b>{0}</b> already exists. Overwrite ?', file_name))
            if res != QMessageBox.StandardButton.Yes:
                return
        src_dir = self.install_dir + '/' + game_dir
        dst_dir = g.games_dir + '/' + game_dir
        exe_file = shlex.quote(g.games_dir + '/' + item.text())
        ppdb = shlex.quote(g.games_dir + '/' + item.text() + '.ppdb')
        self.setDisabled(True)
        if self._installing and Path(dst_dir).exists():
            res = QMessageBox.question(self, _tr('Dir already exists'), _tr('Dir <b>{0}</b> already exists. Overwrite ?', game_dir))
            if res != QMessageBox.StandardButton.Yes:
                return
        if self._installing:
            os.rename(src_dir, dst_dir)
        script = f"""
            export INSTALLING_PORT=1
            export portwine_exe={exe_file}
            cd {shlex.quote(g.scripts_dir)}
            . {shlex.quote(g.scripts_dir + '/runlib')}
            pw_init_db
            [ -f {ppdb} ] && . {ppdb}
            echo -e "export PW_VULKAN_USE=${{PW_VULKAN_USE:-1}}\nexport PW_GUI_DISABLED_CS=1" >> {ppdb}
        """
        run(['bash', '-c', script])
        icon_path = g.games_dir + '/' + item.text() + '.ico'
        if not Path(icon_path).exists():
            icon_path = g.pp_icon
        Path(shortcut).write_text(f"""[Desktop Entry]
Name={shortcut_name}
Exec=env {shlex.quote(g.scripts_dir + '/start.sh')} {exe_file}
Type=Application
Categories=Game
StartupNotify=true
Path={shlex.quote(g.scripts_dir)}
Icon={icon_path}
""", encoding='utf-8')
        os.chmod(shortcut, 0o755)
        win.reload_list()
        self.close()

    def closeEvent(self, event):
        geometry = self.saveGeometry()
        settings.setValue('geometry_install', geometry)
        super().closeEvent(event)


class GameList(QListWidget):
    def __init__(self, parent):
        super().__init__(parent)
        self.itemActivated.connect(self.runGame)
        self.currentItemChanged.connect(self.selectItem)
        self.setViewMode(QListWidget.ViewMode.IconMode)
        self.setResizeMode(QListWidget.ResizeMode.Adjust)
        self.setIconSize(QSize(64, 64))
        self.setWordWrap(True)
        self.setSpacing(3)
        self.reload()

    def reload(self):
        self.clear()
        shortcuts = list(Path(g.shortcuts_dir).glob('*.desktop'))
        shortcuts += list(Path(g.base_dir).glob('*.desktop'))
        for shortcut in shortcuts:
            try:
                item = GameItem(self, shortcut)
                self.addItem(item)
            except ValueError:
                pass
            except:
                logging.exception('Error while parse "%s"', shortcut)
        self.sortItems()
        self.setCurrentIndex(QModelIndex())

    def runGame(self, item):
        win.setDisabled(True)
        app.processEvents()
        run(['bash', '-c', item.get('Exec')])
        win.setDisabled(False)

    def selectItem(self, item):
        win.set_status(item)

    def contextMenuEvent(self, event):
        selected = self.selectedItems()
        if len(selected) == 0:
            return
        selected = selected[0]
        menu = QMenu(self)
        desktop = menu.addAction(self.style().standardIcon(QStyle.StandardPixmap.SP_DesktopIcon), _tr('Add to desktop'))
        restore_gui = menu.addAction(self.style().standardIcon(QStyle.StandardPixmap.SP_DialogResetButton), _tr('Restore PortProton GUI'))
        default_wine = menu.addAction(self.style().standardIcon(QStyle.StandardPixmap.SP_DialogOkButton), _tr('Set default wine'))
        remove = menu.addAction(self.style().standardIcon(QStyle.StandardPixmap.SP_TrashIcon), _tr('Remove game entry'))
        uninstall = menu.addAction(self.style().standardIcon(QStyle.StandardPixmap.SP_DialogCloseButton), _tr('Uninstall game'))
        if not selected.pp_gui_disabled:
            restore_gui.setVisible(False)
        if not selected.wine_use:
            default_wine.setVisible(False)
        if not selected.game_dir.startswith(g.games_dir):
            uninstall.setVisible(False)
        action = menu.exec(self.mapToGlobal(event.pos()))
        desktop_shortcut = QStandardPaths.writableLocation(QStandardPaths.StandardLocation.DesktopLocation) + '/' + Path(selected.desktop_file).name
        if action == desktop:
            if Path(desktop_shortcut).exists():
                res = QMessageBox.question(self, _tr('Shortcut already exists'), _tr('Shortcut <b>{0}</b> already exists. Overwrite ?', desktop_shortcut))
                if res != QMessageBox.StandardButton.Yes:
                    return
            shutil.copy(selected.desktop_file, desktop_shortcut)
        if action == restore_gui or action == default_wine:
            ignore_line = 'PW_GUI_DISABLED_CS' if action == restore_gui else 'PW_WINE_USE'
            ppdb = shlex.split(selected.get('Exec'))[-1] + '.ppdb'
            if not Path(ppdb).exists():
                return
            with open(ppdb, 'r') as read:
                with open(ppdb + '.new', 'w') as write:
                    while (line := read.readline()):
                        if ignore_line not in line:
                            write.write(line)
            os.rename(ppdb + '.new', ppdb)
            if action == restore_gui:
                selected.pp_gui_disabled = False
            if action == default_wine:
                selected.wine_use = None
                self.selectItem(selected)
        def remove_shortcut():
            Path(desktop_shortcut).unlink(True)
            Path(selected.desktop_file).unlink(True)
            def_icon_path = g.base_dir + '/data/img/' + Path(shlex.split(selected.get('Exec'))[-1]).stem + '.png'
            Path(def_icon_path).unlink(True)
        if action == remove:
            remove_shortcut()
            self.reload()
        if action == uninstall:
            res = QMessageBox.question(self,
                _tr('Are you sure ?'),
                _tr('Do you really want to uninstall <b>{0}</b><br/>located in "<b>{1}</b>" ?', selected.get('Name'), selected.game_dir)
            )
            if res != QMessageBox.StandardButton.Yes:
                return
            remove_shortcut()
            if selected.game_dir.startswith(g.games_dir):
                shutil.rmtree(selected.game_dir, True)
            self.reload()


def human_size(num):
    if not num:
        return "-"
    for unit in ["", "Ki", "Mi", "Gi", "Ti", "Pi", "Ei", "Zi"]:
        if abs(num) < 1024.0:
            return f"{num:.2f} {unit}B"
        num /= 1024.0
    return f"{num:.2f} YiB"

class GameItem(QListWidgetItem):
    def __init__(self, parent, desktop_file):
        self.desktop_file = desktop_file
        self.config = RawConfigParser()
        self.config.read(desktop_file)
        text = self.get('Name', Path(desktop_file).stem)
        if not self.get('Exec') or text == 'PortProton':
            raise ValueError('Validation fail')
        exe_file = shlex.split(self.get('Exec'))[-1]
        if exe_file.startswith(g.games_dir):
            self.game_dir = g.games_dir + '/' + exe_file[len(g.games_dir)+1:].split('/')[0]
        else:
            self.game_dir = str(Path(exe_file).parent)
        if self.game_dir == '.':
            raise ValueError('Can not determine game dir')
        self.pp_gui_disabled = False
        self.wine_use = None
        ppdb = exe_file + '.ppdb'
        if Path(ppdb).exists():
            ppdb_conf = RawConfigParser(strict=False)
            with open(ppdb) as f:
                ppdb_conf.read_string('[dummy]\n' + f.read())
            pp_gui_disabled = ppdb_conf.get('dummy', 'export PW_GUI_DISABLED_CS', fallback='').strip('"')
            try: self.pp_gui_disabled = bool(int(pp_gui_disabled))
            except: self.pp_gui_disabled = bool(pp_gui_disabled)
            self.wine_use = ppdb_conf.get('dummy', 'export PW_WINE_USE', fallback='').strip('"')

        super().__init__(parent)

        self.setToolTip(text)
        self.setText(text)
        icon_path = self.get('Icon') if Path(self.get('Icon')).exists() else g.pp_icon
        qicon = QIcon(icon_path)
        self.setIcon(qicon)
        self.setTextAlignment(Qt.AlignmentFlag.AlignHCenter | Qt.AlignmentFlag.AlignTop)
        self.setSizeHint(QSize(100, 105))

        self._set_dir_size(None)
        dir_size_cache = self.game_dir + '/.size'
        if Path(dir_size_cache).exists():
            self._set_dir_size(int(Path(dir_size_cache).read_text()))
        else:
            def calc_dir_size():
                if not Path(self.game_dir).exists():
                    return
                dir_size = sum(p.stat(follow_symlinks=False).st_size for p in Path(self.game_dir).rglob('*'))
                self._set_dir_size(dir_size)
                Path(dir_size_cache).write_text(str(dir_size))
            thread = QThread(parent)
            thread.run = calc_dir_size
            thread.start()

    def get(self, name, fallback=None):
        return self.config.get('Desktop Entry', name, fallback=fallback)

    def _set_dir_size(self, size):
        self.dir_size = size
        self.dir_size_human = human_size(size)

import signal
signal.signal(signal.SIGINT, signal.SIG_DFL)

lang = {
    'RUS': {
        'Install new game': 'Установить игру',
        'Add game entry': 'Добавить в список',
        'Reload list': 'Обновить список',
        'Drop install prefix': 'Удалить установочный префикс',
        'Are you sure ?': 'Вы уверены ?',
        'Do you really want to remove<br/><b>{0}</b> ?': 'Вы действительно хотите удалить<br/><b>{0}</b> ?',
        'Run another setup': 'Запустить установку',
        'Select game exe file': 'Выберите exe файл игры',
        'Choose setup file': 'Выберите установочный файл',
        'Please enter game entry name': 'Введите название игры',
        'New game entry': 'Название игры',
        'Shortcut already exists': 'Ярлык уже существует',
        'Shortcut <b>{0}</b> already exists. Overwrite ?': 'Ярлык <b>{0}</b> уже существует. Перезаписать ?',
        'Dir already exists': 'Директория уже существует',
        'Dir <b>{0}</b> already exists. Overwrite ?': 'Директория <b>{0}</b> уже существует. Перезаписать ?',
        'Add to desktop': 'Добавить на рабочий стол',
        'Restore PortProton GUI': 'Восстановить PortProton GUI',
        'Set default wine': 'Выбрать дефолтный wine',
        'Remove game entry': 'Убрать из списка',
        'Uninstall game': 'Удалить игру',
        'Do you really want to uninstall <b>{0}</b><br/>located in "<b>{1}</b>" ?': 'Вы действительно хотите удалить <b>{0}</b><br/>расположеную в "<b>{1}</b>" ?'
    }
}
def _tr(text, *fmt):
    res = lang.get(g.locale, {}).get(text, text)
    if fmt:
        res = res.format(*fmt)
    return res

app = QApplication([])
app.setDesktopFileName('PortProton')
win = MainWindow()
win.show()
app.exec()