gitpane 1.0.0__py3-none-any.whl

gitpane/ui/sequencer/rebase_editor_window.py

@@ -0,0 +1,220 @@
+"""Show one rebase edit Git waits for until the user continues, saves or aborts it."""
+
+from __future__ import annotations
+
+from enum import Enum
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import Qt, Signal
+from PySide6.QtGui import QFontDatabase, QKeySequence, QPalette, QShortcut
+from PySide6.QtWidgets import QApplication, QDialog, QHBoxLayout, QMessageBox, QPlainTextEdit, QPushButton, QVBoxLayout, QWidget
+from shiboken6 import isValid
+
+from gitpane.config import DARK_BACKGROUND_LIGHTNESS_LIMIT, ERROR_DARK_COLOR, ERROR_LIGHT_COLOR, LINE_SEPARATOR, OPERATION_HEIGHT, OPERATION_WIDTH
+from gitpane.recent.recent_name import repository_display_name
+from gitpane.tool.editor import EditorRequestKind
+from gitpane.ui.look.theme_look import follow_theme
+from gitpane.ui.widget.long_text import WrappingLabel
+from gitpane.ui.widget.numbered_text_edit import NumberedTextEdit
+from gitpane.ui.widget.system_shortcut import EDITOR_SAVE_SHORTCUTS, EDITOR_VALIDATE_SHORTCUTS
+from gitpane.ui.window_control.dialog_modality import open_window_modal, prepare_message_box
+
+if TYPE_CHECKING:
+    from PySide6.QtCore import QRect
+
+
+class RebaseEditorText(Enum):
+    """Texts the rebase editor window shows, one member per text so a misspelt name is an error."""
+
+    CONTINUE = "Continue"
+    SAVE = "Save"
+    ABORT = "Abort"
+    ABORT_QUESTION_TITLE = "Abort the rebase?"
+    ABORT_QUESTION = "Abort the whole rebase and go back to where it started?"
+    ABORT_REBASE = "Abort rebase"
+    KEEP_EDITING = "Keep editing"
+    EMPTY_MESSAGE = "Commit message cannot be empty"
+    SAVE_FAILED = "Could not save the file: {cause}"
+    READ_FAILED = "GitPane cannot read the file Git is waiting for. {button} hands it back unchanged. {cause}"
+    ENCODING_FAILED = "the text cannot be written in the file's encoding"
+    # The cause shown if a write ends with neither a written file nor an error, which the write function never does.
+    WRITE_GAVE_NO_RESULT = "the write gave no result"
+    # The windows are not modal, so the folder of the repository tells apart the editors of two repositories.
+    WINDOW_TITLE = "{kind} — {repository}"
+
+
+class EditorValidation(Enum):
+    """What the validating button of the window does: hand the text to Git so the rebase goes on, or save it while the rebase stays paused."""
+
+    CONTINUE = "continue"
+    SAVE = "save"
+
+    @property
+    def label(self) -> str:
+        """Answer the text of the validating button."""
+        return (RebaseEditorText.CONTINUE if self == EditorValidation.CONTINUE else RebaseEditorText.SAVE).value
+
+
+class RebaseEditorWindow(QDialog):
+    """Edit the text of one file Git waits for, as Git wrote it, until the user answers with the validating button or Abort.
+
+    The window is never modal: the user can read the graph of the repository while editing. Its close button and
+    Escape ask before aborting the whole rebase, so neither can leave Git waiting without a window nor abort by mistake.
+    """
+
+    validate_requested = Signal()
+    save_requested = Signal()
+    abort_requested = Signal()
+
+    def __init__(self, kind: EditorRequestKind, validation: EditorValidation, text: str, repository_dir: str, parent: QWidget | None = None) -> None:
+        """Show Git's text in a numbered fixed-width editor, under a hidden context header, above a hidden error line and the two answer buttons.
+
+        The title names the kind of edit and the repository folder, so the editors of two repositories are told apart.
+        """
+        super().__init__(parent)
+        self.kind = kind
+        self.validation = validation
+        self.answered = False
+        self.busy = False
+        self.abort_question: QMessageBox | None = None
+        self.setWindowTitle(RebaseEditorText.WINDOW_TITLE.value.format(kind=kind.window_title, repository=repository_display_name(repository_dir)))
+        self.resize(OPERATION_WIDTH, OPERATION_HEIGHT)
+        layout = QVBoxLayout(self)
+        self.context_label = WrappingLabel()
+        self.context_label.setWordWrap(True)
+        self.context_label.hide()
+        layout.addWidget(self.context_label)
+        self.text_edit = NumberedTextEdit()
+        self.text_edit.setAccessibleName(kind.window_title)
+        # Monochrome on purpose: the user chose plain fixed-width text over coloured commands and dimmed comments.
+        self.text_edit.setFont(QFontDatabase.systemFont(QFontDatabase.SystemFont.FixedFont))
+        # An instruction stays on one visual line, as Git reads it; a message wraps in the window without adding a line to the text.
+        wrap_mode = QPlainTextEdit.LineWrapMode.NoWrap if kind == EditorRequestKind.SEQUENCE else QPlainTextEdit.LineWrapMode.WidgetWidth
+        self.text_edit.setLineWrapMode(wrap_mode)
+        self.text_edit.setPlainText(text)
+        layout.addWidget(self.text_edit, 1)
+        self.error_label = WrappingLabel()
+        self.error_label.setWordWrap(True)
+        self.error_label.hide()
+        layout.addWidget(self.error_label)
+        button_row = QHBoxLayout()
+        button_row.addStretch(1)
+        self.validate_button = QPushButton(validation.label)
+        self.validate_button.clicked.connect(self.validate_requested)
+        self.abort_button = QPushButton(RebaseEditorText.ABORT.value)
+        self.abort_button.clicked.connect(self.abort_requested)
+        for button in (self.validate_button, self.abort_button):
+            # Enter must never trigger Abort or Continue from the text; each command stays an explicit click or Space on its focused button.
+            button.setAutoDefault(False)
+            button_row.addWidget(button)
+        layout.addLayout(button_row)
+        for sequence in EDITOR_VALIDATE_SHORTCUTS:
+            validate_shortcut = QShortcut(QKeySequence(sequence), self)
+            validate_shortcut.setContext(Qt.ShortcutContext.WindowShortcut)
+            validate_shortcut.activated.connect(self.press_validate_button)
+        for sequence in EDITOR_SAVE_SHORTCUTS:
+            save_shortcut = QShortcut(QKeySequence(sequence), self)
+            save_shortcut.setContext(Qt.ShortcutContext.WindowShortcut)
+            save_shortcut.activated.connect(self.ask_save)
+        self.refresh_metrics()
+        follow_theme(self, self.refresh_metrics)
+
+    def edited_text(self) -> str:
+        """Answer the text as Git must read it back, with line feeds between lines and nothing else changed."""
+        return self.text_edit.raw_text()
+
+    def press_validate_button(self) -> None:
+        """Press the validating button from the keyboard, as a click would, unless a write already runs."""
+        if self.validate_button.isEnabled():
+            self.validate_button.click()
+
+    def ask_save(self) -> None:
+        """Ask for the text to be saved without answering Git, unless a write already runs."""
+        if not self.busy:
+            self.save_requested.emit()
+
+    def show_context(self, lines: tuple[str, ...]) -> None:
+        """Show the repository and the commits an edit is about above the text, or hide the header when there is nothing to show."""
+        self.context_label.setText(LINE_SEPARATOR.join(lines))
+        self.context_label.setVisible(bool(lines))
+
+    def show_error(self, text: str) -> None:
+        """Show a problem above the buttons, or hide the line when there is none."""
+        self.error_label.setText(text)
+        self.error_label.setVisible(bool(text))
+
+    def set_busy(self, busy: bool) -> None:
+        """Disable both answers and the shortcuts while the text is being written, so a second request cannot answer twice."""
+        self.busy = busy
+        self.validate_button.setEnabled(not busy)
+        self.abort_button.setEnabled(not busy)
+
+    def set_read_only(self, reason: str) -> None:
+        """Keep the text visible but not editable, saying why; the answers stay available."""
+        self.text_edit.setReadOnly(True)
+        self.show_error(reason)
+
+    def present(self) -> None:
+        """Show the window in front of the repository window with the keyboard in its text, without blocking the other windows."""
+        self.show()
+        self.raise_()
+        self.activateWindow()
+        self.text_edit.setFocus()
+
+    def close_after_answer(self) -> None:
+        """Close the window once Git has its answer, or once the request is gone, without any question; an open question closes with it.
+
+        Called again on a closed window, it does nothing, so the window reports its end once.
+        """
+        self.answered = True
+        question = self.abort_question
+        if question is not None and isValid(question):
+            question.close()
+        if self.isVisible():
+            QDialog.reject(self)
+
+    def reject(self) -> None:
+        """Ask before aborting the whole rebase when the user closes the window or presses Escape.
+
+        Qt closes a dialog through this method, from its close button as from Escape. Keep editing is the default and
+        the answer of Escape, so a second Escape never aborts; a question already open is brought back instead of a second one.
+        """
+        if self.answered:
+            QDialog.reject(self)
+            return
+        question = self.abort_question
+        if question is not None and isValid(question):
+            question.raise_()
+            question.activateWindow()
+            return
+        box = QMessageBox(QMessageBox.Icon.Warning, RebaseEditorText.ABORT_QUESTION_TITLE.value, RebaseEditorText.ABORT_QUESTION.value, parent=self)
+        prepare_message_box(box, RebaseEditorText.ABORT_QUESTION_TITLE.value)
+        box.setTextFormat(Qt.TextFormat.PlainText)
+        abort_rebase_button = box.addButton(RebaseEditorText.ABORT_REBASE.value, QMessageBox.ButtonRole.DestructiveRole)
+        keep_editing_button = box.addButton(RebaseEditorText.KEEP_EDITING.value, QMessageBox.ButtonRole.RejectRole)
+        box.setDefaultButton(keep_editing_button)
+        box.setEscapeButton(keep_editing_button)
+        self.abort_question = box
+
+        def finished() -> None:
+            """Abort only on an explicit Abort rebase while Git still waits; any other ending keeps the window and its text."""
+            self.abort_question = None
+            aborted = box.clickedButton() is abort_rebase_button and not self.answered
+            box.deleteLater()
+            if aborted:
+                self.abort_requested.emit()
+
+        box.finished.connect(finished)
+        open_window_modal(box)
+
+    def refresh_metrics(self, available: QRect | None = None) -> None:
+        """Keep the error line readable on light and dark backgrounds, again after each switch of appearance.
+
+        The choice is read on the application palette: at a palette notice, the window's own palette can still be the
+        previous one.
+        """
+        dark = QApplication.palette().color(QPalette.ColorRole.Window).lightnessF() < DARK_BACKGROUND_LIGHTNESS_LIMIT
+        color = ERROR_DARK_COLOR if dark else ERROR_LIGHT_COLOR
+        error_style = f"color: {color}; font-weight: bold;"
+        if self.error_label.styleSheet() != error_style:
+            self.error_label.setStyleSheet(error_style)

gitpane/ui/sequencer/replay_conflict_prompt.py

@@ -0,0 +1,105 @@
+"""Ask whether to resolve the conflicts of a paused Cherry-pick or Revert right away."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import Qt, Signal
+from PySide6.QtWidgets import QDialog, QHBoxLayout, QLabel, QPushButton, QStyle, QVBoxLayout
+
+from gitpane.ui.look.theme_look import follow_theme
+from gitpane.ui.widget.dialog_layout import (
+    MESSAGE_BOX_BODY_MARGINS,
+    MESSAGE_BOX_BUTTON_BAND,
+    MESSAGE_BOX_BUTTON_SIZE,
+    MESSAGE_BOX_ICON_SIDE,
+    MESSAGE_BOX_ICON_TO_TEXT_SPACE,
+    BandButtonSizing,
+    install_banded_layout,
+)
+
+if TYPE_CHECKING:
+    from PySide6.QtGui import QKeyEvent
+    from PySide6.QtWidgets import QWidget
+
+CONFLICT_PROMPT_TITLE = "Merge conflicts"
+CONFLICT_PROMPT_TEXT = "There are unresolved merge conflicts, solve conflicts now?"
+# A Windows message box answers Y and N directly (with or without Alt) and shows no underlined letters, so the dialog
+# handles these keys itself instead of using mnemonics.
+YES_KEY, NO_KEY = Qt.Key.Key_Y, Qt.Key.Key_N
+ANSWER_MODIFIER_SET = {Qt.KeyboardModifier.NoModifier, Qt.KeyboardModifier.AltModifier}
+
+
+class ReplayConflictPrompt(QDialog):
+    """Offer an explicit Yes/No choice that never blocks the repository window.
+
+    A dedicated dialog rather than a QMessageBox keeps the Yes contract explicit (one signal, emitted once)
+    instead of comparing the finished() code with a button enumeration, and leaves room for a custom layout.
+    No, Escape and the title-bar close all leave the operation paused.
+    """
+
+    resolve_requested = Signal()
+
+    def __init__(self, parent: QWidget | None = None) -> None:
+        """Build the non-modal prompt with Yes as the default answer."""
+        super().__init__(parent)
+        self.resolve_emitted = False
+        self.setWindowTitle(CONFLICT_PROMPT_TITLE)
+        self.setWindowModality(Qt.WindowModality.NonModal)
+        # Like a Windows message box, the title bar has only the close button: without the system menu hint Windows
+        # shows no window icon, and there is no help button. The customize hint stops Qt from adding its default hints.
+        self.setWindowFlags(Qt.WindowType.Dialog | Qt.WindowType.CustomizeWindowHint | Qt.WindowType.WindowTitleHint | Qt.WindowType.WindowCloseButtonHint)
+        layout = QVBoxLayout()
+        layout.setSpacing(0)
+        message_row = QHBoxLayout()
+        message_row.setSpacing(MESSAGE_BOX_ICON_TO_TEXT_SPACE)
+        self.icon_label = QLabel()
+        self.apply_theme_look()
+        self.icon_label.setFixedSize(MESSAGE_BOX_ICON_SIDE, MESSAGE_BOX_ICON_SIDE)
+        message_row.addWidget(self.icon_label)
+        self.text_label = QLabel(CONFLICT_PROMPT_TEXT)
+        # The question is one short fixed sentence; like a message box it reads on a single line instead of wrapping
+        # into the narrow width a word-wrapped label proposes.
+        self.text_label.setTextFormat(Qt.TextFormat.PlainText)
+        self.text_label.setAlignment(Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter)
+        message_row.addWidget(self.text_label, 1)
+        layout.addLayout(message_row)
+        self.yes_button = QPushButton("Yes")
+        self.yes_button.setFixedSize(MESSAGE_BOX_BUTTON_SIZE)
+        self.no_button = QPushButton("No")
+        self.no_button.setFixedSize(MESSAGE_BOX_BUTTON_SIZE)
+        self.no_button.setAutoDefault(False)
+        # Like the Git Extensions message box: the question on a white body, Yes and No on the grey area below it.
+        self.button_band = install_banded_layout(self, layout, [self.yes_button, self.no_button], MESSAGE_BOX_BUTTON_BAND, MESSAGE_BOX_BODY_MARGINS, button_sizing=BandButtonSizing.WINDOW)
+        follow_theme(self, self.apply_theme_look)
+        # Set once Yes belongs to the dialog, so Qt keeps it as the main default when the focus moves.
+        self.yes_button.setDefault(True)
+        self.yes_button.clicked.connect(self._answer_yes)
+        self.no_button.clicked.connect(self.reject)
+        # No explicit resize or move here: Qt sizes the dialog to its content when it is first shown, and the shared
+        # new-window placement then centres that final frame on the repository window. Fitting the geometry before the
+        # first show froze a stale size instead of the message-box shape.
+
+    def apply_theme_look(self) -> None:
+        """Show the question icon the style gives for the current appearance; laid again after a light/dark switch.
+
+        The style redraws a question icon that cannot be read on a dark window, so the icon of one appearance is not the
+        icon of the other. It is asked for the application palette, which already holds the new colors at a switch.
+        """
+        self.icon_label.setPixmap(self.style().standardIcon(QStyle.StandardPixmap.SP_MessageBoxQuestion).pixmap(MESSAGE_BOX_ICON_SIDE, MESSAGE_BOX_ICON_SIDE))
+
+    def keyPressEvent(self, event: QKeyEvent) -> None:
+        """Answer Yes on Y and No on N, as a Windows message box does; other keys keep the dialog behavior."""
+        button_by_key = {YES_KEY: self.yes_button, NO_KEY: self.no_button}
+        button = button_by_key.get(event.key())
+        if button is None or event.modifiers() not in ANSWER_MODIFIER_SET:
+            super().keyPressEvent(event)
+            return
+        button.click()
+
+    def _answer_yes(self) -> None:
+        """Request resolution at most once, then close the prompt."""
+        if not self.resolve_emitted:
+            self.resolve_emitted = True
+            self.resolve_requested.emit()
+        self.accept()