Struct Shell 

pub struct Shell {

    editor: Rc<RefCell<Editor>>,
    library: Rc<Library>,
    away: Rc<Cell<bool>>,
    pasting: Rc<Cell<Pasting>>,
    waiting: Rc<RefCell<Option<Door>>>,
    batch: Rc<RefCell<Batch>>,
    pacing: Rc<Cell<Pacing>>,
    chrome: Signal<Chrome>,
    frames: Signal<Option<Metered>>,
    reported: Signal<Reported>,
    owed: Signal<Owed>,
    held: Signal<Vec<Listed>>,
    renaming: Signal<u64>,
    picker: Signal<Option<Picker>>,
    wanted: Signal<Option<Wanted>>,
    safe: Signal<Rect>,
    palette: Signal<bool>,
    section: Signal<Option<Section>>,
    token: Token,
}

The shell, held once behind Rcs so every handler carries a clone.

Fields

editor: Rc<RefCell<Editor>>

library: Rc<Library>

The documents the origin holds, and every door onto them.

away: Rc<Cell<bool>>

Whether a door or the journal is standing between the frame and the document. Every one of them takes the document out of the session for as long as it awaits, so the frame that shares this handle is held off rather than shown a document that is not there.

pasting: Rc<Cell<Pasting>>

Whether a paste arriving now is one the user asked for.

waiting: Rc<RefCell<Option<Door>>>

The door someone asked for while another was out, which opens when that one is back. The latest ask is the one kept.

batch: Rc<RefCell<Batch>>

pacing: Rc<Cell<Pacing>>

chrome: Signal<Chrome>

frames: Signal<Option<Metered>>

The frame-rate readout, kept up only while the session shows it.

reported: Signal<Reported>

What the shell itself could not do, which the toast shows.

owed: Signal<Owed>

What the storage owes, which the status line’s liveness slot shows.

held: Signal<Vec<Listed>>

What the origin holds, which the Diagrams section lists.

renaming: Signal<u64>

How many times the menu has asked for the rename box. A count rather than a flag: the box lives on the breadcrumb, which has to tell a fresh ask from the one it has already opened on.

picker: Signal<Option<Picker>>

Which picker an effect opened, if any.

wanted: Signal<Option<Wanted>>

What an open file pick is for, if one is open.

safe: Signal<Rect>

The part of the diagram the chrome leaves clear, which the selection overlay places itself inside.

palette: Signal<bool>

Whether the search palette is up. Shell state, not the session’s — which is why the command that asks for it is an effect.

section: Signal<Option<Section>>

Which sidebar section is open, if any. Likewise the shell’s: the session has no opinion about what is being browsed.

token: Token

How this platform writes the command modifier — the whole of §4’s per-platform difference.

Implementations

impl Shell

pub fn opening( prefs: &Preferences, prefers: Prefers, opened: Opened, ) -> (Self, Signal<Chrome>)

A shell over the document the origin was opened on, primed: the first call runs here — dressed as the preferences ask — so the chrome has a bar and a tool cluster before a frame has ever been booked.

pub fn chrome(&self) -> Signal<Chrome>

What the components bind.

pub fn frames(&self) -> Signal<Option<Metered>>

What the frame-rate readout shows, once a frame has been metered.

pub fn reported(&self) -> Signal<Reported>

What the shell itself could not do, which the toast shows.

pub fn owed(&self) -> Signal<Owed>

What the storage owes, which the status line’s liveness slot shows.

pub fn owes(&self, depth: Owed)

The storage says how far behind it is.

pub fn picker(&self) -> Signal<Option<Picker>>

Which picker is open, which the overlay anchors.

pub fn wanted(&self) -> Signal<Option<Wanted>>

What an open file pick is for, which the hidden input reads.

pub fn safe(&self) -> Signal<Rect>

The part of the diagram the chrome leaves clear.

pub fn palette(&self) -> Signal<bool>

Whether the search palette is up.

pub fn section(&self) -> Signal<Option<Section>>

Which sidebar section is open, if any.

pub fn works(&self)

Only working dismisses the sidebar’s panel: a press on the diagram or a tool pick is unambiguous intent to edit (docs/cad-ui-spec.md §8). Nothing inside the panel ever closes it.

pub fn escaped(&self) -> Escaped

Escape, claimed before anything else reads it: the palette closes first, then the sidebar’s panel, and only a keystroke neither wanted reaches the canvas.

pub fn theme(&self) -> Theme

The roles the chrome resolves its own readings of the diagram through, in the palette the diagram is painted in.

pub fn token(&self) -> Token

How this platform writes the command modifier.

pub fn attributed(&self) -> String

Who this session’s commits are attributed to as it stands.

pub fn wears(&self, prefs: &Preferences, prefers: Prefers)

Dress the diagram as the preferences ask, and attribute the session to who they name. A preference that did not move changes nothing and books no frame.

pub fn failed(&self, what: impl Into<String>)

Something the shell was asked to do did not work. It is the shell’s own failure, not the document’s, so it is toasted rather than filed among the session’s notices.

pub fn raises(&self, act: Act)

What a control raised: an edit goes into the batch by name, and an effect is performed by whoever owns the flow it belongs to.

fn performs(&self, effect: &Effect)

The doors the chrome opens that the kernel cannot. A door that is not there says so rather than failing silently.

pub fn held(&self) -> Signal<Vec<Listed>>

What the origin holds, for the section that lists it. A signal rather than a call, because the answer is a promise and a component cannot await one.

pub fn asks_to_rename(&self)

Rename: the box the breadcrumb opens on a double click, asked for from the Diagrams section instead. One gesture, two ways in.

pub fn renaming(&self) -> Signal<u64>

The count the box watches, so a fresh ask is told from the one it is already open on.

pub fn deletes(&self)

Delete: the document, gone from the origin, and the session left standing on the next one.

pub fn exports_archive(&self)

Export .bwx.zip: what the origin holds, as the one file a container travels in.

pub fn exports_named(&self, name: &str)

A listed row’s Export: the diagram it names, as the one file a container travels in.

pub fn deletes_named(&self, name: &str)

A listed row’s Delete: the diagram it names, gone from the origin. Any but this tab’s own leaves the session where it stands, and one another tab has open is refused.

pub fn imports_archive(&self, called: String, archive: Vec<u8>)

Import .bwx.zip: a container laid down in the origin under a name nothing stands under, and opened.

fn opens_a_door(&self, door: Door)

The library’s own doors, each of which awaits the origin — so the document leaves the session for as long as one is open and the frame stands off until it is back.

One at a time and never two: the origin is written in the order the store made its writes, and a second door open across the first would interleave a rev with the row that names it.

async fn walks_through(&self, door: Door, doc: Doc) -> (Stood, Option<String>)

What a door leaves the session standing on, and what it could not do.

async fn deletes_this(&self, doc: Doc) -> (Stood, Option<String>)

This tab’s diagram, gone from the origin, and the session left standing on a newborn.

async fn exports_this(&self, doc: Doc) -> (Stood, Option<String>)

This tab’s diagram, packed and handed to the browser to save.

pub fn picked(&self, act: Option<Act>)

A picker or a file pick ended. What it ended in is an ordinary action; a cancel is nothing at all, because opening the flow changed nothing to put back.

pub fn provoked(&self)

The middle button went down on the diagram: a paste that follows is the platform’s, not an ask (Pasting).

pub fn asked(&self)

A key was pressed, so the user is at the keyboard and the next paste is theirs.

pub fn takes_a_paste(&self) -> bool

Whether to take a paste the browser just raised. Asking clears the provocation, so one middle click refuses one paste.

pub fn delivers(&self, what: Wanted, name: &str, bytes: Vec<u8>)

The bytes a file pick came back with, delivered to whatever the pick was opened for — so one that took a while still lands where the press that asked for it meant it to.

pub fn embeds(&self, name: &str, bytes: &[u8])

A document dropped on the diagram, embedded as a block of this one.

No door: an embed is a copy of the arriving drawing, so nothing is laid down in the origin and the session keeps its document throughout. Filing a document is the Diagrams section’s drop (Self::imports_archive).

async fn delivers_archive(&self, named: &Name) -> Result<(), String>

The container named, packed and handed to the browser to save.

fn takes_back(&self, stood: Stood)

Give the document back and let the frame run again.

async fn lists_the_origin(&self)

fn drains(&self)

The journal, after a frame: what the container owes the origin, made.

pub fn reports(&self, what: impl Into<String>)

A standing fact about the document, which the notices strip carries until it is acknowledged — as the desktop’s library reports one.

pub fn unpicked(&self)

A file pick was cancelled. Opening the picker changed nothing, so there is nothing to put back — only the record of the flow to drop.

pub fn typeface(&self) -> FontChoice

The face the diagram is drawn in — which the in-place editor types in too, so the draft and what it covers are the same letters.

pub fn say(&self, event: Event)

Say a thing happened, and book the frame that reads it.

pub fn sampled(&self, sample: Sample)

The same, for what the pointer or the keyboard did.

pub fn mounted(&self, canvas: HtmlCanvasElement)

The canvas is in the document: take its context, size its backing store, and tell the session how big the diagram is.

pub fn resized(&self)

The canvas changed size: the backing store follows the display, and the session is told the viewport it now paints in.

pub fn covers(&self, band: Band, at: Rect)

band lies over the diagram at at, in the canvas’s own coordinates. Measured by the band itself and re-measured when it moves, never cached: what a framing has to stay clear of is where the chrome is, not where it was laid out.

pub fn origin(&self) -> Option<Pos2>

Where the canvas’s top-left sits in client coordinates, which a pointer event is read against.

pub fn grabs(&self, pointer: i32)

Take the pointer for the gesture and the keyboard for the canvas, so a drag that leaves the element still arrives and the keys are read.

pub fn takes_keyboard(&self)

The keyboard goes back to the canvas: a field that closes leaves the focus on the page’s body otherwise, where no digit arms a tool.

fn says_the_safe_region(&self, viewport: Rect)

fn books(&self, ask: impl FnOnce(&mut Pacing) -> Schedule)

fn book(&self, schedule: Schedule)

fn frame(&self)

One frame: what was said, run and shown.

A frame while a door is open would find a document that is not there, so it stands off; what was said keeps until the door closes and books the frame that reads it. The wait is one origin write per owed row, so what it costs at worst is the frame after a commit lands.

fn assemble(&self) -> Vec<Event>

The batch as the call takes it: what time it is, then what was said, then what the browser told the canvas.

Trait Implementations

impl Clone for Shell

fn clone(&self) -> Shell

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl PartialEq for Shell

Two shells are the same shell when they are clones of one another, which is what a component needs to know of one.

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.