Struct Documents 

pub struct Documents { /* private fields */ }

Every open document + which one is active. Always holds AT LEAST ONE document: closing the last tab leaves a fresh untitled one in its place, so Documents::engine_mut is infallible and the shell never has to render a “no document” state that would be an empty viewport with extra steps.

Implementations

impl Documents

pub fn new(new_engine: EngineFactory) -> Self

A session holding one fresh document built by new_engine.

pub fn wrap_engine_factory( &mut self, wrap: impl Fn(EngineState) -> EngineState + 'static, )

A fresh engine for a document about to be opened — the caller loads into it and hands the result to Self::open_document.

Seeded with the WHOLE of the session’s settings, workbench included, so a new tab continues what you were doing. The load that follows overrides the workbench if the document names one (see the module header). Build every later tab’s engine through wrap as well: the app’s live PLM reconnect puts the new store’s settings over the factory’s.

pub fn spawn_engine(&self) -> EngineState

pub fn engine(&self) -> &EngineState

pub fn engine_mut(&mut self) -> &mut EngineState

pub fn active(&self) -> &Document

pub fn active_mut(&mut self) -> &mut Document

pub fn active_index(&self) -> usize

pub fn active_id(&self) -> u64

The ACTIVE document’s handle — the shell compares it frame to frame to notice a switch from ANY source (a tab click, a close, New, Open, Open Part, a crash-recovery restore) with one check instead of a hook per site.

pub fn len(&self) -> usize

pub fn get(&self, index: usize) -> Option<&Document>

pub fn get_mut(&mut self, index: usize) -> Option<&mut Document>

pub fn iter(&self) -> Iter<'_, Document>

pub fn iter_mut(&mut self) -> IterMut<'_, Document>

pub fn pump_all(&mut self) -> bool

Land every open document’s finished runs; true while any of them still has work in flight, so the frame loop keeps pumping.

EVERY open document is pumped, not just the active one: a run belongs to the engine that submitted it (each document owns its own runner), so a run still in flight when the user switches tabs must land in ITS document rather than be dropped or, worse, applied to whatever is on screen. An idle document’s pump is a couple of empty try_recvs.

The kernel’s parts library is one store for every tab, and a pump can SUBMIT a run as well as land one: EngineState::pump re-runs after its runner refused a run for a library it no longer holds, after a ports edit moved a point, and when a mesh reconstruction lands (its STEP is imported, which writes the store into the document and runs). A submit hands the runner whatever library is in the store, and a run that lands mirrors the store it ran with into its document’s own partsLibrary block. So a tab in the BACKGROUND that may do either — a run in flight, or a point move waiting — is pumped with ITS library installed, and the active document’s is put back right after. (A STEP probe’s reply only stashes what it found, and landing a run submits nothing, so those need no more than run_pending.) Pumped with the active one’s, it resolved its components against another document’s parts, and the run that landed wrote that into its own file. An idle background tab submits and lands nothing, so it costs nothing.

pub fn index_of(&self, name: &str) -> Option<usize>

The tab holding the document stored under name, if any.

pub fn focus_named(&mut self, name: &str) -> bool

Activate the tab already holding name; false when it is not open. The “focus the existing tab” half of open-or-focus.

pub fn open_document(&mut self, doc: Document) -> usize

Add doc as a new tab and make it active.

pub fn activate(&mut self, index: usize)

Make tab index active, carrying the session’s display settings over to it. Out-of-range indices are ignored (a stale click never panics).

pub fn close(&mut self, index: usize)

Close tab index. Closing the LAST document leaves a fresh untitled one (the always-one-document invariant); closing a tab before the active one keeps the same document active at its new index.

The caller is responsible for the unsaved-changes prompt — this is the mechanical close (panels::file owns the confirmation).

pub fn refresh_dirty_markers(&mut self)

Refresh every tab’s dirty dot (see Document::refresh_dirty_marker).