lbi-gui.in

#!/usr/bin/env python3
#
# Copyright (c) 2020 The NomadBSD Project. All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
# 1. Redistributions of source code must retain the above copyright
#    notice, this list of conditions and the following disclaimer.
# 2. Redistributions in binary form must reproduce the above copyright
#    notice, this list of conditions and the following disclaimer in the
#    documentation and/or other materials provided with the distribution.
#
# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#

from PyQt6.QtWidgets import (
    QApplication, QMainWindow, QMessageBox, QWidget, QFormLayout, QComboBox,
    QLabel, QLineEdit, QStyle, QPushButton, QRadioButton, QTabWidget,
    QHBoxLayout, QPlainTextEdit, QVBoxLayout)
from PyQt6.QtCore import (
    Qt, QTranslator, QLocale, QRegularExpression, QCoreApplication, QProcess)
from PyQt6.QtGui import QIcon, QRegularExpressionValidator, QTextCursor
import os
import sys

PREFIX = '@PREFIX@'
PROGRAM = '@PROGRAM@'
REPO_URL = '@REPO_URL@'
LOCALE_PATH = '@LOCALE_PATH@'
PATH_LBI_DIR = '@PATH_LBI_DIR@'


class MainWindow(QMainWindow):
    def __init__(self, *args, **kwargs):
        super(MainWindow, self).__init__(*args, **kwargs)
        container = QWidget()
        layout = QVBoxLayout(container)
        bbox = QHBoxLayout()
        icon = QIcon.fromTheme('web-browser')
        quit_icon = QIcon.fromTheme('gtk-quit')
        cancel_icon = QIcon.fromTheme('cancel')
        install_icon = QIcon.fromTheme('system-software-install')
        deinstall_icon = QIcon.fromTheme('edit-delete')
        upgrade_icon = QIcon.fromTheme('arrow-up')
        self.chrome_rb = QRadioButton('Google Chrome')
        self.brave_rb = QRadioButton('Brave')
        self.vivaldi_rb = QRadioButton('Vivaldi')
        self.opera_rb = QRadioButton('Opera')
        self.edge_rb = QRadioButton('Microsoft Edge')
        self.install_bt = QPushButton(install_icon, self.tr('&Install'))
        self.deinstall_bt = QPushButton(deinstall_icon, self.tr('&Deinstall'))
        self.cancel_bt = QPushButton(cancel_icon, self.tr('&Cancel'))
        self.quit_bt = QPushButton(quit_icon, self.tr('&Quit'))
        self.output = QPlainTextEdit()
        text = QLabel()
        self.upgrade_bt = QPushButton(
            upgrade_icon, self.tr('&Upgrade browser(s)'))
        text.setWordWrap(True)
        text.setText(
            self.tr(
                'This program installs Linux binaries of <em>Widevine</em> '
                'capable browsers. They allow you to use web services like '
                '<em>Netflix</em>, <em>Prime Video</em>, or <em>Spotify</em>. '
                'The installation requires approx. 1GB for the Linux '
                'environment, and approx. 100MB for the browser.\n\n'
            )
        )
        self.setWindowTitle(self.tr('Linux Browser Installer GUI'))
        self.setWindowIcon(icon)
        self.setContentsMargins(10, 1, 10, 1)
        self.statusBar().showMessage('', 1)
        layout.addWidget(text)
        layout.addWidget(self.chrome_rb)
        layout.addWidget(self.brave_rb)
        layout.addWidget(self.vivaldi_rb)
        layout.addWidget(self.opera_rb)
        layout.addWidget(self.edge_rb)
        layout.addWidget(self.output)
        bbox.addWidget(self.upgrade_bt, 1, Qt.AlignmentFlag.AlignLeft)
        bbox.addWidget(self.install_bt, 1, Qt.AlignmentFlag.AlignLeft)
        bbox.addWidget(self.deinstall_bt, 1, Qt.AlignmentFlag.AlignLeft)
        bbox.addWidget(self.cancel_bt, 1, Qt.AlignmentFlag.AlignLeft)
        bbox.addWidget(self.quit_bt, 0, Qt.AlignmentFlag.AlignRight)
        layout.addLayout(bbox)
        self.setCentralWidget(container)
        self.output.setTextInteractionFlags(
            (self.output.textInteractionFlags() &
             ~Qt.TextInteractionFlag.TextEditable)
        )
        self.brave_rb.setChecked(True)
        self.reset()
        self.upgrade_bt.clicked.connect(self.upgrade)
        self.install_bt.clicked.connect(self.install)
        self.deinstall_bt.clicked.connect(self.deinstall)
        self.quit_bt.clicked.connect(self.quit)
        self.chrome_rb.clicked.connect(self.update_buttons)
        self.brave_rb.clicked.connect(self.update_buttons)
        self.vivaldi_rb.clicked.connect(self.update_buttons)
        self.opera_rb.clicked.connect(self.update_buttons)
        self.edge_rb.clicked.connect(self.update_buttons)
        self.cancel_bt.clicked.connect(self.cancel_cmd)

    def xerrx(self, error, title, msg):
        msgbox = QMessageBox()
        icon = msgbox.style().standardIcon(QStyle.StandardPixmap.SP_MessageBoxCritical)
        msgbox.setIcon(QMessageBox.Icon.Critical)
        msgbox.setWindowIcon(icon)
        msgbox.setWindowTitle(title)
        msgbox.setContentsMargins(10, 1, 10, 1)
        msgbox.setText('<b>{}</b><br/><br/>{}'.format(title, msg))
        msgbox.exec()
        sys.exit(error)

    def msgwin(self, title, msg):
        msgbox = QMessageBox()
        icon = msgbox.style().standardIcon(QStyle.StandardPixmap.SP_MessageBoxInformation)
        msgbox.setIcon(QMessageBox.Icon.Information)
        msgbox.setWindowIcon(icon)
        msgbox.setWindowTitle(title)
        msgbox.setContentsMargins(10, 1, 10, 1)
        msgbox.setText('<b>{}</b><br/><br/>{}'.format(title, msg))
        msgbox.exec()

    def prepare_proc(self):
        self.disable_buttons()
        self.output.moveCursor(QTextCursor.MoveOperation.End)
        self.output.insertPlainText('\n')
        self.proc = QProcess()
        self.proc.readyReadStandardOutput.connect(self.read_stdout)
        self.proc.readyReadStandardError.connect(self.read_stderr)

    def clone_repo(self):
        args = ['clone', REPO_URL, PATH_LBI_DIR]
        self.proc.finished.connect(self.git_finished)
        self.proc.start('git', args)
        self.statusBar().showMessage(self.tr('Cloning repo ...'), -1)

    def install(self):
        self.prepare_proc()
        self.action = self.install
        if not os.path.exists(PATH_LBI_DIR):
            self.clone_repo()
            return
        elif self.chrome_rb.isChecked():
            self.browser = 'Chrome'
            args = ['install', 'chrome']
        elif self.brave_rb.isChecked():
            self.browser = 'Brave'
            args = ['install', 'brave']
        elif self.vivaldi_rb.isChecked():
            self.browser = 'Vivaldi'
            args = ['install', 'vivaldi']
        elif self.opera_rb.isChecked():
            self.browser = 'Opera'
            args = ['install', 'opera']
        elif self.edge_rb.isChecked():
            self.browser = 'Edge'
            args = ['install', 'edge']
        self.proc.finished.connect(self.cmd_finished)
        os.chdir(PATH_LBI_DIR)
        self.proc.start('./linux-browser-installer', args)
        self.statusBar().showMessage(self.tr('Installing ...'), -1)

    def deinstall(self):
        self.prepare_proc()
        self.action = self.deinstall
        if not os.path.exists(PATH_LBI_DIR):
            self.clone_repo()
            return
        elif self.chrome_rb.isChecked():
            self.browser = 'Google Chrome'
            args = ['deinstall', 'chrome']
        elif self.brave_rb.isChecked():
            self.browser = 'Brave'
            args = ['deinstall', 'brave']
        elif self.vivaldi_rb.isChecked():
            self.browser = 'Vivaldi'
            args = ['deinstall', 'vivaldi']
        elif self.opera_rb.isChecked():
            self.browser = 'Opera'
            args = ['deinstall', 'opera']
        elif self.edge_rb.isChecked():
            self.browser = 'Microsoft Edge'
            args = ['deinstall', 'edge']
        self.proc.finished.connect(self.cmd_finished)
        os.chdir(PATH_LBI_DIR)
        self.proc.start('./linux-browser-installer', args)
        self.statusBar().showMessage(self.tr('Deinstalling ...'), -1)

    def upgrade(self):
        self.prepare_proc()
        self.action = self.upgrade
        if not os.path.exists(PATH_LBI_DIR):
            self.clone_repo()
            return
        self.proc.finished.connect(self.cmd_finished)
        os.chdir(PATH_LBI_DIR)
        self.proc.start('./linux-browser-installer', ['jail', 'upgrade'])
        self.statusBar().showMessage(self.tr('Upgrading ...'), -1)

    def update_buttons(self):
        can_install = can_deinstall = False
        if self.brave_rb.isChecked():
            if os.path.exists('/compat/ubuntu/bin/brave'):
                can_deinstall = True
            else:
                can_install = True
        elif self.chrome_rb.isChecked():
            if os.path.exists('/compat/ubuntu/bin/chrome'):
                can_deinstall = True
            else:
                can_install = True
        elif self.vivaldi_rb.isChecked():
            if os.path.exists('/compat/ubuntu/bin/vivaldi'):
                can_deinstall = True
            else:
                can_install = True
        elif self.opera_rb.isChecked():
            if os.path.exists('/compat/ubuntu/bin/opera'):
                can_deinstall = True
            else:
                can_install = True
        elif self.edge_rb.isChecked():
            if os.path.exists('/compat/ubuntu/bin/edge'):
                can_deinstall = True
            else:
                can_install = True
        if (os.path.exists('/compat/ubuntu/bin/brave') or
           os.path.exists('/compat/ubuntu/bin/chrome') or
           os.path.exists('/compat/ubuntu/bin/vivaldi') or
           os.path.exists('/compat/ubuntu/bin/edge') or
           os.path.exists('/compat/ubuntu/bin/opera')):
            self.upgrade_bt.setEnabled(True)
        else:
            self.upgrade_bt.setEnabled(False)
        self.install_bt.setEnabled(can_install)
        self.deinstall_bt.setEnabled(can_deinstall)

    def disable_buttons(self):
        self.chrome_rb.setEnabled(False)
        self.brave_rb.setEnabled(False)
        self.quit_bt.setEnabled(False)
        self.cancel_bt.setEnabled(True)
        self.install_bt.setEnabled(False)
        self.deinstall_bt.setEnabled(False)
        self.chrome_rb.setEnabled(False)
        self.brave_rb.setEnabled(False)
        self.vivaldi_rb.setEnabled(False)
        self.opera_rb.setEnabled(False)
        self.edge_rb.setEnabled(False)
        self.upgrade_bt.setEnabled(False)

    def show_output(self, data):
        self.output.moveCursor(QTextCursor.MoveOperation.End)
        self.output.insertPlainText(bytes(data).decode('utf-8'))
        self.output.moveCursor(QTextCursor.MoveOperation.End)

    def read_stdout(self):
        self.show_output(self.proc.readAllStandardOutput())

    def read_stderr(self):
        self.show_output(self.proc.readAllStandardError())

    def cmd_finished(self, exitCode, exitStatus):
        if exitCode != 0:
            self.xerrx(
                1, self.tr('Error'),
                self.tr('Command "{}" exited with error code {}')
                    .format(self.proc.program(), exitCode)
            )
        self.statusBar().showMessage(self.tr('Done'), -1)
        if self.action == self.install:
            msg = self.tr('Installation of {} finished').format(self.browser)
        elif self.action == self.deinstall:
            msg = self.tr('Deinstallation of {} finished').format(self.browser)
        elif self.action == self.upgrade:
            msg = self.tr('Upgrade finished')
        else:
            msg = self.tr('Command finished')
        self.msgwin(self.tr('Finished'), msg)
        self.reset()

    def git_finished(self, exitCode, exitStatus):
        if exitCode != 0:
            self.xerrx(
                1, self.tr('Error'),
                self.tr('Command {} exited with error code {}')
                    .format(self.proc.program(), exitCode)
            )
        self.proc.disconnect()
        self.action()

    def cancel_cmd(self):
        self.proc.terminate()
        self.proc.disconnect()
        self.reset()
        self.statusBar().showMessage(self.tr('Canceled'), -1)

    def reset(self):
        self.chrome_rb.setEnabled(True)
        self.brave_rb.setEnabled(True)
        self.vivaldi_rb.setEnabled(True)
        self.opera_rb.setEnabled(True)
        self.edge_rb.setEnabled(True)
        self.quit_bt.setEnabled(True)
        self.cancel_bt.setEnabled(False)
        self.update_buttons()

    def quit(self):
        sys.exit(0)


def main():
    app = QApplication(sys.argv)
    QCoreApplication.setApplicationName(PROGRAM)
    os.environ['RESOURCE_NAME'] = PROGRAM
    translator = QTranslator()
    if translator.load(QLocale(), PROGRAM, '_', LOCALE_PATH):
        app.installTranslator(translator)
    win = MainWindow()
    if os.getuid() != 0:
        win.xerrx(
            1, win.tr('Error'), win.tr('You must be root to run this program')
        )
    win.show()
    sys.exit(app.exec())


if __name__ == '__main__':
    main()