gitpane 1.0.0__py3-none-any.whl

gitpane/ui/repository/history_avatar.py

@@ -0,0 +1,130 @@
+"""Load the photos of visible authors only, so painting a history row never waits on a photo."""
+
+from __future__ import annotations
+
+import uuid
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import QEvent, QObject, QTimer
+from PySide6.QtGui import QImage
+
+from gitpane.config import SPACING_XS
+from gitpane.history.avatar import AvatarService, normalize_author_email
+from gitpane.ui.repository.history_model import AUTHOR_COLUMN, AUTHOR_IDENTITY_ROLE
+
+if TYPE_CHECKING:
+    from PySide6.QtWidgets import QTableView
+
+
+class HistoryAvatar(QObject):
+    """Bind visible author consumers to the shared photo cache and cancel them when they leave view."""
+
+    def __init__(self, view: QTableView) -> None:
+        """Coalesce viewport and model changes before scheduling optional network work."""
+        super().__init__(view)
+        self.view = view
+        self.service: AvatarService | None = None
+        self.image_by_email: dict[str, QImage] = {}
+        self.identity_by_email: dict[str, str] = {}
+        self.email_by_identity: dict[str, str] = {}
+        self.closed = False
+        self.size = (0, 0.0)
+        self.timer = QTimer(self)
+        self.timer.setSingleShot(True)
+        self.timer.timeout.connect(self.refresh)
+        view.viewport().installEventFilter(self)
+        view.verticalScrollBar().valueChanged.connect(self.schedule_refresh)
+        view.horizontalScrollBar().valueChanged.connect(self.schedule_refresh)
+        view.model().modelReset.connect(self.schedule_refresh)
+        view.model().rowsInserted.connect(self.schedule_refresh)
+
+    def set_service(self, service: AvatarService) -> None:
+        """Replace the photo provider without leaving subscribers on the previous service."""
+        if self.service is service:
+            return
+        self._clear_consumers()
+        if self.service is not None:
+            self.service.image_ready.disconnect(self._image_ready)
+        self.service = service
+        service.image_ready.connect(self._image_ready)
+        self.schedule_refresh()
+
+    def eventFilter(self, watched: QObject, event: QEvent) -> bool:
+        """Adapt photo dimensions and visible authors when the native viewport changes."""
+        if event.type() in (QEvent.Type.Resize, QEvent.Type.Show, QEvent.Type.Hide, QEvent.Type.FontChange, QEvent.Type.DevicePixelRatioChange):
+            self.schedule_refresh()
+        return super().eventFilter(watched, event)
+
+    def schedule_refresh(self) -> None:
+        """Defer and combine repeated scroll or insertion notifications into one viewport scan."""
+        if not self.closed:
+            self.timer.start(0)
+
+    def refresh(self) -> None:
+        """Request each visible email once at the current row size and screen density."""
+        if self.closed or self.service is None:
+            return
+        view = self.view
+        if not view.isVisible() or not view.model().rowCount():
+            self._clear_consumers()
+            return
+        side = max(1, view.verticalHeader().defaultSectionSize() - SPACING_XS)
+        ratio = view.devicePixelRatioF()
+        size = (side, ratio)
+        if size != self.size:
+            self._clear_consumers()
+            self.size = size
+        first_row = max(0, view.rowAt(0))
+        last_row = view.rowAt(view.viewport().height() - 1)
+        if last_row < 0:
+            visible_row_count = view.viewport().height() // view.verticalHeader().defaultSectionSize() + 1
+            last_row = min(view.model().rowCount() - 1, first_row + visible_row_count)
+        email_set = set()
+        for row in range(first_row, last_row + 1):
+            index = view.model().index(row, AUTHOR_COLUMN)
+            if not view.visualRect(index).intersects(view.viewport().rect()):
+                continue
+            _name, author_email = index.data(AUTHOR_IDENTITY_ROLE)
+            email = normalize_author_email(author_email)
+            if email:
+                email_set.add(email)
+        for email in tuple(self.identity_by_email):
+            if email not in email_set:
+                identity = self.identity_by_email.pop(email)
+                self.email_by_identity.pop(identity)
+                self.image_by_email.pop(email, None)
+                self.service.cancel(identity)
+        for email in sorted(email_set):
+            if email in self.identity_by_email:
+                continue
+            identity = uuid.uuid4().hex
+            self.identity_by_email[email] = identity
+            self.email_by_identity[identity] = email
+            self.service.request(email, side, ratio, identity)
+
+    def close(self) -> None:
+        """Release only this view's requests while other windows continue using the shared service."""
+        self.closed = True
+        self.timer.stop()
+        self._clear_consumers()
+        if self.service is not None:
+            self.service.image_ready.disconnect(self._image_ready)
+            self.service = None
+
+    def _clear_consumers(self) -> None:
+        """Invalidate identities before cancellation can deliver a synchronous callback."""
+        identities = list(self.email_by_identity)
+        self.identity_by_email.clear()
+        self.email_by_identity.clear()
+        self.image_by_email.clear()
+        if self.service is not None:
+            for identity in identities:
+                self.service.cancel(identity)
+
+    def _image_ready(self, identity: object, image: QImage) -> None:
+        """Reject stale authors and density changes before repainting the current viewport."""
+        email = self.email_by_identity.get(identity)
+        if email is None or image.isNull() or self.closed:
+            return
+        self.image_by_email[email] = image
+        self.view.viewport().update()

gitpane/ui/repository/history_model.py

@@ -0,0 +1,179 @@
+"""Expose ordered commit rows to the history view."""
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import QAbstractTableModel, QModelIndex, Qt
+from PySide6.QtGui import QFont
+
+from gitpane.history.graph import GraphLayout
+from gitpane.history.revision import ancestor_oid_set
+from gitpane.ui.widget.commit_date_text import format_commit_time
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+    from collections.abc import Set as AbstractSet
+
+    from gitpane.history.repository_value import Commit, HistorySnapshot, Reference
+
+MESSAGE_COLUMN, AUTHOR_COLUMN, DATE_COLUMN, HASH_COLUMN = range(4)
+COLUMN_LABELS = ("Commit", "Author", "Date", "Hash")
+COLUMN_WIDTHS = (528, 176, 112, 112)
+OID_ROLE = Qt.ItemDataRole.UserRole
+GRAPH_ROLE = OID_ROLE + 1
+REFERENCE_ROLE = GRAPH_ROLE + 1
+HEAD_ROLE = REFERENCE_ROLE + 1
+AUTHOR_IDENTITY_ROLE = HEAD_ROLE + 1
+MESSAGE_PREVIEW_ROLE = AUTHOR_IDENTITY_ROLE + 1
+TIP_ROLE = MESSAGE_PREVIEW_ROLE + 1
+RELATIVE_OID_SET_ROLE = TIP_ROLE + 1
+COMMITTED_PARENT_ROLE = RELATIVE_OID_SET_ROLE + 1
+
+
+class HistoryModel(QAbstractTableModel):
+    """Keep stable OID-to-row positions while metadata pages are appended."""
+
+    def __init__(self, clock: Callable[[], datetime] | None = None) -> None:
+        """Inject the clock for reproducible relative date presentation."""
+        super().__init__()
+        self.clock = clock or (lambda: datetime.now().astimezone())
+        self.commits: list[Commit] = []
+        self.row_by_oid: dict[str, int] = {}
+        self.snapshot: HistorySnapshot | None = None
+        self.graph_layout = GraphLayout()
+        self.visible_oid_set: set[str] | None = None
+        self.visible_parent_oids_by_oid: dict[str, list[str]] | None = None
+        self.references_by_oid: dict[str, list[Reference]] = {}
+        self.relative_oid_set: set[str] | None = None
+        self.committed_parent_oid: str | None = None
+
+    def set_committed_parent(self, oid: str | None) -> None:
+        """Update the parent marker independently of HEAD, references and selection."""
+        self.committed_parent_oid = oid
+        if self.commits:
+            first_row = 0
+            self.dataChanged.emit(self.index(first_row, MESSAGE_COLUMN), self.index(len(self.commits) - 1, MESSAGE_COLUMN))
+
+    def reset_snapshot(self, snapshot: HistorySnapshot) -> None:
+        """Replace references and rows together when a new capture is accepted."""
+        self.beginResetModel()
+        self.snapshot = snapshot
+        self.references_by_oid.clear()
+        for reference in snapshot.references:
+            if reference.target_oid:
+                self.references_by_oid.setdefault(reference.target_oid, []).append(reference)
+        self.commits.clear()
+        self.row_by_oid.clear()
+        self.graph_layout = GraphLayout()
+        self.visible_oid_set = None
+        self.visible_parent_oids_by_oid = None
+        self.refresh_ancestry()
+        self.endResetModel()
+
+    def refresh_ancestry(self) -> None:
+        """Cache HEAD and all its ancestors so unrelated branches can be painted gray.
+
+        The same set answers the commit counter of the revision windows, so it uses the one shared ancestor walk and
+        stays None whenever the graph is incomplete or HEAD has no commit, which sends the counter to Git.
+        """
+        self.relative_oid_set = None
+        if self.snapshot is None or not self.snapshot.complete or not self.snapshot.head_oid:
+            return
+        self.relative_oid_set = ancestor_oid_set(self.snapshot.head_oid, self.snapshot.parent_oids_by_oid)
+
+    def refresh_date(self) -> None:
+        """Repaint visible date values without resetting rows, selection or scrolling."""
+        if self.commits:
+            first_row = 0
+            self.dataChanged.emit(self.index(first_row, DATE_COLUMN), self.index(len(self.commits) - 1, DATE_COLUMN), [Qt.ItemDataRole.DisplayRole])
+
+    def append_batch(self, commits: list[Commit]) -> None:
+        """Insert each OID once without changing the position of existing rows.
+
+        A commit is skipped when it already has a row or appeared earlier in the same page; only the page's own OIDs
+        are collected. The known hashes handed to the graph are a live key view of the snapshot index, not a copy: the
+        graph only tests membership in it, and copying every known hash on each page made a long history load several
+        times slower. Without a snapshot the graph never reads that set, so the row index view is passed as is.
+        """
+        new_commits = []
+        batch_oid_set: set[str] = set()
+        for commit in commits:
+            if commit.oid in self.row_by_oid or commit.oid in batch_oid_set:
+                continue
+            new_commits.append(commit)
+            batch_oid_set.add(commit.oid)
+        if not new_commits:
+            return
+        first_row = len(self.commits)
+        known_oid_set: AbstractSet[str] = self.snapshot.parent_oids_by_oid.keys() if self.snapshot is not None else self.row_by_oid.keys()
+        if self.visible_oid_set is not None:
+            known_oid_set = self.visible_oid_set
+        self.beginInsertRows(QModelIndex(), first_row, first_row + len(new_commits) - 1)
+        for commit in new_commits:
+            self.row_by_oid[commit.oid] = len(self.commits)
+            self.commits.append(commit)
+            parent_oids = commit.parent_oids if self.visible_parent_oids_by_oid is None else self.visible_parent_oids_by_oid.get(commit.oid, [])
+            self.graph_layout.append(commit.oid, parent_oids, known_oid_set, self.snapshot.complete if self.snapshot is not None else False)
+        self.endInsertRows()
+
+    def rowCount(self, parent: QModelIndex | None = None) -> int:
+        """Return root rows only because the history is a flat table."""
+        return 0 if parent is not None and parent.isValid() else len(self.commits)
+
+    def columnCount(self, parent: QModelIndex | None = None) -> int:
+        """Expose one fixed set of metadata columns."""
+        return len(COLUMN_LABELS)
+
+    def headerData(self, section: int, orientation: Qt.Orientation, role: int = Qt.ItemDataRole.DisplayRole) -> object:
+        """Name metadata columns for both visual and accessible navigation."""
+        if orientation == Qt.Orientation.Horizontal and role == Qt.ItemDataRole.DisplayRole:
+            return COLUMN_LABELS[section]
+        return None
+
+    def data(self, index: QModelIndex, role: int = Qt.ItemDataRole.DisplayRole) -> object:
+        """Return complete tooltip text alongside elidable display values."""
+        if not index.isValid() or index.row() >= len(self.commits):
+            return None
+        commit = self.commits[index.row()]
+        if role == OID_ROLE:
+            return commit.oid
+        if role == GRAPH_ROLE:
+            return self.graph_layout.row_by_oid.get(commit.oid)
+        if role == RELATIVE_OID_SET_ROLE:
+            return self.relative_oid_set
+        if role == REFERENCE_ROLE:
+            return self.references_by_oid.get(commit.oid, [])
+        if role == HEAD_ROLE:
+            return self.snapshot is not None and commit.oid == self.snapshot.head_oid
+        if role == COMMITTED_PARENT_ROLE:
+            return commit.oid == self.committed_parent_oid
+        if role == TIP_ROLE:
+            row = self.graph_layout.row_by_oid.get(commit.oid)
+            has_hidden_child = self.snapshot is not None and bool(self.snapshot.child_oids_by_oid.get(commit.oid))
+            return row is not None and row.is_tip and not has_hidden_child
+        if role == AUTHOR_IDENTITY_ROLE:
+            return commit.author_name, commit.author_email
+        if role == MESSAGE_PREVIEW_ROLE:
+            return commit.body_preview
+        if role == Qt.ItemDataRole.FontRole and self.snapshot is not None and commit.oid == self.snapshot.head_oid:
+            font = QFont()
+            font.setWeight(QFont.Weight.DemiBold)
+            return font
+        if role not in (Qt.ItemDataRole.DisplayRole, Qt.ItemDataRole.ToolTipRole, Qt.ItemDataRole.AccessibleTextRole):
+            return None
+        if index.column() == MESSAGE_COLUMN:
+            if role in (Qt.ItemDataRole.ToolTipRole, Qt.ItemDataRole.AccessibleTextRole):
+                names = []
+                if commit.oid == self.committed_parent_oid:
+                    names.append(f"Committed in parent: {commit.oid}")
+                for reference in self.references_by_oid.get(commit.oid, []):
+                    names.append(reference.full_name)
+                return "\n".join(names) + "\n\n" + commit.message if names else commit.message
+            return commit.message.partition("\n")[0]
+        if index.column() == AUTHOR_COLUMN:
+            return commit.author_name
+        if index.column() == DATE_COLUMN:
+            return format_commit_time(commit, commit.author_timestamp, self.clock(), relative_only=role == Qt.ItemDataRole.DisplayRole)
+        return commit.oid if role == Qt.ItemDataRole.ToolTipRole else commit.short_oid

gitpane/ui/repository/repository_list_popup.py

@@ -0,0 +1,319 @@
+"""Dropdown list of the repository switch button: opened under its button like the list of a combo box, without reading the disk."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import QEvent, QModelIndex, QObject, QPoint, QRect, QSize, Qt, Signal
+from PySide6.QtGui import QGuiApplication, QKeyEvent, QMouseEvent, QStandardItem, QStandardItemModel
+from PySide6.QtWidgets import QAbstractItemView, QFrame, QLayout, QTreeView, QVBoxLayout, QWidget
+
+from gitpane.config import REPOSITORY_LIST_COLUMN_GAP, REPOSITORY_LIST_MAX_VISIBLE_ROW_COUNT, SCREEN_MARGIN, SharedText
+from gitpane.recent.recent_name import repository_display_name
+from gitpane.ui.widget.mnemonic import MNEMONIC_MARKER
+from gitpane.ui.widget.plain_tooltip import plain_text_tooltip
+
+if TYPE_CHECKING:
+    from PySide6.QtGui import QScreen
+
+# Numbering of the recent repositories as in Git Extensions: the first ten entries get a keyboard mnemonic (the digit
+# after "&"), the tenth on its "0"; entries beyond ten show their number alone, without a mnemonic.
+REPOSITORY_MENU_MNEMONIC_BY_NUMBER: dict[int, str] = {1: "&1", 2: "&2", 3: "&3", 4: "&4", 5: "&5", 6: "&6", 7: "&7", 8: "&8", 9: "&9", 10: "1&0"}
+# Columns of a row: its number, the repository name, then the full path that tells apart two repositories of the same name.
+NUMBER_COLUMN, NAME_COLUMN, PATH_COLUMN = 0, 1, 2
+COLUMN_COUNT = 3
+# The folder a row opens, carried by its number cell.
+REPOSITORY_DIR_ROLE = Qt.ItemDataRole.UserRole
+# The current repository is always the first row, where the list starts.
+FIRST_ENTRY_ROW = 0
+# The previous repository, the current one being first: the list opens on it, so Enter goes straight back to it.
+SECOND_ENTRY_ROW = 1
+# Width of the line drawn around the list, which sets it apart from the window under it.
+POPUP_FRAME_WIDTH = 1
+# The list numbers its rows from 1, as the user counts them.
+FIRST_ROW_NUMBER = 1
+# A key typed to jump to a name gives one character; longer text comes from an input method composing several.
+TYPED_CHARACTER_LENGTH = 1
+
+
+@dataclass(frozen=True)
+class RepositoryListRow:
+    """Texts of one row of the list and the folder it opens."""
+
+    number_text: str
+    name: str
+    repository_dir: str
+
+
+def repository_list_rows(repository_dirs: list[str]) -> list[RepositoryListRow]:
+    """Return the rows the list shows for folders already known, numbered from 1.
+
+    The texts are shown as written: unlike a menu, the list never turns an "&" into a keyboard mnemonic.
+    """
+    rows = []
+    for number, repository_dir in enumerate(repository_dirs, start=FIRST_ROW_NUMBER):
+        rows.append(RepositoryListRow(str(number), repository_display_name(repository_dir), repository_dir))
+    return rows
+
+
+def repository_menu_number_by_key() -> dict[str, int]:
+    """Return the entry number each typed key opens, read from the mnemonic table so that it stays the only source."""
+    number_by_key = {}
+    for number, mnemonic_text in REPOSITORY_MENU_MNEMONIC_BY_NUMBER.items():
+        key_position = mnemonic_text.index(MNEMONIC_MARKER) + len(MNEMONIC_MARKER)
+        number_by_key[mnemonic_text[key_position]] = number
+    return number_by_key
+
+
+def rows_whose_name_starts_with(names: list[str], typed_text: str) -> list[int]:
+    """Return the rows whose repository name starts with the typed text, whatever the case, in the order of the list.
+
+    The letters are looked up in the names because the mnemonic table only holds digits.
+    """
+    wanted_start = typed_text.casefold()
+    rows = []
+    for row, name in enumerate(names):
+        if name.casefold().startswith(wanted_start):
+            rows.append(row)
+    return rows
+
+
+def next_row_after(rows: list[int], current_row: int) -> int:
+    """Return the first of rows after the current row, or the first of them past the last one.
+
+    A letter that starts several names thus moves from one to the next and around, like duplicate mnemonics in a menu.
+    rows is never empty and already in the order of the list.
+    """
+    for row in rows:
+        if row > current_row:
+            return row
+    return min(rows)
+
+
+def repository_list_geometry(anchor_rect: QRect, wanted_size: QSize, available: QRect, minimum_height: int) -> QRect:
+    """Return where the list goes on screen, given its button in screen coordinates and the usable area of the screen.
+
+    The list always opens right under the button, never above it. Its width is at least the width of the button and at
+    most the usable width of the screen less a margin on each side. Its height is the wanted one, shortened to end at
+    the bottom of the usable area, but never under the minimum height. Its left edge is the left edge of the button,
+    moved left when the list would pass the right edge of the screen, and never left of the screen.
+    """
+    width = min(max(wanted_size.width(), anchor_rect.width()), available.width() - 2 * SCREEN_MARGIN)
+    top = anchor_rect.bottom() + 1
+    room_below = available.bottom() + 1 - top
+    height = max(min(wanted_size.height(), room_below), minimum_height)
+    left = min(anchor_rect.left(), available.right() + 1 - width)
+    left = max(left, available.left())
+    return QRect(left, top, width, height)
+
+
+class RepositoryListPopup(QFrame):
+    """List of the recent repositories in three columns (number, name, full path), shown under the repository button.
+
+    A click on a row chooses it. The rows are rebuilt from folders the window already knows each time the list opens,
+    so opening it never waits for a disk or a network drive.
+    """
+
+    repository_chosen = Signal(str)
+
+    def __init__(self, parent: QWidget) -> None:
+        """Build the list once; each opening only rebuilds its rows.
+
+        The parent window is kept as the owner of the popup: under Wayland a popup without one is placed wrongly.
+        """
+        super().__init__(parent, Qt.WindowType.Popup)
+        self.setFrameShape(QFrame.Shape.Box)
+        self.setLineWidth(POPUP_FRAME_WIDTH)
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.setSpacing(0)
+        # The size of the list is decided at each opening from its rows; left to the layout, the smallest size Qt suggests
+        # for a tree view, about four rows, would make a list of one or two entries taller than its rows.
+        layout.setSizeConstraint(QLayout.SizeConstraint.SetNoConstraint)
+        self.model = QStandardItemModel(0, COLUMN_COUNT, self)
+        self.view = QTreeView(self)
+        self.view.setAccessibleName(SharedText.RECENT_REPOSITORY.value)
+        self.view.setModel(self.model)
+        self.view.setHeaderHidden(True)
+        self.view.setRootIsDecorated(False)
+        self.view.setUniformRowHeights(True)
+        self.view.setItemsExpandable(False)
+        self.view.setAllColumnsShowFocus(True)
+        self.view.setSelectionBehavior(QAbstractItemView.SelectionBehavior.SelectRows)
+        self.view.setSelectionMode(QAbstractItemView.SelectionMode.SingleSelection)
+        self.view.setEditTriggers(QAbstractItemView.EditTrigger.NoEditTriggers)
+        self.view.setTextElideMode(Qt.TextElideMode.ElideMiddle)
+        self.view.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
+        self.view.setFrameShape(QFrame.Shape.NoFrame)
+        # The row under the mouse becomes the chosen row, as in a menu; a single click opens it.
+        self.view.setMouseTracking(True)
+        # The path column takes whatever width the list has left after the number and the name.
+        self.view.header().setStretchLastSection(True)
+        layout.addWidget(self.view)
+        self.view.clicked.connect(self._choose_index)
+        self.view.entered.connect(self._select_hovered_index)
+        self.view.installEventFilter(self)
+
+    def show_entries(self, repository_dirs: list[str], anchor: QWidget) -> None:
+        """Rebuild the rows from folders already known, without touching the disk, then open the list under anchor.
+
+        The list shows at most a fixed number of rows and scrolls past them; its columns and size are set before it
+        shows, since rows laid out at another width keep it.
+        """
+        self.model.removeRows(0, self.model.rowCount())
+        for list_row in repository_list_rows(repository_dirs):
+            self.model.appendRow(self._row_cells(list_row))
+        column_widths = self._measure_columns()
+        row_count = self.model.rowCount()
+        row_height = self.view.sizeHintForIndex(self.model.index(FIRST_ENTRY_ROW, NAME_COLUMN)).height()
+        frame_height = 2 * POPUP_FRAME_WIDTH
+        anchor_rect = QRect(anchor.mapToGlobal(QPoint(0, 0)), anchor.size())
+        available = self._screen_at(QPoint(anchor_rect.left(), anchor_rect.bottom() + 1), anchor).availableGeometry()
+        minimum_height = row_height + frame_height
+        visible_row_count = min(row_count, REPOSITORY_LIST_MAX_VISIBLE_ROW_COUNT)
+        wanted_size = QSize(sum(column_widths) + frame_height, visible_row_count * row_height + frame_height)
+        geometry = repository_list_geometry(anchor_rect, wanted_size, available, minimum_height)
+        scroll_bar_width = 0
+        if geometry.height() - frame_height < row_count * row_height:
+            # Not every row fits, whether the history is long or the list was shortened at the bottom of the screen: the
+            # vertical scroll bar takes its width from the columns unless the list grows by as much.
+            scroll_bar_width = self.view.verticalScrollBar().sizeHint().width()
+            geometry = repository_list_geometry(anchor_rect, QSize(wanted_size.width() + scroll_bar_width, wanted_size.height()), available, minimum_height)
+        self.setGeometry(geometry)
+        # Workaround: with a scroll bar shown "as needed", Qt decides to show or hide it only after the list has shown,
+        # through a queued call, so the list would first show with the bar of its previous opening and columns that no
+        # longer fit. The list already knows whether every row fits, so it says so before it shows.
+        scroll_bar_policy = Qt.ScrollBarPolicy.ScrollBarAlwaysOn if scroll_bar_width else Qt.ScrollBarPolicy.ScrollBarAlwaysOff
+        self.view.setVerticalScrollBarPolicy(scroll_bar_policy)
+        self._fit_columns(column_widths, geometry.width(), scroll_bar_width)
+        opening_row = SECOND_ENTRY_ROW if row_count > SECOND_ENTRY_ROW else FIRST_ENTRY_ROW
+        self.view.setCurrentIndex(self.model.index(opening_row, NUMBER_COLUMN))
+        self.view.scrollToTop()
+        self.show()
+        self.view.setFocus()
+
+    def _row_cells(self, list_row: RepositoryListRow) -> list[QStandardItem]:
+        """Return the cells of one row, in column order: plain text, read only, each with the full path as tooltip."""
+        tooltip = plain_text_tooltip([list_row.repository_dir])
+        text_by_column = {NUMBER_COLUMN: list_row.number_text, NAME_COLUMN: list_row.name, PATH_COLUMN: list_row.repository_dir}
+        cells = []
+        for column in range(COLUMN_COUNT):
+            cell = QStandardItem(text_by_column[column])
+            cell.setEditable(False)
+            cell.setToolTip(tooltip)
+            cells.append(cell)
+        cells[NUMBER_COLUMN].setData(list_row.repository_dir, REPOSITORY_DIR_ROLE)
+        return cells
+
+    def _measure_columns(self) -> list[int]:
+        """Return the width each column wants: its content as the view measures it, style margins included, plus a small
+        gap after the number and after the name so that they do not touch the next column.
+
+        The number and the name never get less than the smallest section the header allows, since it would widen them
+        anyway and the path would then pass the edge of the list.
+        """
+        minimum_section_width = self.view.header().minimumSectionSize()
+        column_widths = []
+        for column in range(COLUMN_COUNT):
+            column_width = self.view.sizeHintForColumn(column)
+            if column != PATH_COLUMN:
+                column_width = max(column_width + REPOSITORY_LIST_COLUMN_GAP, minimum_section_width)
+            column_widths.append(column_width)
+        return column_widths
+
+    def _fit_columns(self, column_widths: list[int], list_width: int, scroll_bar_width: int) -> None:
+        """Give each column its width before the list shows: the number and the name their measured width, the path what
+        the visible part of the list has left.
+
+        When that is less than its content, the view cuts the paths in the middle. A width given after the list shows can
+        leave rows laid out at a width that no longer fits.
+        """
+        header = self.view.header()
+        header.resizeSection(NUMBER_COLUMN, column_widths[NUMBER_COLUMN])
+        header.resizeSection(NAME_COLUMN, column_widths[NAME_COLUMN])
+        viewport_width = list_width - 2 * POPUP_FRAME_WIDTH - scroll_bar_width
+        path_width = viewport_width - header.sectionSize(NUMBER_COLUMN) - header.sectionSize(NAME_COLUMN)
+        header.resizeSection(PATH_COLUMN, max(path_width, header.minimumSectionSize()))
+
+    def _screen_at(self, point: QPoint, anchor: QWidget) -> QScreen:
+        """Return the screen under the top left corner of the list, or the screen of its button when no screen is there."""
+        screen = QGuiApplication.screenAt(point)
+        return screen if screen is not None else anchor.screen()
+
+    def eventFilter(self, watched: QObject, event: QEvent) -> bool:
+        """Answer the keys of the list as the list of a combo box does: Enter opens the chosen row, Escape closes, a digit
+        or a letter opens or chooses an entry. Arrows, Page Up/Down, Home and End are left to the view."""
+        if watched is not self.view or event.type() != QEvent.Type.KeyPress:
+            return super().eventFilter(watched, event)
+        return self._handle_key(event)
+
+    def _handle_key(self, event: QKeyEvent) -> bool:
+        """Act on a key pressed in the list; return whether the list used it, so the view does not act on it as well."""
+        if event.key() in (Qt.Key.Key_Return, Qt.Key.Key_Enter):
+            current_index = self.view.currentIndex()
+            if current_index.isValid():
+                self._choose_row(current_index.row())
+            return True
+        if event.key() == Qt.Key.Key_Escape:
+            self.close()
+            return True
+        typed_text = event.text()
+        number = repository_menu_number_by_key().get(typed_text)
+        if number is not None:
+            if number <= self.model.rowCount():
+                self._choose_row(number - FIRST_ROW_NUMBER)
+            return True
+        if len(typed_text) != TYPED_CHARACTER_LENGTH or not typed_text.isprintable() or typed_text.isspace():
+            return False
+        # No letter has a mnemonic, since the names show as written, so a letter is looked up in the repository names.
+        # The built-in keyboard search of the view is not used: it searches the number column and only ever chooses a
+        # row, never opens one. The key is used even when no name matches, so that search does not move the row either.
+        self._choose_by_name(typed_text)
+        return True
+
+    def _choose_by_name(self, typed_text: str) -> None:
+        """Open the only entry whose name starts with the typed letter, or choose the next of several without opening it."""
+        names = []
+        for row in range(self.model.rowCount()):
+            names.append(self.model.index(row, NAME_COLUMN).data())
+        matching_rows = rows_whose_name_starts_with(names, typed_text)
+        if not matching_rows:
+            return
+        first_row, *other_rows = matching_rows
+        if not other_rows:
+            self._choose_row(first_row)
+            return
+        next_index = self.model.index(next_row_after(matching_rows, self.view.currentIndex().row()), NUMBER_COLUMN)
+        self.view.setCurrentIndex(next_index)
+        self.view.scrollTo(next_index)
+
+    def mousePressEvent(self, event: QMouseEvent) -> None:
+        """Close on any press outside the list without letting that press reach the widget under the mouse."""
+        if self.rect().contains(event.position().toPoint()):
+            super().mousePressEvent(event)
+            return
+        # Workaround: Qt replays the press that closed a popup to the widget under the mouse on Windows, not on X11.
+        # Refusing the replay everywhere makes a click on the repository button close the list instead of opening it
+        # again, and keeps a click on any other control, such as Push or Commit, from acting while it closes the list.
+        # Qt clears this attribute at each new mouse event, so it is set right before closing.
+        self.setAttribute(Qt.WidgetAttribute.WA_NoMouseReplay)
+        self.close()
+
+    def _select_hovered_index(self, index: QModelIndex) -> None:
+        """Make the row under the mouse the chosen row, as a menu highlights the entry under the mouse."""
+        self.view.setCurrentIndex(index)
+
+    def _choose_index(self, index: QModelIndex) -> None:
+        """Choose the row that was clicked."""
+        self._choose_row(index.row())
+
+    def _choose_row(self, row: int) -> None:
+        """Close the list, then ask for the folder of a row.
+
+        The list closes first, as a menu closes before its action runs, so a window opened by the change, such as the
+        message about a missing folder, never shows under the list.
+        """
+        repository_dir = self.model.index(row, NUMBER_COLUMN).data(REPOSITORY_DIR_ROLE)
+        self.hide()
+        self.repository_chosen.emit(repository_dir)