Pages & navigation
Pages are the screens operators move between. They live in a tree of pages and page groups, plus a Dialogs folder holding the pages that are only ever shown on top of another screen. This chapter walks through building that tree and giving operators a way to navigate it.

How the tree is organised
Open the Editor area in the left rail. The tree is a fixed set of collapsible sections, each with a + on its row:
| Section | Holds | + adds |
|---|---|---|
| Header ▣ · Left sidebar ◧ · Right sidebar ◨ · Footer ▄ | The shell regions that wrap every page — see Layout. | a widget to that region |
| Pages | The screen tree operators navigate. | a page or a page group |
| Dialogs | Dialogs and dialog groups — pages that are only ever opened over a screen, never navigated to. | a dialog or a dialog group |
Add your first page
- Add it — Click the
+on the Pages section row, or right-click inside the section and pick Add Page. A blank page appears, selected, with its properties open on the right. - Name it — Set the page title in the properties panel (or double-click the tree row to rename). The title feeds the browser tab, the
$pagesource, breadcrumbs and menus. - Fill in the details — Give it an icon, a breadcrumb label, and a description as needed — navigation widgets read these automatically.
Group, nest, and reorganise
The tree's right-click menu is where structure happens, and it changes with what you clicked. Use it to keep related screens together and to reshape the hierarchy as the project grows.
| Menu item | Where | What it does |
|---|---|---|
Add Page |
Pages section, page group | Create a page — at the root of the section, or inside the group you clicked. |
Add Dialog |
Dialogs section | Create a dialog — the same page, but opened over the current screen instead of navigated to. |
Add Page Group |
Pages section, page group | Create a page group — a container that stacks its own pages and gets its own navigation. Groups can nest. |
Add Dialog Group |
Dialogs section | Create a dialog group — the same page group, opened over the current screen instead of navigated to. |
Rename · Cut · Copy · Paste |
pages, groups | The usual edits; paste drops a copied page (and its widgets) in place. |
Delete Page · Delete Page Group |
the matching node | Remove it. |
Moving things. Drag a row onto another: the top or bottom quarter drops it before or after that row, the middle half drops it inside — into a page group, a container, a page section or a shell area. Hovering a collapsed row for a moment opens it, so a drag can reach anywhere without preparing the tree first.
Cut (Ctrl/Cmd+X) then Paste does the same move from the keyboard, and both
keep the node's id — bindings that name it keep working. Copy + Paste is the
opposite: it duplicates, giving the copy fresh ids. Either way the move is a single
undo step.
A dialog is an ordinary page. The Dialogs folder's + and its right-click menu offer Add Dialog and Add Dialog Group — the same two verbs as the Pages section, under the names the operator meets them by — and a dialog is edited on the same canvas as any other page. What the folder decides is that the page is never navigated to — it has no place in menus, breadcrumbs or the URL — and that its inputs can be Bindings too and it carries its own overlay settings. Because of that, a field that navigates — a menu item, the Breadcrumb's home page — does not offer these pages at all, and the warnings pill flags a project that names one anyway. Drag a row between the two sections, or Cut and Paste it, to move a screen from one to the other.
Reacting to arrival and departure. Pages and groups both carry an Events section — action lists that run when the operator arrives at that node and when they leave it. A group is entered and left as a whole, so navigating between its own pages doesn't re-trigger it. See Page events.
Overlays: a page shown on top of the current screen
Anything that opens over a screen — a confirmation, a detail panel, a setup wizard — is a page, opened with Open Dialog when it lives in the Dialogs folder or Open Page As Overlay when it is a navigable page, and closed with Close Dialog/Overlay either way. There is no separate kind of document to build: you author the widget tree on the same canvas as any other page.
The action decides how it looks — size (auto / small / medium / fullscreen / fixed pixels), placement (centred, edge-docked, or anchored to the button that opened it, popover-style), and whether the backdrop dims. See Actions. The page itself carries the settings that outlive a single opening, in its Overlay section: whether a close button shows, whether clicking the backdrop closes it, and whether that click taps through. With the backdrop set to none, a tap outside a popover then closes it and reaches whatever lies under it — tap the next machine symbol and its own popover opens in the same tap. All three are on unless you turn them off; a dimmed backdrop only ever closes.
Two more settings there are off unless you turn them on. Draggable lets the operator drag the dialog by its header bar, with a mouse or a finger; it stays where it was put until it closes, and its header bar, × included, never leaves the screen. Background usable keeps the screen under the dialog working while it is open — no dim, and buttons, sliders and scrolling beside the dialog work as usual. The dialog stays open until its own × or a Close Dialog/Overlay, so Close on backdrop and Tap through leave the panel. A jog box beside the machine picture or an alarm panel kept open while operating are what it is for. With several dialogs open the screen is only usable when all of them have it on: one ordinary dialog still blocks it. Such a dialog also stays open when the operator moves to another page — same place, same size, same values — even when its own button navigates; put a Close Dialog/Overlay before Navigate To Page to close it on the way.
Show header bar in the same section hides the card's title strip, × included — for a keypad or an access panel that should be all content. The page then needs its own Close Dialog/Overlay button, unless a backdrop click closes it. It is on unless you turn it off, and it is the one Overlay setting a navigable page opened with Open Page As Overlay has too. On a page group the group's setting counts, not its pages'.
Opening a dialog that is already on top swaps its inputs. The card stays, takes the new inputs and moves to the new anchor, rather than stacking a second copy.
Inputs make one page serve many. A page in the Dialogs folder declares
Inputs in its own panel, under its own Inputs title at the bottom of the Dialog section — the same block a Component has at the bottom of its Identity section. Each line shows an input's name, type and default; › opens the rest. Declare
motorId, and the widgets inside read it with $componentProp; the Open Dialog
action that opens the page fills the value in. One "Motor detail" page then serves every
motor on the plant instead of one page per machine. The values belong to the overlay, so
navigating inside it keeps them.
Each input is a Value or a Binding (Value or Binding). A Value is read once as the dialog opens and is then the dialog's own: a field inside can change it for this screen, and closing the dialog throws it away. A Binding is a variable the opener passes, live, and writing it writes the controller. A Value also takes a default value, which applies whenever nothing supplied one. An input of type Page gets a page picker in the Open Dialog action, and a Navigate To Page action inside the dialog can go to whatever page the caller picked.
Overlay settings appear only inside the Dialogs folder. A page in the Pages section is a navigation destination. It can still be opened as an overlay — it then takes no inputs, and uses the default close behaviour.
A page in Pages has inputs too. The same Inputs block sits at the bottom of its Page section, and every entry is a Value — there is no Kind to choose. A Navigate To Page that goes to the page lists one field per input under Inputs: a fixed value, a variable, a Widget Property or any other source, read once in the screen that navigates. An input left empty there starts at its default. After that the input is the page's own: a field or a Write on the page changes it, and nothing goes back. A search box and the list it filters can share one this way, per screen, with nothing stored on the server. When an input is read:
| The operator arrives… | The page's inputs |
|---|---|
| through a Navigate To Page | take what the action passed, the default where it passed nothing |
| through a Navigate To Page to the page already showing | read the new values again |
| any other way — a menu, a Tab Bar, Page Group: Next, Previous or Go To, the browser's back and forward | start at their defaults |
| by refreshing the browser | start at their defaults: inputs are never in the URL |
A page group's inputs keep their values while the operator moves between its pages, and go back to their defaults once the operator leaves the group; a Navigate To Page into the group changes only the group inputs it fills. State the whole machine shares belongs in a static datasource instead.
A whole page group can be opened too. The group's active page shows inside the group's header and footer, so the operator gets the tabs as well — one parameterised, tabbed modal instead of one overlay per tab. A page group declares Inputs in its own panel just like a page, and the values reach every page in the group as well as the group's own header and footer widgets. Switching tabs inside the overlay keeps them.
Declare the same name in more than one place and the innermost one wins: a page's own declaration beats the group it sits in, an inner group beats an outer one, and whatever the action passed in beats every default. A widget in a group's header or footer sits outside the pages, so it reads the group's parameters, never the open page's.
Give operators a way around
You don't hand-wire links. Navigation widgets read the page tree and stay in sync as it changes. Add whichever fits the layout:
- Navigation Menu — A sidebar or top-bar menu that mirrors the page tree automatically. Choose orientation, icon/label display, flat vs. tree hierarchy, and how sub-menus expand.
- Tab Bar — Switches between the sibling pages of a group as tabs — ideal inside a page group.
- Breadcrumb — Shows the trail of pages leading to the current one, with an optional home icon.
- Page Navigator — Previous / next controls that step through the pages of a page group, in tree order. Previous enabled and Next enabled each take a binding, so a step can hold one control shut until the operator has filled something in while the other stays live; Show previous and Show next drop a control altogether rather than disabling it.
To build a tab bar of your own, use Buttons with the Page Group: Next, Page Group:
Previous and Page Group: Go To actions, and read the position
from $page: Page group index is the open page of the group, counted from 0, and
Page group last index the last one. A tab Button lights up with
$compare($page Page group index = 1); a Next Button greys out with
$compare($page Page group index < $page Page group last index) on Interactable, and a
Label shows Tab 2 / 4 with a $formula on Page group index + 1 and Page group last
index + 1.
Put these in a shell region (see Layout) so they persist while operators move between screens.
Size a Navigation Menu from the Layout panel, the same as any other widget — its Width and Height rows are what decide how much room it takes. It has no width of its own to fight you: the default Hug makes it as wide as its labels need, and Fill hands it the rest of the sidebar.