gitpane 1.0.0__py3-none-any.whl

gitpane/ui/look/windows_control_look.py

@@ -0,0 +1,250 @@
+"""Give the controls of the reproduced Git Extensions windows the look Windows 10 gives them in a light theme.
+
+A dark palette keeps the native Fusion controls: the colours below were sampled on light captures and would glare on a
+dark desktop.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from PySide6.QtGui import QColor, QPalette
+from PySide6.QtWidgets import QApplication, QFrame
+
+from gitpane.ui.look.theme_color import is_dark_palette, theme_line_color
+from gitpane.ui.look.theme_palette import BODY_LIGHT_COLOR, WINDOWS_CONTROL_LIGHT_COLOR
+
+if TYPE_CHECKING:
+    from PySide6.QtWidgets import QComboBox, QLabel, QLineEdit, QPlainTextEdit, QPushButton, QWidget
+
+# Windows 10 push buttons as the Git Extensions windows show them: grey face and border, and a two-pixel accent frame on
+# the default button (all sampled on the captures). Hover, pressed and disabled states are the system's own colors.
+WINDOWS_BUTTON_FACE_COLOR = "#e1e1e1"
+WINDOWS_BUTTON_BORDER_COLOR = "#adadad"
+WINDOWS_BUTTON_TEXT_COLOR = "#000000"
+WINDOWS_BUTTON_BORDER_WIDTH = 1
+WINDOWS_DEFAULT_BUTTON_BORDER_COLOR = "#0078d7"
+WINDOWS_DEFAULT_BUTTON_BORDER_WIDTH = 2
+WINDOWS_BUTTON_HOVER_FACE_COLOR = "#e5f1fb"
+WINDOWS_BUTTON_PRESSED_FACE_COLOR = "#cce4f7"
+WINDOWS_BUTTON_PRESSED_BORDER_COLOR = "#005499"
+WINDOWS_BUTTON_DISABLED_FACE_COLOR = "#cccccc"
+WINDOWS_BUTTON_DISABLED_BORDER_COLOR = "#bfbfbf"
+# Windows' grey text (SystemColors.GrayText): disabled button captions and secondary text such as the "-13" commit
+# counter beside a revision field.
+WINDOWS_GRAY_TEXT_COLOR = "#6d6d6d"
+WINDOWS_BUTTON_DISABLED_TEXT_COLOR = WINDOWS_GRAY_TEXT_COLOR
+# Visible height of a Windows 10 single-line text field in the Git Extensions captures, border included.
+WINDOWS_EDIT_HEIGHT = 23
+# Height of the Segoe UI 9 pt text line the captures were taken with. A field keeps the captures' room around a taller
+# line, so a larger system text size makes the fields and their buttons taller instead of cutting the text.
+WINDOWS_CAPTURE_TEXT_HEIGHT = 16
+# Windows 10 text fields: one-pixel grey border, the accent border while focused, a light grey one when disabled.
+WINDOWS_EDIT_BORDER_COLOR = "#7a7a7a"
+WINDOWS_EDIT_DISABLED_BORDER_COLOR = "#cccccc"
+WINDOWS_EDIT_BORDER_WIDTH = 1
+# Border of the Windows 10 multi-line text box, as the message area of an annotated tag shows it in Git Extensions.
+WINDOWS_MESSAGE_BORDER_COLOR = "#646464"
+# Border of the Windows 10 list boxes, sampled on the merge parent list of Cherry pick commit and on the check box list of
+# Select multiple branches.
+WINDOWS_LIST_BORDER_LIGHT_COLOR = "#828790"
+# Windows 10 list boxes have a one-pixel border.
+WINDOWS_LIST_BORDER_WIDTH = 1
+# Share of the way from the text color to the background color for secondary text on a dark palette: visibly paler than
+# the main text, and still readable on the background.
+SECONDARY_TEXT_DARK_BLEND_RATIO = 0.35
+# Room between a push button's text and each side of its frame when the button grows with its text: the padding of the
+# native Fusion button, whose width is its text plus 14 px (a 1 px border and 6 px of padding on each side), as the
+# question windows show it. Without it, a style-sheeted button is only as wide as its text and the text touches the frame.
+BUTTON_TEXT_SIDE_PADDING = 6
+# Space between a drop-down list's border and its text: the Create tag capture writes the type from 4 px inside the list.
+WINDOWS_COMBO_TEXT_PADDING = 3
+
+
+def plain_form_color(palette: QPalette) -> QColor:
+    """Return the background of the Git Extensions windows that have no button band: Windows' control grey in a light theme.
+
+    Those windows are one grey surface carrying their fields and buttons. A dark palette keeps its own window color,
+    by the same light or dark rule as the banded windows, so a dark desktop never gets the light grey.
+    """
+    if is_dark_palette(palette):
+        return palette.color(QPalette.ColorRole.Window)
+    return QColor(WINDOWS_CONTROL_LIGHT_COLOR)
+
+
+def windows_button_style_sheet(text_side_padding: int = 0) -> str:
+    """Return the style sheet that draws a push button like a Windows 10 one, the look of the Git Extensions windows.
+
+    Only the button's own frame and face are styled; a push button has no child widget the sheet could also reach.
+    ``text_side_padding`` is the room kept between the text and the left and right sides of the frame: none for a
+    button sized from a capture, ``BUTTON_TEXT_SIDE_PADDING`` for one that grows with its text.
+    """
+    return (f"QPushButton {{ background-color: {WINDOWS_BUTTON_FACE_COLOR}; color: {WINDOWS_BUTTON_TEXT_COLOR}; padding: 0px {text_side_padding}px;"
+            f" border: {WINDOWS_BUTTON_BORDER_WIDTH}px solid {WINDOWS_BUTTON_BORDER_COLOR}; }}"
+            f" QPushButton:default {{ border: {WINDOWS_DEFAULT_BUTTON_BORDER_WIDTH}px solid {WINDOWS_DEFAULT_BUTTON_BORDER_COLOR}; }}"
+            f" QPushButton:hover {{ background-color: {WINDOWS_BUTTON_HOVER_FACE_COLOR}; border-color: {WINDOWS_DEFAULT_BUTTON_BORDER_COLOR}; }}"
+            f" QPushButton:pressed {{ background-color: {WINDOWS_BUTTON_PRESSED_FACE_COLOR}; border-color: {WINDOWS_BUTTON_PRESSED_BORDER_COLOR}; }}"
+            f" QPushButton:disabled {{ background-color: {WINDOWS_BUTTON_DISABLED_FACE_COLOR}; color: {WINDOWS_BUTTON_DISABLED_TEXT_COLOR};"
+            f" border: {WINDOWS_BUTTON_BORDER_WIDTH}px solid {WINDOWS_BUTTON_DISABLED_BORDER_COLOR}; }}")
+
+
+def apply_windows_button_look(button: QPushButton, text_side_padding: int = 0) -> None:
+    """Draw a button like the Windows 10 buttons of the Git Extensions windows in a light theme, the native one in a dark theme.
+
+    A dark palette keeps the native Fusion button, which already derives its face, frame and default outline from the
+    palette; the Windows colors are light-theme colors and would glare on a dark desktop, so a sheet laid in light is
+    taken off. The choice follows the application palette, never the button's, which its own sheet changes. Calling it
+    again, at any theme switch, gives the same result. ``text_side_padding`` goes to ``windows_button_style_sheet``; the
+    native dark button keeps its own padding.
+    """
+    if is_dark_palette(QApplication.palette()):
+        button.setStyleSheet("")
+        return
+    button.setStyleSheet(windows_button_style_sheet(text_side_padding))
+
+
+def windows_line_edit_style_sheet() -> str:
+    """Return the style sheet that draws a single-line text field like a Windows 10 one, as the Git Extensions forms show it."""
+    return (f"QLineEdit {{ background-color: {BODY_LIGHT_COLOR}; border: {WINDOWS_EDIT_BORDER_WIDTH}px solid {WINDOWS_EDIT_BORDER_COLOR}; }}"
+            f" QLineEdit:focus {{ border-color: {WINDOWS_DEFAULT_BUTTON_BORDER_COLOR}; }}"
+            f" QLineEdit:disabled {{ background-color: {WINDOWS_CONTROL_LIGHT_COLOR}; border-color: {WINDOWS_EDIT_DISABLED_BORDER_COLOR}; }}")
+
+
+def windows_field_height(widget: QWidget) -> int:
+    """Return the height of a control on a field row: the captures' height, taller by as much as its text line is taller than theirs.
+
+    It is measured on the font rather than on the style's size hint, so the default text size gives exactly the
+    captures' height in both themes (the dark Fusion frame asks for one more pixel), while a larger system text size
+    never cuts the text.
+    """
+    return WINDOWS_EDIT_HEIGHT + max(0, widget.fontMetrics().height() - WINDOWS_CAPTURE_TEXT_HEIGHT)
+
+
+def fit_windows_field_height(widget: QWidget) -> None:
+    """Give a field-row control the height of ``windows_field_height`` for its current font; call it again after a font change."""
+    widget.setFixedHeight(windows_field_height(widget))
+
+
+def apply_windows_line_edit_look(edit: QLineEdit) -> None:
+    """Draw a text field like the Windows 10 fields of the Git Extensions windows in a light theme, at their height.
+
+    A dark palette keeps the Fusion field, whose frame and background already follow the palette; the Windows colors
+    are light-theme colors and would glare on a dark desktop, so a sheet laid in light is taken off. The choice follows
+    the application palette, and calling it again at any theme switch gives the same result. The height is the
+    captures' in both themes at the default text size, and grows with a larger one.
+    """
+    fit_windows_field_height(edit)
+    if is_dark_palette(QApplication.palette()):
+        edit.setStyleSheet("")
+        return
+    edit.setStyleSheet(windows_line_edit_style_sheet())
+
+
+def windows_combo_style_sheet(*, editable: bool) -> str:
+    """Return the style sheet that draws a drop-down list like a Windows 10 one, as the Git Extensions forms show it.
+
+    A list the user cannot type into looks like a button (grey face and border); one the user can type into looks
+    like a text field. The arrow is left to Qt's default drop-down part, which the style sheet keeps drawing.
+    """
+    if editable:
+        face_color, border_color, disabled_face_color = BODY_LIGHT_COLOR, WINDOWS_EDIT_BORDER_COLOR, WINDOWS_CONTROL_LIGHT_COLOR
+    else:
+        face_color, border_color, disabled_face_color = WINDOWS_BUTTON_FACE_COLOR, WINDOWS_BUTTON_BORDER_COLOR, WINDOWS_BUTTON_DISABLED_FACE_COLOR
+    return (f"QComboBox {{ background-color: {face_color}; color: {WINDOWS_BUTTON_TEXT_COLOR}; padding-left: {WINDOWS_COMBO_TEXT_PADDING}px;"
+            f" border: {WINDOWS_EDIT_BORDER_WIDTH}px solid {border_color}; }}"
+            f" QComboBox:focus {{ border-color: {WINDOWS_DEFAULT_BUTTON_BORDER_COLOR}; }}"
+            f" QComboBox:disabled {{ background-color: {disabled_face_color}; color: {WINDOWS_GRAY_TEXT_COLOR}; border-color: {WINDOWS_EDIT_DISABLED_BORDER_COLOR}; }}")
+
+
+def apply_windows_combo_look(combo: QComboBox, *, editable: bool) -> None:
+    """Draw a drop-down list like the Windows 10 lists of the Git Extensions windows in a light theme, at their height.
+
+    ``editable`` says whether the list takes typed text, which Windows draws as a field rather than as a button. A dark
+    palette keeps the Fusion list, whose colors already follow the palette, so a sheet laid in light is taken off. The
+    choice follows the application palette, and calling it again at any theme switch gives the same result. The height
+    is the captures' in both themes at the default text size, and grows with a larger one like the text fields beside it.
+    """
+    fit_windows_field_height(combo)
+    if is_dark_palette(QApplication.palette()):
+        combo.setStyleSheet("")
+        return
+    combo.setStyleSheet(windows_combo_style_sheet(editable=editable))
+
+
+def windows_message_style_sheet() -> str:
+    """Return the style sheet that draws a multi-line text box like the Windows 10 one of the Git Extensions forms."""
+    return f"QPlainTextEdit {{ background-color: {BODY_LIGHT_COLOR}; border: {WINDOWS_EDIT_BORDER_WIDTH}px solid {WINDOWS_MESSAGE_BORDER_COLOR}; }}"
+
+
+def hidden_message_style_sheet(background: QColor) -> str:
+    """Return the style sheet that blends a multi-line text box into the window: no border, the window's own background."""
+    return f"QPlainTextEdit {{ background-color: {background.name()}; border: none; }}"
+
+
+def apply_windows_message_look(edit: QPlainTextEdit) -> None:
+    """Draw a multi-line text box like the Git Extensions ones, following whether it is enabled; call it after each change.
+
+    An enabled box has the Windows 10 border and white background in a light theme and the Fusion frame in a dark one.
+    A disabled box has no border and the window's own background in both themes, so it disappears into the window,
+    as Git Extensions shows a text box without border style. The theme is the application palette's, so calling it
+    again at a theme switch lays the new theme's look.
+    """
+    source = QApplication.palette()
+    if not edit.isEnabled():
+        edit.setFrameShape(QFrame.Shape.NoFrame)
+        edit.setStyleSheet(hidden_message_style_sheet(plain_form_color(source)))
+        return
+    edit.setFrameShape(QFrame.Shape.StyledPanel)
+    if is_dark_palette(source):
+        edit.setStyleSheet("")
+        return
+    edit.setStyleSheet(windows_message_style_sheet())
+
+
+def apply_secondary_text_color(label: QLabel) -> None:
+    """Write a label in Windows' grey text in a light theme, like the commit counter of Git Extensions beside a revision field.
+
+    A dark palette keeps its own text color: the grey was sampled on a white body, and a palette's placeholder color is
+    not a safe substitute because Qt leaves it half-transparent black when the palette does not set it, which cannot
+    be read on a dark body. A label greyed in light gets back the palette it inherits, so calling it again at a theme
+    switch gives the new theme's color.
+    """
+    if is_dark_palette(QApplication.palette()):
+        label.setPalette(QPalette())
+        return
+    palette = label.palette()
+    palette.setColor(QPalette.ColorRole.WindowText, QColor(WINDOWS_GRAY_TEXT_COLOR))
+    label.setPalette(palette)
+
+
+def secondary_text_color(palette: QPalette) -> QColor:
+    """Return the color of secondary text written on a list or field background: Windows' grey text in a light theme.
+
+    A dark palette gets its text color moved part of the way towards its input background, so the secondary text reads
+    paler than the main text and stays readable. The palette's placeholder color is not used, for the same reason as in
+    ``apply_secondary_text_color``: Qt leaves it half-transparent black when the palette does not set it. That function
+    is not replaced: it keeps the full text color in a dark theme for the window that uses it.
+    """
+    if not is_dark_palette(palette):
+        return QColor(WINDOWS_GRAY_TEXT_COLOR)
+    text, background = palette.color(QPalette.ColorRole.Text), palette.color(QPalette.ColorRole.Base)
+    channels: list[int] = []
+    for text_channel, background_channel in ((text.red(), background.red()), (text.green(), background.green()), (text.blue(), background.blue())):
+        channels.append(round(text_channel + (background_channel - text_channel) * SECONDARY_TEXT_DARK_BLEND_RATIO))
+    red, green, blue = channels
+    return QColor(red, green, blue)
+
+
+def windows_list_style_sheet(palette: QPalette, selector: str, *, hide_focus_outline: bool) -> str:
+    """Return the style sheet that draws a widget like a Windows 10 list box: one-pixel list border on white in a light theme.
+
+    A dark palette keeps its own input background and takes the theme's line grey for the border, so the list stays
+    readable, shows its edge on the body and does not glare. ``selector`` names the widget class the rule applies to.
+    Whether the keyboard focus rectangle is hidden is each window's choice: a list reached with the keyboard keeps it.
+    """
+    if is_dark_palette(palette):
+        border, background = theme_line_color(palette), palette.color(QPalette.ColorRole.Base)
+    else:
+        border, background = QColor(WINDOWS_LIST_BORDER_LIGHT_COLOR), QColor(BODY_LIGHT_COLOR)
+    outline = " outline: 0;" if hide_focus_outline else ""
+    return f"{selector} {{ border: {WINDOWS_LIST_BORDER_WIDTH}px solid {border.name()}; background-color: {background.name()};{outline} }}"

gitpane/ui/reader/commit_message.py

@@ -0,0 +1,129 @@
+"""Search the visible commit message without changing the repository filter."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import Qt
+from PySide6.QtGui import QKeySequence, QShortcut, QTextOption
+from PySide6.QtWidgets import QHBoxLayout, QLineEdit, QPushButton, QTextEdit, QVBoxLayout, QWidget
+
+from gitpane.config import LAYOUT_SPACING, SharedText
+from gitpane.ui.reader.search_result import ActiveSelectionKeeper, SearchResultLabel
+from gitpane.ui.reader.source_text import SourceTextEdit
+from gitpane.ui.widget.system_shortcut import FIND_NEXT_ACTION, FIND_PREVIOUS_ACTION, find_shortcuts
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+
+class CommitMessage(QWidget):
+    """Keep literal message text and a local, wrapping search in one reading area."""
+
+    def __init__(self, text_edit: QTextEdit | SourceTextEdit | None = None) -> None:
+        """Build a hidden search bar with keyboard navigation and a visible result state."""
+        super().__init__()
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.setSpacing(LAYOUT_SPACING)
+        self.search_bar = QWidget()
+        search_layout = QHBoxLayout(self.search_bar)
+        search_layout.setContentsMargins(0, 0, 0, 0)
+        self.find_edit = QLineEdit()
+        self.find_edit.setPlaceholderText("Find in this commit message")
+        self.find_edit.setAccessibleName("Find in commit message")
+        self.find_edit.setToolTip(SharedText.TEXT_SEARCH_HELP.value)
+        self.result_label = SearchResultLabel()
+        self.previous_button = QPushButton("Previous")
+        self.next_button = QPushButton("Next")
+        self.close_button = QPushButton("Close")
+        search_layout.addWidget(self.find_edit, 1)
+        search_layout.addWidget(self.result_label)
+        for button in (self.previous_button, self.next_button, self.close_button):
+            search_layout.addWidget(button)
+        self.text_edit = text_edit if text_edit is not None else QTextEdit()
+        if isinstance(self.text_edit, QTextEdit):
+            self.text_edit.setAcceptRichText(False)
+        self.text_edit.setUndoRedoEnabled(False)
+        self.text_edit.setReadOnly(True)
+        self.text_edit.setWordWrapMode(QTextOption.WrapMode.WrapAtWordBoundaryOrAnywhere)
+        self.text_edit.setAccessibleName("Full commit message")
+        self.selection_keeper = ActiveSelectionKeeper(self.text_edit)
+        layout.addWidget(self.search_bar)
+        layout.addWidget(self.text_edit, 1)
+        self.search_bar.hide()
+        self.find_edit.textChanged.connect(self._restart_search)
+        self.text_edit.textChanged.connect(self._restart_search)
+        self.find_edit.returnPressed.connect(self.find_next)
+        self.previous_button.clicked.connect(self.find_previous)
+        self.next_button.clicked.connect(self.find_next)
+        self.close_button.clicked.connect(self.close_search)
+        self.shortcuts: list[QShortcut] = []
+        callback_by_action = {FIND_NEXT_ACTION: self.find_next, FIND_PREVIOUS_ACTION: self.find_previous}
+        key_callbacks: list[tuple[str, Callable[[], None]]] = []
+        for key, action in find_shortcuts():
+            key_callbacks.append((key, callback_by_action[action]))
+        key_callbacks.append(("Shift+Return", self.find_previous))
+        key_callbacks.append(("Escape", self.close_search))
+        for key, callback in key_callbacks:
+            shortcut = QShortcut(QKeySequence(key), self)
+            shortcut.setContext(Qt.ShortcutContext.WidgetWithChildrenShortcut)
+            shortcut.activated.connect(callback)
+            self.shortcuts.append(shortcut)
+
+    def open_search(self) -> None:
+        """Reveal the search field while retaining its query and current match."""
+        self.search_bar.show()
+        self.result_label.show_result(self.text_edit, self.find_edit.text())
+        self.text_edit.setExtraSelections(self.result_label.highlight_selections(self.text_edit, self.find_edit.text()))
+        self.find_edit.setFocus(Qt.FocusReason.ShortcutFocusReason)
+        self.find_edit.selectAll()
+
+    def close_search(self) -> None:
+        """Hide search without altering the message or the history filter."""
+        self.search_bar.hide()
+        self.text_edit.setExtraSelections([])
+        self.text_edit.setFocus(Qt.FocusReason.ShortcutFocusReason)
+
+    def find_next(self) -> None:
+        """Select the next match, wrapping at the end of the message."""
+        self._find(False)
+
+    def find_previous(self) -> None:
+        """Select the previous match, wrapping at the start of the message."""
+        self._find(True)
+
+    def _restart_search(self) -> None:
+        """Discard an old match when the query or selected commit changes."""
+        self.text_edit.setExtraSelections([])
+        self.result_label.clear()
+        cursor = self.text_edit.textCursor()
+        cursor.clearSelection()
+        self.text_edit.setTextCursor(cursor)
+        if self.search_bar.isHidden() or not self.find_edit.text():
+            return
+        self._find(False, restart=True)
+
+    def _find(self, backward: bool, restart: bool = False) -> None:
+        """Use document cursors so Unicode offsets and read-only text remain intact."""
+        query = self.find_edit.text()
+        if self.search_bar.isHidden() or not query:
+            return
+        self.result_label.show_result(self.text_edit, query)
+        document = self.text_edit.document()
+        cursor = self.text_edit.textCursor()
+        start = cursor.selectionStart() if backward else cursor.selectionEnd()
+        if restart:
+            start = 0
+        match = self.result_label.find_match(self.text_edit, query, start, backward)
+        if match.isNull():
+            start = document.characterCount() - 1 if backward else 0
+            match = self.result_label.find_match(self.text_edit, query, start, backward)
+        self.text_edit.setExtraSelections([])
+        if match.isNull():
+            cursor.clearSelection()
+            self.text_edit.setTextCursor(cursor)
+            return
+        self.text_edit.setTextCursor(match)
+        self.text_edit.ensureCursorVisible()
+        self.text_edit.setExtraSelections(self.result_label.highlight_selections(self.text_edit, query, match))