gitpane 1.0.0__py3-none-any.whl

gitpane/controller/welcome_controller.py

@@ -0,0 +1,102 @@
+"""Show the welcome window of GitPane, where a repository is chosen."""
+
+from __future__ import annotations
+
+import uuid
+from typing import TYPE_CHECKING
+
+from gitpane.config import SharedText
+from gitpane.history.file_history import WindowCapability
+from gitpane.ui.welcome.welcome_window import WelcomeWindow
+
+if TYPE_CHECKING:
+    from PySide6.QtWidgets import QWidget
+
+    from gitpane.controller.clone_controller import CloneController
+    from gitpane.controller.opening_controller import OpeningController
+    from gitpane.controller.operation_policy import OperationPolicy
+    from gitpane.controller.session_registry import SessionRegistry
+    from gitpane.controller.setting_controller import SettingController
+    from gitpane.controller.window_activation import WindowActivationFilter
+    from gitpane.history.repository import GitRepository
+    from gitpane.operation.diagnostic import DiagnosticLog
+    from gitpane.preference.preference_store import PreferenceStore
+
+
+class WelcomeController:
+    """The single welcome window of GitPane, shown again when no usable Git is found or a repository window asks for it."""
+
+    def __init__(self, *, session_registry_controller: SessionRegistry, operation_policy_controller: OperationPolicy, window_activation_controller: WindowActivationFilter, setting_controller: SettingController, clone_controller: CloneController,
+                 opening_controller: OpeningController, preference: PreferenceStore, repository: GitRepository, diagnostic_log: DiagnosticLog | None) -> None:
+        """Receive the services and the lower controllers the welcome window works with; the wiring builds it after the opening controller, and Settings tells it through the wiring when no usable Git was found."""
+        self.session_registry_controller = session_registry_controller
+        self.operation_policy_controller = operation_policy_controller
+        self.window_activation_controller = window_activation_controller
+        self.setting_controller = setting_controller
+        self.clone_controller = clone_controller
+        self.opening_controller = opening_controller
+        self.preference = preference
+        self.repository = repository
+        self.diagnostic_log = diagnostic_log
+
+    def show_welcome(self, anchor: QWidget | None = None) -> WelcomeWindow:
+        """Focus the single chooser or reopen it using current shared preferences.
+
+        A new chooser opens centred on ``anchor``, the repository window it was asked from, or on the screen without one.
+        A chooser already open is only brought to the front, where it is.
+        """
+        if self.session_registry_controller.welcome_by_session:
+            window = next(iter(self.session_registry_controller.welcome_by_session.values()))
+            window.showNormal()
+            window.raise_()
+            window.activateWindow()
+            return window
+        session_id = uuid.uuid4().hex
+        window = WelcomeWindow(self.preference.read_recent(), anchor, diagnostic_log=self.diagnostic_log)
+        self.session_registry_controller.welcome_by_session[session_id] = window
+        window.open_requested.connect(lambda repository_dir: self.opening_controller.open_from_welcome(session_id, repository_dir))
+        window.clone_requested.connect(lambda: self.clone_controller.show_clone(session_id))
+        window.cancel_requested.connect(lambda: self.opening_controller.cancel_open(session_id))
+        window.closed.connect(lambda: self._close_welcome(session_id))
+        window.setting_requested.connect(self.setting_controller.show_setting)
+        window.installEventFilter(self.window_activation_controller)
+        window.show()
+        if self.diagnostic_log is not None and self.diagnostic_log.warning:
+            window.show_status(self.diagnostic_log.warning)
+        elif self.preference.warning:
+            window.show_status(self.preference.warning)
+        return window
+
+    def show_missing_git(self) -> None:
+        """Keep repository input available and expose a direct path to Git correction."""
+        welcome = self.show_welcome()
+        welcome.show_status("Git was not found\nNo usable Git executable was found. Choose its path in Settings.")
+        welcome.setting_button.setText(SharedText.SETTING_BUTTON_MISSING_GIT.value)
+        dialog = self.setting_controller.show_setting()
+        dialog.status_label.setText(welcome.status_label.text())
+
+    def reopen_welcome(self, session_id: str | None = None) -> WelcomeWindow | None:
+        """Expose the repository-window action that restores the shared chooser."""
+        if session_id is not None and not self.operation_policy_controller.allows(session_id, WindowCapability.MANAGE):
+            return None
+        return self.show_welcome(self.session_registry_controller.window_by_session.get(session_id) if session_id is not None else None)
+
+    def _close_welcome(self, session_id: str) -> None:
+        """Drop a closed chooser without cancelling a successfully opened repository.
+
+        The chooser and its clone form are handed to Qt for deletion, so they end at a safe moment of the event loop
+        instead of wherever their last Python reference happens to go away, such as on return from the close event.
+        """
+        welcome = self.session_registry_controller.welcome_by_session.pop(session_id, None)
+        if welcome is not None:
+            self.clone_controller.cancel_clone(session_id)
+            dialog = self.session_registry_controller.clone_dialog_by_session.pop(session_id, None)
+            if dialog is not None:
+                dialog.close()
+                dialog.deleteLater()
+            self.session_registry_controller.identity_by_session.pop(session_id, None)
+            self.repository.cancel(session_id)
+            self.session_registry_controller.generation_by_session.pop(session_id, None)
+            welcome.deleteLater()
+        self.setting_controller.forget_waiting_opening(session_id)
+        self.session_registry_controller.opening_dir_by_session.pop(session_id, None)

gitpane/controller/window_activation.py

@@ -0,0 +1,116 @@
+"""Follow the windows of GitPane as the system shows, activates or deactivates them."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import QEvent, QObject, Qt, QTimer
+from PySide6.QtWidgets import QWidget
+from shiboken6 import isValid
+
+from gitpane.controller.session_registry import WindowDisplayBinding
+from gitpane.history.file_history import WindowCapability
+from gitpane.worktree.worktree_snapshot import WorktreeKey
+
+if TYPE_CHECKING:
+    from PySide6.QtWidgets import QApplication
+
+    from gitpane.controller.operation_policy import OperationPolicy
+    from gitpane.controller.session_registry import SessionRegistry
+    from gitpane.controller.staging_session_registry import StagingSessionRegistry
+    from gitpane.preference.preference_store import PreferenceStore
+
+# The only events the filter acts on; it runs on every event of the application, so it lets any other one through at once.
+FOLLOWED_EVENT_TYPE_SET = frozenset({QEvent.Type.Show, QEvent.Type.WindowActivate, QEvent.Type.WindowDeactivate})
+
+
+class WindowActivationFilter(QObject):
+    """The event filter of the application and of every window of GitPane, which tells each preparation session whether one of its windows is active."""
+
+    def __init__(self, *, session_registry_controller: SessionRegistry, operation_policy_controller: OperationPolicy, staging_session_registry_controller: StagingSessionRegistry,
+                 application: QApplication, preference: PreferenceStore, parent: QObject | None = None) -> None:
+        """Receive the application, the preferences and the registries the filter reads; the wiring installs it on the application before the placement filter."""
+        super().__init__(parent)
+        self.session_registry_controller = session_registry_controller
+        self.operation_policy_controller = operation_policy_controller
+        self.staging_session_registry_controller = staging_session_registry_controller
+        self.application = application
+        self.preference = preference
+        self.activation_update_pending = False
+
+    def eventFilter(self, watched: QObject, event: QEvent) -> bool:
+        """Follow the screen and the activation of the windows of GitPane, letting every event through."""
+        if event.type() not in FOLLOWED_EVENT_TYPE_SET or not isinstance(watched, QWidget) or not watched.isWindow():
+            return super().eventFilter(watched, event)
+        owner = self._top_level_owner(watched)
+        owned = (owner in self.session_registry_controller.welcome_by_session.values() or owner in self.session_registry_controller.window_by_session.values()
+                 or owner is self.session_registry_controller.setting_dialog or any(owner is staging.window for staging in self.staging_session_registry_controller.staging_by_key.values()))
+        if not owned:
+            return super().eventFilter(watched, event)
+        if event.type() == QEvent.Type.Show and hasattr(watched, "refresh_metrics") and not hasattr(watched, "display_binding"):
+            watched.display_binding = WindowDisplayBinding(watched, self.application)
+            watched.display_binding.schedule_refresh()
+        if event.type() == QEvent.Type.WindowActivate:
+            self.preference.refresh()
+            self.schedule_activation_update()
+        if event.type() == QEvent.Type.WindowDeactivate:
+            self.schedule_activation_update()
+        return super().eventFilter(watched, event)
+
+    def _top_level_owner(self, widget: QWidget) -> QWidget:
+        """Answer the top level window a widget belongs to, walking up its parents."""
+        owner = widget
+        while owner.parentWidget() is not None:
+            owner = owner.parentWidget()
+        return owner
+
+    def schedule_activation_update(self, *arguments: object) -> None:
+        """Ask for one reading of which window is active, once the current burst of events is over.
+
+        Activation events arrive twice for a window that carries the filter itself, and in bursts when a dialog opens
+        or closes. The state is therefore read once, after them, instead of being toggled event by event.
+        """
+        if self.activation_update_pending or self.session_registry_controller.shutdown_requested:
+            return
+        self.activation_update_pending = True
+        QTimer.singleShot(0, self, self._update_window_activation)
+
+    def _worktree_key_of_window(self, owner: QWidget | None) -> WorktreeKey | None:
+        """Answer the worktree a top level window belongs to, or nothing when it belongs to none."""
+        if owner is None:
+            return None
+        for session_id, window in self.session_registry_controller.window_by_session.items():
+            if window is owner and isValid(window) and self.operation_policy_controller.allows(session_id, WindowCapability.MANAGE) and not window.context.is_bare:
+                return WorktreeKey.from_context(window.context)
+        for staging in self.staging_session_registry_controller.staging_by_key.values():
+            if staging.window is owner:
+                return staging.key
+        return None
+
+    def _worktree_has_open_window(self, key: WorktreeKey) -> bool:
+        """Tell whether this worktree still has a window of its own on screen."""
+        for session_id, window in self.session_registry_controller.window_by_session.items():
+            if not isValid(window) or window.is_closed or window.context.is_bare:
+                continue
+            if self.operation_policy_controller.allows(session_id, WindowCapability.MANAGE) and WorktreeKey.from_context(window.context) == key:
+                return True
+        staging = self.staging_session_registry_controller.staging_by_key.get(key)
+        return staging is not None and staging.window is not None
+
+    def _update_window_activation(self) -> None:
+        """Publish to every preparation session whether one of its own windows is the active window."""
+        self.activation_update_pending = False
+        if self.session_registry_controller.shutdown_requested:
+            return
+        active_window = self.application.activeWindow()
+        # Between closing a window and activating the next one, Qt has no active window for one turn of the loop while
+        # the application is still active. Reading that as a loss of activation would make closing any dialog read again.
+        between_windows = active_window is None and self.application.applicationState() == Qt.ApplicationState.ApplicationActive
+        active_key = self._worktree_key_of_window(self._top_level_owner(active_window)) if active_window is not None else None
+        for staging in tuple(self.staging_session_registry_controller.staging_by_key.values()):
+            if not self._worktree_has_open_window(staging.key):
+                staging.set_window_active(False)
+                continue
+            if between_windows:
+                continue
+            staging.set_window_active(staging.key == active_key)

gitpane/controller/worktree_state_controller.py

@@ -0,0 +1,169 @@
+"""Show the state of each worktree in the repository windows that manage it."""
+
+from __future__ import annotations
+
+from dataclasses import replace
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import QObject, Signal
+from shiboken6 import isValid
+
+from gitpane.controller.refresh_controller import RefreshScope
+from gitpane.history.file_history import WindowCapability
+from gitpane.ui.look.action_icon import action_icon
+from gitpane.worktree.worktree_snapshot import WorktreeColorState, WorktreeKey
+
+if TYPE_CHECKING:
+    from gitpane.controller.reference_read_controller import ReferenceReadController
+    from gitpane.controller.refresh_controller import RefreshController
+    from gitpane.controller.session_registry import SessionRegistry
+    from gitpane.controller.staging_session_registry import StagingSessionRegistry
+    from gitpane.history.repository_value import RepositoryContext
+    from gitpane.operation.repository_operation import RepositoryOperationService
+    from gitpane.sequencer.conflict import ConflictService
+    from gitpane.sequencer.mergetool import MergetoolService
+    from gitpane.sequencer.rebase_state import RebaseSnapshot
+    from gitpane.sequencer.replay_state import ReplaySnapshot
+    from gitpane.ui.repository.repository_window import RepositoryWindow
+
+
+def same_pause_state(first: RebaseSnapshot | ReplaySnapshot | None, second: RebaseSnapshot | ReplaySnapshot | None) -> bool:
+    """Tell whether two published pause states show the same thing, the read number aside."""
+    if first is None or second is None:
+        return False
+    return replace(second, generation=first.generation) == first
+
+
+class WorktreeStateController(QObject):
+    """The counters, the merge banner and the pause state of every worktree, shown in each repository window that manages it."""
+
+    # Asks for an automatic look at the rebase and replay pause state of a window, the session id given: only what the
+    # periodic worktree read already found may be shown without reading Git again.
+    automatic_observation_requested = Signal(str)
+    # Tells that a window of a worktree has just shown the conflict state of a working tree read: the session id, the
+    # WorktreeKey and the conflict state, for the conflict window and the conflict prompts of that window.
+    window_conflict_state_shown = Signal(str, object, object)
+    # Tells that a fresh conflict state of a worktree was read, the WorktreeKey given, once every managing window showed
+    # it: a stash kept until its conflicts were solved may now be dropped, and what a Stash pop left is read again.
+    worktree_conflict_state_read = Signal(object)
+
+    def __init__(self, *, session_registry_controller: SessionRegistry, staging_session_registry_controller: StagingSessionRegistry, reference_read_controller: ReferenceReadController, refresh_controller: RefreshController,
+                 repository_operation: RepositoryOperationService, conflict: ConflictService, mergetool: MergetoolService, parent: QObject | None = None) -> None:
+        """Receive the services and the lower controllers the state is read from; the wiring builds it after the refresh controller, and the preparation sessions, the rebase and the replay tell it what changed."""
+        super().__init__(parent)
+        self.session_registry_controller = session_registry_controller
+        self.staging_session_registry_controller = staging_session_registry_controller
+        self.reference_read_controller = reference_read_controller
+        self.refresh_controller = refresh_controller
+        self.repository_operation = repository_operation
+        self.conflict = conflict
+        self.mergetool = mergetool
+        # The last pause state told to the availability views, per worktree; an equal state is not told again.
+        self.relayed_rebase_state_by_key: dict[WorktreeKey, RebaseSnapshot] = {}
+        self.relayed_replay_state_by_key: dict[WorktreeKey, ReplaySnapshot] = {}
+
+    def _relay_pause_state(self, relayed_state_by_key: dict[WorktreeKey, RebaseSnapshot] | dict[WorktreeKey, ReplaySnapshot],
+                           state: RebaseSnapshot | ReplaySnapshot) -> None:
+        """Tell the availability views about a published pause state only when it changed; reservations tell them on their own."""
+        # Every emission recomputes the availability of every dialog and reads the native files again for each staging session.
+        if same_pause_state(relayed_state_by_key.get(state.key), state):
+            return
+        relayed_state_by_key[state.key] = state
+        self.repository_operation.changed.emit()
+
+    def relay_rebase_state(self, state: RebaseSnapshot) -> None:
+        """Relay one published native rebase state to the availability views."""
+        self._relay_pause_state(self.relayed_rebase_state_by_key, state)
+
+    def relay_replay_state(self, state: ReplaySnapshot) -> None:
+        """Relay one published native Cherry-pick or Revert state to the availability views."""
+        self._relay_pause_state(self.relayed_replay_state_by_key, state)
+
+    def managed_windows_of_worktree(self, key: WorktreeKey) -> list[tuple[str, RepositoryWindow]]:
+        """List the open repository windows that manage this worktree: the ones showing its counters and its pause banners."""
+        windows: list[tuple[str, RepositoryWindow]] = []
+        for session_id, window in self.session_registry_controller.window_by_session.items():
+            session = self.session_registry_controller.session_by_id[session_id]
+            if session.is_closed or not isValid(window) or window.is_closed or not isValid(window.commit_action):
+                continue
+            if WorktreeKey.from_context(session.repository_context) != key or WindowCapability.MANAGE not in session.capabilities:
+                continue
+            windows.append((session_id, window))
+        return windows
+
+    def mark_pause_observed(self, key: WorktreeKey, observation: str) -> None:
+        """Tell the worktree's session that an observation of its pause state starts, so its periodic refresh asks again only when something moves afterwards."""
+        staging = self.staging_session_registry_controller.staging_by_key.get(key)
+        if staging is None:
+            return
+        staging.mark_pause_observed(observation)
+
+    def observe_worktree_pause(self, key: WorktreeKey) -> None:
+        """Look at the rebase and replay state when the session reports a pause marker while nothing else moved."""
+        for session_id, _window in self.managed_windows_of_worktree(key):
+            self.automatic_observation_requested.emit(session_id)
+
+    def follow_moved_head(self, key: WorktreeKey) -> None:
+        """Bring the graph of this worktree's windows to the HEAD a worktree read found moved by another program, without a Refresh.
+
+        The working tree and the pause state were read by that very read, so only references and graph are read again.
+        A window already refreshing, a refresh the read belongs to, an operation of GitPane on the worktree, or a graph
+        that already shows this HEAD needs nothing more.
+        """
+        staging = self.staging_session_registry_controller.staging_by_key.get(key)
+        if staging is None or staging.snapshot is None or not staging.snapshot.fresh or staging.snapshot.probe is None:
+            return
+        if self.repository_operation.owns_worktree(key) or self.refresh_controller.full_refresh_reads(key, staging):
+            return
+        probe = staging.snapshot.probe
+        for session_id, _window in self.managed_windows_of_worktree(key):
+            if self.session_registry_controller.session_by_id[session_id].refresh_active:
+                continue
+            displayed = self.reference_read_controller.reference_snapshot_by_session.get(session_id)
+            if displayed is not None and displayed.head_oid == probe.head_oid and displayed.head_ref == probe.branch_head:
+                continue
+            self.refresh_controller.refresh(session_id, scope=RefreshScope.REFERENCES, outside_already_read=True)
+
+    def _merge_banner_busy(self, context: RepositoryContext) -> bool:
+        """Tell whether a merge tool or a reserved operation holds this worktree, while the merge banner's Continue and Abort must wait."""
+        return self.mergetool.owns_repository(context.common_git_dir) or self.repository_operation.owns_worktree(WorktreeKey.from_context(context))
+
+    def merge_banner_actions_changed(self) -> None:
+        """Redraw Continue and Abort of every blue merge banner from the state its window already shows, when a merge tool series or an operation starts or ends.
+
+        No Git read: the banner used to be redrawn only when a worktree read was published, and the merge tool publishes
+        its last read while its series still holds the repository; a later identical read publishes nothing, so the
+        buttons stayed greyed until a Refresh.
+        """
+        for key, staging in tuple(self.staging_session_registry_controller.staging_by_key.items()):
+            busy = self._merge_banner_busy(staging.context)
+            for _session_id, window in self.managed_windows_of_worktree(key):
+                if not window.merge_banner_shown or window.conflict_state is None:
+                    continue
+                window.show_conflict_state(window.conflict_state, merge_state=window.merge_banner_state, busy=busy)
+
+    def show_worktree_state(self, key: WorktreeKey) -> None:
+        """Refresh matching counters and conflicts from the shared working-tree read."""
+        staging = self.staging_session_registry_controller.staging_by_key[key]
+        snapshot = staging.snapshot
+        conflict_state = self.conflict.observe(key, snapshot, staging.diagnostic.cause if staging.diagnostic is not None else "")
+        # The refresh this read belongs to observes the pause state itself; a second observation would only repeat it.
+        pause_observed_by_refresh = self.refresh_controller.full_refresh_covers(key, staging)
+        # A merge tool or an operation at work on the worktree changes the state the merge banner's buttons act on.
+        busy = self._merge_banner_busy(staging.context)
+        for session_id, window in self.managed_windows_of_worktree(key):
+            count = str(snapshot.count) if snapshot is not None and snapshot.fresh else "?"
+            window.commit_action.setText(f"Commit({count})")
+            state = snapshot.color_state() if snapshot is not None else WorktreeColorState.UNKNOWN
+            # Every working-tree read lands here; the icon only needs replacing when its color changes, and the
+            # window redraws it from change_state when the screen density changes.
+            if window.commit_action.property("change_state") != state:
+                window.commit_action.setIcon(action_icon("commit", window.devicePixelRatioF(), state))
+                window.commit_action.setProperty("change_state", state)
+            window.commit_action.setToolTip(staging.diagnostic.cause if staging.diagnostic is not None else "Prepare local changes")
+            window.show_conflict_state(conflict_state, merge_state=staging.merge_banner_state, busy=busy)
+            if not pause_observed_by_refresh:
+                self.automatic_observation_requested.emit(session_id)
+            self.window_conflict_state_shown.emit(session_id, key, conflict_state)
+        if conflict_state.fresh:
+            self.worktree_conflict_state_read.emit(key)

gitpane/emoji/emoji_catalogue.py

@@ -0,0 +1,156 @@
+"""Closed list of the symbols offered by the emoji keyboard.
+
+Both keyboard grids read this list, so it is the only place a symbol is added or removed. The packaged font is the
+complete Noto Color Emoji build, not a subset made from this list: adding a symbol needs no new font, and
+tests/test_emoji_font.py checks that the font draws every entry in colour. Pure data without any Qt import. Sequences are written with escapes because zero-width joiners (U+200D) and variation
+selectors (U+FE0F) are invisible and silently lost when the characters are copied by hand.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class EmojiEntry:
+    """One symbol of the keyboard: the exact text a click produces, its English name and what the button shows."""
+
+    text: str
+    name: str
+    display_text: str = ""
+
+    def shown_text(self) -> str:
+        """Return what the button draws; combining marks are shown on a sample so they have something to sit on."""
+        return self.display_text or self.text
+
+
+COMBINING_MARK_SAMPLE_BEFORE = "\U0001F98B"
+COMBINING_MARK_SAMPLE_AFTER = "\U0001F497"
+COMBINING_MARK_TITLE = "Combining Diacritical Marks"
+
+# Themes follow each other without headings: status, highlight, pointers, tools, documents, faces, people and hands,
+# then coloured circles and squares from red to purple. Symbols written side by side without a zero-width joiner in the
+# original list (stop sign and blue diamond, eye and mouth, alien and laughing face) are separate symbols with their own button.
+EMOJI_ENTRIES: tuple[EmojiEntry, ...] = (
+    EmojiEntry("✅", "Check mark button"),
+    EmojiEntry("✔️", "Check mark"),
+    EmojiEntry("❌", "Cross mark"),
+    EmojiEntry("⛔", "No entry"),
+    EmojiEntry("\U0001F6AB", "Prohibited"),
+    EmojiEntry("\U0001F6D1", "Stop sign"),
+    EmojiEntry("⚠️", "Warning"),
+    EmojiEntry("\U0001F6A8", "Police car light"),
+    EmojiEntry("\U0001F6A7", "Construction"),
+    EmojiEntry("\U0001F691", "Ambulance"),
+    EmojiEntry("‼️", "Double exclamation mark"),
+    EmojiEntry("❓", "Red question mark"),
+    EmojiEntry("❔", "White question mark"),
+    EmojiEntry("\U0001F4AF", "Hundred points"),
+    EmojiEntry("\U0001F31F", "Glowing star"),
+    EmojiEntry("⭐", "Star"),
+    EmojiEntry("\u2728", "Sparkles"),
+    EmojiEntry("\U0001F525", "Fire"),
+    EmojiEntry("\U0001F4A5", "Collision"),
+    EmojiEntry("⚡️", "High voltage"),
+    EmojiEntry("\U0001F3AF", "Bullseye"),
+    EmojiEntry("\U0001F680", "Rocket"),
+    EmojiEntry("\U0001F48E", "Gem stone"),
+    EmojiEntry("\U0001F300", "Cyclone"),
+    EmojiEntry("\U0001F4A4", "Zzz"),
+    EmojiEntry("\U0001F4A2", "Anger symbol"),
+    EmojiEntry("\U0001F5FF", "Moai"),
+    EmojiEntry("\U0001F3F3️", "White flag"),
+    EmojiEntry("\U0001F449", "Backhand index pointing right"),
+    EmojiEntry("\U0001F448", "Backhand index pointing left"),
+    EmojiEntry("\U0001FAF5", "Index pointing at the viewer"),
+    EmojiEntry("➤", "Black rightwards arrowhead"),
+    EmojiEntry("\U0001F53A", "Red triangle pointed up"),
+    EmojiEntry("\U0001F53B", "Red triangle pointed down"),
+    EmojiEntry("\U0001F537", "Large blue diamond"),
+    EmojiEntry("\U0001F500", "Shuffle tracks button"),
+    EmojiEntry("\U0001F4CC", "Pushpin"),
+    EmojiEntry("⚙️", "Gear"),
+    EmojiEntry("\U0001F6E0️", "Hammer and wrench"),
+    EmojiEntry("⚔️", "Crossed swords"),
+    EmojiEntry("\U0001F6E1️", "Shield"),
+    EmojiEntry("\U0001F5DD️", "Old key"),
+    EmojiEntry("\U0001F517", "Link"),
+    EmojiEntry("\U0001F3F7️", "Label"),
+    EmojiEntry("\U0001F50E", "Magnifying glass tilted right"),
+    EmojiEntry("\U0001F9EA", "Test tube"),
+    EmojiEntry("\U0001F9E0", "Brain"),
+    EmojiEntry("\U0001F916", "Robot"),
+    EmojiEntry("\U0001F40D", "Snake"),
+    EmojiEntry("\U0001F3A8", "Artist palette"),
+    EmojiEntry("\U0001F4C1", "File folder"),
+    EmojiEntry("\U0001F4CB", "Clipboard"),
+    EmojiEntry("\U0001F4DD", "Memo"),
+    EmojiEntry("✏️", "Pencil"),
+    EmojiEntry("\U0001F4D2", "Ledger"),
+    EmojiEntry("\U0001F4D5", "Closed book"),
+    EmojiEntry("\U0001F4DA", "Books"),
+    EmojiEntry("\U0001F4DC", "Scroll"),
+    EmojiEntry("\U0001F4CA", "Bar chart"),
+    EmojiEntry("\U0001F4C8", "Chart increasing"),
+    EmojiEntry("\U0001F522", "Input numbers"),
+    EmojiEntry("\U0001D48A", "Mathematical bold italic small i"),
+    EmojiEntry("\U0001F4E4", "Outbox tray"),
+    EmojiEntry("\U0001F4EC", "Open mailbox with raised flag"),
+    EmojiEntry("\U0001F4E2", "Loudspeaker"),
+    EmojiEntry("\U0001F5D3️", "Spiral calendar"),
+    EmojiEntry("⌚", "Watch"),
+    EmojiEntry("⌛", "Hourglass done"),
+    EmojiEntry("\U0001F4B5", "Dollar banknote"),
+    EmojiEntry("\U0001F917", "Smiling face with open hands"),
+    EmojiEntry("\U0001F601", "Beaming face with smiling eyes"),
+    EmojiEntry("\U0001F923", "Rolling on the floor laughing"),
+    EmojiEntry("\U0001F914", "Thinking face"),
+    EmojiEntry("\U0001F9D0", "Face with monocle"),
+    EmojiEntry("\U0001F97A", "Pleading face"),
+    EmojiEntry("\U0001F62C", "Grimacing face"),
+    EmojiEntry("\U0001F628", "Fearful face"),
+    EmojiEntry("\U0001F631", "Face screaming in fear"),
+    EmojiEntry("\U0001F62D", "Loudly crying face"),
+    EmojiEntry("\U0001F47F", "Angry face with horns"),
+    EmojiEntry("\U0001F92C", "Face with symbols on mouth"),
+    EmojiEntry("\U0001F621", "Enraged face"),
+    EmojiEntry("\U0001F921", "Clown face"),
+    EmojiEntry("\U0001F47D", "Alien"),
+    EmojiEntry("\U0001F441️", "Eye"),
+    EmojiEntry("\U0001F444", "Mouth"),
+    EmojiEntry("\U0001F926‍♀️", "Woman facepalming"),
+    EmojiEntry("\U0001F937", "Person shrugging"),
+    EmojiEntry("\U0001F46E\U0001F3FB‍♂️", "Man police officer: light skin tone"),
+    EmojiEntry("✋", "Raised hand"),
+    EmojiEntry("\U0001F919", "Call me hand"),
+    EmojiEntry("\U0001F64C", "Raising hands"),
+    EmojiEntry("\U0001F44C", "OK hand"),
+    EmojiEntry("\U0001F64F", "Folded hands"),
+    EmojiEntry("\U0001F595", "Middle finger"),
+    EmojiEntry("\U0001F534", "Red circle"),
+    EmojiEntry("\U0001F7E0", "Orange circle"),
+    EmojiEntry("\U0001F7E1", "Yellow circle"),
+    EmojiEntry("\U0001F7E2", "Green circle"),
+    EmojiEntry("\U0001F535", "Blue circle"),
+    EmojiEntry("\U0001F7E3", "Purple circle"),
+    EmojiEntry("\U0001F7E5", "Red square"),
+    EmojiEntry("\U0001F7E7", "Orange square"),
+    EmojiEntry("\U0001F7E8", "Yellow square"),
+    EmojiEntry("\U0001F7E9", "Green square"),
+    EmojiEntry("\U0001F7E6", "Blue square"),
+    EmojiEntry("\U0001F7EA", "Purple square"),
+)
+
+
+def combining_mark_entry(mark: str, name: str) -> EmojiEntry:
+    """Build a mark entry whose click gives the mark alone while the button shows it between two emoji."""
+    return EmojiEntry(mark, name, COMBINING_MARK_SAMPLE_BEFORE + mark + COMBINING_MARK_SAMPLE_AFTER)
+
+
+COMBINING_MARK_ENTRIES: tuple[EmojiEntry, ...] = (
+    combining_mark_entry("⃘", "Combining ring overlay"),
+    combining_mark_entry("⃟", "Combining enclosing diamond"),
+    combining_mark_entry("⃤", "Combining enclosing upward pointing triangle"),
+    combining_mark_entry("⃫", "Combining long double solidus overlay"),
+    combining_mark_entry("⃒", "Combining long vertical line overlay"),
+)