Struct Document 

pub struct Document {
    pub engine: EngineState,
    /* private fields */
}

ONE open model: the engine that owns it plus the identity the file lane needs — the store name it was opened from / saved to, and the clean baseline.

Fields

engine: EngineState

The windowing-agnostic brain for THIS document (scene, camera, history, settings, selection). Panels borrow it; it is never forked.

Implementations

impl Document

pub fn new(engine: EngineState) -> Self

Wrap engine as a document, taking its CURRENT model as the clean baseline — so a freshly loaded (or freshly emptied) document is clean and the first edit marks it dirty.

pub fn recovered(engine: EngineState, name: Option<String>) -> Self

Wrap engine as a document RESTORED from the autosave blob (crate::recovery): it carries the store identity it had (None for an untitled one) and NO clean baseline, so it is dirty from its first frame — the work it holds is exactly what was never saved, and the close guard and the tab dot must say so until a Save writes it somewhere.

pub fn name(&self) -> Option<&str>

The raw store identity, or None for a never-saved document.

pub fn set_name(&mut self, name: Option<String>)

pub fn title(&self) -> String

The tab label: the bare display name, or untitled.

pub fn mark_clean(&mut self)

Snapshot the current model as the clean baseline (after New / Open / Save, or a ?loadModel= boot-load).

pub fn is_dirty(&self) -> bool

Dirty = the live model differs from the last saved/opened baseline. (Rolling the history does NOT change the request document, so navigating steps never marks dirty — only real edits/add/delete/reorder do.)

HONEST but not free: it serializes the whole request document, which for an assembly carrying an embedded parts library is megabytes. Every place where being wrong would cost the user work — the close prompt, Save — calls THIS. The per-frame tab dot calls Self::dirty_marker instead.

pub fn refresh_dirty_marker(&mut self)

The cached dirty flag the tab strip draws, recomputed only when the document’s APPLIED RUN generation moved. Every ordinary edit (a param change, add, delete, reorder, undo) re-runs the history and bumps that generation, so the dot tracks editing; a mutation that changes the document WITHOUT a re-run (an object-metadata write) can leave the dot one edit behind. That is a marker being briefly optimistic, never a lost edit: Self::is_dirty is recomputed honestly at the close prompt.

The alternative — serializing every open document every frame — is a per-frame multi-megabyte cost per tab, and the app pays no such cost today.

pub fn dirty_marker(&self) -> bool

pub fn id(&self) -> u64

The document’s process-unique handle (identity across index shuffles).