gitpane 1.0.0__py3-none-any.whl

gitpane/ui/reference/select_branches_dialog.py

@@ -0,0 +1,199 @@
+"""Reproduce the Git Extensions "Select multiple branches" window: the deletable branches with check boxes, then an OK button."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import QMargins, QRect, QSize, Qt, Signal
+from PySide6.QtWidgets import QApplication, QDialog, QHBoxLayout, QLabel, QListWidget, QListWidgetItem, QProxyStyle, QPushButton, QStyle, QStyledItemDelegate, QStyleFactory, QVBoxLayout, QWidget
+
+from gitpane.config import OK_BUTTON_TEXT, fit_window
+from gitpane.reference.reference_snapshot import short_reference_name
+from gitpane.ui.look.application_style import GitPaneFusionStyle
+from gitpane.ui.look.theme_look import follow_theme
+from gitpane.ui.look.windows_control_look import apply_windows_button_look, windows_list_style_sheet
+from gitpane.ui.widget.dialog_layout import fit_capture_control, install_plain_form_palette
+
+if TYPE_CHECKING:
+    from PySide6.QtCore import QModelIndex
+    from PySide6.QtWidgets import QStyleOption, QStyleOptionViewItem
+
+SELECT_MULTIPLE_BRANCHES_TITLE = "Select multiple branches"
+SELECT_BRANCHES_CAPTION = "Select branches"
+# Client area of the Git Extensions capture, in pixels at 100 %.
+SELECT_BRANCHES_CLIENT_SIZE = QSize(263, 252)
+# Measured on the capture in client pixels: "Select branches" ink x 15-96, y 12-20; the check box list (12, 32, 239, 166)
+# with a one-pixel Windows list border; rows every 18 px, squares from x 15 and texts from x 33; the OK button
+# (177, 224, 73, 21), 13 px from the right edge and 7 px from the bottom.
+SELECT_BRANCHES_LIST_RECT = QRect(12, 32, 239, 166)
+BRANCH_ROW_HEIGHT = 18
+OK_BUTTON_SIZE = QSize(73, 21)
+SELECT_BRANCHES_MARGINS = QMargins(12, 8, 12, 7)
+# The caption text starts 3 px right of the list, where the capture's ink starts, and its text box is as high as the
+# space above the list, so the list stays at the capture's place whatever the caption's font.
+SELECT_BRANCHES_CAPTION_INDENT = 3
+CAPTION_HEIGHT = SELECT_BRANCHES_LIST_RECT.top() - SELECT_BRANCHES_MARGINS.top()
+LIST_TO_OK_SPACE = 26
+# The OK button ends one pixel further from the right edge than the list.
+OK_BUTTON_RIGHT_INDENT = 1
+# Horizontal focus margin that puts the Fusion check box square 2 px inside the list and the text 18 px after the
+# square's left edge, where the capture has them; Fusion's own margin puts both about 3 px further right.
+BRANCH_ROW_FOCUS_MARGIN = 1
+
+
+class FixedRowHeightDelegate(QStyledItemDelegate):
+    """Draw list rows as the default delegate does, at a fixed height instead of the font's."""
+
+    def __init__(self, row_height: int, parent: QWidget | None = None) -> None:
+        """Remember the row height every item gets."""
+        super().__init__(parent)
+        self.row_height = row_height
+
+    def sizeHint(self, option: QStyleOptionViewItem, index: QModelIndex) -> QSize:
+        """Keep the default width and replace the height with the fixed one."""
+        size = super().sizeHint(option, index)
+        return QSize(size.width(), self.row_height)
+
+
+class CompactRowMargin:
+    """Workaround: lay list rows out like the Windows check box list, the square and the text closer to the left edge than Fusion does.
+
+    Fusion derives the space before the square, and between the square and the text, from the focus frame margin, and
+    no style sheet property moves them without restyling the whole row. Answering a smaller margin for this list only
+    moves both to the capture's place. Mixed in front of a style class, so every other metric is that style's.
+    """
+
+    def pixelMetric(self, metric: QStyle.PixelMetric, option: QStyleOption | None = None, widget: QWidget | None = None) -> int:
+        """Answer the reduced focus frame margin, and the style's own value for every other metric."""
+        if metric == QStyle.PixelMetric.PM_FocusFrameHMargin:
+            return BRANCH_ROW_FOCUS_MARGIN
+        return super().pixelMetric(metric, option, widget)
+
+
+class CompactCheckListStyle(CompactRowMargin, GitPaneFusionStyle):
+    """The row style when the application runs GitPane's Fusion style: that style's class with the compact row margin.
+
+    Everything else is drawn as the application style draws it, the contour of the squares in a dark theme included.
+    It derives from the application style's class instead of wrapping it: Fusion only asks its direct wrapper for
+    metrics, so a second wrapper around the first would lose the margin.
+    """
+
+
+class CompactProxyRowStyle(CompactRowMargin, QProxyStyle):
+    """The row style when the application runs another style than GitPane's Fusion: a wrapper around a fresh copy of it, with the compact row margin.
+
+    The rows, their check boxes and the list's scroll bar then match the rest of the windows, drawn in that style.
+    """
+
+
+class SelectBranchesDialog(QDialog):
+    """List the branches Delete branch may delete with check boxes, like the Git Extensions Select multiple branches window.
+
+    As in Git Extensions, OK, the title bar close button and Escape all close the window and apply the checks: the
+    window emits the checked branches, in the list order, however it was closed. It never starts Git; its branches
+    are the ones the Delete branch window already offers.
+    """
+
+    selection_applied = Signal(object)
+
+    def __init__(self, candidate_refs: tuple[str, ...], checked_ref_set: set[str], parent: QWidget | None = None) -> None:
+        """Build the caption, one check box row per offered branch with the known ones checked, and the OK button."""
+        super().__init__(parent)
+        self.setWindowTitle(SELECT_MULTIPLE_BRANCHES_TITLE)
+        self.setModal(True)
+        # Git Extensions shows this window as an ordinary one: minimize and maximize buttons, no help button, a size grip.
+        self.setWindowFlag(Qt.WindowType.WindowContextHelpButtonHint, False)
+        self.setWindowFlag(Qt.WindowType.WindowMinMaxButtonsHint, True)
+        self.setSizeGripEnabled(True)
+        install_plain_form_palette(self)
+        self.applied = False
+        self.row_style: QProxyStyle | None = None
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(SELECT_BRANCHES_MARGINS)
+        layout.setSpacing(0)
+        self.caption_label = QLabel(SELECT_BRANCHES_CAPTION)
+        self.caption_label.setContentsMargins(SELECT_BRANCHES_CAPTION_INDENT, 0, 0, 0)
+        self.caption_label.setAlignment(Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignTop)
+        self.caption_label.setMinimumHeight(CAPTION_HEIGHT)
+        self.branch_list = QListWidget()
+        self.branch_list.setAccessibleName(SELECT_BRANCHES_CAPTION)
+        self.branch_list.setUniformItemSizes(True)
+        self.branch_list.setItemDelegate(FixedRowHeightDelegate(BRANCH_ROW_HEIGHT, self.branch_list))
+        self._install_row_style()
+        self.caption_label.setBuddy(self.branch_list)
+        for full_ref in candidate_refs:
+            item = QListWidgetItem(short_reference_name(full_ref))
+            item.setData(Qt.ItemDataRole.UserRole, full_ref)
+            item.setFlags(Qt.ItemFlag.ItemIsEnabled | Qt.ItemFlag.ItemIsSelectable | Qt.ItemFlag.ItemIsUserCheckable)
+            item.setCheckState(Qt.CheckState.Checked if full_ref in checked_ref_set else Qt.CheckState.Unchecked)
+            self.branch_list.addItem(item)
+        self.ok_button = QPushButton(OK_BUTTON_TEXT)
+        # Git Extensions gives this window no default button: Enter does not close it.
+        self.ok_button.setAutoDefault(False)
+        self.ok_button.setDefault(False)
+        self.apply_theme_look()
+        follow_theme(self, self.apply_theme_look)
+        button_row = QHBoxLayout()
+        button_row.setContentsMargins(0, 0, OK_BUTTON_RIGHT_INDENT, 0)
+        button_row.addStretch(1)
+        button_row.addWidget(self.ok_button)
+        layout.addWidget(self.caption_label)
+        layout.addWidget(self.branch_list, 1)
+        layout.addSpacing(LIST_TO_OK_SPACE)
+        layout.addLayout(button_row)
+        self.ok_button.clicked.connect(self.accept)
+        self.finished.connect(self._apply)
+        self.resize(SELECT_BRANCHES_CLIENT_SIZE)
+        self.refresh_metrics()
+        self.branch_list.setFocus()
+
+    def apply_theme_look(self) -> None:
+        """Lay the light or dark look of the branch list's border and background and of OK; called by the constructor and again at each switch.
+
+        The list's sheet is worked out on the application palette, not the list's: macOS gives lists a fully opaque text
+        color, which would give their border a lighter grey than every other line of the window, and at a switch this
+        runs before Qt hands the new palette to the list. The rows need nothing: their style decides when it paints.
+        Only style sheets change: the checked branches stay as they are.
+        """
+        self.branch_list.setStyleSheet(windows_list_style_sheet(QApplication.palette(), "QListWidget", hide_focus_outline=True))
+        apply_windows_button_look(self.ok_button)
+
+    def _install_row_style(self) -> None:
+        """Draw the list with its own instance of the application style whose row margins match the capture.
+
+        With GitPane's Fusion style, the row style is that style's class with the reduced margin: one style layer only.
+        Any other application style is wrapped as it is, so the list keeps the look of the other windows; a proxy without
+        a base style would fall back to the desktop style, so it gets its own instance of the application style, and an
+        application style the style factory cannot build keeps its rows as they are.
+        """
+        application_style = QApplication.style()
+        if isinstance(application_style, GitPaneFusionStyle):
+            self.row_style = CompactCheckListStyle()
+        else:
+            base_style = QStyleFactory.create(application_style.objectName())
+            if base_style is None:
+                return
+            self.row_style = CompactProxyRowStyle(base_style)
+        self.row_style.setParent(self.branch_list)
+        self.branch_list.setStyle(self.row_style)
+
+    def checked_refs(self) -> tuple[str, ...]:
+        """Answer the full names of the checked branches, in the list order."""
+        full_refs: list[str] = []
+        for row in range(self.branch_list.count()):
+            item = self.branch_list.item(row)
+            if item.checkState() == Qt.CheckState.Checked:
+                full_refs.append(item.data(Qt.ItemDataRole.UserRole))
+        return tuple(full_refs)
+
+    def refresh_metrics(self, available: QRect | None = None) -> None:
+        """Give OK the capture's size, or more when its text needs it, then keep the window on the usable screen area without turning its starting size into a minimum."""
+        fit_capture_control(self.ok_button, OK_BUTTON_SIZE)
+        fit_window(self, 0, 0, available)
+
+    def _apply(self) -> None:
+        """Hand the checked branches over once, whether OK, the close button or Escape closed the window."""
+        if self.applied:
+            return
+        self.applied = True
+        self.selection_applied.emit(self.checked_refs())

gitpane/ui/reference/stash_dialog.py

@@ -0,0 +1,171 @@
+"""Offer explicit stash creation while keeping every unsuccessful draft visible."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import Qt, Signal
+from PySide6.QtWidgets import QCheckBox, QDialog, QHBoxLayout, QLabel, QPlainTextEdit, QPushButton, QVBoxLayout
+
+from gitpane.operation.diagnostic import SensitiveTextFilter
+from gitpane.operation.operation_status import OperationStatus
+from gitpane.reference.stash import STASH_INCLUDE_UNTRACKED_KEY, STASH_KEEP_INDEX_KEY, StashIntent, StashOption
+from gitpane.text.typed_text import typed_value
+from gitpane.ui.widget.dialog_layout import fit_form
+
+if TYPE_CHECKING:
+    from PySide6.QtCore import QRect
+    from PySide6.QtGui import QCloseEvent
+    from PySide6.QtWidgets import QWidget
+
+    from gitpane.operation.repository_operation import OperationOutcome
+    from gitpane.preference.preference_store import PreferenceStore
+    from gitpane.worktree.worktree_snapshot import WorktreeSnapshot
+
+STASH_WIDTH, STASH_HEIGHT = 600, 420
+
+
+class StashDialog(QDialog):
+    """Keep message and options until creation and the final working tree are observed."""
+
+    submit_requested = Signal(object)
+
+    def __init__(self, session_id: str, preference: PreferenceStore, parent: QWidget | None = None) -> None:
+        """Build a modeless form before any repository write is authorized."""
+        super().__init__(parent)
+        self.session_id = session_id
+        self.preference = preference
+        self.snapshot: WorktreeSnapshot | None = None
+        self.intent: StashIntent | None = None
+        self.running = False
+        self.capture_pending = False
+        self.closed = False
+        self.status_message = "Reading working tree…"
+        self.preference_error_by_key: dict[str, str] = {}
+        self.setWindowTitle("Stash")
+        self.setWindowModality(Qt.WindowModality.NonModal)
+        self.resize(STASH_WIDTH, STASH_HEIGHT)
+        layout = QVBoxLayout(self)
+        label = QLabel("Message (optional)")
+        self.message_edit = QPlainTextEdit()
+        self.message_edit.setAccessibleName("Message")
+        self.message_edit.setTabChangesFocus(True)
+        label.setBuddy(self.message_edit)
+        layout.addWidget(label)
+        layout.addWidget(self.message_edit, 1)
+        self.include_untracked_check = QCheckBox("Include untracked files")
+        self.include_untracked_check.setChecked(bool(preference.read(STASH_INCLUDE_UNTRACKED_KEY)))
+        self.keep_index_check = QCheckBox("Keep index")
+        self.keep_index_check.setChecked(bool(preference.read(STASH_KEEP_INDEX_KEY)))
+        layout.addWidget(self.include_untracked_check)
+        layout.addWidget(self.keep_index_check)
+        self.diagnostic_edit = QPlainTextEdit(self.status_message)
+        self.diagnostic_edit.setReadOnly(True)
+        self.diagnostic_edit.setAccessibleName("Stash diagnostic")
+        self.diagnostic_edit.setTabChangesFocus(True)
+        layout.addWidget(self.diagnostic_edit, 1)
+        actions = QHBoxLayout()
+        actions.addStretch()
+        self.stash_button = QPushButton("Stash")
+        self.stash_button.setEnabled(False)
+        self.stash_button.clicked.connect(self.submit)
+        self.cancel_button = QPushButton("Cancel")
+        self.cancel_button.clicked.connect(self.reject)
+        actions.addWidget(self.stash_button)
+        actions.addWidget(self.cancel_button)
+        layout.addLayout(actions)
+        self.include_untracked_check.toggled.connect(lambda checked: self._save_option(STASH_INCLUDE_UNTRACKED_KEY, checked))
+        self.keep_index_check.toggled.connect(lambda checked: self._save_option(STASH_KEEP_INDEX_KEY, checked))
+        self.finished.connect(self._closed)
+        self.refresh_metrics()
+
+    def begin_capture(self) -> None:
+        """Invalidate the previous intention while reloading the retained message and choices."""
+        self.capture_pending = True
+        self.snapshot = None
+        self.intent = None
+        self.stash_button.setEnabled(False)
+        self.status_message = "Reading working tree…"
+        self._show_diagnostic()
+
+    def populate(self, snapshot: WorktreeSnapshot) -> None:
+        """Enable a new submission after a fresh read without hiding unsaved option errors."""
+        self.capture_pending = False
+        self.snapshot = snapshot
+        self.status_message = ""
+        self._show_diagnostic()
+        self.stash_button.setEnabled(True)
+
+    def submit(self) -> None:
+        """Freeze visible inputs once, leaving repeats disabled until reconciliation.
+
+        The message is taken without the blanks around it, its inner lines as typed; the field keeps what was typed.
+        """
+        if self.running or self.closed or self.snapshot is None or not self.stash_button.isEnabled():
+            return
+        option = StashOption(self.include_untracked_check.isChecked(), self.keep_index_check.isChecked())
+        self.intent = StashIntent.capture(self.snapshot, typed_value(self.message_edit.toPlainText()), option, session_id=self.session_id)
+        self.running = True
+        self.stash_button.setEnabled(False)
+        self.cancel_button.setEnabled(False)
+        self.status_message = "Creating stash…"
+        self._show_diagnostic()
+        self.submit_requested.emit(self.intent)
+
+    def show_result(self, outcome: OperationOutcome) -> None:
+        """Close only on verified success; never clear a failed or uncertain draft."""
+        self.running = False
+        self.cancel_button.setEnabled(True)
+        if outcome.status == OperationStatus.SUCCESS and any(step.effect == "created" for step in outcome.steps):
+            self.accept()
+            return
+        detail = outcome.diagnostic.detail if outcome.diagnostic else "Stash was not created."
+        self.show_error(detail + "\n\nYour draft is kept. After reviewing the repository, click Stash in the toolbar to reload it.")
+
+    def show_error(self, message: str) -> None:
+        """Keep the complete plain-text diagnostic reachable without growing the form."""
+        self.capture_pending = False
+        self.snapshot = None
+        self.stash_button.setEnabled(False)
+        self.status_message = message
+        self._show_diagnostic()
+
+    def _show_diagnostic(self) -> None:
+        """Show repository activity and still-unsaved choices without letting either erase the other."""
+        messages = [self.status_message] if self.status_message else []
+        for key in sorted(self.preference_error_by_key):
+            message = self.preference_error_by_key[key]
+            if message not in messages:
+                messages.append(message)
+        self.diagnostic_edit.setPlainText("\n\n".join(messages))
+
+    def refresh_metrics(self, available_geometry: QRect | None = None) -> None:
+        """Follow system font metrics and fit within the current screen's usable area."""
+        fit_form(self, available_geometry)
+
+    def _save_option(self, key: str, checked: bool) -> None:
+        """Keep the user's visible choice when durable storage rejects it."""
+        try:
+            self.preference.update({key: checked})
+        except (OSError, TypeError, ValueError) as error:
+            self.preference_error_by_key[key] = ("Could not save stash options. Your choice applies to this stash but will not be remembered. "
+                                                 "After fixing the settings file, change this option again to save it. " + SensitiveTextFilter().redact(str(error)))
+        else:
+            self.preference_error_by_key.pop(key, None)
+        self._show_diagnostic()
+
+    def reject(self) -> None:
+        """Prevent dismissal while the shared owner is still reconciling native work."""
+        if not self.running:
+            super().reject()
+
+    def closeEvent(self, event: QCloseEvent) -> None:
+        """Keep a running form attached to its eventual result."""
+        if self.running:
+            event.ignore()
+            return
+        super().closeEvent(event)
+
+    def _closed(self) -> None:
+        """Record dismissal so late reads cannot populate a closed form."""
+        self.closed = True

gitpane/ui/repository/graph_delegate.py

@@ -0,0 +1,298 @@
+"""Draw the cells of the history list in Qt logical coordinates, from the graph lanes to the author photos."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import QPointF, QRectF, QSize, Qt
+from PySide6.QtGui import QColor, QFontMetrics, QPalette, QPen, QPolygonF
+from PySide6.QtWidgets import QStyledItemDelegate, QStyleOptionViewItem
+
+from gitpane.config import (
+    GRAPH_LANE_WIDTH,
+    GRAPH_MESSAGE_MIN_CHARACTERS,
+    GRAPH_NODE_SIDE,
+    ICON_SIDE,
+    PARENT_MARKER_BACKGROUND,
+    PARENT_MARKER_BORDER,
+    PARENT_MARKER_BORDER_WIDTH,
+    PARENT_MARKER_FILL,
+    PARENT_MARKER_INSET,
+    PARENT_MARKER_SHAFT_RATIO,
+    PARENT_MARKER_SHOULDER_RATIO,
+    SPACING_XS,
+)
+from gitpane.history.avatar import author_color, author_initials, normalize_author_email
+from gitpane.history.graph import ROW_CENTER
+from gitpane.history.repository_value import ReferenceKind
+from gitpane.ui.look.reference_font import reference_font
+from gitpane.ui.look.theme_color import is_dark_palette
+from gitpane.ui.repository.history_model import AUTHOR_IDENTITY_ROLE, COMMITTED_PARENT_ROLE, GRAPH_ROLE, HEAD_ROLE, MESSAGE_PREVIEW_ROLE, REFERENCE_ROLE, RELATIVE_OID_SET_ROLE, TIP_ROLE
+
+if TYPE_CHECKING:
+    from PySide6.QtCore import QModelIndex
+    from PySide6.QtGui import QPainter
+
+    from gitpane.history.repository_value import Reference
+    from gitpane.ui.repository.history_avatar import HistoryAvatar
+
+LANE_WIDTH = GRAPH_LANE_WIDTH
+NODE_RADIUS = GRAPH_NODE_SIDE / 2
+EDGE_WIDTH = 1.5
+BADGE_PADDING = SPACING_XS
+BADGE_GAP = SPACING_XS
+BADGE_BORDER_WIDTH = 1
+BADGE_POINTER_WIDTH = 8
+# Local branches, remote branches and HEAD draw frame and text in one color; tags use the separate colors below.
+BADGE_COLOR_BY_KIND: dict[ReferenceKind, str] = {ReferenceKind.HEADS: "#008000", ReferenceKind.REMOTES: "#c00000", ReferenceKind.HEAD: "#555555"}
+BADGE_LIGHT_FILL_COLOR = "#ffffff"
+# Git Extensions draws a tag from a dark blue base color: its text is that color mixed 25 % toward black and its frame
+# the same color mixed 50 % toward white. Both values were read on a capture of its revision graph.
+TAG_BADGE_TEXT_LIGHT_COLOR = "#000068"
+TAG_BADGE_FRAME_LIGHT_COLOR = "#7f7fc5"
+# Dark theme tag label, chosen on captures of the graph under the macOS dark appearance, on a chosen row as on the
+# others: a blue inside keeps tags blue as in the light graph, the white text reads at 7.0:1 on it, and a lighter blue
+# frame sets the label apart from the dark graph around it.
+TAG_BADGE_FILL_DARK_COLOR = "#3d5a85"
+TAG_BADGE_FRAME_DARK_COLOR = "#9db4e0"
+TAG_BADGE_TEXT_DARK_COLOR = "#ffffff"
+LANE_COLORS = ("#18b52b", "#ed3030", "#e84d9a", "#2677d9", "#a35bd5", "#ca8a04")
+
+
+@dataclass(frozen=True)
+class BadgeColors:
+    """Colors of one reference label in the graph: its frame line, its text and the inside of the frame."""
+
+    frame: QColor
+    text: QColor
+    fill: QColor
+
+
+def badge_colors(kind: ReferenceKind, palette: QPalette) -> BadgeColors:
+    """Pick the label colors for a reference kind, the one place where the graph decides how a label looks.
+
+    Tags follow Git Extensions with a lighter frame than their text on a white label; in a dark theme they are filled
+    with blue and written in white instead, so a white label does not glare in a dark graph and tags stay blue. Every
+    other kind keeps a single color for frame and text on a white label, whatever the theme.
+    """
+    if kind == ReferenceKind.TAGS and is_dark_palette(palette):
+        return BadgeColors(QColor(TAG_BADGE_FRAME_DARK_COLOR), QColor(TAG_BADGE_TEXT_DARK_COLOR), QColor(TAG_BADGE_FILL_DARK_COLOR))
+    if kind == ReferenceKind.TAGS:
+        return BadgeColors(QColor(TAG_BADGE_FRAME_LIGHT_COLOR), QColor(TAG_BADGE_TEXT_LIGHT_COLOR), QColor(BADGE_LIGHT_FILL_COLOR))
+    color = QColor(BADGE_COLOR_BY_KIND.get(kind, BADGE_COLOR_BY_KIND[ReferenceKind.HEAD]))
+    return BadgeColors(color, color, QColor(BADGE_LIGHT_FILL_COLOR))
+
+
+def reference_label(reference: Reference) -> str:
+    """Shorten only the namespace; remote and branch names remain distinguishable."""
+    return reference.full_name.removeprefix(reference.kind.prefix)
+
+
+def visible_references(references: list[Reference]) -> list[Reference]:
+    """Hide redundant HEAD aliases and put the current branch and remote default first."""
+    preferred_name_set = set()
+    displayed_references = []
+    for reference in references:
+        if reference.symbolic_target:
+            preferred_name_set.add(reference.symbolic_target)
+            if reference.kind == ReferenceKind.HEAD or reference.full_name.endswith("/HEAD"):
+                continue
+        displayed_references.append(reference)
+    return sorted(displayed_references, key=lambda reference: (not reference.is_head, reference.full_name not in preferred_name_set, reference.kind, reference.full_name))
+
+
+def graph_content_left(option: QStyleOptionViewItem, index: QModelIndex) -> int:
+    """Place decorations beyond the occupied graph lanes."""
+    row = index.data(GRAPH_ROLE)
+    left = option.rect.left() + BADGE_GAP
+    if row is not None:
+        left += (row.lane_count - ROW_CENTER) * LANE_WIDTH + NODE_RADIUS
+    return int(left)
+
+
+def parent_marker_rectangle(option: QStyleOptionViewItem, index: QModelIndex) -> QRectF:
+    """Reserve a logical icon cell only for the known committed parent row."""
+    if not index.data(COMMITTED_PARENT_ROLE):
+        return QRectF()
+    return QRectF(graph_content_left(option, index), option.rect.center().y() - ICON_SIDE / 2, ICON_SIDE, ICON_SIDE)
+
+
+def reference_content_left(option: QStyleOptionViewItem, index: QModelIndex) -> int:
+    """Apply the same marker spacing to painting and reference hit testing."""
+    rectangle = parent_marker_rectangle(option, index)
+    return int(rectangle.right() + BADGE_GAP) if not rectangle.isEmpty() else graph_content_left(option, index)
+
+
+def reference_badges(option: QStyleOptionViewItem, index: QModelIndex) -> list[tuple[Reference, QRectF, str, int]]:
+    """Share the painted badge rectangles with exact-reference mouse hit testing."""
+    left = reference_content_left(option, index)
+    badge_height = min(option.rect.height() - BADGE_GAP, option.fontMetrics.height() + BADGE_BORDER_WIDTH * 2)
+    top = option.rect.center().y() - badge_height / 2
+    badges: list[tuple[Reference, QRectF, str, int]] = []
+    message_width = option.fontMetrics.averageCharWidth() * GRAPH_MESSAGE_MIN_CHARACTERS
+    for reference in visible_references(index.data(REFERENCE_ROLE) or []):
+        remaining = option.rect.right() - left - message_width - BADGE_GAP
+        if remaining <= BADGE_PADDING * 2:
+            break
+        pointer_width = BADGE_POINTER_WIDTH if reference.kind in (ReferenceKind.HEADS, ReferenceKind.REMOTES) else 0
+        metrics = QFontMetrics(reference_font(option.font, reference))
+        label = metrics.elidedText(reference_label(reference), Qt.TextElideMode.ElideRight, max(0, remaining - BADGE_PADDING * 2 - pointer_width))
+        width = metrics.horizontalAdvance(label) + BADGE_PADDING * 2 + pointer_width
+        badges.append((reference, QRectF(left, top, width, badge_height), label, pointer_width))
+        left += width + BADGE_GAP
+    return badges
+
+
+class GraphDelegate(QStyledItemDelegate):
+    """Draw ancestry, references and the message together so text follows each row's graph."""
+
+    def sizeHint(self, option: QStyleOptionViewItem, index: QModelIndex) -> QSize:
+        """Keep the marker inside the row at normal and enlarged text sizes."""
+        size = super().sizeHint(option, index)
+        if index.data(COMMITTED_PARENT_ROLE):
+            size.setWidth(size.width() + ICON_SIDE + BADGE_GAP)
+            size.setHeight(max(size.height(), ICON_SIDE + BADGE_GAP))
+        return size
+
+    def paint(self, painter: QPainter, option: QStyleOptionViewItem, index: QModelIndex) -> None:
+        """Place labels next to the occupied lanes while retaining native row selection."""
+        preview = index.data(MESSAGE_PREVIEW_ROLE) or ""
+        row = index.data(GRAPH_ROLE)
+        item_option = QStyleOptionViewItem(option)
+        self.initStyleOption(item_option, index)
+        subject = item_option.text
+        item_option.text = ""
+        style = option.widget.style()
+        style.drawControl(style.ControlElement.CE_ItemViewItem, item_option, painter, option.widget)
+        painter.save()
+        painter.setClipRect(option.rect)
+        painter.setRenderHint(painter.RenderHint.Antialiasing)
+        painter.setFont(item_option.font)
+        if row is not None:
+            _paint_graph(painter, option, index)
+        marker = parent_marker_rectangle(option, index)
+        if not marker.isEmpty():
+            painter.fillRect(marker, QColor(PARENT_MARKER_BACKGROUND))
+            arrow = marker.adjusted(PARENT_MARKER_INSET, PARENT_MARKER_INSET, -PARENT_MARKER_INSET, -PARENT_MARKER_INSET)
+            shoulder = arrow.left() + arrow.width() * PARENT_MARKER_SHOULDER_RATIO
+            shaft = arrow.height() * PARENT_MARKER_SHAFT_RATIO
+            painter.setPen(QPen(QColor(PARENT_MARKER_BORDER), PARENT_MARKER_BORDER_WIDTH))
+            painter.setBrush(QColor(PARENT_MARKER_FILL))
+            painter.drawPolygon(QPolygonF([
+                QPointF(arrow.left(), arrow.center().y() - shaft), QPointF(shoulder, arrow.center().y() - shaft),
+                QPointF(shoulder, arrow.top()), QPointF(arrow.right(), arrow.center().y()), QPointF(shoulder, arrow.bottom()),
+                QPointF(shoulder, arrow.center().y() + shaft), QPointF(arrow.left(), arrow.center().y() + shaft),
+            ]))
+        left = reference_content_left(option, index)
+        badge_height = min(option.rect.height() - BADGE_GAP, option.fontMetrics.height() + BADGE_BORDER_WIDTH * 2)
+        top = option.rect.center().y() - badge_height / 2
+        for reference, rectangle, label, pointer_width in reference_badges(option, index):
+            painter.setFont(reference_font(option.font, reference))
+            left = rectangle.left()
+            colors = badge_colors(reference.kind, option.palette)
+            painter.setPen(QPen(colors.frame, BADGE_BORDER_WIDTH))
+            painter.setBrush(colors.fill)
+            # A pen is centered on the outline: drawn on the rectangle's own edges, a one-pixel frame straddles two
+            # device pixels and anti-aliasing paints both at half strength, lighter than the label's color. Moving the
+            # outline half a pen inward keeps the whole line inside the label and, at whole-number scales, on one pixel.
+            frame_inset = BADGE_BORDER_WIDTH / 2
+            painter.drawRect(rectangle.adjusted(frame_inset, frame_inset, -frame_inset, -frame_inset))
+            if pointer_width:
+                pointer_left = left + BADGE_PADDING
+                pointer_top = top + BADGE_GAP
+                pointer_bottom = top + badge_height - BADGE_GAP
+                pointer = QPolygonF([QPointF(pointer_left, pointer_top), QPointF(pointer_left + pointer_width - BADGE_GAP, rectangle.center().y()), QPointF(pointer_left, pointer_bottom)])
+                painter.setBrush(colors.frame if reference.is_head else colors.fill)
+                painter.drawPolygon(pointer)
+            painter.setPen(QPen(colors.text))
+            painter.drawText(rectangle.adjusted(pointer_width, 0, 0, 0), Qt.AlignmentFlag.AlignCenter, label)
+            left = int(rectangle.right() + BADGE_GAP)
+        painter.setFont(item_option.font)
+        selected = bool(option.state & style.StateFlag.State_Selected)
+        group = QPalette.ColorGroup.Active if option.state & style.StateFlag.State_Active else QPalette.ColorGroup.Inactive
+        painter.setPen(option.palette.color(group, QPalette.ColorRole.HighlightedText if selected else QPalette.ColorRole.Text))
+        text_rectangle = option.rect.adjusted(left - option.rect.left(), 0, 0, 0)
+        text = option.fontMetrics.elidedText(subject, Qt.TextElideMode.ElideRight, max(0, text_rectangle.width()))
+        painter.drawText(text_rectangle, Qt.AlignmentFlag.AlignVCenter | Qt.AlignmentFlag.AlignLeft, text)
+        preview_offset = option.fontMetrics.horizontalAdvance(subject) + BADGE_GAP
+        preview_rectangle = text_rectangle.adjusted(preview_offset, 0, 0, 0)
+        if preview and preview_rectangle.width() > 0:
+            preview_color = QPalette.ColorRole.HighlightedText if selected else QPalette.ColorRole.PlaceholderText
+            painter.setPen(option.palette.color(group, preview_color))
+            text = option.fontMetrics.elidedText(preview, Qt.TextElideMode.ElideRight, preview_rectangle.width())
+            painter.drawText(preview_rectangle, Qt.AlignmentFlag.AlignVCenter | Qt.AlignmentFlag.AlignLeft, text)
+        painter.restore()
+
+
+class AuthorDelegate(QStyledItemDelegate):
+    """Show an available photo or the author's colored initials beside their name."""
+
+    def __init__(self, avatar: HistoryAvatar) -> None:
+        """Read viewport-owned images without requesting network work during painting."""
+        super().__init__(avatar.view)
+        self.avatar = avatar
+
+    def paint(self, painter: QPainter, option: QStyleOptionViewItem, index: QModelIndex) -> None:
+        """Use the same fallback identity as the detail panel until a cached photo is ready."""
+        item_option = QStyleOptionViewItem(option)
+        self.initStyleOption(item_option, index)
+        name, email = index.data(AUTHOR_IDENTITY_ROLE)
+        item_option.text = ""
+        style = option.widget.style()
+        style.drawControl(style.ControlElement.CE_ItemViewItem, item_option, painter, option.widget)
+        painter.save()
+        painter.setClipRect(option.rect)
+        painter.setFont(item_option.font)
+        side = option.rect.height() - BADGE_GAP
+        rectangle = QRectF(option.rect.left() + BADGE_GAP, option.rect.top() + BADGE_GAP / 2, side, side)
+        painter.fillRect(rectangle, QColor(author_color(name, email)))
+        photo = self.avatar.image_by_email.get(normalize_author_email(email))
+        if photo is not None:
+            painter.setRenderHint(painter.RenderHint.SmoothPixmapTransform)
+            painter.drawImage(rectangle, photo)
+        else:
+            painter.setPen(QColor("white"))
+            painter.drawText(rectangle, Qt.AlignmentFlag.AlignCenter, author_initials(name))
+        selected = bool(option.state & style.StateFlag.State_Selected)
+        group = QPalette.ColorGroup.Active if option.state & style.StateFlag.State_Active else QPalette.ColorGroup.Inactive
+        painter.setPen(option.palette.color(group, QPalette.ColorRole.HighlightedText if selected else QPalette.ColorRole.Text))
+        text_rectangle = option.rect.adjusted(side + BADGE_GAP * 2, 0, 0, 0)
+        text = option.fontMetrics.elidedText(name, Qt.TextElideMode.ElideRight, max(0, text_rectangle.width()))
+        painter.drawText(text_rectangle, Qt.AlignmentFlag.AlignVCenter | Qt.AlignmentFlag.AlignLeft, text)
+        painter.restore()
+
+
+def _paint_graph(painter: QPainter, option: QStyleOptionViewItem, index: QModelIndex) -> None:
+    """Keep real edges continuous and distinguish branch tips from intermediate commits."""
+    row = index.data(GRAPH_ROLE)
+    relative_oid_set = index.data(RELATIVE_OID_SET_ROLE)
+    color = graph_color(row.oid, row.color_index, relative_oid_set, option.palette)
+    pen = QPen(color, EDGE_WIDTH)
+    for segment in row.segments:
+        pen.setColor(graph_color(segment.child_oid, segment.color_index, relative_oid_set, option.palette))
+        pen.setStyle(Qt.PenStyle.DashLine if segment.kind == "unavailable" else Qt.PenStyle.SolidLine)
+        painter.setPen(pen)
+        start = QPointF(option.rect.left() + (segment.start_lane + ROW_CENTER) * LANE_WIDTH, option.rect.top() + segment.start_position * option.rect.height())
+        end = QPointF(option.rect.left() + (segment.end_lane + ROW_CENTER) * LANE_WIDTH, option.rect.top() + segment.end_position * option.rect.height())
+        painter.drawLine(start, end)
+        if segment.kind == "unavailable":
+            painter.drawLine(QPointF(end.x() - NODE_RADIUS, end.y() - NODE_RADIUS), QPointF(end.x() + NODE_RADIUS, end.y() - NODE_RADIUS))
+    pen.setStyle(Qt.PenStyle.SolidLine)
+    pen.setColor(color)
+    painter.setPen(pen)
+    painter.setBrush(color)
+    center = QPointF(option.rect.left() + (row.lane + ROW_CENTER) * LANE_WIDTH, option.rect.top() + ROW_CENTER * option.rect.height())
+    if index.data(HEAD_ROLE) or index.data(TIP_ROLE):
+        if index.data(HEAD_ROLE):
+            painter.setPen(QPen(QColor("black"), BADGE_BORDER_WIDTH))
+        painter.drawRect(QRectF(center.x() - NODE_RADIUS, center.y() - NODE_RADIUS, GRAPH_NODE_SIDE, GRAPH_NODE_SIDE))
+    else:
+        painter.drawEllipse(center, NODE_RADIUS, NODE_RADIUS)
+
+
+def graph_color(oid: str, color_index: int, relative_oid_set: set[str] | None, palette: QPalette) -> QColor:
+    """Color shared ancestors normally and mute nodes and edges outside HEAD's history."""
+    if relative_oid_set is not None and oid not in relative_oid_set:
+        return palette.color(QPalette.ColorGroup.Disabled, QPalette.ColorRole.Text)
+    return QColor(LANE_COLORS[color_index % len(LANE_COLORS)])