client/securedrop_client/gui/conversation/export/export_wizard.py

import logging
from gettext import gettext as _

from PyQt5.QtCore import QSize, Qt, pyqtSlot
from PyQt5.QtGui import QIcon, QKeyEvent
from PyQt5.QtWidgets import (
    QAbstractButton,
    QApplication,
    QWidget,
    QWizard,
    QWizardPage,
)

from securedrop_client.export import Export
from securedrop_client.export_status import ExportStatus
from securedrop_client.gui.base import SecureQLabel
from securedrop_client.gui.conversation.export.export_wizard_constants import Pages
from securedrop_client.gui.conversation.export.export_wizard_page import (
    ErrorPage,
    ExportWizardPage,
    FinalPage,
    InsertUSBPage,
    PassphraseWizardPage,
    PreflightPage,
)
from securedrop_client.resources import load_movie, load_relative_css

logger = logging.getLogger(__name__)


class ExportWizard(QWizard):
    """
    Guide user through the steps of exporting to a USB.
    """

    PASSPHRASE_LABEL_SPACING = 0.5
    NO_MARGIN = 0
    FILENAME_WIDTH_PX = 260
    FILE_OPTIONS_FONT_SPACING = 1.6

    # If the drive is unlocked, we don't need a passphrase; if we do need one,
    # it's populated later.
    PASS_PLACEHOLDER_FIELD = ""

    def __init__(
        self,
        export: Export,
        summary_text: str,
        filepaths: list[str],
        parent: QWidget | None = None,
    ) -> None:
        # Normally, the active window is the right parent, but if the wizard is launched
        # via another element (a modal dialog, such as the "Some files may not be exported"
        # modal), the parent will be the modal dialog and the wizard layout will be affected.
        # In those cases we want to be able to specify a different parent.
        if not parent:
            parent = QApplication.activeWindow()
        super().__init__(parent)
        self.export = export
        self.summary_text = SecureQLabel(
            summary_text, wordwrap=False, max_length=self.FILENAME_WIDTH_PX
        ).text()
        self.filepaths = filepaths
        self.current_status: ExportStatus | None = None

        # Signal from qrexec command runner
        self.export.export_state_changed.connect(self.on_status_received)

        # Sends cleanup signal to export if wizard is closed or completed.
        # (Avoid orphaned QProcess)
        self.finished.connect(self.export.end_process)

        self._style_buttons()
        self._set_layout()
        self._set_pages()
        self.adjustSize()

    def keyPressEvent(self, event: QKeyEvent) -> None:
        """
        Allow for keyboard navigation of wizard buttons.
        """
        if event.key() == Qt.Key_Enter or event.key() == Qt.Key_Return:
            if self.cancel_button.hasFocus():
                self.cancel_button.click()
            elif self.back_button.hasFocus():
                self.back_button.click()
            else:
                self.next_button.click()
        else:
            super().keyPressEvent(event)

    def _style_buttons(self) -> None:
        """
        Style QWizard buttons and connect "Next" button click event to
        request_export slot.
        """
        # Activestate animation
        self.button_animation = load_movie("activestate-wide.gif")
        self.button_animation.setScaledSize(QSize(32, 32))
        self.button_animation.frameChanged.connect(self._animate_activestate)
        button_stylesheet = load_relative_css(__file__, "wizard_button.css")

        # Buttons
        self.next_button: QAbstractButton = self.button(QWizard.WizardButton.NextButton)
        self.cancel_button: QAbstractButton = self.button(QWizard.WizardButton.CancelButton)
        self.back_button: QAbstractButton = self.button(QWizard.WizardButton.BackButton)
        self.finish_button: QAbstractButton = self.button(QWizard.WizardButton.FinishButton)

        self.next_button.setObjectName("QWizardButton_PrimaryButton")
        self.next_button.setStyleSheet(button_stylesheet)
        self.next_button.setMinimumSize(QSize(142, 40))
        self.next_button.setMaximumHeight(40)
        self.next_button.setIconSize(QSize(21, 21))
        self.next_button.clicked.connect(self.request_export)
        self.next_button.setFixedSize(QSize(142, 40))

        self.cancel_button.setObjectName("QWizardButton_GenericButton")
        self.cancel_button.setStyleSheet(button_stylesheet)
        self.cancel_button.setMinimumSize(QSize(142, 40))
        self.cancel_button.setMaximumHeight(40)
        self.cancel_button.setFixedSize(QSize(142, 40))

        self.back_button.setObjectName("QWizardButton_GenericButton")
        self.back_button.setStyleSheet(button_stylesheet)
        self.back_button.setMinimumSize(QSize(142, 40))
        self.back_button.setMaximumHeight(40)
        self.back_button.setFixedSize(QSize(142, 40))

        self.finish_button.setObjectName("QWizardButton_GenericButton")
        self.finish_button.setStyleSheet(button_stylesheet)
        self.finish_button.setMinimumSize(QSize(142, 40))
        self.finish_button.setMaximumHeight(40)
        self.finish_button.setFixedSize(QSize(142, 40))

        self.setButtonText(QWizard.WizardButton.NextButton, _("CONTINUE"))
        self.setButtonText(QWizard.WizardButton.CancelButton, _("CANCEL"))
        self.setButtonText(QWizard.WizardButton.FinishButton, _("DONE"))
        self.setButtonText(QWizard.WizardButton.BackButton, _("BACK"))

    def _animate_activestate(self) -> None:
        self.next_button.setIcon(QIcon(self.button_animation.currentPixmap()))

    def _start_animate_activestate(self) -> None:
        self.button_animation.start()

    def _stop_animate_activestate(self) -> None:
        self.next_button.setIcon(QIcon())
        self.button_animation.stop()

    def _set_layout(self) -> None:
        title = f"Export {self.summary_text}"
        self.setWindowTitle(title)
        self.setObjectName("QWizard_export")
        self.setStyleSheet(load_relative_css(__file__, "wizard.css"))
        self.setModal(False)
        self.setOptions(
            QWizard.NoBackButtonOnLastPage
            | QWizard.NoCancelButtonOnLastPage
            | QWizard.NoBackButtonOnStartPage
        )

    def _set_pages(self) -> None:
        for id, page in [
            (Pages.PREFLIGHT, self._create_preflight()),
            (Pages.ERROR, self._create_errorpage()),
            (Pages.INSERT_USB, self._create_insert_usb()),
            (Pages.UNLOCK_USB, self._create_passphrase_prompt()),
            (Pages.EXPORT_DONE, self._create_done()),
        ]:
            self.setPage(id, page)
            self.adjustSize()

    @pyqtSlot()
    def request_export(self) -> None:
        """
        Handler for "next" button clicks. Start animation and request export.
        (The export proceeds only as far as it's able, which is why it's
        possible to trigger the same method on every dialog page).

        The Preflight QWizardPage triggers the preflight check itself when
        it is created, so there is no corresponding `request_export_preflight`
        method.
        """
        logger.debug("Request export")
        # While we're waiting for the results to come back, stay on the same page.
        # This prevents the dialog from briefly flashing one page and then
        # advancing to a subsequent page (for example, flashing the "Insert a USB"
        # page before detecting the USB and advancing to the "Unlock USB" page)
        page = self.currentPage()
        if isinstance(page, ExportWizardPage):
            page.set_complete(False)
        self._start_animate_activestate()

        # Disable the continue button until the qProcess completes
        self.next_button.setEnabled(False)

        # Registered fields let us access the passphrase field
        # of the PassphraseRequestPage from the wizard parent
        passphrase_untrusted = self.field("passphrase")
        if str(passphrase_untrusted) is not None:
            self.export.export(self.filepaths, str(passphrase_untrusted))
        else:
            self.export.export(self.filepaths, self.PASS_PLACEHOLDER_FIELD)

    @pyqtSlot(object)
    def on_status_received(self, status: ExportStatus) -> None:
        """
        Receive status update from export process in order to update the animation.
        Child QWizardPages also implement this listener in order to update their own UI and store
        a reference to the current status.

        Adjusting the QWizard control flow based on ExportStatus is handled by each child page.
        """
        # Release the page (page was held during "next" button click event)
        page = self.currentPage()
        if isinstance(page, ExportWizardPage):
            page.set_complete(True)
        self._stop_animate_activestate()
        self.current_status = status

        # Button was disabled when the previous request was made; re-enable it
        self.next_button.setEnabled(True)

    def _create_preflight(self) -> QWizardPage:
        return PreflightPage(self.export, self.summary_text)

    def _create_errorpage(self) -> QWizardPage:
        return ErrorPage(self.export)

    def _create_insert_usb(self) -> QWizardPage:
        return InsertUSBPage(self.export, self.summary_text)

    def _create_passphrase_prompt(self) -> QWizardPage:
        return PassphraseWizardPage(self.export)

    def _create_done(self) -> QWizardPage:
        return FinalPage(self.export)