Merge the Behaviour tab, compact nodes and the property bar

Author: sp00ktober

apps/studio/README.md

@@ -89,15 +89,16 @@ starting where the last stood, facing as it faced, and the Timeline's bar above
 shows the steps (click one to pick it). Picking or playing anything else starts clips where
 they normally start.
 
-The Behaviour dock (the button under the moves, or View > Panels) draws the port's `[behaviour]`
-graph: every move and every block is a node, and right-click adds a block (the palette is
-`mhfu_port.behaviour.KINDS`). A wire from a block's `out` feeds the next block's `in`, or plays a
-move at its `play`; a move's `while playing` starts a path while it plays, and its `then` hands to
-another move (`after`). Any other wire is refused in the status line. `#2` on a block is its path's
-rank (higher on the canvas is checked first, but every path that plays nothing runs before all
-the others), `⚠` a path the game refuses (the tip says why),
-faded a block on no complete path. Delete removes blocks and their links; a move is deleted in
-Moves. Every gesture is one undo step.
+The Behaviour tab beside the 3D view (the button under the moves, or View > Panels) draws the
+port's `[behaviour]` graph: every move and block is a node, and right-click adds a block (the
+palette is `mhfu_port.behaviour.KINDS`). A wire from a block's `out` feeds the next block's `in`,
+or plays a move at its `play`; a move's `while playing` starts a path while it plays, and its
+`then` hands to another move (`after`). Any other wire is refused in the status line. `#2` is a
+block's path rank (higher on the canvas is checked first, but every path that plays nothing runs
+before all the others), `⚠` a path the game refuses (the tip says why), faded a block on no
+complete path. Delete removes blocks and their links; a move is
+deleted in Moves. Every gesture is one undo step. The tab has no docks until you open one on it,
+and keeps them apart from the 3D view's; Findings stays open across tabs.
 
 Effect blocks (violet) change the monster's counters and flags when their path fires. A path may
 end at an effect with nothing to play: it applies its effects, keeps its `#n` on that block, and

apps/studio/src/mhfu_studio/monster/behaviour.py

@@ -3,7 +3,7 @@
 """A port's behaviour graph (`mhfu_port.behaviour`) as document edits, and what the canvas shows
 of it.
 
-No toolkit: the Behaviour dock calls these, one undo step per gesture (`Gesture`); a refusal is
+No toolkit: the Behaviour tab calls these, one undo step per gesture (`Gesture`); a refusal is
 the manifest's own `ManifestError`, so its checks are the only ones. Paths, priority, validity
 and references are the package's; this module names the canvas's nodes and ports and reads the
 graph for them.
@@ -180,19 +180,29 @@ def capped(m: Manifest, ps: Sequence[Path] | None = None) -> str | None:
 
 def part_options(m: Manifest, optional: bool) -> list[tuple[str, int | None]]:
     """The parts to pick from: the manifest's named ones, then `part k`; `any` for none."""
-    named: dict[int, str] = {}
-    for name, part in m.parts.items():
-        named.setdefault(part.index, name)
     out: list[tuple[str, int | None]] = [("any", None)] if optional else []
-    out += [(name, k) for k, name in named.items()]
-    out += [(f"part {k}", k) for k in behaviour.PARTS if k not in named]
+    out += [(label, k) for k, label in behaviour.part_labels(m).items()]
     return out
 
 
 def main_options() -> list[tuple[str, int]]:
     return [(str(k), k) for k in behaviour.MAIN_STATES]
 
 
+def options(m: Manifest, kind: str) -> dict[str, list[tuple[str, object]]]:
+    """The (label, value) choices of `kind`'s parts and main states, and the names in use, by
+    param."""
+    out: dict[str, list[tuple[str, object]]] = {}
+    for p in KINDS[kind].params:
+        if p.type == "part":
+            out[p.name] = list(part_options(m, p.optional))
+        elif p.type == "mains":
+            out[p.name] = list(main_options())
+        elif p.type in behaviour.NAMES:
+            out[p.name] = [(n, n) for n in behaviour.names(m, p.type)]
+    return out
+
+
 def palette() -> list[tuple[str, list[tuple[str, str, str]]]]:
     """The kinds a block can be, a group per role: (kind, title, tip). All from `KINDS`."""
     roles = typing.get_args(behaviour.Role)

apps/studio/src/mhfu_studio/monster/panels/behaviour.py

@@ -1,10 +1,11 @@
 # SPDX-License-Identifier: GPL-3.0-or-later
 # SPDX-FileCopyrightText: 2026 sp00ktober
-"""The Behaviour dock: the port's behaviour graph (`mhfu_port.behaviour`) on a node canvas.
+"""The Behaviour tab: the port's behaviour graph (`mhfu_port.behaviour`) on a node canvas.
 
-A node is a move or a block; a wire is a link the manifest stores (`monster/behaviour.py`). The
-document is the owner: every gesture of the canvas arrives as intents, is applied as one undo
-step, and the canvas is shown again from the document.
+A node is a move or a block, drawn compact; a wire is a link the manifest stores
+(`monster/behaviour.py`). The selected node's values and note are edited in the bar under the
+canvas. The document is the owner: every gesture of the canvas and every edit of the bar arrives
+as intents, is applied as one undo step, and is shown again from the document.
 """
 
 from __future__ import annotations
@@ -13,13 +14,14 @@
 from typing import TYPE_CHECKING
 
 from mhfu_port import behaviour as model
-from mhfu_port.behaviour import KINDS
-from mhfu_port.manifest import Manifest, ManifestError
+from mhfu_port.behaviour import KINDS, Kind
+from mhfu_port.manifest import Manifest, ManifestError, Move
 from PySide6.QtWidgets import QSizePolicy, QVBoxLayout, QWidget
 
 from mhfu_studio.monster import behaviour as graph
 from mhfu_studio.monster.panels.common import kind
-from mhfu_studio.monster.panels.node_graph import NAMES, GraphView, LinkSpec, NodeSpec
+from mhfu_studio.monster.panels.node_graph import GraphView, LinkSpec, NodeSpec
+from mhfu_studio.monster.panels.properties import Detail, PropertyBar
 from mhfu_studio.monster.panels.widgets import NoScene
 from mhfu_studio.shell.overlay import Color, Ink
 from mhfu_studio.ui import kit, theme
@@ -65,6 +67,8 @@ def __init__(self, ws: MonsterWorkspace, studio: Studio) -> None:
         self._dropped: dict[str, graph.Point] = {}
         #: the block the gesture creates
         self._made: str | None = None
+        #: what the canvas was last drawn from, for the bar
+        self._read: graph.Reading | None = None
 
         self.title = kit.label(role="title", wrap=False)
         self.hint = kit.label(HINT, role="muted", wrap=False)
@@ -88,21 +92,21 @@ def __init__(self, ws: MonsterWorkspace, studio: Studio) -> None:
         v.link_requested.connect(lambda *w: self._collect(lambda e: graph.link(e, *w)))
         v.unlink_requested.connect(lambda *w: self._collect(lambda e: graph.unlink(e, *w)))
         v.delete_requested.connect(lambda ids: self._collect(lambda e: graph.delete(e, ids)))
-        v.param_changed.connect(
-            lambda i, n, x: self._collect(lambda e: graph.set_param(e, i, n, x))
-        )
-        v.label_changed.connect(lambda i, t: self._collect(lambda e: graph.set_label(e, i, t)))
         v.moved.connect(lambda i, x, y: self._dropped.__setitem__(i, (x, y)))
         v.create_requested.connect(self._create)
         v.picked.connect(self._picked)
         v.settled.connect(self._settle)
+        self.bar = PropertyBar()
+        self.bar.param_changed.connect(self._param)
+        self.bar.label_changed.connect(self._label)
 
         page = QWidget()
         lay = QVBoxLayout(page)
         lay.setContentsMargins(10, 8, 10, 8)
         lay.setSpacing(6)
         lay.addWidget(kit.row(self.title, self.hint, self.fit, self.spread, stretch=True))
         lay.addWidget(self.view, 1)
+        lay.addWidget(self.bar)
         self.no_scene = NoScene(studio)
         self.no_scene.say(
             "No port manifest",
@@ -117,6 +121,16 @@ def _spread(self) -> str:
             raise ManifestError("no port manifest open")
         return graph.spread(doc)
 
+    # what the bar tells: the same intents as the canvas's, one undo step each
+
+    def _param(self, node: str, name: str, value: object) -> None:
+        self._collect(lambda e: graph.set_param(e, node, name, value))
+        self._settle()
+
+    def _label(self, node: str, text: str) -> None:
+        self._collect(lambda e: graph.set_label(e, node, text))
+        self._settle()
+
     # what the canvas tells
 
     def _collect(self, fn: Callable[[graph.Edits], str]) -> None:
@@ -154,9 +168,11 @@ def edit() -> None:
         m = self.ws.manifest
         if made is not None and m is not None and made in m.behaviour.blocks:
             self.view.select([made])
+            self._show_bar()
 
     def _picked(self, node: object) -> None:
-        """A move node picks its move, as the Moves table does."""
+        """A move node picks its move, as the Moves table does; the bar shows the node."""
+        self._show_bar()
         name = graph.move_name(node) if isinstance(node, str) else None
         if name is None or name == self.ws.move:
             return
@@ -182,9 +198,45 @@ def sync(self) -> None:
             self._drawn = m
             self._draw(m)
         self._follow(m)
+        self._show_bar()
+
+    def _show_bar(self) -> None:
+        """The bar shows the one node selected, from the document: a refused edit goes back."""
+        m, ids = self.ws.manifest, self.view.selected()
+        self.bar.show_detail(self._detail(m, ids[0]) if m is not None and len(ids) == 1 else None)
+
+    def _detail(self, m: Manifest, node: str) -> Detail | None:
+        name = graph.move_name(node)
+        if name is not None:
+            mv = m.moves.get(name)
+            return None if mv is None else Detail(node, name, self._move_tip(mv), label=mv.label)
+        blk = m.behaviour.blocks.get(node)
+        if blk is None or self._read is None:
+            return None
+        k = KINDS[blk.kind]
+        values = model.params(blk)
+        tip = self._block_tip(k, self._read.refused.get(node))
+        return Detail(
+            node,
+            k.title,
+            tip,
+            k.params,
+            {p.name: values.get(p.name) for p in k.params},
+            graph.options(m, blk.kind),
+            blk.label,
+        )
+
+    @staticmethod
+    def _block_tip(k: Kind, why: str | None) -> str:
+        return "\n".join([k.tip, *([f"{WARN} {why}"] if why else [])])
+
+    @staticmethod
+    def _move_tip(mv: Move) -> str:
+        plays = f"plays {mv.clip}" if mv.clip else f"plays anim {mv.anim}"
+        return "\n".join([f"{kind(mv)} · {plays}", *([f"Note: {mv.label}"] if mv.label else [])])
 
     def _draw(self, m: Manifest) -> None:
-        r = graph.read(m)
+        r = self._read = graph.read(m)
         nodes = self._blocks(m, r) + self._moves(m)
         self.view.show(nodes, [LinkSpec(*w) for w in graph.wires(m)])
         loose = f" · {len(r.loose)} loose" if r.loose else ""
@@ -199,15 +251,7 @@ def _blocks(m: Manifest, r: graph.Reading) -> list[NodeSpec]:
             k = KINDS[blk.kind]
             why = r.refused.get(i)
             marks = [*(f"#{n}" for n in r.priority.get(i, [])), *([WARN] if why else [])]
-            values = model.params(blk)
-            options: dict[str, list[tuple[str, object]]] = {}
-            for p in k.params:
-                if p.type == "part":
-                    options[p.name] = list(graph.part_options(m, p.optional))
-                elif p.type == "mains":
-                    options[p.name] = list(graph.main_options())
-                elif p.type in NAMES:
-                    options[p.name] = [(n, n) for n in model.names(m, p.type)]
+            note = [f"Note: {blk.label}"] if blk.label else []
             out.append(
                 NodeSpec(
                     i,
@@ -216,13 +260,10 @@ def _blocks(m: Manifest, r: graph.Reading) -> list[NodeSpec]:
                     blk.at,
                     (graph.IN,),
                     (graph.OUT,),
-                    k.params,
-                    {p.name: values.get(p.name) for p in k.params},
-                    options,
+                    model.summary(m, blk),
                     " ".join(marks),
                     i in r.loose,
-                    blk.label,
-                    "\n".join([k.tip, *([f"{WARN} {why}"] if why else [])]),
+                    "\n".join([BehaviourPanel._block_tip(k, why), *note]),
                 )
             )
         return out
@@ -232,7 +273,6 @@ def _moves(m: Manifest) -> list[NodeSpec]:
         spots = graph.spots(m)
         out = []
         for name, mv in m.moves.items():
-            plays = f"plays {mv.clip}" if mv.clip else f"plays anim {mv.anim}"
             out.append(
                 NodeSpec(
                     graph.move_id(name),
@@ -241,8 +281,7 @@ def _moves(m: Manifest) -> list[NodeSpec]:
                     spots[name],
                     (graph.PLAY,),
                     (graph.WHILE, graph.THEN),
-                    label=mv.label,
-                    tip=f"{kind(mv)} · {plays}",
+                    tip=BehaviourPanel._move_tip(mv),
                 )
             )
         return out

apps/studio/src/mhfu_studio/monster/panels/moves.py

@@ -254,7 +254,7 @@ def __init__(self, ws: MonsterWorkspace, studio: Studio) -> None:
 
         self.behaviour = kit.button(
             "Open the behaviour graph",
-            tip="Opens the Behaviour dock: the events, states and conditions that play your moves",
+            tip="Opens the Behaviour tab: the events, states and conditions that play your moves",
             on=act("open behaviour", lambda: ws.focus("Behaviour")),
             icon="ph.tree-structure",
         )