gitpane 1.0.0__py3-none-any.whl

gitpane/ui/emoji/emoji_grid.py

@@ -0,0 +1,125 @@
+"""Grid of the emoji keyboard that the staging window shares with the floating keyboard window."""
+
+from __future__ import annotations
+
+from PySide6.QtCore import QEvent, Qt, Signal
+from PySide6.QtGui import QFont, QResizeEvent
+from PySide6.QtWidgets import QFrame, QGraphicsOpacityEffect, QLabel, QScrollArea, QToolButton, QVBoxLayout, QWidget
+
+from gitpane.config import EMOJI_GRID_DISABLED_OPACITY, EMOJI_MARK_BUTTON_WIDTH_RATIO, EMOJI_POINT_SIZE, SPACING_SM, SPACING_XS, emoji_button_side
+from gitpane.emoji.emoji_catalogue import COMBINING_MARK_ENTRIES, COMBINING_MARK_TITLE, EMOJI_ENTRIES
+from gitpane.ui.emoji.emoji_font import emoji_capable_font
+from gitpane.ui.widget.flow_layout import FlowLayout
+
+EMOJI_BUTTON_WIDTH_RATIO = 1
+# A frame and an inner margin sit on both edges of each axis.
+EDGES_PER_AXIS = 2
+
+
+class EmojiGrid(QScrollArea):
+    """Flat buttons for every catalogue symbol, wrapped to the available width.
+
+    The grid only reports which text was chosen and which button was clicked; the host decides what happens with it
+    (insertion into the commit message, or a copy to the clipboard).
+    """
+
+    chosen = Signal(str, object)
+
+    def __init__(self, parent: QWidget | None = None) -> None:
+        """Build every button once, in catalogue order, with the combining marks in their own titled row at the end."""
+        super().__init__(parent)
+        self.setWidgetResizable(True)
+        self.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
+        self.setVerticalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAsNeeded)
+        self.setFrameShape(QFrame.Shape.StyledPanel)
+        container = QWidget()
+        container_layout = QVBoxLayout(container)
+        container_layout.setContentsMargins(SPACING_XS, SPACING_XS, SPACING_XS, SPACING_XS)
+        container_layout.setSpacing(0)
+        self.emoji_area = QWidget()
+        emoji_layout = FlowLayout(self.emoji_area)
+        emoji_layout.setContentsMargins(0, 0, 0, 0)
+        self.mark_area = QWidget()
+        mark_layout = FlowLayout(self.mark_area)
+        mark_layout.setContentsMargins(0, 0, 0, 0)
+        # The symbol size is set on the two symbol areas only, so the marks title keeps the normal application font.
+        symbol_font = self._symbol_font()
+        self.emoji_area.setFont(symbol_font)
+        self.mark_area.setFont(symbol_font)
+        self.mark_title_label = QLabel(COMBINING_MARK_TITLE)
+        container_layout.addWidget(self.emoji_area)
+        container_layout.addSpacing(SPACING_SM)
+        container_layout.addWidget(self.mark_title_label)
+        container_layout.addSpacing(SPACING_XS)
+        container_layout.addWidget(self.mark_area)
+        container_layout.addStretch(1)
+        self.button_side = emoji_button_side(self.emoji_area.fontMetrics().height())
+        self.buttons: list[QToolButton] = []
+        for entries, layout, area, width_ratio in ((EMOJI_ENTRIES, emoji_layout, self.emoji_area, EMOJI_BUTTON_WIDTH_RATIO),
+                                                   (COMBINING_MARK_ENTRIES, mark_layout, self.mark_area, EMOJI_MARK_BUTTON_WIDTH_RATIO)):
+            for entry in entries:
+                button = QToolButton(area)
+                button.setAutoRaise(True)
+                button.setText(entry.shown_text())
+                button.setToolTip(entry.name)
+                button.setAccessibleName(entry.name)
+                button.setFixedSize(self.button_side * width_ratio, self.button_side)
+                button.clicked.connect(lambda checked=False, text=entry.text, button=button: self.chosen.emit(text, button))
+                layout.addWidget(button)
+                self.buttons.append(button)
+        self.setWidget(container)
+
+    def changeEvent(self, event: QEvent) -> None:
+        """Dim the symbols while the grid is disabled, and only then.
+
+        Colour emoji glyphs ignore the palette's disabled colour, so without this a disabled grid would look clickable.
+        """
+        if event.type() == QEvent.Type.EnabledChange:
+            if self.isEnabled():
+                self.widget().setGraphicsEffect(None)
+            else:
+                effect = QGraphicsOpacityEffect(self.widget())
+                effect.setOpacity(EMOJI_GRID_DISABLED_OPACITY)
+                self.widget().setGraphicsEffect(effect)
+        super().changeEvent(event)
+
+    def resizeEvent(self, event: QResizeEvent) -> None:
+        """Follow the new size, then drop a vertical scroll bar the symbols no longer need."""
+        super().resizeEvent(event)
+        self._drop_needless_scroll_bar()
+
+    def _drop_needless_scroll_bar(self) -> None:
+        """Hide the vertical scroll bar once every symbol fits at the full width of the grid.
+
+        Workaround: QScrollArea decides whether the bar is needed from the height its content asks at the current viewport
+        width, which is narrower while the bar is shown. When the symbols only fit at the full width (the bar's width
+        would push one symbol to a new row), the bar never goes away on its own, even at a height that shows every
+        symbol. Switching the bar off for a moment makes Qt measure the content again at the full width.
+        """
+        scroll_bar = self.verticalScrollBar()
+        if scroll_bar.isHidden() or self.widget() is None:
+            return
+        full_size = self.maximumViewportSize()
+        if self.widget().heightForWidth(full_size.width()) > full_size.height():
+            return
+        self.setVerticalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
+        self.setVerticalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAsNeeded)
+
+    def _symbol_font(self) -> QFont:
+        """Return the font the symbols are drawn with: the bundled colour emoji font at the keyboard size."""
+        return emoji_capable_font(EMOJI_POINT_SIZE)
+
+    def _length_for_cells(self, cell_count: int) -> int:
+        """Return the grid length that shows exactly this many symbol cells along one axis, frame and inner margins included.
+
+        Cells are square and the gap between them equals the inner margin, so the same length holds across and down.
+        """
+        return cell_count * self.button_side + (cell_count - 1) * SPACING_XS + EDGES_PER_AXIS * (SPACING_XS + self.frameWidth())
+
+    def row_height(self, row_count: int) -> int:
+        """Return the grid height that shows this many rows of symbols, frame and inner margins included."""
+        return self._length_for_cells(row_count)
+
+    def content_height_for_width(self, width: int) -> int:
+        """Return the grid height that shows every symbol without scrolling at this width, frame included."""
+        return self.widget().heightForWidth(width - EDGES_PER_AXIS * self.frameWidth()) + EDGES_PER_AXIS * self.frameWidth()

gitpane/ui/emoji/emoji_window.py

@@ -0,0 +1,154 @@
+"""Show the floating emoji keyboard every repository window shares, where a click copies a symbol to the clipboard."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import QByteArray, QPoint, QRect, QSize, Qt, QTimer, Signal
+from PySide6.QtGui import QAction, QClipboard, QKeySequence, QPalette
+from PySide6.QtWidgets import QFrame, QLabel, QStyle, QVBoxLayout, QWidget
+
+from gitpane.config import (
+    COPIED_TO_CLIPBOARD_TEXT,
+    EMOJI_COPY_TOAST_MS,
+    EMOJI_KEYBOARD_TITLE,
+    EMOJI_WINDOW_MIN_HEIGHT,
+    EMOJI_WINDOW_MIN_WIDTH,
+    EMOJI_WINDOW_SCREEN_WIDTH_SHARE,
+    SCREEN_MARGIN,
+    SPACING_SM,
+    SPACING_XS,
+    fit_window,
+    frame_position_inside,
+)
+from gitpane.ui.emoji.emoji_grid import EmojiGrid
+from gitpane.ui.window_control.window_placement import mark_window_placed
+
+if TYPE_CHECKING:
+    from PySide6.QtGui import QCloseEvent
+
+
+def toast_frame(button_frame: QRect, toast_size: QSize, available: QRect) -> QRect:
+    """Return where the copy bubble goes for a button, in global coordinates.
+
+    The bubble is centred on the button, a small gap above it; when that would cross the top of the usable screen area it
+    goes the same gap below the button instead, and it is always pulled back inside the screen.
+    """
+    left = button_frame.left() + (button_frame.width() - toast_size.width()) // 2
+    top = button_frame.top() - SPACING_XS - toast_size.height()
+    if top < available.top():
+        top = button_frame.bottom() + 1 + SPACING_XS
+    frame = QRect(QPoint(left, top), toast_size)
+    return QRect(frame_position_inside(frame, available), toast_size)
+
+
+class CopyToast(QLabel):
+    """Short-lived bubble above the clicked button that never takes the focus or the clicks; a new copy moves it and restarts its delay."""
+
+    def __init__(self, parent: QWidget) -> None:
+        """Build the hidden bubble once; the owning window moves and shows it on every copy."""
+        super().__init__(COPIED_TO_CLIPBOARD_TEXT, parent, Qt.WindowType.ToolTip | Qt.WindowType.FramelessWindowHint | Qt.WindowType.WindowTransparentForInput)
+        self.setAttribute(Qt.WidgetAttribute.WA_ShowWithoutActivating)
+        self.setFrameShape(QFrame.Shape.Box)
+        self.setAutoFillBackground(True)
+        self.setBackgroundRole(QPalette.ColorRole.ToolTipBase)
+        self.setForegroundRole(QPalette.ColorRole.ToolTipText)
+        self.setContentsMargins(SPACING_SM, SPACING_XS, SPACING_SM, SPACING_XS)
+        self.hide_timer = QTimer(self)
+        self.hide_timer.setSingleShot(True)
+        self.hide_timer.setInterval(EMOJI_COPY_TOAST_MS)
+        self.hide_timer.timeout.connect(self.hide)
+
+    def show_above(self, button: QWidget) -> None:
+        """Place the bubble over this button, inside its screen, and restart the countdown that hides it."""
+        self.adjustSize()
+        button_frame = QRect(button.mapToGlobal(QPoint(0, 0)), button.size())
+        frame = toast_frame(button_frame, self.size(), button.screen().availableGeometry())
+        self.move(frame.topLeft())
+        self.show()
+        self.raise_()
+        self.hide_timer.start()
+
+
+class EmojiWindow(QWidget):
+    """Always-on-top window showing the shared emoji grid; a click puts the exact symbol on the clipboard and pastes nothing.
+
+    The window has no Qt parent, so it belongs to no repository and outlives a repository switch in the window that opened it.
+    Its geometry is handed out on every close, as ASCII text, so the owner can keep it from one session to the next.
+    """
+
+    geometry_saved = Signal(str)
+
+    def __init__(self, clipboard: QClipboard) -> None:
+        """Build the grid once and write only to the clipboard it is given."""
+        super().__init__(None, Qt.WindowType.Window | Qt.WindowType.WindowStaysOnTopHint)
+        # A window without a parent that keeps this attribute holds back the "last window closed" signal when the last
+        # repository window closes, and GitPane would never stop while the keyboard is open.
+        self.setAttribute(Qt.WidgetAttribute.WA_QuitOnClose, False)
+        self.setWindowTitle(EMOJI_KEYBOARD_TITLE)
+        self.clipboard = clipboard
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(SPACING_SM, SPACING_SM, SPACING_SM, SPACING_SM)
+        self.grid = EmojiGrid()
+        layout.addWidget(self.grid)
+        self.grid.chosen.connect(self.copy_symbol)
+        self.toast = CopyToast(self)
+        close_action = QAction("Close", self)
+        close_action.setShortcuts([QKeySequence(Qt.Key.Key_Escape), QKeySequence("Ctrl+W")])
+        close_action.triggered.connect(self.close)
+        self.addAction(close_action)
+
+    def copy_symbol(self, text: str, button: QWidget) -> None:
+        """Put the exact symbol on the system clipboard and confirm it over the clicked button.
+
+        This is the only clipboard access of the window, and it never reads the clipboard.
+        """
+        self.clipboard.setText(text, QClipboard.Mode.Clipboard)
+        self.toast.show_above(button)
+
+    def resize_to_whole_grid(self, available: QRect) -> None:
+        """Take the first-open size from the grid's real layout, so every symbol and mark shows without scrolling, within the screen.
+
+        The usable area is the one of the screen the window is about to open on: before it is shown the window does not
+        know that screen yet, and would otherwise report the primary one. The window starts at a share of the usable
+        width, with the height the laid-out grid asks for at that width. When that height does not fit, the window grows
+        wider one symbol at a time, which removes rows, until it fits or reaches the usable width; only then does the
+        grid scroll.
+        """
+        inner_area = available.adjusted(SCREEN_MARGIN, SCREEN_MARGIN, -SCREEN_MARGIN, -SCREEN_MARGIN)
+        # The title bar only has a real height once the window is shown; the style's title bar height stands in for it.
+        title_bar_height = self.style().pixelMetric(QStyle.PixelMetric.PM_TitleBarHeight, None, self)
+        maximum_width = max(1, inner_area.width())
+        maximum_height = max(1, inner_area.height() - title_bar_height)
+        width = min(maximum_width, max(EMOJI_WINDOW_MIN_WIDTH, round(inner_area.width() * EMOJI_WINDOW_SCREEN_WIDTH_SHARE)))
+        height = self._height_for_width(width)
+        symbol_step = self.grid.button_side + SPACING_XS
+        while height > maximum_height and width < maximum_width:
+            width = min(maximum_width, width + symbol_step)
+            height = self._height_for_width(width)
+        self.resize(width, min(height, maximum_height))
+        fit_window(self, EMOJI_WINDOW_MIN_WIDTH, EMOJI_WINDOW_MIN_HEIGHT, available)
+
+    def _height_for_width(self, width: int) -> int:
+        """Return the window height that shows the whole laid-out grid at this window width, margins included."""
+        margins = self.layout().contentsMargins()
+        grid_width = width - margins.left() - margins.right()
+        return self.grid.content_height_for_width(grid_width) + margins.top() + margins.bottom()
+
+    def restore_saved_geometry(self, value: str) -> bool:
+        """Put the window back where a previous session left it; return True only when Qt could read the saved geometry.
+
+        A restored window is marked as placed, so its first show keeps that place instead of centring it again. An empty
+        or non-ASCII value cannot come from a saved geometry, so it is refused before Qt reads anything.
+        """
+        if not value or not value.isascii():
+            return False
+        restored = self.restoreGeometry(QByteArray.fromBase64(value.encode("ascii")))
+        if restored:
+            mark_window_placed(self)
+        return restored
+
+    def closeEvent(self, event: QCloseEvent) -> None:
+        """Hand the current geometry to the owner before closing, with the same text encoding as the other saved window states."""
+        self.geometry_saved.emit(bytes(self.saveGeometry().toBase64()).decode("ascii"))
+        event.accept()

gitpane/ui/emoji/file_action_icon.py

@@ -0,0 +1,131 @@
+"""Produce colour icons for file menu actions."""
+
+from __future__ import annotations
+
+from enum import Enum
+from typing import TYPE_CHECKING, assert_never
+
+from PySide6.QtCore import QPointF, QRectF, Qt
+from PySide6.QtGui import QIcon, QPainter, QPixmap, QPixmapCache, QTextLayout
+from PySide6.QtWidgets import QStyle
+
+from gitpane.config import EMOJI_GRID_DISABLED_OPACITY
+from gitpane.ui.emoji.emoji_font import emoji_capable_font
+from gitpane.ui.look.icon_density import physical_icon_side
+from gitpane.worktree.file_menu_action import FileAction
+from gitpane.worktree.ignore_rule import IgnoreDestination
+
+if TYPE_CHECKING:
+    from PySide6.QtGui import QFont
+    from PySide6.QtWidgets import QMenu
+
+SYMBOL_MARGIN = 1.0
+PIXMAP_CACHE_PREFIX = "gitpane-file-action:"
+
+
+class FileActionSymbol(Enum):
+    """Keep each file action's complete emoji sequence in one UI definition."""
+
+    STAGE = "📥"
+    RESET = "↩️"
+    DELETE = "🗑️"
+    COPY = "📋"
+    FOLDER = "📂"
+    TEXT_EDITOR = "📝"
+    HISTORY = "📜"
+    COMPARE = "⚖️"
+    SAVE_AS = "💾"
+    IGNORE = "🙈"
+    STOP_TRACKING = "🔓"
+    HISTORY_REMOVE = "🧹"
+
+
+def file_action_symbol(action: FileAction | IgnoreDestination) -> FileActionSymbol:
+    """Choose a symbol by domain identity without interpreting the displayed label."""
+    match action:
+        case FileAction.STAGE:
+            return FileActionSymbol.STAGE
+        case FileAction.RESET | FileAction.RESET_TO:
+            return FileActionSymbol.RESET
+        case FileAction.DELETE:
+            return FileActionSymbol.DELETE
+        case FileAction.COPY_PATHS | FileAction.COPY_BASENAME | FileAction.COPY_ABSOLUTE:
+            return FileActionSymbol.COPY
+        case FileAction.FOLDER:
+            return FileActionSymbol.FOLDER
+        case FileAction.TEXT_EDITOR:
+            return FileActionSymbol.TEXT_EDITOR
+        case FileAction.HISTORY | FileAction.DISPLAY_HISTORY:
+            return FileActionSymbol.HISTORY
+        case FileAction.COMPARE:
+            return FileActionSymbol.COMPARE
+        case FileAction.SAVE_AS:
+            return FileActionSymbol.SAVE_AS
+        case FileAction.STOP_TRACKING:
+            return FileActionSymbol.STOP_TRACKING
+        case FileAction.REMOVE_FROM_HISTORY:
+            return FileActionSymbol.HISTORY_REMOVE
+        case IgnoreDestination.WORKTREE | IgnoreDestination.EXCLUDE:
+            return FileActionSymbol.IGNORE
+    assert_never(action)
+
+
+def file_action_icon(action: FileAction | IgnoreDestination, menu: QMenu) -> QIcon:
+    """Render both action states at the menu's font size and screen density using Qt's bounded cache."""
+    symbol = file_action_symbol(action)
+    font = emoji_capable_font()
+    menu_font = menu.font()
+    if menu_font.pixelSize() > 0:
+        font.setPixelSize(menu_font.pixelSize())
+    else:
+        font.setPointSizeF(menu_font.pointSizeF())
+    side = max(menu.fontMetrics().height(), menu.style().pixelMetric(QStyle.PixelMetric.PM_SmallIconSize, None, menu))
+    density = menu.devicePixelRatioF()
+    cache_prefix = PIXMAP_CACHE_PREFIX + repr((symbol.value, font.toString(), menu_font.toString(), side, density))
+    icon = QIcon()
+    normal = None
+    for mode in (QIcon.Mode.Normal, QIcon.Mode.Disabled):
+        cache_key = cache_prefix + mode.name
+        pixmap = QPixmapCache.find(cache_key)
+        if pixmap is None:
+            physical_side = physical_icon_side(side, density)
+            pixmap = QPixmap(physical_side, physical_side)
+            pixmap.setDevicePixelRatio(density)
+            pixmap.fill(Qt.GlobalColor.transparent)
+            painter = QPainter(pixmap)
+            if mode == QIcon.Mode.Normal:
+                _paint_symbol(painter, symbol, font, QRectF(0, 0, side, side))
+            else:
+                painter.setOpacity(EMOJI_GRID_DISABLED_OPACITY)
+                painter.drawPixmap(QPointF(0, 0), normal)
+            painter.end()
+            QPixmapCache.insert(cache_key, pixmap)
+        if mode == QIcon.Mode.Normal:
+            normal = pixmap
+        icon.addPixmap(pixmap, mode)
+    return icon
+
+
+def _paint_symbol(painter: QPainter, symbol: FileActionSymbol, font: QFont, target: QRectF) -> None:
+    """Fit a complete shaped emoji into a transparent margin without replacing its colour glyphs."""
+    layout = QTextLayout(symbol.value, font)
+    layout.beginLayout()
+    layout.createLine()
+    layout.endLayout()
+    runs = layout.glyphRuns()
+    bounds = QRectF()
+    for run in runs:
+        bounds = bounds.united(run.boundingRect())
+    if bounds.isEmpty():
+        return
+    # Centred drawText uses line metrics that can clip colour emoji; fit the shaped glyph bounds instead.
+    inset = target.adjusted(SYMBOL_MARGIN, SYMBOL_MARGIN, -SYMBOL_MARGIN, -SYMBOL_MARGIN)
+    scale = min(inset.width() / bounds.width(), inset.height() / bounds.height())
+    painter.save()
+    painter.setRenderHint(QPainter.RenderHint.SmoothPixmapTransform)
+    painter.translate(inset.center())
+    painter.scale(scale, scale)
+    painter.translate(-bounds.center())
+    for run in runs:
+        painter.drawGlyphRun(QPointF(0, 0), run)
+    painter.restore()

gitpane/ui/emoji/opentype_family_name.py

@@ -0,0 +1,182 @@
+"""Return a copy of OpenType font bytes whose `name` table gives the font another family name, every other table left as it is.
+
+The new name table is appended at the end of the copy and the table directory points to it; the old one stays in place,
+unreferenced. The table checksum and the whole-font checksum adjustment of the `head` table are computed again, so the
+copy stays a valid font for any font engine. Malformed bytes raise ValueError and nothing is written anywhere: the copy
+lives in memory only.
+"""
+
+from __future__ import annotations
+
+import struct
+import sys
+from array import array
+
+# Versions a single (not collection) OpenType font starts with: TrueType outlines, the Apple "true" tag, CFF outlines.
+SINGLE_FONT_SFNT_VERSION_SET = {b"\x00\x01\x00\x00", b"true", b"OTTO"}
+OFFSET_TABLE_FORMAT = ">4sHHHH"
+TABLE_RECORD_FORMAT = ">4sIII"
+NAME_HEADER_FORMAT = ">HHH"
+NAME_RECORD_FORMAT = ">HHHHHH"
+OFFSET_TABLE_SIZE = struct.calcsize(OFFSET_TABLE_FORMAT)
+TABLE_RECORD_SIZE = struct.calcsize(TABLE_RECORD_FORMAT)
+NAME_HEADER_SIZE = struct.calcsize(NAME_HEADER_FORMAT)
+NAME_RECORD_SIZE = struct.calcsize(NAME_RECORD_FORMAT)
+NAME_TABLE_TAG = b"name"
+HEAD_TABLE_TAG = b"head"
+# Name table format 1 adds language tag records after the name records; both keep their strings in the same storage.
+SUPPORTED_NAME_FORMAT_SET = {0, 1}
+# Byte offsets of the fields patched in a table record and in a name record.
+TABLE_RECORD_CHECKSUM_OFFSET = 4
+NAME_RECORD_LENGTH_OFFSET = 8
+# In the head table, the field that makes the whole font sum to the magic number below.
+HEAD_CHECKSUM_ADJUSTMENT_OFFSET = 8
+HEAD_CHECKSUM_ADJUSTMENT_FORMAT = ">I"
+CHECKSUM_MAGIC = 0xB1B0AFBA
+UINT32_MODULO = 1 << 32
+UINT16_LIMIT = 1 << 16
+TABLE_ALIGNMENT = 4
+# Name ids that carry the family: family (1), unique id (3), full name (4), typographic family (16), WWS family (21).
+# Fontconfig and DirectWrite read the family from several of them, so all are renamed, never one alone.
+FAMILY_NAME_ID_SET = {1, 3, 4, 16, 21}
+POSTSCRIPT_NAME_ID = 6
+# Unicode (0) and Windows (3) strings are UTF-16 big endian; Macintosh (1) strings are in a Mac script encoding, which
+# matches ASCII for the ASCII names written here.
+UNICODE_PLATFORM_ID = 0
+MACINTOSH_PLATFORM_ID = 1
+WINDOWS_PLATFORM_ID = 3
+TEXT_ENCODING_BY_PLATFORM_ID = {UNICODE_PLATFORM_ID: "utf-16-be", MACINTOSH_PLATFORM_ID: "ascii", WINDOWS_PLATFORM_ID: "utf-16-be"}
+# array("I") holds machine words; the font words are big endian.
+UINT32_TYPECODE = "I"
+UINT32_SIZE = 4
+
+
+def postscript_name(family: str) -> str:
+    """Return the PostScript name of a family: the family without spaces, the form the PostScript name id expects."""
+    return family.replace(" ", "")
+
+
+def font_with_family_name(content: bytes, family: str) -> bytes:
+    """Return a copy of the font bytes whose name table names `family`, the original bytes left untouched.
+
+    Every family record (family, unique id, full name, typographic and WWS family) takes `family` and the PostScript
+    record takes it without spaces; other records keep their strings. `family` must be ASCII so the Macintosh records
+    can hold it. A font collection, a missing table, a record outside its table or an unknown platform raises ValueError.
+    """
+    if not family.isascii() or family == "":
+        raise ValueError("The new family name must be non-empty ASCII")
+    try:
+        name_record_offset, name_offset, name_length = name_table_location(content)
+        new_name_table = renamed_name_table(content[name_offset:name_offset + name_length], family)
+        copy = bytearray(content)
+        copy.extend(bytes(padding_length(len(copy))))
+        new_name_offset = len(copy)
+        copy.extend(new_name_table)
+        copy.extend(bytes(padding_length(len(copy))))
+        struct.pack_into(">III", copy, name_record_offset + TABLE_RECORD_CHECKSUM_OFFSET, table_checksum(new_name_table), new_name_offset, len(new_name_table))
+        set_checksum_adjustment(copy)
+    except struct.error as error:
+        raise ValueError("The font is truncated: " + str(error)) from error
+    return bytes(copy)
+
+
+def table_records(content: bytes | bytearray) -> list[tuple[bytes, int, int, int]]:
+    """Return each table record of a single font as (tag, record offset, table offset, table length), checked to lie in the bytes."""
+    sfnt_version, table_count, _search_range, _entry_selector, _range_shift = struct.unpack_from(OFFSET_TABLE_FORMAT, content, 0)
+    if sfnt_version not in SINGLE_FONT_SFNT_VERSION_SET:
+        raise ValueError("Not a single OpenType font (version " + sfnt_version.hex() + ")")
+    records = []
+    for index in range(table_count):
+        record_offset = OFFSET_TABLE_SIZE + index * TABLE_RECORD_SIZE
+        tag, _checksum, table_offset, table_length = struct.unpack_from(TABLE_RECORD_FORMAT, content, record_offset)
+        if table_offset + table_length > len(content):
+            raise ValueError("The table " + ascii(tag) + " lies past the end of the font")
+        records.append((tag, record_offset, table_offset, table_length))
+    return records
+
+
+def name_table_location(content: bytes) -> tuple[int, int, int]:
+    """Return the offset of the name table record, then the offset and length of the name table itself."""
+    for tag, record_offset, table_offset, table_length in table_records(content):
+        if tag == NAME_TABLE_TAG:
+            return record_offset, table_offset, table_length
+    raise ValueError("The font has no name table")
+
+
+def renamed_name_table(name_table: bytes, family: str) -> bytes:
+    """Return the name table with its family and PostScript records pointing to new strings appended to its storage.
+
+    The header, the records left alone, the language tags and the old strings keep their bytes and their offsets.
+    """
+    name_format, record_count, storage_offset = struct.unpack_from(NAME_HEADER_FORMAT, name_table, 0)
+    if name_format not in SUPPORTED_NAME_FORMAT_SET:
+        raise ValueError("Unknown name table format " + str(name_format))
+    if storage_offset > len(name_table):
+        raise ValueError("The name strings lie past the end of the name table")
+    table = bytearray(name_table)
+    for index in range(record_count):
+        record_offset = NAME_HEADER_SIZE + index * NAME_RECORD_SIZE
+        platform_id, _encoding_id, _language_id, name_id, string_length, string_offset = struct.unpack_from(NAME_RECORD_FORMAT, name_table, record_offset)
+        if storage_offset + string_offset + string_length > len(name_table):
+            raise ValueError("The name record " + str(name_id) + " lies past the end of the name table")
+        text = new_name_text(name_id, family)
+        if text is None:
+            continue
+        encoding = TEXT_ENCODING_BY_PLATFORM_ID.get(platform_id)
+        if encoding is None:
+            raise ValueError("Unknown platform " + str(platform_id) + " in the name record " + str(name_id))
+        encoded = text.encode(encoding)
+        new_string_offset = len(table) - storage_offset
+        if new_string_offset + len(encoded) >= UINT16_LIMIT:
+            raise ValueError("The renamed name table would be too large")
+        table.extend(encoded)
+        struct.pack_into(">HH", table, record_offset + NAME_RECORD_LENGTH_OFFSET, len(encoded), new_string_offset)
+    return bytes(table)
+
+
+def new_name_text(name_id: int, family: str) -> str | None:
+    """Return the new string of a name record, or None when the record keeps its own."""
+    if name_id in FAMILY_NAME_ID_SET:
+        return family
+    if name_id == POSTSCRIPT_NAME_ID:
+        return postscript_name(family)
+    return None
+
+
+def padding_length(length: int) -> int:
+    """Return how many zero bytes bring a length up to the next table alignment."""
+    return -length % TABLE_ALIGNMENT
+
+
+def word_sum(data: bytes | bytearray) -> int:
+    """Return the sum, modulo 2**32, of the big endian 32 bit words of the data, padded with zeros to a whole word."""
+    words = array(UINT32_TYPECODE)
+    if words.itemsize != UINT32_SIZE:
+        raise ValueError("This Python has no 32 bit unsigned array")
+    padding = padding_length(len(data))
+    if padding:
+        data = bytes(data) + bytes(padding)
+    words.frombytes(data)
+    if sys.byteorder == "little":
+        words.byteswap()
+    return sum(words) % UINT32_MODULO
+
+
+def table_checksum(table: bytes) -> int:
+    """Return the OpenType checksum of a table."""
+    return word_sum(table)
+
+
+def set_checksum_adjustment(font: bytearray) -> None:
+    """Write the head table's checksum adjustment so the whole font sums to the OpenType magic number.
+
+    The adjustment counts as zero in the sum, which is also why the head table's own checksum does not change.
+    """
+    for tag, _record_offset, table_offset, _table_length in table_records(font):
+        if tag != HEAD_TABLE_TAG:
+            continue
+        adjustment_offset = table_offset + HEAD_CHECKSUM_ADJUSTMENT_OFFSET
+        struct.pack_into(HEAD_CHECKSUM_ADJUSTMENT_FORMAT, font, adjustment_offset, 0)
+        struct.pack_into(HEAD_CHECKSUM_ADJUSTMENT_FORMAT, font, adjustment_offset, (CHECKSUM_MAGIC - word_sum(font)) % UINT32_MODULO)
+        return
+    raise ValueError("The font has no head table")

gitpane/ui/history_rewrite/details.py

@@ -0,0 +1,78 @@
+"""Present complete history rewrite details as selectable plain text."""
+
+from __future__ import annotations
+
+from enum import Enum
+from typing import TYPE_CHECKING
+
+from PySide6.QtWidgets import QApplication, QDialog, QPlainTextEdit, QPushButton, QVBoxLayout
+
+from gitpane.config import fit_window
+from gitpane.ui.history_rewrite.preview_model import CommitColumn, ModelText, author_date, safe_text
+from gitpane.ui.widget.dialog_layout import install_banded_layout
+from gitpane.ui.window_control.dialog_modality import open_window_modal
+
+if TYPE_CHECKING:
+    from PySide6.QtWidgets import QWidget
+
+    from gitpane.history_rewrite.value import RewriteRow
+
+DETAIL_WIDTH, DETAIL_HEIGHT = 720, 480
+DETAIL_MINIMUM_WIDTH, DETAIL_MINIMUM_HEIGHT = 320, 240
+
+
+class DetailsText(Enum):
+    """Name the complete-text window and its actions."""
+
+    TITLE = "History rewrite details"
+    COPY = "Copy details"
+    CLOSE = "Close"
+    INCOMPLETE = "The complete commit message is unavailable. Recompute the preview before confirming."
+
+
+def commit_details(row: RewriteRow, message_filename: str = "") -> str:
+    """Read only the chosen message from its private spool, never from Git."""
+    message = row.message
+    if row.message_offset is not None:
+        if not message_filename:
+            raise ValueError(DetailsText.INCOMPLETE.value)
+        with open(message_filename, "rb") as stream:
+            stream.seek(row.message_offset)
+            message = stream.read(row.message_length)
+        if len(message) != row.message_length:
+            raise ValueError(DetailsText.INCOMPLETE.value)
+    lines = [f"{CommitColumn.COMMIT.value}: {row.oid}", f"{CommitColumn.AUTHOR.value}: {safe_text(row.author)}",
+             f"{CommitColumn.DATE.value}: {author_date(row.date)}", f"{CommitColumn.MESSAGE.value}:", safe_text(message, multiline=True) if message else ModelText.NO_MESSAGE.value]
+    return "\n".join(lines)
+
+
+class HistoryRewriteDetails(QDialog):
+    """Offer a complete, copyable detail with no repository operation."""
+
+    def __init__(self, text: str, parent: QWidget | None = None) -> None:
+        """Build a native read-only text area with explicit copy and close actions."""
+        super().__init__(parent)
+        self.setWindowTitle(DetailsText.TITLE.value)
+        self.resize(DETAIL_WIDTH, DETAIL_HEIGHT)
+        self.text = QPlainTextEdit()
+        self.text.setReadOnly(True)
+        self.text.setPlainText(text)
+        self.text.setAccessibleName(DetailsText.TITLE.value)
+        self.copy_button = QPushButton(DetailsText.COPY.value)
+        self.close_button = QPushButton(DetailsText.CLOSE.value)
+        self.copy_button.setAutoDefault(False)
+        self.close_button.setAutoDefault(False)
+        self.copy_button.clicked.connect(self.copy_details)
+        self.close_button.clicked.connect(self.reject)
+        body = QVBoxLayout()
+        body.addWidget(self.text)
+        self.button_band = install_banded_layout(self, body, [self.copy_button, self.close_button])
+        fit_window(self, DETAIL_MINIMUM_WIDTH, DETAIL_MINIMUM_HEIGHT)
+
+    def copy_details(self) -> None:
+        """Copy the exact visible text, including escaped raw bytes."""
+        QApplication.clipboard().setText(self.text.toPlainText())
+
+    def show_modal(self) -> None:
+        """Open through the common native modality policy."""
+        open_window_modal(self)