ff9mapkit 1.0.0b3__py3-none-any.whl

ff9mapkit/workspace/mapview.py

@@ -0,0 +1,131 @@
+"""A QGraphicsView campaign MAP for the Workspace -- the visual twin of the project tree.
+
+The placement is the SAME tk-free core the tkinter Campaign Editor uses: ``editor.graphview.compute_layout``
+lays a :class:`..campaign.CampaignGraph` out top-down in BFS levels (entry at the top, unreachable members
+below) and returns absolute node/edge/seam coordinates. This module only RENDERS that ``GraphLayout`` into
+a Qt scene (rounded-rect nodes coloured by health, arrowed gateway edges -- dashed when gated -- and dashed
+seam stubs) and turns a double-click into an open-member call. So both editors draw the identical map.
+"""
+
+from __future__ import annotations
+
+import math
+
+from PySide6.QtCore import QPointF, QRectF, Qt
+from PySide6.QtGui import QBrush, QColor, QFont, QPainter, QPainterPath, QPen, QPolygonF
+from PySide6.QtWidgets import QGraphicsScene, QGraphicsView
+
+from ..editor.graphview import compute_layout
+
+
+class CampaignMap(QGraphicsView):
+    """A scrollable, pannable node-link map of a campaign. ``on_open(name)`` fires on double-clicking a
+    node; the open member is highlighted (accent fill). Call :meth:`render` with a CampaignGraph."""
+
+    def __init__(self, palette, *, on_open=None):
+        super().__init__()
+        self.pal = palette
+        self.on_open = on_open
+        self._layout = None
+        self._current = None
+        self._scene = QGraphicsScene(self)
+        self.setScene(self._scene)
+        self.setRenderHint(QPainter.RenderHint.Antialiasing)
+        self.setDragMode(QGraphicsView.DragMode.ScrollHandDrag)        # click-drag to pan
+        self.setBackgroundBrush(QColor(palette["surface"]))
+
+    # -- public --
+    def render(self, graph, current=None):
+        self._layout = compute_layout(graph)
+        self._current = current
+        self._draw()
+
+    def highlight(self, name):
+        if self._layout is None:
+            return
+        self._current = name
+        self._draw()
+
+    def clear(self):
+        self._scene.clear()
+        self._layout = None
+        self._current = None
+
+    # -- drawing --
+    def _draw(self):
+        sc, pal, lay = self._scene, self.pal, self._layout
+        sc.clear()
+        if lay is None:
+            return
+        sc.setSceneRect(0, 0, lay.width, lay.height)
+        muted = QColor(pal["muted"])
+        for e in lay.edges:                                            # edges under the nodes
+            pen = QPen(muted, 2)
+            if e.gated:
+                pen.setDashPattern([5, 3])
+            sc.addLine(e.x1, e.y1, e.x2, e.y2, pen)
+            self._arrow_head(e.x1, e.y1, e.x2, e.y2, muted)
+        for s in lay.seams:
+            pen = QPen(muted, 1)
+            pen.setDashPattern([2, 3])
+            sc.addLine(s.nx, s.ny, s.x, s.y, pen)
+            t = sc.addSimpleText("~ " + s.label, QFont("Segoe UI", 8))
+            t.setBrush(QBrush(muted))
+            t.setPos(s.x + 4, s.y - 7)
+        for n in lay.nodes:
+            self._node(n)
+
+    def _node(self, n):
+        sc, pal = self._scene, self.pal
+        if not n.reachable:
+            outline = pal["error"]
+        elif n.needs_export:
+            outline = pal["warn"]
+        elif n.is_entry:
+            outline = pal["success"]
+        else:
+            outline = pal["border"]
+        current = (n.name == self._current)
+        fill = pal["accent"] if current else pal["surface_btn"]
+        tcol = pal["accent_fg"] if current else pal["text"]
+        sub_col = pal["accent_fg"] if current else pal["muted"]
+        path = QPainterPath()
+        path.addRoundedRect(QRectF(n.x, n.y, n.w, n.h), 10, 10)
+        sc.addPath(path, QPen(QColor(outline), 2 if outline != pal["border"] else 1), QBrush(QColor(fill)))
+        title = sc.addSimpleText(n.name, QFont("Segoe UI", 10, QFont.Weight.Bold))
+        title.setBrush(QBrush(QColor(tcol)))
+        title.setPos(n.cx - title.boundingRect().width() / 2, n.y + 8)
+        sub = sc.addSimpleText(f"id {n.new_id}" + ("" if n.mode == "borrow" else f" · {n.mode}"),
+                               QFont("Segoe UI", 8))
+        sub.setBrush(QBrush(QColor(sub_col)))
+        sub.setPos(n.cx - sub.boundingRect().width() / 2, n.y + 26)
+
+    def _arrow_head(self, x1, y1, x2, y2, color, size=11):
+        dx, dy = x2 - x1, y2 - y1
+        d = math.hypot(dx, dy)
+        if d == 0:
+            return
+        ux, uy = dx / d, dy / d
+        bx, by = x2 - ux * size, y2 - uy * size           # base of the head, back along the line
+        px, py = -uy, ux                                  # perpendicular
+        head = QPolygonF([QPointF(x2, y2),
+                          QPointF(bx + px * size * 0.5, by + py * size * 0.5),
+                          QPointF(bx - px * size * 0.5, by - py * size * 0.5)])
+        self._scene.addPolygon(head, QPen(color, 0), QBrush(color))
+
+    # -- interaction --
+    def _node_at(self, view_pos):
+        if self._layout is None:
+            return None
+        sp = self.mapToScene(view_pos)
+        for n in self._layout.nodes:
+            if n.x <= sp.x() <= n.x + n.w and n.y <= sp.y() <= n.y + n.h:
+                return n.name
+        return None
+
+    def mouseDoubleClickEvent(self, event):                # noqa: N802 (Qt override)
+        name = self._node_at(event.position().toPoint())
+        if name and self.on_open:
+            self.on_open(name)
+        else:
+            super().mouseDoubleClickEvent(event)

ff9mapkit/workspace/palette.py

@@ -0,0 +1,85 @@
+"""The Ctrl-K command palette for the Workspace -- fuzzy search over content + named commands.
+
+A modal overlay: type to filter a flat list of entries (each ``(label, kind, callback)``), Enter / click
+runs the selected one. The shell feeds it the named commands (Open Campaign, Check, switch tab, …) AND
+the project content (every journey / campaign / field / object node in the tree), so a clicker and a
+keyboard user reach the same place. Matching is a subsequence test (``ocm`` -> "Open Campaign"), so
+abbreviations work. PySide6-only view; the entry list + callbacks are the shell's to build.
+"""
+
+from __future__ import annotations
+
+from PySide6.QtCore import QEvent, Qt
+from PySide6.QtWidgets import QDialog, QLineEdit, QListWidget, QListWidgetItem, QVBoxLayout
+
+
+def fuzzy(needle: str, hay: str) -> bool:
+    """True if every char of ``needle`` appears in ``hay`` IN ORDER (a subsequence match). Both lower."""
+    i = 0
+    for ch in hay:
+        if i < len(needle) and ch == needle[i]:
+            i += 1
+    return i == len(needle)
+
+
+def rank(needle: str, label: str, kind: str):
+    """A sort key: exact substring first, then earliest match, then shorter labels. Lower = better."""
+    lab = label.lower()
+    sub = lab.find(needle)
+    return (0 if sub == 0 else 1 if sub > 0 else 2, sub if sub >= 0 else 1_000, len(label))
+
+
+class CommandPalette(QDialog):
+    """Type-to-filter overlay over ``entries`` (a list of ``(label, kind, callback)``)."""
+
+    def __init__(self, parent, entries, palette):
+        super().__init__(parent)
+        self.setWindowTitle("Search content & commands")
+        self.setModal(True)
+        self.resize(580, 440)
+        self._entries = list(entries)
+        self._filtered = list(entries)
+        lay = QVBoxLayout(self)
+        self.q = QLineEdit()
+        self.q.setPlaceholderText("Search content & commands…  (a field name, or a command)")
+        self.q.textChanged.connect(self._refilter)
+        self.q.returnPressed.connect(self._run_current)
+        self.q.installEventFilter(self)                # forward Up/Down to the list while typing
+        lay.addWidget(self.q)
+        self.lst = QListWidget()
+        self.lst.itemActivated.connect(lambda _i: self._run_current())
+        lay.addWidget(self.lst, 1)
+        self._muted = palette["muted"]
+        self._fill()
+        self.q.setFocus()
+
+    def _fill(self):
+        self.lst.clear()
+        for label, kind, _cb in self._filtered:
+            it = QListWidgetItem(f"{label}     ·  {kind}")
+            self.lst.addItem(it)
+        if self._filtered:
+            self.lst.setCurrentRow(0)
+
+    def _refilter(self, text):
+        t = text.strip().lower()
+        if not t:
+            self._filtered = list(self._entries)
+        else:
+            self._filtered = sorted(
+                (e for e in self._entries if fuzzy(t, e[0].lower()) or fuzzy(t, (e[0] + " " + e[1]).lower())),
+                key=lambda e: rank(t, e[0], e[1]))
+        self._fill()
+
+    def _run_current(self):
+        r = self.lst.currentRow()
+        if 0 <= r < len(self._filtered):
+            cb = self._filtered[r][2]
+            self.accept()
+            cb()
+
+    def eventFilter(self, obj, ev):                    # noqa: N802 (Qt override)
+        if obj is self.q and ev.type() == QEvent.Type.KeyPress and ev.key() in (Qt.Key_Down, Qt.Key_Up):
+            self.lst.keyPressEvent(ev)                  # arrow keys move the list while focus stays in the box
+            return True
+        return super().eventFilter(obj, ev)