Docs Designing the system 10
Screens: pages you compose
On this page
A screen is a page you put together from blocks: a Work centre for one machine (the machine, how many lots are on it, the lots processing, waiting and done, and a form to move the next lot in), or a Shop floor board (machines by state, lots on hold, scrap by reason). The seed has both. People open screens from the navigator: a favorite, or found by searching its name (star it to keep it).


Start one from the designer's home (Screens → New screen), or add one to a change (+ screen). Its tabs:


- General: its label and description; Opened with: nothing (the same page for everyone), a
record (a machine), a word (a line) or a date; a record is picked by scanning its label or from a list. Each machine then has its own
address and tab:
/_s/work_centre/<machine>. …only those where limits which records open it ({"process": ["die_saw"]}: a die saw's screen lists and opens die saws only). …part of it typed: where it is scanned, lists those that hold it lets people type part of a label ("W-2"): the screen then shows how many records hold it, counted by state (click a state for those alone), and the records themselves with the fields you tick in …showing beside each (up to 6), each a click from opening the screen on it. A whole label still opens it at once. One tab: for a desk worked all day (a crib, a receiving bench), each record scanned opens in the screen's own tab, named after the screen, so nobody closes a tab per record; when its input flow ends on back to the start (repeat), the screen goes back to its scan, the end's words kept above the next prompt ("Bring it to the maintenance room"). Opened with makes the parameter required; for the screen to show its blocks before anything is scanned (a history, say), set"required": falseon it in the JSON tab (there is no checkbox), and give the record's blocks Shown when{"not": {"is_null": {"param": "tool"}}}, the history{"is_null": {"param": "tool"}}. Fill the window, as a transaction's: a Maximize button on its page that sets the navigator, the top bar and the tabs aside, for a tablet at a machine or a board on a wall (on request), or the page opening that way (always at first). Filled, the page still shows who is signed in and whether it is live, and the database banners stay; Restore brings the rest back. Each device remembers the person's choice for that page, so a kiosk stays filled after a reload. - Blocks: + add a block (at most 20 on a screen), then set its Title and Width (3 to 12 of a
12-column row; on a tablet or a phone they stack), and ↑ ↓ to order them. Give blocks a Tab to put them under tabs:
blocks with the same tab share it (four transaction forms, under Move in, Track in, Track
out and Move out), and blocks without one stay above the tabs. An installed suite may add kinds of
block of its own to the list:
- one record: a record's fields, usually the one the screen is opened with (
{"param": "machine"}); - a table of records (it holds up to At most rows, 1 000 at the most; they come Fetched at a
time (50) when the screen opens, the next as many only once the list is scrolled to the end of
them, and like every list it shows fifteen at first and fifteen more as it is scrolled, its head kept
in view; sorted text puts numbers in number order): Only records where (for example
machine = {"param": "machine"}andstate = ["processing"]), the Columns, the sort, how many rows, and Buttons on each row: transactions that appear on those records. A row shows the ones for its state; pressing one fills the row into the screen's own form of that transaction, if it has one (a station's Move in tab: the tab opens, the row is marked, and the page scrolls to the form with four of the list's rows still in sight), or else opens it right under the table with the row filled in, or, with Their form opens: in a side panel over the screen, in a panel over the list (a list of held lots whose Release opens over it; Esc or Done closes it), in a dialog over the screen, or in the panel of the screen you name (a kiosk); when it is done the form closes, the table says what changed, and the row moves on. …filling in fills one of their inputs with the screen's record too (the equipment, on Move in), locked. Record buttons: New (to add one) and Remove on each row (it archives the record, after asking), each shown only to whoever the object's policies allow, its rules still applying. Under New, say where its form opens: on the New page (the screen is left), in a dialog over the screen, or in the panel you name; once created, the dialog closes and the table says so. Or Rows from: a named query: its rows instead of an object's records (A screen's table of a query's rows, below); - a number: how many records, or the sum, average, least or most of a number field; optionally only those Changed today or in the last 7 or 30 days;
- a breakdown: bars by a field or by state, with the same measures;
- a map (map): the cells of a grid a record keeps (a wafer's dies, a panel's cells, a tray's slots). Pick the
object, which record (
{"param": "wafer"}, or one the screen's record refers to:{"lookup": "scan.wafer_yield"}) and the map's name on it; Coloured by a class (give each code its words and tone:{"1": {"label": "Good", "tone": "ok"}, "2": {"label": "Edge reject", "tone": "warn"}}; a code left out is grey) or by a value (a scale, optionally its Unit); Outline a rectangle or a circle (a wafer). It draws the cells where they are, says the one under the pointer, counts every class in a legend with its share, and shows the number of cells and the content hash of what is kept; a map of more than 40 000 cells is drawn merged and says so. It shows only what the viewer may read of the record. The cells come from a service (ctx.grids.put("wafer", id, "dies", { x: [...], y: [...], class: [...], value: [...] }): one list a column, one entry a cell, no cell twice, up to 400 000 a map;{ append: true }adds a chunk) or from an outside system calling a **web service whose input is of typecolumns(bodies up to 24 MB for it): the service's own role must be able to write the record. Classes from records** colours the codes from records you keep instead of typing them into the block: a bin set's bins ({"object": "bin", "code": "bin_no", "label": "name", "tone": "tone", "where": {"bin_set": {"lookup": "wafer.bin_set"}}}), as the viewer may read them; the block's own classes win where both say. - a window of an outside system's data (source): pick a connection that is a data source, give its
parameters (the screen's, the viewer's, or the record's:
{"record": "machine"}) and the window: From and To (expressions:{"record": "started_at"}; To empty or empty on the record means now) or the last hours; tick Of a record and say which ({"param": "lot"}) to read the record's own fields, as the viewer may (a record they may not read shows nothing, and the source is not asked). It draws as a chart (a line to start; the source's columns go where the kind needs them), a table or both, and says under it where and when it was read and the content hash of the rows. It is read when the screen is opened and when its record changes, never live; the time-series itself stays in the system that keeps it. - a chart from a query: any of the AI Report's twenty kinds of chart. Its query is a JSON or SQL
query over the views of the Queries page, run as whoever opens the screen (what their policies
hide is not there); a JSON query may stand for the screen's parameter,
{"eq": [{"field": "machine"}, {"param": "machine"}]}, so a machine's screen charts that machine. Or A named query: pick one, and give its parameters (values, or{"param": "machine"}); the formula is the query's, approved once, and the query's Used by names the chart. A control chart (kind Control chart: x the sample or the time, y the measure) draws the measure with its centre and 1, 2 and 3 sigma lines: give Centre and Sigma for fixed limits, or leave them out to work them out from the first Baseline points (all of them when empty); LSL and USL are the specification limits (lines, and what Cp and Cpk under the chart are worked out against); Run rules fromwe1…we4(Western Electric, the default) andnelson1…nelson8. The points that complete a rule are marked and the hover says which; a line under the chart says the centre, how many points broke a rule, Cp and Cpk. Pick the kind, then say which of its columns go where (the boxes the kind needs are starred), the unit, how it is drawn (stacked, across, labels…), and reference lines or bands as JSON. A record named in its answer is shown by its title, never its id; - a transaction's form: embedded, with inputs the screen fills in (the machine) shown locked; In a dialog: close the dialog once it is done, for a screen shown as a dialog;
- a button: it opens a screen (with what you give Opened with,
{"param": "machine"}) or runs a transaction (its form, with the inputs you fill in shown locked), in a dialog over this screen or in a panel of it; offered only to people who may open that screen or run that transaction. Or it is a link, To: a record (Of an object, Which record: usually{"param": "machine"}), an object's list (Finding: a text typed into its search box as it opens, such as{"param": "machine"}), a kept report (its id, the end of its page's address,/_r/…), or a web address (https://…only). Opens: here, in this tab, in a new browser tab (a web address's own; the page it opens is handed nothing of this one), or, for a record, its form in a dialog or in the panel you name. A link is offered to whoever may read what it opens (a role on that object, a report that is theirs or shared); the others read that it is not shared with them. Give it a Picture and it becomes a tile, the picture its background and the label over its foot, as tall as Height says: a kiosk's buttons; - on a table, A row opens: the record's own page (as ever, from its first cell); the record's own form, to edit it, in a dialog, on its own page or in a panel; or a screen opened on that record, in a dialog or in a panel. Then the whole row is pressed, anywhere on it (from the keyboard, Tab to its first cell and press Enter), and a person works on one of a list without leaving the list. The record's form is its page's own: Save, its actions and Archive, through its policies and rules, every change in its History; once sent, the dialog closes and the table says what was done. With New in a dialog too, and Remove on each row, a table is a whole small register: add, look, change, remove, without a page of its own. Or design a screen once (its parameter the record: a card of its fields, its forms) and any list can open it;
- on a table, Typed into here: tick the columns people type into where they stand, as in a spreadsheet (a work order's steps, their quantities and due dates). Each cell is its record's field: click it (or Tab to it), type, and it is saved when you leave it (Enter, Tab, a click elsewhere; Escape puts it back), by whoever typed it, through the object's policies, rules and approvals, in its History like a save on its page. A cell someone may not write on that record shows as plain text; one whose change waits for approval too (its form asks for it). What a rule would refuse is said under the cell as you type; what the server refuses is said there too, and the cell goes back to the record's value. If someone changed the record since you entered the cell, it says so and keeps what you typed: leave the cell again to send it. With New ticked, a line at the foot becomes a record once its required fields are in (Enter, Add, or leaving the line): it is typed into in the ticked columns and in every required one, the first included, so each required field is a column; Remove archives a row after asking. The first column stays the record's link, and only fields people enter can be ticked (not the state, numbered, derived, worked-out or sensitive ones, pictures, files or lists of values; a table of a query's rows has none);
- a panel: a named place on the screen where a button or a table's row shows what it opens; it says what you write for While empty until then, holds one thing at a time, and has a Close of its own;
- text: words for the people at the screen, an instruction or a note: a line per paragraph,
-for a list,**bold**,#a heading, and[the torque guide](https://…)or[the line board](/_s/line_board)for a link (to an https address, in a new tab, or to a page of this site); - what was done lately with transactions: tick the transactions; the block lists their runs, newest first (50, or How many, 5 to 200): when, who, which, each record it moved with its status's way (Available → In use) and the values it set (Issued to: Eli Brandt), as the viewer may read them. Tick Only the viewer's own runs for a person's own history. It reads the audit trail, so it adds nothing to it;
- the step a record's plan waits at: Of the record (usually the screen's parameter) and, if you tick some, which plans: the step its plan waits at, as its own page shows it (the PM checklist to fill, the repair's choices), for those it is for, with the cursor in it; to anyone else, whom it waits for. A transaction's form is shown only to those who may run it, so one desk can serve two kinds of people;
- a file: a guide, a picture, a video or a PDF: Shows either a file of its own, uploaded here
(Upload…: the station's guide, a drawing, a video of the job; a picture up to 5 MB, a PDF or a
spreadsheet 10 MB, a video, MP4 or WebM, 100 MB), or a record's file or picture: Of an object
with a file or picture field, Which record (the screen's:
{"param": "lot"}) and the Field. A field derived through a reference shows that record's: a station opened with a lot shows the work instruction of the lot's step. A PDF is read in the page, a video plays (and can be skipped through), a picture is shown, each with a link to open it on its own; Height for a PDF or a video. A record's file is read as whoever opens the screen: someone who may not read the record sees nothing. Steps: a line each, where the step starts and what it is,3 Torque crosswise(a PDF's page) or0:45 Clean the seal(a video's time). Write them in the block for its own file, or pick Steps from, a text field of the record (each instruction its steps; derived from the step like its file). At the screen, a PDF shows one page at a time with big ‹ Previous step and Next step › (page by page without steps), "Step 2 of 5 · page 3 of 8", and the steps to jump to, with −, + and Fit to zoom in on a small drawing or a table (the page then scrolls inside its box; the keys-,+and0do the same); a video has Previous step, Play this step (it stops where the next step begins, unless you untick A video stops at each step's end) and Next step. On a browser too old for the page viewer, a PDF is shown by the browser itself, without steps. Steps marked done by: a transaction that records a step done (a "Step done" with the lot, the step's number and, if you want them kept, a value and a photo, creating one record per step). Then Its number in (the input taking the step's number: 1, 2, … as the steps are written), Photos and files in, It fills in ({"lot": {"param": "lot"}}), and which records say a step is done: Done when there is a (the object the transaction creates), …whose step is its number field, …and where whose ({"lot": {"param": "lot"}}). Tick Next only once the step in view is done to hold the operator on each step until it is. End a step's line with how it is done: nothing or#click(a Mark done button),#value:torque(a value typed or scanned, into the transaction'storque),#photo(a picture: on a phone or a tablet, its camera),#file(a file uploaded),#device(the equipment records it: the step waits for it),#wait(another transaction or a flow records it), or#screen:etch_station(it is done on that screen, which the step opens). Each step marked is that transaction's run, with its checks, its signature if it has one, and the audit trail; a record the equipment or another page writes ticks its step at once, for everyone at the screen. A done step shows who did it and when, and Undo for whoever may archive its record (the record is archived, never deleted: the audit trail keeps both). A transaction verified by a second person works here as on its form: they sign in beside the operator (Add a second person), and both give their passwords. Follows a route: the steps are the route's instead, its sequences given a place in this guide (In the guide at, in the Flow designer), with Whose way the lot ({"param": "lot"}). The guide opens where the lot is, ticks each step it has left, and says which transaction takes it on.
- one record: a record's fields, usually the one the screen is opened with (
- Input flow: how the screen is filled from the keyboard or a scanner, over its machine and its forms' inputs (section 11). With one, the screen walks its forms itself, in place of their transactions' own flows.
- Scanning: the labels on this screen, as one table: its machine's own (set here: a label printed on the tool), and its forms' inputs' as their transactions define them (changed there). No two under different names may share a prefix. Try a scan says where a read would go.
- Preview: the draft as it will look, with your own rights; pick a machine to open it with.
- Drawn from: rest the pointer on a block, here or on Blocks (or reach its link with Tab), and a card in its corner names what it is drawn from: the object it reads, the transaction it runs, the named query, the flow, the screen a button opens, the data source; for a suite's block (drawn by the suite itself), the object of the screen parameter its setting names (a machine's block: the machine). View opens that design as it is live; Open here opens one this change holds in this window. In Preview the card also has Edit this block: the Blocks tab opens on that block's card (its list, its buttons, its inputs), marked a moment, the cursor in it. The live screen never shows it.
- Pop-up: tick Opens by itself to have this screen open as a dialog, by itself, Over the
pages you choose (a transaction, a screen, or every page), For the groups or people you name,
While a condition (section 17) holds (over the page: a transaction's inputs,
{"lookup": "machine.state"}, a screen's parameter, counts), Opened with what it needs from the page ({"input": "machine"}). Everyone on that page sees it at once, and it closes by itself when the condition stops holding. A person may close it; it shows again when they next open the page while it still holds. It only shows: what must not happen is refused by the transaction's own checks (its Must hold). The seed's Machine down opens over Move in and Track in while the machine is down. - Callers: who may open it; nobody until named.
Any screen can be a dialog. A button or a pop-up opens it over the page you are on, which stays as it was: a few questions, or a whole screen of its own, such as manual data collection with its tables and its transaction. Close it with its ✕, Escape or a click beside it.
Everyone sees it with their own rights. A table lists only the records they may read, with only the fields they may read; a number counts and adds only those. So one screen can serve Production and Quality, each seeing what they are allowed to. A screen changes nothing itself: its buttons are transactions, with their own checks and approvals. It is approved by its stewards alone.
It is live: a lot tracked in on one tablet moves from "Waiting" to "Processing" on every screen showing that machine.
From the keyboard or a scanner. Opened without its machine, the cursor waits in its scan (or list); once chosen, it goes to the first empty input of the form on the tab in view. Alt+1, Alt+2, … switch the tabs (Option+1 on a Mac), the tab's form taking the cursor; a row's button that fills a form puts the cursor in that form. Each form then goes as section 9 says, by its transaction's own input flow if it has one. A screen may draw an input flow of its own, over its machine and its forms (scan the machine, then on Move in the lot, run, and again): then the screen walks its forms, and their transactions' flows are left aside.
A floor layout: the line seen from above
A floor layout block draws your equipment where it stands on a picture of the floor, each with a small square in the colour of its state, as it is right now. Add it on a screen's Blocks tab (+ add a block → a floor layout), then, on its card:
- Of: the object your equipment is.
- Status: the field the square shows: the record's state, or a field of it (a choice, a yes/no).
- Each record's picture: where the equipment's own picture is: an image field of the equipment, or of what it refers to (Model → Picture: one picture per model, set once on the model). None: a plain tile with its name.
- Legend: a colour for each state. Leave one alone and it takes its tone. The colours are the theme's (five tones and eight more), so the board reads in light and in dark.
- Upload the floor's picture: a top view of the floor or the line (PNG, JPEG or WebP, up to 5 MB).
- Put the equipment on it: type part of a name (WBD), and click each one found. Then:
- drag a tool to where it stands;
- drag its small square to where it sits on the tool (its signal tower, its screen);
- click a tool to size it with the slider, or take it off the floor;
- Same size and square for its like gives every tool with the same picture the same size and square position: arrange one wirebonder, and the others follow;
- the arrow keys move the chosen tool a step (with Shift, a larger one).
The squares on the canvas already show the tools' real states. Name who may open the screen (Callers), and submit the change: the layout is reviewed and approved with its screen. Up to 200 tools on a floor.
On the board, a tool that changes state changes colour at once, on every screen showing it; the legend counts the tools in each state; a tool opens its record. Each person sees the states of the tools they may read: one they may not is drawn in its place with an empty square. Use Fill the window (General) for a wall board.
To hold pictures, give an object a field of type image (its Fields tab): on its form, whoever may write the field uploads the picture.
Showing and enabling blocks and tabs by condition
A screen can offer only what makes sense right now: at a machine that already has a lot on it, the Move in tab is greyed; a block for Quality is drawn for Quality only. Every block has three more settings, under its Title, Tab and Width:
- Shown when: a condition. While it does not hold, the block is not drawn, and its records are not read or sent to the page. Empty means always.
- Enabled when: a condition. While it does not hold, the block is drawn greyed and cannot be used (not with the pointer, and not from the keyboard). Empty means always.
- …because: what the person reads on a greyed block, and on its tab: "This machine already has a lot on it." Write it as you would say it at the machine.
Tabs follow their blocks. A tab none of whose blocks is shown is not there. A tab none of whose blocks is enabled is greyed, with a lock and the reason when the pointer rests on it; pressing it says the reason under the tabs instead of opening it. If the tab someone is on becomes unavailable, the screen moves to the first one that is. A row's button that fills a greyed form (Move in on a waiting lot) is greyed with the same reason.
What a condition reads (the language of section 17):
| It reads | Written | For example |
|---|---|---|
| the record the screen was opened with: a field, or its state | {"lookup": "machine.state"} | {"eq": [{"lookup": "machine.state"}, "idle"]} |
| what the screen was opened with | {"param": "machine"} | {"not": {"is_null": {"param": "machine"}}} |
| who is looking: their id, name, departments | {"user": "departments"} | {"contains": [{"user": "departments"}, "quality"]} |
| how many records there are | {"count": {"object": …, "where": …}} | {"gt": [{"count": {"object": "lot", "where": {"machine": {"param": "machine"}, "state": ["at_machine"]}}}, 0]} |
The record is read as the person may read it: a field their policies hide is empty to the condition. A condition is checked as you design it (a field the record does not have, an operator the language does not have, are problems on the block), and it is worked out again whenever a record changes, so the tab comes back the moment the machine is idle. A condition that cannot be worked out does not hold: the block is not shown, or not enabled.
It is what the screen offers, not who may do it. A greyed tab saves someone a refusal; it is not the rule. Whether a transaction may run is still its own callers and requirements (section 9), checked when it is confirmed, wherever it is run from. Put the rule there, and repeat it here only so the screen does not offer what would be refused. Likewise, hiding a block keeps its records from the page; the block's own title and words are part of the screen's design, which everyone who may open the screen receives.
With the copilot: "grey the Move in tab while the machine has a lot on it, and say so", or "show the scrap figures to Quality only".
A website: pages anyone can read
The business's own landing pages (home, about, products, contact) can live on the same site as the plant's work.
Visitors read them at /, /about, /products/widgets; the app's own pages keep their addresses (/_o, /_t, /_s,
/_design …), which no page may take.
- Start a screen, and on its General tab tick Website page. Give it Its address (
/for the home page; else lower case words and hyphens), a title (the browser tab and search results), a sentence of what it is about (search engines and link previews), and the label it has in the site's menu (empty: reached by its links only), in order. - Its blocks are what a visitor may see: text (headings, lists, links, bold), media with a file uploaded to
the screen (a picture, a video, a PDF), and buttons that link to a web address or to a page of this site
(another page's address, or
/_loginto sign in). A table, a figure, a chart, a transaction or a record reads what a person may see, so a website page refuses it, and the check says so. A suite may add blocks made for visitors (a hero, features, questions and answers). - It needs no callers: everyone may read it. It is approved like any screen, by its stewards; until the change executes, visitors see the page as it was.
- A visitor at
/sees the home page and the site's menu, with Sign in at the top; someone signed in still opens the app at/, and reaches the site through its other addresses (with Open the app at the top). - With the copilot: "draft our website: a home page with what we make, an about page, and a contact page with our address", then review and submit it as any change.
Customers who ask for an account
In People & departments → Sign-in, choose the group people who ask for an account join (a Customers group of your own, given the roles customers need). The sign-in page then offers No account? Ask for one: a name, an email, a company and why. Requests wait on Sign-in administration, where a sign-in administrator approves one (the person is made, joins the group, and is sent a link to set a password, also shown there once) or refuses it, saying why. Choose no group and nobody may ask.
For a public site whose people are its customers (a shop, courses), tick Anyone signs up at once: nobody approves
each request; the account is made the moment it is asked for and the link to set a password mailed to the address
given, which is what proves it. The sign-in page then says No account? Sign up. It needs the server's mail set up
(IT: SMTP_URL, PUBLIC_URL); until it is, requests wait on Sign-in administration as before, and so do those past a
hundred in an hour. Give that group only what a stranger may do: its own records, the transactions meant for it.
Products on the website, and a form visitors send
- What visitors may read. On the object's Roles & policies tab add a policy whose role is $visitor
(anyone, signed in nowhere): read the records only when they are published, and only the fields to show (the
name, the price, the picture; never
*). It is approved by the object's stewards like any policy. - Cards. Add a records as cards block to a website page: the object, what titles each card, a picture field, up to four lines, a badge, how many and in how many columns. Visitors see only what that policy lets them read; the same block on an ordinary screen shows each person what their own roles let them.
- A form visitors send. Make a transaction that creates the record (a quote request, an order), and on its Callers tab tick Visitors may send it. Give the object a $visitor policy that may create it, with the fields the form fills. Put the transaction on a website page as a block. It only makes new records; a product it asks for is picked from those visitors may read. A robot is caught by a field people never see, and one address may send a form ten times an hour.
- Orders from customers who signed in. A customer is someone who asked for an account and was approved into your
Customers group (above). Give the order a field that names its customer, a transaction for that group that creates
the order and sets the field to who is signed in (
{ user: 'id' }, never an input they type), a policy that lets the group create orders only through that transaction, and one that lets them read an order only when it names them. A screen for the group with the transaction and a table of orders is then each customer's own list. - From the order to the factory. What happens next is your design: approval on the order object (sales checks the price, planning the capacity), then a transaction your staff run on the approved order that creates the work order, which its route takes up at once. For example Release to the floor: an input for the order, shown on orders that are confirmed (Appears on), a step that creates a work order (its item from the order's product, its quantity from the order's, its line and due date as planning gives them) and a step that moves the order to released, both in one save: nothing is half done.
A desktop's own page
A computer on the floor is usually for one job. Say so once, and whoever signs in there starts on that page:
- Open Desktop (search "desktop" in the navigator; it is listed for those who hold a role on it:
the designers at first, and whoever People & departments gives
editororvieweron it, usually IT) and add a record: the desktop's name (Press 3 terminal), its address (the IP address its browser comes from, as the server sees it: ask IT), whether it opens a screen or a transaction, and which one: its field lists the screens (or transactions) that are live, by name; type part of one to narrow them. For a screen opened on one record (the work centre of this press), or a transaction opened from one, pick that record in Opened with: it lists that page's records you may read (none readable, it says so: ask for a role on them). Its menu lists the menus that are live. A name that is not live is refused when you save. - Load a floor at once from Excel: Data → Import / export, a tab named
desktopwith the columnsname,address,opens,page(andopened_with,menu,theme,note). A row is found again by its address, so loading the workbook again updates the desktops it names and adds the new ones. - At that desktop, signing in opens its page instead of Home, filling the window. Restore (top right of the page) brings back the navigator, the top bar and the tabs, and the person can go anywhere from there; it stays restored until they sign out, and the next sign-in opens it filled again. Home shows This desktop opens … as a way back.
- Someone who may not open that page (its callers) lands on Home there, as on any computer. A link followed before signing in still leads where it pointed.
- An address must be an IP address (anything else is refused at the field) and must stay the same: give the computer a reserved or fixed address. Archive a desktop to stop it opening its page.
Its theme. A desktop may look different from the rest of the plant: give it Its theme.
- The plant's (or empty): as on any computer, the plant's theme, and each person's own light or dark where the plant lets them pick.
- Light or Dark: that, at this computer, whatever the plant's theme and the person's choice.
- Dark room, amber: for a room where only filtered light may enter, such as a lithography's yellow room. Every page is amber, yellow and red on black, with no blue (so no white) anywhere, no brighter than it needs to be read.
- Dark room, red: for rooms darker still. Red on black only: the least light a screen can give and still be read.
At that computer every page takes it: the sign-in page before anyone signs in, records, lists, transactions, screens, the designer and every dialog. Nobody there can switch it: the light or dark button is not in the top bar, since the light a room may take is the room's. Each person's own choice is kept for the other computers. A change to the desktop's theme shows on its sign-in page at once, and on the pages of whoever signs in there after it (someone already signed in keeps the one they signed in with until they sign out).
In a dark room:
- States are told apart by how their badge is drawn as well as by colour, since there are few colours (red has one): a neutral state is dotted, info outlined, ok on a dim fill, warn on a dim fill with a heavy outline, danger filled.
- Pictures (an image field, a floor's picture, a PDF's pages, a label, a video) are shown in the room's colour, dimmed: a white page of a work instruction is dim amber, never white.
- The plant's own colours (People & departments → Theme) and the sign-in page's background picture are not used: a brand blue would be blue light.
- What the screen cannot do for you: turn the monitor's own brightness down (a backlight shows a little through black; an OLED screen does not). Set the computer's browser to open the app at start and to dark mode, so a new window or its start page is not white before the page arrives. The operating system's own windows (printing, a file to pick) are its own colours: avoid them in the room. A scanner's or a keyboard's lights are theirs.
Menus: the pages a group works from
Operators who use the same few screens and transactions all day can have them in the top bar of every page, and the page the whole width. A menu is designed on the Designer's Menus tab (New menu) and approved like any design.
- Items: a screen or a transaction each, in order, up to 12; more go under a heading, which opens as a dropdown. An item's label is the page's own unless you give one; an icon is optional: its field lists each icon drawn beside its name (type part of the name to find one, × to go back to none).
- Callers: the groups (or departments, or people) who work from it. Nobody has it until you name them.
- Order: someone in two groups named by two menus gets the one with the lower order.
- The navigator on the left: shown beside the menu; hidden, behind a button (the page takes the whole width, and a button in the top bar opens the navigator over the page, search included); or not offered (a station: the menu and Home only).
- A screen opened on a record: for a screen that opens with something (a machine's work centre), give what it opens with ("PRESS-1"): the item opens that record's page, labelled "Work centre: PRESS-1".
- A desktop's menu: a desktop (the Desktop records, under Organization in the navigator: a computer known by its address) may name a menu in Its menu: whoever signs in at that computer works from that menu there, whatever their own.
What each person sees of a menu is what they may open: a transaction they may not run is not in their menu, whoever else's menu shows it. On a phone the whole menu is one dropdown. A screen or a transaction a menu opens cannot be retired until the menu no longer names it. A menu's words are translated on its Translations tab like any design's.
The navigator's width is each person's own: drag its edge, or focus the edge (Tab) and use the arrow keys; Home, or a double click, puts the default back. It is kept with their tabs and favorites. It never takes more than a fifth of the window (at least 200 pixels), so on a laptop the page keeps its room; on a wider screen it opens up to the width dragged.
The page size is each person's own too: in the menu under their name, Page size draws every page at 90, 100, 110, 125 or 150 %, at once, at whatever computer they sign in at (an operator who reads the screen from a step away, a supervisor on a small laptop). The page still fits the window; the browser's own zoom (Ctrl and +) still works on top of it, for that computer alone. Firefox older than version 126 does not offer the choice.
Workbenches: the designer your suite's people work in
An installed suite may bring a workbench: what of the designer its people see. A cooperative's suite shows the coop's designers objects, approval flows, transactions, screens, queries and mail and report layouts, and leaves out routes, plans, labels, floors, menus and scanning; inside an object it shows the tabs a coop designs with.
- Who works in which: People & departments → Workbenches. Pick what everyone works in (the whole designer, unless you choose a workbench), then add a line per department or group that works in another; the first line naming one of a person's departments or groups wins. Governance approves the change, like any to People & departments.
- The designer says which: its home starts with You work in Cooperative designer, and Open the whole designer
beside it (kept in your browser; Back to … returns). People & departments can stop offering the switch; the
whole designer is still at
/_design?designer=whole. - It hides, it never forbids. The checks, the policies and the approvals are the same in any workbench, and a change's Changes are always shown whole, so reviewers and approvers read everything that changes. Something a design already uses is never hidden: an object with translations shows its Translations tab, a kind holding designs stays on the home (in italics, outside your workbench), and a design keeps its own kind (a route opened in a coop's workbench is still a route).
- The copilot works in it too: it drafts what your workbench shows, and says when what you ask needs the whole designer.
- A suite removed: its workbench goes with it, everyone works in the whole designer, and every design works as before. People & departments keeps its name, marked as not installed, until you change it.
A suite's author writes the workbench as workbench.json beside the suite: see the use cases book, 81b.