Struct Editor 

struct Editor {
    session: Session,
    glyphs: Glyphs,
    images: Images,
    reader: Reader,
    surface: Option<Surface>,
    diagram: Option<Diagram>,
    bands: Vec<(Band, Rect)>,
    dressed: Dressed,
    refused: Vec<String>,
    raised: Vec<Effect>,
    meter: FrameMeter,
    metered: Option<Metered>,
}

The editor and everything it draws through: one borrow, taken by the frame and by nothing else.

Fields

session: Session

glyphs: Glyphs

The text engine the kernel is called with and the ink its glyphs are filled from — one value, so the diagram cannot draw a face the recorder did not measure.

images: Images

reader: Reader

surface: Option<Surface>

The canvas, once it is mounted. A frame before that runs the kernel and paints nothing.

diagram: Option<Diagram>

What the canvas last showed.

bands: Vec<(Band, Rect)>

What each piece of the chrome covers of the diagram, which the safe region is the viewport minus. Measured by the bands themselves and re-measured when they move, never cached.

dressed: Dressed

What the diagram is currently drawn with, so a preference that did not move books no frame.

refused: Vec<String>

What the browser would not do with this call’s hand-offs, drained by the frame that ran it — the editor has no signal of its own to say so.

raised: Vec<Effect>

What a command named this call turned out to be the shell’s to perform. Drained by the frame that ran it, for the same reason: a picker is opened by a signal the editor does not hold.

meter: FrameMeter

The frames of the last second, for the frame-rate readout.

metered: Option<Metered>

What the last call’s frame came to on the meter.

Implementations

impl Editor

fn states_the_sheet(&mut self)

What an export is called, which sheet it is stamped with and which palette it prints in are the shell’s facts, not the document’s, so the session is told them before it draws its chrome or is told to do anything. The breadcrumb’s root segment is the same name.

fn run(&mut self, batch: Vec<Event>) -> View

The call, its hand-offs delivered and its diagram painted.

fn deliver(&mut self, handoff: Handoff)

fn shows(&mut self, diagram: Diagram, viewport: Rect) -> Repaint

Paint diagram over viewport, and keep it.

fn repaints(&self, viewport: Rect)

The kept diagram, back over a backing store a resize has just cleared — where it stood, until the call the resize books draws it for the new size.

fn paint(&self, diagram: &Diagram, viewport: Rect) -> Repaint

fn wears(&self, cursor: Option<Cursor>)