Files
craft-libs/docs/contract-api.md
T

553 KiB
Raw Blame History

Contract API

Generated by cl cargo run -p craft-ui-gallery --bin contract-api; do not edit. Every public item of craft_behavior and of the shared modules of craft_ui (contract, layout, layout_components, primitives, runtime, style, testing and the crate root), by public path, with its signature line and the first line of its doc comment. Inherent methods and trait methods are indented under their type. Setters written by #[derive(Props)] are not listed: each #[prop] field of a type is a setter of the same name.

craft-ui-contract defines every module listed here except layout_components, which craft-ui-widgets defines; the craft-ui facade re-exports each under the same name. craft_ui::testing also re-exports the story helpers of craft-ui-widgets, testing::internals of craft-ui-panels and the tool and canvas fixtures of craft-ui-canvas, which are not listed.

craft_behavior

Pure UI behaviours (layer 1): press lifecycle, ValueDrag, navigation, item layouts, edit events,

  • craft_behavior::AccessAction: re-export of accesskit::Action (outside these crates).
  • craft_behavior::AccessData: re-export of accesskit::ActionData (outside these crates).
  • craft_behavior::AccessRequest: re-export of craft_behavior::intent::AccessRequest.
  • craft_behavior::Anchor9: re-export of craft_behavior::anchor::Anchor9.
  • craft_behavior::Applied: re-export of craft_behavior::value::Applied.
  • craft_behavior::Arrangement: re-export of craft_behavior::arrangement::Arrangement.
  • craft_behavior::Arrows: pub enum Arrows { All, Horizontal, Vertical, None }. Which arrow keys a roving group moves its lead with.
  • craft_behavior::Axis: re-export of craft_behavior::flow::Axis.
  • craft_behavior::Buttons: re-export of craft_behavior::press::Buttons.
  • craft_behavior::CancelReason: re-export of craft_behavior::value::CancelReason.
  • craft_behavior::CancelRule: re-export of craft_behavior::focus::CancelRule.
  • craft_behavior::CanvasTransform: re-export of craft_behavior::canvas::CanvasTransform.
  • craft_behavior::CanvasView: pub struct CanvasView { pub rect: ScreenRect, pub center: Point, pub zoom: f64, pub rotation: f64, pub flip_x: bool, pub aspect: f64 }. How a canvas shows its document: where, how large, turned and mirrored how. Apps convert their
    • pub fn new(rect: ScreenRect, center: Point, zoom: f64) -> Self. An upright, unmirrored, square-pixel view of rect showing center at zoom.
    • pub const fn rotation(mut self, degrees: f64) -> Self. The same view turned degrees clockwise.
    • pub const fn flip_x(mut self, flip: bool) -> Self. The same view mirrored left-right (or not).
    • pub const fn aspect(mut self, aspect: f64) -> Self. The same view with a document unit aspect times as wide as it is tall.
    • pub fn points_per_unit(device_zoom: f64, pixels_per_point: f32) -> f64. zoom for a view that shows device_zoom device pixels per document unit at
    • pub fn affine(&self) -> Affine. Document to screen points.
    • pub fn to_screen(&self, p: Point) -> Pos2. Where the view draws document point p.
    • pub fn to_doc(&self, p: Pos2) -> Point. The document point under screen position p.
    • pub fn map_vec(&self, v: Vec2) -> ScreenVec. A document vector as the view draws it: stretched, turned, zoomed and mirrored.
    • pub fn unmap_vec(&self, v: ScreenVec) -> Vec2. The document vector a screen vector shows: the inverse of map_vec.
    • pub fn zoom_x(&self) -> f64. Screen points per document unit along the document's x axis: zoom × aspect.
    • pub fn quad(&self, r: Rect) -> [Pos2; 4]. The screen corners of document rect r, in order round it: (x0, y0), (x1, y0), (x1, y1),
    • pub fn visible(&self) -> Rect. The document bounds of the screen rect: every document point the view can show.
    • pub fn doc_len(&self, points: f32) -> f64. A screen distance in document units along the document's y axis (divide by
    • pub fn layer_transform(&self) -> Option<CanvasTransform>. The transform a canvas body is shown through when this view only scales and moves the document: unturned,
    • pub fn axis_aligned(&self) -> bool. Whether the rotation is a multiple of 90°, so document axes are screen axes.
    • pub fn level(&self, zero: Point) -> CanvasView. The view without its rotation, moved so it draws zero where this view does: the same
  • craft_behavior::Caret: re-export of craft_behavior::codec::Caret.
  • craft_behavior::CellAdvance: pub enum CellAdvance { Enter, Tab }. Which key moves the active cell after an entry: Enter goes down the rows, Tab along a row.
  • craft_behavior::CellAt: re-export of craft_behavior::selection::CellAt.
  • craft_behavior::CellDirection: pub enum CellDirection { Up, Down, Left, Right }. A move of one cell. Logical: in a right-to-left sheet the widget maps the Left arrow to
  • craft_behavior::CellRange: re-export of craft_behavior::selection::CellRange.
  • craft_behavior::CellSelection: re-export of craft_behavior::selection::CellSelection.
  • craft_behavior::Codec: re-export of craft_behavior::codec::Codec.
  • craft_behavior::ColumnKey: re-export of craft_behavior::columns::ColumnKey.
  • craft_behavior::ColumnWidth: re-export of craft_behavior::columns::ColumnWidth.
  • craft_behavior::CommandFlags: re-export of craft_behavior::command::CommandFlags.
  • craft_behavior::ControlMetrics: re-export of craft_behavior::sizing::ControlMetrics.
  • craft_behavior::Cursor: re-export of craft_behavior::cursor::Cursor.
  • craft_behavior::CursorBadge: re-export of craft_behavior::cursor::CursorBadge.
  • craft_behavior::CursorIcon: re-export of craft_behavior::cursor::CursorIcon.
  • craft_behavior::CursorPriority: re-export of craft_behavior::cursor::CursorPriority.
  • craft_behavior::DigitEntry: re-export of craft_behavior::digit_keys::DigitEntry.
  • craft_behavior::DigitKeys: re-export of craft_behavior::digit_keys::DigitKeys.
  • craft_behavior::DisplayOrder: re-export of craft_behavior::item_source::DisplayOrder.
  • craft_behavior::DocKey: re-export of craft_behavior::doc_key::DocKey.
  • craft_behavior::DockSide: re-export of craft_behavior::dock::DockSide.
  • craft_behavior::DragWarp: re-export of craft_behavior::value_drag::DragWarp.
  • craft_behavior::DropOperation: re-export of craft_behavior::keys::DropOperation.
  • craft_behavior::EditCommand: re-export of craft_behavior::intent::EditCommand.
  • craft_behavior::EditEvent: re-export of craft_behavior::value::EditEvent.
  • craft_behavior::EditEvents: re-export of craft_behavior::value::EditEvents.
  • craft_behavior::EditHistory: re-export of craft_behavior::edit_history::EditHistory.
  • craft_behavior::EditPolicy: re-export of craft_behavior::value::EditPolicy.
  • craft_behavior::EditRun: re-export of craft_behavior::typing::EditRun.
  • craft_behavior::EditorInput: re-export of craft_behavior::editor::EditorInput.
  • craft_behavior::Ended: re-export of craft_behavior::typing::Ended.
  • craft_behavior::EscapeRule: re-export of craft_behavior::typing::EscapeRule.
  • craft_behavior::Escaped: re-export of craft_behavior::typing::Escaped.
  • craft_behavior::Flow: re-export of craft_behavior::flow::Flow.
  • craft_behavior::FreeLayout: re-export of craft_behavior::item_layout::FreeLayout.
  • craft_behavior::Gesture: re-export of craft_behavior::value::Gesture.
  • craft_behavior::GestureId: re-export of craft_behavior::value::GestureId.
  • craft_behavior::GesturePhase: re-export of craft_behavior::value::GesturePhase.
  • craft_behavior::Granularity: re-export of craft_behavior::intent::Granularity.
  • craft_behavior::GridCursor: re-export of craft_behavior::grid::GridCursor.
  • craft_behavior::GridFacts: re-export of craft_behavior::role_rule::GridFacts.
  • craft_behavior::GridMeasure: re-export of craft_behavior::grid::GridMeasure.
  • craft_behavior::GridSection: re-export of craft_behavior::columns::GridSection.
  • craft_behavior::GridView: re-export of craft_behavior::columns::GridView.
  • craft_behavior::HitLevel: re-export of craft_behavior::hit::HitLevel.
  • craft_behavior::HitPriority: re-export of craft_behavior::hit::HitPriority.
  • craft_behavior::HitShape: re-export of craft_behavior::hit::HitShape.
  • craft_behavior::IconId: re-export of craft_behavior::cursor::IconId.
  • craft_behavior::Input: re-export of craft_behavior::input::Input.
  • craft_behavior::Insets: re-export of craft_behavior::flow::Insets.
  • craft_behavior::Intent: re-export of craft_behavior::intent::Intent.
  • craft_behavior::ItemLayout: re-export of craft_behavior::item_layout::ItemLayout.
  • craft_behavior::ItemSource: re-export of craft_behavior::item_source::ItemSource.
  • craft_behavior::KeyOwner: re-export of craft_behavior::focus::KeyOwner.
  • craft_behavior::KeyRole: re-export of craft_behavior::keys::KeyRole.
  • craft_behavior::Keyed: re-export of craft_behavior::item_source::Keyed.
  • craft_behavior::LabelColumn: re-export of craft_behavior::label_column::LabelColumn.
  • craft_behavior::LabelPlacement: re-export of craft_behavior::label_column::LabelPlacement.
  • craft_behavior::Letters: pub enum Letters { None, TypeAhead }. Whether a roving group matches typed letters to entries.
  • craft_behavior::LineIndex: re-export of craft_behavior::item_layout::LineIndex.
  • craft_behavior::MarqueeMode: re-export of craft_behavior::item_marquee::MarqueeMode.
  • craft_behavior::MarqueeSelect: re-export of craft_behavior::item_marquee::MarqueeSelect.
  • craft_behavior::Metrics: re-export of craft_behavior::sizing::Metrics.
  • craft_behavior::Mixed: re-export of craft_behavior::value::Mixed.
  • craft_behavior::Monitor: re-export of craft_behavior::monitor::Monitor.
  • craft_behavior::MonitorKey: re-export of craft_behavior::monitor::MonitorKey.
  • craft_behavior::MotionKind: re-export of craft_behavior::motion::MotionKind.
  • craft_behavior::MotionMode: re-export of craft_behavior::motion::MotionMode.
  • craft_behavior::MoveMods: re-export of craft_behavior::intent::MoveMods.
  • craft_behavior::MultiTouch: re-export of craft_behavior::press::MultiTouch.
  • craft_behavior::NavMove: re-export of craft_behavior::intent::NavMove.
  • craft_behavior::NavOutline: pub trait NavOutline. Positions, not keys: the key-free part of DisplayOrder.
    • fn len(&self) -> usize. The number of positions.
    • fn depth(&self, at: usize) -> usize. The nesting depth of the position, 0 for a root.
    • fn has_children(&self, at: usize) -> bool. Whether the position has children.
    • fn open(&self, at: usize) -> bool. Whether the position's children show.
    • fn is_section(&self, at: usize) -> bool. Whether the position is a section header, which a move skips.
    • fn enabled(&self, at: usize) -> bool. Whether the position can take the lead.
    • fn row_len(&self, _row: usize) -> Option<usize>. RaggedGrid: the number of positions in row; rows hold consecutive positions. None past the last row.
    • fn columns(&self) -> usize. Cell: the cells of every position (a row of a sheet).
    • fn first_column(&self) -> Option<usize>. WrappedGrid: the column of position 0 when the grid has blank cells before it (the leading days of a
    • fn rect(&self, _at: usize) -> Option<Rect>. Spatial: where the position sits, in any one coordinate space.
    • fn is_empty(&self) -> bool. Whether there are no positions.
  • craft_behavior::NavShape: pub enum NavShape { Flat, Tree, WrappedGrid { columns: usize }, BoundedGrid { columns: usize }, RaggedGrid, Cell, Spatial }. The geometry a collection's keyboard navigation follows.
    • pub const fn wrapped_grid(columns: usize) -> Self. Equal-width cells that wrap at columns.
    • pub const fn bounded_grid(columns: usize) -> Self. Equal-width cells in columns columns whose Left and Right stop at the row ends.
  • craft_behavior::NavState: pub struct NavState { pub lead: Option<usize>, pub anchor: Option<usize>, pub page: usize, pub wrap: bool, pub column: usize }. Where a navigation stands between moves.
    • pub const fn new() -> Self. A state with no lead, a page of ten and no wrap.
    • pub const fn at(lead: usize) -> Self. A state at lead.
    • pub const fn page(mut self, rows: usize) -> Self. Sets the page size.
    • pub const fn wrap(mut self, on: bool) -> Self. Sets whether moves wrap.
    • pub const fn column(mut self, column: usize) -> Self. Sets the lead cell's column.
  • craft_behavior::NavStep: pub enum NavStep { Stay, Moved(usize), Expand(usize), Collapse(usize), Column(usize), Unhandled }. What one move did.
  • craft_behavior::NotAValue: re-export of craft_behavior::codec::NotAValue.
  • craft_behavior::NumberCodec: re-export of craft_behavior::codec::NumberCodec.
  • craft_behavior::Outline: re-export of craft_behavior::item_source::Outline.
  • craft_behavior::OwnerClass: re-export of craft_behavior::focus::OwnerClass.
  • craft_behavior::PaintedCursor: re-export of craft_behavior::cursor::PaintedCursor.
  • craft_behavior::PartKey: re-export of craft_behavior::part::PartKey.
  • craft_behavior::PartRef: re-export of craft_behavior::part::PartRef.
  • craft_behavior::PassInput: re-export of craft_behavior::press::PassInput.
  • craft_behavior::PixelSize: re-export of craft_behavior::pixel_size::PixelSize.
  • craft_behavior::PlacedSelection: pub struct PlacedSelection. The selected cells by position in one display order: the rows and columns of each range, and the cells taken out
    • pub fn of_rows(spans: impl IntoIterator<Item = Range<usize>>) -> Self. The selected rows spans, every column of each.
    • pub fn of_cells(ranges: Vec<(Range<usize>, Range<u32>)>, mut removed: Vec<(usize, u32)>) -> Self. The ranges ranges (row positions, column positions) without the cells removed.
    • pub fn holds_row(&self, at: usize) -> bool. Whether the row at position at has a selected cell.
    • pub fn holds_cell(&self, at: usize, column: u32) -> bool. Whether the cell at row position at and column position column is selected.
    • pub fn rows(&self) -> Vec<usize>. The positions of the rows that have a selected cell, ascending.
  • craft_behavior::PlainText: re-export of craft_behavior::codec::PlainText.
  • craft_behavior::Playback: re-export of craft_behavior::motion::Playback.
  • craft_behavior::PointerButton: re-export of craft_behavior::press::PointerButton.
  • craft_behavior::PointerEvent: re-export of craft_behavior::press::PointerEvent.
  • craft_behavior::PointerKind: re-export of craft_behavior::press::PointerKind.
  • craft_behavior::PointerSample: re-export of craft_behavior::press::PointerSample.
  • craft_behavior::Positions: pub struct Positions. The display order of a grid whose row keys are their positions (a sheet, a document table): key(at) == at, and
    • pub const fn new(rows: u32) -> Self. The order of rows rows.
  • craft_behavior::PressCancel: re-export of craft_behavior::press::PressCancel.
  • craft_behavior::PressFocus: re-export of craft_behavior::focus::PressFocus.
  • craft_behavior::PressMachine: re-export of craft_behavior::press::PressMachine.
  • craft_behavior::PressPhase: re-export of craft_behavior::press::PressPhase.
  • craft_behavior::PressStart: re-export of craft_behavior::press::PressStart.
  • craft_behavior::PressState: re-export of craft_behavior::press::PressState.
  • craft_behavior::PressStep: re-export of craft_behavior::press::PressStep.
  • craft_behavior::Proposal: re-export of craft_behavior::sizing::Proposal.
  • craft_behavior::Reader: re-export of craft_behavior::quantity::Reader.
  • craft_behavior::ResolveFor: re-export of craft_behavior::hit::ResolveFor.
  • craft_behavior::RoleRule: re-export of craft_behavior::role_rule::RoleRule.
  • craft_behavior::Roving: pub struct Roving { pub shape: NavShape, pub wrap: bool, pub home_end: bool, pub page: Option<usize>, pub letters: Letters, pub arrows: Arrows, pub first_column: Option<usize>, pub hands_back: bool, pub no_lead: bool, pub keeps_lead_moves: bool }. A roving group's rules: one Tab stop whose members take moves.
    • pub const fn new(shape: NavShape) -> Roving. A group of shape with Home and End, no wrap, no paging and no letters.
    • pub const fn wrap(mut self, on: bool) -> Self. Whether moves wrap.
    • pub const fn home_end(mut self, on: bool) -> Self. Whether Home and End move to the ends.
    • pub const fn page(mut self, rows: Option<usize>) -> Self. Rows a Page key covers.
    • pub const fn letters(mut self, letters: Letters) -> Self. Whether letters pick entries.
    • pub const fn arrows(mut self, arrows: Arrows) -> Self. The arrows the group takes.
    • pub const fn first_column(mut self, column: usize) -> Self. The column of the first member of a wrapped grid with column blank cells before it: Up and Down keep the
    • pub const fn hands_back(mut self) -> Self. A move the group cannot make reaches the owning component, which may page or change what the group shows.
    • pub const fn keeps_lead_moves(mut self) -> Self. Left and Right with the lead modifier reach the focused member.
    • pub const fn no_lead(mut self, on: bool) -> Self. Whether the focused member is no lead: the next move starts at an end, as from a group with no lead.
    • pub const fn state(&self, lead: Option<usize>) -> NavState. The state a step over this group starts from, at lead, or from no lead when the group has none.
    • pub const fn takes(&self, mv: NavMove, mods: MoveMods) -> bool. Whether the group handles mv with mods: Page moves only with a page size and without lead (on a document
  • craft_behavior::RowAt: re-export of craft_behavior::selection::RowAt.
  • craft_behavior::RulerUnits: pub struct RulerUnits { pub per_doc: f64, pub ticks: Ticks }. The ruler unit of one document axis: its size and its ticks. Rulers label their ticks with it; guides use it for
    • pub const fn new(per_doc: f64, ticks: Ticks) -> Self. Ruler units of per_doc per document unit, spaced by ticks.
    • pub const fn pixels() -> Self. Whole document pixels.
    • pub fn step(&self, zoom: f64, step_min: f32) -> (f64, u32). The labelled step in ruler units and its subdivisions when one document unit is zoom screen points along
    • pub fn snap_to_tick(&self, position: f64, zero: f64, zoom: f64, step_min: f32) -> f64. position (document units) moved to the nearest minor tick of the ruler counting from zero, at zoom
    • pub fn distance(&self, position: f64, zero: f64) -> f64. The distance of position (document units) from zero, in ruler units.
    • pub fn label_decimals(&self, step: f64) -> usize. The decimals a ruler writes a tick of labelled step step with. Whole ticks are whole numbers; a step of at
    • pub fn label_value(&self, value: f64, step: f64) -> f64. The number a ruler prints at the tick value (ruler units from the zero point) for a labelled step step:
  • craft_behavior::SHEET_ZOOM: re-export of craft_behavior::item_layout::SHEET_ZOOM.
  • craft_behavior::ScopeKind: re-export of craft_behavior::focus::ScopeKind.
  • craft_behavior::ScrollPos: re-export of craft_behavior::scroll::ScrollPos.
  • craft_behavior::ScrollSpan: re-export of craft_behavior::scroll::ScrollSpan.
  • craft_behavior::Selection: re-export of craft_behavior::selection::Selection.
  • craft_behavior::SelectionChange: re-export of craft_behavior::selection::SelectionChange.
  • craft_behavior::SelectionModel: re-export of craft_behavior::selection::SelectionModel.
  • craft_behavior::Sense: re-export of craft_behavior::sense::Sense.
  • craft_behavior::Shape: re-export of craft_behavior::hit::Shape.
  • craft_behavior::SheetLayout: re-export of craft_behavior::item_layout::SheetLayout.
  • craft_behavior::SizeHint: re-export of craft_behavior::item_source::SizeHint.
  • craft_behavior::SizeTween: re-export of craft_behavior::layout_memory::SizeTween.
  • craft_behavior::SpanLayout: re-export of craft_behavior::item_layout::SpanLayout.
  • craft_behavior::TextPos: re-export of craft_behavior::intent::TextPos.
  • craft_behavior::Ticks: pub enum Ticks { Decimal { whole: bool }, Custom(fn(f64) -> (f64, u32)) }. How a ruler divides its unit at a zoom.
    • pub const fn decimal(whole: bool) -> Self. PhotoCraft's decimal steps; whole keeps the step a whole number of units without 2.5.
  • craft_behavior::TileLayout: re-export of craft_behavior::item_layout::TileLayout.
  • craft_behavior::TypeAhead: pub struct TypeAhead. Typed letters of the last second as one prefix.
    • pub const fn new() -> Self. An empty buffer.
    • pub fn push(&mut self, letter: char, now: f64) -> &str. Adds letter typed at now seconds and returns the prefix.
    • pub fn pick<'a>(prefix: &str, from: Option<usize>, len: usize, label: impl Fn(usize) -> std::borrow::Cow<'a, str>) -> Option<usize>. The entry a prefix picks: the first match from the position after from (from from itself when the
  • craft_behavior::Typed: re-export of craft_behavior::typing::Typed.
  • craft_behavior::TypingRun: re-export of craft_behavior::typing::TypingRun.
  • craft_behavior::Validity: re-export of craft_behavior::value::Validity.
  • craft_behavior::Value: re-export of craft_behavior::value::Value.
  • craft_behavior::ValueDrag: re-export of craft_behavior::value_drag::ValueDrag.
  • craft_behavior::ViewHistory: pub struct ViewHistory<K>. The places a window jumped between, oldest first, with the one it shows now. The app records
    • pub const LIMIT: usize. Entries kept; the oldest go first.
    • pub fn leave(&mut self, place: ViewPlace<K>). The view is about to jump away from place: its entry keeps the centre and zoom the
    • pub fn visit(&mut self, place: ViewPlace<K>). The view jumped to place. Visiting after Go Back drops the Go Forward entries; visiting
    • pub fn go(&mut self, step: isize, exists: impl Fn(&K) -> bool) -> Option<ViewPlace<K>>. Go Back or Go Forward: the place to show, skipping places that no longer exist. Going
  • craft_behavior::ViewPlace: pub struct ViewPlace<K> { pub key: K, pub center: Point, pub zoom: f64 }. Where a view stood: what it showed (key: a page, an artboard, a document) and the view's
    • pub const fn new(key: K, center: Point, zoom: f64) -> Self. The view of key centred on center at zoom.
  • craft_behavior::Wheel: re-export of craft_behavior::wheel::Wheel.
  • craft_behavior::WheelNotch: re-export of craft_behavior::wheel::WheelNotch.
  • craft_behavior::WheelPhase: re-export of craft_behavior::wheel::WheelPhase.
  • craft_behavior::WheelRoom: re-export of craft_behavior::wheel::WheelRoom.
  • craft_behavior::WheelTaker: re-export of craft_behavior::wheel::WheelTaker.
  • craft_behavior::WheelUnit: re-export of craft_behavior::wheel::WheelUnit.
  • craft_behavior::Winner: re-export of craft_behavior::hit::Winner.
  • craft_behavior::ZoomLadder: re-export of craft_behavior::canvas::zoom::ZoomLadder.
  • craft_behavior::count_clicks: re-export of craft_behavior::press::count_clicks.
  • craft_behavior::decimals_for_step: re-export of craft_behavior::codec::decimals_for_step.
  • craft_behavior::is_checkable: re-export of craft_behavior::role_rule::is_checkable.
  • craft_behavior::is_selectable: re-export of craft_behavior::role_rule::is_selectable.
  • craft_behavior::keyed: re-export of craft_behavior::item_source::keyed.
  • craft_behavior::kurbo: re-export of craft_behavior::kurbo (defined outside these crates).
  • craft_behavior::lead_step: pub const fn lead_step(mv: NavMove, mods: MoveMods) -> Option<NavMove>. The step Left or Right with the lead modifier makes, physical as the arrows are: Ctrl+Left and Ctrl+Right (Back
  • craft_behavior::pick_instance: re-export of craft_behavior::command::pick_instance.
  • craft_behavior::resize_cursor: pub fn resize_cursor(view: &CanvasView, doc_dir: Vec2) -> CursorIcon. The resize arrow for moving along document direction doc_dir, as view shows it (its
  • craft_behavior::resolve: re-export of craft_behavior::hit::resolve.
  • craft_behavior::resolve_columns: re-export of craft_behavior::grid::resolve_columns.
  • craft_behavior::resolve_flags: re-export of craft_behavior::command::resolve_flags.
  • craft_behavior::resolve_mapped: re-export of craft_behavior::hit::resolve_mapped.
  • craft_behavior::role_violations: re-export of craft_behavior::role_rule::role_violations.
  • craft_behavior::wheel_step: pub fn wheel_step(steps: &ValueSteps, axes: ValueAxes, wheel: &Wheel, rtl: bool) -> StepResult. Maps a wheel event to the new value of a single-value control: one notch per event, up for positive scroll.
  • craft_behavior::wrap_value: re-export of craft_behavior::value_drag::wrap_value.

craft_behavior::anchor

The nine points of a box, shared by the transform box rules and the reference point picker.

  • craft_behavior::anchor::Anchor9: pub enum Anchor9 { TopLeft, Top, TopRight, Left, Centre, Right, BottomLeft, Bottom, BottomRight }. The nine points of a box: its corners, edge midpoints and centre, row by row from the top left.
    • pub const ALL: [Anchor9; 9]. Every point, row by row from the top left.
    • pub fn uv(self) -> (f64, f64). Where the point sits in the box: 0 to 1 across from the left edge and down from the top.
    • pub fn cell(self) -> (usize, usize). The point's column and row in the 3 by 3 grid, counted from the top left.

craft_behavior::arrangement

Arrangement: a custom placement for a body, in logical coordinates.

  • craft_behavior::arrangement::Arrangement: pub trait Arrangement. A placement of keyed children measured by the caller. Logical: x runs from the start edge of room, so
    • fn place(&self, room: Rect, sizes: &[Vec2], out: &mut Vec<Rect>) -> Vec2. Fills out with one rect per entry of sizes, in order, inside room; returns the size the placement
    • fn mirrors(&self) -> bool. False for a placement that must not mirror (a free-position board).

craft_behavior::canvas

The transform a canvas body is shown through, and the canvas view with its zoom rules, history and ruler units.

  • craft_behavior::canvas::CanvasTransform: pub struct CanvasTransform { pub scale: f32, pub offset: Vec2 }. A canvas body's mapping from canvas coordinates to its layer: screen = canvas * scale + offset.
    • pub const fn new(scale: f32, offset: Vec2) -> Self. The transform with scale layer points per canvas unit and the canvas origin at offset.
    • pub fn to_layer(&self, canvas: Pos2) -> Pos2. The position in the layer of a canvas point.
  • craft_behavior::canvas::CanvasView: pub struct CanvasView { pub rect: ScreenRect, pub center: Point, pub zoom: f64, pub rotation: f64, pub flip_x: bool, pub aspect: f64 }. How a canvas shows its document: where, how large, turned and mirrored how. Apps convert their
    • pub fn new(rect: ScreenRect, center: Point, zoom: f64) -> Self. An upright, unmirrored, square-pixel view of rect showing center at zoom.
    • pub const fn rotation(mut self, degrees: f64) -> Self. The same view turned degrees clockwise.
    • pub const fn flip_x(mut self, flip: bool) -> Self. The same view mirrored left-right (or not).
    • pub const fn aspect(mut self, aspect: f64) -> Self. The same view with a document unit aspect times as wide as it is tall.
    • pub fn points_per_unit(device_zoom: f64, pixels_per_point: f32) -> f64. zoom for a view that shows device_zoom device pixels per document unit at
    • pub fn affine(&self) -> Affine. Document to screen points.
    • pub fn to_screen(&self, p: Point) -> Pos2. Where the view draws document point p.
    • pub fn to_doc(&self, p: Pos2) -> Point. The document point under screen position p.
    • pub fn map_vec(&self, v: Vec2) -> ScreenVec. A document vector as the view draws it: stretched, turned, zoomed and mirrored.
    • pub fn unmap_vec(&self, v: ScreenVec) -> Vec2. The document vector a screen vector shows: the inverse of map_vec.
    • pub fn zoom_x(&self) -> f64. Screen points per document unit along the document's x axis: zoom × aspect.
    • pub fn quad(&self, r: Rect) -> [Pos2; 4]. The screen corners of document rect r, in order round it: (x0, y0), (x1, y0), (x1, y1),
    • pub fn visible(&self) -> Rect. The document bounds of the screen rect: every document point the view can show.
    • pub fn doc_len(&self, points: f32) -> f64. A screen distance in document units along the document's y axis (divide by
    • pub fn layer_transform(&self) -> Option<CanvasTransform>. The transform a canvas body is shown through when this view only scales and moves the document: unturned,
    • pub fn axis_aligned(&self) -> bool. Whether the rotation is a multiple of 90°, so document axes are screen axes.
    • pub fn level(&self, zero: Point) -> CanvasView. The view without its rotation, moved so it draws zero where this view does: the same
  • craft_behavior::canvas::RulerUnits: pub struct RulerUnits { pub per_doc: f64, pub ticks: Ticks }. The ruler unit of one document axis: its size and its ticks. Rulers label their ticks with it; guides use it for
    • pub const fn new(per_doc: f64, ticks: Ticks) -> Self. Ruler units of per_doc per document unit, spaced by ticks.
    • pub const fn pixels() -> Self. Whole document pixels.
    • pub fn step(&self, zoom: f64, step_min: f32) -> (f64, u32). The labelled step in ruler units and its subdivisions when one document unit is zoom screen points along
    • pub fn snap_to_tick(&self, position: f64, zero: f64, zoom: f64, step_min: f32) -> f64. position (document units) moved to the nearest minor tick of the ruler counting from zero, at zoom
    • pub fn distance(&self, position: f64, zero: f64) -> f64. The distance of position (document units) from zero, in ruler units.
    • pub fn label_decimals(&self, step: f64) -> usize. The decimals a ruler writes a tick of labelled step step with. Whole ticks are whole numbers; a step of at
    • pub fn label_value(&self, value: f64, step: f64) -> f64. The number a ruler prints at the tick value (ruler units from the zero point) for a labelled step step:
  • craft_behavior::canvas::Ticks: pub enum Ticks { Decimal { whole: bool }, Custom(fn(f64) -> (f64, u32)) }. How a ruler divides its unit at a zoom.
    • pub const fn decimal(whole: bool) -> Self. PhotoCraft's decimal steps; whole keeps the step a whole number of units without 2.5.
  • craft_behavior::canvas::ViewHistory: pub struct ViewHistory<K>. The places a window jumped between, oldest first, with the one it shows now. The app records
    • pub const LIMIT: usize. Entries kept; the oldest go first.
    • pub fn leave(&mut self, place: ViewPlace<K>). The view is about to jump away from place: its entry keeps the centre and zoom the
    • pub fn visit(&mut self, place: ViewPlace<K>). The view jumped to place. Visiting after Go Back drops the Go Forward entries; visiting
    • pub fn go(&mut self, step: isize, exists: impl Fn(&K) -> bool) -> Option<ViewPlace<K>>. Go Back or Go Forward: the place to show, skipping places that no longer exist. Going
  • craft_behavior::canvas::ViewPlace: pub struct ViewPlace<K> { pub key: K, pub center: Point, pub zoom: f64 }. Where a view stood: what it showed (key: a page, an artboard, a document) and the view's
    • pub const fn new(key: K, center: Point, zoom: f64) -> Self. The view of key centred on center at zoom.
  • craft_behavior::canvas::ZoomLadder: re-export of craft_behavior::canvas::zoom::ZoomLadder.
  • craft_behavior::canvas::resize_cursor: pub fn resize_cursor(view: &CanvasView, doc_dir: Vec2) -> CursorIcon. The resize arrow for moving along document direction doc_dir, as view shows it (its

craft_behavior::canvas::zoom

Zoom rules as pure functions on a [CanvasView]: Photoshop's zoom range and Zoom In / Zoom Out ladder, Fit on

  • craft_behavior::canvas::zoom::ZoomLadder: pub struct ZoomLadder. Photoshop's zoom range and the Zoom In / Zoom Out ladder, measured on Photoshop 25.4: up to
    • pub const MAX: f64. 12800 %.
    • pub const STEPS: [f64; 33]. Zoom In / Zoom Out rungs (1 = 100 %).
    • pub fn min(size: Size) -> f64. The lowest zoom for a document of size units: its shorter side 2 device pixels. An empty
    • pub fn clamp(zoom: f64, size: Size) -> f64. zoom within the range for a document of size; a zoom that is not a finite number
    • pub fn step(zoom: f64, dir: i32, size: Size) -> f64. Zoom In (dir > 0) or Zoom Out (dir < 0) from zoom: the next rung past it (a zoom
    • pub fn step_in_range(zoom: f64, dir: i32, range: RangeInclusive<f64>) -> f64. step within an explicit range (a navigator or a zoom field with bounds of
    • pub fn percent_range(zoom: f64, size: Size) -> RangeInclusive<f64>. A zoom field's range in percent: the document's range widened to include zoom itself.
  • craft_behavior::canvas::zoom::about: pub fn about(view: &mut CanvasView, screen: Pos2, device_zoom: f64, center_on_point: bool, pixels_per_point: f32). Set the zoom to device_zoom (clamped by the caller) keeping the document point under
  • craft_behavior::canvas::zoom::anchor: pub fn anchor(view: &mut CanvasView, screen: Pos2, doc: Point, device_zoom: f64, pixels_per_point: f32). Set the zoom to device_zoom with the document point doc shown at screen.
  • craft_behavior::canvas::zoom::device: pub fn device(view: &CanvasView, pixels_per_point: f32) -> f64. view.zoom as device zoom (1 = 100 %) at pixels_per_point.
  • craft_behavior::canvas::zoom::fill: pub fn fill(view: &mut CanvasView, size: Size, pixels_per_point: f32). Fill Screen: centre the document and zoom until it covers view.rect; one axis may extend
  • craft_behavior::canvas::zoom::fit: pub fn fit(view: &mut CanvasView, size: Size, pixels_per_point: f32, margin: f64). Fit on Screen: centre the document and zoom so all of it shows inside view.rect less margin points on
  • craft_behavior::canvas::zoom::fit_up_to: pub fn fit_up_to(view: &mut CanvasView, size: Size, pixels_per_point: f32, max_device: f64, margin: f64). [fit] with the device zoom allowed up to max_device (1 = 100 %) instead of 100 %: a small document is
  • craft_behavior::canvas::zoom::step: pub fn step(view: &mut CanvasView, dir: i32, size: Size, pixels_per_point: f32) -> bool. View › Zoom In (dir > 0) or Zoom Out (dir < 0): the next ladder rung
  • craft_behavior::canvas::zoom::wheel_anchor: pub fn wheel_anchor(view: &CanvasView, screen: Pos2, size: Size) -> Pos2. Where a wheel or pinch zoom anchors for a pointer at screen: the pointer over the document,
  • craft_behavior::canvas::zoom::with_device: pub fn with_device(view: &CanvasView, device: f64, size: Size, pixels_per_point: f32) -> CanvasView. view at device zoom (1 = 100 %), clamped to the zoom range of a document of size, with its centre kept.

craft_behavior::codec

Codec: how a text part turns a value into text and text into a value (18.2), with the library codecs of this

  • craft_behavior::codec::Caret: pub enum Caret { All, End }. Where the caret goes when the part takes focus.
  • craft_behavior::codec::Codec: pub trait Codec. A value's text form.
    • type Value. The value the text stands for.
    • const DRAFTS_ARE_VALUES: bool. Every draft is a value (plain text): a draft applies as typed and never rejects.
    • fn format(&self, v: &Self::Value) -> String. The text of v.
    • fn parse(&self, text: &str, start: &Self::Value) -> Result<Self::Value, NotAValue>. The value of text; start is the value when editing began, for relative input.
    • fn parse_tagged(&self, text: &str, start: &Self::Value) -> Result<(Self::Value, Option<u32>), NotAValue>. The value of text and the tag of the unit it named (Reader::read_tagged); the default names none.
    • fn applies_as_typed(&self, _text: &str) -> bool. Whether text applies as soon as it is typed rather than on commit.
    • fn filter(&self, _c: char) -> bool. Whether the codec takes c as typed.
    • fn normalise(&self, _text: &str, v: &Self::Value) -> String. The text the field shows after committing v, which was parsed from text.
    • fn caret_on_focus(&self, _text: &str) -> Caret. Where the caret goes when the part takes focus with this text.
    • fn sample(&self, current: &Self::Value) -> Cow<'_, str>. The widest typical text, for the field's ideal width. Codecs with bounded text only; PlainText returns
  • craft_behavior::codec::NotAValue: pub struct NotAValue. The text is not a value of the codec's type.
  • craft_behavior::codec::NumberCodec: pub struct NumberCodec. An optional number: empty text is None; anything else reads through a [Reader].
    • pub fn new(reader: Reader, decimals: usize) -> Self. A codec reading with reader and writing at most decimals decimal places.
    • pub fn fixed(mut self) -> Self. The same codec writing every decimal place, trailing zeros included ("1.00"), as a field of a quantity shown
    • pub fn or_parse(mut self, parse: impl Fn(&str) -> Option<f64> + Send + Sync + 'static) -> Self. The same codec with parse as a second reader: it runs when the reader rejects the text, so words of the
    • pub fn widest(&self, range: &RangeInclusive<f64>) -> String. The widest text the codec writes for a number in range: the longer of its two ends, with every decimal
    • pub fn decimals(&self) -> usize. The most decimal places the codec writes.
    • pub fn reader(&self) -> &Reader. The reader the codec parses with.
  • craft_behavior::codec::PlainText: pub struct PlainText. Plain text: every draft is a value.
  • craft_behavior::codec::decimals_for_step: pub fn decimals_for_step(step: f64) -> usize. The decimal places a step needs to be written exactly: 2 for 0.25, 3 for 0.001, 0 for a whole step. A step with

craft_behavior::columns

Column keys, widths and the sections a grid layout reports.

  • craft_behavior::columns::ColumnKey: pub struct ColumnKey. The key of a column; stable across reordering and resizing. It serializes as its name, or as its position for a
    • pub const fn new(key: &'static str) -> Self. A key named key.
    • pub const fn index(column: u32) -> Self. The key of the column at column in a sheet whose columns are numbered rather than named
    • pub fn as_str(&self) -> Option<&str>. The name of a key made by [ColumnKey::new]; None for a numbered key.
    • pub fn position(&self) -> Option<u32>. The position a key made by [ColumnKey::index] holds; None for a named key.
  • craft_behavior::columns::ColumnWidth: pub enum ColumnWidth { Content, Fixed(f32), Controls(f32), Fill { weight: f32 } }. How wide a column is.
    • pub fn in_unit(self, unit: f32) -> Self. The width with Controls(n) turned into Fixed(n * unit).
    • pub const fn fill(weight: f32) -> Self. A share of the remaining width with weight among the Fill columns.
  • craft_behavior::columns::GridSection: pub struct GridSection { pub rect: Rect, pub columns: Range<u32>, pub edges: Vec<f32> }. One horizontal section of a grid layout: its rect, the columns it shows and their edges.
    • pub fn new(rect: Rect, columns: Range<u32>, edges: Vec<f32>) -> Self. A section at rect showing columns with their edges.
  • craft_behavior::columns::GridView: pub struct GridView { pub sections: SmallVec<[GridSection; 4]> }. The sections of a sheet layout, one per frozen area.
    • pub fn new(sections: impl IntoIterator<Item = GridSection>) -> Self. A view of sections, in reading order.

craft_behavior::command

The pure rules of command routing (spec 11.3): which state a command resolves to, and which live instance

  • craft_behavior::command::CommandFlags: pub struct CommandFlags { pub enabled: bool, pub checked: Option<bool> }. A command's enabled and checked state.
    • pub const fn new(enabled: bool, checked: Option<bool>) -> Self. Flags with the given enabled and checked state.
    • pub const DEFAULT: CommandFlags. A command nobody published a state for: enabled, with no checked state.
  • craft_behavior::command::pick_instance: pub fn pick_instance<I: Copy + PartialEq>(live: &[I], focused: &[I], last_focused: &[I]) -> Option<I>. The instance a non-component source delivers to, out of the live instances of the command's scope in
  • craft_behavior::command::resolve_flags: pub const fn resolve_flags(this_frame: Option<CommandFlags>, last_frame: Option<CommandFlags>) -> CommandFlags. This frame's state, else last frame's, else the default.

craft_behavior::cursor

Cursor requests as plain data and the rule that picks the winner (8.5).

  • craft_behavior::cursor::Cursor: pub enum Cursor { System(CursorIcon), Painted(PaintedCursor) }. What a cursor request names.
  • craft_behavior::cursor::CursorBadge: pub enum CursorBadge { Add, Subtract, Intersect, Copy, NotAllowed, Scissors, Close }. A mark beside a painted cursor.
  • craft_behavior::cursor::CursorIcon: pub enum CursorIcon { Default, None, ContextMenu, Help, PointingHand, Progress, Wait, Cell, Crosshair, Text, VerticalText, Alias, Copy, Move, NoDrop, NotAllowed, Grab, Grabbing, AllScroll, ResizeHorizontal, ResizeNeSw, ResizeNwSe, ResizeVertical, ResizeColumn, ResizeEast, ResizeSouthEast, ResizeSouth, ResizeSouthWest, ResizeWest, ResizeNorthWest, ResizeNorth, ResizeNorthEast, ZoomIn, ZoomOut }. A system cursor: craft-behavior's copy of egui's set, converted by runtime::egui::output.
  • craft_behavior::cursor::CursorPriority: pub enum CursorPriority { Default, Tool, Hover, Part, DropTarget, Drag }. Who asks, in ascending order of precedence.
  • craft_behavior::cursor::IconId: pub struct IconId. An icon's egui-free key (5.2), so plain data such as [PaintedCursor::Tool] names icons without egui.
    • pub const fn new(name: &'static str) -> Self. The icon named name.
    • pub fn name(&self) -> &str. The name.
  • craft_behavior::cursor::PaintedCursor: pub enum PaintedCursor { Crosshair, Circle { radius: f32, centre: bool, badge: Option<CursorBadge> }, Outline { rings: Vec<Vec<Pos2>>, centre: bool, badge: Option<CursorBadge> }, Hand, Zoom { out: bool }, Tool { icon: IconId, hotspot: Vec2, badge: Option<CursorBadge> }, Badged { base: CursorIcon, badge: CursorBadge }, Turn { toward: Vec2 }, Distort { dir: Vec2 }, Skew { dir: Vec2 }, Hidden }. A cursor the overlay host paints. Geometry is in screen points around the pointer (a tool scales its brush
    • pub const CENTRE_ARM: f32. The arm of the centre mark of a circle or an outline, in points.
    • pub const fn circle(radius: f32) -> Self. A circle of radius points, with no centre mark and no badge.
    • pub fn outline(rings: Vec<Vec<Pos2>>) -> Self. App shapes as closed rings, with no centre mark and no badge.
    • pub fn marked(self, centre: bool, badge: Option<CursorBadge>) -> Self. A circle or an outline with the centre mark when centre and badge centred on the pointer; any other cursor
    • pub const fn zoom(out: bool) -> Self. A magnifier, zooming out when out.
    • pub const fn tool(icon: IconId, hotspot: Vec2, badge: Option<CursorBadge>) -> Self. A tool's icon with its hotspot and an optional badge.
    • pub const fn turn(toward: Vec2) -> Self. The rotate pointer bent toward screen direction toward.
    • pub const fn distort(dir: Vec2) -> Self. The free-distort pointer along screen direction dir.
    • pub const fn skew(dir: Vec2) -> Self. The skew pointer along screen direction dir.
    • pub const fn badged(base: CursorIcon, badge: CursorBadge) -> Self. A system cursor with a mark.
  • craft_behavior::cursor::pick: pub fn pick(requests: &[(Cursor, CursorPriority)]) -> Option<&Cursor>. The winning request: the highest priority, the later request on a tie.

craft_behavior::digit_keys

[DigitKeys]: Photoshop's number keys for a tool's opacity. 1 sets 10 % … 9 sets 90 %, 0 sets 100 %; two digits

  • craft_behavior::digit_keys::DigitEntry: pub struct DigitEntry { pub percent: f64, pub second: bool }. What a number key sets: the percentage and which value.
  • craft_behavior::digit_keys::DigitKeys: pub struct DigitKeys. The number keys' state between presses: the first digit of a pair. The app keeps one.
    • pub const TWO_DIGITS: f64. Seconds within which a second digit makes an exact value.
    • pub fn press(&mut self, digit: u8, second: bool, now: f64) -> Option<DigitEntry>. One press of digit (0..=9) for the second value or not, at now seconds: 10 × the digit (0: 100) on its own,

craft_behavior::divider

The resize of a row of segments separated by dividers.

  • craft_behavior::divider::Give: pub enum Give { Neighbours, Pair }. Which segments give way when a divider moves.
  • craft_behavior::divider::Segment: pub struct Segment { pub extent: f32, pub min: f32, pub max: f32 }. One segment of a row: its extent along the row and its limits.
    • pub const fn new(extent: f32, min: f32, max: f32) -> Self. A segment of extent that stays within min and max.
    • pub const fn unbounded(extent: f32, min: f32) -> Self. A segment of extent with no upper limit.
  • craft_behavior::divider::resize: pub fn resize(row: &[Segment], index: usize, target: f32, give: Give) -> Vec<f32>. The extents of row after the divider after row[index] moves to target, a distance from the row's start, clamped
  • craft_behavior::divider::travel: pub fn travel(row: &[Segment], index: usize, give: Give) -> (f32, f32). How far the divider after row[index] can move: (lo, hi), with lo <= 0 <= hi. Toward the start the segments

craft_behavior::doc_key

A stable, crate-prefixed semantic key for presence, automation, undo names and programmatic focus.

  • craft_behavior::doc_key::DocKey: pub struct DocKey. A document key such as "craft-ui.find-field".
    • pub const fn new(name: &'static str) -> DocKey. A key crate-prefix.name; evaluated in a const context it rejects a malformed name at compile time. The
    • pub const fn name(self) -> &'static str. The name the key was declared with.

craft_behavior::dock

The dock model: the tree of splits over panel frames, the side of a group a drop lands on (20.6), and the rules

  • craft_behavior::dock::DockSide: pub enum DockSide { Start, End, Top, Bottom, Center }. The side of a group a dropped panel docks on, in reading order: Start is the left half in a left-to-right
    • pub const fn axis(self) -> Option<Axis>. The axis the side splits along; None for Center.
    • pub fn area(self, group: Rect) -> Rect. The part of group a panel docked on this side takes: the half on that side, or the whole group.
  • craft_behavior::dock::Action: pub enum Action<P> { Move { panel: P, anchor: P, placement: DockPlacement<P> }, Float { panel: P, rect: Rect }, Close { panel: P }, Activate { panel: P }, Open { panel: P, anchor: Option<P> }, OpenAt { panel: P, anchor: P, placement: DockPlacement<P> }, MoveFloating { panel: P, rect: Rect }, ResizeSplit { path: Vec<bool>, size: SplitSize }, ResizeWindowSplit { panel: P, path: Vec<bool>, size: SplitSize }, SetStackOpen { panel: P, open: bool }, ResizeStack { panel: P, height: Option<f32> }, MoveGroup { panel: P, to: Target<P> }, StepGroup { panel: P, up: bool }, MoveColumn { panel: P, to: Target<P> }, MoveWindow { panel: P, to: Target<P> }, CloseGroup { panel: P }, CloseWindow { panel: P }, CloseOthers { panel: P }, SetMinimized { panel: P, minimized: bool }, SetIconic { panel: P, iconic: bool }, ResizeColumn { panel: P, width: f32 }, ResizeGroup { panel: P, height: Option<f32> }, ResizeFlyoutWidth { panel: P, width: Option<f32> }, ResizeIconic { panel: P, width: Option<f32> }, SetNative { panel: P, placement: Option<Placement> }, MovePanel { panel: P, to: Target<P> } }. Groups, columns and floating windows are named by a panel they contain.
    • pub fn move_beside(panel: P, anchor: P, placement: DockPlacement<P>) -> Self. Builds [Action::Move].
    • pub fn float(panel: P, rect: Rect) -> Self. Builds [Action::Float].
    • pub fn close(panel: P) -> Self. Builds [Action::Close].
    • pub fn activate(panel: P) -> Self. Builds [Action::Activate].
    • pub fn open(panel: P, anchor: Option<P>) -> Self. Builds [Action::Open].
    • pub fn open_at(panel: P, anchor: P, placement: DockPlacement<P>) -> Self. Builds [Action::OpenAt].
    • pub fn move_floating(panel: P, rect: Rect) -> Self. Builds [Action::MoveFloating].
    • pub fn resize_split(path: Vec<bool>, size: SplitSize) -> Self. Builds [Action::ResizeSplit].
    • pub fn resize_window_split(panel: P, path: Vec<bool>, size: SplitSize) -> Self. Builds [Action::ResizeWindowSplit].
    • pub fn set_stack_open(panel: P, open: bool) -> Self. Builds [Action::SetStackOpen].
    • pub fn resize_stack(panel: P, height: Option<f32>) -> Self. Builds [Action::ResizeStack].
    • pub fn move_group(panel: P, to: Target<P>) -> Self. Builds [Action::MoveGroup].
    • pub fn step_group(panel: P, up: bool) -> Self. Builds [Action::StepGroup].
    • pub fn move_column(panel: P, to: Target<P>) -> Self. Builds [Action::MoveColumn].
    • pub fn move_window(panel: P, to: Target<P>) -> Self. Builds [Action::MoveWindow].
    • pub fn close_group(panel: P) -> Self. Builds [Action::CloseGroup].
    • pub fn close_window(panel: P) -> Self. Builds [Action::CloseWindow].
    • pub fn close_others(panel: P) -> Self. Builds [Action::CloseOthers].
    • pub fn set_minimized(panel: P, minimized: bool) -> Self. Builds [Action::SetMinimized].
    • pub fn set_iconic(panel: P, iconic: bool) -> Self. Builds [Action::SetIconic].
    • pub fn resize_column(panel: P, width: f32) -> Self. Builds [Action::ResizeColumn].
    • pub fn resize_group(panel: P, height: Option<f32>) -> Self. Builds [Action::ResizeGroup].
    • pub fn resize_flyout_width(panel: P, width: Option<f32>) -> Self. Builds [Action::ResizeFlyoutWidth].
    • pub fn resize_iconic(panel: P, width: Option<f32>) -> Self. Builds [Action::ResizeIconic].
    • pub fn set_native(panel: P, placement: Option<Placement>) -> Self. Builds [Action::SetNative].
    • pub fn move_panel(panel: P, to: Target<P>) -> Self. Builds [Action::MovePanel].
  • craft_behavior::dock::Arrangement: pub enum Arrangement { TileAllVertically, TileAllHorizontally, TwoUpVertical, TwoUpHorizontal, ThreeUpVertical, ThreeUpHorizontal, ThreeUpStacked, FourUp, SixUp, ConsolidateAllToTabs, Cascade, Tile, FloatInWindow, FloatAllInWindows, NewWindowForDocument, MatchZoom, MatchLocation, MatchRotation, MatchAll }. One Window › Arrange entry. The n-up entries split the document area into that many
    • pub fn group_count(self, documents: usize) -> Option<usize>. How many document groups an n-up or tile arrangement wants, None for the window and
    • pub fn enabled(self, documents: usize, groups: usize, floating: usize) -> bool. Whether the entry is enabled with documents open and floating floating windows:
  • craft_behavior::dock::Column: pub struct Column<P> { pub groups: Vec<Group<P>>, pub width: Option<f32>, pub iconic: bool, pub iconic_width: Option<f32> }. One column of a dock: groups from top to bottom.
    • pub fn new(groups: Vec<Group<P>>) -> Self. A column of groups, expanded at the theme's column width until the user resizes it.
    • pub fn with_width(mut self, width: f32) -> Self. The column resized to width points.
  • craft_behavior::dock::ColumnLocation: pub struct ColumnLocation { pub side: DockEdge, pub width: Option<f32>, pub iconic: bool, pub iconic_width: Option<f32> }. The column a closed panel's group was in.
    • pub const fn new(side: DockEdge, width: Option<f32>, iconic: bool, iconic_width: Option<f32>) -> Self. A column location on side, width points wide when expanded (the theme's column width for None).
  • craft_behavior::dock::DockEdge: pub enum DockEdge { Start, End }. The window edge a [Node::Dock] sits on, in reading order so right-to-left interfaces
  • craft_behavior::dock::DockError: pub enum DockError { LimitExceeded, DuplicatePanel, MissingPanel, MissingTarget, InvalidSelection, InvalidGeometry, InvalidPlacement, NotAllowed, UnsupportedVersion }. Why a layout edit or load was refused. The layout is unchanged when an edit fails.
  • craft_behavior::dock::DockPlacement: pub enum DockPlacement<P> { Tab { before: Option<P> }, Split(DockSide), SplitSized { zone: DockSide, size: SplitSize, outer: SplitSize }, Group { below: bool, height: Option<f32> }, Column { after: bool }, Edge(DockSide) }. Where a moved panel goes relative to an anchor panel.
    • pub fn tab(before: Option<P>) -> Self. Builds [DockPlacement::Tab].
    • pub fn group(below: bool, height: Option<f32>) -> Self. Builds [DockPlacement::Group].
    • pub fn column(after: bool) -> Self. Builds [DockPlacement::Column].
    • pub fn allowed_by(&self, anchor: Permissions, floating: bool) -> bool. Whether the anchor's permissions take this placement: tabs need accepts_tabs, side
  • craft_behavior::dock::DocumentGroup: pub struct DocumentGroup<D> { pub id: u64, pub documents: Vec<D>, pub shown: Option<D> }. A document group: the documents in one tab strip, one of them shown.
    • pub fn new(id: u64, documents: Vec<D>) -> Self. A group with id id holding documents, none shown.
  • craft_behavior::dock::DocumentWindows: pub struct DocumentWindows<D> { pub docked: Vec<DocumentGroup<D>>, pub floating: Vec<(DocumentGroup<D>, Rect)> }. The document windows of the app: the tabbed groups in the canvas area and the floating ones.
    • pub fn float(&mut self, document: &D, rect: Rect) -> Option<u64>. Float document from its group into a new window at rect. A document alone in a
    • pub fn float_all(&mut self, area: Rect, size: Vec2, step: f32). Every document into its own floating window, cascaded from area's top left. A floating
    • pub fn consolidate(&mut self, active: Option<&D>). Every document back into one docked group, the active one shown. A document in several
    • pub fn split_into(&mut self, n: usize). Split the docked documents into n groups for an n-up arrangement, in order. The first
    • pub fn new_window_for(&mut self, document: &D, rect: Rect) -> u64. A second view of document: the same document id in a new window; the app keeps one
    • pub fn to_actions<P: Clone + Eq + Hash>(&self, layout: &Layout<P>, panel_of: impl Fn(u64) -> P) -> Vec<Action<P>>. The dock actions that put self into layout, for the dock to draw the windows. The
  • craft_behavior::dock::Floating: pub struct Floating<P> { pub id: u64, pub root: Node<P>, pub rect: Rect, pub native: Option<Placement>, pub minimized: bool }. A floating window: a tree of groups like the docked layout's, without docks.
    • pub fn new(root: Node<P>, rect: Rect) -> Self. A window holding root. Each call makes a new window, with a fresh [Self::id]: build
    • pub fn single(panels: Vec<P>, active: usize, rect: Rect) -> Self. A window with one group. Each call makes a new window, as [Self::new] does.
    • pub fn with_id(mut self, id: u64) -> Self. The window with id, for a layout the app builds in code, such as a default layout:
    • pub fn panels(&self) -> impl Iterator<Item = &P>. Every panel in the window, in tree order.
    • pub fn stack(groups: Vec<Group<P>>, rect: Rect) -> Option<Self>. Groups stacked top to bottom, as a v1 layout stored them: each group over a vertical
    • pub fn groups(&self) -> Vec<Group<P>> where P: Clone,. The window's groups, first to last.
    • pub fn contains<Q: ?Sized + PartialEq>(&self, panel: &Q) -> bool where P: std::borrow::Borrow<Q>,. True when a group of this window holds panel. Takes any borrowed form of P, such
  • craft_behavior::dock::Group: pub struct Group<P> { pub panels: Vec<P>, pub active: usize, pub minimized: bool, pub height: Option<f32>, pub flyout_width: Option<f32> }. Tabs that move, minimize and size together in a dock column.
    • pub fn new(panels: Vec<P>, active: usize) -> Self. A group of panels with tab active selected, expanded and with no preferred height or flyout width.
    • pub fn active_panel(&self) -> Option<&P>. The selected panel, or None when active is out of range.
  • craft_behavior::dock::GroupLocation: pub struct GroupLocation { pub minimized: bool, pub height: Option<f32>, pub flyout_width: Option<f32>, pub column: Option<ColumnLocation> }. The group a closed panel was in, when that group was in a dock.
    • pub const fn new(minimized: bool, height: Option<f32>, column: Option<ColumnLocation>) -> Self. A group location with the given state and column.
    • pub const fn with_flyout_width(mut self, width: Option<f32>) -> Self. The location with the group's flyout width points wide.
  • craft_behavior::dock::Layout: pub struct Layout<P> { pub root: Option<Node<P>>, pub floating: Vec<Floating<P>> }. The panels of a workspace: a docked tree plus floating windows. Every panel occurs once.
    • pub fn new(root: Option<Node<P>>, floating: Vec<Floating<P>>) -> Self. A layout with the docked tree root and the floating windows floating.
    • pub fn validate(&self) -> Result<(), DockError>. Check depth, allocation bounds, geometry, selection, globally unique panel ownership and
    • pub fn panels(&self) -> Vec<&P>. Iterate identities without recursion. On excessive input returns no more than the limit.
    • pub fn contains(&self, panel: &P) -> bool. Whether the layout holds panel, docked or floating.
    • pub fn can_step_group(&self, panel: &P, up: bool, permissions: impl Fn(&P) -> Permissions) -> bool. Whether [Action::StepGroup] would move panel's group, for enabling a menu item.
    • pub fn location(&self, panel: &P) -> Result<Location<P>, DockError>. Capture a panel's nearest surviving group/split neighbor before hiding it.
    • pub fn panel_state(&self, panel: &P) -> PanelState. Hidden, open behind another tab or in a collapsed container, or showing.
    • pub fn restore(&mut self, panel: P, location: &Location<P>) -> Result<(), DockError>. Restore an absent panel at a captured location. Missing anchors are reported without
    • pub fn open_at_edge(&mut self, panel: P) -> Result<(), DockError>. Open an absent panel as a frame at the outer edge of the docked area, taking most of it:
  • craft_behavior::dock::Location: pub struct Location<P> { pub floating: Option<Rect>, pub anchor: Option<P>, pub placement: DockPlacement<P>, pub size: Option<SplitSize>, pub stack: Option<(bool, Option<f32>)>, pub sibling: Vec<P>, pub group: Option<GroupLocation> }. A closed panel's former placement. Applications may retain this beside visibility flags.
    • pub fn new(anchor: Option<P>, placement: DockPlacement<P>) -> Self. A location relative to anchor by placement, with no recorded sizes or siblings.
  • craft_behavior::dock::MAX_DEPTH: pub const MAX_DEPTH: usize. Limits are checked before cloning or recursively modifying an application layout.
  • craft_behavior::dock::MAX_PANELS: pub const MAX_PANELS: usize. Most panels a layout may hold. Larger layouts fail with DockError::LimitExceeded.
  • craft_behavior::dock::NamedWorkspace: pub struct NamedWorkspace<P> { pub id: String, pub name: String, pub layout: Workspace<P>, pub chrome: WorkspaceChrome, pub keeps_shortcuts: bool, pub keeps_menus: bool }. One named workspace.
    • pub fn new(id: impl Into<String>, name: impl Into<String>, layout: Workspace<P>) -> Self. A workspace named name with the stable id id, showing every bar and keeping no shortcuts or menus.
  • craft_behavior::dock::Node: pub enum Node<P> { Split { axis: Axis, size: SplitSize, first: Box<Node<P>>, second: Box<Node<P>> }, Tabs { panels: Vec<P>, active: usize }, Stack { entries: Vec<StackEntry<P>> }, Dock { side: DockEdge, columns: Vec<Column<P>> } }. A node of a layout tree.
    • pub fn tabs(panels: Vec<P>, active: usize) -> Self. A group of tabs with tab active selected.
    • pub fn split(axis: Axis, size: SplitSize, first: Node<P>, second: Node<P>) -> Self. Two children along axis, sharing the room by size.
    • pub fn stack(entries: Vec<StackEntry<P>>) -> Self. Builds [Node::Stack].
    • pub fn dock(side: DockEdge, columns: Vec<Column<P>>) -> Self. Builds [Node::Dock].
  • craft_behavior::dock::PanelPlace: pub enum PanelPlace { Node(Vec<bool>), Dock { path: Vec<bool>, column: usize, group: usize }, Floating { window: usize, path: Vec<bool> } }. Where a panel is. Paths lead from the root: false is a split's first child, true its second.
    • pub fn tree_path(&self) -> Option<(Option<usize>, &[bool])>. The tree (None for the docked layout, else a floating window) and the path of a
  • craft_behavior::dock::PanelState: pub enum PanelState { Hidden, Open, Front }. What the Window menu shows for a panel. The model does not track the z-order of floating
  • craft_behavior::dock::Permissions: pub struct Permissions { pub movable: bool, pub floatable: bool, pub closable: bool, pub accepts_tabs: bool, pub accepts_splits: bool }. What may happen to a panel. [Layout::apply_with_permissions] enforces these for every
    • pub const ALL: Self. Every right: the panel moves, floats, closes and takes tabs and splits.
    • pub const PROTECTED: Self. A document canvas: it stays docked and open, and takes neither tabs nor side splits.
    • pub const fn movable(mut self, movable: bool) -> Self. These permissions with [Self::movable] set to movable.
    • pub const fn floatable(mut self, floatable: bool) -> Self. These permissions with [Self::floatable] set to floatable.
    • pub const fn closable(mut self, closable: bool) -> Self. These permissions with [Self::closable] set to closable.
    • pub const fn accepts_tabs(mut self, accepts_tabs: bool) -> Self. These permissions with [Self::accepts_tabs] set to accepts_tabs.
    • pub const fn accepts_splits(mut self, accepts_splits: bool) -> Self. These permissions with [Self::accepts_splits] set to accepts_splits.
    • pub fn is_protected(self) -> bool. A canvas: it can neither move, close nor take tabs. accepts_splits and floatable
    • pub fn locked(self) -> Self. Lock Workspace: nothing moves, floats or closes; tab and split drops keep their policy.
  • craft_behavior::dock::SIDE_ZONE_DEPTH_SHARE: pub const SIDE_ZONE_DEPTH_SHARE: f32. The most of a body's smaller side that a [ZoneSize::Depth] zone reaches, so a body always keeps a middle.
  • craft_behavior::dock::SIDE_ZONE_FRACTION: pub const SIDE_ZONE_FRACTION: f32. Share of a body, from each edge, that means "beside" under [ZoneSize::Fraction]: of its width from the start
  • craft_behavior::dock::SplitSize: pub enum SplitSize { Ratio(f32), FixedFirst(f32), FixedSecond(f32) }. A transient sizing request. Applications may adapt their own persisted sizing enum.
  • craft_behavior::dock::StackEntry: pub struct StackEntry<P> { pub panel: P, pub open: bool, pub height: Option<f32> }. One panel of a [Node::Stack] accordion.
    • pub fn new(panel: P) -> Self. An open accordion section for panel with no preferred height.
  • craft_behavior::dock::Target: pub enum Target<P> { At { anchor: P, placement: DockPlacement<P> }, NewDock { side: DockEdge }, Float { rect: Rect } }. Where a group, column or floating window goes.
    • pub fn at(anchor: P, placement: DockPlacement<P>) -> Self. Builds [Target::At].
    • pub fn new_dock(side: DockEdge) -> Self. Builds [Target::NewDock].
    • pub fn float(rect: Rect) -> Self. Builds [Target::Float].
  • craft_behavior::dock::Workspace: pub struct Workspace<P> { pub version: u32, pub layout: Layout<P>, pub hidden: Vec<(P, Location<P>)> }. A saved arrangement of panels: the [Layout] and the closed panels' former places.
    • pub const VERSION: u32. The format version written to files.
    • pub fn revision(&self) -> u64. The revision of this live workspace: it changes with every replace and nothing else.
    • pub fn replace(&mut self, with: Workspace<P>). Replaces the arrangement with with and moves to the next revision.
    • pub fn apply(&mut self, action: Action<P>, locked: bool, permissions: impl Fn(&P) -> Permissions) -> Result<Vec<P>, DockError>. Apply one action. Closed panels record where they go back, so each one can be reopened
    • pub fn apply_all(&mut self, actions: impl IntoIterator<Item = Action<P>>, locked: bool, permissions: impl Fn(&P) -> Permissions,) -> Result<Vec<P>, DockError>. Apply every action in order, or none, as [Self::apply] does. Returns the panels the
  • craft_behavior::dock::WorkspaceChrome: pub struct WorkspaceChrome { pub menu_bar: bool, pub tool_rail: bool, pub options_bar: bool, pub status_bar: bool }. Chrome a workspace remembers beside the dock layout: which bars show. The default shows every bar.
  • craft_behavior::dock::WorkspaceError: pub enum WorkspaceError { UnknownId, NameTaken, EmptyName, CurrentCannotBeDeleted }. Why a [WorkspaceSet] edit was refused.
  • craft_behavior::dock::WorkspaceSet: pub struct WorkspaceSet<P> { pub builtin: Vec<NamedWorkspace<P>>, pub saved: Vec<NamedWorkspace<P>>, pub current: String, pub locked: bool, pub edited: BTreeMap<String, Workspace<P>> }. The app's workspaces: built-ins first, saved ones after, one current. It is a settings
    • pub fn new(builtin: Vec<NamedWorkspace<P>>) -> Self. A set of builtin workspaces with the first one current.
    • pub fn current(&self) -> Option<&NamedWorkspace<P>>. The current workspace, or None when current names none.
    • pub fn find(&self, id: &str) -> Option<&NamedWorkspace<P>>. The workspace with this id.
    • pub fn layout(&self) -> Option<&Workspace<P>>. The layout the current workspace shows: what it was left with, else its stored one.
    • pub fn select(&mut self, id: &str, live: &mut Workspace<P>) -> Result<(), WorkspaceError>. Switch to id and replace live with the layout it shows; the current workspace's live
    • pub fn save(&mut self, name: &str, live: Workspace<P>, chrome: WorkspaceChrome) -> Result<String, WorkspaceError>. Save live under name and make it current; a name a built-in has is refused. A saved
    • pub fn delete(&mut self, id: &str) -> Result<(), WorkspaceError>. Delete a saved workspace; the current one can't be deleted (Photoshop greys it).
    • pub fn reset(&mut self, live: &mut Workspace<P>) -> Result<(), WorkspaceError>. Reset the current workspace: drop what it was left with and replace live with its stored
  • craft_behavior::dock::ZoneSize: pub enum ZoneSize { Depth(f32), Fraction }. How deep the side zones of a body are.
  • craft_behavior::dock::arrange_rects: pub fn arrange_rects(arrangement: Arrangement, area: Rect, n: usize) -> Option<Vec<Rect>>. The cells of an n-up or Tile All arrangement inside area, in reading order. `Tile All
  • craft_behavior::dock::first_active: pub fn first_active<P>(root: &Node<P>) -> Option<&P>. The shown panel of a tree's first group.
  • craft_behavior::dock::node_at: pub fn node_at<'a, P>(mut node: &'a Node<P>, path: &[bool]) -> Option<&'a Node<P>>. The node at path from root: false is a split's first child, true its second.
  • craft_behavior::dock::tree_panels: pub fn tree_panels<P>(root: &Node<P>) -> Vec<&P>. The panels of a tree in order, without recursion; at most [MAX_PANELS].
  • craft_behavior::dock::zones: pub fn zones(body: Rect, size: ZoneSize, rtl: bool) -> [(DockSide, Rect); 5]. The zones of body, the part of a group below its tab strip: the start and end zones along its full height,

craft_behavior::edit_history

EditHistory<T>: the undo and redo of a dialog, a tool session or the keymap editor, fed by edit events.

  • craft_behavior::edit_history::EditHistory: pub struct EditHistory<T>. Undo and redo stacks of a value T, at most 100 steps. A gesture is one step: Begin opens it, Commit closes it,
    • pub fn new(now: &T) -> Self. A history that starts at now.
    • pub fn record(&mut self, event: &EditEvent<T>). Takes in one event. Events of a gesture other than the open one are ignored.
    • pub fn is_open(&self) -> bool. A gesture is open: a caller that restores a draft waits for it to end.
    • pub fn step(&mut self, now: &mut T, step: Step) -> bool. Steps now back or forward. False when there is nowhere to go. An open gesture is abandoned.
    • pub fn take_back(&mut self) -> Option<T>. Takes back the newest undo step without a redo entry, for an edit that was refused: settled returns to the
    • pub fn can_undo(&self) -> bool. An undo would change something.
    • pub fn can_redo(&self) -> bool. A redo would change something.
  • craft_behavior::edit_history::Step: pub enum Step { Undo, Redo }. Which way [EditHistory::step] goes.

craft_behavior::editor

EditorInput: the one ordered input stream the IME engine produces and an editor part reads (18.4).

  • craft_behavior::editor::EditorInput: pub enum EditorInput { Text(Arc<str>), Move(NavMove, MoveMods), Delete { forward: bool, by: Granularity }, DeleteSurrounding { before: usize, after: usize }, Select { anchor: TextPos, focus: TextPos }, Preedit { text: Arc<str>, cursor: Option<Range<usize>> }, ImeCommit, Edit(EditCommand), Newline, Tab, Cancel }. One input of an editor part.
    • pub const fn delete(forward: bool, by: Granularity) -> Self. A Delete of by.
    • pub fn preedit(text: impl Into<Arc<str>>, cursor: Option<Range<usize>>) -> Self. A Preedit of text with the IME's cursor.
    • pub const fn select(anchor: TextPos, focus: TextPos) -> Self. A Select of anchor to focus.
    • pub const fn is_read_only_safe(&self) -> bool. Whether the input changes no text: a read-only editor receives only these (18.4).

craft_behavior::eviction

When a component's remembered state is due for eviction.

  • craft_behavior::eviction::owner_due: pub fn owner_due(last_pass: u64, last_at: f64, pass_now: u64, now: f64, viewport_live: bool) -> bool. Whether the owner last registered at pass last_pass and time last_at is due: both the pass count and the

craft_behavior::fit

The fit rules: which tabs, bar items or titles stay in a strip and which go to an overflow menu. [fit] and

  • craft_behavior::fit::Fit: pub struct Fit { pub shown: Vec<usize>, pub overflow: Vec<usize> }. Which items the strip shows and which go to the overflow menu, as indexes into the input, in input order.
  • craft_behavior::fit::FitItem: pub struct FitItem { pub extent: f32, pub section: u16, pub keep: FitKeep }. One item as the fit rule sees it: its extent along the strip, its section and whether it may overflow.
    • pub const fn new(extent: f32, section: u16, keep: FitKeep) -> Self. An item extent long in section.
  • craft_behavior::fit::FitKeep: pub enum FitKeep { Free, Pinned, Menu }. Whether an item may move into the overflow menu, or lives there.
  • craft_behavior::fit::TabFit: pub struct TabFit { pub shown: Vec<(usize, f32)>, pub overflow: Vec<usize>, pub overflow_width: f32 }. Tabs visible on a strip and tabs that need an overflow menu, all in original order.
  • craft_behavior::fit::fit: pub fn fit(natural: &[f32], selected: usize, available: f32, minimum_width: f32, overflow_width: f32) -> TabFit. Fit tab widths into available points, shrinking the widest tabs first to a common cap.
  • craft_behavior::fit::fit_items: pub fn fit_items(items: &[FitItem], available: f32, gap: f32, section_gap: f32, overflow_extent: f32) -> Fit. Decides which items stay in a strip available long. Everything fits and no item is Menu: all items show.
  • craft_behavior::fit::fit_whole: pub fn fit_whole(natural: &[f32], selected: usize, available: f32, overflow_width: f32) -> TabFit. Fit tabs at their natural widths; the tabs that do not fit go to an overflow menu.
  • craft_behavior::fit::run_extent: pub fn run_extent(items: &[FitItem], shown: &[bool], gap: f64, section_gap: f64) -> f64. The length of the items marked in shown, with gap between neighbours of a section and section_gap between

craft_behavior::flow

Insets, Flow and Axis: start and end geometry resolved once for the layout direction.

  • craft_behavior::flow::Axis: pub enum Axis { X, Y }. An axis of the screen or of a document. Saved layouts written with the former split axis names load through
  • craft_behavior::flow::Flow: pub struct Flow. The geometry of one rect in one direction. Components place by start and end and never test direction.
    • pub const fn new(rect: Rect, rtl: bool) -> Self. The flow of rect, right to left when rtl.
    • pub const fn rect(&self) -> Rect. The rect the flow places in.
    • pub const fn is_rtl(&self) -> bool. Whether start is the right edge.
    • pub fn start_x(&self) -> f32. The x of the start edge: the left edge, or the right edge under RTL.
    • pub fn end_x(&self) -> f32. The x of the end edge.
    • pub fn span(&self, start: f32, width: f32) -> Rect. The full-height rect width wide that begins start from the start edge.
    • pub fn take_start(&self, width: f32) -> (Rect, Flow). Takes width from the start edge: the taken rect, and the flow of the rest.
    • pub fn take_end(&self, width: f32) -> (Rect, Flow). Takes width from the end edge: the taken rect, and the flow of the rest.
    • pub fn inset(&self, insets: Insets) -> Rect. The rect shrunk by insets.
    • pub fn align(&self, size: Vec2, h: Align, v: Align) -> Rect. A rect of size in the flow's rect: h along the reading direction (Min is the start edge), v
    • pub fn to_physical(&self, logical: Rect) -> Rect. A rect given in logical x (from the start edge of this flow's rect) as a physical rect.
    • pub const fn unmirrored(rect: Rect, reason: &'static str) -> Flow. The same rect placed left to right, for a site that places by explicit rects and must not mirror (a
  • craft_behavior::flow::Insets: pub struct Insets { pub start: f32, pub end: f32, pub top: f32, pub bottom: f32 }. Distances from the four edges of a rect; start and end follow the reading direction.
    • pub const fn new(start: f32, end: f32, top: f32, bottom: f32) -> Self. Insets of start, end, top and bottom.
    • pub const fn horizontal(h: f32) -> Self. h at the start and the end.
    • pub const fn vertical(v: f32) -> Self. v at the top and the bottom.
    • pub const fn uniform(all: f32) -> Self. all on every side.

craft_behavior::focus

Pure focus rules (spec 9.3, 9.4, 8.3): key ownership, focus after removal, the Escape order and the

  • craft_behavior::focus::CancelRule: pub enum CancelRule { Close, ClearThenClose, Ignore }. What Escape does in a scope that has no more specific taker.
  • craft_behavior::focus::EscapeFacts: pub struct EscapeFacts { pub press_captured: bool, pub component_undoable: bool, pub in_row_child: bool, pub scope_clearable: bool }. The facts the Escape order reads.
    • pub const fn new() -> Self. No fact set.
    • pub const fn press_captured(mut self, on: bool) -> Self. A press is captured.
    • pub const fn in_row_child(mut self, on: bool) -> Self. Focus is on a row's child.
    • pub const fn scope_clearable(mut self, on: bool) -> Self. The scope has content to clear.
  • craft_behavior::focus::EscapeRouting: pub struct EscapeRouting { pub cancels_press: bool, pub to_components: usize }. How the Escapes that arrived in one pass split between the captured press and the components.
  • craft_behavior::focus::EscapeStep: pub enum EscapeStep { CancelPress, Component, BackToRow, ClearScope, CloseScope, Ignore }. What the Escape of one pass reaches first.
  • craft_behavior::focus::KeyOwner: pub enum KeyOwner { Blocked, Class(OwnerClass) }. Who owns the keys of one pass.
  • craft_behavior::focus::OwnerClass: pub enum OwnerClass { Widget, Text, Recorder, App, Popup, PassivePopup, Menu, Dialog }. A key class: the input of key ownership.
  • craft_behavior::focus::PressFocus: pub enum PressFocus { Take, Keep, Release, Unclaimed }. How a primary press moves key focus (8.3).
    • pub const fn commits_draft(self) -> bool. Whether a focused text part with a draft commits it in the press pass.
  • craft_behavior::focus::ScopeKind: pub enum ScopeKind { Window, Pane, Dialog, Popup, Menu, Group }. What a focus scope is.
  • craft_behavior::focus::after_removal: pub fn after_removal<'a, T: PartialEq>(last_order: &'a [T], focused: &T, registered: impl Fn(&T) -> bool) -> Option<&'a T>. The stop that takes focus when focused is no longer registered: the one after it in last pass's order
  • craft_behavior::focus::classify_press: pub fn classify_press(winner: Option<Sense>) -> PressFocus. The kind of a press from the sense of the shape that wins it, None when no shape senses it. A shape that
  • craft_behavior::focus::escape_step: pub fn escape_step(facts: EscapeFacts, rule: CancelRule) -> EscapeStep. The order of Escape for the top egui layer that is not exiting: a captured press, the focused component,
  • craft_behavior::focus::key_owner: pub fn key_owner(blocked: bool, present: &[OwnerClass]) -> KeyOwner. Key ownership, in the order blocked, Menu, Recorder, Dialog, Text, Popup and PassivePopup,
  • craft_behavior::focus::route_escapes: pub fn route_escapes(escapes: usize, press_captured: bool) -> EscapeRouting. Routes escapes Escapes of one pass: with a press captured, the first one is the press's (escape_step's

craft_behavior::geometry

Pure canvas geometry in document units: the transform box ([quad]), snapping ([snap]), the

  • craft_behavior::geometry::BoxAllow: re-export of craft_behavior::geometry::quad::BoxAllow.
  • craft_behavior::geometry::BoxDrag: re-export of craft_behavior::geometry::quad::BoxDrag.
  • craft_behavior::geometry::BoxPart: re-export of craft_behavior::geometry::quad::BoxPart.
  • craft_behavior::geometry::BoxRules: re-export of craft_behavior::geometry::quad::BoxRules.
  • craft_behavior::geometry::BoxState: re-export of craft_behavior::geometry::quad::BoxState.
  • craft_behavior::geometry::ConstrainStyle: re-export of craft_behavior::geometry::move_gesture::ConstrainStyle.
  • craft_behavior::geometry::Constraint: re-export of craft_behavior::geometry::marquee::Constraint.
  • craft_behavior::geometry::CropBox: re-export of craft_behavior::geometry::crop::CropBox.
  • craft_behavior::geometry::CropGuide: re-export of craft_behavior::geometry::crop::CropGuide.
  • craft_behavior::geometry::Directions: re-export of craft_behavior::geometry::lock::Directions.
  • craft_behavior::geometry::DraftEvent: re-export of craft_behavior::geometry::draft::DraftEvent.
  • craft_behavior::geometry::DraftKind: re-export of craft_behavior::geometry::draft::DraftKind.
  • craft_behavior::geometry::DraftPoint: re-export of craft_behavior::geometry::draft::DraftPoint.
  • craft_behavior::geometry::DraftReach: re-export of craft_behavior::geometry::draft::DraftReach.
  • craft_behavior::geometry::GuideShow: re-export of craft_behavior::geometry::crop::GuideShow.
  • craft_behavior::geometry::Homography: re-export of craft_behavior::geometry::quad::Homography.
  • craft_behavior::geometry::LOCK_HYSTERESIS_DEGREES: re-export of craft_behavior::geometry::lock::LOCK_HYSTERESIS_DEGREES.
  • craft_behavior::geometry::MarqueeGesture: re-export of craft_behavior::geometry::marquee::MarqueeGesture.
  • craft_behavior::geometry::MarqueeRect: re-export of craft_behavior::geometry::marquee::MarqueeRect.
  • craft_behavior::geometry::MoveGesture: re-export of craft_behavior::geometry::move_gesture::MoveGesture.
  • craft_behavior::geometry::MoveValue: re-export of craft_behavior::geometry::move_gesture::MoveValue.
  • craft_behavior::geometry::OutlineDraft: re-export of craft_behavior::geometry::draft::OutlineDraft.
  • craft_behavior::geometry::Parts: re-export of craft_behavior::geometry::quad::Parts.
  • craft_behavior::geometry::SKEW_LIMIT: re-export of craft_behavior::geometry::quad::SKEW_LIMIT.
  • craft_behavior::geometry::SNAP_PX: re-export of craft_behavior::geometry::snap::SNAP_PX.
  • craft_behavior::geometry::ScaleRule: re-export of craft_behavior::geometry::quad::ScaleRule.
  • craft_behavior::geometry::SelectionOperation: re-export of craft_behavior::geometry::selection_op::SelectionOperation.
  • craft_behavior::geometry::SnapGesture: re-export of craft_behavior::geometry::snap::SnapGesture.
  • craft_behavior::geometry::SnapKind: re-export of craft_behavior::geometry::snap::SnapKind.
  • craft_behavior::geometry::SnapLine: re-export of craft_behavior::geometry::snap::SnapLine.
  • craft_behavior::geometry::SnapOptions: re-export of craft_behavior::geometry::snap::SnapOptions.
  • craft_behavior::geometry::SnapTarget: re-export of craft_behavior::geometry::snap::SnapTarget.
  • craft_behavior::geometry::SnapTargets: re-export of craft_behavior::geometry::snap::SnapTargets.
  • craft_behavior::geometry::StrokeLock: re-export of craft_behavior::geometry::move_gesture::StrokeLock.
  • craft_behavior::geometry::TransformMode: re-export of craft_behavior::geometry::quad::TransformMode.
  • craft_behavior::geometry::across_axis: re-export of craft_behavior::geometry::snap::across_axis.
  • craft_behavior::geometry::coordinate_across: re-export of craft_behavior::geometry::snap::coordinate_across.
  • craft_behavior::geometry::crop_view: re-export of craft_behavior::geometry::crop::crop_view.
  • craft_behavior::geometry::crop_view_about: re-export of craft_behavior::geometry::crop::crop_view_about.
  • craft_behavior::geometry::drag: re-export of craft_behavior::geometry::quad::drag.
  • craft_behavior::geometry::fixed_size_pixels: re-export of craft_behavior::geometry::marquee::fixed_size_pixels.
  • craft_behavior::geometry::hit_rect: re-export of craft_behavior::geometry::crop::hit_rect.
  • craft_behavior::geometry::lock_direction: re-export of craft_behavior::geometry::lock::lock_direction.
  • craft_behavior::geometry::marquee_pixels: re-export of craft_behavior::geometry::marquee::marquee_pixels.
  • craft_behavior::geometry::motion_across: re-export of craft_behavior::geometry::snap::motion_across.
  • craft_behavior::geometry::round_to_direction: re-export of craft_behavior::geometry::lock::round_to_direction.
  • craft_behavior::geometry::screen_step: re-export of craft_behavior::geometry::crop::screen_step.
  • craft_behavior::geometry::square_pixels: re-export of craft_behavior::geometry::marquee::square_pixels.
  • craft_behavior::geometry::turn_to_45: re-export of craft_behavior::geometry::lock::turn_to_45.

craft_behavior::geometry::crop

The crop frame's pure geometry: the box, where a press lands on it, what each gesture makes of it, the

  • craft_behavior::geometry::crop::CropBox: pub struct CropBox { pub rect: Rect, pub angle: f64 }. The crop frame: a document rect and the angle it is turned by about its centre.
    • pub const fn new(rect: Rect, angle: f64) -> Self. The frame rect turned angle degrees about its centre.
    • pub const fn upright(rect: Rect) -> Self. An unturned frame.
    • pub fn part_at(&self, point: Point, reach: f64) -> BoxPart. The part a press at point (document units) lands on, with reach document units of reach: a corner or an
    • pub fn is_finite(&self) -> bool. Whether the rect and the angle are finite numbers.
    • pub fn center(&self) -> Point. The centre the frame turns about.
    • pub fn corners(&self) -> [Point; 4]. The corners on the page, turned: top left, top right, bottom right, bottom left of the upright frame.
    • pub fn part_point(&self, part: BoxPart) -> Option<Point>. The document point of part on the turned frame: a corner or an edge handle, or the centre for
    • pub fn part_direction(&self, part: BoxPart) -> Option<Vec2>. The direction part points out of the frame, as a document vector turned with the frame; none for the
    • pub fn quadrant_diagonal(&self, point: Point) -> Vec2. The diagonal, as a document vector, from the frame's corner nearest point towards the frame's centre
    • pub fn turned_bounds(&self) -> Rect. The axis-aligned bounds of the turned frame.
    • pub fn moved(&self, by: Vec2) -> Self. The frame moved by by on the page, its angle kept.
    • pub fn swapped(&self) -> Self. Width and height swapped about the centre, the angle kept (X).
    • pub fn nudged(&self, part: BoxPart, by: Vec2, ratio: Option<f64>) -> Self. The frame after an arrow key moves part by by, as a plain drag of the part would, with ratio held.
    • pub fn crop_size(&self) -> Option<(f64, f64)>. The size Enter would crop to: the frame's own width and height in whole document units, at least 1; None
    • pub fn size_ok(&self) -> bool. Whether both sides are at least one document unit.
    • pub fn resized(&self, part: BoxPart, by: Vec2, ratio: Option<f64>, alt: bool) -> Self. The frame with part dragged by the page vector by: along the frame's own axes, the opposite edges kept on
    • pub fn resized_centred(&self, part: BoxPart, by: Vec2, ratio: Option<f64>, alt: bool) -> Option<Self>. resized for Auto Center Preview in image mode: part dragged by by grows or shrinks the
    • pub fn turned_to(&self, grab: f64, to: Point, step: Option<f64>, image: bool) -> Self. The frame turned from this one's angle by the pointer's sweep about the centre, from direction grab
    • pub fn within(self, bounds: Rect, resizing: bool, held: bool) -> Option<Self>. The frame kept inside bounds: an unturned frame is cut to it; a turned one is moved by the least that
    • pub fn level_angle(a: Point, b: Point) -> Option<f64>. The frame angle (degrees, clockwise on the page, in -45..=45) that makes the line from a to b level, or
    • pub fn fitted(&self, canvas: Size, angle: f64) -> Option<CropBox>. The largest frame with this one's proportions that fits a canvas of canvas at angle degrees, centred on
  • craft_behavior::geometry::crop::CropGuide: pub enum CropGuide { Thirds, Grid, Diagonal, Triangle, GoldenRatio, GoldenSpiral }. The composition guide drawn inside a crop frame, in Photoshop's menu order.
    • pub const ALL: [CropGuide; 6]. Every guide, in the order next cycles through.
    • pub fn orientations(self) -> u8. How many distinct orientations next_orientation steps through: the Triangle's diagonal runs either way, the
    • pub fn next(self) -> Self. The next guide (O); the orientation starts over at 0.
    • pub fn next_orientation(self, orientation: u8) -> u8. The guide's next orientation (Shift+O) after orientation; a symmetric guide stays at 0 and a stray value
    • pub fn guides(self, orientation: u8, w: f64, h: f64, grid_step: f64, grid_max: usize) -> Vec<Vec<Point>>. The guide's polylines for a frame w x h screen points, in its unit square (0..1 along its top edge, 0..1
  • craft_behavior::geometry::crop::GuideShow: pub enum GuideShow { Auto, Always, Never }. When the guide shows.
    • pub const ALL: [GuideShow; 3]. Every rule, in menu order.
    • pub fn shows(self, gesture: bool) -> bool. Whether the guide shows, gesture being a crop drag in progress.
  • craft_behavior::geometry::crop::crop_view: pub fn crop_view(b: &CropBox, view: &CanvasView) -> CanvasView. view turned so the frame b shows upright (rotation -b.angle), the frame's centre kept where it is on screen.
  • craft_behavior::geometry::crop::crop_view_about: pub fn crop_view_about(b: &CropBox, view: &CanvasView, pivot: Point) -> CanvasView. [crop_view] keeping document point pivot where it is on screen. view itself when anything is not finite.
  • craft_behavior::geometry::crop::direction: pub fn direction(c: Point, p: Point) -> f64. The direction of p from c, in radians.
  • craft_behavior::geometry::crop::drawn: pub fn drawn(anchor: Point, cur: Point, ratio: Option<f64>, mods: Mods) -> Rect. A new frame drawn from anchor to cur: ⇧ square, ⌥ from the centre, ratio held.
  • craft_behavior::geometry::crop::hit_rect: pub fn hit_rect(rect: Rect, point: Point, reach: f64) -> BoxPart. [CropBox::part_at] for a plain upright rect, with no frame or view.
  • craft_behavior::geometry::crop::image_turn: pub fn image_turn(frame_angle: f64) -> f64. The turn the image-mode readout shows: clockwise positive, the frame's angle undone, never -0.
  • craft_behavior::geometry::crop::normalized_angle: pub fn normalized_angle(deg: f64) -> f64. An angle in degrees brought into (-180, 180]; 0 for anything not finite. An angle already in range comes back
  • craft_behavior::geometry::crop::screen_step: pub fn screen_step(view: &CanvasView, by: Vec2) -> Vec2. An arrow step by (screen points) as the document vector it is in view, at one document unit per point.
  • craft_behavior::geometry::crop::snap_angle: pub fn snap_angle(deg: f64, step: f64) -> f64. deg on the nearest multiple of step degrees, brought into (-180, 180]; a step that is not finite and positive
  • craft_behavior::geometry::crop::turn: pub fn turn(p: Point, c: Point, deg: f64) -> Point. p turned deg degrees clockwise on screen (y down) about c.

craft_behavior::geometry::draft

An outline being drawn by a selection or freeform tool, and how it closes: [OutlineDraft].

  • craft_behavior::geometry::draft::DraftEvent: pub enum DraftEvent { Started { intent: Mods }, Changed, Closed { points: Vec<Point>, straight: Vec<usize> }, Cancelled }. What a call on an [OutlineDraft] did. Calls that change nothing return None.
  • craft_behavior::geometry::draft::DraftKind: pub enum DraftKind { Freehand, Mixed, Polygonal }. Which tool's rules an [OutlineDraft] follows.
  • craft_behavior::geometry::draft::DraftPoint: pub struct DraftPoint { pub at: Point, pub mods: Mods, pub zoom: f64 }. One pointer sample for an [OutlineDraft].
    • pub fn new(at: Point, mods: Mods, zoom: f64) -> Self. A sample at at (document units) with mods held, at zoom screen points per unit.
  • craft_behavior::geometry::draft::DraftReach: pub struct DraftReach { pub close: f64, pub same_point: f64 }. How near a press must be to close an outline, in screen points. The caller passes the hit
    • pub const fn new(close: f64, same_point: f64) -> Self. A reach closing within close screen points of the first vertex and treating a press
  • craft_behavior::geometry::draft::OutlineDraft: pub struct OutlineDraft. The pointer state machine of an outline being drawn, shared by every lasso.
    • pub fn new(kind: DraftKind, reach: DraftReach) -> Self. An empty draft following kind's rules, closing within reach.
    • pub fn kind(&self) -> DraftKind. The rules this draft follows.
    • pub fn set_reach(&mut self, reach: DraftReach). Changes the close radii; an open outline keeps its points.
    • pub fn for_document(&mut self, key: u64) -> Option<DraftEvent>. Records key as the active document's. An open outline begun under another key is
    • pub fn press(&mut self, at: DraftPoint, has_selection: bool) -> Option<DraftEvent>. The primary button went down at at; has_selection is whether the document has a
    • pub fn drag(&mut self, at: DraftPoint) -> Option<DraftEvent>. The pointer moved to at with the button down. Freehand and Mixed: the point is added
    • pub fn hover(&mut self, at: DraftPoint) -> Option<DraftEvent>. The pointer moved to at with the button up: only the rubber band follows (hover moves
    • pub fn release(&mut self, at: DraftPoint) -> Option<DraftEvent>. The primary button went up at at. Freehand: closes. Mixed: closes unless straight
    • pub fn mods_changed(&mut self, mods: Mods) -> Option<DraftEvent>. The held modifiers changed. Mixed only: ⌥ pressed after the press (or pressed again after
    • pub fn retract(&mut self) -> Option<DraftEvent>. Removes the last vertex while takes_retract; removing the only
    • pub fn close(&mut self) -> Option<DraftEvent>. Closes an open outline (Enter, a double-click): [DraftEvent::Closed] with 3 or more
    • pub fn cancel(&mut self) -> Option<DraftEvent>. Drops an open outline: [DraftEvent::Cancelled]; None with no outline.
    • pub fn points(&self) -> &[Point]. The outline's points so far, in document units; empty with no outline.
    • pub fn straight(&self) -> &[usize]. Indices into points whose incoming segment is straight.
    • pub fn rubber_band(&self) -> Option<[Point; 2]>. The rubber band from the last vertex to the pointer while straight segments are on and
    • pub fn is_open(&self) -> bool. Whether an outline is open.
    • pub fn is_down(&self) -> bool. Whether the primary button is down on an open outline.
    • pub fn takes_retract(&self) -> bool. Whether retract acts: an outline is open and the button is up (between

craft_behavior::geometry::geom

Plane geometry the canvas overlays share, in document or screen units: segment clipping. Pure maths beside

  • craft_behavior::geometry::geom::clip_segment: pub fn clip_segment(a: Point, b: Point, rect: Rect) -> Option<(Point, Point)>. The part of segment a–b inside rect (Liang–Barsky), or None when none is.

craft_behavior::geometry::lock

Direction locking for ⇧ drags: [Directions], [lock_direction], [round_to_direction] and [turn_to_45].

  • craft_behavior::geometry::lock::Directions: pub enum Directions { Four, Eight }. The directions ⇧ locks a move to.
    • pub const fn count(self) -> u32. How many evenly spaced directions: 4 or 8.
  • craft_behavior::geometry::lock::LOCK_HYSTERESIS_DEGREES: pub const LOCK_HYSTERESIS_DEGREES: f64. Extra angle in degrees the pointer must pass the half-way line between two directions by
  • craft_behavior::geometry::lock::lock_direction: pub fn lock_direction(d: Vec2, previous: Option<Vec2>, directions: Directions) -> Vec2. d locked to the nearest of directions evenly spaced directions (0° = right, document y
  • craft_behavior::geometry::lock::round_to_direction: pub fn round_to_direction(angle: f64, directions: Directions) -> f64. angle (radians, 0 = right, document y down) rounded to the nearest of directions evenly
  • craft_behavior::geometry::lock::turn_to_45: pub fn turn_to_45(from: Point, point: Point) -> Point. point turned about from to the nearest multiple of 45°, keeping its distance: the one ⇧ rule for a line, a

craft_behavior::geometry::marquee

The Ui-free rules of a marquee drag: [MarqueeGesture], the options bar's [Constraint], and the

  • craft_behavior::geometry::marquee::Constraint: pub enum Constraint { Free, Ratio(f64, f64), Size(f64, f64) }. The options bar's marquee style. Serialises camelCase ("free", {"ratio": [1, 1]},
    • pub fn corners(self, start: Point, end: Point, square: bool, centre: bool) -> (Point, Point). The corners of the marquee dragged from start to end: the style applied, ⇧ (square)
  • craft_behavior::geometry::marquee::MarqueeGesture: pub struct MarqueeGesture. The rules of a marquee drag: ⇧ and ⌥ counted only when pressed after the
    • pub fn press(screen: Pos2, at: Point, mods: Mods) -> Self. A press at screen (screen points) and at (document units, snapped by the host) with
    • pub fn pointer(&self) -> Pos2. The pointer on screen as last followed.
    • pub fn has_begun(&self) -> bool. The tool began the gesture with its first drag call.
    • pub fn follow(&mut self, screen: Option<Pos2>, mods: Mods). The pass's mods and pointer (None keeps the last one): records ⇧ and ⌥ being
    • pub fn begin(&mut self) -> bool. Begins the gesture: the tool calls it on its first drag, the press arena having separated the drag from a
    • pub fn square_and_centre(&self) -> (bool, bool). ⇧ (square) and ⌥ (from the centre) for the marquee: held now, and either not held at the
    • pub fn size_to(&mut self, at: Point, space: bool, constraint: Constraint) -> MarqueeRect. Sizes the marquee to the pointer's document point at (the host's snap applied): with
  • craft_behavior::geometry::marquee::MarqueeRect: pub struct MarqueeRect { pub a: Point, pub b: Point }. The two corners of a marquee in document space, as dragged: not ordered, not rounded.
    • pub const fn new(a: Point, b: Point) -> Self. The marquee from the corner a to the corner b.
    • pub fn rect(&self) -> Rect. The rectangle between the corners, with x0 <= x1 and y0 <= y1.
  • craft_behavior::geometry::marquee::fixed_size_pixels: pub fn fixed_size_pixels(a: Point, b: Point, size:(f64, f64)) -> Rect. The pixel rectangle of a fixed-size marquee between the corners a and b: exactly size
  • craft_behavior::geometry::marquee::marquee_pixels: pub fn marquee_pixels(a: Point, b: Point) -> Rect. The pixel rectangle a marquee between two corners selects: both edges snapped outwards to
  • craft_behavior::geometry::marquee::square_pixels: pub fn square_pixels(r: Rect, start: Point, end: Point) -> Rect. A square marquee's pixel rectangle r, as [marquee_pixels] returns it, with equal sides.

craft_behavior::geometry::move_gesture

A move by drag: direction lock, stroke lock and snapping along a ray.

  • craft_behavior::geometry::move_gesture::ConstrainStyle: pub struct ConstrainStyle { pub copy_reach: f64, pub stroke_lock: f64 }. The distances of the move and stroke rules, in screen points.
    • pub const fn new(copy_reach: f64, stroke_lock: f64) -> Self. A style with the two distances; a tool passes ToolContext::slop for both.
  • craft_behavior::geometry::move_gesture::MoveGesture: pub struct MoveGesture. A Move-tool drag in progress: the press, whether ⌥ was held at it, and the last locked
    • pub fn press(style: &ConstrainStyle, start: Point, mods: Mods, directions: Directions) -> MoveGesture. Starts a drag at start (document units) with the keys held at the press.
    • pub fn follow(&mut self, at: Point, mods: Mods, zoom: f64) -> Option<MoveValue>. The pointer moved to at (document units) with mods at zoom screen points per
    • pub fn release(mut self, at: Point, mods: Mods, zoom: f64) -> MoveValue. The release at at: the same lock as follow applies, so a release where
    • pub fn value(&self) -> MoveValue. The value of the last follow: the offset and whether it copies.
    • pub fn locked(&self) -> Option<Vec2>. The direction ⇧ holds the offset to, as the last locked offset; None while the move is free.
  • craft_behavior::geometry::move_gesture::MoveValue: pub struct MoveValue { pub delta: Vec2, pub copy: bool }. The value of a move drag.
    • pub fn changed(&self) -> bool. Whether the drag changes anything: an offset or a copy. A press and release without
  • craft_behavior::geometry::move_gesture::StrokeLock: pub struct StrokeLock. ⇧ during a painting stroke (every painting tool, the Freeform Pen; which tools is the app's
    • pub fn new(style: &ConstrainStyle) -> Self. No lock yet; style gives the screen distance before the direction locks.
    • pub fn constrain(&mut self, last: Point, p: Point, shift: bool, zoom: f64) -> Point. The stroke point for the pointer at p (document units), last the stroke's last point,
    • pub fn locked(&self) -> bool. Whether a direction is locked.
    • pub fn reset(&mut self). Forget the lock (the stroke ended).

craft_behavior::geometry::quad

Box geometry of transform boxes: where the box goes when a part of it is dragged, and the

  • craft_behavior::geometry::quad::BoxAllow: pub struct BoxAllow { pub rotate: bool, pub skew: bool, pub distort: bool }. What the box's content allows. PhotoCraft: editable type refuses distort and perspective
    • pub const fn new(rotate: bool, skew: bool, distort: bool) -> Self. What the content allows: turning, skewing and distorting.
  • craft_behavior::geometry::quad::BoxDrag: pub enum BoxDrag { Move, Pivot, Rotate, Scale, Distort, Perspective, Skew, SlideCorner }. What a drag of a box part does ([BoxRules::drag_kind]).
  • craft_behavior::geometry::quad::BoxPart: pub enum BoxPart { Corner(u8), Edge(u8), Pivot, Inside, Outside }. A part of a box under the pointer or picked from the keyboard. Edge k joins corners k and
    • pub const fn index(self) -> u64. The number a part is keyed by in a canvas control's part keys: 0 inside or outside, 1 to 4 the corners, 5 to
    • pub const fn from_index(index: u64) -> Option<BoxPart>. The part keyed by index: the inverse of index, with 0 the inside.
  • craft_behavior::geometry::quad::BoxRules: pub struct BoxRules { pub mode: TransformMode, pub scale: ScaleRule, pub aspect_linked: bool, pub allow: BoxAllow, pub rotate_step: f64 }. How drags change a box.
    • pub fn in_mode(mode: TransformMode) -> BoxRules. The rules of mode with the default scale rule, a linked aspect, everything allowed and
    • pub fn with_scale(mut self, scale: ScaleRule) -> BoxRules. The rules with scale as the plain corner and edge drag rule.
    • pub fn with_aspect_linked(mut self, linked: bool) -> BoxRules. The rules with the options bar's aspect link on or off.
    • pub fn with_allow(mut self, allow: BoxAllow) -> BoxRules. The rules with allow as what the content permits.
    • pub fn effective_mode(&self) -> TransformMode. The mode drags follow: a mode the content refuses scales as Free Transform does.
    • pub fn allows(&self, part: BoxPart) -> bool. Whether a drag of part changes the box: in Distort only the corners, the inside and the
    • pub fn drag_kind(&self, part: BoxPart, mods: Mods) -> Option<BoxDrag>. What a drag of part with mods held (as the host has them, before
  • craft_behavior::geometry::quad::BoxState: pub struct BoxState { pub quad: [Point; 4], pub pivot: Point }. A transform box: its four corners clockwise from the top left (as the box was before any
    • pub const fn new(quad: [Point; 4], pivot: Point) -> Self. A box with the corners quad, clockwise from the top left, and the reference point pivot.
    • pub fn from_rect(r: Rect) -> Self. The box of r, the reference point at its centre.
    • pub fn moved(&self, by: Vec2) -> Self. The box and its reference point moved by by.
    • pub fn is_parallelogram(&self) -> bool. Whether the box is still an affine image of its rect (opposite sides parallel), so W and H
    • pub fn parts(&self, rect: Rect, skew_v: f64) -> Parts. The box read as the options bar shows it, rect being the box before the transform and
    • pub fn with_parts(&self, rect: Rect, skew_v: f64, mut to: Parts) -> Self. The box with the options bar's fields set to to: W and H scale it along its own axes, the
    • pub fn linked_scale(now:(f64, f64), axis: usize, typed: f64) -> (f64, f64). The signed factors (w, h) after the side on axis (0: W, 1: H) is set to typed with W
    • pub fn point_at(&self, at: Anchor9) -> Point. One of the box's nine points, through the box's own frame (a distorted box's centre is
    • pub fn anchor_of_pivot(&self) -> Option<Anchor9>. The point of the nine the reference point is on, within 0.05 document units; None for a
    • pub fn part_at(&self, p: Point, tol: f64) -> BoxPart. The part at p: the nearest of the corners, edge midpoints and reference point within
    • pub fn contains(&self, p: Point) -> bool. Whether p is inside the box (even-odd, so a folded box has holes).
    • pub fn angle(&self) -> f64. The direction of the top edge in degrees, clockwise in document space (y down): the rotate
    • pub fn scaled_about_pivot(&self, kx: f64, ky: f64) -> Self. Scaled by kx and ky along the box's own axes about the reference point. A negative
    • pub fn turned_about_pivot(&self, radians: f64) -> Self. Turned by radians about the reference point.
  • craft_behavior::geometry::quad::Homography: pub struct Homography. A projective map of the plane: the unit square onto a box, so a box scales along its own axes
    • pub fn from_rows(rows: [[f64; 3]; 3]) -> Homography. The map with these rows of (x, y, w) coefficients, applied to (x, y, 1).
    • pub fn row(&self, i: usize) -> [f64; 3]. Row i (0 to 2) of the matrix: the coefficients of x, y and the constant.
    • pub fn unit_to_quad(q: [Point; 4]) -> Option<Homography>. The map taking (0, 0), (1, 0), (1, 1), (0, 1) to q's corners; None for a degenerate
    • pub fn apply(&self, p: Point) -> Point. p of the unit square, carried to the box.
    • pub fn inverse(&self) -> Option<Homography>. The map back from the box to the unit square; None when the map is singular.
  • craft_behavior::geometry::quad::Parts: pub struct Parts { pub w: f64, pub h: f64, pub angle: f64, pub skew_h: f64, pub skew_v: f64 }. A box read as the options bar shows it: the starting rect scaled by w and h, skewed by
    • pub const fn new(w: f64, h: f64, angle: f64, skew_h: f64, skew_v: f64) -> Self. The readings: scale factors w and h, the angle in degrees and the two skews in degrees.
  • craft_behavior::geometry::quad::SKEW_LIMIT: pub const SKEW_LIMIT: f64. The skew fields' reach in degrees: a skew of ±90° would flatten the box (PhotoCraft's).
  • craft_behavior::geometry::quad::ScaleRule: pub enum ScaleRule { Proportional, Free }. What a plain corner or edge drag does.
  • craft_behavior::geometry::quad::TransformMode: pub enum TransformMode { Free, Rotate, Skew, Distort, Perspective }. Edit › Transform's modes.
  • craft_behavior::geometry::quad::bisector: pub fn bisector(screen: &BoxState, i: usize) -> emath::Vec2. Corner i of screen's unit bisector, pointing into the box; zero for a collapsed corner. The
  • craft_behavior::geometry::quad::drag: pub fn drag(start: &BoxState, last: &BoxState, part: BoxPart, from: Point, to: Point, mods: Mods, rules: &BoxRules) -> BoxState. The box after dragging part from from to to (document points) with mods held, from the
  • craft_behavior::geometry::quad::outset: pub fn outset(corners: &[emath::Pos2; 4], by: f32) -> [emath::Pos2; 4]. The closed polygon corners moved by points outward, each corner along its mitre (kept

craft_behavior::geometry::selection_op

[SelectionOperation]: how a new selection combines with the current one.

  • craft_behavior::geometry::selection_op::SelectionOperation: pub enum SelectionOperation { New, Add, Subtract, Intersect }. How a selection made by a click or a drag combines with the current one: the rule the Channels
    • pub const ALL: [SelectionOperation; 4]. Every operation, in Photoshop's options-bar order.
    • pub fn from_mods(mods: Mods) -> SelectionOperation. The operation mods ask for: Shift and Alt Intersect, Shift Add, Alt Subtract,
    • pub fn resolve(bar: SelectionOperation, mods: Mods, has_selection: bool) -> SelectionOperation. The operation a selection tool's gesture uses (Photoshop's): the options bar's bar,
    • pub fn badge(self) -> Option<CursorBadge>. The badge beside the selection pointer: Add a plus, Subtract a minus, Intersect a
    • pub const fn name(self) -> &'static str. The operation's stable name for commands and settings: "new", "add", "subtract",

craft_behavior::geometry::snap

[SnapTargets]: snapping (View › Snap / Snap To) and smart-guide geometry.

  • craft_behavior::geometry::snap::SNAP_PX: pub const SNAP_PX: f64. Screen points within which a position snaps (Photoshop).
  • craft_behavior::geometry::snap::SnapGesture: pub enum SnapGesture { Point, Rect { at_press: Rect }, Axis { along: Axis } }. How the host snaps a tool's pointer.
    • pub const fn rect(at_press: Rect) -> Self. A moving rectangle that was at_press when the gesture began.
    • pub const fn axis(along: Axis) -> Self. Only the coordinate across the lines that run along snaps: x for Axis::Y.
  • craft_behavior::geometry::snap::SnapKind: pub enum SnapKind { Guide, Grid, Bounds, Center, LayerEdge, LayerCenter, Selection }. What a target is, so an app can filter (Snap To › Guides only) and the lines can be drawn in
  • craft_behavior::geometry::snap::SnapLine: pub struct SnapLine { pub along: Axis, pub position: f64, pub kind: SnapKind, pub span: Option<(f64, f64)> }. The line the UI draws for a snap that happened.
  • craft_behavior::geometry::snap::SnapOptions: pub struct SnapOptions { pub on: bool, pub guides: bool, pub grid: bool, pub layers: bool, pub document_bounds: bool, pub selection: bool, pub smart_guides: bool }. View › Snap To and View › Show › Smart Guides, as the app stores them.
  • craft_behavior::geometry::snap::SnapTarget: pub struct SnapTarget { pub along: Axis, pub position: f64, pub kind: SnapKind, pub span: Option<(f64, f64)> }. One snap position on one axis.
    • pub const fn new(along: Axis, position: f64, kind: SnapKind) -> Self. A full-height line of kind running along an axis, at position across it: a line along Axis::Y
  • craft_behavior::geometry::snap::SnapTargets: pub struct SnapTargets. The snap targets of one gesture.
    • pub fn new() -> Self. No targets.
    • pub fn add(&mut self, target: SnapTarget). Add one target.
    • pub fn with_document(self, options: &SnapOptions, bounds: Rect, guides: impl IntoIterator<Item =(Axis, f64)>, grid: Option<(Point, Vec2)>,) -> Self. Guides as full-height targets, grid lines of spacing from origin over bounds, the
    • pub fn filtered(&self, keep: impl Fn(SnapKind) -> bool) -> SnapTargets. Only the targets keep accepts (Snap To with one kind off).
    • pub fn is_empty(&self) -> bool. Whether there is no target.
    • pub fn nearest(&self, along: Axis, value: f64, tolerance: f64) -> Option<SnapTarget>. The nearest target among the lines that run along an axis, within tolerance of value across them.
    • pub fn snap_point(&self, point: Point, tolerance: f64) -> (Point, Vec<SnapLine>). point snapped on each axis independently, with the lines to draw.
    • pub fn snap_rect(&self, rect: Rect, tolerance: f64) -> (Vec2, Vec<SnapLine>). The offset that moves rect so its nearest edge or centre meets a target on each axis,
  • craft_behavior::geometry::snap::across_axis: pub const fn across_axis(along: Axis) -> Axis. The axis across along: a line running along Axis::Y (vertical) is placed on Axis::X.
  • craft_behavior::geometry::snap::coordinate_across: pub const fn coordinate_across(along: Axis, p: Point) -> f64. The coordinate of p a line running along an axis is placed by: x for a line along Axis::Y.
  • craft_behavior::geometry::snap::motion_across: pub fn motion_across(along: Axis) -> Vec2. The document direction a line running along an axis moves in: x for a line along Axis::Y. A screen caller
  • craft_behavior::geometry::snap::union: pub fn union(rects: impl IntoIterator<Item = Rect>) -> Option<Rect>. The bounding rectangle of rects, or None for none.

craft_behavior::grid

The Grid cursor: columns resolved from last pass's measurements, and the cell each child takes.

  • craft_behavior::grid::GridCursor: pub struct GridCursor. Hands out the cells of one Grid pass, row-major. Cells are placed from last pass's measurements; this
    • pub fn new(flow: Flow, columns: &[ColumnWidth], gap: Vec2, last: &GridMeasure) -> Self. A cursor over columns in flow's rect, with gap between columns (x) and rows (y), placed by last. A
    • pub fn sized_by_content(flow: Flow, columns: &[ColumnWidth], gap: Vec2, last: &GridMeasure) -> Self. A cursor for a measuring run under a body sized from its content: each Fill column of columns is placed
    • pub fn unbounded(flow: Flow, columns: &[ColumnWidth], gap: Vec2) -> Self. A cursor for the sweep that asks each column for its least: every column but a Fixed one is placed as a
    • pub fn each_alone(mut self) -> Self. The cursor with each Content column measuring in the room the other columns leave at their least, whatever
    • pub fn short(&self) -> bool. Whether the columns, as this sweep measured them, do not fit beside each other: the columns that do not share
    • pub fn cell(&mut self, size: Vec2) -> Rect. The cell of the next child, whose measured size is size.
    • pub fn room(&self) -> Vec2. The room the next child measures in: as wide as its column, or for a Content column as wide as the columns
    • pub fn region(&self) -> Rect. The rect the next child measures and is placed in: from its column's start edge and its row's top, as large
    • pub fn fill_room(&self) -> Vec2. The room the next child fills when it fills its width: its column's width, which for a Content column is the
    • pub fn in_content_column(&self) -> bool. Whether the next child goes in a Content column.
    • pub fn widen(&mut self, size: Vec2). The cell last placed measured size after all: its column and row record that, and a Content column offers
    • pub fn measured(&self) -> &GridMeasure. What this pass measured.
  • craft_behavior::grid::GridMeasure: pub struct GridMeasure { pub columns: Vec<f32>, pub rows: Vec<f32>, pub least: Vec<f32> }. What a Grid pass measured: the widest child per column and the tallest per row, and the least each column
    • pub const fn new(columns: Vec<f32>, rows: Vec<f32>) -> Self. A measurement of columns and rows.
    • pub fn with_least(mut self, least: Vec<f32>) -> Self. The measurement with the least width of each column.
  • craft_behavior::grid::resolve_columns: pub fn resolve_columns(columns: &[ColumnWidth], content: &[f32], room: f32, gap: f32) -> Vec<f32>. The width of each column in room: Fixed is the app's width, Content the widest child of last pass

craft_behavior::hit

Hit shapes, their priority and the arena's resolve rule (8.3).

  • craft_behavior::hit::HitLevel: pub enum HitLevel { Background, Body, Edge, Handle }. The tier of a shape inside one stack position; a higher level wins.
  • craft_behavior::hit::HitPriority: pub struct HitPriority { pub level: HitLevel, pub sub: u8 }. A part's rank among the shapes of its stack position: a node editor ranks port above wire above node body.
    • pub const fn new(level: HitLevel, sub: u8) -> Self. A priority at level and sub.
    • pub const BODY: HitPriority. The priority of a component body.
  • craft_behavior::hit::HitShape: pub enum HitShape { Rect(Rect), Circle { center: Pos2, radius: f32 }, Segment { a: Pos2, b: Pos2 }, Polyline { points: Vec<Pos2>, closed: bool }, Polygon(Vec<Pos2>), OutsidePolygon { within: Rect, polygon: Vec<Pos2> } }. The geometry a part registers: the shape painted is the shape hit.
    • pub const fn circle(center: Pos2, radius: f32) -> Self. A disc.
    • pub const fn segment(a: Pos2, b: Pos2) -> Self. A line segment.
    • pub fn polyline(points: Vec<Pos2>, closed: bool) -> Self. A chain of segments, closed when closed.
    • pub fn outside_polygon(within: Rect, polygon: Vec<Pos2>) -> Self. The part of within outside polygon.
    • pub fn bounds(&self) -> Rect. The smallest rectangle around the shape.
    • pub fn hit(&self, point: Pos2) -> bool. Whether point hits the shape.
  • craft_behavior::hit::LINE_REACH: pub const LINE_REACH: f32. How far from a line a point still hits it, in points.
  • craft_behavior::hit::ResolveFor: pub enum ResolveFor { Press, Hover }. What a resolution is for.
  • craft_behavior::hit::Shape: pub struct Shape<O> { pub shape: HitShape, pub sense: Sense, pub owner: O, pub part: Option<PartRef>, pub priority: HitPriority, pub position: u32, pub local: bool, pub min_across: f32 }. One registered shape of the shape record: a root's, a member's or a part's.
    • pub const fn new(shape: HitShape, sense: Sense, owner: O, part: Option<PartRef>, priority: HitPriority, position: u32) -> Self. A shape of owner at stack position.
    • pub const fn min_across(mut self, across: f32) -> Self. The hit area is at least across points wide and high.
    • pub const fn local(mut self, local: bool) -> Self. The shape lies in the body layer's space.
  • craft_behavior::hit::Winner: pub struct Winner<O> { pub index: usize, pub owner: O, pub part: Option<PartRef>, pub sense: Sense, pub local: bool }. The shape that won a resolution.
  • craft_behavior::hit::resolve: pub fn resolve<O: Copy>(shapes: &[Shape<O>], point: Pos2, what: ResolveFor) -> Option<Winner<O>>. The winner among shapes at point: stack position first, then level, sub-level, the nearest centre, the last
  • craft_behavior::hit::resolve_mapped: pub fn resolve_mapped<O: Copy>(shapes: &[Shape<O>], point: Pos2, what: ResolveFor, to_local: impl Fn(Pos2) -> Pos2) -> Option<Winner<O>>. [resolve] where shapes with local set are tested at to_local(point).

craft_behavior::input

What a component takes from the user, which decides its default key use.

  • craft_behavior::input::Input: pub enum Input { Pointer, Text, Display, Editor }. The input a component takes.

craft_behavior::intent

Intents: a key, an AccessKit action or typed text turned into meaning (spec 9.2).

  • craft_behavior::intent::AccessRequest: pub struct AccessRequest { pub action: accesskit::Action, pub target: Option<PartRef>, pub data: Option<accesskit::ActionData> }. An AccessKit action with no intent of its own, or any action on a non-focusable sub-node.
    • pub const fn new(action: accesskit::Action, target: Option<PartRef>, data: Option<accesskit::ActionData>) -> Self. A request for action on target.
  • craft_behavior::intent::EditCommand: pub enum EditCommand { Cut, Copy, Paste, SelectAll, Undo, Redo }. An edit command a component lists in its KeyUse to receive it as Intent::Edit.
  • craft_behavior::intent::Granularity: pub enum Granularity { Unit, Word, Line, Paragraph, Document }. How far a move reaches.
  • craft_behavior::intent::Intent: pub enum Intent { Activate, Submit, SubmitForce, Cancel, Move(NavMove, MoveMods), Delete { forward: bool, by: Granularity, shift: bool }, Space, TogglePick, Digit(u8), Rename, ContextMenu, Reset, Text(Arc<str>), Tab, Edit(EditCommand), SwitchPage { forward: bool }, MoveItem { front: bool, all_the_way: bool }, Open, Close, Access(AccessRequest) }. What the runtime routes to a focused component.
    • pub const fn delete(forward: bool, by: Granularity) -> Intent. Delete of by, forward or back.
    • pub const fn switch_page(forward: bool) -> Intent. SwitchPage to the next page when forward.
    • pub const fn move_item(front: bool, all_the_way: bool) -> Intent. MoveItem toward the front when front, all the way when all_the_way.
    • pub fn same_kind(&self, other: &Intent) -> bool. Whether self and other are the same kind of intent, whatever their data.
  • craft_behavior::intent::MoveMods: pub struct MoveMods { pub extend: bool, pub lead: bool, pub by: Granularity, pub fine: bool }. The modifiers of a move, read from the key table.
    • pub const PLAIN: MoveMods. A move by one unit with no modifier.
    • pub const fn new(extend: bool, lead: bool, by: Granularity) -> MoveMods. Modifiers with the given parts and no fine flag.
    • pub const fn fine(mut self, on: bool) -> MoveMods. The same modifiers with the fine flag set to on.
  • craft_behavior::intent::NavMove: pub enum NavMove { Back, Forward, Up, Down, PageUp, PageDown, Start, End }. A logical move. Back and Forward follow the reading direction; the runtime flips physical arrows
  • craft_behavior::intent::TextPos: pub struct TextPos { pub line: usize, pub byte: usize }. A position in a text document.
    • pub const fn new(line: usize, byte: usize) -> TextPos. The position byte bytes into line.

craft_behavior::item_layout

Item geometry: where each item of a collection sits for a scroll offset and viewport.

  • craft_behavior::item_layout::FreeLayout: pub struct FreeLayout { pub rects: Vec<Rect> }. Items at positions the document stores: a freeform bin or a node graph.
    • pub fn new(rects: Vec<Rect>) -> Self. Items at rects, in content coordinates.
  • craft_behavior::item_layout::ItemLayout: pub trait ItemLayout. Item geometry in content units. Offsets are f64, so a sheet of a million rows places its last row
    • fn mirrors(&self) -> bool. False for a layout whose positions are document data (FreeLayout); the item step then leaves them as given.
    • fn content_size(&self) -> ScrollPos. Finite and non-negative.
    • fn visible(&self, offset: ScrollPos, view: Vec2, out: &mut Vec<usize>). The indices of the items that intersect a viewport of size view scrolled to offset, ascending.
    • fn rect(&self, at: usize, offset: ScrollPos) -> Rect. The rect of item at.
    • fn hit(&self, point: Pos2, offset: ScrollPos) -> Option<usize>. The item under point.
    • fn nav(&self) -> NavShape. How arrow keys move through the items.
    • fn row_len(&self, _row: usize) -> Option<usize>. NavShape::RaggedGrid: the number of items in row, rows holding consecutive items and a run of hidden items
    • fn shown(&self, _at: usize) -> bool. Whether item at takes a place in the layout; a hidden item (in a closed group) cannot take the lead.
    • fn cells(&self, _at: usize, _offset: ScrollPos, _out: &mut Vec<(ColumnKey, Rect)>). The cells of item at, with their rects.
    • fn grid(&self) -> Option<&GridView>. Column virtualisation and sections of a sheet.
    • fn frozen_band(&self, _at: usize) -> f32. The height at the top of the view that item at must not paint into: the zoomed frozen-row band for a scrolled
    • fn first_navigable(&self) -> usize. The first item that is not frozen: where Ctrl or Cmd with Home goes. Zero for a layout without frozen rows.
    • fn set_columns(&mut self, _columns: &[(ColumnKey, f32)]). The column widths the collection resolved, from the start edge; layouts without columns ignore them.
    • fn column_count(&self) -> usize. The number of columns of a table or sheet; 0 for a layout with none.
    • fn column_shown(&self, _index: usize) -> bool. Whether the column at position index is shown; a hidden column has no cell and the arrows skip it.
    • fn column_key(&self, _index: usize) -> Option<ColumnKey>. The key of the column at position index.
    • fn column_at(&self, _point: Pos2, _offset: ScrollPos) -> Option<usize>. The position of the column under point.
    • fn is_auto(&self, _at: usize) -> bool. Whether item at is as tall as it measures itself.
    • fn measured(&mut self, _heights: &dyn Fn(usize) -> Option<f32>). Takes the measured heights of the auto items: heights(at) is None before the item's first measure.
    • fn set_height(&mut self, _at: usize, _height: f32). An auto item measured height in this pass; the items after it move.
    • fn auto_widths(&self) -> bool. Whether the items are as wide as they measure themselves. A layout that asks for widths places the items
    • fn set_width(&mut self, _at: usize, _ideal: f32, _min: f32). An auto-width item measured ideal and min width. The values of the previous pass arrive before
    • fn set_view(&mut self, _viewport: Vec2, _offset: ScrollPos). The viewport and scroll offset the grid view describes. Layouts without a grid ignore it.
  • craft_behavior::item_layout::LineIndex: pub struct LineIndex. Lines (rows or columns) with a default size, the lines whose size differs and their prefix sums, so the start
    • pub fn uniform(size: f32, count: u32) -> Self. count lines of size each (negative or NaN sizes count as 0.0).
    • pub fn set(&mut self, line: u32, size: f32). Gives line the size size; the lines after it move. A line at or past count is ignored.
    • pub fn start(&self, line: u32) -> f64. The start of line: the sum of the sizes before it. A line past the last one continues at the default size.
    • pub fn end(&self, line: u32) -> f64. The end of line: its start plus its size.
    • pub fn shown(&self, line: u32) -> bool. Whether line exists and has a size above zero.
    • pub fn count(&self) -> u32. The number of lines.
    • pub fn total(&self) -> f64. The sum of all sizes: where the line after the last would start.
  • craft_behavior::item_layout::SHEET_ZOOM: pub const SHEET_ZOOM: RangeInclusive<f32>. The least and greatest zoom of a sheet (10 %…400 %).
  • craft_behavior::item_layout::SheetLayout: pub struct SheetLayout. Rows of a sheet: one position per row, each split into the sheet's columns, over one [LineIndex] for the rows
    • pub fn new<K>(source: &dyn DisplayOrder<K>, row_h: f32, columns: Vec<(ColumnKey, f32)>) -> Self. A row of row_h per entry of source, split into columns, each with its key and width.
    • pub fn lines(rows: LineIndex, columns: LineIndex) -> Self. A sheet with the size of every row and column in rows and columns, at 100 % zoom. A column's key is
    • pub fn frozen(mut self, count: usize) -> Self. The first count columns stay in view while the others scroll.
    • pub fn frozen_rows(mut self, count: u32) -> Self. The first count rows stay in view while the others scroll. Hidden rows among them take no room.
    • pub fn zoom(mut self, zoom: f32) -> Self. Every row height and column width is multiplied by zoom, clamped to [SHEET_ZOOM].
    • pub fn rows(&self) -> &LineIndex. The row extents at 100 %.
    • pub fn columns(&self) -> &LineIndex. The column extents at 100 %.
  • craft_behavior::item_layout::SpanLayout: pub struct SpanLayout { pub row_h: f32, pub count: usize, pub width: f32, pub columns: Vec<(ColumnKey, f32)>, pub tree: bool }. Rows of equal height, optionally split into columns: lists, popup lists, tab strips and timeline tracks.
    • pub fn new<K>(source: &dyn DisplayOrder<K>, width: f32, row_h: f32) -> Self. One row of row_h per entry of source, width wide, with no columns.
    • pub fn sized<K>(source: &dyn ItemSource<K>, width: f32, row_h: f32) -> Self. Rows as tall as source says: Height and Rect are the app's, Aspect follows the width, and Auto
    • pub fn columns(mut self, columns: Vec<(ColumnKey, f32)>) -> Self. The columns with their widths, from the start edge.
    • pub fn tree(mut self) -> Self. Rows that expand and collapse.
  • craft_behavior::item_layout::TileLayout: pub struct TileLayout { pub tile: Vec2, pub gap: f32, pub count: usize, pub width: f32, pub fixed_columns: Option<usize> }. Equal tiles that wrap at the width: tile grids, preset grids, font cards and swatch grids.
    • pub fn new<K>(source: &dyn DisplayOrder<K>, width: f32, tile: Vec2, gap: f32) -> Self. One tile of tile per entry of source, gap apart, wrapping at width.
    • pub fn in_columns(mut self, columns: usize) -> Self. Exactly columns tiles per row, whatever the width (a user setting; at least one).
    • pub fn columns(&self) -> usize. Tiles per row: the user's count, else what the width allows; at least one.

craft_behavior::item_marquee

MarqueeSelect: the rectangle a drag over list items sweeps and the selection it makes (8.7).

  • craft_behavior::item_marquee::MarqueeMode: pub enum MarqueeMode { Replace, Add, Toggle, Subtract }. How the swept items combine with the selection the drag started from. Items follow the list rule (Cmd or Ctrl
    • pub const fn of(mods: Mods) -> MarqueeMode. The mode a press with mods starts: Shift adds, Cmd or Ctrl toggles, Alt subtracts, none replaces.
  • craft_behavior::item_marquee::MarqueeSelect: pub struct MarqueeSelect<K>. A marquee drag in progress. It holds the selection the drag started from, so a cancel restores it.
    • pub fn begin(origin: Pos2, mods: Mods, base: Vec<K>) -> Self. A marquee that began at origin over base, in the mode mods pick.
    • pub fn mode(&self) -> MarqueeMode. The mode the drag runs in.
    • pub fn update(&mut self, pos: Pos2). Moves the free corner to pos.
    • pub fn rect(&self) -> Rect. The swept rectangle.
    • pub fn selection(&self, items: impl IntoIterator<Item =(K, Rect)>) -> Vec<K>. The selection while the marquee is live, from the items items (key and rect) it sweeps.
    • pub fn cancel(self) -> Vec<K>. Ends the drag with Escape: the selection it started from.

craft_behavior::item_source

Where a collection's items come from: the data traits and the one way to show a slice.

  • craft_behavior::item_source::DisplayOrder: pub trait DisplayOrder<K>. The order a collection shows its entries in. The library never owns the data.
    • fn len(&self) -> usize. The number of entries.
    • fn key(&self, at: usize) -> K. The key of entry at. Items take their id from it, never from the position.
    • fn index_of(&self, key: &K) -> Option<usize> where K: PartialEq,. The position of key, None when the source no longer holds it. The default scans; a source over a
    • fn depth(&self, _at: usize) -> usize. The nesting depth of entry at, 0 for a root.
    • fn has_children(&self, _at: usize) -> bool. Whether entry at has children.
    • fn open(&self, _at: usize) -> bool. Whether the children of entry at show.
    • fn is_section(&self, _at: usize) -> bool. Whether entry at is a section header, which navigation skips.
    • fn section_stop(&self, _at: usize) -> bool. Whether section at is a stop of navigation: it holds the lead, takes Enter, the context-menu key and a
    • fn section_stops_before(&self, _at: usize) -> usize. How many section stops (section_stop) come before entry at. They are not members of the set of items, so
    • fn enabled(&self, _at: usize) -> bool. Whether entry at can take the lead.
    • fn text(&self, _at: usize) -> Option<Cow<'_, str>>. The text type-ahead matches entry at against.
    • fn revision(&self) -> Option<u64>. A number that changes whenever the entries or their order change; None when the source does not report.
    • fn is_empty(&self) -> bool. Whether there are no entries.
  • craft_behavior::item_source::ItemSource: pub trait ItemSource<K>: DisplayOrder<K>. A display order that also says how tall its entries want to be.
    • fn size_hint(&self, _at: usize) -> SizeHint. The size entry at wants.
    • fn toggled(&self, _at: usize, _column: &ColumnKey) -> bool. Whether the cell of entry at in the toggle column column is on.
    • fn toggle_enabled(&self, _at: usize, _column: &ColumnKey) -> bool. Whether the cell of entry at in the toggle column column can be flipped: a locked field's cell shows its
  • craft_behavior::item_source::Keyed: pub struct Keyed<'a, T, K>. A slice as an item source, each entry keyed by key.
    • pub fn with_text(mut self, text: impl for<'t> Fn(&'t T) -> Cow<'t, str> + 'a) -> Self. The text type-ahead matches each entry against.
    • pub fn with_toggled(mut self, toggled: impl Fn(&T, &ColumnKey) -> bool + 'a) -> Self. Whether an entry's cell in a toggle column is on. Without it every toggle cell is off.
  • craft_behavior::item_source::Outline: pub struct Outline<'a, K>. DisplayOrder as the key-free outline the navigation core steps over.
    • pub fn new(order: &'a dyn DisplayOrder<K>) -> Self. The outline of order.
    • pub fn columns(mut self, columns: usize) -> Self. The cells of every position, for a sheet's cell navigation.
  • craft_behavior::item_source::SizeHint: pub enum SizeHint { Auto, Height(f32), Aspect(f32), Rect(Vec2) }. How tall (or what shape) an item wants to be.
  • craft_behavior::item_source::keyed: pub fn keyed<'a, T, K>(items: &'a [T], key: impl Fn(&T) -> K + 'a) -> Keyed<'a, T, K>. Shows items keyed by key: the one way to show a slice (7.1 rule 4).

craft_behavior::keys

The key table (spec 9.2): the one place that maps a key press to an intent and modifiers to MoveMods.

  • craft_behavior::keys::DropOperation: pub enum DropOperation { Move, Copy, Link }. What a drop of a dragged payload does with it.
  • craft_behavior::keys::KeyRole: pub struct KeyRole { pub resettable: bool, pub space: bool, pub multi_select: bool, pub reorderable: bool, pub rename: bool, pub pages: bool, pub nudge: bool, pub document: bool, pub type_ahead: bool, pub digits: bool, pub value: bool, pub text: bool, pub moves: bool, pub deletes: bool, pub stacked: bool, pub owner_arrows: bool, pub home_row: usize }. What the focused stop is, as far as the table's rows differ.
    • pub const fn new() -> KeyRole. A role with no special rows.
    • pub const fn resettable(mut self, on: bool) -> Self. Delete resets the control.
    • pub const fn space(mut self, on: bool) -> Self. Space is the component's own intent.
    • pub const fn multi_select(mut self, on: bool) -> Self. Ctrl+Space toggles the lead's pick.
    • pub const fn reorderable(mut self, on: bool) -> Self. The stacking keys move the selected items.
    • pub const fn rename(mut self, on: bool) -> Self. Rename has its key.
    • pub const fn pages(mut self, on: bool) -> Self. Ctrl+Tab switches pages.
    • pub const fn nudge(mut self, on: bool) -> Self. Arrows are nudges, not moves.
    • pub const fn document(mut self, on: bool) -> Self. Cmd (Ctrl off macOS) turns the page moves sideways: a document canvas.
    • pub const fn type_ahead(mut self, on: bool) -> Self. Typed letters are delivered as text.
    • pub const fn digits(mut self, on: bool) -> Self. Typed digits are delivered as digits.
    • pub const fn value(mut self, on: bool) -> Self. Alt with an arrow is a fine move.
    • pub const fn moves(mut self, on: bool) -> Self. The component acts on the moves routed to it.
    • pub const fn deletes(mut self, on: bool) -> Self. Delete and Backspace are the component's own.
    • pub const fn stacked(mut self, on: bool) -> Self. Shift with Left or Right is no move.
    • pub const fn owner_arrows(mut self, on: bool) -> Self. The arrow keys are the enclosing component's, not this role's moves.
    • pub const fn home_row(mut self, row: usize) -> Self. Ctrl or Cmd with Home goes to item row.
    • pub const fn text(mut self, on: bool) -> Self. The stop is a text part.
  • craft_behavior::keys::REORDER_KEYS: pub const REORDER_KEYS: [Chord; 6]. The stacking keys (Photoshop's Bring Forward and Send Backward): Cmd+] moves the selected items one place toward the
  • craft_behavior::keys::drop_operation: pub fn drop_operation(os: Os, mods: Mods) -> DropOperation. The drop operation the held modifiers pick.
  • craft_behavior::keys::intent: pub fn intent(os: Os, key: Key, mods: Mods, role: KeyRole) -> Option<Intent>. The intent a key press has for a stop of role, if any. Enter and Space as activation are not rows:
  • craft_behavior::keys::reorder_intent: pub fn reorder_intent(key: Key, mods: Mods) -> Option<Intent>. The Intent::MoveItem a stacking key asks for, None for any other press.
  • craft_behavior::keys::split_digits: pub fn split_digits(text: &str) -> (Vec<u8>, String). Typed text split for a role that takes digits: the ASCII digits it holds, in order, and the text without them.
  • craft_behavior::keys::toward_end: pub fn toward_end(front: bool, axis: Axis) -> bool. Whether a move toward the front goes toward the end of an order laid out along axis. The front of a vertical

craft_behavior::label_column

LabelColumn: label-then-control geometry for one row.

  • craft_behavior::label_column::LabelColumn: pub struct LabelColumn { pub width: f32, pub stack_below: f32, pub gap: f32 }. The label column of a row: a width token, and the row width under which the label moves above the control.
    • pub const fn new(width: f32, stack_below: f32, gap: f32) -> Self. A column width wide that stacks below stack_below, with gap between label and control.
    • pub fn place(&self, flow: Flow, label: Vec2, label_baseline: f32, control_baseline: Option<f32>) -> LabelPlacement. Places a label of label size whose baseline is label_baseline below its top, and the control in the
  • craft_behavior::label_column::LabelPlacement: pub struct LabelPlacement { pub label: Rect, pub control: Rect, pub stacked: bool }. What LabelColumn::place decided for one row.

craft_behavior::layout_memory

The tolerance rule of layout memory: when a measured size asks for a discard pass.

  • craft_behavior::layout_memory::SizeTween: pub struct SizeTween { pub from: Vec2, pub to: Vec2, pub start: f64, pub duration: f64 }. A size that moves from one value to another over a duration, evaluated at the reader's clock.
    • pub const fn new(from: Vec2, to: Vec2, start: f64, duration: f64) -> Self. A tween from from to to that begins at start and runs for duration.
    • pub fn at(&self, now: f64) -> Vec2. The size at clock reading now, eased in and out.
    • pub fn is_done(&self, now: f64) -> bool. Whether the tween has reached its end at now.
  • craft_behavior::layout_memory::measure_tolerance: pub fn measure_tolerance(pixels_per_point: f32) -> f32. The tolerance in points under which a measured size equals the one placement used: half a physical pixel.
  • craft_behavior::layout_memory::measured_change_asks_for_discard: pub fn measured_change_asks_for_discard(recorded: Option<Vec2>, real: Vec2, changed_last_frame: bool, tolerance: f32) -> bool. Whether a measured size asks for a discard pass. recorded is the size placement used this frame

craft_behavior::monitor

The connected monitors, as every window placement reads them.

  • craft_behavior::monitor::Monitor: pub struct Monitor { pub key: MonitorKey, pub pos_px: [i32; 2], pub size_px: [u32; 2], pub scale: f32, pub work_px: Option<([i32; 2], [u32; 2])> }. A connected monitor, in physical pixels of the desktop's coordinate space (negative for a monitor left of or
    • pub fn new(key: MonitorKey, pos_px: [i32; 2], size_px: [u32; 2], scale: f32) -> Self. A monitor at pos_px of size_px pixels with scale, usable in full.
    • pub fn with_work_px(mut self, pos_px: [i32; 2], size_px: [u32; 2]) -> Self. Sets the usable area (see work_px).
    • pub fn rect_px(&self) -> Rect. The monitor's area in pixels.
    • pub fn points_at(&self, window_scale: f32) -> Rect. The monitor's area in points of a window whose scale is window_scale. Monitors that touch in pixels touch
  • craft_behavior::monitor::MonitorKey: pub struct MonitorKey { pub name: String, pub size_px: [u32; 2] }. Identifies a monitor across launches: the name the platform reports and its size in pixels.
    • pub fn new(name: impl Into<String>, size_px: [u32; 2]) -> Self. A key for the monitor called name with size size_px.

craft_behavior::motion

The motion level an animation runs at.

  • craft_behavior::motion::MotionKind: pub enum MotionKind { Fade, Travel, Loop, Blink }. What an animation is: the kind picks its row of the motion table.
  • craft_behavior::motion::MotionMode: pub enum MotionMode { Full, Reduced, Off }. How much motion the interface shows.
    • pub const fn playback(self, kind: MotionKind) -> Playback. What an animation of kind does at this mode (the motion table, 13.2).
    • pub const fn lowered_by(self, scope: MotionMode) -> MotionMode. The lower of two modes: a scope can lower the motion mode, never raise it.
  • craft_behavior::motion::Playback: pub enum Playback { Run, Snap, Still, Solid }. What an animation does under a mode.

craft_behavior::nav

The navigation core (spec 9.5): shapes, the key-free outline, stepping, roving groups, type-ahead and

  • craft_behavior::nav::Arrows: pub enum Arrows { All, Horizontal, Vertical, None }. Which arrow keys a roving group moves its lead with.
  • craft_behavior::nav::LARGE_STEPS: pub const LARGE_STEPS: f64. How many small steps one large step is, when a control sets no large step of its own.
  • craft_behavior::nav::Letters: pub enum Letters { None, TypeAhead }. Whether a roving group matches typed letters to entries.
  • craft_behavior::nav::NavOutline: pub trait NavOutline. Positions, not keys: the key-free part of DisplayOrder.
    • fn len(&self) -> usize. The number of positions.
    • fn depth(&self, at: usize) -> usize. The nesting depth of the position, 0 for a root.
    • fn has_children(&self, at: usize) -> bool. Whether the position has children.
    • fn open(&self, at: usize) -> bool. Whether the position's children show.
    • fn is_section(&self, at: usize) -> bool. Whether the position is a section header, which a move skips.
    • fn enabled(&self, at: usize) -> bool. Whether the position can take the lead.
    • fn row_len(&self, _row: usize) -> Option<usize>. RaggedGrid: the number of positions in row; rows hold consecutive positions. None past the last row.
    • fn columns(&self) -> usize. Cell: the cells of every position (a row of a sheet).
    • fn first_column(&self) -> Option<usize>. WrappedGrid: the column of position 0 when the grid has blank cells before it (the leading days of a
    • fn rect(&self, _at: usize) -> Option<Rect>. Spatial: where the position sits, in any one coordinate space.
    • fn is_empty(&self) -> bool. Whether there are no positions.
  • craft_behavior::nav::NavShape: pub enum NavShape { Flat, Tree, WrappedGrid { columns: usize }, BoundedGrid { columns: usize }, RaggedGrid, Cell, Spatial }. The geometry a collection's keyboard navigation follows.
    • pub const fn wrapped_grid(columns: usize) -> Self. Equal-width cells that wrap at columns.
    • pub const fn bounded_grid(columns: usize) -> Self. Equal-width cells in columns columns whose Left and Right stop at the row ends.
  • craft_behavior::nav::NavState: pub struct NavState { pub lead: Option<usize>, pub anchor: Option<usize>, pub page: usize, pub wrap: bool, pub column: usize }. Where a navigation stands between moves.
    • pub const fn new() -> Self. A state with no lead, a page of ten and no wrap.
    • pub const fn at(lead: usize) -> Self. A state at lead.
    • pub const fn page(mut self, rows: usize) -> Self. Sets the page size.
    • pub const fn wrap(mut self, on: bool) -> Self. Sets whether moves wrap.
    • pub const fn column(mut self, column: usize) -> Self. Sets the lead cell's column.
  • craft_behavior::nav::NavStep: pub enum NavStep { Stay, Moved(usize), Expand(usize), Collapse(usize), Column(usize), Unhandled }. What one move did.
  • craft_behavior::nav::Roving: pub struct Roving { pub shape: NavShape, pub wrap: bool, pub home_end: bool, pub page: Option<usize>, pub letters: Letters, pub arrows: Arrows, pub first_column: Option<usize>, pub hands_back: bool, pub no_lead: bool, pub keeps_lead_moves: bool }. A roving group's rules: one Tab stop whose members take moves.
    • pub const fn new(shape: NavShape) -> Roving. A group of shape with Home and End, no wrap, no paging and no letters.
    • pub const fn wrap(mut self, on: bool) -> Self. Whether moves wrap.
    • pub const fn home_end(mut self, on: bool) -> Self. Whether Home and End move to the ends.
    • pub const fn page(mut self, rows: Option<usize>) -> Self. Rows a Page key covers.
    • pub const fn letters(mut self, letters: Letters) -> Self. Whether letters pick entries.
    • pub const fn arrows(mut self, arrows: Arrows) -> Self. The arrows the group takes.
    • pub const fn first_column(mut self, column: usize) -> Self. The column of the first member of a wrapped grid with column blank cells before it: Up and Down keep the
    • pub const fn hands_back(mut self) -> Self. A move the group cannot make reaches the owning component, which may page or change what the group shows.
    • pub const fn keeps_lead_moves(mut self) -> Self. Left and Right with the lead modifier reach the focused member.
    • pub const fn no_lead(mut self, on: bool) -> Self. Whether the focused member is no lead: the next move starts at an end, as from a group with no lead.
    • pub const fn state(&self, lead: Option<usize>) -> NavState. The state a step over this group starts from, at lead, or from no lead when the group has none.
    • pub const fn takes(&self, mv: NavMove, mods: MoveMods) -> bool. Whether the group handles mv with mods: Page moves only with a page size and without lead (on a document
  • craft_behavior::nav::STEP_SHARE: pub const STEP_SHARE: f64. The share of a value's span that one small step is, when a control sets no step.
  • craft_behavior::nav::StepResult: pub enum StepResult { Set(f64), Ignored }. What a single-value move does.
  • craft_behavior::nav::TypeAhead: pub struct TypeAhead. Typed letters of the last second as one prefix.
    • pub const fn new() -> Self. An empty buffer.
    • pub fn push(&mut self, letter: char, now: f64) -> &str. Adds letter typed at now seconds and returns the prefix.
    • pub fn pick<'a>(prefix: &str, from: Option<usize>, len: usize, label: impl Fn(usize) -> std::borrow::Cow<'a, str>) -> Option<usize>. The entry a prefix picks: the first match from the position after from (from from itself when the
  • craft_behavior::nav::ValueAxes: pub enum ValueAxes { Horizontal, Vertical, Both }. The axes a single-value control reads moves on.
  • craft_behavior::nav::ValueSteps: pub struct ValueSteps { pub value: f64, pub min: f64, pub max: f64, pub small: f64, pub large: f64, pub fine: f64, pub notch: f64 }. The value and steps of a single-value control.
    • pub const fn new(value: f64, min: f64, max: f64, small: f64, large: f64) -> Self. Steps over min..=max from value. The fine step is small / LARGE_STEPS and a wheel notch is small.
    • pub const fn fine(mut self, fine: f64) -> Self. The same steps with an Alt arrow of fine.
    • pub const fn notch(mut self, notch: f64) -> Self. The same steps with a wheel notch of notch.
  • craft_behavior::nav::lead_step: pub const fn lead_step(mv: NavMove, mods: MoveMods) -> Option<NavMove>. The step Left or Right with the lead modifier makes, physical as the arrows are: Ctrl+Left and Ctrl+Right (Back
  • craft_behavior::nav::snap_to_step: pub fn snap_to_step(value: f64, step: f64, origin: f64, range: RangeInclusive<f64>) -> f64. value clamped to range, then on the nearest of the stops origin + k * step and the ends of range; a tie
  • craft_behavior::nav::step: pub fn step(shape: NavShape, outline: &dyn NavOutline, state: &mut NavState, mv: NavMove, mods: MoveMods) -> NavStep. Steps the lead of a navigation of shape over outline by mv. mods.extend keeps the anchor at the
  • craft_behavior::nav::step_until_changed: pub fn step_until_changed<T: PartialEq + Copy>(from: T, step: impl Fn(T) -> T, same: impl Fn(T) -> bool) -> T. The value step reaches from from, stepped again while a step still moves it and same says the value is the
  • craft_behavior::nav::step_value: pub fn step_value(steps: &ValueSteps, axes: ValueAxes, mv: NavMove, mods: MoveMods) -> StepResult. Maps a move to the new value of a slider, dial, rating, resize handle or colour pad. Forward, Up and
  • craft_behavior::nav::wheel_step: pub fn wheel_step(steps: &ValueSteps, axes: ValueAxes, wheel: &Wheel, rtl: bool) -> StepResult. Maps a wheel event to the new value of a single-value control: one notch per event, up for positive scroll.

craft_behavior::one_press

The one-press-per-pass rule: a pass carries at most one press, as its last pointer event.

  • craft_behavior::one_press::split_after_first_press: pub fn split_after_first_press<E>(mut events: Vec<E>, is_press: impl Fn(&E) -> bool) -> (Vec<E>, Vec<E>). Splits events after the first press. The first part is what this pass receives, up to and including the

craft_behavior::overlay

place: where an overlay of a given content size goes around its anchor.

  • craft_behavior::overlay::Align: pub enum Align { Start, Center, End }. How the overlay lines up with the anchor along the edge it hangs from.
  • craft_behavior::overlay::MinWidth: pub enum MinWidth { None, Anchor, Points(f32) }. The narrowest an overlay may be.
    • pub fn points(self, anchor_width: f32) -> f32. The width in points, given the anchor's width.
  • craft_behavior::overlay::PlaceRequest: pub struct PlaceRequest { pub anchor: Rect, pub size: Vec2, pub side: Side, pub align: Align, pub rtl: bool, pub gap: f32, pub min_width: MinWidth, pub bounds: Rect, pub kept: Option<Side> }. What place reads.
    • pub const fn new(anchor: Rect, size: Vec2, bounds: Rect) -> Self. A request for size around anchor inside bounds: below, aligned to the start, no gap, free width.
    • pub const fn size(mut self, size: Vec2) -> Self. Sets the content size.
    • pub const fn side(mut self, side: Side) -> Self. Sets the preferred side.
    • pub const fn align(mut self, align: Align) -> Self. Sets the alignment.
    • pub const fn rtl(mut self, rtl: bool) -> Self. Sets the reading direction.
    • pub const fn gap(mut self, gap: f32) -> Self. Sets the gap.
    • pub const fn min_width(mut self, min_width: MinWidth) -> Self. Sets the narrowest width.
    • pub const fn kept(mut self, side: Option<Side>) -> Self. Keeps side instead of flipping.
  • craft_behavior::overlay::Placement: pub struct Placement { pub rect: Rect, pub side: Side }. Where place put the overlay.
  • craft_behavior::overlay::Side: pub enum Side { Below, Above, Start, End }. The side of the anchor an overlay prefers. Start and End follow the reading direction.
  • craft_behavior::overlay::place: pub fn place(request: &PlaceRequest) -> Placement. Places an overlay: the preferred side unless the other has more room and the content does not fit, shifted to

craft_behavior::part

Part keys and part references: the one name for a part in focus, style, results, sub-nodes and decision records.

  • craft_behavior::part::PartKey: pub struct PartKey. The key of a part, declared as a const by the component that owns it.
    • pub const fn new(name: &'static str) -> PartKey. A key named name; the name is unique within one component.
    • pub const CELL: PartKey. A cell of a sheet row: CELL.at(column). The item step writes the cell's SELECTED and LEAD flags into
    • pub const fn name(self) -> &'static str. The name the key was declared with.
    • pub const fn at(self, i: u64) -> PartRef. One of a repeated part: POINT.at(id). i is a stable sub-key, an entity id where the repeats
  • craft_behavior::part::PartRef: pub struct PartRef { pub key: PartKey, pub index: Option<u64> }. A part's key with an optional index.

craft_behavior::pixel_size

A size in whole pixels.

  • craft_behavior::pixel_size::PixelSize: pub struct PixelSize { pub width: u32, pub height: u32 }. The size of an image or document in whole pixels; PixelSize::new builds one.
    • pub const fn new(width: u32, height: u32) -> Self. A size of width by height pixels.

craft_behavior::placement

Where windows go on the desktop: where a saved window opens ([place]), which monitor a window is on, and where

  • craft_behavior::placement::Defaults: pub struct Defaults { pub size: [f32; 2], pub min: [f32; 2], pub screen_room: [f32; 2], pub restore_fullscreen: bool, pub no_position: bool }. What the app wants when nothing (usable) is saved, and how the platform behaves.
    • pub fn new(size: [f32; 2], min: [f32; 2]) -> Self. Defaults for a first window of size points and a minimum of min points.
    • pub fn with_screen_room(mut self, room: [f32; 2]) -> Self. Set the room a monitor loses to the taskbar, Dock or menu bar.
    • pub fn with_restore_fullscreen(mut self, on: bool) -> Self. Set whether full screen is restored.
    • pub fn with_no_position(mut self, on: bool) -> Self. Set whether the platform hides window positions.
  • craft_behavior::placement::NormalRect: pub struct NormalRect { pub pos: [f32; 2], pub size: [f32; 2] }. A rectangle in logical points at zoom 1: top-left corner and size.
  • craft_behavior::placement::Placement: pub struct Placement { pub normal: NormalRect, pub position_px: Option<[i32; 2]>, pub scale: f32, pub zoom: f32, pub maximized: bool, pub fullscreen: bool, pub monitor: Option<MonitorKey> }. What to remember about a window, and what [place] returns for the app to open it with.
    • pub fn new(size: [f32; 2], scale: f32) -> Self. A window of size points, position unknown, on a monitor of scale, not maximized.
    • pub fn repaired(&self) -> Option<Placement>. The record with out-of-range numbers repaired, or None when its size is no size.
    • pub fn position(&self) -> Option<[f32; 2]>. The outer top-left corner in desktop points at the saved scale, where the position is known.
  • craft_behavior::placement::cascade: pub fn cascade(previous: Rect, size: Vec2, bounds: Rect, step: f32) -> Rect. Where a window of size opens after the one at previous: one step right and down. An axis on which that
  • craft_behavior::placement::cascade_rects: pub fn cascade_rects(area: Rect, size: Vec2, n: usize, step: f32) -> Vec<Rect>. n windows of size in a cascade inside area: the first at its top left, each next one [cascade]d from the
  • craft_behavior::placement::monitor_of: pub fn monitor_of(monitors: &[Monitor], window_px: Rect) -> Option<&Monitor>. The monitor the window at window_px (desktop pixels) is on: the one showing most of it or, when none shows it,
  • craft_behavior::placement::place: pub fn place(saved: Option<&Placement>, monitors: &[Monitor], home: Option<usize>, d: &Defaults) -> Placement. Where a window opens: saved kept on a connected monitor, else the default size on home

craft_behavior::press

Pointer values and the press lifecycle (8.1, 8.2), egui-free: the runtime converts egui's events once per

  • craft_behavior::press::Buttons: pub struct Buttons: u8 (flag set). The pointer buttons held.
    • pub const fn of(button: PointerButton) -> Buttons. The flag of one button.
  • craft_behavior::press::MULTI_CLICK_TIME: pub const MULTI_CLICK_TIME: f64. The longest gap between presses that still count as one multi-click, in seconds.
  • craft_behavior::press::MultiTouch: pub struct MultiTouch { pub translation: Vec2, pub zoom: f32, pub rotation: f32, pub center: Pos2 }. A two-finger gesture.
    • pub const fn new(translation: Vec2, zoom: f32, rotation: f32, center: Pos2) -> Self. A gesture around center.
  • craft_behavior::press::PassInput: pub struct PassInput<'a> { pub events: &'a [PointerEvent], pub slop: f32, pub pos: Pos2, pub delta: Vec2, pub held: bool, pub cancel: Option<PressCancel> }. What the machine reads of one pass.
    • pub const fn new(events: &'a [PointerEvent], slop: f32, pos: Pos2, held: bool) -> Self. A pass with these events, no movement and no cancel.
    • pub const fn delta(mut self, delta: Vec2) -> Self. The pointer movement of the pass.
    • pub const fn cancel(mut self, cancel: Option<PressCancel>) -> Self. A reason the captured press ends now.
  • craft_behavior::press::PointerButton: pub enum PointerButton { Primary, Secondary, Middle, Extra1, Extra2 }. A pointer button.
  • craft_behavior::press::PointerEvent: pub enum PointerEvent { Moved(Pos2), Pressed { button: PointerButton, pos: Pos2, time: f64, clicks: u32 }, Released { button: PointerButton, pos: Pos2 }, Gone }. A button event of one pass, in the order it arrived. The press lifecycle follows the primary button and the
    • pub const fn pressed(pos: Pos2, time: f64, clicks: u32) -> Self. The primary button going down at pos, time, as the clicksth press in a row.
    • pub const fn released(pos: Pos2) -> Self. The primary button going up at pos.
    • pub const fn pressed_by(button: PointerButton, pos: Pos2, time: f64, clicks: u32) -> Self. button going down at pos, time, as the clicksth press in a row.
    • pub const fn released_by(button: PointerButton, pos: Pos2) -> Self. button going up at pos.
  • craft_behavior::press::PointerKind: pub enum PointerKind { Mouse, Pen, Touch }. What kind of device the pointer is.
  • craft_behavior::press::PointerSample: pub struct PointerSample { pub pressure: f32, pub tilt: [f32; 2], pub rotation: f32, pub eraser: bool }. Pressure and tilt of the current contact.
    • pub const fn new(pressure: f32) -> Self. A sample with no tilt or rotation.
  • craft_behavior::press::PressCancel: pub enum PressCancel { Escape, FocusLost, Disabled, Removed }. Why a captured press ended without a release.
  • craft_behavior::press::PressMachine: pub struct PressMachine<T>. The press lifecycle of one root: the press winner it picked, kept until release or cancel.
    • pub const fn new() -> Self. A machine with no press.
    • pub fn target(&self) -> Option<T>. The target of the open press.
    • pub fn button(&self) -> Option<PointerButton>. The button of the open press.
    • pub fn dragging(&self) -> bool. Whether a drag holds the pointer.
    • pub fn step(&mut self, input: PassInput<'_>, mut pick: impl FnMut(Pos2) -> Option<(T, Sense)>) -> PressStep<T>. Runs one pass. pick chooses the press winner and what it senses at a press position; it returns None
  • craft_behavior::press::PressPhase: pub enum PressPhase { Idle, Hover, Down { start: PressStart }, Held { start: PressStart }, DragStart { start: PressStart, pos: Pos2 }, Drag { start: PressStart, pos: Pos2, delta: Vec2 }, Release { start: PressStart, pos: Pos2, click: bool }, Cancel { start: PressStart, reason: PressCancel } }. One part's press state in one pass.
    • pub const fn is_press(&self) -> bool. A press is in progress or just ended: not Idle or Hover.
    • pub const fn start(&self) -> Option<PressStart>. The press the phase belongs to.
    • pub const fn button_down(&self) -> bool. Whether the button is down: Down, Held, DragStart or Drag.
    • pub const fn is_drag(&self) -> bool. Whether the phase is a drag in progress.
    • pub const fn is_click(&self) -> bool. Whether the phase is a click: a release within slop.
    • pub fn mapped(self, point: impl Fn(Pos2) -> Pos2, delta: impl Fn(Vec2) -> Vec2) -> PressPhase. The phase with its positions mapped by point and its drag delta by delta, for a part whose space
  • craft_behavior::press::PressStart: pub struct PressStart { pub origin: Pos2, pub button: PointerButton, pub time: f64, pub clicks: u32 }. Where and when a press began.
    • pub const fn new(origin: Pos2, button: PointerButton, time: f64, clicks: u32) -> Self. A press of button at origin.
  • craft_behavior::press::PressState: pub struct PressState { pub phase: PressPhase, pub mods: Mods, pub sample: Option<PointerSample>, pub captured: bool }. A part's phase, the modifiers held, the pen sample and whether it holds the pointer.
    • pub const IDLE: PressState. A part with no press history.
    • pub const fn new(phase: PressPhase) -> Self. A state in phase with no modifiers, sample or capture.
    • pub const fn mods(mut self, mods: Mods) -> Self. The modifiers held.
    • pub const fn sample(mut self, sample: Option<PointerSample>) -> Self. The pen sample of the contact.
    • pub const fn captured(mut self, captured: bool) -> Self. Whether a drag holds the pointer.
    • pub const fn double_pressed(&self) -> bool. Whether the phase is the Down of the second press of a double click: true once, false while the button is
  • craft_behavior::press::PressStep: pub struct PressStep<T> { pub target: Option<T>, pub phase: Option<PressPhase>, pub dragging: bool, pub activated: Option<T> }. What one pass did to the press.
  • craft_behavior::press::count_clicks: pub fn count_clicks(previous: Option<(Pos2, f64, u32)>, pos: Pos2, time: f64, slop: f32) -> u32. The click count of a press at pos and time, given the previous press (pos, time, clicks): one more when

craft_behavior::quantity

quantity::Reader: the one number and unit parser (18.3): locale digits, unit spellings, expressions and

  • craft_behavior::quantity::Reader: pub struct Reader. Reads numbers, expressions and unit quantities written in one locale.
    • pub fn new() -> Self. A reader for plain numbers written with . as the decimal separator.
    • pub fn decimal(mut self, decimal: char) -> Self. The decimal separator.
    • pub fn group(mut self, group: char) -> Self. The digit-group separator, which the reader skips between digits.
    • pub fn unit(mut self, spelling: &str, factor: f64) -> Self. A unit spelling (case-insensitive; letters or the symbols %, °, ×) and its factor to the base unit.
    • pub fn unit_tagged(mut self, spelling: &str, factor: f64, tag: u32) -> Self. Like [Reader::unit], with a tag that [Reader::read_tagged] returns when the text names this spelling.
    • pub fn decimal_separator(&self) -> char. The decimal separator the reader reads and writes.
    • pub fn read(&self, text: &str, start: Option<f64>) -> Result<f64, NotAValue>. The value of text. start is the value relative input applies to.
    • pub fn read_tagged(&self, text: &str, start: Option<f64>) -> Result<(f64, Option<u32>), NotAValue>. The value of text and the tag of the unit its last quantity named (None for a bare number or an untagged
  • craft_behavior::quantity::is_unit_spelling: pub fn is_unit_spelling(spelling: &str) -> bool. Whether spelling can be registered with [Reader::unit]: letters and unit symbols only, so the reader can

craft_behavior::role_rule

RoleRule: the fields each AccessKit role requires (spec 12.3).

  • craft_behavior::role_rule::GridFacts: pub struct GridFacts { pub row_index: bool, pub row_count: bool, pub column_index: bool, pub column_count: bool }. Which of a grid node's indexes and counts it carries.
    • pub const fn new() -> Self. A node that carries none of them.
    • pub const fn row_index(mut self, known: bool) -> Self. The node knows its row index.
    • pub const fn row_count(mut self, known: bool) -> Self. The node knows the number of rows.
    • pub const fn column_index(mut self, known: bool) -> Self. The node knows its column index.
    • pub const fn column_count(mut self, known: bool) -> Self. The node knows the number of columns.
  • craft_behavior::role_rule::RoleRule: pub struct RoleRule<'a> { pub role: Role, pub named: bool, pub range: Option<&'a RangeInclusive<f64>>, pub positioned: bool, pub leveled: bool, pub expanded: Option<bool>, pub controls: bool, pub grid: GridFacts }. What a node carries, as far as the rules read it.
    • pub const fn new(role: Role) -> Self. A node of role that carries nothing yet.
    • pub const fn range(mut self, range: Option<&'a RangeInclusive<f64>>) -> Self. The node's numeric range.
    • pub const fn positioned(mut self, positioned: bool) -> Self. The node knows its place in a set.
    • pub const fn leveled(mut self, leveled: bool) -> Self. The node has a heading level or tree depth.
    • pub const fn expanded(mut self, expanded: Option<bool>) -> Self. The node's expanded state.
    • pub const fn controls(mut self, controls: bool) -> Self. The node controls another node.
    • pub const fn grid(mut self, grid: GridFacts) -> Self. The indexes and counts the node carries.
  • craft_behavior::role_rule::is_checkable: pub fn is_checkable(role: Role) -> bool. Roles that are checked or unchecked: a node of one always carries a toggled state.
  • craft_behavior::role_rule::is_selectable: pub fn is_selectable(role: Role) -> bool. Roles that are selected or not: a node of one always carries a selected state.
  • craft_behavior::role_rule::role_violations: pub fn role_violations(rule: &RoleRule<'_>) -> Vec<&'static str>. The rules rule breaks, each as a short phrase.

craft_behavior::scroll

Scroll positions and the range a scroll part shows.

  • craft_behavior::scroll::ScrollPos: pub struct ScrollPos { pub x: f64, pub y: f64 }. Offsets and extents in content units. They are f64 so a sheet of a million rows scrolls exactly.
  • craft_behavior::scroll::ScrollSpan: pub struct ScrollSpan { pub content: Range<f64>, pub visible: Range<f64>, pub resize_ends: bool }. The range a scroll part shows. content is what the part's track stands for (it may start below zero
    • pub const fn new(content: Range<f64>, visible: Range<f64>) -> ScrollSpan. A span whose thumb ends do not resize.
    • pub const fn resize_ends(mut self, on: bool) -> ScrollSpan. Lets the thumb ends change the visible length.
  • craft_behavior::scroll::drag: pub fn drag(span: &ScrollSpan, track: f32, min_thumb: f32, delta: f32) -> Range<f64>. The visible range after the thumb moved delta points along the track, kept inside the content range.
  • craft_behavior::scroll::jump: pub fn jump(span: &ScrollSpan, mv: NavMove) -> Option<Range<f64>>. The visible range after a navigation move that scrolls: a page up or down, or to the start or the end of the
  • craft_behavior::scroll::page: pub fn page(span: &ScrollSpan, toward_end: bool) -> Range<f64>. The visible range one visible length further toward the end (or the start), kept inside the content range.
  • craft_behavior::scroll::thumb: pub fn thumb(span: &ScrollSpan, track: f32, min_thumb: f32) -> (f32, f32). The thumb of span on a track track points long: its start along the track and its length, at least

craft_behavior::selection

Selection models: what a collection's selection holds and how a change applies to it.

  • craft_behavior::selection::CellAt: pub struct CellAt<K> { pub row: K, pub column: u32 }. A cell: its row key and its column position. CellAt<u32> is a cell by position.
    • pub fn new(row: K, column: u32) -> Self. The cell of row at column position column.
  • craft_behavior::selection::CellRange: pub struct CellRange<K> { pub first: K, pub last: K, pub columns: Range<u32>, pub lead_column: u32 }. A rectangle of cells: the rows from first to last in the display order (either may come first), the column
    • pub fn new(first: K, last: K, columns: Range<u32>, lead_column: u32) -> Self. The cells of the rows from first to last in columns, with the lead cell in lead_column. A range has at
    • pub fn cells(from: CellAt<K>, to: CellAt<K>) -> Self. The rectangle from the anchor cell from to the lead cell to, whichever way round they lie.
    • pub fn cell(c: CellAt<u32>) -> Self. One cell.
    • pub fn contains(&self, c: CellAt<u32>) -> bool. Whether c lies in the range.
    • pub fn rows(&self) -> RangeInclusive<u32>. The rows the range spans.
    • pub fn column_span(&self) -> RangeInclusive<u32>. The columns the range spans.
    • pub fn intersects(&self, other: &Self) -> bool. Whether the two ranges share a cell.
    • pub fn union(&self, other: &Self) -> Self. The smallest range holding both.
    • pub fn covering_merges(self, merges: &[CellRange<u32>]) -> Self. The range grown until no merged cell (merges: each merge's range) crosses its edge, as Excel, InDesign and
  • craft_behavior::selection::CellSelection: pub struct CellSelection<K>. The cell selection of a sheet or table: ranges of cells, the active cell, the anchor and the cells toggled
    • pub fn ranges(&self) -> &[CellRange<K>]. The selected ranges, in the order they were added.
    • pub fn current(&self) -> Option<&CellRange<K>>. The range Shift extends: the last one added, until Enter or Tab moves into another.
    • pub fn active(&self) -> Option<&CellAt<K>>. The active cell: the one an entry goes into.
    • pub fn anchor_cell(&self) -> Option<&CellAt<K>>. The cell of the current range that Shift extends from.
    • pub fn toggled(&self) -> &[CellAt<K>]. The cells taken out of the ranges.
    • pub fn cell(c: CellAt<K>) -> Self. One cell, active and the anchor. A cell inside a merge selects the merge through select instead.
    • pub fn range(r: CellRange<K>) -> Self. One range with its first row and first column active and the anchor.
    • pub fn from_ranges(ranges: Vec<CellRange<K>>, active: CellAt<K>) -> Option<Self>. Several ranges with active in the last one, which is the current range, and the anchor at active. None
    • pub fn bounds(&self, space: &CellSpace<'_, K>) -> Option<CellRange<u32>>. The smallest range holding every selected range, by position; None for the empty selection.
    • pub fn head(&self, space: &CellSpace<'_, K>) -> Option<CellAt<u32>>. The corner of the current range opposite the anchor: the end Shift+arrows move; None for the empty
    • pub fn select(&mut self, c: CellAt<K>, space: &CellSpace<'_, K>) -> bool. A click, or an arrow's landing cell: c alone (its merged cell whole, the active cell at the merge's
    • pub fn select_range(&mut self, range: CellRange<K>, space: &CellSpace<'_, K>) -> bool. A header click, a header drag or Select All: range alone, covered over merges unless it is whole lines
    • pub fn extend_to(&mut self, c: CellAt<K>, space: &CellSpace<'_, K>) -> bool. Shift+click and a drag: the current range runs from the anchor to c, covered over merges; the active cell
    • pub fn add(&mut self, c: CellAt<K>, space: &CellSpace<'_, K>) -> bool. Cmd+click (Ctrl+click) on a cell no range holds: a new range at c (its merged cell whole) after the others;
    • pub fn add_range(&mut self, range: CellRange<K>, space: &CellSpace<'_, K>) -> bool. Cmd+click (Ctrl+click) on a row or column header: range joins as a new range after the others, covered over
    • pub fn extend_current(&mut self, range: CellRange<K>, space: &CellSpace<'_, K>) -> bool. Shift+click on a header and a drag over the headers: the current range becomes range, covered as
    • pub fn toggle(&mut self, c: CellAt<K>, space: &CellSpace<'_, K>) -> bool. Cmd+click (Ctrl+click) on any cell: a cell a range holds is taken out of the selection (and joins it again
    • pub fn step(&mut self, direction: CellDirection, space: &CellSpace<'_, K>) -> bool. An arrow: the selection collapses to the active cell's neighbour toward direction
    • pub fn change(&self) -> SelectionChange<K>. The change that reports this selection: [SelectionChange::Cells] when one range says it (the anchor cell and
  • craft_behavior::selection::RowAt: pub struct RowAt<'a, K> { pub key: &'a K, pub at: usize, pub order: &'a dyn DisplayOrder<K> }. A row as the item step reads it: its key, its position and the order that places other keys. A rectangle of
    • pub fn new(key: &'a K, at: usize, order: &'a dyn DisplayOrder<K>) -> Self. The row key at position at of order.
  • craft_behavior::selection::Selection: pub struct Selection<K> { pub items: Vec<K>, pub lead: Option<K>, pub anchor: Option<K> }. A set of keys with a lead and an anchor.
    • pub fn new(items: Vec<K>, lead: Option<K>, anchor: Option<K>) -> Self. A selection of items with lead and anchor.
    • pub fn contains(&self, key: &K) -> bool. Whether key is selected.
    • pub fn single(key: K) -> Self. A selection of key alone, which is also its lead and its anchor.
  • craft_behavior::selection::SelectionChange: pub enum SelectionChange<K> { Set(Vec<K>), Toggle(K), Clear, Cells(CellRange<K>), CellSet(Box<CellSelection<K>>) }. A change to a selection, as a collection reports it.
  • craft_behavior::selection::SelectionModel: pub trait SelectionModel<K>: Value + Default. The selection a collection reads and the app owns.
    • fn contains(&self, row: RowAt<'_, K>) -> bool. Whether the row row is selected.
    • fn lead(&self) -> Option<&K>. The item keyboard navigation moves.
    • fn anchor(&self) -> Option<&K>. The fixed end of a range extended with Shift.
    • fn apply(&mut self, change: SelectionChange<K>). Applies a change.
    • fn lead_column(&self) -> Option<u32>. The column position of the lead cell; None for a model of rows.
    • fn contains_cell(&self, row: RowAt<'_, K>, _column: u32) -> bool. Whether the cell of row row in column position column is selected.
    • fn cells(&self) -> Option<&CellSelection<K>>. The cell rules of a model of cells, which the item step runs on a copy over the collection's CellSpace; the
    • fn placed(&self, order: &dyn DisplayOrder<K>) -> PlacedSelection. The selection by position in order, placed once so that the reads of a pass scan no keys. The default
  • craft_behavior::selection::CellAdvance: pub enum CellAdvance { Enter, Tab }. Which key moves the active cell after an entry: Enter goes down the rows, Tab along a row.
  • craft_behavior::selection::CellDirection: pub enum CellDirection { Up, Down, Left, Right }. A move of one cell. Logical: in a right-to-left sheet the widget maps the Left arrow to
  • craft_behavior::selection::PlacedSelection: pub struct PlacedSelection. The selected cells by position in one display order: the rows and columns of each range, and the cells taken out
    • pub fn of_rows(spans: impl IntoIterator<Item = Range<usize>>) -> Self. The selected rows spans, every column of each.
    • pub fn of_cells(ranges: Vec<(Range<usize>, Range<u32>)>, mut removed: Vec<(usize, u32)>) -> Self. The ranges ranges (row positions, column positions) without the cells removed.
    • pub fn holds_row(&self, at: usize) -> bool. Whether the row at position at has a selected cell.
    • pub fn holds_cell(&self, at: usize, column: u32) -> bool. Whether the cell at row position at and column position column is selected.
    • pub fn rows(&self) -> Vec<usize>. The positions of the rows that have a selected cell, ascending.
  • craft_behavior::selection::Positions: pub struct Positions. The display order of a grid whose row keys are their positions (a sheet, a document table): key(at) == at, and
    • pub const fn new(rows: u32) -> Self. The order of rows rows.

craft_behavior::sense

The library's sense set, for a root or a part.

  • craft_behavior::sense::Sense: pub struct Sense: u16 (flag set). What a root or a part senses. The egui adapter maps the root's sense to egui's.
    • pub const PRESS: Sense. The bits that make a shape a press candidate.
    • pub const WHEELS: Sense. The bits that make a shape register a wheel taker.
    • pub const fn takes_press(self) -> bool. Whether a press can start on a shape with this sense.

craft_behavior::sizing

Proposal, Metrics and ControlMetrics: what a measure call is asked and what a style gives it to add.

  • craft_behavior::sizing::ControlMetrics: pub struct ControlMetrics { pub height: f32, pub icon: f32, pub pad_x: f32, pub gap: f32, pub field: f32, pub number: f32 }. The sizes a control takes from its ControlSize: height, icon side, horizontal padding, gap and the widths of a
    • pub fn at(size: ControlSize, height: &BySize<f32>, icon: &BySize<f32>, pad_x: &BySize<f32>, gap: &BySize<f32>, field: &BySize<f32>, number: &BySize<f32>,) -> Self. The entries of the six tables at size.
    • pub const fn metrics(&self) -> Metrics. The Metrics of a control of this height: horizontal padding, the height as the least height, the gap.
  • craft_behavior::sizing::Metrics: pub struct Metrics { pub padding: Insets, pub min_size: Vec2, pub max_width: Option<f32>, pub gap: f32, pub min_text: f32, pub ideal_width: f32, pub least_width: Option<f32> }. What the pipeline adds around a component's measured content.
    • pub const fn new() -> Self. No padding, no minimum, no wrap width.
    • pub const fn padding(mut self, padding: Insets) -> Self. Sets the padding.
    • pub const fn min_size(mut self, min_size: Vec2) -> Self. Sets the least size.
    • pub const fn max_width(mut self, width: f32) -> Self. Sets the wrap width.
    • pub const fn gap(mut self, gap: f32) -> Self. Sets the gap between content parts.
    • pub const fn min_text(mut self, width: f32) -> Self. Sets the least text width.
    • pub const fn ideal_width(mut self, width: f32) -> Self. Sets the width the component takes where its room allows.
    • pub const fn least_width(mut self, width: f32) -> Self. Sets the least width, padding included, that the least measure floors at in place of min_size's width.
  • craft_behavior::sizing::Proposal: pub enum Proposal { Ideal, Min, Width(f32), Size(Vec2) }. The question one measure call answers.

craft_behavior::typing

TypingRun<C>: the draft, rejected text, commit, cancel, escape rule and limits of a text part (18.2).

  • craft_behavior::typing::EditRun: pub struct EditRun<V> { pub start: V, pub draft: Option<String>, pub error: Option<NotAValue>, pub rejected: Option<(String, V)>, pub composing: bool, pub gesture: GestureId }. The state a [TypingRun] keeps per text part.
    • pub fn new(start: V) -> Self. No run is open; start is the value shown.
    • pub fn is_open(&self) -> bool. A run is open.
  • craft_behavior::typing::Ended: pub enum Ended<V> { Commit(V), Rejected, Idle }. How a commit ended.
  • craft_behavior::typing::EscapeRule: pub enum EscapeRule { Restore, Clear }. What Escape does to a draft.
  • craft_behavior::typing::Escaped: pub enum Escaped<V> { Cleared(V), Restore(V), Idle }. What Escape did.
  • craft_behavior::typing::Typed: pub enum Typed<V> { Draft, Apply(V) }. What typing did to the run.
  • craft_behavior::typing::TypingRun: pub struct TypingRun<C: Codec>. The behaviour of a text part over a codec.
    • pub fn new(codec: C) -> Self. A run that applies a draft as typed when the codec says so, with no length limit.
    • pub fn live(mut self, live: bool) -> Self. Whether every parsable draft applies as typed, whatever the codec says.
    • pub fn limit(mut self, limit: usize) -> Self. The most characters a draft holds.
    • pub fn escape_rule(mut self, rule: EscapeRule) -> Self. What Escape does.
    • pub fn codec(&self) -> &C. The codec.
    • pub fn shown(&self, run: &EditRun<C::Value>, value: &C::Value) -> String. The text to show: the draft, else the value's text.
    • pub fn open(&self, run: &mut EditRun<C::Value>, start: &C::Value). Opens the run on start when none is open.
    • pub fn edit(&self, run: &mut EditRun<C::Value>, start: &C::Value, text: &str) -> Typed<C::Value>. The draft is now text: characters the codec refuses and characters past the limit drop out.
    • pub fn commit(&self, run: &mut EditRun<C::Value>) -> Ended<C::Value>. Commits the draft: a value closes the run, a draft that is no value keeps it open.
    • pub fn commit_tagged(&self, run: &mut EditRun<C::Value>) -> (Ended<C::Value>, Option<u32>). commit, with the tag of the unit the committed text named (Codec::parse_tagged).
    • pub fn cancel(&self, run: &mut EditRun<C::Value>) -> Option<C::Value>. Closes the run without a commit and returns the value from before it; None when no run was open.
    • pub fn escape(&self, run: &mut EditRun<C::Value>) -> Escaped<C::Value>. Applies the escape rule. A codec that refuses the empty text keeps the cleared draft open under

craft_behavior::value

The value core of chapter 10: the bound every value type meets, Mixed, edit events and the list a pass's events

  • craft_behavior::value::Applied: pub enum Applied { Changed, Unchanged, Restored }. What applying an event did to a value.
  • craft_behavior::value::CancelReason: pub enum CancelReason { Refused, Dismissed, Escape, Blur, Removed, HostChanged, UndoDuringGesture }. Why a gesture ended without a commit.
    • pub const fn document_moved(self) -> bool. The document changed under the gesture, so the gesture's own edits stay and a revert would also take back the
  • craft_behavior::value::EditEvent: pub enum EditEvent<T> { Begin { id: GestureId, before: Mixed<T>, label: Arc<str>, doc_key: Option<DocKey> }, Update { id: GestureId, value: T }, Commit { id: GestureId, before: Mixed<T>, after: T }, Cancel { id: GestureId, reason: CancelReason, before: Option<Mixed<T>> }, Set { before: Mixed<T>, after: T, label: Arc<str>, doc_key: Option<DocKey> } }. One step of an edit. A pass raises several; [EditEvents] holds them in order.
    • pub fn begin(id: GestureId, before: Mixed<T>, label: Arc<str>, doc_key: Option<DocKey>) -> Self. A gesture began.
    • pub fn update(id: GestureId, value: T) -> Self. A proposed value of the running gesture.
    • pub fn commit(id: GestureId, before: Mixed<T>, after: T) -> Self. The gesture committed after.
    • pub fn cancel(id: GestureId, reason: CancelReason, before: Option<Mixed<T>>) -> Self. The gesture ended without a commit.
    • pub fn set(before: Mixed<T>, after: T, label: Arc<str>, doc_key: Option<DocKey>) -> Self. A one-step change, named the way a Begin names its gesture.
    • pub fn id(&self) -> Option<GestureId>. The gesture the event belongs to; a Set belongs to none.
    • pub fn map<U>(self, f: impl Fn(T) -> U) -> EditEvent<U>. Maps the carried values and keeps the gesture.
    • pub fn filter_map<U>(self, f: impl Fn(T) -> Option<U>) -> Option<EditEvent<U>>. Maps the carried values and keeps the gesture; None when f has no value for one of them.
    • pub fn value(&self) -> Option<&T>. The value the event carries: a proposal, a commit or a set.
    • pub fn landed(&self) -> Option<&T>. The value the binding holds after the event: the carried value, or the value a cancel restores.
    • pub fn phase(&self) -> Option<GesturePhase>. Where the gesture stands after this event; a Set is not a gesture.
    • pub fn apply(&self, v: &mut T) -> Applied. Applies the event to v: a proposal, commit or set writes its value, a cancel restores the value from before
    • pub fn apply_mixed(&self, v: &mut Mixed<T>) -> Applied. Applies the event to a value that may be mixed: the written value is a concrete one.
  • craft_behavior::value::EditEvents: pub struct EditEvents<T>. The edit events of one pass, in order. push folds what loses nothing, within one gesture: a later Update,
    • pub fn new() -> Self. No events.
    • pub fn push(&mut self, event: EditEvent<T>). Adds the next event of the pass, folding it with the one before when that loses nothing.
    • pub fn is_empty(&self) -> bool. No event happened.
    • pub fn len(&self) -> usize. The number of events.
    • pub fn iter(&self) -> std::slice::Iter<'_, EditEvent<T>>. The events in order.
    • pub fn last(&self) -> Option<&EditEvent<T>>. The latest event.
    • pub fn value(&self) -> Option<&T>. The latest value the events carry: a proposal, a commit or a set.
    • pub fn landed(&self) -> Option<&T>. The value the binding holds after the events: the latest carried value, or the value a cancel restores.
    • pub fn began(&self) -> bool. A gesture began.
    • pub fn ended(&self) -> Option<&EditEvent<T>>. The Commit, Cancel or Set that ended an edit in this pass; the latest one.
    • pub fn cancel_reason(&self) -> Option<CancelReason>. Why a gesture was cancelled in this pass; the latest cancel.
    • pub fn map<U>(self, f: impl Fn(T) -> U) -> EditEvents<U>. Maps the carried values of every event.
    • pub fn filter_map<U>(self, f: impl Fn(T) -> Option<U>) -> EditEvents<U>. Maps the carried values of every event, dropping the events f has no value for.
  • craft_behavior::value::EditPolicy: pub enum EditPolicy { WriteThrough, OnCommit }. When a write-through source is written: on every proposal of a gesture or only on its commit.
  • craft_behavior::value::Gesture: pub struct Gesture<V> { pub id: GestureId, pub before: Option<Mixed<V>>, pub proposal: Option<V>, pub last_given: Option<V>, pub emitted: Option<V>, pub reported: Option<V>, pub dead: bool, pub cancel_seen: u64, pub watched: bool }. The running gesture of a value component, kept in shown memory under the component. Plain data; the pipeline
    • pub fn ended(&self, dead: bool) -> Gesture<V>. The gesture after it ended: no value, the id kept, and dead while the press that carried it is held.
    • pub fn is_running(&self) -> bool. A gesture is running.
  • craft_behavior::value::GestureId: pub struct GestureId(pub u64). Names a gesture; ids grow in the order the gestures begin.
    • pub const fn new(n: u64) -> GestureId. The id numbered n.
    • pub const fn next(self) -> GestureId. The id of the gesture after this one.
  • craft_behavior::value::GesturePhase: pub enum GesturePhase { Begin, Update, Commit, Cancel }. Where a gesture stands in one pass.
  • craft_behavior::value::Mixed: pub enum Mixed<T> { Same(T), Mixed }. A value that may differ across a multi-selection.
    • pub const fn same(&self) -> Option<&T>. The shared value, None while the items differ.
    • pub const fn or<'a>(&'a self, start: &'a T) -> &'a T. The shared value, or start while the items differ.
    • pub fn each<const N: usize>(values: [T; N]) -> [Mixed<T>; N]. Every part of values as a shared value: the per-part form of a composite value no part of which differs.
    • pub fn parts(self) -> [Mixed<T>; N]. The per-part form of a composite value: a whole Mixed binding means every part differs.
  • craft_behavior::value::Validity: pub enum Validity<T, M> { Ok, Fix(T), Warn(M), Refuse(M), Error(M) }. What a check says about a value. M is the message type: craft-ui exports the alias with its own Message.
  • craft_behavior::value::Value: pub trait Value: Clone + PartialEq + Send + Sync + 'static. What a bound value must be: cloneable, comparable and shareable across threads.

craft_behavior::value_drag

ValueDrag: the drag maths of sliders, dials, scrubbing number fields and rulers, written once (8.7).

  • craft_behavior::value_drag::DragWarp: pub struct DragWarp. The pointer warps of one drag. The OS reports the pointer at its new place a frame after a warp, so a warp
    • pub fn shift(&mut self, pos: Pos2) -> Vec2. The total warp so far, given the pointer pos of this pass. Pass it to [ValueDrag::value_shifted].
    • pub const fn pending(&self) -> bool. Whether a warp waits for the pointer to show up at its new place: no second warp starts before it does.
    • pub fn sent(&mut self, from: Pos2, by: Vec2). Records that the pointer at from was warped by by.
  • craft_behavior::value_drag::ValueDrag: pub struct ValueDrag. Turns a press into a value. Components set it as data and call [ValueDrag::value] in update.
    • pub fn absolute(track: Range<f32>, range: RangeInclusive<f64>) -> Self. The value follows the pointer on track: range.start() at track.start, range.end() at track.end.
    • pub fn relative(rate: f64, range: RangeInclusive<f64>) -> Self. The value changes by rate units per point of travel from the press. Vertical travel upwards increases it.
    • pub const fn axis(mut self, axis: Axis) -> Self. The axis the pointer travels on; the default is horizontal.
    • pub const fn fine(mut self, factor: f64) -> Self. The factor Alt (Option) applies to travel.
    • pub const fn coarse(mut self, factor: f64) -> Self. The factor Shift applies to travel. A drag sets none by default: on an absolute drag such as a slider's a
    • pub const fn warp(mut self, on: bool) -> Self. Warps the pointer to the other side of the window when the drag reaches an edge, so the drag has no end
    • pub const fn hide_cursor(mut self, on: bool) -> Self. Hides the pointer while the drag runs, as a scrub does that warps the pointer.
    • pub const fn warps(&self) -> bool. Whether the pointer warps at a window edge.
    • pub fn warp_by(&self, pos: Pos2, bounds: Rect) -> Option<Vec2>. How far to move the pointer when the drag at pos has reached an edge of bounds on the drag's axis: to
    • pub fn value(&self, start: f64, press: &PressState, rtl: bool) -> Option<f64>. The value the press gives, None while it gives none: before a drag starts, and after a cancel. start is the
    • pub fn value_shifted(&self, start: f64, press: &PressState, rtl: bool, shift: Vec2) -> Option<f64>. [ValueDrag::value] for a pointer that warped by shift in total ([DragWarp::shift]): the pointer
    • pub fn at(&self, pos: Pos2, rtl: bool) -> Option<f64>. The value at pos on an absolute drag's track, in the range: what a press there sets. None for a relative
  • craft_behavior::value_drag::wrap_value: pub fn wrap_value(value: f64, low: f64, period: f64) -> f64. value moved by whole periods into low..low + period, as a wrapping slider or dial holds it. A period that is

craft_behavior::wheel

Wheel gesture values, as craft-behavior's copy of egui's types so the wheel split is egui-free.

  • craft_behavior::wheel::Wheel: pub struct Wheel { pub scroll: Vec2, pub zoom: f32, pub mods: Mods, pub unit: WheelUnit, pub phase: WheelPhase, pub at: Option<Pos2>, pub zooms: bool }. One wheel event, or the sum of one pass's, as a taker reads it with take_wheel.
    • pub const fn new(scroll: Vec2, mods: Mods, unit: WheelUnit, phase: WheelPhase) -> Self. A scroll of scroll points with no zoom.
    • pub const fn zoom(mut self, zoom: f32) -> Self. The same gesture with zoom factor zoom.
    • pub const fn at(mut self, at: Pos2) -> Self. The same gesture with the pointer at at.
  • craft_behavior::wheel::WheelNotch: pub enum WheelNotch { Points(f32), ViewShare(f32) }. The distance one wheel line scrolls a taker.
    • pub const DEFAULT: WheelNotch. The distance of a taker that states none.
    • pub fn points(self, extent: f32) -> f32. The notch in points, for a taker whose view is extent points along the axis.
  • craft_behavior::wheel::WheelPhase: pub enum WheelPhase { Start, Move, End, Cancel }. A wheel gesture's phase.
  • craft_behavior::wheel::WheelRoom: pub struct WheelRoom { pub positive: Vec2, pub negative: Vec2 }. The scroll left in a region, in points of wheel scroll: positive is what a wheel with positive scroll can
    • pub const fn new(positive: Vec2, negative: Vec2) -> Self. A room of positive and negative points.
  • craft_behavior::wheel::WheelTaker: pub struct WheelTaker<O> { pub owner: O, pub rect: Rect, pub horizontal: bool, pub vertical: bool, pub zoom: bool, pub gated: bool, pub scrolls: bool, pub notch: WheelNotch, pub room: Option<WheelRoom>, pub zooms_view: bool }. A component that takes wheel input, as registered last pass.
    • pub const fn new(owner: O, rect: Rect) -> Self. A taker over rect that takes no axis yet.
    • pub fn for_sense(owner: O, rect: Rect, sense: Sense) -> Option<Self>. The taker a shape with sense registers, None when sense has no wheel bit: WHEEL takes both scroll
    • pub const fn zooms_view(mut self, on: bool) -> Self. Whether it is a zoom zone (WheelTaker::zooms_view).
    • pub const fn horizontal(mut self, on: bool) -> Self. Whether it takes horizontal scroll.
    • pub const fn vertical(mut self, on: bool) -> Self. Whether it takes vertical scroll.
    • pub const fn zoom(mut self, on: bool) -> Self. Whether it takes zoom.
    • pub const fn gated(mut self, on: bool) -> Self. Whether every axis needs focus or arming.
    • pub const fn notch(mut self, notch: WheelNotch) -> Self. The distance of one wheel line.
    • pub const fn scrolls(mut self, on: bool) -> Self. The taker is a scroll region (WheelTaker::scrolls).
    • pub const fn room(mut self, room: WheelRoom) -> Self. The taker's scroll room: it passes a wheel on an axis it has no room left for to the next enclosing taker.
    • pub fn points(&self, scroll: Vec2, unit: WheelUnit) -> Vec2. scroll, given in units of the device, as points of this taker's view: a line is one notch, a page is
  • craft_behavior::wheel::WheelUnit: pub enum WheelUnit { Point, Line, Page }. How far one wheel event reaches.
  • craft_behavior::wheel::split: pub fn split<O: Copy + PartialEq>(takers: &[WheelTaker<O>], at: Pos2, wheel: Wheel, focused: Option<O>, armed: Option<O>) -> Vec<(O, Wheel)>. The split rule: each axis of wheel goes to the innermost taker under at that takes it; a share no taker

craft_ui

The base of the craft UI library: runtime, style, fonts, primitives, the component contract, layout and the test

  • craft_ui::testing_registered!: macro_rules! testing_registered. Writes pub fn registered() for the invoking package: its library crate's registrations in the running binary.
  • craft_ui::InstallError: re-export of craft_ui::runtime::install::InstallError.
  • craft_ui::InstallSpec: re-export of craft_ui::runtime::install::InstallSpec.
  • craft_ui::install: re-export of craft_ui::contract::install.
  • craft_ui::words: re-export of craft_ui_macros::words (outside these crates).

craft_ui::contract

The component traits, context types, PaintUi, Looks, the pipeline and its step functions, the label, body and item steps, the mount and overlay hosts and contract::tooltip.

  • craft_ui::contract::Collection: pub trait Collection: Component + HasProps + Meta<Shape = shape::Items>. A component that shows an item per visible entry of a source.
    • type Key. The item key.
    • type ItemLayout. Kept in session memory so step 8 can hit-test against last frame's layout.
    • type Selection. The selection model.
    • type Item. The item component.
    • type ItemEvent. Events an item reports.
    • const MEMBERS: bool. Whether the items are members of the collection's run instead of runs of their own. Each visible item is then
    • fn items(&self) -> &CollectionProps. Plain data: selection mode, reorder, rename, columns.
    • fn selection(&mut self) -> Option<BindMut<'_, Self::Selection>>. The selection binding; None keeps it in session memory.
    • fn cell_space<'s>(&'s self, space: CellSpace<'s, Self::Key>) -> CellSpace<'s, Self::Key>. The grid a model of cells selects in (17.7). The item step passes the grid it knows, the source's rows and the
    • fn reveal(&self) -> Option<&Self::Key>. A one-shot request to scroll an item into view.
    • fn item_layout(&self, source: &dyn ItemSource<Self::Key>, width: f32, cx: &StyleCx<'_>) -> Self::ItemLayout. The layout of source at width.
    • fn item_layout_from(&self, _previous: Option<Self::ItemLayout>, source: &dyn ItemSource<Self::Key>, width: f32, _item: Option<Vec2>, cx: &StyleCx<'_>,) -> Self::ItemLayout. The layout of source at width, given the layout of the last pass. An implementor may reuse previous
    • fn measures_items(&self) -> bool. Whether the layout sizes its items from their own measure: the items step measures every item at its ideal
    • fn dress_inputs(&self) -> u64. What dress reads of the collection, hashed: a kept measure of the items serves only while it is the same.
    • fn ideal_width(&self, _item: Option<Vec2>, _cx: &StyleCx<'_>) -> f32. The width the collection asks for when it takes its width from its content, over its widest row: a grid of
    • fn filtered<'s>(&self, _source: &'s dyn ItemSource<Self::Key>, _env: &crate::runtime::env::Env) -> Option<Box<dyn ItemSource<Self::Key> + 's>>. A view of source for this pass, such as the rows a filter keeps; None shows source as it is.
    • fn dress<'r>(&self, item: Self::Item<'r>, _row: &RowState) -> Self::Item<'r>. Adjusts the item the closure built for a row, from the row's state.
    • fn rename_editor(&mut self, _ui: &mut Ui, _draft: Bind<'_, String>, _label: Rect, _name: &str) -> Option<EditResponse<String>>. The rename editor at label: the label rect the renaming item reports (ItemOutput::label_rect), else its row.
    • fn rename_draft(&self, _key: &Self::Key) -> Option<String>. The text the rename field of the item key opens with; None for the item's own text.
    • fn can_rename(&self, _key: &Self::Key) -> bool. Whether the item key may be renamed; a rename request on another item does nothing.
    • fn can_drag(&self, _key: &Self::Key) -> bool. Whether the item key may be dragged (reordered, moved in a free layout, or dragged to another collection).
    • fn accepts(&self, _drag: &ListDrag<Self::Key>, _over: Option<&Self::Key>, _insert: usize) -> bool. Whether the collection's own dragged items may land before insert (a position of the display order, over is
    • fn drops(&self) -> &[DropKind<'_, Self::Key>]. What the collection takes from drags that did not start in it, in order: the first kind that takes the drag's
    • fn zooms(&self) -> bool. Whether the collection takes the zoom share of the wheel (Ctrl or Cmd with the wheel): it reports
    • fn empty_height(&self, width: f32, ui: &Ui, _cx: &StyleCx<'_>) -> f32. The height of the empty state at width: a Sizing::Content collection with no rows is this tall. The
    • fn empty(&mut self, ui: &mut Ui, cx: &mut BodyCx<'_>). The empty state at the rect the item step placed. The default shows CollectionProps::empty.
  • craft_ui::contract::Component: pub trait Component: Meta + Sized. The core trait: every UI type is a Component.
    • const ROLE: Role. The AccessKit role.
    • const ALT_ROLES: &'static [Role]. Roles access may pick per instance.
    • const INPUT: Input. How input reaches the component.
    • const OVERLAYS: bool. Whether the component hosts popups: false skips the overlay bookkeeping of steps 9, 10, 12, 15 and 16.
    • const PARTS: bool. Whether the component declares parts, a text part or an editor part: false skips the parts step (the parts
    • const STOPS: bool. Whether the component or its parts can take key focus: false skips the stop registration of step 7, except
    • const KEYS: crate::runtime::focus::KeyUse. Keys the focused component keeps from egui and the shortcut dispatcher.
    • fn keys(&self) -> crate::runtime::focus::KeyUse. The keys this instance keeps in its current state. The default is KEYS; a component whose key use depends
    • const SHOWS_LABEL: bool. Whether the component paints its label as visible text. false for a face that shows only an icon or a
    • const LABELLED_AFTER: bool. Whether the control draws only its mark and its text is the label step's, placed after it: a check box, a
    • const SINGLE_VALUE: bool. Whether the component edits one value that several selected things cannot disagree on (a colour picker's
    • const BINDS_VIEW: bool. Whether the binding is the component's view of what it shows (a time area's scroll and zoom, a navigator's
    • const DISABLED: DisabledLook. How a disabled instance looks: token states (the default), or its enabled look faded.
    • type Style. The style type.
    • type Output. Response, EditResponse<T> or a richer type.
    • fn shows_label(&self) -> bool. Whether this instance paints its label as visible text; SHOWS_LABEL unless an instance prop decides, as
    • fn paint_outset(_tokens: &crate::style::UiTokens) -> f32. How far the component paints outside its rect by design, in points (a graph node's ports sit on its edge).
    • fn style(cx: &StyleCx<'_>, key: Self::StyleKey) -> Self::Style. Pure function of the resolved context and the key.
    • fn measure(&mut self, _cx: &MeasureCx<'_, Self>) -> Vec2. Content size only; the pipeline adds padding and minimum size.
    • fn fills(&self) -> Option<craft_behavior::Axis>. The axis along which the component takes all the room the flow offers when that is more than it measured,
    • fn cut_first(&self) -> bool. Whether the content is made to be cut where it does not fit: an elided line or a path. In a row too short for
    • fn sense(&self) -> Sense. The root's sense; the shape's default unless a canvas control.
    • fn parts(&mut self, _rect: Rect, _cx: &mut PartsCx<'_, Self>). Named sub-rects: thumbs, chevrons, handles, segments and the roving groups over them.
    • fn bind(&mut self) -> Option<BindMut<'_, ValueOf<Self>>>. Value components return their binding; the same binding on every call, with no side effects.
    • fn same_value(&self, proposed: &ValueOf<Self>, host: &ValueOf<Self>) -> bool. Whether host, a value the app wrote back, is the value proposed as the component holds values: a host that
    • fn scrub(&self) -> Option<Scrub<ValueOf<Self>>>. Lets a drag on the scrub's sources (the side label, the body, a part) change the value; the pipeline runs the
    • fn scroll(&mut self) -> Option<BindMut<'_, ScrollPos>>. The scroll offset's owner when the app drives scrolling; None keeps it in session memory. The app restores a
    • fn content_env(&self, _cx: &Cx<'_, Self>, _values: &mut crate::runtime::env::AppValues). App values for content the component does not build: its body or its items. Runs once, at step 13.
    • fn update(&mut self, _cx: &mut Cx<'_, Self>). After sensing, before paint: value maths, memory, popup triggers.
    • fn overlay(&mut self, _ui: &mut OverlayUi<'_>, _cx: &mut Cx<'_, Self>). Anchored popups. Runs before flags and paint.
    • fn flags(&self) -> Flags. Value-driven flags (checked, open, invalid, busy).
    • fn activated(&self, cx: &Cx<'_, Self>) -> bool. When a bound command fires; the default is a primary click or Intent::Activate.
    • fn paint(&mut self, _ui: &mut PaintUi<'_>, _cx: &Cx<'_, Self>). Content only; surface, state fill and focus ring are painted by the pipeline.
    • fn paint_over(&mut self, _ui: &mut PaintUi<'_>, _cx: &Cx<'_, Self>). Content above the body or items.
    • fn access(&self, _access: &mut Access, _cx: &Cx<'_, Self>). Value, range, relations, sub-nodes and custom actions beyond role, label and flags.
    • fn value_text(&self, _cx: &Cx<'_, Self>) -> Option<String>. The shown value as the component words it ("40.0", "20 to 60"), which assistive technology reads and a viewer
    • fn finish(self, cx: Cx<'_, Self>) -> Self::Output. Builds the output from the finished context.
  • craft_ui::contract::Container: pub trait Container: Component + HasProps + Meta<Shape = shape::Body>. A component whose caller supplies a body.
    • fn open(&mut self) -> Option<BindMut<'_, bool>>. The open state's owner: the caller's binding. None: a session slot under the id.
    • fn header(&mut self, _ui: &mut Ui, _cx: &mut BodyCx<'_>). Fills the header region the body step laid out.
    • fn header_parts(&self, _cx: &MeasureCx<'_, Self>) -> HeaderParts. The room the container's own parts take at the edges of its header's line (a menu button, a drag band). The
    • fn controls(&mut self, _ui: &mut Ui, _cx: &mut BodyCx<'_>). Fills the header's trailing region.
    • fn footer(&mut self, _ui: &mut Ui, _cx: &mut BodyCx<'_>). Fills the footer region.
    • fn end(&mut self, _ui: &mut Ui, _cx: &mut BodyCx<'_>). Fills the end region, after the body.
    • fn closed(&mut self, _why: CloseReason). The container closed, and why: a layer's dismissal rule, a close the body or footer asked for with
    • fn placement_changed(&mut self, _change: &overlay::PlacementChange). The user moved or resized the container's layer: by the move band, a grip or the keyboard Move and Size
  • craft_ui::contract::ContentPainter: pub trait ContentPainter: Component. Implemented by the allowlisted components that paint content with a raw painter (a preview, a waveform).
  • craft_ui::contract::DisabledLook: pub enum DisabledLook { States, Faded }. How a component that is not enabled looks (Component::DISABLED). Either way it takes no input, its access node
  • craft_ui::contract::HasProps: pub trait HasProps. Written by the derive from a #[container] field, for containers and collections.
    • fn props(&self, _: Internal) -> &ContainerProps.
  • craft_ui::contract::IdSource: pub enum IdSource { Auto, Salt(IdSalt), Id(Id) }. Where an element's id comes from.
  • craft_ui::contract::Inner: pub struct Inner<O, R> { pub output: O, pub inner: Option<R>, pub settle: Option<settle::SettleAt> }. The container show output: the component's own output and the body's result.
    • pub fn settle<T>(&mut self, f: impl FnOnce(&mut SettleCx<'_>, &mut R) -> T) -> Option<T>. Runs f once, after the pass's real run, with the body's memory (keep, memory, saved, pending,
    • pub fn map_output<O2>(self, f: impl FnOnce(O) -> O2) -> Inner<O2, R>. Maps the component's own output and keeps the body's result and its settle handle.
  • craft_ui::contract::Internal: pub struct Internal. A token only craft-ui can build: the private field and pub(crate) constructor let derive output in any
  • craft_ui::contract::ItemFn: pub type ItemFn<'r, C> = dyn FnMut(&<C as Collection>::Key, &mut ItemCx<'_, 'r,<C as Collection>::Key>) -><C as Collection>::Item<'r> + 'r. The item closure of ShowCollection::show_items: one call per visible key.
  • craft_ui::contract::MAX_EXTENT: pub const MAX_EXTENT: f32. The most a component may measure on either side, in points.
  • craft_ui::contract::Meta: pub trait Meta. Written by #[derive(Component)]; never by hand.
    • type Shape. The shape: leaf, body or items.
    • type StyleKey. The instance inputs the style depends on.
    • const CANVAS_CONTROL: bool. A leaf the Canvas body shows (#[component(canvas_control)]): its default sense is empty, so a press away
    • fn style_key(&self) -> Self::StyleKey. The style key of this instance.
    • fn common(&self, _: Internal) -> &Common.
    • fn common_mut(&mut self, _: Internal) -> &mut Common.
    • fn set_sizing(&mut self, sizing: Sizing, _: Internal). Takes the caller's Props::sizing: a leaf keeps it in its Common; the derive writes a container's or a
  • craft_ui::contract::Pattern: pub trait Pattern. A type that only assembles components: a composition with no contract shape of its own (24.4).
  • craft_ui::contract::ShapeKind: pub enum ShapeKind { Leaf, Body, Items }. The shape of a component, as a value: what a registration records.
  • craft_ui::contract::Show: pub trait Show: Component + Meta<Shape = shape::Leaf> + sealed::Show. Shows a leaf.
    • fn show(self, ui: &mut Ui) -> Self::Output. Shows the component in the flow of ui.
    • fn show_at(self, ui: &mut Ui, rect: Rect) -> Self::Output. Shows the component at rect, with no allocation.
    • fn show_with_tip(self, ui: &mut Ui, tip: impl FnOnce(&mut Ui)) -> Self::Output. Shows the component with rich tooltip content from the same call.
    • fn show_at_with_tip(self, ui: &mut Ui, rect: Rect, tip: impl FnOnce(&mut Ui)) -> Self::Output. Shows the component at rect with rich tooltip content.
    • fn measure_in(&mut self, ui: &Ui, proposal: Proposal) -> Vec2. Measures without allocating: steps 1 to 5 under the id show would use next. It registers no id, opens no
  • craft_ui::contract::ShowCollection: pub trait ShowCollection: Collection + sealed::ShowCollection. Shows a collection's items.
    • fn show_items<'r>(self, ui: &mut Ui, source: &dyn ItemSource<Self::Key>, item: &mut ItemFn<'r, Self>) -> Self::Output. Shows the visible items of source, one item call each.
  • craft_ui::contract::ShowContainer: pub trait ShowContainer: Container + sealed::ShowContainer. Shows a container with its body.
    • fn show<R>(self, ui: &mut Ui, body: impl FnMut(&mut Ui, &mut BodyCx<'_>) -> R) -> Inner<Self::Output, R>. Shows the container in the flow of ui.
    • fn show_at<R>(self, ui: &mut Ui, rect: Rect, body: impl FnMut(&mut Ui, &mut BodyCx<'_>) -> R) -> Inner<Self::Output, R>. Shows the container at rect, with no allocation: a frame over a split or a layer the parent places.
    • fn show_at_taking_room<R>(self, ui: &mut Ui, rect: Rect, body: impl FnMut(&mut Ui, &mut BodyCx<'_>) -> R) -> Inner<Self::Output, R>. Shows the container at rect and takes that rect's room in the flow of ui: what is shown after it lies
    • fn measure_in<R>(&mut self, ui: &Ui, proposal: Proposal, body: impl FnMut(&mut Ui, &mut BodyCx<'_>) -> R) -> Vec2. Measures the container with body without allocating: steps 1 to 5 under the id show would use next, with
    • fn show_with_tip<R>(self, ui: &mut Ui, body: impl FnMut(&mut Ui, &mut BodyCx<'_>) -> R, tip: impl FnOnce(&mut Ui)) -> Inner<Self::Output, R>. Shows the container with rich tooltip content.
    • fn show_at_with_tip<R>(self, ui: &mut Ui, rect: Rect, body: impl FnMut(&mut Ui, &mut BodyCx<'_>) -> R, tip: impl FnOnce(&mut Ui),) -> Inner<Self::Output, R>. Shows the container at rect with rich tooltip content.
  • craft_ui::contract::ShowShape: pub trait ShowShape: sealed::ShowShape. Which show trait applies, and the shape's default sense.
    • const KIND: ShapeKind. The shape as a value.
    • const DEFAULT_SENSE: Sense. Leaf CLICK | FOCUS; body empty; items CLICK | DRAG | FOCUS | WHEEL | TAKE_FOCUS.
  • craft_ui::contract::install: pub fn install(ctx: &egui::Context, spec: crate::runtime::InstallSpec) -> Result<(), crate::runtime::InstallError>. Adds the runtime to ctx: runtime::install with the overlay host's ghost-layer painter in the end hook.
  • craft_ui::contract::Access: re-export of craft_ui::runtime::access::Access.
  • craft_ui::contract::Accessible: pub trait Accessible. Live announcements and the enclosing field label (chapter 12).
    • fn announce(&mut self, text: impl Into<String>, politeness: Politeness). Announces transient text; it is flushed at frame end as one status node and returned in FrameOutput.
    • fn field_label(&self) -> Option<FieldLabel>. The label of the enclosing field container, when the component sits in one.
  • craft_ui::contract::ActivateOn: pub enum ActivateOn { DoubleClick, Click }. The pointer gesture that activates an item.
  • craft_ui::contract::Activation: pub struct Activation { pub by_key: bool, pub mods: craft_keymap::Mods }. How a component was activated this pass.
  • craft_ui::contract::Animate: re-export of craft_ui::runtime::motion::Animate.
  • craft_ui::contract::Bind: pub struct Bind<'a, T>. The binding of a value component: a value the app owns, the check on it and the value a reset restores. The same
    • pub fn given(v: impl Into<Mixed<T>>) -> Self. A value in; every edit comes out as an event.
    • pub fn bound(v: &'a mut T) -> Self. Edits write through to v.
    • pub fn bound_mixed(v: &'a mut Mixed<T>) -> Self. Edits write through to a field that may be mixed; an edit makes it concrete.
    • pub fn kept() -> Self. No caller value: the component keeps it in session memory under its id.
    • pub fn saved(mut self, key: SaveKey) -> Self where T: Savable,. A kept value that is also saved across runs under key. The Savable bound sits here; the pipeline reaches
    • pub fn policy(mut self, policy: EditPolicy) -> Self. When a write-through source is written.
    • pub fn check(mut self, check: impl Fn(&T) -> Validity<T> + 'a) -> Self. The check on a value: Fix replaces it; Warn, Refuse and Error set the component's state, and Refuse
    • pub fn reset(mut self, default: T) -> Self. The value a reset gesture restores.
    • pub fn reborrowed(&mut self) -> Bind<'_, T>. A binding with the same source, check, policy and reset that borrows this one, so a composite can hand its
    • pub fn reborrow(&mut self) -> BindMut<'_, T>. The binding as the pipeline reads and writes it.
  • craft_ui::contract::BindMut: pub struct BindMut<'a, T>. A reborrow of a [Bind] the pipeline reads at steps 4, 11, 15 and 17. Component::bind returns it, and returns the
    • pub fn read(&self, cx: &mut impl StageAccess) -> Option<Mixed<T>>. The binding's value for code that runs no pipeline step: a given or write-through value, or the kept value
    • pub fn write(&mut self, cx: &mut impl StageAccess, event: &EditEvent<T>) -> bool. Writes event as the pipeline's apply step does: the check may replace the value (Fix) or refuse it
  • craft_ui::contract::BodyCx: pub struct BodyCx<'a> { pub id: Id, pub env: EnvView<'a>, pub resolved: &'a Resolved<'a>, pub rect: Rect, pub memory: &'a mut MemoryStage }. What a body closure and the header, footer and empty hooks read: a view over the pipeline's memory stage
    • pub fn open_url(&mut self, url: &str, new_tab: bool). Asks the platform to open url, in a new tab where the platform has tabs and new_tab is set: the opener
    • pub fn take_pick_answer(&self, ticket: craft_host::PickId) -> Option<craft_host::Picked>. The host file service's answer to the picker ticket, taken once. A measuring run gets none and leaves
    • pub fn field_message(&self) -> Option<(Message, craft_theme::variant::Tone)>. The validity message of the first control in the container's label scope, recorded last frame, with the
    • pub fn is_open(&self) -> bool. Whether the body is open.
    • pub fn open(&mut self) -> &mut bool. The open state: a title row's disclosure binds to it, and step 15 writes a change to its owner.
    • pub fn gate(&mut self) -> Option<&mut bool>. The gate's shown copy, for a container whose value is a bool: a title row's check box binds to it, and
    • pub fn gate_is_mixed(&self) -> bool. Whether the gate's value is mixed: gate then reads off, and a title row's check box shows the mixed face.
    • pub fn request_close(&mut self). Asks the container to close, as CloseReason::Requested: step 15 closes it.
    • pub fn request_close_as(&mut self, why: CloseReason). Asks the container to close and tells it why (an OK button is Activated, Enter is Enter): step 15
    • pub fn labelled<C: Show>(&mut self, ui: &mut Ui, key: impl Hash + Debug, label: Label, side: SideLabel, child: C) -> C::Output. Runs the label step (B2, 16.3) for one leaf child in the body's flow: label sits beside the child or above
    • pub fn labelled_with<C: Show, D: Show>(&mut self, ui: &mut Ui, key: impl Hash + Debug, label: Label, side: SideLabel, child: C, content: D,) -> C::Output. labelled, with content shown inside the label after its text (a sample of what the option picks). The
    • pub fn style<C: Container>(&self) -> Option<&'a C::Style>. The style of the container C whose body this is, as step 2 resolved it for this pass: the one way a body
    • pub fn gap(&self) -> Option<f32>. The gap the body's layout puts between its children (ContainerProps::body_gap), for a body that places
    • pub fn take_cancel(&mut self) -> bool. Takes the Escape of this pass that no component took: a field that clears on Escape passes it on once it
  • craft_ui::contract::BodyLayout: pub enum BodyLayout { Stack, Row { wrap: bool, align: RowAlign }, Grid { columns: Cow<'static, [ColumnWidth]> } }. How a body lays out its children, in reading order: mirrored under a right-to-left direction.
    • pub const fn stack() -> Self. Children one under another.
    • pub const fn row() -> Self. Children side by side from the start edge, with no wrap.
    • pub fn grid(columns: impl Into<Cow<'static, [ColumnWidth]>>) -> Self. Children row-major over columns: a 'static slice, or columns built in the pass.
    • pub fn wrap(self, on: bool) -> Self. A Row that wraps; any other layout is unchanged.
    • pub fn align(self, align: RowAlign) -> Self. A Row with align; any other layout is unchanged.
  • craft_ui::contract::CellWidth: pub type CellWidth = ColumnWidth. The width of a caption's cell.
  • craft_ui::contract::Collapse: pub struct Collapse { pub initially_open: bool, pub animated: bool }. Collapse configuration.
    • pub const fn new() -> Self. A collapsible body that starts open, animated.
    • pub const fn initially_open(mut self, on: bool) -> Self. Whether the body starts open.
    • pub const fn animated(mut self, on: bool) -> Self. Whether opening and closing animate.
  • craft_ui::contract::CollectionEvent: pub enum CollectionEvent<K, E> { Selection(SelectionChange<K>), LeadMoved { key: K, by: LeadSource }, Activate(K), EmptyActivated, Preview(K), ContextMenu(ContextMenuRequest<K>), CommandClick { key: K, mods: craft_keymap::Mods }, Delete(Vec<K>), Open(OpenChange<K>), Reorder(EditEvent<ReorderMove<K>>), Move(EditEvent<Vec2>), Dropped { at: DropAt<K>, op: DropOperation, payload: DropPayload }, Zoom { factor: f32, about: Pos2 }, Rename(EditEvent<Rename<K>>), Toggle(EditEvent<ToggleEdit<K>>), Column(ColumnEvent), Item(K, E) }. What a collection reports, in drawing order.
  • craft_ui::contract::CollectionProps: pub struct CollectionProps { pub select: SelectMode, pub reorder: Option<ReorderRule>, pub rename: bool, pub rename_column: Option<ColumnKey>, pub slow_click_rename: bool, pub columns: Vec<ColumnSpec>, pub sort: Option<ColumnSort>, pub empty: Option<Label>, pub activate: ActivateOn, pub striped: bool, pub allow_empty: bool, pub lead_on_open: LeadOnOpen, pub lead_follows_hover: bool, pub arrows_select: bool, pub focus_on_press: bool, pub rows_stamp: Option<u64>, pub space: SpaceAction, pub type_ahead: bool, pub arrows_wrap: bool, pub header: bool, pub digit_keys: bool, pub menu_on_click: bool, pub item_keys: ItemKeys, pub marquee: bool, pub deletable: bool, pub drag_payload: Option<DragPayload>, pub drag_count: Option<Counted>, pub natural_height: bool, pub min_rows: u16, pub max_rows: Option<u16>, pub command_click: bool, pub notch: Option<Notch>, pub overflow: Axis, pub pages: bool, pub current: Option<Arc<dyn Any + Send + Sync>> }. What a collection reads from the app: plain data. A new builder's name is added to the forwarder list in
    • pub const fn new() -> Self. Collection props with every setting at its default.
    • pub fn select(mut self, mode: SelectMode) -> Self. What can be selected.
    • pub fn reorder(mut self, rule: ReorderRule) -> Self. Items reorder by rule.
    • pub fn drag_payload<K: 'static, P: Send + Sync + 'static>(mut self, map: impl Fn(&ListDrag<K>) -> Option<P> + Send + Sync + 'static) -> Self. A row drag carries map of it, for the drop targets of type P; a row the map gives None for does not drag
    • pub const fn drag_count(mut self, count: Counted) -> Self. The drag badge reads count for the number of dragged items.
    • pub const fn pages(mut self, on: bool) -> Self. The items are pages (CollectionProps::pages).
    • pub fn rename(mut self, on: bool) -> Self. Rename runs through the collection's editor.
    • pub fn rename_column(mut self, column: ColumnKey) -> Self. A double click on column of a renamable item (rename, Collection::can_rename) opens its rename editor; the
    • pub const fn slow_click_rename(mut self, on: bool) -> Self. A slow second click on the label of the only selected item opens its rename editor.
    • pub fn columns(mut self, columns: Vec<ColumnSpec>) -> Self. The columns.
    • pub fn sort(mut self, sort: impl Into<Option<ColumnSort>>) -> Self. The column the rows are sorted by.
    • pub const fn activate(mut self, on: ActivateOn) -> Self. What activates an item with the pointer.
    • pub const fn striped(mut self, on: bool) -> Self. Odd rows carry RowState.striped.
    • pub const fn allow_empty(mut self, on: bool) -> Self. A press on the empty space below the rows empties the selection.
    • pub const fn lead_on_open(mut self, at: LeadOnOpen) -> Self. Where the lead starts.
    • pub const fn lead_follows_hover(mut self, on: bool) -> Self. The lead follows the pointer over the rows.
    • pub const fn arrows_select(mut self, on: bool) -> Self. Whether the arrow keys select the row they move the lead to.
    • pub const fn type_ahead(mut self, on: bool) -> Self. Typed letters move the lead (CollectionProps::type_ahead).
    • pub const fn arrows_wrap(mut self, on: bool) -> Self. The arrow keys wrap at the ends (CollectionProps::arrows_wrap).
    • pub const fn rows_stamp(mut self, stamp: u64) -> Self. The rows are the set stamp names; the lead starts over when the stamp changes.
    • pub const fn focus_on_press(mut self, on: bool) -> Self. A primary press moves key focus to the collection; off, it leaves focus where it is.
    • pub const fn space(mut self, action: SpaceAction) -> Self. What Space does.
    • pub const fn header(mut self, on: bool) -> Self. Whether the header row shows.
    • pub const fn digit_keys(mut self, on: bool) -> Self. Typed digits go to the collection's update as Intent::Digit.
    • pub const fn menu_on_click(mut self, on: bool) -> Self. A plain click on a row asks for its menu, as a secondary click does.
    • pub const fn item_keys(mut self, keys: ItemKeys) -> Self. Who takes the arrow keys while the collection has the key focus.
    • pub const fn marquee(mut self, on: bool) -> Self. A drag from empty space selects with a marquee.
    • pub const fn deletable(mut self, on: bool) -> Self. Delete and Backspace at the lead report the items to delete (CollectionEvent::Delete).
    • pub const fn natural_height(mut self, on: bool) -> Self. The collection takes its full content height and owns no scroll (see [CollectionProps::natural_height]).
    • pub const fn min_rows(mut self, rows: u16) -> Self. The collection is at least rows rows tall (see [CollectionProps::min_rows]).
    • pub const fn max_rows(mut self, rows: u16) -> Self. The collection shows at most rows rows and scrolls the rest (see [CollectionProps::max_rows]).
    • pub const fn command_click(mut self, on: bool) -> Self. A Cmd/Ctrl click on an item is a command, not a pick (see [CollectionProps::command_click]).
    • pub const fn notch(mut self, notch: Notch) -> Self. The distance one wheel notch scrolls the rows (see [CollectionProps::notch]).
    • pub fn wheel_notch(&self, line: f32) -> craft_behavior::WheelNotch. The wheel distance of one notch, with a text line line points high: the set notch, else the default.
    • pub const fn overflow(mut self, axis: Axis) -> Self. The axis the rows overflow along (see [CollectionProps::overflow]).
    • pub fn current<K: Send + Sync + 'static>(mut self, key: Option<K>) -> Self. The current item: Some(key) marks the item with that key, None marks none. K is the collection's key type;
    • pub fn empty(mut self, text: impl Into<Label>) -> Self. The empty-state text.
  • craft_ui::contract::CollectionResponse: pub struct CollectionResponse<K, E> { pub response: Response, pub events: Vec<CollectionEvent<K, E>>, pub visible: Range<usize>, pub shown: Vec<ShownRow<K>>, pub select: SelectMode, pub rename: bool, pub reorder: bool, pub activation_clicks: u8, pub pending_drop: Option<PendingDrop<K>> }. The output of a collection.
    • pub fn opener(&self, opener: crate::contract::ItemOpener) -> Option<&Response>. The response of the item part opener names: its click this pass and its rect. A menu or popover hangs from
  • craft_ui::contract::ColumnAlign: pub enum ColumnAlign { Start, End }. Where a column's content sits.
  • craft_ui::contract::ColumnCommands: pub enum ColumnCommands { Resize, MoveLeft, MoveRight }. The commands of a column header (17.1): resize works from the keyboard through them, and the header menu lists
    • pub const ALL: [ColumnCommands; 3]. Every header command, in menu order.
  • craft_ui::contract::ColumnEvent: pub enum ColumnEvent { Sort { key: ColumnKey, descending: bool }, Resized { key: ColumnKey, width: f32 }, Moved { key: ColumnKey, to: usize }, Shown { key: ColumnKey, shown: bool }, Unsorted, Reset }. A change to the columns.
  • craft_ui::contract::ColumnKey: re-export of craft_behavior::columns::ColumnKey.
  • craft_ui::contract::ColumnKind: pub enum ColumnKind { Content, Toggle(ToggleColumn) }. What a column's cells are.
  • craft_ui::contract::ColumnRequest: pub enum ColumnRequest { Shown(ColumnKey, bool), Reset, Command(crate::contract::ColumnCommands) }. What a pick in the header menu asks of the header, given back with Cx::column_request.
  • craft_ui::contract::ColumnSort: pub struct ColumnSort { pub key: ColumnKey, pub descending: bool }. The column the rows are sorted by and the direction: the app's value, which it changes on ColumnEvent::Sort.
    • pub const fn new(key: ColumnKey, descending: bool) -> Self. Rows sorted by key, descending when descending.
    • pub const fn ascending(key: ColumnKey) -> Self. Rows sorted by key, ascending.
    • pub const fn descending(key: ColumnKey) -> Self. Rows sorted by key, descending.
  • craft_ui::contract::ColumnSpec: pub struct ColumnSpec { pub key: ColumnKey, pub header: Label, pub width: ColumnWidth, pub resizable: bool, pub sortable: bool, pub movable: bool, pub frozen: bool, pub kind: ColumnKind, pub align: ColumnAlign, pub tabular: bool, pub first_descending: bool, pub icon: Option<craft_behavior::IconId>, pub tip: Option<Label>, pub max_share: Option<f32>, pub hideable: bool }. One column of a collection.
    • pub fn new(key: ColumnKey, header: impl Into<Label>, width: ColumnWidth) -> Self. A content column with a header and a width; the other settings off.
    • pub fn sortable(mut self) -> Self. Activating the header sorts.
    • pub fn resizable(mut self) -> Self. The user can resize the column.
    • pub fn movable(mut self) -> Self. The user can move the column.
    • pub fn frozen(mut self) -> Self. The column stays in view.
    • pub fn kind(mut self, kind: ColumnKind) -> Self. The column's cell kind.
    • pub fn align(mut self, align: ColumnAlign) -> Self. The cells' content sits at align.
    • pub fn numeric(mut self) -> Self. A column of numbers: content at the end edge, tabular figures.
    • pub fn hideable(mut self) -> Self. The user can hide the column from the header menu.
    • pub fn at_most(mut self, share: f32) -> Self. A Content column takes at most share of the collection's width.
    • pub fn tip(mut self, tip: impl Into<Label>) -> Self. The header's tooltip.
    • pub fn icon(mut self, icon: craft_behavior::IconId) -> Self. The icon the column's cells show. A cell of a column with no header text is named after it.
    • pub fn first_descending(mut self) -> Self. The first press on the header sorts descending.
  • craft_ui::contract::CommandSet: re-export of craft_ui::runtime::commands::CommandSet.
  • craft_ui::contract::Commands: re-export of craft_ui::runtime::commands::Commands.
  • craft_ui::contract::Common: pub struct Common { pub label: Label, pub tooltip: Option<Tooltip>, pub description: Option<String>, pub selected: Option<bool> }. What every component carries: the props the pipeline reads at step 1.
    • pub const fn new() -> Common. A Common with every prop unset, which the derive's constructors start from.
  • craft_ui::contract::Component: re-export of craft_ui_macros::Component (outside these crates).
  • craft_ui::contract::ContainerProps: pub struct ContainerProps { pub mount: Mount, pub surface: Option<SurfaceKind>, pub pad: Pad, pub sizing: Sizing, pub room_height: Option<f32>, pub layout: BodyLayout, pub header: Option<HeaderRegion>, pub scroll: Option<Scroll>, pub footer: Option<FooterRegion>, pub end: Option<EndRegion>, pub help: Option<Label>, pub position: Option<SetPosition>, pub focus: FocusPolicy, pub collapse: Option<Collapse>, pub body_gap: Gap, pub least_width: Option<LeastWidth>, pub edge_rule: bool, pub child_size: Option<ControlSize>, pub child_glyphs: Option<GlyphRole>, pub arena: bool, pub scroll_owner: bool, pub gates: bool, pub transform: Option<CanvasTransform>, pub theme: Option<ThemeScope>, pub command_scope: Option<CommandScope>, pub live: Option<Politeness>, pub label: Option<SideLabel>, pub roving: Option<Roving>, pub save: Option<SaveKey>, pub outer_edit: bool, pub collection_body: bool, pub label_column: bool, pub labels: Option<LabelScheme> }. What a container or collection adds to Common. A builder added here is added to the forwarder list in
    • pub const fn new() -> Self. Props with every field at its default.
    • pub fn mount(mut self, mount: Mount) -> Self. Where the container lives.
    • pub const fn surface(mut self, surface: SurfaceKind) -> Self. The surface the container paints.
    • pub const fn pad(mut self, pad: Pad) -> Self. The padding tier.
    • pub const fn sizing(mut self, sizing: Sizing) -> Self. How the size follows the content.
    • pub const fn room_height(mut self, height: f32) -> Self. The height the body offers its children in flow (room_height).
    • pub fn layout(mut self, layout: BodyLayout) -> Self. How the body lays out its children.
    • pub const fn header(mut self, header: HeaderRegion) -> Self. A header region.
    • pub const fn scroll(mut self, scroll: Scroll) -> Self. A scroll region.
    • pub const fn collection_body(mut self) -> Self. The body holds one collection that owns the scroll (a popup list): a layer's own body scroll is off, and the
    • pub const fn footer(mut self, footer: FooterRegion) -> Self. A footer region.
    • pub const fn end(mut self, end: EndRegion) -> Self. An end region at the line's end edge, outside the body's scroll region. Its stops join the body's roving
    • pub fn help(mut self, help: impl Into<Label>) -> Self. The help line the footer shows under the control column. Its text joins the description of the control the
    • pub const fn position(mut self, position: SetPosition) -> Self. The container's place in its set (n of m), reported on its node.
    • pub const fn focus(mut self, policy: FocusPolicy) -> Self. The focus scope.
    • pub const fn collapse(mut self, collapse: Collapse) -> Self. Collapse configuration.
    • pub const fn body_gap(mut self, gap: Gap) -> Self. The spacing between the children of the body.
    • pub const fn least_width(mut self, least: LeastWidth) -> Self. The least width of the content, from a size role.
    • pub const fn edge_rule(mut self, on: bool) -> Self. Draws a divider along the inner edge of the edge pane the container sits in.
    • pub const fn child_size(mut self, size: ControlSize) -> Self. A scope size for the body.
    • pub const fn child_glyphs(mut self, role: GlyphRole) -> Self. A scope glyph role for the body: a rail's buttons show its icons at the rail's side and ink.
    • pub const fn arena(mut self, on: bool) -> Self. Makes the container an arena root.
    • pub const fn scroll_owner(mut self, on: bool) -> Self. Makes the container its body's scroll owner with a view of its own (ContainerProps::scroll_owner).
    • pub const fn transform(mut self, transform: CanvasTransform) -> Self. Shows the body through transform on its own egui layer.
    • pub fn theme(mut self, theme: ThemeScope) -> Self. Token-changing values for the body.
    • pub const fn command_scope(mut self, scope: CommandScope) -> Self. Makes the container an instance of scope.
    • pub const fn live(mut self, politeness: Politeness) -> Self. A live region.
    • pub fn label(mut self, label: SideLabel) -> Self. A field label.
    • pub const fn roving(mut self, roving: Roving) -> Self. Makes the body's members one roving stop.
    • pub fn save(mut self, key: SaveKey) -> Self. Saves placement, size and open state under key.
    • pub const fn outer_edit(mut self, on: bool) -> Self. One outer gesture over the body's fields, from open to close.
    • pub const fn label_column(mut self, on: bool) -> Self. The labelled rows of the body share the widest label as one column. A nested container with its own
    • pub const fn labels(mut self, scheme: LabelScheme) -> Self. The labelled rows under the container show their labels in scheme: its regions, its body and every container
  • craft_ui::contract::ContextMenuRequest: pub struct ContextMenuRequest<K> { pub key: K, pub at: Pos2, pub column: Option<ColumnKey>, pub part: Option<PartRef> }. A request for the context menu of an item. Collections never open menus: the app does.
  • craft_ui::contract::Cx: pub struct Cx<'a, C: Component> { pub core: CxCore<'a>, pub style: &'a C::Style, pub mixed: bool }. What component code reads and calls. It derefs to [CxCore] for reading only.
    • pub fn reset_part(&self) -> Option<PartRef>. The part a reset aimed at, when it declared own_reset; update proposes the value with that part at its
    • pub fn layout_doc(&self, text: &crate::primitives::DocText<'_>) -> TextLayout. Lays document text out text.wrap wide: the call ContentPainterCx::layout and MeasureCx::layout_doc
    • pub fn open_url(&mut self, url: &str, new_tab: bool). Asks the platform to open url, in a new tab where the platform has tabs and new_tab is set.
    • pub fn join_roving(&mut self). Makes this component a member of the roving group of the body it is shown in: its stop joins the group and
    • pub fn fire(&mut self, command: impl Into<CommandRef>, source: FireSource) -> bool. Runs command as this component's own activation would, for a command that is not the component's bound
    • pub fn part_activated(&self, part: impl Into<PartRef>) -> Option<FireSource>. Where an activation of part came from this pass: Key for a keyboard activation while part is the
    • pub fn context_part(&self) -> Option<PartRef>. The part this pass's context request was made at: the part under the pointer for a secondary click, the
    • pub fn roving_arrival(&mut self, member: Id). Names the member of this container's roving group (ContainerProps.roving) that Tab arrives at; the
    • pub fn focus_part(&mut self, part: impl Into<PartRef>). Moves focus to one of this component's focusable parts, in this pass: the rest of the pass reads the new
    • pub fn focus_own(&mut self). Moves focus to the component's own stop (not a part), under the rule of focus_part.
  • craft_ui::contract::CxCore: pub struct CxCore<'a> { pub env: EnvView<'a>, pub resolved: &'a Resolved<'a>, pub id: Id, pub rect: Rect, pub content_rect: Rect, pub visible: Rect, pub flow: Flow, pub response: Response, pub command: Option<Arc<ResolvedCommand>>, pub intents: Intents, pub memory: &'a mut MemoryStage, pub ctx: Context, pub focus: crate::runtime::focus::Facts, pub toggles: Vec<Toggle> }. The non-generic part of every Cx; the step functions take this. It is a read-only output: component code
  • craft_ui::contract::DragBand: pub enum DragBand { None, Move, Reorder }. What dragging the header does.
  • craft_ui::contract::DragPayload: pub struct DragPayload. A mapping from a row drag to the payload of type P that other drop targets take; the drag session carries it
    • pub fn new<K: 'static, P: Send + Sync + 'static>(map: impl Fn(&ListDrag<K>) -> Option<P> + Send + Sync + 'static) -> Self. The payload map makes of a drag of the collection whose keys are K; None for a row that carries none.
  • craft_ui::contract::DragPreview: re-export of craft_ui::runtime::drag::DragPreview.
  • craft_ui::contract::DropAt: pub enum DropAt<K> { Gap { key: Option<K>, insert: usize }, Onto(K) }. The place of one drop.
    • pub const fn gap(key: Option<K>, insert: usize) -> Self. Between items, over key, before insert.
    • pub fn key(&self) -> Option<&K>. The item under the pointer.
  • craft_ui::contract::DropKind: pub struct DropKind<'a, K>. A payload type a collection takes from a drag that did not start in it, at one place, where accepts passes. A
    • pub fn new<P: Send + Sync + 'static>(place: DropPlace, accepts: impl Fn(&P, &DropAt<K>) -> bool + 'a) -> Self. Drops of payload type P at place where accepts passes for the payload and the place under the pointer.
  • craft_ui::contract::DropMark: re-export of craft_ui::runtime::drag::DropMark.
  • craft_ui::contract::DropOperation: re-export of craft_behavior::keys::DropOperation.
  • craft_ui::contract::DropPayload: pub struct DropPayload. The payload of a drop a collection took, read by its type.
    • pub fn get<P: 'static>(&self) -> Option<&P>. The payload, when it is a P.
  • craft_ui::contract::DropPlace: pub enum DropPlace { Between, Onto }. Where a drop kind takes its drops.
  • craft_ui::contract::DropTarget: re-export of craft_ui::runtime::drag::DropTarget.
  • craft_ui::contract::Edit: pub trait Edit. Values and edits (chapter 10). value, validity, gesture, adopt and edit_response take &self, so paint
    • type Value. The component's value type.
    • fn value(&self) -> Option<&Self::Value>. The shown value: the running gesture's proposal, else the binding's. None for a mixed binding, a kept
    • fn validity(&self) -> Validity<Self::Value>. What the binding's check says about the shown value.
    • fn gesture(&self) -> Option<GesturePhase>. Where this pass's gesture stands.
    • fn adopt<V: Value>(&self, child: &EditResponse<V>, start: &Self::Value, map: impl Fn(&V, &mut Self::Value)). Maps each of the child's events onto a clone of this component's shown value and queues the resulting events, in
    • fn edit_response(&self) -> EditResponse<Self::Value>. The EditResponse a value component returns from finish.
    • fn propose(&mut self, v: Self::Value). Sets the running gesture's value, beginning a gesture if none runs and the press that carries it has had no
    • fn set(&mut self, v: Self::Value). A one-shot change outside a gesture.
    • fn begin(&mut self). Opens a gesture.
    • fn commit(&mut self). Commits the proposed value.
    • fn cancel(&mut self, reason: CancelReason). Cancels the running gesture.
  • craft_ui::contract::EditResponse: pub struct EditResponse<T> { pub response: Response, pub events: EditEvents<T>, pub submitted: bool, pub submit_mods: craft_keymap::Mods, pub left_by_tab: Option<bool>, pub escaped: bool, pub unparsed: bool, pub validity: Validity<T>, pub shown: Option<Mixed<Arc<T>>>, pub value_text: Option<String> }. The output of a component that edits a value. Only cx.edit_response() builds it.
    • pub fn lifted(response: Response, events: EditEvents<T>, shown: Option<Mixed<Arc<T>>>) -> Self. The response of a composite that edits one value through several child components: events are the edits of
    • pub fn value(&self) -> Option<&T>. The latest value the pass's events carry: a proposal, a commit or a set; None when nothing was edited or no
    • pub fn map<U>(self, f: impl Fn(T) -> U) -> EditResponse<U>. The response of a child component's edit as the response of the edit of a value built from it: the events, the
  • craft_ui::contract::EndRegion: pub struct EndRegion { pub full_height: bool, pub gap: Gap, pub rule: bool }. An end region, filled by Container::end: content in reading order at the line's end edge, beside the body and
    • pub const fn new() -> Self. An end region as high as the line, space.gap.tight from the body, with no rule.
    • pub const fn rule(mut self, on: bool) -> Self. Whether a rule separates the end region from the body.
    • pub const fn full_height(mut self, on: bool) -> Self. Whether the region takes the full height under the header.
    • pub const fn gap(mut self, gap: Gap) -> Self. Sets the gap between the body and the region.
  • craft_ui::contract::Entry: pub struct Entry<T>. A row of entries: an item that reports its value when picked, a heading over a group of items, or a separator
    • pub fn new(value: T, label: impl Into<Label>) -> Self. An entry reporting value when picked, shown as label: enabled and unchecked, without an icon.
    • pub fn separator() -> Self. A rule between groups of entries. It is not a row: it takes no pick and no lead.
    • pub fn heading(label: impl Into<Label>) -> Self. A caption over the entries after it, up to the next heading or separator, that names their group for assistive
    • pub fn icon(mut self, icon: impl Into<IconSpec<'static>>) -> Self. An icon before the label. A separator has none.
    • pub fn swatch(self, color: Srgba) -> Self. A swatch of color before the label, in the icon's place (a guide colour, a matte colour). A separator has none.
    • pub fn empty_swatch(self) -> Self. The empty swatch of a colour the theme decides, in the icon's place, so the label lines up with the labels of
    • pub fn closed_label(mut self, text: impl Into<Label>) -> Self. The text a closed control shows for the entry in place of its label (a tab leader's fill without its number).
    • pub fn enabled(mut self, on: bool) -> Self. Whether the entry can be picked; a disabled entry shows dimmed and never takes the lead.
    • pub fn disabled_reason(mut self, reason: impl Into<Label>) -> Self. Disables the entry and says why: the row shows reason as its tooltip and its accessible description while the
    • pub fn stepped(mut self, on: bool) -> Self. Whether a step over the closed control (an arrow, Home, End, the wheel, an AccessKit step) stops on the entry.
    • pub fn checked(mut self, on: bool) -> Self. Whether the entry shows as the current choice.
    • pub fn value(&self) -> Option<&T>. The value a pick reports; None for a heading or a separator.
    • pub fn label(&self) -> &Label. The label: a heading's caption; empty for a separator.
    • pub fn face_label(&self) -> &Label. The text a closed control shows for the entry: its closed label, else its label.
    • pub fn icon_spec(&self) -> Option<&IconSpec<'static>>. The icon before the label.
    • pub fn is_enabled(&self) -> bool. Whether the entry can be picked; false for a separator.
    • pub fn is_stepped(&self) -> bool. Whether a step over the closed control stops on the entry: an enabled, stepped item.
    • pub fn why_disabled(&self) -> Option<&Label>. Why the entry is disabled, while it is.
    • pub fn is_checked(&self) -> bool. Whether the entry shows as the current choice.
    • pub fn is_separator(&self) -> bool. Whether the entry is a separator.
    • pub fn is_heading(&self) -> bool. Whether the entry is a heading.
    • pub fn is_item(&self) -> bool. Whether the entry is an item, which reports a value: neither a heading nor a separator.
  • craft_ui::contract::FacesCx: pub trait FacesCx. Where a document face is asked for: a component's context, its measure or a content painter.
    • fn document_face(&self, key: &str, load: impl FnOnce() -> Option<FaceBytes>) -> FaceState. The face registered under key as a family of its own. load runs only for a new key within the frame's
  • craft_ui::contract::FieldLabel: pub struct FieldLabel { pub id: Id, pub rect: Rect, pub press: PressState, pub hovered: bool, pub text: String, pub role: FieldLabelRole, pub detail: Option<String>, pub activated: bool, pub status: bool }. The label a container shows beside its body.
    • pub fn new(id: Id, rect: Rect, text: impl Into<String>) -> Self. A label of text at rect, the node id.
    • pub fn role(mut self, role: FieldLabelRole) -> Self. Whether the label names or describes the controls.
    • pub fn detail(mut self, detail: impl Into<String>) -> Self. Adds a detail line to the description of the controls the label covers.
    • pub fn status(mut self, status: bool) -> Self. Whether the container shows its control's validity message as its status line.
    • pub fn activated(mut self, activated: bool) -> Self. Whether the label was clicked or activated this pass.
    • pub fn with_press(mut self, press: PressState) -> Self. The label's press this pass.
    • pub fn with_hover(mut self, hovered: bool) -> Self. Whether the pointer is over the label this pass.
    • pub fn pressed(&self) -> bool. The label is held down or being dragged.
  • craft_ui::contract::FieldLabelRole: pub enum FieldLabelRole { Names, Describes }. Whether a field label names its control or describes it.
  • craft_ui::contract::FieldLayout: pub enum FieldLayout { Beside, Above, Caption(CellWidth), After, Line, Inside }. Where a side label sits relative to its control.
  • craft_ui::contract::Focus: pub trait Focus. Focus and keys (chapter 9).
    • fn intents(&mut self) -> &mut Intents. The intents routed to this component this pass: cx.intents().take(Intent::Activate).
    • fn claim(&mut self, chord: Chord). Claims chord for the next frames while this component is focused.
    • fn take_claimed(&mut self, chord: Chord) -> bool. Whether chord arrived this pass for this component, consuming it.
    • fn active_part(&self) -> Option<PartRef>. The focused part while the component holds focus.
    • fn focus_arrived(&self) -> Option<PartRef>. The part focus moved onto in this frame (Tab or an arrow into a roving group, a focus request, a click), for
    • fn focus_arrived_by_key(&self) -> Option<PartRef>. focus_arrived when the part is not under a press: focus came by the keyboard or a
    • fn is_focused(&self) -> bool. The component holds key focus.
    • fn focus_visible(&self) -> bool. The component holds focus and shows it.
    • fn reveal(&mut self, rect: Rect). Asks the nearest scroll owner to bring rect into view.
    • fn take_scroll_moves(&mut self) -> Vec<(NavMove, MoveMods)>. For a container that is its body's scroll owner with a view of its own (ContainerProps::scroll_owner): the
    • fn take_reveal(&mut self, view: Rect) -> Option<Vec2>. For a container that is its body's scroll owner with a view of its own: the reveal a child asked of it, as the
    • fn register_menu_bar(&mut self). Registers that this component is a menu bar that takes the menu-bar keys of the next input hook (9.7).
    • fn take_menu_keys(&mut self) -> Vec<MenuKey>. The menu-bar keys of the pass: F10 or a lone Alt press focus the bar, Alt and a letter open a menu.
  • craft_ui::contract::FooterPlace: pub enum FooterPlace { Across, EndBottom, EndTop }. Where a footer region sits.
    • pub const fn in_end(self) -> bool. Whether the footer sits in the end region.
  • craft_ui::contract::FooterRegion: pub struct FooterRegion { pub rule: bool, pub place: FooterPlace, pub gap: Option<Gap>, pub status: bool }. A footer region, filled by Container::footer.
    • pub const fn new() -> Self. A footer across the container under the line, with no rule.
    • pub const fn rule(mut self, on: bool) -> Self. Whether a rule separates the footer from the content beside it.
    • pub const fn place(mut self, place: FooterPlace) -> Self. Where the footer sits.
    • pub const fn gap(mut self, gap: Gap) -> Self. The space above the footer's content, inside the region.
    • pub const fn status(mut self) -> Self. The footer shows the validity message of the control the container labels as its status line.
  • craft_ui::contract::Gap: pub enum Gap { None, Row, Tight, Stack, Item, Section, CardColumn, CardRow, Inline }. The spacing between the children of a body.
  • craft_ui::contract::GlyphLabel: pub struct GlyphLabel. The visible form of a glyph label: an icon, or a short text such as "W" or "H". The accessible name stays the
    • pub fn icon(icon: impl Into<IconSpec<'static>>) -> Self. Shows icon, as large as the control's icons.
    • pub fn text(text: impl Into<Label>) -> Self. Shows text, resolved in the scope's language.
  • craft_ui::contract::GridPlace: re-export of craft_ui::runtime::access::GridPlace.
  • craft_ui::contract::GroupHandle: pub struct GroupHandle<G: GroupKind>. A group form's handle, put into its body's env with content_env. Members and body code read it with
    • pub fn register(&self, member: G::Member, id: Id, enabled: bool). Registers a member's value, id and enabled state for the group's pick next pass.
    • pub fn selected(&self) -> Option<G::Member>. The group's pick this frame.
    • pub fn is(&self, value: &G::Member) -> bool. Whether value is the group's pick.
  • craft_ui::contract::GroupKind: pub trait GroupKind: 'static. The kind of a group form (radio, chip): it names the type of the members' values.
    • type Member. The value a member stands for.
  • craft_ui::contract::GroupState: pub struct GroupState<M> { pub selected: Option<M>, pub members: Vec<(M, Id, bool)> }. A group's registrations: the members shown in the last pass and the member the group picked.
  • craft_ui::contract::HeaderEdge: pub enum HeaderEdge { Start, End }. An edge of a header's line, where a container's own header parts sit.
  • craft_ui::contract::HeaderMenuRequest: pub struct HeaderMenuRequest { pub column: Option<ColumnKey>, pub at: Pos2 }. A request for the header menu: a secondary click on a header cell or on the empty header after the last one, or the
  • craft_ui::contract::HeaderParts: pub struct HeaderParts { pub start: f32, pub end: f32 }. The room a container's own parts take on its header's line (Container::header_parts): a width at the start edge
    • pub const NONE: HeaderParts. No room for parts.
    • pub const fn start(mut self, width: f32) -> Self. width at the start edge.
    • pub const fn end(mut self, width: f32) -> Self. width at the end edge.
  • craft_ui::contract::HeaderRegion: pub struct HeaderRegion { pub band: DragBand, pub rule: bool, pub rule_above: bool, pub inline: bool, pub trailing: bool, pub fill: Option<SurfaceKind>, pub inset: Pad, pub gap: Option<Gap> }. A header region, filled by Container::header.
    • pub const fn new() -> Self. A header with no drag band, no rule, on its own line, with no trailing region, no fill and no inset.
    • pub const fn fill(mut self, kind: SurfaceKind) -> Self. The surface of a band behind the header.
    • pub const fn gap(mut self, gap: Gap) -> Self. The space between a stacked header and the body.
    • pub const fn inset(mut self, pad: Pad) -> Self. The padding tier between the container's edge and the header's content.
    • pub const fn band(mut self, band: DragBand) -> Self. What dragging the header does.
    • pub const fn rule(mut self, on: bool) -> Self. Whether a rule separates the header from the body.
    • pub const fn rule_above(mut self, on: bool) -> Self. Whether a rule runs above the header.
    • pub const fn inline(mut self, on: bool) -> Self. Whether the header shares a line with the body.
    • pub const fn trailing(mut self, on: bool) -> Self. Whether the header has a trailing region for the container's controls.
  • craft_ui::contract::Held: pub struct Held<'a, T>. The caller's binding of a value a pattern edits: the body reads the value at the start of its pass and returns
    • pub fn new(bind: Bind<'a, T>) -> Self. Holds bind.
    • pub fn read(&mut self, cx: &mut impl StageAccess) -> Option<T>. The bound value; None while a mixed or kept binding holds none.
    • pub fn write(&mut self, cx: &mut impl StageAccess, before: &T, after: T, name: &str). Replaces before with after, the edit named name.
  • craft_ui::contract::Hosted: pub trait Hosted<H: Component>. A hosted leaf of a host H, erased.
    • fn measure(&mut self, cx: &MeasureCx<'_, H>, key: HostedKey, proposal: Proposal) -> Vec2. The leaf's size at proposal, as show will show it under key.
    • fn show(self: Box<Self>, ui: &mut PaintUi<'_>, key: HostedKey, rect: Rect). Shows the leaf at rect under key and hands its output on.
  • craft_ui::contract::HostedKey: pub type HostedKey = (&'static str, usize). The key a hosted leaf is measured and shown under: the slot's name and its index among the host's slots.
  • craft_ui::contract::Input: re-export of craft_behavior::input::Input.
  • craft_ui::contract::InsideLabel: pub struct InsideLabel. What a control shows in its slot for a side label with FieldLayout::Inside (EnvView::inside_label): the
    • pub const PART: PartKey. The part a control declares its slot as (PartsCx::label_part).
    • pub fn icon(&self) -> Option<&IconSpec<'static>>. The glyph's icon, for an icon glyph.
    • pub fn text(&self) -> Option<&Label>. The glyph's text, resolved in the scope's language, for a text glyph.
    • pub fn tooltip(&self) -> Option<&Tooltip>. The label's tooltip, shown over the slot.
    • pub fn scrubs(&self) -> bool. A drag on the slot scrubs the control's value.
  • craft_ui::contract::Interpolate: re-export of craft_ui::runtime::motion::Interpolate.
  • craft_ui::contract::ItemCx: pub struct ItemCx<'a, 'r, K> { pub key: &'a K, pub at: usize, pub rect: Rect, pub row: crate::contract::RowState, pub depth: usize, pub set: crate::runtime::access::SetPosition, pub row_index: usize, pub row_count: usize, pub column_count: usize, pub env: EnvView<'a> }. What the item closure reads for one item: a view over the pipeline's memory stage keyed by the item.
    • pub fn cells(&self) -> &[(craft_behavior::ColumnKey, Rect)]. The visible columns of the row with their rects.
    • pub fn column_index(&self, key: &craft_behavior::ColumnKey) -> Option<usize>. The zero-based position of column key among the columns the row shows.
    • pub fn cell(&self, key: &craft_behavior::ColumnKey) -> Option<Rect>. The rect of column key in this row.
    • pub fn grid(&self) -> Option<&craft_behavior::GridView>. The sections of a sheet layout.
    • pub fn tip(&mut self, tip: impl FnOnce(&mut Ui) + 'r). Rich tooltip content for the item; it may borrow app data.
    • pub fn part_opener(&mut self, part: impl Into<craft_behavior::PartRef>) -> ItemOpener. The opener for the item's part part: after the collection is shown, CollectionResponse::opener gives the
  • craft_ui::contract::ItemKeys: pub enum ItemKeys { Own, Owner }. Who takes a collection's arrow keys while it has the key focus.
  • craft_ui::contract::ItemOpener: pub struct ItemOpener. The part of one item that opens a menu or popover: ItemCx::part_opener names it and
  • craft_ui::contract::ItemOutput: pub trait ItemOutput<E>: Outcome. What an item's output may report beyond its response.
    • fn into_event(self) -> Option<E>. The event the collection reports for this item, None when the item reports nothing.
    • fn open_request(&self) -> Option<super::OpenChange<()>>. The item asks to open or close its children, as a click on its disclosure does. The collection reports it
    • fn menu_request(&self) -> Option<egui::Rect>. The item asks for its menu from one of its parts (a row's "More" button): the part's rect, in the item's layer.
    • fn label_rect(&self) -> Option<egui::Rect>. The rect of the item's label, where a rename editor goes; None puts it over the whole row.
  • craft_ui::contract::Job: re-export of craft_ui::runtime::pending::Job.
  • craft_ui::contract::LabelKind: pub enum LabelKind { Text, Hidden, Glyph(GlyphLabel), Short(Label) }. How a side label is shown.
  • craft_ui::contract::LabelScheme: pub enum LabelScheme { Form, Inspector }. How the labelled rows under a container show their labels: set once on the container (ContainerProps::labels),
  • craft_ui::contract::Lazy: pub struct Lazy. A child of a scroll area that runs only while it is in view. Out of view its content does not run: it takes the
    • pub fn new(key: impl Hash, estimate: f32) -> Lazy. The child keyed key in its scroll area. estimate is how long it is along the axes the area scrolls, an
    • pub fn reveal(mut self, reveal: bool) -> Lazy. When reveal holds, the scroll area glides until the child starts at the view's start (as far as the
    • pub fn settles(mut self, settles: bool) -> Lazy. When settles holds, the child runs only when something it shows may have changed, inside a scroll area or
    • pub fn show<R>(self, ui: &mut Ui, add: impl FnOnce(&mut Ui) -> R) -> Option<R>. Runs add in a child Ui placed in flow in ui, or takes the remembered extent there; None when it did not
  • craft_ui::contract::LeadOnOpen: pub enum LeadOnOpen { Selected, First }. Where the lead starts when the collection first shows rows.
  • craft_ui::contract::LeadSource: pub enum LeadSource { Keys, Pointer }. What moved the lead.
  • craft_ui::contract::LeastWidth: pub enum LeastWidth { Popup }. A size role that sets the least width of a container's content.
  • craft_ui::contract::ListDrag: pub struct ListDrag<K> { pub list: Id, pub keys: Vec<K>, pub grabbed: K }. What a row drag carries through the drag session (8.4).
    • pub fn new(list: Id, keys: Vec<K>, grabbed: K) -> Self. A drag of keys from list, grabbed at grabbed.
  • craft_ui::contract::Looks: pub struct Looks. Only apps write Looks: a replacement for one component type's style function, keyed by its StyleKey.
    • pub const fn new() -> Self. No replacements.
    • pub fn style<C: Component>(&mut self, f: for<'a> fn(&StyleCx<'a>, C::StyleKey) -> C::Style) -> &mut Self. Replaces the style function of C app-wide. Two replacements for one style key are an install error.
  • craft_ui::contract::MeasureCx: pub struct MeasureCx<'a, C: Component> { pub env: EnvView<'a>, pub style: &'a C::Style, pub resolved: &'a Resolved<'a>, pub proposal: Proposal, pub room: Option<f32>, pub ui: &'a Ui, pub tokens: &'a UiTokens, pub id: Id }. What measure reads: step 5's view of the environment, the style, the resolved props and the shown value.
    • pub fn value(&self) -> Option<&'a ValueOf<C>>. The shown value; it has the stage's lifetime, so a borrow of cx is not held.
    • pub fn command(&self) -> Option<&ResolvedCommand>. The bound command as step 1 resolved it, with the scoped bindings of the scopes above the component.
    • pub fn resolve_command(&self, command: impl Into<CommandRef>) -> Option<ResolvedCommand>. command as this component shows it: the label, icon and chord with the scoped bindings of the scopes above
    • pub fn column_room(&self) -> Option<f32>. The width a component whose height follows its width (wrapped text, a square plot) sizes at: the room the
    • pub fn picture_width(&self, least: f32, most: f32) -> f32. The width a picture sizes at (a plot, a wheel, a well): it takes the room it is offered, down to least and up
    • pub fn label(&self) -> Label. The label as given.
    • pub fn cell_width(&self, column: &craft_behavior::ColumnKey, width: f32). Reports, from the Ideal measure of a collection's item, the width its content in column takes unclipped,
    • pub fn layout(&self, run: &TextRun<'_>) -> TextLayout. Lays run out in the content's room, as Draw::text will paint it.
    • pub fn layout_at(&self, run: &TextRun<'_>, width: f32) -> TextLayout. Lays run out width wide, for a text that paints in a band narrower than the room.
    • pub fn field_text(&self, run: &TextRun<'_>) -> Vec2. The room an editable text in a control sized by its text needs for run: the laid-out text and the caret the
    • pub fn layout_doc(&self, text: &crate::primitives::DocText<'_>) -> TextLayout. Lays document text out text.wrap wide, as ContentPainterCx::layout will paint it: the galley a content
    • pub fn child<D: Show>(&self, key: impl Hash + Debug, child: &mut D, proposal: Proposal) -> Vec2. Measures a child under the composite's resolved enabled and size, as PaintUi::child will show it.
    • pub fn labelled<D: Show>(&self, key: impl Hash + Debug, side: &crate::contract::SideLabel, child: &mut D, proposal: Proposal) -> Vec2. Measures a child as PaintUi::labelled will show it with side: under the inside label side gives it
    • pub fn face<S: Show>(&self, mut face: S) -> Vec2. The size face has when PaintUi::face shows it as the look of a part: steps 1, 2 and 4 of the face run
    • pub fn icon(&self) -> f32. The icon side of the component's size.
    • pub fn gap(&self) -> f32. The gap between the component's items.
  • craft_ui::contract::MenuKey: re-export of craft_ui::runtime::keys::MenuKey.
  • craft_ui::contract::MotionSpec: re-export of craft_ui::runtime::motion::MotionSpec.
  • craft_ui::contract::Mount: pub enum Mount { Inline, Pane(ShellPane), Layer(Overlay), FullWindow, Window { resize: Resize }, Viewport { fallback: Overlay, spec: Option<WindowSpec> } }. Where a container lives.
    • pub const fn window(resize: Resize) -> Mount. The whole content of the window: its edges resize it where resize has grips and the app draws the frame.
    • pub const fn viewport(fallback: Overlay) -> Mount. An OS viewport that falls back to fallback, and opens as a dialog or tool window by the fallback's rank.
    • pub fn viewport_with(fallback: Overlay, spec: WindowSpec) -> Mount. An OS viewport that falls back to fallback and opens as spec says.
  • craft_ui::contract::Name: re-export of craft_ui::runtime::access::Name.
  • craft_ui::contract::NoValue: pub struct NoValue. The value type of a component with no value.
  • craft_ui::contract::Notch: pub enum Notch { Lines(f32), ViewShare(f32) }. The distance of one wheel notch.
    • pub fn wheel(self, line: f32) -> craft_behavior::WheelNotch. The wheel distance of the notch, with a text line line points high.
  • craft_ui::contract::Numeric: re-export of craft_ui::runtime::access::Numeric.
  • craft_ui::contract::OpenChange: pub struct OpenChange<K> { pub key: K, pub open: bool, pub all: bool }. A tree row opened or closed.
    • pub const fn new(key: K, open: bool) -> Self. key opens or closes.
    • pub const fn all(mut self) -> Self. The change reaches every descendant.
  • craft_ui::contract::OsFile: re-export of craft_ui::runtime::drag::OsFile.
  • craft_ui::contract::OsFiles: re-export of craft_ui::runtime::drag::OsFiles.
  • craft_ui::contract::Outcome: pub trait Outcome. What show returns: the component's response and the type of value it edits.
    • type Value. The value type; NoValue for a component with none.
    • fn response(&self) -> &Response. The component's response.
    • fn unshown(response: Response) -> Option<Self> where Self: Sized,. The output of a layer-like container that shows nothing this pass (closed, past its exit fade): response is
    • fn value_text(&self) -> Option<&str>. The shown value as the component words it to assistive technology; None for a component that gives none.
    • fn story_facts(&self) -> crate::testing::StoryOutput. The facts a story reports about this output: its id, click, edit kinds, collection kinds and visible range.
  • craft_ui::contract::Overlay: pub struct Overlay { pub place: Place, pub fit: OverlayFit, pub min_width: MinWidth, pub movable: bool, pub resize: Resize, pub rank: Rank, pub keys: OwnerClass, pub focus: FocusPolicy, pub dismiss: Dismiss, pub motion: MotionSpec, pub opener: Option<Opener>, pub popup: PopupKind, pub size: Option<Vec2>, pub size_limits: SizeLimits, pub placed: Option<Rect>, pub placed_at: Option<Pos2>, pub bounds: Option<Rect>, pub opacity: f32, pub body_scroll: bool, pub moves_window: bool }. Data describing an egui layer. Presets fill focus and dismissal; builders change single fields.
    • pub fn popover() -> Overlay. A popover: a popup anchored below, taking focus in. It closes when the focus moves out of it.
    • pub fn dropdown() -> Overlay. A dropdown list: from its content, at least as wide as its anchor and capped, focus stays on the anchor. It
    • pub fn menu() -> Overlay. A menu: a popup the arrow keys move through. A press outside closes it and goes no further.
    • pub fn submenu() -> Overlay. A submenu: beside its parent entry.
    • pub fn tooltip() -> Overlay. A tooltip: below the control, no focus, never takes input.
    • pub fn dialog() -> Overlay. A dialog: modal, floating, movable and resizable. .modeless() gives rank Window.
    • pub fn modal() -> Overlay. A modal: centred, content capped.
    • pub fn modal_chrome(rect: Rect) -> Overlay. The chrome of a modal over a part of the window the modal covers, placed at rect: above the modal, with no
    • pub fn toast(body: Rect, corner: Align2) -> Overlay. A toast stack at corner of body, a rect in the opener's layer space: the end-bottom corner of a window's body.
    • pub fn floating() -> Overlay. A floating panel or document window: a window-rank layer that is a pane of the app. F6 reaches it and Escape
    • pub fn resizable(mut self, on: bool) -> Overlay. Whether edge grips resize the layer.
    • pub fn modeless(mut self) -> Overlay. Rank Window and no backdrop.
    • pub fn place(mut self, place: Place) -> Overlay. Sets where it sits.
    • pub fn fit(mut self, fit: OverlayFit) -> Overlay. Sets how it sizes.
    • pub fn anchor(mut self, anchor: Anchor) -> Overlay. Hangs the layer from anchor on the side and alignment its preset gave. Without an opener, a point is in the
    • pub fn size(mut self, size: Vec2) -> Overlay. Sets the size a resizable layer has before the user resizes it.
    • pub fn min_size(mut self, min_size: Vec2) -> Overlay. Sets the least a resizable layer may be resized to.
    • pub fn size_limits(mut self, limits: SizeLimits) -> Overlay. Sets the least and the most a resizable layer may be resized to.
    • pub fn placed(mut self, rect: Rect) -> Overlay. Places the layer at rect in its parent's space. The container reports the moves and resizes the user makes
    • pub fn placed_at(mut self, pos: Pos2) -> Overlay. Places the layer's top left at pos in its parent's space and sizes it from its content and size limits, so a
    • pub fn bounds(mut self, bounds: Rect) -> Overlay. Sets the rect a move or resize keeps the layer inside.
    • pub fn body_scroll(mut self, on: bool) -> Overlay. Whether a container mounted as this layer scrolls its body vertically (default on).
    • pub fn opacity(mut self, opacity: f32) -> Overlay. Sets the layer's opacity, from 0 (invisible) to 1.
    • pub fn min_width(mut self, min_width: MinWidth) -> Overlay. Sets the narrowest width.
    • pub fn movable(mut self, on: bool) -> Overlay. Sets whether the user may move it.
    • pub fn moves_window(mut self, on: bool) -> Overlay. Sets whether the move band moves the OS window the layer is shown in, in place of the layer.
    • pub fn focus(mut self, focus: FocusPolicy) -> Overlay. Sets the focus scope.
    • pub fn dismiss(mut self, dismiss: Dismiss) -> Overlay. Sets the dismissal rules.
    • pub fn motion(mut self, motion: MotionSpec) -> Overlay. Sets the open and close motion.
    • pub fn opened_by(mut self, anchor: &Response, trigger: Trigger) -> Overlay. Records an opener. An anchored layer hangs from the rect of the opener that opened it, on the side and
    • pub fn opener_anchor(mut self, anchor: Anchor) -> Overlay. Sets where the layer hangs when the opener named last opened it. A rect or point is in that opener's layer
  • craft_ui::contract::OverlayUi: pub struct OverlayUi<'a> { pub closed: Vec<(Id, CloseReason)> }. What the overlay hook gets: one call per anchored popup of this component, built at step 10 with the open state
    • pub fn closing(&self, popup: PopupHandle) -> Option<CloseReason>. Why popup closes at the end of this pass, as its show decided (its dismissal, or a close its body asked for);
    • pub fn anchor_part(&self, part: impl Into<PartRef>) -> Anchor. The anchor at the rect of the toggling part part of the owner. The layer's placement mirrors the side and
    • pub fn show<R>(&mut self, popup: PopupHandle, overlay: Overlay, mut body: impl FnMut(&mut Ui, &mut BodyCx<'_>) -> R) -> Option<R>. Shows the popup while its handle is open, on a popup surface, inside POPUP_PAD; the content is a body closure.
  • craft_ui::contract::Overlays: pub trait Overlays. The Cx trait that registers popups.
    • fn popup(&mut self, name: &'static str) -> PopupHandle. Registers the popup name of this component for this pass and returns its handle. A component registers every
  • craft_ui::contract::POPUP_PAD: pub const POPUP_PAD: Pad. The padding of every popup surface around its content.
  • craft_ui::contract::Pad: pub enum Pad { None, Control, Regular, Roomy }. The padding tier of a body.
  • craft_ui::contract::PaintUi: pub struct PaintUi<'a> { pub env: &'a Env }. What paint and paint_over get instead of a Ui.
    • pub fn draw(&self) -> Draw<'_>. The content-paint API: text, rules, surfaces and shapes, recorded for the later steps.
    • pub fn selectable_text(&mut self, part: impl Into<PartRef>, rect: Rect, run: &TextRun<'_>). Shows the selection part part (PartsCx::selectable_text): run in rect, painted as Draw::text
    • pub fn draw_part(&self, part: impl Into<PartRef>) -> Draw<'_>. The content-paint API for painting part: as draw, and when the part was declared
    • pub fn clipped<R>(&mut self, rect: Rect, paint: impl FnOnce(&mut Self) -> R) -> R. Runs paint with this PaintUi cut to rect (inside the clip already in force), as Draw::clipped does for a
    • pub fn with_style<R>(&self, variant: Variant, f: impl FnOnce(&StyleCx<'_>) -> R) -> R. Runs f with the style context of this component's env, so app hooks called from paint pick colours and
    • pub fn child<C: Show>(&mut self, key: impl Hash + Debug, rect: Rect, child: C) -> C::Output. Shows a child component at a physical rect, with id cx.key(key). The child Ui is pinned left to
    • pub fn inner<C: Show>(&mut self, key: impl Hash + Debug, rect: Rect, child: C) -> C::Output. Shows child as the owner's own control, such as a picker the owner draws its field with. The child's node
    • pub fn child_with_tip<C: Show>(&mut self, key: impl Hash + Debug, rect: Rect, child: C, tip: impl FnOnce(&mut Ui)) -> C::Output. Shows a child with rich tooltip content.
    • pub fn labelled<C: Show>(&mut self, key: impl Hash + Debug, rect: Rect, label: Label, side: SideLabel, child: C) -> C::Output. Runs the label step (B2) for one leaf child at rect: the label's placement beside or above the child, the
    • pub fn face<C: Show>(&mut self, part: impl Into<PartRef>, face: C). Paints face as the look of part: its style, surface and state fill from the part's state merged with the
    • pub fn face_in<C: Show>(&mut self, part: impl Into<PartRef>, face: C, ink: &Stateful<StyleColor>). face, for a face on a fill the composite draws for that part alone (a plate over a picture): the face reads
    • pub fn content_painter<C: ContentPainter>(&self, cx: &Cx<'_, C>) -> ContentPainterCx<'_>. The raw painter for an allowlisted content painter, clipped to the component's own rect.
  • craft_ui::contract::PaneEdge: pub enum PaneEdge { Center, Start, End, Top, Bottom }. Where a shell pane sits.
  • craft_ui::contract::PartBuilder: pub struct PartBuilder<'a>. A part as PartsCx::part declares it; the builder sets its flags.
    • pub fn sense(self, sense: Sense) -> Self. What the part senses; hover only by default.
    • pub fn priority(self, priority: HitPriority) -> Self. The part's level and sub-level in the resolve order.
    • pub fn cursor(self, cursor: impl Into<Cursor>) -> Self. The cursor while the pointer is over the part.
    • pub fn drag_cursor(self, cursor: CursorIcon) -> Self. The cursor while the part is dragged.
    • pub fn focusable(self) -> Self. The part is a focus stop.
    • pub fn inactive(self, inactive: bool) -> Self. The part is inactive (a switched-off clip): it paints with the Disabled state, and a Draw from
    • pub fn held(self, held: bool) -> Self. The component holds a press on the part that the part does not sense itself (a collection's press on a row's
    • pub fn selected(self) -> Self. The part is the arrival of the component's part roving group: Tab and Shift+Tab into the group land here, not
    • pub fn nudges(self) -> Self. The focused part takes the arrow keys, with any modifier, as nudges of its content (Intents::take_nudge),
    • pub fn default_stop(self) -> Self. The part's stop is its scope's default (Initial::Default); the scope focuses the first default stop in tab order.
    • pub fn exclusive(self, hit: crate::runtime::windows::WindowHit) -> Self. The part is what hit says for the OS window: its move area, one of its edge zones or a caption button. It
    • pub fn focus_shape(self, shape: FocusShape) -> Self. The shape the focus ring takes around the part.
    • pub fn flags(self, flags: Flags) -> Self. Value flags of the part, merged into its state at step 12 and its sub-node at step 16.
    • pub fn over(self) -> Self. The part sits above the body or items in the stacking order and is painted by paint_over.
    • pub fn state_layer(self) -> Self. The part's look is the plain state layer: the paint step fills its rect with StyleCx::state_layer in the
    • pub fn tooltip(self, tooltip: impl Into<Tooltip>) -> Self. The part's tooltip.
    • pub fn value_part(self) -> Self. The part shows the component's value: a double click on it resets the value, as one on the root does. A
    • pub fn own_reset(self) -> Self. A reset aimed at the part (Reset while it is the focused part, a double click on it) does not reset the
    • pub fn pointer_only(self, reason: &'static str) -> Self. A part with no focus stop names its keyboard path: the intent or command that does the same.
    • pub fn toggles(self, popup: &'static str) -> Self. The part opens and closes the component's popup popup (the name given to cx.popup): a press on it toggles
    • pub fn keyboard_via(self, part: PartKey) -> Self. A part with no focus stop of its own does the same as the focusable part part of this component, which
  • craft_ui::contract::PartsCx: pub struct PartsCx<'a, C: Component> { pub content_rect: Rect, pub flow: Flow }. Step 7's context: the step-5 read view plus the rect geometry and the part builders.
    • pub fn header_slot(&self, edge: crate::contract::HeaderEdge) -> Option<Rect>. The slot at edge of the header's line that Container::header_parts keeps for the container's own parts;
    • pub fn header_part(&mut self, edge: crate::contract::HeaderEdge, part: impl Into<PartRef>, shape: impl Into<HitShape>) -> PartBuilder<'_>. Declares a part in the header slot at edge. Its stop sits where the part sits: at the start edge before the
    • pub fn rect_of(&self, key: &C::Key) -> Option<Rect>. The rect of the item key this pass, in the coordinates the item step lays rows out in (a transformed
    • pub fn offset(&self) -> craft_behavior::ScrollPos. How far the rows are scrolled this pass.
    • pub fn hovered(&self) -> bool. Last pass's pointer-over state of this component, so parts can register hover-revealed parts.
    • pub fn focus_visible(&self) -> bool. Last pass's focus-visible state of this component.
    • pub fn part(&mut self, part: impl Into<PartRef>, shape: impl Into<HitShape>) -> PartBuilder<'_>. Declares a part; a repeated part is named with its index: cx.part(POINT.at(id), shape).
    • pub fn label_part(&mut self, rect: Rect). Declares rect, the slot where the component shows its inside label (EnvView::inside_label), as the label's
    • pub fn roving(&mut self, roving: Roving). Declares a roving group over part and child keys.
    • pub fn scroll(&mut self, key: PartKey, rect: Rect, axis: Axis, span: ScrollSpan). Declares one axis's scroll bar: the track as part key and the thumb as part key.at(THUMB), inside
  • craft_ui::contract::Pattern: re-export of craft_ui_macros::Pattern (outside these crates).
  • craft_ui::contract::Pending: re-export of craft_ui::runtime::pending::Pending.
  • craft_ui::contract::PendingDrop: pub enum PendingDrop<K> { Reorder(ReorderMove<K>), Drop(DropAt<K>) }. The drop a release would make on a collection now.
  • craft_ui::contract::Pointer: pub trait Pointer. Pointer state and requests (chapter 8).
    • fn part(&self, part: impl Into<PartRef>) -> &PartResult. The result of part this pass: idle for a part first registered this frame. A part parts did not
    • fn part_if_declared(&self, part: impl Into<PartRef>) -> Option<&PartResult>. The result of part this pass, None when parts did not declare it: for parts that exist only under a
    • fn hover_pos(&self, part: impl Into<PartRef>) -> Option<Pos2>. Where the pointer is over part this pass, in the component's layer space; None when part is not hovered.
    • fn press(&self) -> &PressState. The component's own press.
    • fn hit(&self) -> bool. The pointer is over the component's own shapes.
    • fn activation(&self) -> Option<Activation>. Set only when the component's own shapes won the press and it was released as a click, or
    • fn activated_member(&self) -> Option<Id>. For an arena root, the member activated this pass.
    • fn take_wheel(&mut self) -> Option<Wheel>. This pass's wheel share, once.
    • fn cursor(&mut self, cursor: impl Into<Cursor>, priority: CursorPriority). Requests cursor at priority; the highest priority of the pass wins.
    • fn cancel_press(&mut self, reason: PressCancel). Ends every captured press of this viewport.
    • fn start_drag<P: Clone + Send + Sync + 'static>(&mut self, payload: P, preview: DragPreview). Starts the drag session with payload; the context holds one session at a time, and a running one stays.
    • fn start_drag_also<P: Clone + Send + Sync + 'static>(&mut self, payload: P, also: Arc<dyn std::any::Any + Send + Sync>, preview: DragPreview). Starts the drag session with payload, which also carries also: targets of either type see the one drag.
    • fn dragging<P: Send + Sync + 'static>(&self) -> Option<(Arc<P>, Pos2)>. The active drag payload of type P and the pointer position in this component's egui layer space (8.3), from any
    • fn drop_target<P: Send + Sync + 'static, T: DropTarget<P>>(&mut self, target: &T) -> Option<T::Drop>. Registers target over this component's rect for this pass, in update. Returns the drop released over it this
    • fn window_drop_target<P: Send + Sync + 'static, T: WindowDropTarget<P>>(&mut self, target: &T) -> Option<T::Drop>. Registers target over the whole window of the running viewport for this pass, in update; a target over a
    • fn drag_ended<P: Send + Sync + 'static>(&self) -> Option<DropOperation>. The operation of a drop of this component's payload, in the pass after the drop; None while dragging, when the
    • fn scroll_moved(&self, key: PartKey) -> Option<Range<f64>>. The visible range the scroll part key moved to this pass (thumb or end drag, page press, or an AccessKit click
  • craft_ui::contract::Politeness: re-export of craft_ui::runtime::access::Politeness.
  • craft_ui::contract::Popup: pub struct Popup. The open state of a container's layer that has an opener and no binding, driven from the opener's side.
    • pub fn open<C: Component>(opener: impl Into<Id>, cx: &mut Cx<'_, C>). Opens the container hung from opener (a [PopupHandle] or the id of the opener's response).
    • pub fn close<C: Component>(opener: impl Into<Id>, cx: &mut Cx<'_, C>). Closes the container hung from opener.
    • pub fn toggle<C: Component>(opener: impl Into<Id>, cx: &mut Cx<'_, C>). Opens the container hung from opener when it is closed, else closes it.
    • pub fn opening<C: Component>(popup: PopupHandle, cx: &Cx<'_, C>) -> bool. Whether the layer popup shows first in this pass: true in the passes of the frame it first shows, false
  • craft_ui::contract::PopupHandle: pub struct PopupHandle. An id and a name; Copy, never a snapshot of the open state.
    • pub fn at(self, index: usize) -> PopupHandle. The popup of the repeat index of this name: a component with one popup per part or per entry gives each its
    • pub fn id(self) -> Id. The popup's id: its open state's and its entry in the layer stack.
    • pub fn name(self) -> &'static str. The name given to cx.popup.
    • pub fn trigger<C: Component>(self, trigger: Trigger, cx: &mut Cx<'_, C>). Toggles or opens the popup from trigger at step 9, as the pass's pending open change.
    • pub fn open<C: Component>(self, cx: &mut Cx<'_, C>). Queues an open that step 15 writes. For Trigger::Manual this and the binding are the only ways it opens.
    • pub fn close<C: Component>(self, cx: &mut Cx<'_, C>). Queues a close; step 15 writes the slot, so this pass still shows the popup open.
    • pub fn changed<C: Component>(self, cx: &mut Cx<'_, C>) -> bool. Whether a toggle, open or close queued in this pass leaves the popup's open state different from the
    • pub fn bind_open<C: Component>(self, cx: &mut Cx<'_, C>, mut open: BindMut<'_, bool>) -> bool. Binds the popup's open state to open: call it in update, after the toggles and closes the component
    • pub fn is_open<C: Component>(self, cx: &mut Cx<'_, C>) -> bool. Whether the popup is open in this pass: valid from step 8, with the changes queued so far applied.
  • craft_ui::contract::PopupKind: re-export of craft_ui::runtime::access::PopupKind.
  • craft_ui::contract::Presence: re-export of craft_ui::runtime::motion::Presence.
  • craft_ui::contract::Progress: re-export of craft_ui::runtime::pending::Progress.
  • craft_ui::contract::Props: re-export of craft_ui_macros::Props (outside these crates).
  • craft_ui::contract::Remember: re-export of craft_ui::runtime::memory::Remember.
  • craft_ui::contract::Rename: pub struct Rename<K> { pub key: K, pub name: String }. A committed rename.
  • craft_ui::contract::ReorderMove: pub struct ReorderMove<K> { pub key: K, pub keys: Vec<K>, pub to: usize, pub copy: bool, pub parent: Option<K> }. A reorder: the items keys move together, and the first of them lands at position to.
    • pub fn new(key: K, keys: Vec<K>, to: usize, copy: bool) -> Self. A move of keys (key among them) to position to at the top level.
    • pub fn in_group(mut self, parent: Option<K>) -> Self. The items land in the group parent, None for the top level.
  • craft_ui::contract::ReorderRule: pub struct ReorderRule { pub copy_with_alt: bool, pub into_groups: bool }. How the user may reorder items.
    • pub const fn new() -> Self. A rule that only moves.
    • pub const fn into_groups(mut self) -> Self. Items may land inside the groups of a tree.
    • pub const fn copy_with_alt(mut self) -> Self. Alt copies.
  • craft_ui::contract::Resolved: pub struct Resolved<'p> { pub id: Id, pub label: &'p str, pub enabled: bool, pub read_only: bool, pub size: ControlSize, pub variant: Variant, pub selected: Option<bool>, pub tooltip: Option<&'p Tooltip>, pub doc_key: Option<DocKey> }. Common after step 1; it borrows locals of the pipeline frame, never the component.
    • pub fn sizing(&self) -> Option<Sizing>. The sizing the host set on this component, if any: a leaf with Sizing::Content sizes to its content.
  • craft_ui::contract::Role: re-export of craft_ui::runtime::access::Role.
  • craft_ui::contract::RowAlign: pub enum RowAlign { Start, Center, End, SpaceBetween }. Where a Row places its block of children along the row.
  • craft_ui::contract::RowPressed: pub enum RowPressed { Row, Cell(ColumnKey), Part { was_lead: bool } }. Where the collection holds a primary press on a row, within slop, or the press a part of the row holds.
  • craft_ui::contract::RowState: pub struct RowState { pub selected: bool, pub lead: bool, pub drop_target: bool, pub dragging: bool, pub renaming: bool, pub emphasized: bool, pub current: bool, pub striped: bool, pub open: bool, pub hovered: bool, pub pressed: Option<RowPressed>, pub menu_open: bool, pub activated_by_key: bool }. What an item reads of its place in the collection; the item step joins it to the item's flags at step 12.
  • craft_ui::contract::Sampler: pub trait Sampler: sealed::Host. The canvas reach under a modal layer (15.5, 8.3): a control of a dialog keeps the canvas below it usable. It is
    • fn arm_sampler(&mut self, canvas: Id). Arms a sampler for canvas (the canvas component's id): while the modal layer is open, primary presses on the
    • fn keep_view_open(&mut self, canvas: Id). Keeps the view of canvas (the canvas component's id) usable under the modal layer: the wheel scrolls and
  • craft_ui::contract::Savable: re-export of craft_ui::runtime::memory::Savable.
  • craft_ui::contract::SaveKey: re-export of craft_ui::runtime::memory::SaveKey.
  • craft_ui::contract::Scroll: pub struct Scroll { pub axes: ScrollAxes, pub anchor: ScrollAnchor, pub notch: Notch }. A scrolling body.
    • pub const fn vertical() -> Scroll. Scrolls along y.
    • pub const fn horizontal() -> Scroll. Scrolls along x.
    • pub const fn both() -> Scroll. Scrolls along both axes.
    • pub const fn anchored_end(mut self) -> Scroll. Stays at the end when the content grows.
    • pub const fn notch(mut self, notch: Notch) -> Scroll. The distance of one wheel notch.
    • pub const fn horizontal_on(&self) -> bool. Whether the x axis scrolls.
    • pub const fn vertical_on(&self) -> bool. Whether the y axis scrolls.
  • craft_ui::contract::ScrollAnchor: pub enum ScrollAnchor { Start, End }. Which end of the content a scroll region stays at when the content grows.
  • craft_ui::contract::ScrollAxes: pub enum ScrollAxes { Vertical, Horizontal, Both }. The axes a body scrolls on.
  • craft_ui::contract::Scrub: pub struct Scrub<V>. How a drag changes a control's value: the drag maths over the control's number, and the sources a drag starts on
    • pub fn new(drag: ValueDrag, read: impl Fn(&V) -> f64 + Send + Sync + 'static, write: impl Fn(f64) -> V + Send + Sync + 'static) -> Self. A scrub by drag, reading the number a value holds with read and making a value of a number with write.
    • pub fn by_label(mut self) -> Self. A drag on the control's side label scrubs, with or without the focus in the control; the label senses the
    • pub fn part(mut self, part: impl Into<PartRef>, drag: ValueDrag) -> Self. A drag on the part part scrubs by drag, with or without the focus in the control: a scrub handle, or an
    • pub fn on_field(mut self) -> Self. A drag on the control's body scrubs while its text part does not take the pointer: a field that is not in
  • craft_ui::contract::SelectMode: pub enum SelectMode { None, Single, Multi, Cells }. What a collection lets the user select.
  • craft_ui::contract::SetPosition: re-export of craft_ui::runtime::access::SetPosition.
  • craft_ui::contract::SettleCx: pub struct SettleCx<'a>. The body's memory after the real run: the same Remember access the body's context has, and the Held and
  • craft_ui::contract::ShellPane: pub struct ShellPane { pub name: &'static str, pub edge: PaneEdge, pub extent: Option<f32>, pub at: Option<Rect> }. One of AppShell's panes.
    • pub const fn new(name: &'static str) -> Self. The central pane named name.
    • pub const fn edge(mut self, edge: PaneEdge) -> Self. The pane at edge.
    • pub const fn extent(mut self, extent: f32) -> Self. The pane's size along its edge, exactly: the pane host shows it at this extent in every pass.
    • pub const fn at(mut self, rect: Rect) -> Self. The pane in rect, which the caller laid out for this pass. The pane takes no room from its siblings.
  • craft_ui::contract::ShownRow: pub struct ShownRow<K> { pub key: K, pub rect: egui::Rect, pub cells: Vec<(ColumnKey, egui::Rect)>, pub openers: Vec<(crate::contract::ItemOpener, Response)> }. The geometry of one row the collection showed this pass.
  • craft_ui::contract::SideLabel: pub struct SideLabel { pub kind: LabelKind, pub layout: FieldLayout, pub role: FieldLabelRole, pub scrub: bool, pub reset_dot: bool, pub icon: Option<IconSpec<'static>>, pub detail: Option<Label>, pub tooltip: Option<Tooltip> }. What ContainerProps.label holds: how the label is shown and what it does. The text is Common.label.
    • pub const fn new() -> Self. A text label beside its control that names it.
    • pub fn kind(mut self, kind: LabelKind) -> Self. How the label is shown.
    • pub const fn layout(mut self, layout: FieldLayout) -> Self. Where the label sits.
    • pub const fn role(mut self, role: FieldLabelRole) -> Self. Whether the label names or describes its control.
    • pub const fn scrub(mut self, on: bool) -> Self. Lets a drag on the label scrub the control's value.
    • pub const fn reset_dot(mut self, on: bool) -> Self. Shows a dot after the text while the control's value differs from its reset value; a click on it resets the value.
    • pub fn icon(mut self, icon: impl Into<IconSpec<'static>>) -> Self. Shows icon before the text.
    • pub fn detail(mut self, detail: impl Into<Label>) -> Self. Shows detail after the text, in the muted text colour, and adds it to the control's description.
    • pub fn tooltip(mut self, tooltip: impl Into<Tooltip>) -> Self. Shows tooltip over the label in place of its text, and adds it to the label's description.
  • craft_ui::contract::SizeLimits: pub struct SizeLimits { pub min: Vec2, pub max: Option<Vec2> }. Size limits, in points: the smallest size and, where there is one, the largest. A layer's (Overlay::size_limits)
    • pub const BOUND: f32. The largest value a limit or a height may have: a value above it is invalid.
    • pub const fn new(min: Vec2, max: Vec2) -> Self. Limits between min and max.
    • pub const fn at_least(min: Vec2) -> Self. No smaller than min, with no maximum.
    • pub const fn at_most(max: Vec2) -> Self. No larger than max, with no minimum.
    • pub fn around(self, extra: Vec2) -> Self. The limits of a frame that holds a size with these limits and extra around it: both ends grow by extra.
    • pub fn valid(self) -> bool. Whether every value is finite and non-negative, the maximum is no less than the minimum and no value is
  • craft_ui::contract::Sizing: pub enum Sizing { Fill, FillWidth, Content }. How a container's size follows its content.
  • craft_ui::contract::Slot: re-export of craft_ui::runtime::memory::Slot.
  • craft_ui::contract::SpaceAction: pub enum SpaceAction { Activate, ToggleCell, Preview, None }. What Space does in a collection (Enter always activates the lead).
  • craft_ui::contract::Styled: pub trait Styled. The resolved look (chapter 4); every method reads step 12's output.
    • fn state(&self) -> &StateSet. The state set.
    • fn root_state(&self) -> StateSet. The root's own state: the hover and press of the root without those of its parts, for a control whose parts
    • fn ink(&self) -> Ink. The ink the surface reads in.
    • fn resolve<T: Mix>(&self, look: &Stateful<T>) -> T. The value of look for the component's state set.
    • fn resolve_part<T: Mix>(&self, part: impl Into<PartRef>, look: &Stateful<T>) -> T. The value of look for the state set of part.
  • craft_ui::contract::SubNode: re-export of craft_ui::runtime::access::SubNode.
  • craft_ui::contract::SweepApply: pub struct SweepApply. The one consumer of a toggle column's events (CollectionEvent::Toggle), for a host that applies a sweep live.
    • pub fn new() -> Self. A plain column: Alt is ignored.
    • pub fn show_only() -> Self. A column where Alt plus the first press shows only that cell.
    • pub fn gesture(&self) -> Option<GestureId>. The first gesture of the running sweep, which a host that groups a sweep's edits as one undo step uses as the
    • pub fn feed<K: Clone>(&mut self, edit: &EditEvent<ToggleEdit<K>>) -> Option<SweepStep<K>>. The step for edit, if it asks the host for one. Commit repeats what its Update already applied.
  • craft_ui::contract::SweepStep: pub enum SweepStep<K> { Flip(ToggleEdit<K>), ShowOnly(ToggleEdit<K>), Restore(ToggleEdit<K>), UndoShowOnly(ToggleEdit<K>) }. What a host does for one toggle event, from [SweepApply::feed]. Each carries the cell's key, column and value.
  • craft_ui::contract::ThemeScope: pub struct ThemeScope. Token-changing values for a container's body: the body and everything under it resolve their styles from the
    • pub fn mode(mode: Mode) -> Self. A scope whose body resolves the inherited theme, contrast, density and text size in mode: a plot that is dark
  • craft_ui::contract::ToggleColumn: pub struct ToggleColumn { pub sweepable: bool, pub exclusive: bool, pub key: Option<Chord> }. A toggle column: its cells flip by click, and a drag across them sweeps one value over all of them.
    • pub const fn sweepable() -> Self. A sweepable toggle column (eye, lock, mute).
    • pub const fn exclusive() -> Self. An exclusive toggle column: one cell is on at a time, and a drag does not sweep.
    • pub const fn key(mut self, chord: Chord) -> Self. The column with chord as its key.
  • craft_ui::contract::ToggleEdit: pub struct ToggleEdit<K> { pub key: K, pub column: ColumnKey, pub on: bool, pub mods: craft_keymap::Mods }. A toggle column's cell flipped.
  • craft_ui::contract::Tooltip: pub struct Tooltip. A tooltip: one type for components and parts.
    • pub fn spec(&self) -> &TooltipSpec. What the tooltip shows and when.
  • craft_ui::contract::TooltipAt: pub enum TooltipAt { Control, Pointer }. Where a tooltip appears.
  • craft_ui::contract::TooltipSpec: pub struct TooltipSpec { pub text: Label, pub disabled_text: Option<Label>, pub at: TooltipAt, pub when: TooltipWhen }. What a tooltip shows and when.
    • pub fn new(text: impl Into<Label>) -> Self. A tooltip of text under the control, after the hover delay.
    • pub fn disabled_text(mut self, text: impl Into<Label>) -> Self. The text shown while the control is disabled.
    • pub const fn at(mut self, at: TooltipAt) -> Self. Where it appears.
    • pub const fn when(mut self, when: TooltipWhen) -> Self. When it appears.
  • craft_ui::contract::TooltipWhen: pub enum TooltipWhen { Hover, Now }. When a tooltip appears.
  • craft_ui::contract::Trigger: pub enum Trigger { Click, Press, Context, Hover, Hold, Manual }. How a free-standing popup's trigger fires.
  • craft_ui::contract::Tween: re-export of craft_ui::runtime::motion::Tween.
  • craft_ui::contract::Validity: pub type Validity<T> = craft_behavior::Validity<T, Message>. What a check says about a value, with the message type of craft-ui.
  • craft_ui::contract::ValueOf: pub type ValueOf<C> = <<C as super::Component>::Output as Outcome>::Value. The value type of C's output.
  • craft_ui::contract::WindowDropTarget: re-export of craft_ui::runtime::drag::WindowDropTarget.
  • craft_ui::contract::WordSetCx: pub trait WordSetCx. The label a component shows and the built-in text it reads (chapter 19).
    • fn label(&self) -> Label. The label as given, a cheap clone.
    • fn words<L: WordSet + Send + Sync + 'static>(&self) -> Arc<L>. The word set L in the language of the scope; built once per installed Words.
    • fn format(&self) -> &Format. How the scope writes numbers: locale digits, separators and grouping.
  • craft_ui::contract::announce: pub fn announce(ctx: &Context, text: impl Into<String>, politeness: Politeness). Announces text; for code without a context. Components call cx.announce. The same announcement made again
  • craft_ui::contract::clicked: pub fn clicked(response: &Response) -> bool. Whether response reports a click, by pointer or by keyboard activation.
  • craft_ui::contract::item_part_open: pub fn item_part_open(ctx: &Context, item: Id, part: impl Into<craft_behavior::PartRef>) -> bool. Whether a menu or popover hung from the part part of the item item (ItemCx::part_opener) is open: an item
  • craft_ui::contract::pressed: pub fn pressed(response: &Response) -> bool. Whether a pointer press went down on response's component and is still held.
  • craft_ui::contract::register_contract: re-export of craft_ui_macros::register_contract (outside these crates).
  • craft_ui::contract::request_rename: pub fn request_rename<K: Clone + Send + Sync + 'static>(ctx: &Context, collection: Id, key: &K). Asks the collection collection (the id it is built with, Props::id) to start renaming the item key. At its
  • craft_ui::contract::section_part: pub fn section_part<K: std::hash::Hash>(key: &K) -> craft_behavior::PartRef. The part of a collection that stands for the section row key (ItemSource::section_stop): the item step builds
  • craft_ui::contract::spec: re-export of the module craft_ui::runtime::motion::spec.
  • craft_ui::contract::step_stop: pub fn step_stop(stops: &[usize], from: Option<usize>, forward: bool) -> Option<usize>. The stop one step from the entry at from (a position in the entries), toward the end when forward. A step holds
  • craft_ui::contract::step_stops: pub fn step_stops<T>(entries: &[Entry<T>]) -> Vec<usize>. The positions of the entries a step over a closed control stops on ([Entry::is_stepped]), in order.

craft_ui::contract::ghost

The ghost layer's content (8.4, 8.5): the running drag's preview beside the pointer, the mark of the drop target that

  • craft_ui::contract::ghost::paint: pub fn paint(ctx: &Context). The end hook's painter of the ghost layer: pass it to InstallSpec::frame_layers.

craft_ui::contract::overlay

Chapter 15: the Overlay data, its presets, popup handles, OverlayUi and the overlay host.

  • craft_ui::contract::overlay::Anchor: pub enum Anchor { Rect(Rect), Response, Point(Pos2), Pointer, Corner(Rect, Align2) }. Where an overlay hangs from.
  • craft_ui::contract::overlay::Dismiss: pub struct Dismiss { pub outside: Outside, pub enter: bool, pub focus_left: bool, pub on_activate: bool, pub anchor_gone: bool, pub timeout: Option<f32> }. When a layer closes by itself. Escape goes through the focus policy's CancelRule.
    • pub const fn new() -> Self. An outside press closes; nothing else does.
    • pub const fn outside(mut self, outside: Outside) -> Self. Sets what an outside press does.
    • pub const fn enter(mut self, on: bool) -> Self. Closes on an untaken Enter.
    • pub const fn focus_left(mut self, on: bool) -> Self. Closes when focus leaves the scope.
    • pub const fn on_activate(mut self, on: bool) -> Self. Closes when a component inside is activated, except an opener toggling its popup.
    • pub const fn timeout(mut self, seconds: Option<f32>) -> Self. Closes after seconds.
  • craft_ui::contract::overlay::FloatPlace: pub struct FloatPlace { pub pos: Option<Pos2> }. Where a floating layer sits.
    • pub const fn centred() -> Self. Centred in the viewport.
    • pub const fn at(pos: Pos2) -> Self. At pos.
  • craft_ui::contract::overlay::HOLD: pub const HOLD: f64. The seconds a press must be held for Trigger::Hold.
  • craft_ui::contract::overlay::OpenFilter: re-export of craft_ui::runtime::overlay::OpenFilter.
  • craft_ui::contract::overlay::Opener: pub struct Opener { pub id: Id, pub rect: Rect, pub layer: areas::Layer, pub trigger: Trigger, pub enabled: bool, pub anchor: Option<Anchor>, pub others: Vec<Opener> }. A component that opens a free-standing popup, and how. A layer with several openers keeps the first as its
  • craft_ui::contract::overlay::Outside: pub enum Outside { Close, Keep, Absorb }. What a press outside the layer and its anchor does.
  • craft_ui::contract::overlay::Overlay: pub struct Overlay { pub place: Place, pub fit: OverlayFit, pub min_width: MinWidth, pub movable: bool, pub resize: Resize, pub rank: Rank, pub keys: OwnerClass, pub focus: FocusPolicy, pub dismiss: Dismiss, pub motion: MotionSpec, pub opener: Option<Opener>, pub popup: PopupKind, pub size: Option<Vec2>, pub size_limits: SizeLimits, pub placed: Option<Rect>, pub placed_at: Option<Pos2>, pub bounds: Option<Rect>, pub opacity: f32, pub body_scroll: bool, pub moves_window: bool }. Data describing an egui layer. Presets fill focus and dismissal; builders change single fields.
    • pub fn popover() -> Overlay. A popover: a popup anchored below, taking focus in. It closes when the focus moves out of it.
    • pub fn dropdown() -> Overlay. A dropdown list: from its content, at least as wide as its anchor and capped, focus stays on the anchor. It
    • pub fn menu() -> Overlay. A menu: a popup the arrow keys move through. A press outside closes it and goes no further.
    • pub fn submenu() -> Overlay. A submenu: beside its parent entry.
    • pub fn tooltip() -> Overlay. A tooltip: below the control, no focus, never takes input.
    • pub fn dialog() -> Overlay. A dialog: modal, floating, movable and resizable. .modeless() gives rank Window.
    • pub fn modal() -> Overlay. A modal: centred, content capped.
    • pub fn modal_chrome(rect: Rect) -> Overlay. The chrome of a modal over a part of the window the modal covers, placed at rect: above the modal, with no
    • pub fn toast(body: Rect, corner: Align2) -> Overlay. A toast stack at corner of body, a rect in the opener's layer space: the end-bottom corner of a window's body.
    • pub fn floating() -> Overlay. A floating panel or document window: a window-rank layer that is a pane of the app. F6 reaches it and Escape
    • pub fn resizable(mut self, on: bool) -> Overlay. Whether edge grips resize the layer.
    • pub fn modeless(mut self) -> Overlay. Rank Window and no backdrop.
    • pub fn place(mut self, place: Place) -> Overlay. Sets where it sits.
    • pub fn fit(mut self, fit: OverlayFit) -> Overlay. Sets how it sizes.
    • pub fn anchor(mut self, anchor: Anchor) -> Overlay. Hangs the layer from anchor on the side and alignment its preset gave. Without an opener, a point is in the
    • pub fn size(mut self, size: Vec2) -> Overlay. Sets the size a resizable layer has before the user resizes it.
    • pub fn min_size(mut self, min_size: Vec2) -> Overlay. Sets the least a resizable layer may be resized to.
    • pub fn size_limits(mut self, limits: SizeLimits) -> Overlay. Sets the least and the most a resizable layer may be resized to.
    • pub fn placed(mut self, rect: Rect) -> Overlay. Places the layer at rect in its parent's space. The container reports the moves and resizes the user makes
    • pub fn placed_at(mut self, pos: Pos2) -> Overlay. Places the layer's top left at pos in its parent's space and sizes it from its content and size limits, so a
    • pub fn bounds(mut self, bounds: Rect) -> Overlay. Sets the rect a move or resize keeps the layer inside.
    • pub fn body_scroll(mut self, on: bool) -> Overlay. Whether a container mounted as this layer scrolls its body vertically (default on).
    • pub fn opacity(mut self, opacity: f32) -> Overlay. Sets the layer's opacity, from 0 (invisible) to 1.
    • pub fn min_width(mut self, min_width: MinWidth) -> Overlay. Sets the narrowest width.
    • pub fn movable(mut self, on: bool) -> Overlay. Sets whether the user may move it.
    • pub fn moves_window(mut self, on: bool) -> Overlay. Sets whether the move band moves the OS window the layer is shown in, in place of the layer.
    • pub fn focus(mut self, focus: FocusPolicy) -> Overlay. Sets the focus scope.
    • pub fn dismiss(mut self, dismiss: Dismiss) -> Overlay. Sets the dismissal rules.
    • pub fn motion(mut self, motion: MotionSpec) -> Overlay. Sets the open and close motion.
    • pub fn opened_by(mut self, anchor: &Response, trigger: Trigger) -> Overlay. Records an opener. An anchored layer hangs from the rect of the opener that opened it, on the side and
    • pub fn opener_anchor(mut self, anchor: Anchor) -> Overlay. Sets where the layer hangs when the opener named last opened it. A rect or point is in that opener's layer
  • craft_ui::contract::overlay::OverlayFit: pub enum OverlayFit { Content, Resizable, ContentCapped(ViewportShare) }. How an egui layer sizes.
  • craft_ui::contract::overlay::OverlayUi: pub struct OverlayUi<'a> { pub closed: Vec<(Id, CloseReason)> }. What the overlay hook gets: one call per anchored popup of this component, built at step 10 with the open state
    • pub fn closing(&self, popup: PopupHandle) -> Option<CloseReason>. Why popup closes at the end of this pass, as its show decided (its dismissal, or a close its body asked for);
    • pub fn anchor_part(&self, part: impl Into<PartRef>) -> Anchor. The anchor at the rect of the toggling part part of the owner. The layer's placement mirrors the side and
    • pub fn show<R>(&mut self, popup: PopupHandle, overlay: Overlay, mut body: impl FnMut(&mut Ui, &mut BodyCx<'_>) -> R) -> Option<R>. Shows the popup while its handle is open, on a popup surface, inside POPUP_PAD; the content is a body closure.
  • craft_ui::contract::overlay::Overlays: pub trait Overlays. The Cx trait that registers popups.
    • fn popup(&mut self, name: &'static str) -> PopupHandle. Registers the popup name of this component for this pass and returns its handle. A component registers every
  • craft_ui::contract::overlay::Place: pub enum Place { Anchored { anchor: Anchor, side: Side, align: Align }, Float(FloatPlace) }. Where an egui layer sits.
    • pub const fn anchored(anchor: Anchor, side: Side, align: Align) -> Self. An anchored place.
  • craft_ui::contract::overlay::PlacementChange: pub struct PlacementChange { pub rect: Rect, pub phase: GesturePhase, pub pointer: Option<Pos2>, pub kind: PlacementKind }. A move or resize of a layer the user made, or of the OS window a viewport mount shows in, reported to
  • craft_ui::contract::overlay::PlacementKind: pub enum PlacementKind { Move, Size(ResizeEdge), Keyboard }. What kind of gesture a PlacementChange reports.
  • craft_ui::contract::overlay::Popup: pub struct Popup. The open state of a container's layer that has an opener and no binding, driven from the opener's side.
    • pub fn open<C: Component>(opener: impl Into<Id>, cx: &mut Cx<'_, C>). Opens the container hung from opener (a [PopupHandle] or the id of the opener's response).
    • pub fn close<C: Component>(opener: impl Into<Id>, cx: &mut Cx<'_, C>). Closes the container hung from opener.
    • pub fn toggle<C: Component>(opener: impl Into<Id>, cx: &mut Cx<'_, C>). Opens the container hung from opener when it is closed, else closes it.
    • pub fn opening<C: Component>(popup: PopupHandle, cx: &Cx<'_, C>) -> bool. Whether the layer popup shows first in this pass: true in the passes of the frame it first shows, false
  • craft_ui::contract::overlay::PopupHandle: pub struct PopupHandle. An id and a name; Copy, never a snapshot of the open state.
    • pub fn at(self, index: usize) -> PopupHandle. The popup of the repeat index of this name: a component with one popup per part or per entry gives each its
    • pub fn id(self) -> Id. The popup's id: its open state's and its entry in the layer stack.
    • pub fn name(self) -> &'static str. The name given to cx.popup.
    • pub fn trigger<C: Component>(self, trigger: Trigger, cx: &mut Cx<'_, C>). Toggles or opens the popup from trigger at step 9, as the pass's pending open change.
    • pub fn open<C: Component>(self, cx: &mut Cx<'_, C>). Queues an open that step 15 writes. For Trigger::Manual this and the binding are the only ways it opens.
    • pub fn close<C: Component>(self, cx: &mut Cx<'_, C>). Queues a close; step 15 writes the slot, so this pass still shows the popup open.
    • pub fn changed<C: Component>(self, cx: &mut Cx<'_, C>) -> bool. Whether a toggle, open or close queued in this pass leaves the popup's open state different from the
    • pub fn bind_open<C: Component>(self, cx: &mut Cx<'_, C>, mut open: BindMut<'_, bool>) -> bool. Binds the popup's open state to open: call it in update, after the toggles and closes the component
    • pub fn is_open<C: Component>(self, cx: &mut Cx<'_, C>) -> bool. Whether the popup is open in this pass: valid from step 8, with the changes queued so far applied.
  • craft_ui::contract::overlay::Resize: pub struct Resize { pub grips: bool }. How the user may resize a layer.
    • pub const NONE: Resize. The layer keeps its size.
    • pub const GRIPS: Resize. Grips on every edge and corner.
  • craft_ui::contract::overlay::SizeLimits: pub struct SizeLimits { pub min: Vec2, pub max: Option<Vec2> }. Size limits, in points: the smallest size and, where there is one, the largest. A layer's (Overlay::size_limits)
    • pub const BOUND: f32. The largest value a limit or a height may have: a value above it is invalid.
    • pub const fn new(min: Vec2, max: Vec2) -> Self. Limits between min and max.
    • pub const fn at_least(min: Vec2) -> Self. No smaller than min, with no maximum.
    • pub const fn at_most(max: Vec2) -> Self. No larger than max, with no minimum.
    • pub fn around(self, extra: Vec2) -> Self. The limits of a frame that holds a size with these limits and extra around it: both ends grow by extra.
    • pub fn valid(self) -> bool. Whether every value is finite and non-negative, the maximum is no less than the minimum and no value is
  • craft_ui::contract::overlay::Trigger: pub enum Trigger { Click, Press, Context, Hover, Hold, Manual }. How a free-standing popup's trigger fires.
  • craft_ui::contract::overlay::ViewportShare: pub struct ViewportShare { pub x: f32, pub y: f32 }. A fraction of the viewport per axis.
    • pub const fn new(x: f32, y: f32) -> Self. A share of x of the width and y of the height.
  • craft_ui::contract::overlay::any_open: re-export of craft_ui::runtime::overlay::any_open.
  • craft_ui::contract::overlay::family: re-export of craft_ui::runtime::overlay::family.
  • craft_ui::contract::overlay::is_open: re-export of craft_ui::runtime::overlay::is_open.
  • craft_ui::contract::overlay::paint_frame_layers: pub fn paint_frame_layers(ctx: &Context). Paints the ghost egui layer from runtime data: the drag preview and drop mark, and the painted cursor the cursor
  • craft_ui::contract::overlay::request_close: re-export of craft_ui::runtime::overlay::request_close.
  • craft_ui::contract::overlay::top: re-export of craft_ui::runtime::overlay::top.

craft_ui::contract::shape

The shapes of component: which show trait applies.

  • craft_ui::contract::shape::Body: pub struct Body. A component whose caller supplies a body closure.
  • craft_ui::contract::shape::Items: pub struct Items. A component that shows an item per visible entry of a source.
  • craft_ui::contract::shape::Leaf: pub struct Leaf. A component with no body and no items.

craft_ui::contract::toast

The toast host (15.5): one layer per window root (its id derives from the scope of the root's body) that lays out

  • craft_ui::contract::toast::CardOutcome: pub struct CardOutcome { pub hovered: bool, pub end: Option<ToastEnd> }. What a drawn card reports back to the host.
    • pub fn new(hovered: bool, end: Option<ToastEnd>) -> Self. A card the pointer rests on when hovered, which the user ended as end.
  • craft_ui::contract::toast::ToastHost: pub struct ToastHost. The layer that shows the toast queue of a window. The window root calls show once per pass with its window and
    • pub fn show(ui: &Ui, window: &WindowKey, body: Rect, card: &mut dyn FnMut(&mut Ui, &Toast, IdSalt) -> CardOutcome). Lays out every queued toast of window, oldest at the top, at the end-bottom corner of body (a rect of ui's

craft_ui::contract::tooltip

contract::tooltip: the one step-16 function that shows every tooltip (3.4, 15.5).

  • craft_ui::contract::tooltip::DELAY: pub const DELAY: f64. Seconds the pointer rests on a component before its tooltip shows.
  • craft_ui::contract::tooltip::GRACE: pub const GRACE: f64. Seconds after a tooltip hides during which the next one shows at once.
  • craft_ui::contract::tooltip::TipStyle: pub struct TipStyle. The look of a tooltip card.
  • craft_ui::contract::tooltip::attach: pub fn attach(response: &egui::Response, tooltip: &Tooltip). Shows tooltip for a raw egui response during the app migration: the same delay, grace and placement as a
  • craft_ui::contract::tooltip::with_chord: pub fn with_chord(base: &str, chord: &craft_keymap::Chord, os: craft_keymap::Platform) -> String. A tooltip's text followed by the chord that does the same, as every tooltip shows a key: "Hide Layers (⌘,)".

craft_ui::layout

The layout services: LabelColumn, ColumnGroup, the Grid cursor, measure_slot and arrange.

  • craft_ui::layout::BodyLayout: pub enum BodyLayout { Stack, Row { wrap: bool, align: RowAlign }, Grid { columns: Cow<'static, [ColumnWidth]> } }. How a body lays out its children, in reading order: mirrored under a right-to-left direction.
    • pub const fn stack() -> Self. Children one under another.
    • pub const fn row() -> Self. Children side by side from the start edge, with no wrap.
    • pub fn grid(columns: impl Into<Cow<'static, [ColumnWidth]>>) -> Self. Children row-major over columns: a 'static slice, or columns built in the pass.
    • pub fn wrap(self, on: bool) -> Self. A Row that wraps; any other layout is unchanged.
    • pub fn align(self, align: RowAlign) -> Self. A Row with align; any other layout is unchanged.
  • craft_ui::layout::ColumnGroup: pub struct ColumnGroup. The widest content per column key of one scope, measured through the same LayoutMemory rule as a Grid
    • pub fn scope<R>(ui: &mut Ui, key: impl Hash + Debug, rows: impl FnOnce(&mut Ui, &mut ColumnGroup) -> R) -> R. Runs rows with a group named key under ui. A measuring run records the widest width per column the rows
    • pub fn barrier<R>(ui: &mut Ui, rows: impl FnOnce(&mut Ui) -> R) -> R. Runs rows with no group open: a labelled row inside reads no column, so only the rows that sit directly in a
    • pub fn width(&mut self, ui: &Ui, column: &ColumnKey, content: f32) -> f32. The width every row gives column column: the widest content this pass's measuring run found, or in that run
  • craft_ui::layout::Placed: pub struct Placed<'c>. A keyed child for arrange; shown once, under the id derived from the key.
    • pub fn new<C: Show + 'c>(key: impl Hash + Debug + 'c, child: C) -> Self. A child shown under the id key derives from the arranging Ui.
    • pub fn response(&self) -> Option<&Response>. The child's response after arrange showed it.
  • craft_ui::layout::RowAlign: pub enum RowAlign { Start, Center, End, SpaceBetween }. Where a Row places its block of children along the row.
  • craft_ui::layout::ShrinkOrder: pub enum ShrinkOrder { Even, FromEnd }. Which units of a row too long for its room give way first.
  • craft_ui::layout::ShrinkUnit: pub struct ShrinkUnit { pub ideal: f32, pub least: f32 }. The widths of a unit of a row that shrinks to fit: the width it asks for and the least it narrows to.
  • craft_ui::layout::arrange: pub fn arrange(ui: &mut Ui, layout: &dyn Arrangement, children: &mut [Placed<'_>]) -> Rect. Places children by layout in the rest of ui and shows each once. The placement is logical; its output
  • craft_ui::layout::control_baseline: pub fn control_baseline(ctx: &egui::Context, id: Id, label: Vec2, label_baseline: f32) -> Option<f32>. The control's first baseline from its top, as record_control_baseline stored it last pass. A control that paints
  • craft_ui::layout::measure_slot: pub fn measure_slot(ui: &mut Ui, width: f32, body: impl FnOnce(&mut Ui)) -> Vec2. Runs body in an invisible sizing pass width wide and returns the size it took. Nothing is allocated in
  • craft_ui::layout::place_label: pub fn place_label(ui: &Ui, id: Id, column: &LabelColumn, flow: Flow, label: Vec2, label_baseline: f32) -> LabelPlacement. Places a label of label size with baseline label_baseline and the control of the row id in flow's
  • craft_ui::layout::record_control_baseline: pub fn record_control_baseline(ui: &Ui, id: Id, baseline: f32). Stores the distance from the top of the control of the row id to its first baseline, for the next
  • craft_ui::layout::shrink_widths: pub fn shrink_widths(units: &[ShrinkUnit], fixed: f32, room: f32, order: ShrinkOrder) -> Vec<f32>. The widths of the units of a row whose units, with fixed (its other children and gaps), ask for more than room:

craft_ui::layout_components

The layout components Stack, Row and Grid: containers with no surface, header or footer whose body

  • craft_ui::layout_components::LayoutStyle: pub struct LayoutStyle. The style of the layout components: no minimum size, and padding only at the start edge, one

craft_ui::primitives

Painters, Draw, the sensing core, the text adapter and ImeSurface.

  • craft_ui::primitives::CachedTexture: pub struct CachedTexture { pub id: TextureId, pub size: PixelSize }. A stored picture as a painter draws it: painter.image(texture.id, rect, uv, tint).
    • pub fn size_vec2(&self) -> Vec2. size as a vector, for fitting: only the aspect matters to a cell.
    • pub fn sized(&self) -> SizedTexture. The texture with its size, the form PreviewPane and egui's image widgets take.
  • craft_ui::primitives::Checker: pub struct Checker { pub size: Option<f32>, pub light: Option<DataColor>, pub dark: Option<DataColor> }. The cells of the transparency checkerboard: their side and the two colours. A field left unset takes the
    • pub const fn new() -> Self. The theme's checker.
    • pub const fn size(mut self, size: f32) -> Self. Cells of size points.
    • pub const fn colors(mut self, light: DataColor, dark: DataColor) -> Self. The light and dark colours.
    • pub fn shape(&self, ctx: &Context, tokens: &UiTokens, area: CheckerArea, origin: Pos2) -> Shape. The checkerboard over area as one textured shape: square cells of the light and dark colours, a light cell
  • craft_ui::primitives::CheckerArea: pub enum CheckerArea { Rect(Rect, CornerRadius), Quad([Pos2; 4]) }. Where a [Checker] paints.
  • craft_ui::primitives::ChordText: pub struct ChordText. A chord formatted for the OS, as one text run laid out as its own left-to-right run.
    • pub fn new(formatted: impl Into<String>) -> Self. A chord already formatted by craft-keymap's pure function over craft_keymap::layout.
    • pub fn run(&self) -> TextRun<'_>. The chord as a run laid out left to right in any direction.
    • pub fn isolated(&self) -> String. The chord isolated as a left-to-right run (LRI ... PDI) for use inside a longer label.
  • craft_ui::primitives::Completer: pub trait Completer: Send + Sync. Completion candidates for a text part.
    • fn complete(&self, text: &str, caret: usize, out: &mut Vec<Completion>) -> Option<Range<usize>>. The candidates for the text before the caret, and the byte range they replace.
  • craft_ui::primitives::Completion: pub struct Completion { pub label: Label, pub insert: String, pub mark: Option<Label>, pub description: Option<Label> }. One completion candidate.
    • pub fn new(label: impl Into<Label>, insert: impl Into<String>) -> Self. A candidate shown as label that inserts insert.
    • pub fn mark(mut self, mark: impl Into<Label>) -> Self. Sets the mark before the label.
    • pub fn description(mut self, description: impl Into<Label>) -> Self. Sets the description shown while the candidate is highlighted.
  • craft_ui::primitives::ContentPainterCx: pub struct ContentPainterCx<'a> { pub painter: Painter }. The raw painter of an allowlisted content painter, clipped to its rect.
    • pub fn ink(&self) -> Color32. The colour of text and glyphs on the surface being painted: the resolved content-text colour Draw paints
    • pub fn stroke_width(&self, width: StrokeWidth) -> f32. The width in points of a named stroke width on this display, as Draw::stroke strokes it: a content painter
    • pub fn faded(&self, share: f32, paint: impl FnOnce(&ContentPainterCx<'_>)). Runs paint with a ContentPainterCx whose painting is share as opaque as it would be: the fade
    • pub fn layout(&self, text: &DocText<'_>) -> TextLayout. The one sanctioned text layout for content painters: document runs with their own font, size and colour,
  • craft_ui::primitives::Dashes: pub struct Dashes { pub dash: f32, pub gap: f32, pub phase: f32 }. The lengths of a dashed stroke, in points along the path.
    • pub fn new(dash: f32, gap: f32) -> Self. Dashes of dash with gaps of gap, starting at the pattern's beginning.
    • pub fn even(length: f32) -> Self. Dashes of length with gaps of the same length, starting at the pattern's beginning.
    • pub fn phase(mut self, phase: f32) -> Self. The pattern advanced by phase points.
  • craft_ui::primitives::DataStrokeWidth: pub enum DataStrokeWidth { Named(StrokeWidth), Data(DataWidth) }. The width of a stroke: a named theme width or one from the document.
  • craft_ui::primitives::DataWidth: pub struct DataWidth. A line width the data gives (a path's thickness, a pen size), in screen points: the caller maps a document width
    • pub const fn points(points: f32) -> Self. A width of points.
  • craft_ui::primitives::DocRun: pub struct DocRun<'a> { pub text: Cow<'a, str>, pub font: FontRef, pub size: f32, pub weight: u16, pub italic: bool, pub color: DataColor, pub underline: bool, pub strikethrough: bool, pub indent: f32 }. One run of document text.
    • pub fn new(text: impl Into<Cow<'a, str>>, font: FontRef, size: f32, color: DataColor) -> Self. A regular-weight upright run without lines or indent.
    • pub fn italic(mut self) -> Self. Italic.
    • pub fn bold(mut self) -> Self. Bold weight.
    • pub fn underline(mut self) -> Self. Underlined.
    • pub fn strikethrough(mut self) -> Self. Struck through.
    • pub fn indent(mut self, points: f32) -> Self. points of space before the run.
    • pub fn into_owned(self) -> DocRun<'static>. The run owning its text.
  • craft_ui::primitives::DocText: pub struct DocText<'a> { pub runs: &'a [DocRun<'a>], pub wrap: Option<f32>, pub align: HAlign, pub elide: bool }. Document text: runs with their own font, size and colour. On TextRun these fields would let any component
    • pub const fn new(runs: &'a [DocRun<'a>]) -> Self. Unwrapped document text of runs.
    • pub const fn elide(mut self) -> Self. Cuts the text to one row with an ellipsis at the end.
    • pub fn full_text(&self) -> String. The text of every run, joined.
  • craft_ui::primitives::Draw: pub struct Draw<'a>. The content-paint API PaintUi::draw gives.
    • pub fn text(&self, rect: Rect, run: &TextRun<'_>) -> TextLayout. Lays run out in rect's width and paints it at the reading start of rect. A single line is centred
    • pub fn text_on_centre_line(&self, rect: Rect, run: &TextRun<'_>) -> TextLayout. Paints a one-line run as text does, with the middle of its lowercase letters (the x-height) on the middle
    • pub fn doc(&self, rect: Rect, text: &DocText<'_>) -> TextLayout. Lays text out in rect's width and paints it top aligned, its block placed in rect by text.align (Start
    • pub fn layout(&self, run: &TextRun<'_>, max_width: f32) -> TextLayout. Lays run out in max_width without painting it: the one text layout path for painters that measure before
    • pub fn galley(&self, pos: Pos2, layout: &TextLayout). Paints a laid-out run at pos. Records the first baseline and, when the layout cut text, the full text, as
    • pub fn icon(&self, rect: Rect, icon: &super::IconSpec<'_>). Paints icon centred in rect, in the colour or ink the spec names, mirrored under right-to-left when it is
    • pub fn reset_mark(&self, look: &crate::style::ResetMarkLook, center: Pos2, differs: bool). Paints the reset mark of look centred on center: the dot while the value differs, else the ring.
    • pub fn marker(&self, look: &crate::style::MarkerLook, marker: &super::Marker). Paints marker in look. A Draw for an inactive part fills a filled marker with the theme's disabled fill, as
    • pub fn rule(&self, kind: RuleKind, from: Pos2, to: Pos2). Paints the line of kind from from to to.
    • pub fn edge_rule(&self, kind: RuleKind, rect: Rect, side: RectSide). Paints the line of kind along the side edge of rect, on the physical pixels just inside it
    • pub fn scroll_bar(&self, look: &crate::style::ScrollBarLook, track: Rect, axis: craft_behavior::Axis, rtl: bool, span: &craft_behavior::ScrollSpan, state: &crate::style::StateSet,). Paints the scroll bar in track along axis for span, in state (ScrollBar::shapes).
    • pub fn rule_width(&self, kind: RuleKind) -> f32. The width in points of the line rule paints for kind.
    • pub fn rule_with(&self, look: &crate::style::RuleLook, from: Pos2, to: Pos2). Paints the line look from from to to, snapped to physical pixels as rule is: a rule in a component's own
    • pub fn surface(&self, rect: Rect, kind: SurfaceKind, corners: Corners). Paints a surface of kind (tracks, plot wells).
    • pub fn surface_styled(&self, rect: Rect, style: &SurfaceStyle). Paints a surface of an already resolved style (a kind's look with one field changed, as a knob's round radius).
    • pub fn surface_look(&self, rect: Rect, look: &crate::style::SurfaceLook, state: &crate::style::StateSet). Paints look over rect in state, as the paint step paints a component's surface: a part's own surface (an
    • pub fn fill(&self, shape: &PaintShape, color: StyleColor). Fills shape.
    • pub fn stroke(&self, shape: &PaintShape, width: impl Into<DataStrokeWidth>, color: impl Into<StrokeColor>). Strokes shape at a theme width or a width from the document, in a theme colour or a colour from data (a
    • pub fn data_fill(&self, shape: &PaintShape, color: DataColor). Fills shape with a colour from data (a swatch well, a layer label dot, an avatar). A Draw for an inactive
    • pub fn texture(&self, rect: Rect, texture: TextureId, uv: Rect). Paints the part uv of texture (from TextureCache or a TextureStore) into rect, untinted. A Draw
    • pub fn checker(&self, checker: &super::Checker, rect: Rect, radius: CornerRadius). Paints checker over rect with corners radius, a light cell at the rect's top left. A Draw for an
    • pub fn swatch_well(&self, well: Rect, radius: CornerRadius, color: Option<Srgba>). Paints the well of a colour swatch over well with corners radius: the colour, over a checkerboard where it is
    • pub fn dashed(&self, path: &[Pos2], pattern: Dashes, width: impl Into<DataStrokeWidth>, color: impl Into<StrokeColor>). Strokes the open path path as dashes (copy marks, drag previews, reference lines), with the width and colour
    • pub fn clipped(&self, rect: Rect, paint: impl FnOnce(&Draw<'_>)). Runs paint with a Draw whose painting is cut to rect (inside the clip already in force): scrolled content
    • pub fn faded(&self, share: f32, paint: impl FnOnce(&Draw<'_>)). Runs paint with a Draw whose fills, strokes, text runs, icons and pictures are all share as opaque as
  • craft_ui::primitives::EditorLine: pub struct EditorLine<'a> { pub text: &'a str, pub rect: Rect, pub baseline: f32, pub runs: &'a [EditorRun<'a>] }. One visible line of an own-caret editor.
    • pub const fn new(text: &'a str, rect: Rect, baseline: f32, runs: &'a [EditorRun<'a>]) -> Self. A line of text at rect.
  • craft_ui::primitives::EditorPurpose: pub enum EditorPurpose { Text, Code, Number, Password }. What an editor part edits.
  • craft_ui::primitives::EditorRun: pub struct EditorRun<'a> { pub bytes: Range<usize>, pub rtl: bool, pub positions: &'a [f32], pub widths: &'a [f32] }. One bidi run of a line: its bytes, direction, each character's start offset and advance.
    • pub const fn new(bytes: Range<usize>, rtl: bool, positions: &'a [f32], widths: &'a [f32]) -> Self. A run over bytes.
  • craft_ui::primitives::EditorState: pub struct EditorState<'a> { pub caret: Rect, pub lines: &'a [EditorLine<'a>], pub caret_at: TextPos, pub selection: Option<(TextPos, TextPos)>, pub revision: u64, pub can_undo: bool, pub can_redo: bool }. What an own-caret editor reports once per frame for the IME and AccessKit.
    • pub const fn new(caret: Rect, lines: &'a [EditorLine<'a>], caret_at: TextPos, revision: u64) -> Self. A state with no selection and nothing to undo.
  • craft_ui::primitives::FacesCx: pub trait FacesCx. Where a document face is asked for: a component's context, its measure or a content painter.
    • fn document_face(&self, key: &str, load: impl FnOnce() -> Option<FaceBytes>) -> FaceState. The face registered under key as a family of its own. load runs only for a new key within the frame's
  • craft_ui::primitives::FakeThumbSource: pub struct FakeThumbSource<K>. A [ThumbSource] for stories and tests in every crate: pictures made from the key and a revision the test sets,
    • pub fn new() -> Self. Synchronous square pictures at revision 0.
    • pub fn later(mut self, later: bool) -> Self. Renders as Later jobs.
    • pub fn opaque(mut self, opaque: bool) -> Self. The picture has no transparent quarter.
    • pub fn aspect(mut self, width: u32, height: u32) -> Self. The frame's width to height (4:3 landscape, 3:4 portrait).
    • pub fn failing(mut self, keys: impl IntoIterator<Item = K>) -> Self. These keys fail.
    • pub fn blank(mut self, keys: impl IntoIterator<Item = K>) -> Self. These keys have no picture.
    • pub fn set_revision(&mut self, revision: u64). Every key's revision.
    • pub fn bump(&mut self). Moves every key's revision on by one.
  • craft_ui::primitives::FocusKind: pub enum FocusKind { Ring, Halo }. How a focus indication is drawn.
  • craft_ui::primitives::FocusRing: pub struct FocusRing. The focus ring painter.
    • pub fn visible(flags: Flags) -> bool. Whether a part with flags shows its ring: only when it is the focused component or its active part, with
    • pub fn shapes(look: &FocusLook, kind: FocusKind, shape: &PaintShape, pixels_per_point: f32) -> Vec<Shape>. The shapes of the ring around shape, grown by look.offset. A halo adds a stroke twice as wide at a
  • craft_ui::primitives::Glyph: pub trait Glyph: Sync. A value glyph: an icon drawn from a value. It is Sync because container props that show one are kept with a
    • fn directional(&self) -> bool. Whether the glyph has a reading direction (an arrow) and so flips under right-to-left.
    • fn paint(&self, painter: &Painter, tokens: &UiTokens, rect: Rect, color: Color32, mirrored: bool). Paints the glyph into rect in color, with the strokes of tokens. mirrored is set when a directional
  • craft_ui::primitives::GridAxis: pub struct GridAxis { pub minor: Vec<f64>, pub major: Vec<f64> }. The lines of one axis: positions along it, in the grid's space.
  • craft_ui::primitives::GridInk: pub struct GridInk { pub major: Option<DataColor>, pub minor: Option<DataColor>, pub stroke: GridStroke }. The colours a grid's lines take; an unset one is the theme's.
    • pub const fn new() -> Self. The theme's colours and solid lines.
    • pub const fn major(mut self, color: DataColor) -> Self. The major lines in color.
    • pub const fn minor(mut self, color: DataColor) -> Self. The minor lines in color.
    • pub const fn stroke(mut self, stroke: GridStroke) -> Self. The lines drawn as stroke.
  • craft_ui::primitives::GridLines: pub struct GridLines { pub x: GridAxis, pub y: GridAxis, pub extent: Option<kurbo::Rect>, pub crossings: bool, pub view: Option<CanvasView> }. The lines of a grid, as [grid_lines] draws them: vertical lines (by x) and horizontal lines (by y), each
    • pub fn document(view: &CanvasView, extent: kurbo::Rect, spacing: kurbo::Vec2, origin: kurbo::Point, subdivisions: u32) -> Self. The lines of a grid in document units: majors every spacing from origin, subdivisions steps to a major
    • pub fn screen(rect: Rect, spacing: Vec2, clip: Rect, pixels_per_point: f32) -> Self. The lines over rect that clip shows, every spacing points from the rect's top-left corner, all major.
  • craft_ui::primitives::GridLook: pub struct GridLook. What the lines of a grid read from the tokens: the line colour and width, and the dash and gap lengths.
    • pub fn of(tokens: &UiTokens) -> Self. The grid look of tokens.
  • craft_ui::primitives::GridStroke: pub enum GridStroke { Solid, Dashed, Dots }. How the lines of a grid are drawn.
  • craft_ui::primitives::HAlign: pub enum HAlign { Start, Center, End }. Where the lines of a multi-line run sit within the run's width.
  • craft_ui::primitives::Handle: pub struct Handle. The handle painter.
    • pub fn shapes(look: &HandleLook, shape: HandleShape, center: Pos2, state: &StateSet) -> Vec<Shape>. The shapes of a handle of shape centred on center, filled for state.
  • craft_ui::primitives::HandleShape: pub enum HandleShape { Square, Circle, Diamond }. The outline of a handle.
  • craft_ui::primitives::HiddenContent: pub struct HiddenContent { pub left: f32, pub right: f32, pub top: f32, pub bottom: f32 }. How far a scroll view's content runs past each of its edges, in points.
    • pub fn new(content: Vec2, view: Vec2, offset: Vec2, rtl: bool) -> Self. The content of content points past a view of view points scrolled by offset, with x counted from the
  • craft_ui::primitives::IconSet: re-export of craft_ui::primitives::icon::IconSet (defined outside these crates).
  • craft_ui::primitives::IconSource: pub enum IconSource<'a> { Svg(IconId), Glyph(&'a dyn Glyph), Swatch(Option<Srgba>), Disc, Initial(char) }. Where an icon's drawing comes from.
  • craft_ui::primitives::IconSpec: pub struct IconSpec<'a> { pub source: IconSource<'a>, pub ink: Ink, pub color: Option<StyleColor>, pub mirror: Mirror, pub set: IconSet, pub badge: Option<DataColor> }. An icon to paint.
    • pub fn svg(id: IconId) -> Self. An icon of the SVG set or a tool icon, in the panel ink.
    • pub fn glyph(glyph: &'a dyn Glyph) -> Self. An icon of glyph in the panel ink.
    • pub fn swatch(color: Srgba) -> Self. A swatch of color, painted as Draw::swatch_well paints a well.
    • pub fn empty_swatch() -> Self. The empty swatch of a colour the theme decides (a "Default" pasteboard colour): it keeps a swatch's place, so
    • pub fn initial(name: &str) -> Self. The first letter of name in capitals, in an outlined box, in the panel ink: the icon of something that has
    • pub fn disc() -> Self. A filled circle in the panel ink, or in the colour color or data_color
    • pub fn ink(mut self, ink: Ink) -> Self. Sets the ink.
    • pub fn color(mut self, color: StyleColor) -> Self. Sets the colour, in place of the ink's.
    • pub fn data_color(mut self, color: DataColor) -> Self. Sets the colour from data, in place of the ink's: an icon drawn in document content (an annotation pictogram),
    • pub fn mirror(mut self, mirror: Mirror) -> Self. Sets the mirroring.
    • pub fn set(mut self, set: IconSet) -> Self. Sets the set an SVG icon is drawn from.
    • pub fn badge(mut self, color: DataColor) -> Self. Adds a dot of color at the bottom-trailing corner of an SVG or glyph icon, ringed in the icon's colour: the
  • craft_ui::primitives::ImeSurface: pub struct ImeSurface. The handle of an editor part's focus widget.
  • craft_ui::primitives::LayoutRun: pub struct LayoutRun { pub bytes: Range<usize>, pub rtl: bool, pub positions: Vec<f32>, pub widths: Vec<f32> }. One direction run of a single-row layout, owned.
  • craft_ui::primitives::LoadFailure: pub enum LoadFailure { Missing, Unreadable, Panicked, Message(String) }. Why a job made no picture. A job carries no text: the state carries this value and the painter words it at run
    • pub fn text<'a>(&'a self, words: &'a TextureWords) -> &'a str. The failure tooltip in the words of the scope (cx.words::<TextureWords>()).
  • craft_ui::primitives::LoadResult: pub type LoadResult = Result<LoadedPicture, LoadFailure>. What a loader job returns: a LoadedPicture, or why there is none.
  • craft_ui::primitives::LoadedPicture: pub enum LoadedPicture { Image(ColorImage), Blank }. What a background job makes when it succeeds: a picture, or the answer that the key has none.
  • craft_ui::primitives::LoaderOptions: pub struct LoaderOptions { pub store: TextureStoreOptions, pub lanes: usize, pub jobs: Option<Arc<dyn Jobs>> }. A loader's settings, read when it is created (TextureLoader::in_context).
    • pub fn new() -> Self. Thumbnail budgets, the machine's lanes, the host's jobs.
    • pub fn store(mut self, store: TextureStoreOptions) -> Self. Settings of the loader's store.
    • pub fn lanes(mut self, lanes: usize) -> Self. Jobs running at once.
    • pub fn jobs(mut self, jobs: Arc<dyn Jobs>) -> Self. Where the lanes run.
  • craft_ui::primitives::MAX_LINES: pub const MAX_LINES: usize. Most lines a grid draws along one axis.
  • craft_ui::primitives::MAX_TEXTURE: pub const MAX_TEXTURE: u32. The largest texture side the library uploads.
  • craft_ui::primitives::Marker: pub struct Marker. A colour marker centred on at: the colour it marks (when filled), a ring and a halo ring just outside it.
    • pub const fn hollow(at: Pos2) -> Self. A ring that shows the field under it.
    • pub const fn filled(at: Pos2, color: Color32) -> Self. A disc of color; a translucent colour sits on the look's backing.
    • pub const fn size(mut self, size: MarkerSize) -> Self. Drawn at size.
    • pub const fn radius(mut self, radius: f32) -> Self. Drawn at radius in place of its size's: a ring round a picked mark, such as a selected blur pin's ring.
    • pub const fn selected(mut self, selected: bool) -> Self. The ring in the look's selected colour while selected.
    • pub fn size_radius(look: &MarkerLook, size: MarkerSize) -> f32. The radius of a marker of size, out to the inner edge of its ring.
    • pub fn reach(look: &MarkerLook, size: MarkerSize) -> f32. How far a marker of size reaches from its centre, halo included.
    • pub fn shapes(&self, look: &MarkerLook) -> Vec<Shape>. The shapes, bottom first.
  • craft_ui::primitives::MarkerSize: pub enum MarkerSize { Regular, Large }. How large a marker is drawn.
  • craft_ui::primitives::Mirror: pub enum Mirror { Auto, Never }. Whether a directional icon flips under right-to-left.
  • craft_ui::primitives::PaintShape: pub enum PaintShape { Rect(Rect, CornerRadius), Circle(Pos2, f32), Polygon(Vec<Pos2>), Path(Vec<Pos2>) }. A shape Draw::fill and Draw::stroke paint.
  • craft_ui::primitives::PartResult: pub struct PartResult { pub rect: Rect, pub press: PressState, pub hovered: bool, pub hover_pos: Option<Pos2>, pub flags: Flags, pub sense: Sense, pub inactive: bool, pub held: bool }. A part's results this pass.
    • pub const IDLE: PartResult. What a read returns for a part with no press history: face mode, or a part first registered this pass.
    • pub fn pressed(&self) -> bool. The part paints pressed: its own press, or one its component holds on it.
  • craft_ui::primitives::Priority: re-export of craft_ui::primitives::textures::Priority (defined outside these crates).
  • craft_ui::primitives::ReadingMeasure: pub struct ReadingMeasure { pub target: f32, pub least: f32 }. The width of a reading column, from the text it holds: a count of characters of the role's average character
    • pub const TARGET_CHARACTERS: f32. The characters in the measure a reading column aims for.
    • pub const LEAST_CHARACTERS: f32. The characters in the shortest measure a reading column allows.
    • pub fn of(role: TypeRole, layout: impl FnOnce(&TextRun<'static>) -> TextLayout) -> Self. The widths for text of role. layout lays a run out the way the component lays out its text
  • craft_ui::primitives::RectSide: pub enum RectSide { Top, Bottom, Left, Right }. A side of a rect, on screen: left and right stay put under right-to-left.
    • pub const fn start(rtl: bool) -> RectSide. The start side in reading order: left, or right under right-to-left.
    • pub const fn end(rtl: bool) -> RectSide. The end side in reading order: right, or left under right-to-left.
  • craft_ui::primitives::ResetMark: pub struct ResetMark. The reset mark painter.
    • pub fn shapes(look: &ResetMarkLook, center: Pos2, differs: bool) -> Vec<Shape>. The mark centred on center: the dot while the value differs, else the ring.
  • craft_ui::primitives::Revision: pub struct Revision. The version of a key's picture, computed by the app: a stored fingerprint, an Arc address with a Weak guard,
    • pub const fn new(value: u64) -> Revision. The revision value (a document's own change counter).
    • pub const fn get(self) -> u64. The number.
    • pub fn of(value: &impl Hash) -> Revision. The revision of anything hashable: Revision::of(&(fingerprint, doc_width)). Stable within one run of the
  • craft_ui::primitives::Rule: pub struct Rule. The rule painter.
    • pub fn shapes(look: &RuleLook, from: Pos2, to: Pos2, pixels_per_point: f32) -> Vec<Shape>. The line from from to to, snapped across its direction: a line whose physical width is odd sits on a
    • pub fn edge(look: &RuleLook, rect: Rect, side: RectSide, pixels_per_point: f32) -> Vec<Shape>. The line along the side edge of rect, on the physical pixels just inside it: a row's bottom rule or a
  • craft_ui::primitives::RuleKind: pub enum RuleKind { Divider, Edge, Grid, DropMark }. Which rule a look is for.
  • craft_ui::primitives::ScrollBar: pub struct ScrollBar. The scroll bar painter.
    • pub fn thumb(min_thumb: f32, track: Rect, axis: Axis, rtl: bool, span: &ScrollSpan) -> Rect. The thumb inside track, a bar along axis, for span: its length is the shown share of the track, at least
    • pub fn shapes(look: &ScrollBarLook, track: Rect, axis: Axis, rtl: bool, span: &ScrollSpan, state: &StateSet, pixels_per_point: f32,) -> Vec<Shape>. The shapes of the bar in track along axis for span, in state: the track, a docked bar's rule along the
  • craft_ui::primitives::Span: pub struct Span<'a> { pub text: Cow<'a, str>, pub italic: bool, pub tabular: bool, pub mono: bool, pub muted: bool, pub shortcut: bool, pub highlight: bool, pub underline: bool, pub strong: bool }. One styled stretch of a run.
    • pub fn new(text: impl Into<Cow<'a, str>>) -> Self. A plain span.
    • pub fn italic(mut self) -> Self. Italic.
    • pub fn tabular(mut self) -> Self. Tabular figures.
    • pub fn mono(mut self) -> Self. The monospace face.
    • pub fn muted(mut self) -> Self. The muted colour.
    • pub fn shortcut(mut self) -> Self. A shortcut hint.
    • pub fn highlight(mut self) -> Self. A match highlight.
    • pub fn underline(mut self) -> Self. Underlined: a link, or the mnemonic letter of a menu title.
    • pub fn strong(mut self) -> Self. The role's semibold face: a short mark that stands out among the row's other text, such as a layer's fx.
  • craft_ui::primitives::StateLayer: pub struct StateLayer. The state layer painter.
    • pub fn shapes(kind: StateLayerKind, color: StyleColor, rect: Rect, radius: CornerRadius, width: f32) -> Vec<Shape>. The shape of color over rect; an outline is width wide.
  • craft_ui::primitives::StateLayerKind: pub enum StateLayerKind { Fill, Outline }. How a state layer paints its colour.
  • craft_ui::primitives::StrokeColor: pub enum StrokeColor { Theme(StyleColor), Data(DataColor) }. The colour of a stroke: a theme colour or one from the data.
  • craft_ui::primitives::StrokeWidth: pub enum StrokeWidth { Hairline, Thin, Medium, Thick, Heavy }. A line width from the theme, so content never picks a literal one.
  • craft_ui::primitives::Surface: pub struct Surface. The surface painter: shadow, fill, then edge.
    • pub fn shapes(style: &SurfaceStyle, fill: Option<Color32>, rect: Rect, corners: Corners, direction: Direction, pixels_per_point: f32,) -> Vec<Shape>. The shapes of style over rect, snapped to the pixel grid: shadow, fill, edge. fill replaces the
  • craft_ui::primitives::TextKey: pub struct TextKey<V>. A text part's key, typed by the value its codec gives.
    • pub const fn new(key: PartKey) -> Self. The key of the text part key.
    • pub const fn key(self) -> PartKey. The part key.
  • craft_ui::primitives::TextLayout: pub struct TextLayout { pub galley: Arc<Galley>, pub elided: bool, pub full: String, pub first_baseline: f32, pub runs: Vec<LayoutRun>, pub rotation: f32 }. A laid-out run.
    • pub fn size(&self) -> egui::Vec2. The galley size.
  • craft_ui::primitives::TextOptions: pub struct TextOptions { pub placeholder: Option<Label>, pub lines: Option<usize>, pub limit: Option<usize>, pub mask: bool, pub live: bool, pub clear_on_escape: bool, pub mono: bool, pub role: TypeRole, pub ink: Option<Ink>, pub tab_inserts: bool, pub complete: Option<Arc<dyn Completer>>, pub complete_on_enter: bool, pub replace_selection: Option<String>, pub commit_on: &'static [char], pub enabled: bool, pub steps_value: bool, pub select_on_focus: bool, pub submits: bool, pub mixed: bool, pub centred: bool, pub arrows_from_end: bool, pub unparsed: Option<Message> }. How a text part behaves beyond its codec.
    • pub fn new() -> Self. Options with every default.
  • craft_ui::primitives::TextOutcome: pub struct TextOutcome<V> { pub rect: Rect, pub draft: Option<String>, pub value: Option<V>, pub layout: Option<super::TextLayout>, pub caret_visible: bool, pub invalid: bool, pub committed_tag: Option<u32>, pub composing: bool, pub completions: Vec<super::Completion> }. A text part's result this pass.
    • pub const fn new(rect: Rect) -> Self. An outcome over rect with no draft or value.
  • craft_ui::primitives::TextRun: pub struct TextRun<'a> { pub spans: Vec<Span<'a>>, pub role: TypeRole, pub color: Option<StyleColor>, pub wrap: Wrap, pub ltr: bool, pub align: HAlign, pub rotation: f32 }. The one description of UI text.
    • pub fn new(text: impl Into<Cow<'a, str>>) -> Self. A one-span run in the label role.
    • pub fn spans(spans: Vec<Span<'a>>) -> Self. A run of spans.
    • pub fn mnemonic(text: &'a str, at: Option<usize>) -> Self. text with its character at underlined, as a mnemonic shows while it is in use; all of text plain when
    • pub fn role(mut self, role: TypeRole) -> Self. Sets the type role.
    • pub fn color(mut self, color: StyleColor) -> Self. Sets the colour.
    • pub fn wrap(mut self, wrap: Wrap) -> Self. Sets how the run fits its room.
    • pub fn align(mut self, align: HAlign) -> Self. Sets where the lines sit within the run's width.
    • pub fn rotated(mut self, radians: f32) -> Self. Sets the angle the run is painted at, in radians clockwise about the top-left corner of its layout.
    • pub fn elide(self) -> Self. Cuts the run with an ellipsis at the end.
    • pub fn full_text(&self) -> String. The text of every span, joined.
  • craft_ui::primitives::TextureBudget: pub struct TextureBudget { pub max_bytes: usize, pub max_entries: usize, pub uploads_per_pass: usize, pub upload_bytes_per_pass: usize }. How much a store may hold and upload. Entries past max_bytes or max_entries are evicted; uploads_per_pass
    • pub const fn new(max_bytes: usize, max_entries: usize) -> Self. Holds max_bytes and max_entries; a loader uploads 16 pictures and 16 MiB per frame.
    • pub const fn uploads(mut self, count: usize, bytes: usize) -> Self. Other upload limits per frame.
  • craft_ui::primitives::TextureCache: re-export of craft_ui::primitives::textures::TextureCache.
  • craft_ui::primitives::TextureKey: pub trait TextureKey: Clone + Eq + Hash + Send + Sync + 'static. What can key a stored texture: a layer id, a path, a (document, page) pair. Every type with these bounds is
  • craft_ui::primitives::TextureLoader: pub struct TextureLoader<K: TextureKey>. A TextureStore whose pictures are made by background jobs: FilmCraft's frames, PdfCraft's pages and the
    • pub fn in_context(ctx: &Context, salt: impl Hash + Debug, options: LoaderOptions) -> Self. The loader of ctx under salt, made with options the first time; its store is
    • pub fn cache(&self) -> &TextureStore<K>. The loader's store: state, forget, retain and statistics work on it as on any store.
    • pub fn request<J>(&self, ctx: &Context, key: &K, revision: Revision, priority: Priority, job: impl FnOnce() -> J) -> TextureState where J: FnOnce(&Cancel) -> LoadResult + Send + 'static,. What key shows for revision, queueing the job job() makes when the store has nothing for this revision
    • pub fn ask(&self, ctx: &Context, key: &K, revision: Revision, priority: Priority) -> Option<TextureState>. What key shows for revision when that is known without a new job: Some of the store's Ready, Empty
    • pub fn submit(&self, ctx: &Context, key: K, revision: Revision, priority: Priority, job: impl FnOnce(&Cancel) -> LoadResult + Send + 'static,) -> TextureState. Queues job making key's picture at revision, replacing a queued job of the key, and returns Loading
    • pub fn shutdown(&self, timeout: std::time::Duration) -> bool. Stops the loader's queue: waiting jobs are dropped, running ones are cancelled, and the call waits up to
  • craft_ui::primitives::TextureState: pub enum TextureState { Missing, Loading { stand_in: Option<CachedTexture> }, Ready(CachedTexture), Empty, Failed { failure: LoadFailure } }. What a key shows for a revision, from TextureStore::state.
    • pub fn shown(&self) -> Option<CachedTexture>. The picture to draw now: the ready one, or the stand-in while loading.
  • craft_ui::primitives::TextureStatistics: pub struct TextureStatistics { pub entries: usize, pub bytes: usize, pub uploads: usize, pub upload_bytes: usize, pub evicted: usize }. What a store holds and did, for automation, stories and tests.
  • craft_ui::primitives::TextureStore: pub struct TextureStore<K: TextureKey>. Textures by key and revision, with byte and entry budgets: the one place an app's pictures become egui
    • pub fn in_context(ctx: &Context, salt: impl Hash + Debug, options: TextureStoreOptions) -> Self. The store of ctx under salt, made with options the first time. Later calls with the same salt get the
    • pub fn state(&self, ctx: &Context, key: &K, revision: Revision) -> TextureState. What key shows for revision (see TextureState), and marks the entry seen this frame.
    • pub fn put(&self, ctx: &Context, key: K, revision: Revision, image: ColorImage) -> CachedTexture. Stores image as key's picture at revision and returns it: in place when the key has a texture (same
    • pub fn put_region(&self, ctx: &Context, key: &K, revision: Revision, origin: [u32; 2], image: ColorImage) -> Option<CachedTexture>. Updates part of key's picture in place and moves the entry to revision: image goes at origin, both
    • pub fn get_or_put(&self, ctx: &Context, key: K, revision: Revision, make: impl FnOnce() -> ColorImage) -> CachedTexture. key's picture at revision, calling make and putting its image only when the entry has another revision
    • pub fn put_empty(&self, ctx: &Context, key: K, revision: Revision). Records that key has no picture at revision (state Empty); frees its texture.
    • pub fn put_failure(&self, ctx: &Context, key: K, revision: Revision, failure: LoadFailure). Records that making key's picture at revision failed (state Failed), so nothing asks for it again
    • pub fn forget(&self, ctx: &Context, key: &K). Drops key's entry and frees its texture.
    • pub fn retain(&self, ctx: &Context, mut keep: impl FnMut(&K) -> bool). Keeps only the entries whose key keep accepts (PhotoCraft's prune_thumbs when the open documents
    • pub fn clear(&self, ctx: &Context). Drops every entry (another library opened).
    • pub fn allow_upload(&self, ctx: &Context, bytes: usize) -> bool. Whether this frame's upload allowance has room for one more upload of bytes: fewer than uploads_per_pass
    • pub fn statistics(&self, ctx: &Context) -> TextureStatistics. What the store holds and uploaded this frame.
    • pub fn options(&self) -> TextureStoreOptions. The options the store was made with.
  • craft_ui::primitives::TextureStoreOptions: pub struct TextureStoreOptions { pub budget: TextureBudget, pub filter: TextureOptions }. A store's settings, read when the store is created (TextureStore::in_context).
    • pub const fn thumbnails() -> Self. Row and grid thumbnails: 32 MiB and 512 entries.
    • pub const fn pages() -> Self. Document pages: 128 MiB and 64 entries.
    • pub const fn frames() -> Self. Video frames and other named images: 64 MiB and 512 entries.
    • pub const fn filter(mut self, filter: TextureOptions) -> Self. The sampling of every texture.
    • pub const fn budget(mut self, budget: TextureBudget) -> Self. Other limits.
  • craft_ui::primitives::TextureWords: re-export of craft_ui::primitives::textures::TextureWords (defined outside these crates).
  • craft_ui::primitives::ThumbFit: pub enum ThumbFit { Contain, Cover }. How [Thumbnails::paint] fits a picture into its cell.
  • craft_ui::primitives::ThumbJob: pub type ThumbJob = Box<dyn FnOnce(&Cancel) -> Result<LoadedPicture, LoadFailure> + Send>. A background render: runs on a queue lane, checks the [Cancel] between steps, and returns the picture, the
  • craft_ui::primitives::ThumbPaint: pub struct ThumbPaint { pub fit: ThumbFit, pub checker: bool, pub paper: Option<DataColor>, pub tint: DataColor }. How to paint one thumbnail.
    • pub fn fit(mut self, fit: ThumbFit) -> Self. Sets how the picture fits its box.
    • pub fn checker(mut self, checker: bool) -> Self. Sets whether the transparency grid shows behind the picture.
    • pub fn paper(mut self, paper: DataColor) -> Self. Sets the paper under the picture: a fill in place of the transparency grid, whatever checker says (a page
    • pub fn tint(mut self, tint: DataColor) -> Self. Sets the tint that multiplies the picture.
  • craft_ui::primitives::ThumbRender: pub enum ThumbRender { Ready(ColorImage), Later(ThumbJob), Blank }. What a [ThumbSource] renders for a key.
  • craft_ui::primitives::ThumbRequest: pub struct ThumbRequest { pub side: u32, pub pixels_per_point: f32, pub region: Option<Rect> }. What a thumbnail is asked at: the side in pixels, the screen's density and the part of the frame wanted.
    • pub fn for_cell(points: f32, pixels_per_point: f32) -> ThumbRequest. The request for a cell points wide on a screen of pixels_per_point: the side in pixels rounded up to a
    • pub fn region(self, region: Rect) -> ThumbRequest. The request for the part region of the frame (fractions of the frame, 0 to 1).
  • craft_ui::primitives::ThumbSource: pub trait ThumbSource<K>. The app's side of the contract: how a key's picture is versioned and made.
    • fn revision(&self, key: &K, request: &ThumbRequest) -> Revision. The version of key's picture.
    • fn render(&self, key: &K, request: &ThumbRequest) -> ThumbRender. Makes key's picture, now or as a job.
  • craft_ui::primitives::ThumbnailOptions: pub struct ThumbnailOptions { pub max_side: u32, pub store: TextureStoreOptions, pub lanes: usize, pub jobs: Option<Arc<dyn Jobs>>, pub renders_per_pass: usize }. A [Thumbnails]' settings, read when it is created.
    • pub fn new() -> Self. Sides up to 512, thumbnail budgets, the machine's lanes, the host's jobs, 16 renders per pass.
    • pub fn max_side(mut self, max_side: u32) -> Self. The longest side any request is lowered to.
    • pub fn store(mut self, store: TextureStoreOptions) -> Self. Budgets of the texture store.
    • pub fn lanes(mut self, lanes: usize) -> Self. Lanes of the queue for Later renders.
    • pub fn jobs(mut self, jobs: Arc<dyn Jobs>) -> Self. Where the lanes run.
    • pub fn renders_per_pass(mut self, renders: usize) -> Self. Renders on the UI thread per pass.
  • craft_ui::primitives::Thumbnails: pub struct Thumbnails<K: TextureKey>. Thumbnails of one kind (layers, channels, snapshots, a grid's files) over one store: what every list and grid
    • pub fn in_context(ctx: &Context, salt: impl std::hash::Hash + std::fmt::Debug, options: ThumbnailOptions) -> Self. The thumbnails stored in ctx under salt, made with options the first time; the loader and its store
    • pub fn state(&self, ctx: &Context, source: &dyn ThumbSource<K>, key: &K, request: &ThumbRequest, priority: Priority) -> TextureState. What key shows now; renders or queues it when its revision has no picture yet.
    • pub fn paint(&self, cx: &ContentPainterCx<'_>, rect: Rect, state: &TextureState, paint: &ThumbPaint) -> bool. Paints state into rect and returns whether it drew anything:
    • pub fn shutdown(&self, timeout: Duration) -> bool. Stops the queue of Later renders and waits up to timeout for the running ones to end
    • pub fn hold(&self, hold: bool). Freezes the shown pictures while hold: no render starts and no job is queued; state returns the current
    • pub fn retain(&self, ctx: &Context, keep: impl FnMut(&K) -> bool). Keeps only the pictures whose key keep accepts (the open documents changed).
    • pub fn cache(&self) -> &super::TextureStore<K>. The store under the thumbnails, for forget, clear and statistics.
  • craft_ui::primitives::Tick: pub struct Tick { pub at: f32, pub rank: TickRank }. One tick: where it sits along its edge and how long it is.
    • pub const fn new(at: f32, rank: TickRank) -> Self. A tick at at of the length class rank.
  • craft_ui::primitives::TickEdge: pub enum TickEdge { Bottom, Top, Left, Right }. Which edge of a rect a tick row sits on, and so which way its marks point.
  • craft_ui::primitives::TickRank: pub enum TickRank { Minor, Mid, Major }. How long a tick is: the rank it has among its neighbours.
  • craft_ui::primitives::ToolIcon: pub enum ToolIcon { Custom(IconId), Move, Artboard, RectangularMarquee, EllipticalMarquee, SingleRowMarquee, SingleColumnMarquee, Brush, Pencil, MixerBrush, ColorReplacement, Eraser, BackgroundEraser, MagicEraser, Eyedropper, ColorSampler, Ruler, Note, Count, Lasso, PolygonalLasso, MagneticLasso, MagicWand, Crop, PerspectiveCrop, Slice, SliceSelect, Frame, Gradient, PaintBucket, HorizontalType, VerticalType, HorizontalTypeMask, VerticalTypeMask, Hand, RotateView, Zoom, SpotHealing, Healing, Remove, Patch, ContentAwareMove, RedEye, CloneStamp, PatternStamp, HistoryBrush, ArtHistoryBrush, Blur, Sharpen, Smudge, Dodge, Burn, Sponge, QuickSelection, ObjectSelection, Pen, FreeformPen, CurvaturePen, AddAnchorPoint, DeleteAnchorPoint, ConvertPoint, PathSelection, DirectSelection, Rectangle, Ellipse, Triangle, Polygon, Line, CustomShape }. A tool, for its icon: a raster editor's tool set, which other apps share variant for variant (a vector
    • pub const ALL: [ToolIcon; 68]. Every tool, in this enum's order.
    • pub fn icon(&self) -> IconId. The icon that draws the tool.
    • pub fn id(&self) -> &str. The tool's id as the apps' tool commands spell it (tool.rectangularMarquee without the
    • pub fn from_id(id: &str) -> Option<ToolIcon>. The built-in tool for an id, None for an unknown one and for a custom tool.
  • craft_ui::primitives::Wrap: pub enum Wrap { Line, Wrap, Elide, ElideStart, ElideMiddle, ElidePath, Clamp(u8) }. How a run fits its room.
    • pub const fn cuts(self) -> bool. Whether the run is one line cut to its room.
  • craft_ui::primitives::dashed: pub fn dashed(points: &[Pos2], pattern: Dashes, width: f32, color: Color32) -> Vec<Shape>. A dashed line along points in color, width thick, with the lengths and phase of pattern. The pattern
  • craft_ui::primitives::drop_mark: pub fn drop_mark(tokens: &UiTokens, from: Pos2, to: Pos2, pixels_per_point: f32) -> Vec<Shape>. The insertion mark of a drop from from to to.
  • craft_ui::primitives::ellipse: pub fn ellipse(center: Pos2, axes: [Vec2; 2]) -> Vec<Pos2>. The points of the ellipse with centre center and conjugate half-axes axes (a rotated or skewed circle is
  • craft_ui::primitives::fit_image: pub fn fit_image(image: ColorImage, max_side: u32) -> ColorImage. image reduced to at most max_side texels per side, or unchanged when it fits. The image is reduced by the
  • craft_ui::primitives::fit_rect: pub fn fit_rect(cell: Rect, picture: Vec2) -> Rect. The rect inside cell that shows a picture of picture's aspect whole, as large as fits and centred; cell
  • craft_ui::primitives::grid_lines: pub fn grid_lines(tokens: &UiTokens, grid: &GridLines, ink: &GridInk, pixels_per_point: f32) -> Vec<Shape>. The lines of grid as ink draws them: minor lines first, then the major ones, each running across
  • craft_ui::primitives::grid_lines_with: pub fn grid_lines_with(look: &GridLook, grid: &GridLines, ink: &GridInk, pixels_per_point: f32) -> Vec<Shape>. [grid_lines] from a look read earlier.
  • craft_ui::primitives::has_icon: pub fn has_icon(id: &IconId) -> bool. Whether the catalog has an icon named id.
  • craft_ui::primitives::icon_names: pub fn icon_names() -> &'static [&'static str]. The names of the catalog's icons, sorted.
  • craft_ui::primitives::marching_ants: pub fn marching_ants(tokens: &UiTokens, points: &[Pos2], closed: bool, phase: f32, clip: Rect, pixels_per_point: f32) -> Vec<Shape>. Marching ants along points (closed when closed) inside clip: bands of the marquee colour with dark dashes in
  • craft_ui::primitives::outline: pub fn outline(tokens: &UiTokens, shape: &PaintShape) -> Vec<Shape>. The line that marks a shape on any image: a thick halo under a medium line, in the overlay colours.
  • craft_ui::primitives::ramp: pub fn ramp(rect: Rect, radius: CornerRadius, stops: &[(f32, DataColor)], axis: Axis) -> Vec<Shape>. A colour ramp over rect with corners of radius (CornerRadius::ZERO for square ones): the strip shades from
  • craft_ui::primitives::reduce_image: pub fn reduce_image(image: &ColorImage, factor: u32) -> ColorImage. image box-averaged by the whole factor, in premultiplied values.
  • craft_ui::primitives::texture_factor: pub fn texture_factor(size: PixelSize, side: u32) -> u32. How many document pixels per side one texel of the base texture holds for a document of size with textures at
  • craft_ui::primitives::texture_side: pub fn texture_side(ctx: &Context) -> u32. The texture side on this device: [MAX_TEXTURE], or the device's smaller limit (2048 on some older GPUs and
  • craft_ui::primitives::thumb_image: pub fn thumb_image(frame: PixelSize, longest_side: u32, mut sample: impl FnMut(u32, u32) -> [u8; 4]) -> ColorImage. A picture of the document area frame (pixels) with that exact aspect, its longest side longest_side, each
  • craft_ui::primitives::ticks: pub fn ticks(tokens: &UiTokens, rect: Rect, edge: TickEdge, ticks: &[Tick], clip: Rect, pixels_per_point: f32) -> Vec<Shape>. The tick marks of ticks on one edge of rect that clip shows, stroke.thin lines of text.faint: minor ones

craft_ui::primitives::textures

TextureCache, the icon texture path, and beside it the keyed TextureStore with its background

  • craft_ui::primitives::textures::TextureCache: pub struct TextureCache. The texture cache of a context: components keep a cache key and ask for the texture when they paint.
    • pub const CAPACITY: usize. The number of textures above which the cache drops those no frame asked for lately.
    • pub fn texture<K: Hash + 'static>(ctx: &Context, key: K, image: impl FnOnce() -> ColorImage) -> TextureId. The texture for key: loads image() on the first request and returns the same texture afterwards. A key
    • pub fn texture_with<K: Hash + 'static>(ctx: &Context, key: K, options: TextureOptions, image: impl FnOnce() -> ColorImage) -> TextureId. The texture for key sampled with options (a repeating pattern, nearest filtering); see [Self::texture].
    • pub fn len(ctx: &Context) -> usize. The number of textures the context holds.
    • pub fn is_empty(ctx: &Context) -> bool. Whether the context holds no texture.
    • pub fn clear(ctx: &Context). Drops every texture of the context; the next request loads again.
  • craft_ui::primitives::textures::CachedTexture: pub struct CachedTexture { pub id: TextureId, pub size: PixelSize }. A stored picture as a painter draws it: painter.image(texture.id, rect, uv, tint).
    • pub fn size_vec2(&self) -> Vec2. size as a vector, for fitting: only the aspect matters to a cell.
    • pub fn sized(&self) -> SizedTexture. The texture with its size, the form PreviewPane and egui's image widgets take.
  • craft_ui::primitives::textures::FakeThumbSource: pub struct FakeThumbSource<K>. A [ThumbSource] for stories and tests in every crate: pictures made from the key and a revision the test sets,
    • pub fn new() -> Self. Synchronous square pictures at revision 0.
    • pub fn later(mut self, later: bool) -> Self. Renders as Later jobs.
    • pub fn opaque(mut self, opaque: bool) -> Self. The picture has no transparent quarter.
    • pub fn aspect(mut self, width: u32, height: u32) -> Self. The frame's width to height (4:3 landscape, 3:4 portrait).
    • pub fn failing(mut self, keys: impl IntoIterator<Item = K>) -> Self. These keys fail.
    • pub fn blank(mut self, keys: impl IntoIterator<Item = K>) -> Self. These keys have no picture.
    • pub fn set_revision(&mut self, revision: u64). Every key's revision.
    • pub fn bump(&mut self). Moves every key's revision on by one.
  • craft_ui::primitives::textures::LoadFailure: pub enum LoadFailure { Missing, Unreadable, Panicked, Message(String) }. Why a job made no picture. A job carries no text: the state carries this value and the painter words it at run
    • pub fn text<'a>(&'a self, words: &'a TextureWords) -> &'a str. The failure tooltip in the words of the scope (cx.words::<TextureWords>()).
  • craft_ui::primitives::textures::LoadResult: pub type LoadResult = Result<LoadedPicture, LoadFailure>. What a loader job returns: a LoadedPicture, or why there is none.
  • craft_ui::primitives::textures::LoadedPicture: pub enum LoadedPicture { Image(ColorImage), Blank }. What a background job makes when it succeeds: a picture, or the answer that the key has none.
  • craft_ui::primitives::textures::LoaderOptions: pub struct LoaderOptions { pub store: TextureStoreOptions, pub lanes: usize, pub jobs: Option<Arc<dyn Jobs>> }. A loader's settings, read when it is created (TextureLoader::in_context).
    • pub fn new() -> Self. Thumbnail budgets, the machine's lanes, the host's jobs.
    • pub fn store(mut self, store: TextureStoreOptions) -> Self. Settings of the loader's store.
    • pub fn lanes(mut self, lanes: usize) -> Self. Jobs running at once.
    • pub fn jobs(mut self, jobs: Arc<dyn Jobs>) -> Self. Where the lanes run.
  • craft_ui::primitives::textures::MAX_TEXTURE: pub const MAX_TEXTURE: u32. The largest texture side the library uploads.
  • craft_ui::primitives::textures::Priority: re-export of craft_ui::primitives::textures::loader::Priority (defined outside these crates).
  • craft_ui::primitives::textures::Revision: pub struct Revision. The version of a key's picture, computed by the app: a stored fingerprint, an Arc address with a Weak guard,
    • pub const fn new(value: u64) -> Revision. The revision value (a document's own change counter).
    • pub const fn get(self) -> u64. The number.
    • pub fn of(value: &impl Hash) -> Revision. The revision of anything hashable: Revision::of(&(fingerprint, doc_width)). Stable within one run of the
  • craft_ui::primitives::textures::TextureBudget: pub struct TextureBudget { pub max_bytes: usize, pub max_entries: usize, pub uploads_per_pass: usize, pub upload_bytes_per_pass: usize }. How much a store may hold and upload. Entries past max_bytes or max_entries are evicted; uploads_per_pass
    • pub const fn new(max_bytes: usize, max_entries: usize) -> Self. Holds max_bytes and max_entries; a loader uploads 16 pictures and 16 MiB per frame.
    • pub const fn uploads(mut self, count: usize, bytes: usize) -> Self. Other upload limits per frame.
  • craft_ui::primitives::textures::TextureKey: pub trait TextureKey: Clone + Eq + Hash + Send + Sync + 'static. What can key a stored texture: a layer id, a path, a (document, page) pair. Every type with these bounds is
  • craft_ui::primitives::textures::TextureLoader: pub struct TextureLoader<K: TextureKey>. A TextureStore whose pictures are made by background jobs: FilmCraft's frames, PdfCraft's pages and the
    • pub fn in_context(ctx: &Context, salt: impl Hash + Debug, options: LoaderOptions) -> Self. The loader of ctx under salt, made with options the first time; its store is
    • pub fn cache(&self) -> &TextureStore<K>. The loader's store: state, forget, retain and statistics work on it as on any store.
    • pub fn request<J>(&self, ctx: &Context, key: &K, revision: Revision, priority: Priority, job: impl FnOnce() -> J) -> TextureState where J: FnOnce(&Cancel) -> LoadResult + Send + 'static,. What key shows for revision, queueing the job job() makes when the store has nothing for this revision
    • pub fn ask(&self, ctx: &Context, key: &K, revision: Revision, priority: Priority) -> Option<TextureState>. What key shows for revision when that is known without a new job: Some of the store's Ready, Empty
    • pub fn submit(&self, ctx: &Context, key: K, revision: Revision, priority: Priority, job: impl FnOnce(&Cancel) -> LoadResult + Send + 'static,) -> TextureState. Queues job making key's picture at revision, replacing a queued job of the key, and returns Loading
    • pub fn shutdown(&self, timeout: std::time::Duration) -> bool. Stops the loader's queue: waiting jobs are dropped, running ones are cancelled, and the call waits up to
  • craft_ui::primitives::textures::TextureState: pub enum TextureState { Missing, Loading { stand_in: Option<CachedTexture> }, Ready(CachedTexture), Empty, Failed { failure: LoadFailure } }. What a key shows for a revision, from TextureStore::state.
    • pub fn shown(&self) -> Option<CachedTexture>. The picture to draw now: the ready one, or the stand-in while loading.
  • craft_ui::primitives::textures::TextureStatistics: pub struct TextureStatistics { pub entries: usize, pub bytes: usize, pub uploads: usize, pub upload_bytes: usize, pub evicted: usize }. What a store holds and did, for automation, stories and tests.
  • craft_ui::primitives::textures::TextureStore: pub struct TextureStore<K: TextureKey>. Textures by key and revision, with byte and entry budgets: the one place an app's pictures become egui
    • pub fn in_context(ctx: &Context, salt: impl Hash + Debug, options: TextureStoreOptions) -> Self. The store of ctx under salt, made with options the first time. Later calls with the same salt get the
    • pub fn state(&self, ctx: &Context, key: &K, revision: Revision) -> TextureState. What key shows for revision (see TextureState), and marks the entry seen this frame.
    • pub fn put(&self, ctx: &Context, key: K, revision: Revision, image: ColorImage) -> CachedTexture. Stores image as key's picture at revision and returns it: in place when the key has a texture (same
    • pub fn put_region(&self, ctx: &Context, key: &K, revision: Revision, origin: [u32; 2], image: ColorImage) -> Option<CachedTexture>. Updates part of key's picture in place and moves the entry to revision: image goes at origin, both
    • pub fn get_or_put(&self, ctx: &Context, key: K, revision: Revision, make: impl FnOnce() -> ColorImage) -> CachedTexture. key's picture at revision, calling make and putting its image only when the entry has another revision
    • pub fn put_empty(&self, ctx: &Context, key: K, revision: Revision). Records that key has no picture at revision (state Empty); frees its texture.
    • pub fn put_failure(&self, ctx: &Context, key: K, revision: Revision, failure: LoadFailure). Records that making key's picture at revision failed (state Failed), so nothing asks for it again
    • pub fn forget(&self, ctx: &Context, key: &K). Drops key's entry and frees its texture.
    • pub fn retain(&self, ctx: &Context, mut keep: impl FnMut(&K) -> bool). Keeps only the entries whose key keep accepts (PhotoCraft's prune_thumbs when the open documents
    • pub fn clear(&self, ctx: &Context). Drops every entry (another library opened).
    • pub fn allow_upload(&self, ctx: &Context, bytes: usize) -> bool. Whether this frame's upload allowance has room for one more upload of bytes: fewer than uploads_per_pass
    • pub fn statistics(&self, ctx: &Context) -> TextureStatistics. What the store holds and uploaded this frame.
    • pub fn options(&self) -> TextureStoreOptions. The options the store was made with.
  • craft_ui::primitives::textures::TextureStoreOptions: pub struct TextureStoreOptions { pub budget: TextureBudget, pub filter: TextureOptions }. A store's settings, read when the store is created (TextureStore::in_context).
    • pub const fn thumbnails() -> Self. Row and grid thumbnails: 32 MiB and 512 entries.
    • pub const fn pages() -> Self. Document pages: 128 MiB and 64 entries.
    • pub const fn frames() -> Self. Video frames and other named images: 64 MiB and 512 entries.
    • pub const fn filter(mut self, filter: TextureOptions) -> Self. The sampling of every texture.
    • pub const fn budget(mut self, budget: TextureBudget) -> Self. Other limits.
  • craft_ui::primitives::textures::TextureWords: re-export of craft_ui::primitives::textures::words::TextureWords (defined outside these crates).
  • craft_ui::primitives::textures::ThumbFit: pub enum ThumbFit { Contain, Cover }. How [Thumbnails::paint] fits a picture into its cell.
  • craft_ui::primitives::textures::ThumbJob: pub type ThumbJob = Box<dyn FnOnce(&Cancel) -> Result<LoadedPicture, LoadFailure> + Send>. A background render: runs on a queue lane, checks the [Cancel] between steps, and returns the picture, the
  • craft_ui::primitives::textures::ThumbPaint: pub struct ThumbPaint { pub fit: ThumbFit, pub checker: bool, pub paper: Option<DataColor>, pub tint: DataColor }. How to paint one thumbnail.
    • pub fn fit(mut self, fit: ThumbFit) -> Self. Sets how the picture fits its box.
    • pub fn checker(mut self, checker: bool) -> Self. Sets whether the transparency grid shows behind the picture.
    • pub fn paper(mut self, paper: DataColor) -> Self. Sets the paper under the picture: a fill in place of the transparency grid, whatever checker says (a page
    • pub fn tint(mut self, tint: DataColor) -> Self. Sets the tint that multiplies the picture.
  • craft_ui::primitives::textures::ThumbRender: pub enum ThumbRender { Ready(ColorImage), Later(ThumbJob), Blank }. What a [ThumbSource] renders for a key.
  • craft_ui::primitives::textures::ThumbRequest: pub struct ThumbRequest { pub side: u32, pub pixels_per_point: f32, pub region: Option<Rect> }. What a thumbnail is asked at: the side in pixels, the screen's density and the part of the frame wanted.
    • pub fn for_cell(points: f32, pixels_per_point: f32) -> ThumbRequest. The request for a cell points wide on a screen of pixels_per_point: the side in pixels rounded up to a
    • pub fn region(self, region: Rect) -> ThumbRequest. The request for the part region of the frame (fractions of the frame, 0 to 1).
  • craft_ui::primitives::textures::ThumbSource: pub trait ThumbSource<K>. The app's side of the contract: how a key's picture is versioned and made.
    • fn revision(&self, key: &K, request: &ThumbRequest) -> Revision. The version of key's picture.
    • fn render(&self, key: &K, request: &ThumbRequest) -> ThumbRender. Makes key's picture, now or as a job.
  • craft_ui::primitives::textures::ThumbnailOptions: pub struct ThumbnailOptions { pub max_side: u32, pub store: TextureStoreOptions, pub lanes: usize, pub jobs: Option<Arc<dyn Jobs>>, pub renders_per_pass: usize }. A [Thumbnails]' settings, read when it is created.
    • pub fn new() -> Self. Sides up to 512, thumbnail budgets, the machine's lanes, the host's jobs, 16 renders per pass.
    • pub fn max_side(mut self, max_side: u32) -> Self. The longest side any request is lowered to.
    • pub fn store(mut self, store: TextureStoreOptions) -> Self. Budgets of the texture store.
    • pub fn lanes(mut self, lanes: usize) -> Self. Lanes of the queue for Later renders.
    • pub fn jobs(mut self, jobs: Arc<dyn Jobs>) -> Self. Where the lanes run.
    • pub fn renders_per_pass(mut self, renders: usize) -> Self. Renders on the UI thread per pass.
  • craft_ui::primitives::textures::Thumbnails: pub struct Thumbnails<K: TextureKey>. Thumbnails of one kind (layers, channels, snapshots, a grid's files) over one store: what every list and grid
    • pub fn in_context(ctx: &Context, salt: impl std::hash::Hash + std::fmt::Debug, options: ThumbnailOptions) -> Self. The thumbnails stored in ctx under salt, made with options the first time; the loader and its store
    • pub fn state(&self, ctx: &Context, source: &dyn ThumbSource<K>, key: &K, request: &ThumbRequest, priority: Priority) -> TextureState. What key shows now; renders or queues it when its revision has no picture yet.
    • pub fn paint(&self, cx: &ContentPainterCx<'_>, rect: Rect, state: &TextureState, paint: &ThumbPaint) -> bool. Paints state into rect and returns whether it drew anything:
    • pub fn shutdown(&self, timeout: Duration) -> bool. Stops the queue of Later renders and waits up to timeout for the running ones to end
    • pub fn hold(&self, hold: bool). Freezes the shown pictures while hold: no render starts and no job is queued; state returns the current
    • pub fn retain(&self, ctx: &Context, keep: impl FnMut(&K) -> bool). Keeps only the pictures whose key keep accepts (the open documents changed).
    • pub fn cache(&self) -> &super::TextureStore<K>. The store under the thumbnails, for forget, clear and statistics.
  • craft_ui::primitives::textures::fit_image: pub fn fit_image(image: ColorImage, max_side: u32) -> ColorImage. image reduced to at most max_side texels per side, or unchanged when it fits. The image is reduced by the
  • craft_ui::primitives::textures::fit_rect: pub fn fit_rect(cell: Rect, picture: Vec2) -> Rect. The rect inside cell that shows a picture of picture's aspect whole, as large as fits and centred; cell
  • craft_ui::primitives::textures::reduce_image: pub fn reduce_image(image: &ColorImage, factor: u32) -> ColorImage. image box-averaged by the whole factor, in premultiplied values.
  • craft_ui::primitives::textures::texture_factor: pub fn texture_factor(size: PixelSize, side: u32) -> u32. How many document pixels per side one texel of the base texture holds for a document of size with textures at
  • craft_ui::primitives::textures::texture_side: pub fn texture_side(ctx: &Context) -> u32. The texture side on this device: [MAX_TEXTURE], or the device's smaller limit (2048 on some older GPUs and
  • craft_ui::primitives::textures::thumb_image: pub fn thumb_image(frame: PixelSize, longest_side: u32, mut sample: impl FnMut(u32, u32) -> [u8; 4]) -> ColorImage. A picture of the document area frame (pixels) with that exact aspect, its longest side longest_side, each

craft_ui::runtime

Per-pass and per-frame services and the one egui adapter.

  • craft_ui::runtime::InstallError: re-export of craft_ui::runtime::install::InstallError.
  • craft_ui::runtime::InstallSpec: re-export of craft_ui::runtime::install::InstallSpec.
  • craft_ui::runtime::install: re-export of craft_ui::runtime::install::install.

craft_ui::runtime::access

Role, the access facts of a component and the AccessKit emitter (chapter 12).

  • craft_ui::runtime::access::Access: pub struct Access. The facts a component adds to its AccessKit node: what the pipeline cannot derive from the label, the flags
    • pub fn role(&mut self, role: Role) -> &mut Self. The role of this instance, one of the component's ALT_ROLES.
    • pub fn name(&mut self, name: Name) -> &mut Self. How the node is named, when the label is not the name.
    • pub fn description(&mut self, text: impl Into<String>) -> &mut Self. A description, over the bound command's hint and the tooltip.
    • pub fn placeholder(&mut self, text: impl Into<String>) -> &mut Self. The hint text of an empty input.
    • pub fn value(&mut self, text: impl Into<String>) -> &mut Self. The text value of a text component.
    • pub fn color(&mut self, color: Srgba) -> &mut Self. The colour value of a colour well.
    • pub fn numeric(&mut self, numeric: Numeric) -> &mut Self. The numeric value of a value component; a step also declares increment and decrement.
    • pub fn expanded(&mut self, on: bool) -> &mut Self. Whether a disclosure is open, when no flag says it.
    • pub fn has_popup(&mut self, kind: PopupKind) -> &mut Self. What kind of popup the component opens.
    • pub fn level(&mut self, level: usize) -> &mut Self. The heading level or tree depth.
    • pub fn grid(&mut self, grid: GridPlace) -> &mut Self. The row and column counts of a grid or table node. A collection's item step fills them for its own node.
    • pub fn position(&mut self, position: SetPosition) -> &mut Self. The place in a closed set.
    • pub fn required(&mut self, on: bool) -> &mut Self. The input must be filled in.
    • pub fn url(&mut self, url: impl Into<String>) -> &mut Self. The target of a link.
    • pub fn shortcut(&mut self, text: impl Into<String>) -> &mut Self. The keyboard shortcut, over the bound command's.
    • pub fn access_key(&mut self, key: char) -> &mut Self. The mnemonic letter.
    • pub fn labelled_by(&mut self, id: Id) -> &mut Self. The node id names this one. Targets are cx.key(..) ids; one shown in a later frame follows the
    • pub fn described_by(&mut self, id: Id) -> &mut Self. The node id describes this one.
    • pub fn controls(&mut self, id: Id) -> &mut Self. This node controls the node id (the popup of an open combo box).
    • pub fn flow_to(&mut self, id: Id) -> &mut Self. Reading continues at the node id.
    • pub fn live(&mut self, politeness: Politeness) -> &mut Self. Makes the node a live region.
    • pub fn pans(&mut self, vertical: bool, horizontal: bool) -> &mut Self. The leaf pans its content along the vertical and horizontal axes: the node serves the scroll actions on them,
    • pub fn busy(&mut self, on: bool) -> &mut Self. The node is working.
    • pub fn node(&mut self, part: impl Into<PartRef>, role: Role) -> &mut SubNode. A node below this component's node, keyed by a PartRef (content painters key lines and runs as
    • pub fn text_selection(&mut self, anchor:(PartRef, usize), focus:(PartRef, usize)) -> &mut Self. The text selection of the component's own text, from anchor to focus: each end is a text-run sub-node
    • pub fn custom_action(&mut self, id: i32, label: Label) -> &mut Self. An action the component serves itself; it arrives through cx.intents().take_access().
  • craft_ui::runtime::access::GridPlace: pub struct GridPlace { pub row_index: Option<usize>, pub row_count: Option<usize>, pub column_index: Option<usize>, pub column_count: Option<usize> }. The indexes and counts of a grid, table, row or cell node (12.3).
    • pub const fn grid(rows: usize, columns: usize) -> Self. A grid of rows rows and columns columns.
    • pub const fn cell(row: usize, column: usize) -> Self. The cell at row and column.
  • craft_ui::runtime::access::Name: pub enum Name { FromLabel, Text(String), Joined(Vec<String>), LabelledBy(Id), Decorative }. How a node or sub-node is named.
  • craft_ui::runtime::access::Numeric: pub struct Numeric { pub value: Option<f64>, pub range: RangeInclusive<f64>, pub step: Option<f64>, pub wraps: bool, pub text: Option<String> }. A numeric value.
    • pub fn new(value: f64, range: RangeInclusive<f64>) -> Self. A value in a range.
    • pub fn empty(range: RangeInclusive<f64>) -> Self. A range with no value.
    • pub fn step(mut self, step: f64) -> Self. The step of an increment or decrement.
    • pub fn wraps(mut self, wraps: bool) -> Self. Whether a step past one end of the range continues from the other.
    • pub fn text(mut self, text: impl Into<String>) -> Self. The value as shown.
  • craft_ui::runtime::access::Politeness: pub enum Politeness { Polite, Assertive }. How urgently a live announcement is read.
  • craft_ui::runtime::access::PopupKind: pub enum PopupKind { Menu, Listbox, Tree, Grid, Dialog }. The kind of popup a component opens.
  • craft_ui::runtime::access::Role: pub enum Role { None, Merged, Node(NodeRole) }. What a component is to assistive technology.
    • pub const fn of_tone(tone: Tone) -> Role. The role of a message of tone: status for the neutral tones, alert for a warning or a failure.
    • pub const fn hover_cursor(self) -> Option<craft_behavior::CursorIcon>. The cursor over an enabled component of this role: the pointing hand over a link and over a control that picks
  • craft_ui::runtime::access::SetPosition: pub struct SetPosition { pub index: usize, pub size: Option<usize>, pub level: Option<usize>, pub columns: Option<usize> }. A node's place in its set, on the closed list of items it belongs to.
    • pub const fn new(index: usize) -> Self. Position index.
    • pub const fn columns(mut self, columns: usize) -> Self. In a grid of columns columns.
    • pub const fn of(mut self, size: usize) -> Self. In a set of size.
    • pub const fn level(mut self, level: usize) -> Self. At depth level.
  • craft_ui::runtime::access::SubNode: pub struct SubNode { pub name: Name, pub description: Option<String>, pub numeric: Option<Numeric>, pub expanded: Option<bool>, pub position: Option<SetPosition>, pub grid: GridPlace, pub level: Option<usize>, pub flags: Flags }. A node below a component's node, for a part, a cell or a line of a content painter.
    • pub fn bounds(&mut self, rect: egui::Rect) -> &mut Self. The node's rectangle on screen, for a node that has no part of its own to take it from (a block of text a
    • pub fn text_run(&mut self, text: impl Into<String>, positions: Vec<f32>, widths: Vec<f32>, rtl: bool) -> &mut Self. Makes the node a run of text: text laid out on one line, each character's start offset from the node's left
    • pub fn run_link(&mut self, chars: std::ops::Range<usize>, target: impl Into<String>) -> &mut Self. Marks characters chars of a text run as a link to target: the run node gets a Link
    • pub fn level(&mut self, level: usize) -> &mut Self. The heading level or tree depth.
    • pub fn value(&mut self, text: impl Into<String>) -> &mut Self. A plain text value, for a sub-node that shows text as its value and has no number.
    • pub fn column(&mut self, key: craft_behavior::ColumnKey) -> &mut Self. The column of a cell of an item row; the item step reads the cell's column index from the collection's
    • pub fn access_key(&mut self, key: char) -> &mut Self. The mnemonic letter.
    • pub fn shortcut(&mut self, text: impl Into<String>) -> &mut Self. The key that activates the sub-node, as the access tree lists it (Access::shortcut for the component's own
    • pub fn has_popup(&mut self, kind: PopupKind) -> &mut Self. What kind of popup the sub-node opens.
    • pub fn expanded(&mut self, on: bool) -> &mut Self. Whether the sub-node's popup or region is open.
    • pub fn current(&mut self, on: bool) -> &mut Self. The sub-node is the current one of its set: the current page of a trail.
    • pub fn under(&mut self, other: impl Into<PartRef>) -> &mut Self. Nests this sub-node below another sub-node of the same component.
    • pub fn custom_action(&mut self, id: i32, label: Label) -> &mut Self. An action the component serves itself, targeted at this sub-node.
  • craft_ui::runtime::access::FieldLabel: pub struct FieldLabel { pub id: Id, pub rect: Rect, pub press: PressState, pub hovered: bool, pub text: String, pub role: FieldLabelRole, pub detail: Option<String>, pub activated: bool, pub status: bool }. The label a container shows beside its body.
    • pub fn new(id: Id, rect: Rect, text: impl Into<String>) -> Self. A label of text at rect, the node id.
    • pub fn role(mut self, role: FieldLabelRole) -> Self. Whether the label names or describes the controls.
    • pub fn detail(mut self, detail: impl Into<String>) -> Self. Adds a detail line to the description of the controls the label covers.
    • pub fn status(mut self, status: bool) -> Self. Whether the container shows its control's validity message as its status line.
    • pub fn activated(mut self, activated: bool) -> Self. Whether the label was clicked or activated this pass.
    • pub fn with_press(mut self, press: PressState) -> Self. The label's press this pass.
    • pub fn with_hover(mut self, hovered: bool) -> Self. Whether the pointer is over the label this pass.
    • pub fn pressed(&self) -> bool. The label is held down or being dragged.
  • craft_ui::runtime::access::FieldLabelRole: pub enum FieldLabelRole { Names, Describes }. Whether a field label names its control or describes it.
  • craft_ui::runtime::access::announce: pub fn announce(ctx: &Context, text: impl Into<String>, politeness: Politeness). Announces text; for code without a context. Components call cx.announce. The same announcement made again

craft_ui::runtime::commands

The command board: the registry and typed sets, per-frame state, the queue, firing and the gate (spec 11).

  • craft_ui::runtime::commands::CommandGate: pub struct CommandGate. The app's one gate over commands: a dialog is open, a workspace is not ready, a recorder has the keys or an
    • pub fn new(allows: impl Fn(&CommandRef) -> bool + Send + Sync + 'static) -> Self. A gate that lets allows commands through.
  • craft_ui::runtime::commands::CommandInput: pub struct CommandInput. App-scope command state for this frame, set from app state before the pass.
    • pub fn new() -> Self. No state, no overrides and no gate.
    • pub fn state(mut self, command: impl Into<CommandRef>, state: CommandState) -> Self. The state of an app-scope command.
    • pub fn overrides(mut self, overrides: Arc<Overrides>) -> Self. The user's binding overrides; the keymap is rebuilt when the Arc changes.
    • pub fn gate(mut self, gate: CommandGate) -> Self. The one gate over commands.
  • craft_ui::runtime::commands::CommandSet: pub trait CommandSet: Copy + Send + Sync + 'static. A typed set of commands, written by #[derive(CommandSet)].
    • const SCOPE: CommandScope. The scope the set's commands belong to.
    • fn from_ref(command: &CommandRef) -> Option<Self>. The command of this set that command names.
    • fn id(self) -> &'static str.
    • fn defs() -> Result<Vec<CommandDef>, CommandDefError>.
    • fn no_default_on() -> Vec<(&'static str, Platform)>. The commands that have no default binding on a platform, as (id, platform).
    • fn edits() -> Vec<(&'static str, EditCommand)>. The commands a focused component takes as an Intent::Edit, as (id, edit): the edit option of the
    • fn platform_defaults() -> Result<Vec<(&'static str, Platform, Binding)>, CommandDefError>. The defaults of one platform, as (id, platform, binding): on that platform they replace the command's other
  • craft_ui::runtime::commands::CommandState: pub struct CommandState. What the app or an instance says about a command this frame.
    • pub fn new() -> Self. An enabled, unchecked-less state with the command's own label.
    • pub fn enabled(mut self, enabled: bool) -> Self. Whether the command can fire.
    • pub fn checked(mut self, checked: bool) -> Self. The checked state of a toggle or radio command.
    • pub fn marked(mut self, marked: bool) -> Self. Whether the command's content has something to show, such as comments on a panel. A rail marks the command's
    • pub fn title(mut self, title: impl Into<Arc<str>>) -> Self. A label for this frame in place of the command's own, such as "Undo Move".
    • pub fn hint(mut self, hint: impl Into<Arc<str>>) -> Self. The accessible description and second tooltip line.
  • craft_ui::runtime::commands::Commands: pub trait Commands: CommandAccess. The chapter-11 context trait that Cx, BodyCx and ItemCx implement. "This instance" is the innermost
    • fn clipboard(&self) -> ClipboardHandle. The one clipboard path.
    • fn publish(&mut self, command: impl Into<CommandRef>, state: CommandState). This frame's state of a scoped command, for this instance. Publishing an app-scope command here is a
    • fn take_command<S: CommandSet>(&mut self) -> Option<(S, Fired)>. The next command of set S routed to this instance this pass; each is taken once, so a discard pass does
    • fn take_step(&mut self, can_undo: bool, can_redo: bool) -> Option<Step>. Declares Undo and Redo on the innermost instance around this context, enabled as can_undo and can_redo
    • fn resolve_command(&self, command: impl Into<CommandRef>) -> Option<ResolvedCommand>. command as this context shows it: the label, icon and chord with the scoped bindings of the scopes above
  • craft_ui::runtime::commands::FirePhase: pub enum FirePhase { Press, Repeat, Release }. The phase of the key press that fired a command.
  • craft_ui::runtime::commands::FireSource: pub enum FireSource { Key, Menu, Palette, Pointer, Automation, Access }. Where a fired command came from.
  • craft_ui::runtime::commands::Fired: pub struct Fired { pub command: CommandRef, pub target: Option<Id>, pub source: FireSource, pub phase: FirePhase, pub cycle: bool, pub alt_variant: bool }. A command a surface or a key fired, as the instance or the app takes it.
  • craft_ui::runtime::commands::ResolvedCommand: pub struct ResolvedCommand { pub label: Arc<str>, pub icon: Option<Cow<'static, str>>, pub chord: Option<Chord>, pub enabled: bool, pub checked: Option<bool>, pub marked: bool, pub hint: Option<Arc<str>>, pub kind: CommandKind, pub instance: Option<Id> }. A command as a surface shows and fires it.
  • craft_ui::runtime::commands::fire: pub fn fire(ctx: &Context, command: impl Into<CommandRef>, source: FireSource) -> bool. Fires command from a surface that has no component of its own: a menu, the palette or automation. Scoped
  • craft_ui::runtime::commands::resolve: pub fn resolve(ctx: &Context, command: impl Into<CommandRef>) -> ResolvedCommand. command as a surface with no component of its own shows it: the label, icon, chord, enabled and checked state
  • craft_ui::runtime::commands::Binding: re-export of craft_keymap::Binding (outside these crates).
  • craft_ui::runtime::commands::ChromeCommand: pub enum ChromeCommand { TogglePanels, TogglePanelsKeepTools }. The window commands that hide the panels of the window they run in.
    • pub const ALL: [ChromeCommand; 2]. Both commands.
    • pub const fn toggle(self) -> ChromeToggle. The toggle the command writes to the output.
  • craft_ui::runtime::commands::ClipContent: pub struct ClipContent { pub text: Option<Arc<str>> }. What a paste delivers.
  • craft_ui::runtime::commands::ClipError: pub struct ClipError(pub String). Why a paste has no content.
  • craft_ui::runtime::commands::ClipItem: pub enum ClipItem { Text(Arc<str>), Html(Arc<str>), Image(Arc<ColorImage>), Custom { mime: Arc<str>, bytes: Arc<[u8]> } }. One clipboard item.
  • craft_ui::runtime::commands::ClipboardHandle: pub struct ClipboardHandle. The component's paste slot over the system clipboard. egui carries text and images, so Html and Custom
    • pub fn put(&self, items: &[ClipItem]). Writes every flavour of items that the clipboard carries.
    • pub fn paste(&self) -> &Pending<ClipContent, ClipError>. The pasted content: ready in the pass that delivers the paste to the focused component that lists Paste.
  • craft_ui::runtime::commands::CommandDef: re-export of craft_keymap::CommandDef (outside these crates).
  • craft_ui::runtime::commands::CommandDefError: pub enum CommandDefError { Binding { command: &'static str, error: BindingError }, Scope { command: &'static str }, Duplicate { command: String } }. Why a command definition is unusable.
  • craft_ui::runtime::commands::CommandKind: re-export of craft_keymap::CommandKind (outside these crates).
  • craft_ui::runtime::commands::CommandRef: re-export of craft_keymap::CommandRef (outside these crates).
  • craft_ui::runtime::commands::CommandScope: re-export of craft_keymap::CommandScope (outside these crates).
  • craft_ui::runtime::commands::EditCommand: re-export of craft_behavior::intent::EditCommand.
  • craft_ui::runtime::commands::EditCommands: pub enum EditCommands { Cut, Copy, Paste, SelectAll, Undo, Redo, Delete }. The edit commands (11.3). A focused component that lists one in KEYS.edits takes it as
    • pub const ALL: [EditCommands; 6]. Every edit command that a focused component can take as an Intent::Edit.
    • pub const fn edit(self) -> Option<EditCommand>. The intent a component takes this command as; None for a command that is always the app's.
    • pub const fn of(command: EditCommand) -> Option<Self>. The command an edit intent comes from.
  • craft_ui::runtime::commands::ModalRule: re-export of craft_keymap::ModalRule (outside these crates).
  • craft_ui::runtime::commands::NavCommand: pub enum NavCommand { NextPane, PreviousPane, FocusMenuBar }. The window commands that move focus between the window's panes and onto its menu bar (spec 9.4, 9.7). Their keys
  • craft_ui::runtime::commands::Platform: re-export of craft_keymap::Platform (outside these crates).
  • craft_ui::runtime::commands::WindowCommand: pub enum WindowCommand { Move, Size }. The window commands (16.3): a floating container moves and resizes from the keyboard. macOS binds no chord to

craft_ui::runtime::cursor

The cursor service (8.5): requests of a pass collect here, the end hook picks the winner and records it.

  • craft_ui::runtime::cursor::current: pub fn current(ctx: &Context) -> Option<Cursor>. The cursor the last pass of the running viewport settled on; None is the default arrow.

craft_ui::runtime::drag

The drag session (8.4): one per context. It holds the payload, the preview, the held modifiers, the operation and the

  • craft_ui::runtime::drag::DragPreview: pub enum DragPreview { None, Badge(Label), Frame { size: Vec2, label: Option<Label> } }. What the ghost layer paints beside the pointer during a drag.
    • pub fn frame(size: Vec2, label: Option<Label>) -> Self. A frame of size with an optional label.
  • craft_ui::runtime::drag::DropMark: pub enum DropMark { Line { from: Pos2, to: Pos2 }, Into(Rect), Split(Rect) }. Where a drop would land, as geometry in the target's egui layer space.
    • pub const fn line(from: Pos2, to: Pos2) -> Self. An insertion line from from to to.
  • craft_ui::runtime::drag::DropTarget: pub trait DropTarget<P: ?Sized>. What a component registers with Pointer::drop_target.
    • type Drop. What a drop on this target carries to the component's caller.
    • fn accept(&self, payload: &P, at: Pos2, op: DropOperation) -> Option<Self::Drop>. None rejects. at is the pointer in the component's egui layer space, so a target picks its sub-area (a port,
    • fn mark(&self, drop: &Self::Drop) -> DropMark. Where drop would land, a value the ghost layer paints.
  • craft_ui::runtime::drag::OsFile: pub struct OsFile { pub name: String, pub path: Option<PathBuf>, pub mime: String, pub bytes: Option<Arc<[u8]>> }. A file the OS drags over the window or drops on it.
  • craft_ui::runtime::drag::OsFiles: pub struct OsFiles { pub files: Vec<OsFile> }. The payload of a drag that comes from the OS: files held over the window, then the files dropped. Targets take it
  • craft_ui::runtime::drag::WindowDropTarget: pub trait WindowDropTarget<P>. What a component registers with Pointer::window_drop_target: a target over the whole window, which needs no
    • type Drop. What a drop on this target carries to the component's caller.
    • fn accept(&self, payload: &P, op: DropOperation) -> Option<Self::Drop>. None rejects. op is the operation the held modifiers pick, which a target may refuse.
    • fn mark(&self, drop: &Self::Drop) -> DropMark. Where drop would land, a value the ghost layer paints.
  • craft_ui::runtime::drag::active: pub fn active<P: Send + Sync + 'static>(ctx: &Context) -> Option<Arc<P>>. The active drag payload of type P, from any viewport. For code without a Cx.
  • craft_ui::runtime::drag::amend: pub fn amend<P: Clone + Send + Sync + 'static>(ctx: &Context, change: impl FnOnce(&mut P)) -> bool. Changes the running session's payload of type P (or its second payload of that type) with change, in the frame
  • craft_ui::runtime::drag::cancel: pub fn cancel(ctx: &Context, reason: CancelReason). Ends the session without a drop; the source's press ends with it, so nobody gets a drop.

craft_ui::runtime::edit

The pass's edit events and edit-command routing: the context-free calls an app makes around edits.

  • craft_ui::runtime::edit::cancel_all: pub fn cancel_all(ctx: &Context, reason: CancelReason). Cancels every running gesture at its next step 4, which then stays cancelled under its press. The app's undo and
  • craft_ui::runtime::edit::next_gesture_id: pub fn next_gesture_id(ctx: &Context) -> GestureId. A gesture id no gesture of this context has had: ids grow in the order gestures begin, across components and
  • craft_ui::runtime::edit::watch_gestures: pub fn watch_gestures<R>(ctx: &Context, body: impl FnOnce() -> R) -> (R, bool). Runs body and says whether a gesture of a component shown inside it was running after the component's apply

craft_ui::runtime::egui::access

AccessKit node building, register_accesskit_parent and set_accesskit_focus: the one place that names

  • craft_ui::runtime::egui::access::AccessTree: pub struct AccessTree. The AccessKit tree update of one frame.
    • pub fn has(&self, id: Id) -> bool. Whether the node of id exists.
    • pub fn role(&self, id: Id) -> Option<Role>. The role of the node of id.
    • pub fn name(&self, id: Id) -> Option<&str>. The name of the node of id.
    • pub fn description(&self, id: Id) -> Option<&str>. The description of the node of id.
    • pub fn description_of(&self, key: NodeKey) -> Option<&str>. The description of a node by key.
    • pub fn shortcut_of(&self, key: NodeKey) -> Option<&str>. The keyboard shortcut a node by key lists.
    • pub fn value_of(&self, key: NodeKey) -> Option<&str>. The text value of a node by key.
    • pub fn value(&self, id: Id) -> Option<&str>. The text value of the node of id.
    • pub fn numeric(&self, id: Id) -> Option<Numeric>. The numeric value and range of the node of id.
    • pub fn numeric_of(&self, key: NodeKey) -> Option<Numeric>. The numeric value and range of a node by key.
    • pub fn is_disabled(&self, id: Id) -> bool. Whether the node of id is reported as disabled.
    • pub fn declares(&self, id: Id, action: Declared) -> bool. Whether the node of id declares action.
    • pub fn labelled_by(&self, id: Id) -> Vec<NodeKey>. The nodes that name the node of id.
    • pub fn labelled_by_key(&self, key: NodeKey) -> Vec<NodeKey>. [AccessTree::labelled_by] for a node by key.
    • pub fn described_by(&self, id: Id) -> Vec<NodeKey>. The nodes that describe the node of id.
    • pub fn position(&self, id: Id) -> Option<(usize, usize)>. The place of the node of id in its set: its zero-based index and the size of the set.
    • pub fn grid_of(&self, key: NodeKey) -> GridPlace. The row and column indexes and counts of a node by key.
    • pub fn sort_of(&self, key: NodeKey) -> Option<bool>. The sort order a column header node by key shows: true descending.
    • pub fn declares_sort(&self, key: NodeKey) -> bool. Whether a column header node declares a sort direction: it sorts when activated, sorted now or not.
    • pub fn expanded(&self, id: Id) -> Option<bool>. The expanded state of the node of id.
    • pub fn has_popup(&self, id: Id) -> Option<PopupKind>. The kind of popup the node of id opens.
    • pub fn controls(&self, id: Id) -> Vec<NodeKey>. The nodes the node of id controls.
    • pub fn is_modal(&self, key: NodeKey) -> bool. Whether the node of key is modal.
    • pub fn live(&self, id: Id) -> Option<Politeness>. The live politeness of the node of id.
    • pub fn invalid(&self, id: Id) -> bool. Whether the node of id is marked invalid.
    • pub fn run_texts(&self, id: Id) -> Vec<String>. The text of each TextRun node below id, in order.
    • pub fn text_selection(&self, id: Id) -> Option<((NodeKey, usize),(NodeKey, usize))>. The selection of the text node id as the run node and character index of its anchor and focus.
    • pub fn name_of(&self, key: NodeKey) -> Option<&str>. The name of a node by key.
    • pub fn toggled_of(&self, key: NodeKey) -> Option<craft_behavior::Mixed<bool>>. The toggled state of a node by key.
    • pub fn expanded_of(&self, key: NodeKey) -> Option<bool>. The expanded state of a node by key.
    • pub fn has_popup_of(&self, key: NodeKey) -> Option<PopupKind>. The kind of popup the node of key opens.
    • pub fn access_key_of(&self, key: NodeKey) -> Option<char>. The access key of the node of key.
    • pub fn current_of(&self, key: NodeKey) -> bool. Whether the node of key is the current item of its set (the current page).
    • pub fn parent_of(&self, id: Id) -> Option<NodeKey>. The nearest ancestor of id that screen readers see: AccessKit's consumer drops generic containers.
    • pub fn parent_of_key(&self, key: NodeKey) -> Option<NodeKey>. [AccessTree::parent_of] for a node by key.
    • pub fn in_ltr_axis(&self, key: NodeKey) -> bool. Whether the node is, or lies inside, a component whose horizontal axis keeps its left-to-right order
    • pub fn keys(&self) -> Vec<NodeKey>. Every node that assistive technology reports.
    • pub fn node_count(&self) -> usize. The number of nodes that assistive technology reports.
    • pub fn role_of(&self, key: NodeKey) -> Option<Role>. The role of a node by key.
    • pub fn selected_of(&self, key: NodeKey) -> Option<bool>. Whether a node by key is reported as selected: None for a node that reports no selected state.
    • pub fn bounds_of(&self, key: NodeKey) -> Option<egui::Rect>. The bounds of a node by key, in points.
    • pub fn is_disabled_key(&self, key: NodeKey) -> bool. Whether a node by key is reported as disabled.
    • pub fn declares_key(&self, key: NodeKey, action: Declared) -> bool. Whether a node by key declares action.
    • pub fn children_of(&self, key: NodeKey) -> Vec<NodeKey>. The children of a node by key.
  • craft_ui::runtime::egui::access::Declared: pub enum Declared { Focus, Click, Increment, Decrement, SetValue, SetTextSelection, Expand, Collapse, Custom, ScrollUp, ScrollDown, ScrollLeft, ScrollRight }. An action a node declares.
  • craft_ui::runtime::egui::access::NodeKey: pub struct NodeKey. A node's number in the tree.
    • pub fn of(id: Id) -> NodeKey. The key of the node of id.

craft_ui::runtime::egui::areas

Area with its left-top pivot, Order, sublayers, transform layers and set_layer_order.

  • craft_ui::runtime::egui::areas::LayerKey: pub type LayerKey = egui::LayerId. An egui layer, as the runtime's shape records name it.
  • craft_ui::runtime::egui::areas::LayerOrder: pub struct LayerOrder { pub listed_on_top: bool, pub unlisted_keep_order: bool, pub unknown_ignored: bool }. The layer order after Context::set_layer_order.
  • craft_ui::runtime::egui::areas::layer_order: pub fn layer_order() -> LayerOrder. Two frames over three areas; the second lists the first area and an unknown layer.

craft_ui::runtime::egui::injected

Injected input: pointer moves, clicks, keys and text an automation client asks for, and the event builders

  • craft_ui::runtime::egui::injected::hook_without_pass: pub fn hook_without_pass(ctx: &Context, viewport: ViewportId) -> Vec<Event>. The input of one hook call for viewport with no pass behind it: the events the hook appends. Stands in for
  • craft_ui::runtime::egui::injected::move_focus_without_pass: pub fn move_focus_without_pass(ctx: &Context, viewport: ViewportId, id: Id). Moves the focus the end hook recorded for viewport to the component id with no pass, as the application does

craft_ui::runtime::egui::input

Raw input in the input hook, key events converted to craft-keymap's key types, InputOptions.

  • craft_ui::runtime::egui::input::RawInput: re-export of egui::RawInput (outside these crates).

craft_ui::runtime::egui::screenshot

One-shot screenshot slots and the facts a screenshot is measured against.

  • craft_ui::runtime::egui::screenshot::ScreenshotError: pub enum ScreenshotError { DimensionsOverflow { width: usize, height: usize }, MalformedImage { width: usize, height: usize, pixels: usize }, ImageTooLarge { bytes: usize, max_bytes: usize } }. Why a completed screenshot was rejected and released.
  • craft_ui::runtime::egui::screenshot::ScreenshotFacts: pub struct ScreenshotFacts { pub size_points: Vec2, pub pixels_per_point: f32, pub zoom: f32, pub max_texture_side: usize, pub minimized: bool }. What a screenshot of the running viewport measures this pass.
  • craft_ui::runtime::egui::screenshot::ScreenshotSlot: pub struct ScreenshotSlot. The live request side of a screenshot. Keep it alive until the result is taken or the request is cancelled;
    • pub fn take(&self) -> Option<Result<Arc<ColorImage>, ScreenshotError>>. Takes the completed result, at most once.
    • pub fn cancel(&self). Cancels the request and releases any completed image. A completion that published its result before this
    • pub fn detached(ctx: &Context, viewport: ViewportId, max_image_bytes: usize) -> (Self, ScreenshotCallback). A slot with its callback and no command sent, for trials that stand in for the renderer.
    • pub fn complete(&self, image: Arc<ColorImage>). Completes the slot with image as the renderer would, without the callback.
    • pub fn lock_is_free(&self) -> bool. Whether the slot mutex is free, proving the wakeup runs after the lock was released.

craft_ui::runtime::env

Env and scopes, app values and content_env.

  • craft_ui::runtime::env::Env: pub struct Env. The inherited context of a Ui: one Arc clone per read.
    • pub fn words<L: WordSet + Send + Sync + 'static>(&self) -> Arc<L>. The word set L in the scope's language.
    • pub fn format(&self) -> &Format. How the scope writes numbers: locale digits, separators and grouping.
    • pub fn dates(&self) -> Arc<DateFormat>. How the scope writes dates: the host's catalog format, else the system region's.
    • pub fn today(&self) -> Option<CalendarDate>. Today's date as the host supplied it with RootEnv::today; None when it gave none.
    • pub fn units(&self) -> Units. The scope's number format and unit words, to read and write numbers with their unit.
    • pub fn relative_age(&self, seconds: u64, style: AgeStyle) -> String. How long ago seconds was, in the scope's language and digits: "Just now", "3 minutes ago", "Yesterday".
    • pub fn of(ui: &Ui) -> Env. The env of ui: the nearest entry up the Ui stack, else the running viewport's root env, so the Ui
    • pub fn get<T: EnvValue>(&self) -> T. A clone of the innermost app value, else T::root(). Large values hold an Arc.
    • pub fn capture(&self) -> EnvCapture. The inherited group only; layer-local fields start fresh where the capture is installed.
    • pub fn view(&self) -> EnvView<'_>. What component code sees of this env.
    • pub fn folder(&self) -> Folder. Folds text for search in the scope's language: case and accents ignored, dotted and dotless i by locale.
    • pub fn collator(&self) -> Arc<Collator>. Orders text in the scope's language, with runs of digits by value (Layer 2 before Layer 10).
  • craft_ui::runtime::env::EnvCapture: pub struct EnvCapture. The inherited group of an env, captured to open a popup or viewport: the layer-local fields are reset.
  • craft_ui::runtime::env::Inherited: pub struct Inherited { pub tokens: Arc<UiTokens>, pub os: Os, pub active: bool, pub words: Arc<Words>, pub line_ratio: f32, pub motion: MotionPolicy, pub scale: Scale, pub values: AppValues }. The values of an env that a scope rarely changes: the resolved tokens, the platform, the language and the app's
  • craft_ui::runtime::env::Scoped: pub struct Scoped { pub ink: Ink, pub key: EnvKey, pub size: ControlSize, pub glyphs: GlyphRole, pub enabled: bool, pub read_only: bool, pub wheel: WheelScope, pub direction: Direction, pub text_direction: Direction, pub ids_stable: bool, pub arena: Option<ArenaId>, pub transform: Option<CanvasTransform> }. The values of an env.
  • craft_ui::runtime::env::AgeStyle: re-export of craft_i18n::AgeStyle (outside these crates).
  • craft_ui::runtime::env::AppValues: pub struct AppValues. The app values a root, a scope or a component's content_env carries: one entry per EnvValue type, the
    • pub fn set<T: EnvValue>(&mut self, value: T) -> &mut Self. Sets the value of type T.
  • craft_ui::runtime::env::ArenaId: pub struct ArenaId(pub Id). The id of an arena, carried in Env.arena.
    • pub const fn new(id: Id) -> Self. The arena whose id is id.
  • craft_ui::runtime::env::BodyMode: pub enum BodyMode { Normal, Only }. What the window shows besides its body.
  • craft_ui::runtime::env::Count: re-export of craft_i18n::Count (outside these crates).
  • craft_ui::runtime::env::Counted: re-export of craft_i18n::Counted (outside these crates).
  • craft_ui::runtime::env::Direction: re-export of craft_i18n::Direction (outside these crates).
  • craft_ui::runtime::env::EnvValue: re-export of craft_ui_macros::EnvValue (outside these crates).
  • craft_ui::runtime::env::EnvView: pub struct EnvView<'a>. What component code sees: everything in Env except tokens, size, enabled, read-only, arena, transform
    • pub fn inside_label(&self) -> Option<&'a crate::contract::InsideLabel>. The inside label the component shows in its slot, when it is the control of a side label with
    • pub fn surface(&self) -> crate::style::SurfaceKind. The surface the component sits on: the innermost container or collection surface that paints a fill, else the
    • pub fn direction(&self) -> Direction. The flow direction: layout order, arrow keys and roving.
    • pub fn text_direction(&self) -> Direction. The paragraph direction of text, which only a scope that sets the interface's direction changes.
    • pub fn mode(&self) -> Mode. The light or dark mode the scope's tokens are resolved in: the app's, or the one a scope with its own tokens
    • pub fn motion(&self) -> MotionPolicy. The motion mode in effect.
    • pub fn scale(&self) -> Scale. The pixels per point.
    • pub fn shell(&self) -> &'a ShellInfo. The platform and the running viewport's window facts: the OS, the capabilities and the window's kind,
    • pub fn keyboard_layout(&self) -> &'a craft_keymap::Layout. The keyboard layout: which character each key position types, for text that names a key.
    • pub fn host(&self) -> Option<&'a Arc<Host>>. The app's Host, from FrameInput.host.
    • pub fn get<T: EnvValue>(&self) -> T. A clone of the innermost app value, else T::root().
    • pub fn words<L: WordSet + Send + Sync + 'static>(&self) -> Arc<L>. The word set L in the scope's language, built once per Words.
    • pub fn format(&self) -> &'a Format. How the scope writes numbers: locale digits, separators and grouping.
    • pub fn dates(&self) -> Arc<DateFormat>. How the scope writes dates: the host's catalog format, else the system region's.
    • pub fn today(&self) -> Option<CalendarDate>. Today's date as the host supplied it with RootEnv::today; None when it gave none.
    • pub fn units(&self) -> Units. The scope's number format and unit words, to read and write numbers with their unit.
    • pub fn relative_age(&self, seconds: u64, style: AgeStyle) -> String. How long ago seconds was, in the scope's language and digits: "Just now", "3 minutes ago", "Yesterday".
    • pub fn counted(&self, count: Counted, n: u64) -> String. n things by the count word count, in the scope's language and digits: "1 page", "3 pages".
    • pub fn resolve(&self, label: &Label) -> Label. label with a Word replaced by its text in the scope's language: what domain code that draws a Label
  • craft_ui::runtime::env::Label: pub enum Label { Empty, Static(&'static str), Shared(Arc<str>), Word(Word) }. A label: a literal stays borrowed, a built string is shared. Cloning is cheap.
    • pub fn as_str(&self) -> &str. The text of a label whose Word is not resolved yet reads as its English text.
    • pub fn from_cow(text: Cow<'static, str>) -> Self. The label of text: a borrowed text stays borrowed.
  • craft_ui::runtime::env::LengthUnits: pub struct LengthUnits { pub stored: UnitKind, pub shown: UnitKind, pub pixels_per_inch: f64 }. A length kept in one unit and shown in another: what a length field reads and writes (stored, the document's
    • pub const fn new(stored: UnitKind, shown: UnitKind, pixels_per_inch: f64) -> Self. A length kept in stored and shown in shown, with pixels_per_inch sizing pixels.
  • craft_ui::runtime::env::Message: pub struct Message { pub text: Label, pub tone: Option<Tone> }. The text of a Validity: a label and an optional tone override. Warn defaults to Tone::Warn, Refuse to
    • pub fn new(text: impl Into<Label>) -> Self. A message with the default tone.
    • pub fn tone(mut self, tone: Tone) -> Self. The message in tone.
    • pub fn effective_tone(&self, warn: bool) -> Tone. The tone the message shows in: its own, else Warn when it belongs to a Validity::Warn (warn), else Bad.
  • craft_ui::runtime::env::MotionPolicy: pub struct MotionPolicy { pub mode: MotionMode, pub tokens: MotionTokens }. The motion mode in effect, carried in Env.motion.
    • pub const fn new(mode: MotionMode, tokens: MotionTokens) -> Self. The policy that runs animations at mode with tokens.
  • craft_ui::runtime::env::Overrides: pub struct Overrides { pub size: Option<ControlSize>, pub enabled: Option<bool>, pub read_only: Option<bool>, pub wheel: Option<WheelScope>, pub motion: Option<MotionMode>, pub direction: Option<Direction>, pub words: Option<WordsOverride>, pub values: AppValues }. Changes to the inherited values for a stretch of code.
  • craft_ui::runtime::env::PointSize: pub enum PointSize { PostScript, Traditional }. The size of a point, the Point/Pica Size of the Units preference. An app sets it once on its root env with
    • pub const fn points_per_inch(self) -> f64. How many points make an inch.
  • craft_ui::runtime::env::ResolvedRoot: pub struct ResolvedRoot { pub mode: Mode, pub contrast: Contrast, pub motion: MotionMode }. The mode, contrast and motion of a pass, with System resolved.
  • craft_ui::runtime::env::RevealEdge: pub enum RevealEdge { Top, Start, End }. An edge of the window whose slots a pointer at the edge reveals in body-only mode. The bottom edge and the centre
  • craft_ui::runtime::env::RootEnv: pub struct RootEnv { pub sizes: Arc<AppSizes>, pub text_size: TextSize, pub direction: Direction, pub motion: MotionChoice, pub mode: ModeChoice, pub contrast: ContrastChoice, pub density: Size, pub scale: Scale, pub tab_all_controls: bool, pub tab_toggles_chrome: bool, pub theme: ThemeId, pub values: AppValues, pub today: Option<CalendarDate> }. The app's root values each frame.
    • pub fn new() -> Self. A root with every value at its default.
    • pub fn scale(mut self, scale: Scale) -> Self. Sets the interface scale.
    • pub fn direction(mut self, direction: Direction) -> Self. Sets the layout direction.
    • pub fn motion(mut self, motion: MotionMode) -> Self. Sets the motion choice from a motion mode.
    • pub fn mode(mut self, mode: impl Into<ModeChoice>) -> Self. Sets the mode choice.
    • pub fn theme(mut self, theme: ThemeId) -> Self. Sets the theme.
    • pub fn resolved(&self, ctx: &Context) -> ResolvedRoot. What the choices resolve to on ctx's pass: the one place System is replaced by the OS's answer.
    • pub fn resolved_for(&self, system: SystemAppearance) -> ResolvedRoot. What the choices resolve to when the OS reports system.
    • pub fn appearance(&self, ctx: &Context) -> Appearance. The appearance the root's tokens resolve under on ctx: the mode, contrast, density and text size.
    • pub fn contrast(mut self, contrast: impl Into<ContrastChoice>) -> Self. Sets the contrast choice.
    • pub fn density(mut self, density: Size) -> Self. Sets the density preset.
    • pub fn today(mut self, date: CalendarDate) -> Self. Sets today's date, as the host's clock and time zone give it.
  • craft_ui::runtime::env::Scale: pub struct Scale(pub f32). The interface scale: pixels per point.
    • pub const fn new(pixels_per_point: f32) -> Self. pixels_per_point pixels per point.
  • craft_ui::runtime::env::ShellCx: pub struct ShellCx. What the window skeleton shows on this pass, read only.
    • pub fn new(window: WindowKey, mode: BodyMode, regions: ShellRegions) -> Self. The skeleton of window in mode with the layout of this pass. No reveal is on, the document tabs show as the
    • pub fn detached(window: WindowKey, mode: BodyMode, body: Rect) -> Self. A skeleton with no slots around body, for tests and the gallery without an AppShell.
    • pub fn with_tabs(mut self, tabs: bool) -> Self. Whether the host shows the document tabs; they show only in [BodyMode::Normal].
    • pub fn with_tab_reveal(mut self, on: bool) -> Self. The Tab reveal is on or off.
    • pub fn with_edge_reveal(mut self, edge: RevealEdge, on: bool) -> Self. The edge reveal of edge is on or off.
    • pub fn with_float_bounds(mut self, bounds: Rect) -> Self. Where floating frames may go: the body rect plus the area under bars that overlay the body.
    • pub fn with_region(mut self, region: Rect) -> Self. The screen rect of the region this shell fills inside another window (AppShell::embedded). Modal layers opened
    • pub fn region(&self) -> Option<Rect>. The region an embedded shell fills; None for a window's own shell.
    • pub fn put(&self, values: &mut AppValues). Sets this value in values, where BodyCx::shell reads it. The shell calls it on the values of the scope that
    • pub fn window(&self) -> &WindowKey. The window's key; components in slots key their ids and memory by it.
    • pub fn body_mode(&self) -> BodyMode. The body mode of this pass.
    • pub fn slot_visible(&self, key: SlotKey) -> bool. Is the slot with this key shown on this pass?
    • pub fn reveal_rect(&self, edge: RevealEdge, rect: Rect). Registers rect, a revealed panel the body drew on this pass, as part of the revealed edge: the edge reveal
    • pub fn revealed_rects(&self) -> Vec<(RevealEdge, Rect)>. The rects registered with reveal_rect on this pass, in registration order.
    • pub fn dialogs_shown(&self) -> u32. How many times a container in this shell showed on this pass as a dialog (a layer with a dialog's focus scope,
    • pub fn tabs_visible(&self) -> bool. Whether the document tabs show: the host's flag in normal mode, never in body-only mode.
    • pub fn revealed(&self) -> bool. Are slots shown by a reveal (Tab or edge) on this pass? Only body-only mode reveals.
    • pub fn edge_revealed(&self, edge: RevealEdge) -> bool. Is the edge reveal on for edge? False in normal mode and during the Tab reveal.
    • pub fn regions(&self) -> &ShellRegions. The body rect and the shown slots of this pass.
    • pub fn float_bounds(&self) -> Rect. Where floating frames may go: the body rect plus the area under bars that overlay the body.
  • craft_ui::runtime::env::ShellRegions: pub struct ShellRegions { pub body: Rect, pub slots: Vec<(SlotKey, Rect)> }. What one shell pass laid out.
    • pub fn new(body: Rect) -> Self. A layout with body and no slots.
    • pub fn with_slot(mut self, key: SlotKey, rect: Rect) -> Self. The layout with the shown slot key at rect, after the slots already listed.
  • craft_ui::runtime::env::SlotKey: pub type SlotKey = &'static str. The stable key of a slot.
  • craft_ui::runtime::env::StyleValue: pub trait StyleValue: EnvValue + Hash. Marker for values style may read. Hash, because the value is folded into the style key.
  • craft_ui::runtime::env::ThemeScope: pub struct ThemeScope. Token-changing values for a container's body: the body and everything under it resolve their styles from the
    • pub fn mode(mode: Mode) -> Self. A scope whose body resolves the inherited theme, contrast, density and text size in mode: a plot that is dark
  • craft_ui::runtime::env::UnitKind: pub enum UnitKind { Pixels, Percent, Degrees, Points, Times, Inches, Centimetres, Millimetres, Picas, PixelsPerInch, PixelsPerCentimetre, Minutes }. What a number counts.
    • pub const LENGTHS: [UnitKind; 5]. The kinds that measure a length, which per_inch answers for: what a length field offers.
    • pub const fn decimals(self) -> RangeInclusive<usize>. The digits after the decimal mark a number of this kind shows by default, at most.
    • pub const fn step(self) -> f64. What one arrow press, wheel notch or scrub point changes a number of this kind by, where the control that shows
    • pub const POINTS_PER_INCH: f64. The points in an inch of PostScript points, the default of Points and Picas.
    • pub fn per_inch(self, points_per_inch: f64) -> Option<f64>. How many units of this kind make an inch, for the kinds that measure length; points_per_inch sets the size
    • pub fn from_pixels(self, pixels: f64, extent: f64, pixels_per_inch: f64, points_per_inch: f64) -> Option<f64>. pixels in this unit: Pixels as they are, Percent of extent pixels, a length through pixels_per_inch
    • pub fn to_pixels(self, value: f64, extent: f64, pixels_per_inch: f64, points_per_inch: f64) -> Option<f64>. A value in this unit as pixels; the inverse of from_pixels.
  • craft_ui::runtime::env::UnitWords: re-export of craft_ui::runtime::env::units::UnitWords (defined outside these crates).
  • craft_ui::runtime::env::Units: pub struct Units. Reads and writes numbers with their unit in the user's language and digits. Build it with Env::units or
    • pub fn zoom_codec(&self) -> NumberCodec. The codec of a zoom field in percent: the percent reader, up to two decimals (the zoom ladder has rungs such as
    • pub fn points_per_inch(&self) -> f64. How many points make an inch in the scope: the app's point-size preference.
    • pub fn symbol(&self, kind: UnitKind) -> String. The unit's spelling in the user's language without the number: mm, px.
    • pub fn suffix(&self, kind: UnitKind) -> String. What follows a number of kind in the user's language: the symbol with the space the language puts before
    • pub fn text(&self, kind: UnitKind, n: f64, decimals: RangeInclusive<usize>) -> String. n of kind with between the least and most digits of decimals after the decimal mark, in the user's
    • pub fn show(&self, kind: UnitKind, n: f64) -> String. n of kind with its default digits ([UnitKind::decimals]).
    • pub fn pixels(&self, n: f64) -> String. n pixels: 12 px.
    • pub fn percent(&self, n: f64) -> String. n percent: 12%.
    • pub fn zoom_percent(&self, n: f64) -> String. A zoom of n percent: 100%, 12.5%, 66.67%. The fewest digits that show it to two decimals, so the
    • pub fn degrees(&self, n: f64) -> String. n degrees: 12°.
    • pub fn times(&self, n: f64) -> String. n times: 12×.
    • pub fn duration(&self, seconds: f64) -> String. seconds as a duration: 0.35 s, 12 s, with at most two digits after the decimal mark.
    • pub fn file_size(&self, bytes: u64) -> String. bytes as a file size in steps of 1024 with one decimal (1.5 KB, 12.0 MB, 512 bytes), the unit
    • pub fn file_size_as(&self, bytes: u64, style: FileSize) -> String. bytes as a file size written the way style says.
    • pub fn number(&self, n: f64, decimals: RangeInclusive<usize>) -> String. n with digit groups and between the least and most digits of decimals after the decimal mark, in the
    • pub fn number_ungrouped(&self, n: f64, decimals: RangeInclusive<usize>) -> String. n with between the least and most digits of decimals after the decimal mark, in the user's language and
    • pub fn reader(&self, kind: Option<UnitKind>) -> Reader. A reader for numbers of kind (plain numbers when None): the locale's decimal and group separators and
    • pub fn reader_with_points(&self, kind: Option<UnitKind>, points_per_inch: f64) -> Reader. Like reader, with Points and Picas of points_per_inch to the inch, so a typed 12pt is the
    • pub fn length_scale(&self, lengths: LengthUnits) -> Option<f64>. How many lengths.shown make one lengths.stored; None when either is not a pixel or length unit or the
    • pub fn length_reader(&self, lengths: LengthUnits) -> Reader. A reader for lengths shown in lengths.shown: the spellings of every length unit and of pixels convert to it,
    • pub fn document_reader(&self, ruler: UnitKind, extent: f64, pixels_per_inch: f64, points_per_inch: f64) -> Reader. A reader for the numbers of a document measured in ruler: the unit spellings of every pixel and length unit
  • craft_ui::runtime::env::WheelScope: pub enum WheelScope { Plain, Free, Gated }. How the wheel takers of a scope take the wheel.
  • craft_ui::runtime::env::WindowKey: pub struct WindowKey. The key of a window. It equals the placement SaveKey of the window, so two windows of one app need different keys.
    • pub fn main() -> Self. The first window, "main".
    • pub fn new(key: impl Into<String>) -> Self. A key from any string.
    • pub fn as_str(&self) -> &str. The key as a string.
  • craft_ui::runtime::env::Word: re-export of craft_ui::runtime::env::label::Word (defined outside these crates).
  • craft_ui::runtime::env::WordRows: re-export of craft_i18n::WordRows (outside these crates).
  • craft_ui::runtime::env::WordSet: re-export of craft_i18n::WordSet (outside these crates).
  • craft_ui::runtime::env::WordTemplate: re-export of craft_i18n::WordTemplate (outside these crates).
  • craft_ui::runtime::env::Words: re-export of craft_i18n::Words (outside these crates).
  • craft_ui::runtime::env::WordsOverride: pub enum WordsOverride { Replace(Arc<Words>), Overlay(WordRows) }. How a scope changes the built-in text: the only override path for words.
  • craft_ui::runtime::env::with_env: pub fn with_env<R>(ui: &mut Ui, set: impl FnOnce(&mut Overrides), body: impl FnOnce(&mut Ui) -> R) -> R. Runs body in a child Ui with set's changes applied to the inherited values. A scope that disables

craft_ui::runtime::focus

The focus service: stops, scopes and roving groups registered per pass, the focused stop per arena root,

  • craft_ui::runtime::focus::FocusMove: pub enum FocusMove { Keys, Other }. What moved the key focus.
  • craft_ui::runtime::focus::FocusShape: pub enum FocusShape { Rect, Circle }. The shape the focus ring takes around a part.
  • craft_ui::runtime::focus::host_canvas: pub fn host_canvas(ctx: &Context, id: Id, keys: KeyUse). Registers the app's own egui widget id, drawn in the running pass, as its window's document canvas: a focus stop
  • craft_ui::runtime::focus::request: pub fn request(ctx: &Context, target: FocusTarget) -> bool. Moves focus to target, leaves modality unchanged and asks the enclosing scroll owner to reveal it. Called
  • craft_ui::runtime::focus::ActivateKeys: pub enum ActivateKeys { Neither, Enter, Space, Both }. The keys that activate a component.
    • pub const fn enter(self) -> bool. Whether Enter activates.
    • pub const fn space(self) -> bool. Whether Space activates.
  • craft_ui::runtime::focus::EditSet: pub struct EditSet. The edit commands a component takes as Intent::Edit.
    • pub const NONE: EditSet. No command.
    • pub const ALL: EditSet. Every command.
    • pub const fn with(self, command: EditCommand) -> EditSet. The set plus command.
    • pub const fn contains(self, command: EditCommand) -> bool. Whether the set has command.
  • craft_ui::runtime::focus::EndKey: pub enum EndKey { LastItem, EndMode }. What a bare End means for a focused component.
  • craft_ui::runtime::focus::EnterRule: pub enum EnterRule { Pass, Submit }. What Enter does in a scope after the focused component declined it.
  • craft_ui::runtime::focus::FocusPolicy: pub struct FocusPolicy { pub kind: ScopeKind, pub trap: bool, pub restore: bool, pub initial: Initial, pub enter: EnterRule, pub cancel: CancelRule, pub pages: bool, pub list_enter: bool }. A focus scope's rules.
    • pub const NONE: FocusPolicy. A scope that changes nothing.
    • pub const PANE: FocusPolicy. A pane: an F6 stop.
    • pub const DIALOG: FocusPolicy. A dialog: Tab stays inside, Enter submits, Escape closes.
    • pub const POPUP: FocusPolicy. A popup: focus moves in, Escape closes and focus returns to the opener.
    • pub const MENU: FocusPolicy. A menu: like a popup.
    • pub const TAB_LAYER: FocusPolicy. A layer that only Tab reaches, such as the toasts: it traps nothing and takes no focus on its own, and when it
    • pub const fn trap(mut self, on: bool) -> Self. Whether Tab wraps inside the scope.
    • pub const fn restore(mut self, on: bool) -> Self. Whether focus returns to the opener.
    • pub const fn initial(mut self, initial: Initial) -> Self. Where focus goes first.
    • pub const fn cancel(mut self, cancel: CancelRule) -> Self. What Escape does.
    • pub const fn list_enter(mut self, on: bool) -> Self. Whether Enter on a text opener activates the layer's list.
    • pub const fn pages(mut self, on: bool) -> Self. Whether Ctrl+Tab cycles pages.
  • craft_ui::runtime::focus::FocusTarget: pub enum FocusTarget { Id(Id), Part(Id, PartRef), Doc(DocKey) }. What runtime::focus::request focuses.
  • craft_ui::runtime::focus::Initial: pub enum Initial { Keep, First, FirstField, Default, Key(&'static str), KeepAnchor }. Where focus goes the first time a scope is pushed.
  • craft_ui::runtime::focus::Intents: pub struct Intents. An owned copy of the intents routed to one id this pass; read through cx.intents().
    • pub fn take_digit(&mut self) -> Option<u8>. Takes the next typed digit.
    • pub fn take(&mut self, intent: Intent) -> bool. Takes an intent of the kind of intent, once per pass: the first taker gets it.
    • pub fn take_exact(&mut self, intent: &Intent) -> bool. Takes an intent equal to intent in every field, once per pass: Intent::delete(false, Granularity::Grapheme)
    • pub fn take_move(&mut self) -> Option<(NavMove, MoveMods)>. Takes the next move.
    • pub fn take_move_where(&mut self, wanted: impl Fn(NavMove, MoveMods) -> bool) -> Option<(NavMove, MoveMods)>. Takes the next move that wanted accepts; the others stay for a later taker, or for the scroll owner around a
    • pub fn take_scroll_access(&mut self, into_view: bool) -> Option<AccessRequest>. Takes the next AccessKit request that asks a scroll region to scroll, or with into_view to show its target.
    • pub fn take_edit(&mut self) -> Option<EditCommand>. Takes the next edit command.
    • pub fn take_text(&mut self) -> Option<Arc<str>>. Takes the next typed text.
    • pub fn take_nudge(&mut self) -> Option<(Vec2, Mods)>. Takes the physical arrow nudge for canvas content: a unit direction and the modifiers.
    • pub fn take_chords(&mut self) -> Vec<Chord>. Takes the chords this pass's presses spell, for a component whose key use is KeyUse::RECORDER; empty for any
    • pub fn take_set_value(&mut self) -> Option<f64>. Takes the AccessKit SetValue request aimed at the component's own node.
    • pub fn take_set_value_at(&mut self, part: impl Into<PartRef>) -> Option<f64>. Takes the AccessKit SetValue request aimed at the sub-node of part.
    • pub fn untaken(&self, intent: &Intent) -> bool. Whether an intent of the kind of intent is routed and not taken.
    • pub fn take_access(&mut self) -> Option<AccessRequest>. Takes the next Intent::Access request.
  • craft_ui::runtime::focus::KeepKeys: pub enum KeepKeys { None, Tab, InlineArrows, BlockArrows }. The keys a focused component keeps from the key stage.
  • craft_ui::runtime::focus::KeyUse: pub struct KeyUse { pub keep: KeepKeys, pub activate: ActivateKeys, pub claims: &'static [Chord], pub edits: EditSet, pub owner: OwnerClass, pub value: bool, pub moves: bool, pub chrome_key: bool, pub nudge: bool, pub deletes: bool, pub submits: bool, pub end: EndKey, pub session: bool, pub type_ahead: bool }. A component's declared keys.
    • pub const TEXT_MULTILINE: KeyUse. A multi-line text field: Up and Down move the caret.
    • pub const CODE: KeyUse. A code editor: Tab inserts.
    • pub const CANVAS: KeyUse. A document canvas: all arrows, no activation, and the key that marks its window as showing a document.
    • pub const SPLITTER: KeyUse. A divider between panes: it takes the arrows as moves of its value, but it is no document and no canvas tool, so
    • pub const RECORDER: KeyUse. A shortcut recorder: it takes the arrows of a canvas, but it is no document, so it marks no window and a Tab in
    • pub const fn of(input: Input) -> KeyUse. The default key use of a component that takes input. The only place egui key filters start from.
    • pub const fn with_type_ahead(mut self) -> Self. The same use taking typed letters as Intent::Text.
    • pub const fn with_claims(mut self, claims: &'static [Chord]) -> Self. The same use claiming claims.
    • pub const fn with_edits(mut self, edits: EditSet) -> Self. The same use listing edits.
    • pub const fn with_activate(mut self, activate: ActivateKeys) -> Self. The same use with activate as the keys that activate: a value control that arrow and Page keys step takes none.
    • pub const fn with_value(mut self, value: bool) -> Self. The same use with value as whether its arrows step a value.
    • pub const fn with_moves(mut self) -> Self. The same use declaring that the component acts on the moves routed to it.
    • pub const fn with_deletes(mut self) -> Self. The same use declaring that the component acts on Delete and Backspace.
    • pub const fn with_session(mut self) -> Self. The same use declaring that the component holds its arena's edit session (session).
    • pub const fn with_submits(mut self) -> Self. The same use declaring that the component acts on Enter and takes Intent::Submit.
    • pub const fn with_end(mut self, end: EndKey) -> Self. The same use with end as the meaning of a bare End.
    • pub const fn with_keep(mut self, keep: KeepKeys) -> Self. The same use with keep as the keys it keeps from the key stage.
    • pub const fn with_chrome_key(mut self, chrome_key: bool) -> Self. The same use with chrome_key as whether the component marks its window as showing a document: a canvas
    • pub fn claims_chord(&self, chord: &Chord) -> bool. Whether the component claims chord.
  • craft_ui::runtime::focus::Letters: pub enum Letters { None, TypeAhead }. Whether a roving group matches typed letters to entries.
  • craft_ui::runtime::focus::Roving: pub struct Roving { pub shape: NavShape, pub wrap: bool, pub home_end: bool, pub page: Option<usize>, pub letters: Letters, pub arrows: Arrows, pub first_column: Option<usize>, pub hands_back: bool, pub no_lead: bool, pub keeps_lead_moves: bool }. A roving group's rules: one Tab stop whose members take moves.
    • pub const fn new(shape: NavShape) -> Roving. A group of shape with Home and End, no wrap, no paging and no letters.
    • pub const fn wrap(mut self, on: bool) -> Self. Whether moves wrap.
    • pub const fn home_end(mut self, on: bool) -> Self. Whether Home and End move to the ends.
    • pub const fn page(mut self, rows: Option<usize>) -> Self. Rows a Page key covers.
    • pub const fn letters(mut self, letters: Letters) -> Self. Whether letters pick entries.
    • pub const fn arrows(mut self, arrows: Arrows) -> Self. The arrows the group takes.
    • pub const fn first_column(mut self, column: usize) -> Self. The column of the first member of a wrapped grid with column blank cells before it: Up and Down keep the
    • pub const fn hands_back(mut self) -> Self. A move the group cannot make reaches the owning component, which may page or change what the group shows.
    • pub const fn keeps_lead_moves(mut self) -> Self. Left and Right with the lead modifier reach the focused member.
    • pub const fn no_lead(mut self, on: bool) -> Self. Whether the focused member is no lead: the next move starts at an end, as from a group with no lead.
    • pub const fn state(&self, lead: Option<usize>) -> NavState. The state a step over this group starts from, at lead, or from no lead when the group has none.
    • pub const fn takes(&self, mv: NavMove, mods: MoveMods) -> bool. Whether the group handles mv with mods: Page moves only with a page size and without lead (on a document

craft_ui::runtime::frame

The frame plugin: the per-pass and per-frame steps, with the inputs the app sets and the outputs it drains.

  • craft_ui::runtime::frame::ChromeToggle: pub enum ChromeToggle { Panels, PanelsKeepTools }. Which panels a window's chrome toggle hides (spec 1.8): the window.toggle_panels and
  • craft_ui::runtime::frame::FrameInput: pub struct FrameInput { pub root: RootEnv, pub commands: CommandInput, pub host: Option<Arc<Host>> }. What the app sets before each frame.
    • pub fn new(root: RootEnv) -> Self. A frame with root and no host.
    • pub fn commands(mut self, commands: CommandInput) -> Self. Sets the command input.
    • pub fn host(mut self, host: Arc<Host>) -> Self. Sets the host.
  • craft_ui::runtime::frame::FrameOutput: pub struct FrameOutput { pub fired: Vec<Fired>, pub announcements: Vec<String>, pub chrome_toggles: Vec<(ViewportId, ChromeToggle)>, pub removed_gestures: Vec<GestureId>, pub outer_edits: Vec<OuterEdit> }. What the runtime accumulated since the last take_output, across passes and discarded passes.
  • craft_ui::runtime::frame::OuterEdit: pub enum OuterEdit { Begin { id: GestureId, label: Arc<str>, doc_key: Option<DocKey> }, Commit { id: GestureId }, Cancel { id: GestureId } }. A step of the outer gesture of a container whose ContainerProps::outer_edit is on: one undo step over the edits of
  • craft_ui::runtime::frame::discard_pass: pub fn discard_pass(ctx: &Context, reason: &'static str). Discards the running pass, so nothing of it paints, and runs it again, when [discardable]: for a host that learns
  • craft_ui::runtime::frame::discardable: pub fn discardable(ctx: &Context) -> bool. Whether the running pass can still be discarded: egui runs a bounded number of passes a frame, and a discard asked
  • craft_ui::runtime::frame::request_repaint_after: pub fn request_repaint_after(ctx: &Context, seconds: f64). Asks for one more pass of the viewport the running pass belongs to after seconds (a playback clock, a poll);
  • craft_ui::runtime::frame::set_input: pub fn set_input(ctx: &Context, input: FrameInput). Before the pass: from eframe's App::raw_input_hook, or before run_ui in tests. A call during a pass,
  • craft_ui::runtime::frame::take_output: pub fn take_output(ctx: &Context) -> FrameOutput. Everything accumulated since the last call, across passes and discarded passes.

craft_ui::runtime::inspect

Decision records and findings: what each pipeline step did, kept in frames a test fixture drives and inside an

  • craft_ui::runtime::inspect::Element: pub struct Element { pub id: Id, pub part: Option<PartRef>, pub component: &'static str, pub depth: usize, pub rect: Rect, pub content: Rect, pub facts: Option<Facts>, pub stop: Option<usize> }. One element an inspected region showed: a component, or a part of one with a node, a hit area or a focus stop.
  • craft_ui::runtime::inspect::Facts: pub struct Facts { pub role: String, pub name: Option<String>, pub labelled_by: Vec<Id>, pub value: Option<String>, pub actions: Vec<&'static str>, pub disabled: bool, pub interactive: bool }. What a node says, as step 16 reported it.
  • craft_ui::runtime::inspect::HitArea: pub struct HitArea { pub owner: Id, pub part: Option<PartRef>, pub rect: Rect }. A hit area the sensing core registered for a component of the region.
  • craft_ui::runtime::inspect::Recorded: pub struct Recorded { pub elements: Vec<Element>, pub hits: Vec<HitArea> }. What an inspected region showed in a pass.
    • pub fn stop_rect(&self, index: usize) -> Option<Rect>. The rect of the element at index where Tab stops on it: its hit area when it has one, else its box.
  • craft_ui::runtime::inspect::point_at: pub fn point_at(ctx: &Context, key: Id, index: Option<usize>). Points the list of the region key at the element at index, or at none. A region shown earlier in the pass that
  • craft_ui::runtime::inspect::pointed: pub fn pointed(ctx: &Context, key: Id) -> Option<usize>. The element of the region key its list points at (the row under the pointer), read as a value.
  • craft_ui::runtime::inspect::record: pub fn record<R>(ui: &mut Ui, key: Id, body: impl FnOnce(&mut Ui) -> R) -> (R, Option<Arc<Recorded>>). Shows body as the inspected region key: the components it shows in a real run are recorded, and the record is
  • craft_ui::runtime::inspect::recorded: pub fn recorded(ctx: &Context, key: Id) -> Option<Arc<Recorded>>. The latest record of the region key, read as a value: when the region shows later in the pass with a different

craft_ui::runtime::install

runtime::install: adds the runtime plugin once and sets the egui options the runtime owns.

  • craft_ui::runtime::install::InstallError: pub enum InstallError { AlreadyInstalled, DuplicateStyle(DuplicateStyle), Commands(commands::CommandDefError) }. Why install refused a spec.
  • craft_ui::runtime::install::InstallSpec: pub struct InstallSpec { pub shell_info: ShellInfo, pub window_system: Arc<dyn WindowSystem>, pub placement: Option<Arc<Mutex<Store>>>, pub frame_layers: Option<fn(&Context)>, pub looks: StyleReplacements, pub frame: Option<Decision> }. What install takes.
    • pub fn new(shell_info: ShellInfo, window_system: Arc<dyn WindowSystem>) -> Self. A spec for shell_info and window_system, with no ghost-layer painter.
    • pub fn placement(mut self, store: Arc<Mutex<Store>>) -> Self. Sets the store viewport mounts save their window placement in.
    • pub fn looks(mut self, looks: impl Into<StyleReplacements>) -> Self. Sets the app's style replacements.
    • pub fn frame(mut self, decision: Decision) -> Self. Sets the root window's decided frame (craft_window::policy::decide_for).
    • pub fn frame_layers(mut self, painter: Option<fn(&Context)>) -> Self. Sets the end hook's ghost-layer painter.
  • craft_ui::runtime::install::install: pub fn install(ctx: &Context, spec: InstallSpec) -> Result<(), InstallError>. Adds the runtime plugin to ctx and sets the egui options the runtime owns: interface scale is a command, and

craft_ui::runtime::keys

The key stage (spec 9.1, 9.2, 9.3, 9.7): the input hook strips the keys the runtime owns and records

  • craft_ui::runtime::keys::MenuKey: pub enum MenuKey { Focus, Letter(char) }. A menu-bar key of an in-window bar (spec 9.7). F10 reaches the bar on every OS; Alt keys only off a Mac.
  • craft_ui::runtime::keys::AccessRequest: re-export of craft_behavior::intent::AccessRequest.
  • craft_ui::runtime::keys::Intent: re-export of craft_behavior::intent::Intent.
  • craft_ui::runtime::keys::Intents: pub struct Intents. An owned copy of the intents routed to one id this pass; read through cx.intents().
    • pub fn take_digit(&mut self) -> Option<u8>. Takes the next typed digit.
    • pub fn take(&mut self, intent: Intent) -> bool. Takes an intent of the kind of intent, once per pass: the first taker gets it.
    • pub fn take_exact(&mut self, intent: &Intent) -> bool. Takes an intent equal to intent in every field, once per pass: Intent::delete(false, Granularity::Grapheme)
    • pub fn take_move(&mut self) -> Option<(NavMove, MoveMods)>. Takes the next move.
    • pub fn take_move_where(&mut self, wanted: impl Fn(NavMove, MoveMods) -> bool) -> Option<(NavMove, MoveMods)>. Takes the next move that wanted accepts; the others stay for a later taker, or for the scroll owner around a
    • pub fn take_scroll_access(&mut self, into_view: bool) -> Option<AccessRequest>. Takes the next AccessKit request that asks a scroll region to scroll, or with into_view to show its target.
    • pub fn take_edit(&mut self) -> Option<EditCommand>. Takes the next edit command.
    • pub fn take_text(&mut self) -> Option<Arc<str>>. Takes the next typed text.
    • pub fn take_nudge(&mut self) -> Option<(Vec2, Mods)>. Takes the physical arrow nudge for canvas content: a unit direction and the modifiers.
    • pub fn take_chords(&mut self) -> Vec<Chord>. Takes the chords this pass's presses spell, for a component whose key use is KeyUse::RECORDER; empty for any
    • pub fn take_set_value(&mut self) -> Option<f64>. Takes the AccessKit SetValue request aimed at the component's own node.
    • pub fn take_set_value_at(&mut self, part: impl Into<PartRef>) -> Option<f64>. Takes the AccessKit SetValue request aimed at the sub-node of part.
    • pub fn untaken(&self, intent: &Intent) -> bool. Whether an intent of the kind of intent is routed and not taken.
    • pub fn take_access(&mut self) -> Option<AccessRequest>. Takes the next Intent::Access request.
  • craft_ui::runtime::keys::MoveMods: re-export of craft_behavior::intent::MoveMods.
  • craft_ui::runtime::keys::NavMove: re-export of craft_behavior::intent::NavMove.
  • craft_ui::runtime::keys::PartRef: re-export of craft_behavior::part::PartRef.
  • craft_ui::runtime::keys::with_window_intents: pub fn with_window_intents(ctx: &Context, rtl: bool, take: impl FnOnce(&mut Intents) -> bool) -> bool. Offers the window's unfocused intents to take while nothing in the window has framework focus, and writes back

craft_ui::runtime::layout_memory

Layout memory: sizes one pass measures and the next pass places by, the one discard pass a change asks for, what

  • craft_ui::runtime::layout_memory::emit_text: pub fn emit_text(ctx: &Context, id: Id, text: Option<&str>). Hands forward a text a run found under id that content outside the body it runs in shows, as [emit_record]
  • craft_ui::runtime::layout_memory::forget_kept: pub fn forget_kept(ctx: &Context). Drops every kept measurement, so the next pass measures each body as a first pass would.
  • craft_ui::runtime::layout_memory::text: pub fn text(ctx: &Context, id: Id) -> Option<Arc<str>>. The text a run of this pass handed forward under id ([emit_text]), or a kept transcript gave this pass.

craft_ui::runtime::memory

Ids and memory: Remember, the memory stage, Facts, eviction and saved state.

  • craft_ui::runtime::memory::Remember: pub trait Remember. Implemented by Cx, BodyCx and ItemCx over the pipeline's memory stage, each keyed by its own base id.
    • fn key(&self, part: impl Hash + Debug) -> Id. base.with(part): child and relation ids.
    • fn memory<T: Slot>(&mut self) -> &mut T. The shown slot of this component.
    • fn memory_at<T: Slot>(&mut self, part: impl Hash + Debug) -> &mut T. A shown slot keyed sub(base, ("mem", part)).
    • fn take<T: Slot>(&mut self) -> Option<T>. The shown slot, read once: it moves out, so it follows the shown lifetime's eviction.
    • fn press_slot<T: Slot>(&mut self) -> &mut Option<T>. The press slot: it goes when its press ends.
    • fn keep<T: Slot>(&mut self) -> &mut T. The session slot: it goes only through forget.
    • fn saved<T: Savable>(&mut self, key: &SaveKey) -> &mut T. The saved slot of key: it goes only through forget_saved.
    • fn recall<T: Slot>(&self) -> T. A read-only copy of the shown slot, for paint.
    • fn pending<K: Hash, T: Slot, E: Slot>(&mut self, key: K, start: impl FnOnce() -> Job<T, E>) -> &Pending<T, E>. The result of the job start returns, one per key: it is submitted once, cancelled when the owner is
    • fn appeared(&self) -> bool. True on the first pass a shown stage exists for this id.
  • craft_ui::runtime::memory::Savable: pub trait Savable: Slot + Serialize + DeserializeOwned. A slot that also lives in saved state.
  • craft_ui::runtime::memory::SaveKey: pub struct SaveKey. The key of a saved slot, such as "craft_dialogs.export.place". The crate prefix is checked, and the key
    • pub const fn new(key: &'static str) -> Self. A key crate_prefix.name; evaluated in a const context it rejects a malformed name at compile time. The
    • pub fn named(key: impl Into<Arc<str>>) -> Self. A key crate_prefix.name built at run time, for slots kept per item, such as a window for each open
    • pub fn as_str(&self) -> &str. The key's text.
  • craft_ui::runtime::memory::Slot: pub trait Slot: Clone + Default + Send + Sync + 'static. A value kept in memory. Clone is required because egui's temp store clones on insert; large caches hold Arcs.

craft_ui::runtime::motion

The motion service (13): tweens over one clock, the motion table, and one repaint request per viewport.

  • craft_ui::runtime::motion::Animate: pub trait Animate: crate::runtime::memory::sealed::Sealed. Motion on Cx, BodyCx and ItemCx. Every method takes &self: slots live in context data under the
    • fn anim<T: Interpolate>(&self, name: &'static str, target: T, spec: MotionSpec) -> T. target approached over spec's duration; the first call returns target without animating.
    • fn anim_bool(&self, name: &'static str, on: bool, spec: MotionSpec) -> f32. A 0 to 1 value approaching 1 when on, else 0.
    • fn presence(&self, name: &'static str, open: bool, spec: MotionSpec) -> Presence. Open-close presence for something shown while it opens and fades out.
    • fn jump<T: Interpolate>(&self, name: &'static str, value: T). Sets name to value with no animation.
    • fn phase(&self, period: f64, tick: Option<f64>) -> Option<f32>. The 0 to 1 position of a loop of period seconds, stepped every tick seconds when given; None when
    • fn blink(&self, restart: f64) -> bool. Whether a caret last moved at restart (a pass time) shows now: solid right after restart, then
    • fn now(&self) -> f64. The pass's time in seconds, read once per frame.
    • fn wake_at(&self, at: f64). Asks for a pass at at (timers, holds, polls), whatever the motion mode.
  • craft_ui::runtime::motion::Interpolate: pub trait Interpolate: Copy + PartialEq + Send + Sync + 'static. A value a tween can run over.
    • fn lerp(a: Self, b: Self, t: f32) -> Self. The value t of the way from a to b; t is 0 to 1.
    • fn distance(a: Self, b: Self) -> f32. How far apart two values are, in the value's own unit.
  • craft_ui::runtime::motion::MotionSpec: pub struct MotionSpec. A motion constant: a component picks one from spec, never writes seconds.
    • pub const fn kind(self) -> MotionKind. The kind that picks this spec's row of the motion table.
  • craft_ui::runtime::motion::Presence: pub struct Presence { pub t: f32, pub visible: bool, pub exiting: bool }. An open-close presence: t is 0 closed and 1 open, and a closing one stays visible until t reaches 0.
  • craft_ui::runtime::motion::Tween: pub struct Tween<T: Interpolate>. A running animation of one value. Evaluating it at the same time twice gives the same value, so a
    • pub fn at(value: T) -> Self. A tween at rest at value.
    • pub fn shown(&self) -> T. The value to paint.
    • pub fn target(&self) -> T. The value it runs toward.
    • pub fn is_settled(&self) -> bool. True once the shown value is the target.
    • pub fn retarget(&mut self, to: T, now: f64). Runs toward to from the value shown now.
  • craft_ui::runtime::motion::now: pub fn now() -> web_time::Instant. The wall clock's reading, for a host that drives a store on real time (ShellApp::tick). It is the one place

craft_ui::runtime::motion::spec

The motion constants.

  • craft_ui::runtime::motion::spec::BLINK: pub const BLINK: MotionSpec. A text caret's blink.
  • craft_ui::runtime::motion::spec::CARET: pub const CARET: MotionSpec. A text caret gliding to its new place.
  • craft_ui::runtime::motion::spec::CHECK: pub const CHECK: MotionSpec. A check, a toggle or a selection turning on or off.
  • craft_ui::runtime::motion::spec::FOLLOW: pub const FOLLOW: MotionSpec. A target that moves every frame: zoom ease, remote cursors, autoscroll.
  • craft_ui::runtime::motion::spec::HOVER: pub const HOVER: MotionSpec. Hover and press feedback.
  • craft_ui::runtime::motion::spec::LOOP: pub const LOOP: MotionSpec. A spinner, marching ants or a pulse.
  • craft_ui::runtime::motion::spec::MOVE: pub const MOVE: MotionSpec. An element moving within the screen.
  • craft_ui::runtime::motion::spec::OPEN_FADE: pub const OPEN_FADE: MotionSpec. A popup's opacity.
  • craft_ui::runtime::motion::spec::OPEN_RISE: pub const OPEN_RISE: MotionSpec. A popup's travel while it opens.
  • craft_ui::runtime::motion::spec::OUTLINE: pub const OUTLINE: MotionSpec. A selection outline gliding to its new cells.

craft_ui::runtime::overlay

The layer stack (15.2): the record of the egui layers shown, their order and the open-modal fact.

  • craft_ui::runtime::overlay::Backdrop: pub enum Backdrop { None, Scrim }. A modal's backdrop.
  • craft_ui::runtime::overlay::CloseReason: pub enum CloseReason { Requested, Escape, Outside, FocusLeft(crate::runtime::focus::FocusMove), Activated, Enter, Timeout, AnchorGone }. Why a layer closes.
  • craft_ui::runtime::overlay::OpenFilter: pub enum OpenFilter { Any, Modal, Keys }. What any_open counts.
  • craft_ui::runtime::overlay::Rank: pub enum Rank { Window, Toast, Popup, Modal { backdrop: Backdrop }, ModalChrome, Tooltip }. An overlay's place in the order. Rank is the only place a layer's egui order is chosen.
    • pub const fn modal(backdrop: Backdrop) -> Rank. A modal rank with backdrop.
  • craft_ui::runtime::overlay::any_open: pub fn any_open(ctx: &Context, filter: OpenFilter) -> bool. Whether any layer of the running viewport that filter counts was shown last frame.
  • craft_ui::runtime::overlay::family: pub fn family(ctx: &Context, id: Id) -> SmallVec<[Id; 4]>. id and everything opened from inside it, shown last frame.
  • craft_ui::runtime::overlay::is_open: pub fn is_open(ctx: &Context, id: Id) -> bool. Whether the layer id was shown last frame.
  • craft_ui::runtime::overlay::request_close: pub fn request_close(ctx: &Context, id: Id, why: CloseReason). Queues a close of the layer id (a popup or a container). The owner's step 9 or OverlayUi::show collects it and
  • craft_ui::runtime::overlay::top: pub fn top(ctx: &Context) -> Option<Id>. The layer that receives Cancel: the newest member of the topmost family that takes keys.

craft_ui::runtime::pending

Background results (14): one result per key in runtime memory, produced by a job on a host::queue::JobQueue per context.

  • craft_ui::runtime::pending::Job: pub struct Job<T, E>. Background work for Remember::pending: runs on the context's job queue, stops early when its owner is
    • pub fn new(run: impl FnOnce(&Progress, &Cancel) -> Result<T, E> + Send + 'static) -> Self. A job at Priority::VISIBLE. run checks Cancel::is_cancelled where it can stop early.
    • pub fn priority(mut self, priority: Priority) -> Self. Runs before waiting jobs of lower priority.
  • craft_ui::runtime::pending::LOST_LIMIT: pub const LOST_LIMIT: u32. How many times in a row a job may end without delivering before its key shows [Pending::Lost].
  • craft_ui::runtime::pending::Pending: pub enum Pending<T, E> { Loading { progress: Option<f32> }, Ready(T), Failed(E), Lost }. A result that may not have arrived.
  • craft_ui::runtime::pending::Progress: pub struct Progress. A job's report of how far it has come. A report asks for a pass, so the progress shows.
    • pub fn report(&self, fraction: f32). Reports fraction (0 to 1) done.

craft_ui::runtime::pointer

The pointer snapshot, press targets, the shape record and press cancels (8.1, 8.3).

  • craft_ui::runtime::pointer::PointerFrame: pub struct PointerFrame { pub pos: Option<Pos2>, pub delta: Vec2, pub buttons: Buttons, pub press: Option<PressStart>, pub release: Option<PointerButton>, pub mods: Mods, pub time: f64, pub kind: PointerKind, pub sample: Option<PointerSample>, pub multi_touch: Option<MultiTouch>, pub scroll: Vec2, pub zoom: f32, pub slop: f32, pub target: f32 }. The pointer input of one pass of one viewport, egui-converted.
  • craft_ui::runtime::pointer::frame: pub fn frame(ctx: &Context) -> PointerFrame. The running pass's pointer input.

craft_ui::runtime::requests

What a control asks of its host and what the host answers: the colour picker, the file dialog and the eyedropper.

  • craft_ui::runtime::requests::ColorRequest: pub struct ColorRequest { pub key: String, pub title: Option<Label>, pub color: Option<Srgba> }. A request for a colour: the host opens its colour picker with title and color and writes the answer into
    • pub fn new(key: impl Into<String>, color: impl Into<Option<Srgba>>) -> Self. A request for key, opening the picker at color, or with no colour for None.
    • pub fn title(mut self, title: impl Into<Label>) -> Self. The picker's title.
  • craft_ui::runtime::requests::EyedropperRequest: pub struct EyedropperRequest { pub key: String }. An eyedropper toggle of a colour row after a press: the host answers it with the colour the sampler picked for the
    • pub fn new(key: impl Into<String>) -> Self. A request for the dropper of key.
  • craft_ui::runtime::requests::HostAnswer: pub enum HostAnswer { Color { key: String, color: Srgba }, Path { key: String, path: PathBuf }, Eyedropper { key: String, color: Srgba } }. What the host answered to a request, kept until the dialog applies it to its values in its next pass.
  • craft_ui::runtime::requests::IMAGE_EXTENSIONS: pub const IMAGE_EXTENSIONS: [&str; 6]. The image file extensions a file dialog offers for pictures, without the dot, in lower case.
  • craft_ui::runtime::requests::PathFilter: pub struct PathFilter { pub name: String, pub extensions: Vec<String> }. One entry of a file dialog's type filter.
    • pub fn new(name: impl Into<String>, extensions: &[&str]) -> Self. A filter named name for extensions.
  • craft_ui::runtime::requests::PathKind: pub enum PathKind { Folder, OpenFile { extensions: Vec<String> }, SaveFile }. What a text row's Browse button picks.
    • pub fn open_file(extensions: &[&str]) -> Self. An existing file of one of extensions.
  • craft_ui::runtime::requests::PathRequest: pub struct PathRequest { pub key: String, pub kind: PathKind, pub file_name: Option<String>, pub filters: Vec<PathFilter> }. A pressed Browse button: the host opens its file dialog for kind and writes the answer into key as a
    • pub fn new(key: impl Into<String>, kind: PathKind) -> Self. A request for the path of key.
    • pub fn save(key: impl Into<String>, file_name: impl Into<String>, filters: impl IntoIterator<Item = PathFilter>) -> Self. A request for a file to write under key, suggesting file_name and offering filters.

craft_ui::runtime::toast

The toast queues: one per window (WindowKey), filled from any code with a Context.

  • craft_ui::runtime::toast::Card: pub struct Card { pub id: ToastId, pub toast: Toast }. A toast in the queue, as the host reads it.
  • craft_ui::runtime::toast::MAX_CARDS: pub const MAX_CARDS: usize. Most cards queued at once; posting past it drops the oldest card that has no action.
  • craft_ui::runtime::toast::TIMEOUT: pub const TIMEOUT: f32. How long a toast stays when it names no timeout, in seconds: the source apps' notification duration.
  • craft_ui::runtime::toast::Toast: pub struct Toast { pub message: Label, pub timeout: Option<f32>, pub politeness: Politeness, pub tone: Tone, pub title: Option<Label>, pub lines: Vec<Label>, pub actions: Vec<ToastAction> }. A message the user sees for a while.
    • pub fn new(message: impl Into<Label>) -> Self. A neutral toast of message that stays [TIMEOUT] seconds and is announced politely.
    • pub fn tone(mut self, tone: Tone) -> Self. Sets the tone the card reads in.
    • pub fn title(mut self, title: impl Into<Label>) -> Self. Sets the title above the message.
    • pub fn lines<L: Into<Label>>(mut self, lines: impl IntoIterator<Item = L>) -> Self. Sets the bullet lines under the message.
    • pub fn action(mut self, action: ToastAction) -> Self. Adds an action after the message.
    • pub fn timeout(mut self, timeout: Option<f32>) -> Self. Sets how long the card stays.
    • pub fn politeness(mut self, politeness: Politeness) -> Self. Sets the announcement's politeness.
  • craft_ui::runtime::toast::ToastAction: pub struct ToastAction { pub label: Label }. An action of a toast card: a button-like link that ends the toast and is reported by end.
    • pub fn new(label: impl Into<Label>) -> Self. An action named label.
  • craft_ui::runtime::toast::ToastEnd: pub enum ToastEnd { Action(usize), Dismissed, Expired }. How a toast left the queue.
  • craft_ui::runtime::toast::ToastId: pub struct ToastId. A posted toast's handle.
  • craft_ui::runtime::toast::cards: pub fn cards(ctx: &Context, window: &WindowKey) -> Vec<Card>. The cards of the window window in the running viewport, oldest first.
  • craft_ui::runtime::toast::dismiss: pub fn dismiss(ctx: &Context, id: ToastId). Removes a toast before its timer ends, from whichever viewport holds it. The app asked for it, so no end is
  • craft_ui::runtime::toast::end: pub fn end(ctx: &Context, id: ToastId) -> Option<ToastEnd>. How the toast id ended, once: None while it is queued, after the report was read, and for a toast the cap
  • craft_ui::runtime::toast::keep: pub fn keep(ctx: &Context, id: ToastId). Keeps the toast id until it is closed, whatever its timeout (an error the user must read).
  • craft_ui::runtime::toast::post: pub fn post(ctx: &Context, window: &WindowKey, toast: Toast) -> ToastId. Posts toast to the window window of the running viewport. A body posts to its shell's window
  • craft_ui::runtime::toast::post_to: pub fn post_to(ctx: &Context, viewport: ViewportId, window: &WindowKey, toast: Toast) -> ToastId. Posts toast to the window window of viewport.
  • craft_ui::runtime::toast::shown: pub fn shown(ctx: &Context, id: ToastId, text: &str, held: bool). The host shows id in this pass; held says the pointer or focus is on it. The first show announces it.

craft_ui::runtime::windows

WindowHost: the one multi-window driver. It owns ShellInfo, refreshes each viewport's WindowInfo, releases

  • craft_ui::runtime::windows::CaptionRegions: pub struct CaptionRegions { pub buttons: Vec<(Button, Rect)>, pub edges: Vec<(ResizeEdge, Rect)>, pub moves: Vec<Rect>, pub covers: Vec<Vec<Rect>> }. Where the exclusive parts of one window lie, in points of its viewport: the window procedure answers a Windows
    • pub fn hit(&self, point: Pos2) -> Option<WindowHit>. What lies at point: a button wins over an edge, and an edge over a drag area. A drag area answers only where
  • craft_ui::runtime::windows::HitSink: pub struct HitSink. The Windows hit test of one window: the window procedure asks [HitSink::answer] where the OS asks for a hit
    • pub fn answer(&self, pixel: Pos2) -> Option<WindowHit>. What lies at pixel, in physical pixels from the top left of the window's client area: the hit test's screen
  • craft_ui::runtime::windows::KeyEquivalent: pub enum KeyEquivalent { Press(Chord), Tap(Chord), Copy, Cut }. A key equivalent the platform's menu took from the window.
  • craft_ui::runtime::windows::ResizeEdge: pub enum ResizeEdge { Top, Bottom, Left, Right, TopLeft, TopRight, BottomLeft, BottomRight }. An edge or corner a window resize starts from.
  • craft_ui::runtime::windows::ScreenshotError: re-export of craft_ui::runtime::egui::screenshot::ScreenshotError.
  • craft_ui::runtime::windows::ScreenshotFacts: re-export of craft_ui::runtime::egui::screenshot::ScreenshotFacts.
  • craft_ui::runtime::windows::ScreenshotSlot: re-export of craft_ui::runtime::egui::screenshot::ScreenshotSlot.
  • craft_ui::runtime::windows::WindowAction: pub enum WindowAction { Close, Minimize, ToggleMaximize, ToggleFullscreen, SetFullscreen(bool), SetMaximized(bool), Focus, StartMove, StartResize(ResizeEdge), SetOuterPosition(Pos2), SetInnerSize(Vec2), SetLevel(WindowLevel), SetTitle(String), SetOpacity(f32) }. A window command act sends.
  • craft_ui::runtime::windows::WindowFacts: pub struct WindowFacts { pub inner: Rect, pub outer: Option<Rect>, pub scale: Option<f32>, pub state: WindowState, pub focused: bool }. What the OS tells about a window, in desktop points.
  • craft_ui::runtime::windows::WindowHit: pub enum WindowHit { Move, Resize(ResizeEdge), Caption(Button) }. What a part of the window does for the operating system: a press on it moves the window, resizes it from an edge,
  • craft_ui::runtime::windows::WindowHost: pub struct WindowHost. The multi-window driver of one context.
    • pub fn of(ctx: &Context) -> Self. The window host of ctx.
    • pub fn current(&self) -> ViewportId. The viewport the running pass is for.
    • pub fn shell(&self) -> ShellInfo. The shell as the running viewport sees it.
    • pub fn viewports_available(&self) -> bool. Whether OS viewports can open: the capability is on and the integration does not embed them.
    • pub fn positions_reported(&self) -> bool. Whether the platform reports where windows are on the desktop and moves them there; false on Wayland.
    • pub fn visible(&self) -> bool. Whether the running viewport's window is drawn; a minimized or covered window runs no UI pass, so this reads
    • pub fn screenshot_facts(&self) -> ScreenshotFacts. What a screenshot of the running viewport measures this pass.
    • pub fn inject_move(&self, viewport: ViewportId, at: Pos2). Queues a pointer move to at in viewport, delivered on a pass of its own.
    • pub fn inject_click(&self, viewport: ViewportId, at: Pos2, button: PointerButton, count: u32). Queues a move to at, then count presses and releases of button, one pass each; a button egui has no
    • pub fn inject_key(&self, viewport: ViewportId, key: Key, mods: Mods). Queues key pressed and released with mods held, as the platform reports them.
    • pub fn key_equivalent(&self, viewport: ViewportId, equivalent: KeyEquivalent). Adds equivalent to the next input of viewport: a key equivalent the platform's menu took from the window
    • pub fn menu_open(&self, viewport: ViewportId, open: bool). Records whether the platform's menu of viewport is open. While it is, the window's next press or Escape is
    • pub fn take_menu_close(&self, viewport: ViewportId) -> bool. True once after a press or Escape reached viewport's input: the platform's menu is to close.
    • pub fn inject_text(&self, viewport: ViewportId, text: &str). Queues text as typed text.
    • pub fn withdraw_injected(&self, viewport: ViewportId). Drops the injected queue of viewport (the document changed); a pending queue counts as withdrawn
    • pub fn cancel_injected(&self) -> bool. Drops every injected queue and step in flight; true when anything was pending.
    • pub fn injected_idle(&self) -> bool. Whether no injected step is queued or awaits its pass: the application may answer its waiters.
    • pub fn take_injected_withdrawn(&self) -> bool. Whether an injected step was withdrawn since the last call.
    • pub fn repaint_in(&self, viewport: ViewportId, seconds: f64). Asks for one pass of viewport after seconds; a negative time means now, a non-finite one asks for
    • pub fn act(&self, viewport: ViewportId, action: WindowAction) -> bool. Sends action to viewport; see [act].
    • pub fn desktop_pointer(&self) -> Option<Pos2>. The system pointer in desktop points, as the platform tells it or, failing that, as the window a drag
    • pub fn warp_pointer(&self, to: Pos2) -> bool. Moves the system pointer to to in desktop points; false where the platform cannot.
    • pub fn facts(&self, viewport: ViewportId) -> Option<WindowFacts>. viewport's window facts, once it has reported its inner rect.
    • pub fn monitors(&self) -> Vec<Monitor>. The connected monitors, in desktop pixels; none where the platform does not list them.
    • pub fn set_outer(&self, viewport: ViewportId, outer: Rect) -> bool. Places viewport's outer rect at outer: its position, and the inner size that leaves the window's
    • pub fn viewport_of(&self, id: Id) -> Option<ViewportId>. The viewport of the container id while its window is open.
    • pub fn viewport_at(&self, at: Pos2) -> Option<ViewportId>. The window under the desktop point at: where windows overlap, the focused one, else the one focused last,
    • pub fn viewports_at(&self, at: Pos2) -> Vec<ViewportId>. The windows under the desktop point at, the topmost first (the order of [Self::viewport_at]).
    • pub fn frame(&self) -> Frame. Who draws the running viewport's frame, and the caption buttons it shows.
    • pub fn caption_regions(&self, viewport: ViewportId) -> Option<CaptionRegions>. Where the exclusive parts of viewport's window lay in its last complete pass: the caption buttons, the edge
    • pub fn install_hit_sink(&self, viewport: ViewportId) -> HitSink. The hit-test sink of viewport's window, made on the first call. The platform layer calls it once it has put
    • pub fn pointer_in(&self, viewport: ViewportId) -> Option<Pos2>. The desktop pointer in the coordinates of viewport, when it lies inside that window.
  • craft_ui::runtime::windows::WindowLevel: pub enum WindowLevel { Normal, Palette, AlwaysOnTop }. Where a window stands in the stack of windows.
  • craft_ui::runtime::windows::WindowSpec: pub struct WindowSpec { pub kind: WindowKind, pub chrome: Option<WindowChrome>, pub captions: Option<Captions>, pub level: WindowLevel, pub taskbar: bool, pub shown_after_first_paint: bool }. How an OS window opens (21.2): what it is for, who draws its frame, where it stands and whether it has a taskbar
    • pub fn tool() -> Self. A tool window (a native dock window): its own title row in place of the OS title bar
    • pub fn document() -> Self. A document window with the installed decision's frame.
    • pub fn dialog() -> Self. A dialog window with the installed decision's frame.
    • pub fn kind(mut self, kind: WindowKind) -> Self. Sets what the window is for.
    • pub fn chrome(mut self, chrome: WindowChrome) -> Self. Sets who draws the frame, whatever the installed decision says.
    • pub fn captions(mut self, captions: Option<Captions>) -> Self. Sets the caption buttons.
    • pub fn frame(mut self, frame: &Frame) -> Self. Takes the chrome and the captions from a decided frame; a frame without buttons has no captions.
    • pub fn level(mut self, level: WindowLevel) -> Self. Sets the level.
    • pub fn taskbar(mut self, taskbar: bool) -> Self. Sets whether the window has a taskbar or Dock entry.
  • craft_ui::runtime::windows::act: pub fn act(ctx: &Context, viewport: ViewportId, action: WindowAction) -> bool. Sends action to viewport. It is the only sender of window commands: it checks the capabilities and the
  • craft_ui::runtime::windows::double_click_action: pub fn double_click_action(frame: &Frame, setting: DoubleClick, maximized: bool) -> Option<WindowAction>. What a double click on a window's free move band (its title bar, or the strip a modal leaves over it) asks of the

craft_ui::runtime::words

Word sets that more than one family reads.

  • craft_ui::runtime::words::CommonWords: re-export of craft_ui::runtime::words::common::CommonWords (defined outside these crates).
  • craft_ui::runtime::words::HeaderWords: re-export of craft_ui::runtime::words::header::HeaderWords (defined outside these crates).

craft_ui::style

The style layer: the state set and its resolver, style parts and ComponentStyle, tokens (UiTokens,

  • craft_ui::style::Accepted: pub struct Accepted { pub variant: Variant, pub fell_back: bool }. The variant a component takes for a requested one.
  • craft_ui::style::ComponentStyle: re-export of craft_ui_macros::ComponentStyle (outside these crates).
  • craft_ui::style::ControlMetrics: re-export of craft_behavior::sizing::ControlMetrics.
  • craft_ui::style::Corners: pub enum Corners { All, Top, Start, End, None }. Which corners of a surface are rounded. Start and End mirror under right-to-left.
    • pub fn apply(self, radius: CornerRadius, direction: Direction) -> CornerRadius. radius with the corners this value leaves square zeroed.
  • craft_ui::style::DataColor: pub struct DataColor(pub Color32). A colour from data (a swatch, a layer label dot).
    • pub const fn new(color: Color32) -> Self. A data colour.
  • craft_ui::style::DuplicateStyle: pub struct DuplicateStyle(pub &'static str). Two replacements named one style key.
  • craft_ui::style::EnvKey: pub struct EnvKey. The key of everything a style depends on besides its own key: tokens, direction, scale, the OS, the window's
    • pub fn new(tokens: u64, direction: Direction, scale: Scale, os: Os, active: bool, values: u64) -> Self. The key of these inputs. tokens is UiTokens::key and values the hash of the style-affecting app values.
  • craft_ui::style::FlagMask: re-export of craft_theme::FlagMask (outside these crates).
  • craft_ui::style::Flags: re-export of craft_theme::Flags (outside these crates).
  • craft_ui::style::FocusLook: pub struct FocusLook { pub stroke: Stroke, pub offset: f32 }. A component's focus ring.
    • pub const fn new(stroke: Stroke, offset: f32) -> Self. A focus look.
  • craft_ui::style::GlyphRole: pub enum GlyphRole { Control, Tool, ToolRail, PanelRail }. How the icon-only buttons of a scope show their glyph, set by the container that holds them
  • craft_ui::style::HandleLook: pub struct HandleLook { pub side: f32, pub fill: Stateful<StyleColor>, pub stroke: StyleColor, pub stroke_width: f32 }. A canvas handle's fills and stroke.
  • craft_ui::style::IconLook: pub struct IconLook { pub side: f32, pub color: Stateful<StyleColor>, pub ground: Option<Stateful<StyleColor>> }. A component's icon.
    • pub fn new(side: f32, color: Stateful<StyleColor>) -> Self. An icon look.
    • pub fn on(mut self, ground: Stateful<StyleColor>) -> Self. Declares the fill the icon is painted on, for an icon that sits on a part's own fill.
  • craft_ui::style::Ink: pub enum Ink { OnPanel, OnDark, Accent }. The text and icon colour that reads on a surface, resolved at step 12.
  • craft_ui::style::Insets: re-export of craft_behavior::flow::Insets.
  • craft_ui::style::MarkerLook: pub struct MarkerLook { pub radius: f32, pub large: f32, pub ring: StyleColor, pub selected: StyleColor, pub ring_width: f32, pub halo: StyleColor, pub halo_width: f32, pub backing: StyleColor }. A colour marker: the mark on a colour field, wheel, disc or gradient line that shows where a colour sits. Its ring
  • craft_ui::style::Metrics: re-export of craft_behavior::sizing::Metrics.
  • craft_ui::style::Mix: re-export of craft_theme::Mix (outside these crates).
  • craft_ui::style::ResetMarkLook: pub struct ResetMarkLook { pub color: StyleColor, pub ring: StyleColor, pub ring_width: f32, pub diameter: f32 }. The reset dot's colours and diameter.
  • craft_ui::style::ResizeLineLook: pub struct ResizeLineLook { pub line: Stateful<StyleColor>, pub edge: Stateful<StyleColor>, pub width: Stateful<f32>, pub focus: StyleColor, pub focus_width: f32 }. The line of a resize divider: a split handle between panes, a table column's edge.
  • craft_ui::style::Resolve: re-export of craft_theme::Resolve (outside these crates).
  • craft_ui::style::RuleKind: pub enum RuleKind { Divider, Edge, Grid, DropMark }. Which rule a look is for.
  • craft_ui::style::RuleLook: pub struct RuleLook { pub color: Color32, pub width: RuleWidth }. The line a rule draws.
  • craft_ui::style::RuleWidth: pub enum RuleWidth { Hairline, Points(f32) }. The width of a rule.
    • pub fn pixels(self, pixels_per_point: f32) -> f32. The width in whole physical pixels on a display of pixels_per_point.
    • pub fn points(self, pixels_per_point: f32) -> f32. The width in points on a display of pixels_per_point.
  • craft_ui::style::ScrollBarKind: pub enum ScrollBarKind { Overlay, Docked }. Where a scroll bar sits.
  • craft_ui::style::ScrollBarLook: pub struct ScrollBarLook { pub kind: ScrollBarKind, pub track: Stateful<StyleColor>, pub thumb: Stateful<StyleColor>, pub thickness: f32, pub min_thumb: f32, pub inset: f32, pub edge: Option<RuleLook>, pub fade: f32 }. A scroll bar's track and thumb.
  • craft_ui::style::State: re-export of craft_theme::State (outside these crates).
  • craft_ui::style::StateMix: re-export of craft_theme::StateMix (outside these crates).
  • craft_ui::style::StateSet: pub struct StateSet { pub state: State, pub flags: Flags, pub t: StateMix }. The state of a component or one of its parts at step 12: the interaction state, the value flags and the
    • pub const fn new(state: State, flags: Flags, t: StateMix) -> Self. A state set.
    • pub fn resolve<T: Mix>(&self, look: &Stateful<T>) -> T. The value of look in this state.
  • craft_ui::style::Stateful: re-export of craft_theme::Stateful (outside these crates).
  • craft_ui::style::States: re-export of craft_theme::States (outside these crates).
  • craft_ui::style::StyleColor: pub struct StyleColor(pub Color32). A colour a style builder picked from tokens. Draw accepts only this or DataColor. It has no
    • pub fn egui(self) -> Color32. The colour as egui paints it: a domain painter wraps it in DataColor::new for a document run, so it never holds
  • craft_ui::style::StyleCx: pub struct StyleCx<'a> { pub tokens: &'a UiTokens, pub size: ControlSize, pub variant: Variant, pub direction: Direction, pub scale: Scale, pub os: Os, pub active: bool, pub key: EnvKey }. What fn style gets. Tokens are read here and nowhere else.
    • pub fn contrast(&self) -> Contrast. The contrast setting of the scope, for a style that adds a cue at high contrast.
    • pub fn density(&self) -> Size. The density preset of the scope, for a style whose shape differs between presets.
    • pub fn env<T: StyleValue>(&self) -> T. An app value set by a scope. Its hash is part of the style cache key.
    • pub fn color(&self, color: Rgba) -> StyleColor. The one constructor of StyleColor: a semantic token read or a token-group field becomes a style colour here.
    • pub fn ink_on(&self, fill: DataColor) -> StyleColor. The ink for text on a user colour: the higher-contrast of text.normal and text.on_strong on the fill,
    • pub fn focus_look(&self) -> FocusLook. The one builder of the focus ring: the line's focus colour at the medium stroke, on the shape's edge.
    • pub fn tone(&self, tone: Tone) -> StyleColor. The colour text and icons of tone read in.
    • pub fn tone_fill(&self, tone: Tone) -> StyleColor. The tinted background text and icons of tone sit on: the status or accent background, and the sunken surface
    • pub fn host_ink(&self, base: Stateful<StyleColor>) -> Stateful<StyleColor>. A text or icon colour that is base when the component stands alone and the text colour of the host part
    • pub fn host_muted_ink(&self, base: Stateful<StyleColor>) -> Stateful<StyleColor>. A muted text colour that is base when the component stands alone and the muted text colour of the host part
    • pub fn accent_fill(&self) -> Stateful<StyleColor>. The fill of an accent control that is on or filled: the strong accent at rest, with its hover and pressed
    • pub fn track(&self) -> TrackLook. The look of a value track: a groove of size.groove with the part a value fills over it, and its marks.
    • pub fn ink(&self, ink: Ink) -> StyleColor. The colour text and icons on a surface read in.
    • pub fn control(&self) -> ControlMetrics. The height, icon side, padding, gap and field widths of a control at the ambient size.
    • pub fn glyph(&self) -> f32. The side of a mark inside a control at the ambient size (size.icon.glyph_sm, glyph_md): an icon-only
    • pub fn glyph_role(&self) -> GlyphRole. How the icon-only buttons of the scope show their glyph.
    • pub fn control_of(&self, size: ControlSize) -> ControlMetrics. control at size, whatever the ambient size: the part of a control that keeps its own size (a field's
    • pub fn segment_control(&self) -> ControlMetrics. control, with the side padding of a segment of a segmented control: space.pad.control at the small size
    • pub fn text_width(&self, role: craft_theme::TypeRole, text: &str) -> f32. The width of text set in the face of role: the sizes that follow the text (a row header's digit) read it
    • pub fn surface(&self, kind: SurfaceKind) -> SurfaceStyle. What a surface of kind draws.
    • pub fn text_well(&self) -> SurfaceLook. The look of a text well: the well surface with an edge that takes the focus colour while the well holds
    • pub fn field(&self) -> SurfaceLook. The look of a text or value field: the text well with the failure colour on its edge while its value is
    • pub fn dropdown(&self) -> SurfaceLook. The look of the closed box of a dropdown picker: the field, filled with the hover fill under the pointer and
    • pub fn rule(&self, kind: RuleKind) -> RuleLook. The line a rule of kind draws.
    • pub fn handle(&self) -> HandleLook. The look of a canvas handle.
    • pub fn marker(&self) -> MarkerLook. The look of a colour marker.
    • pub fn scroll_bar(&self, kind: ScrollBarKind) -> ScrollBarLook. The look of a scroll bar of kind.
    • pub fn state_layer(&self) -> Stateful<StyleColor>. The state layer: the theme's hover and press fills, clear at rest and while disabled. A part declared
    • pub fn reset_mark(&self) -> ResetMarkLook. The look of the reset mark.
    • pub fn variant_look(&self) -> VariantParts. The look of the instance's variant as style parts.
    • pub fn token_group<G: TokenGroup>(&self) -> G. The token group G for this token set: derived from the tokens with the theme's values under G::PATH laid
  • craft_ui::style::StyleKey: pub trait StyleKey: Copy + Eq + Hash + Send + Sync + 'static. A 'static key of the instance inputs a style depends on: unique per component type, so two components that
  • craft_ui::style::StyleReplacements: pub struct StyleReplacements. The replacements an app asks for, collected before runtime::install freezes them.
    • pub const fn new() -> Self. No replacements.
    • pub fn push<K: StyleKey, S: ComponentStyle>(&mut self, f: Replacement<K, S>) -> &mut Self. Replaces the style function of the component whose style key is K. Two replacements for one key are an
  • craft_ui::style::SurfaceEdge: pub enum SurfaceEdge { None, Border(Stroke), Bevel { top_left: Color32, bottom_right: Color32, width: f32 } }. A surface's edge, resolved from the theme's edge style.
  • craft_ui::style::SurfaceKind: pub enum SurfaceKind { Background, Canvas, Chrome, Panel, Raised, Pressed, Sunken, Well, Knob, Popup, Dialog, Floating, Scrim, Frame }. The surface a container or part sits on, which picks fill, edge, shadow and ink.
    • pub const fn ink(self) -> super::Ink. The ink text and icons read on this surface.
  • craft_ui::style::SurfaceLook: pub struct SurfaceLook { pub kind: Option<SurfaceKind>, pub kind_down: Option<SurfaceKind>, pub kind_on: Option<SurfaceKind>, pub fill: Stateful<StyleColor>, pub border: Option<Stateful<StyleColor>>, pub border_width: f32, pub inner: Option<Stateful<StyleColor>>, pub radius: CornerRadius, pub corners: Corners, pub border_replaces_edge: bool }. A component's or part's surface.
    • pub fn new(fill: Stateful<StyleColor>) -> Self. A look with fill and no kind, border or radius.
    • pub fn kind_in(&self, state: &super::StateSet) -> Option<SurfaceKind>. The surface kind in state: kind_down while pressed, kind_on while on, else kind.
    • pub fn kind(mut self, kind: SurfaceKind) -> Self. Sets the surface kind.
    • pub fn kind_down(mut self, kind: SurfaceKind) -> Self. Sets the kind used while pressed.
    • pub fn kind_on(mut self, kind: SurfaceKind) -> Self. Sets the kind used while on.
    • pub fn radius(mut self, radius: CornerRadius) -> Self. Sets the corner radius.
    • pub fn corners(mut self, corners: Corners) -> Self. Sets which corners are rounded.
    • pub fn border_replaces_edge(mut self) -> Self. The border replaces the kind's flat edge.
    • pub fn border(mut self, border: Stateful<StyleColor>, width: f32) -> Self. Sets the border colours and width.
  • craft_ui::style::SurfaceStyle: pub struct SurfaceStyle { pub fill: Color32, pub radius: CornerRadius, pub edge: SurfaceEdge, pub shadow: Option<Shadow> }. Everything a surface of one kind draws.
    • pub fn disabled(&self, panel: Color32, edge: Color32) -> SurfaceStyle. This look while disabled: opaque, the fill moved toward panel (the disabled fill) by Opacity::DISABLED, the edge edge, and no
  • craft_ui::style::TextLook: pub struct TextLook { pub role: TypeRole, pub color: Stateful<StyleColor>, pub ground: Option<Stateful<StyleColor>> }. A component's text.
    • pub fn new(role: TypeRole, color: Stateful<StyleColor>) -> Self. A text look.
    • pub fn on(mut self, ground: Stateful<StyleColor>) -> Self. Declares the fill the text is painted on, for a text that sits on a part's own fill.
  • craft_ui::style::TokenGroup: re-export of craft_theme::TokenGroup (outside these crates).
  • craft_ui::style::Tokens: re-export of craft_theme::Tokens (outside these crates).
  • craft_ui::style::TrackLook: pub struct TrackLook { pub unfilled: Stateful<StyleColor>, pub filled: Stateful<StyleColor>, pub edge: Stateful<StyleColor>, pub edge_width: f32, pub thickness: f32, pub ramp: f32, pub radius: CornerRadius, pub mark_length: f32, pub mark_width: f32, pub mark_color: Stateful<StyleColor>, pub snap: f32 }. A value track: a groove with the part a value fills over it, and the marks and ticks along it. A slider, a
    • pub fn groove(&self, rect: egui::Rect) -> egui::Rect. The groove across the middle of rect.
  • craft_ui::style::TypeRole: re-export of craft_theme::TypeRole (outside these crates).
  • craft_ui::style::UiTokens: pub struct UiTokens. One resolved token set with the theme's token-group values and a key of their content. Each theme scope
    • pub fn new(tokens: Arc<Tokens>, contrast: Contrast, density: Size) -> Self. A token set resolved under contrast and density, with no theme values for token groups.
    • pub fn tokens(&self) -> &Arc<Tokens>. The source tokens.
    • pub fn groups(&self) -> &GroupValues. The theme's token-group values.
    • pub fn key(&self) -> u64. Equal for equal sets and distinct for different ones; the token-group and style caches key on it.
  • craft_ui::style::Variant: re-export of craft_theme::Variant (outside these crates).
  • craft_ui::style::VariantParts: pub struct VariantParts { pub fill: Stateful<StyleColor>, pub text: Stateful<StyleColor>, pub muted: Stateful<StyleColor>, pub edge: Option<Stateful<StyleColor>>, pub radius: CornerRadius }. A variant's look as style parts.
  • craft_ui::style::accepted_variant: pub fn accepted_variant<K: StyleKey, S: ComponentStyle>(requested: Variant) -> Accepted. A component accepts its VARIANTS plus every custom variant built for its style key. Any other variant gives
  • craft_ui::style::resize_line_look: pub fn resize_line_look(tokens: &UiTokens) -> ResizeLineLook. The resize divider's line, read from tokens.

craft_ui::testing

The fixture, the suite runner and the story helpers.

  • craft_ui::testing::Trial: pub struct Trial { pub module: &'static str, pub name: &'static str, pub run: fn(), pub ignored: bool }. One registered trial.
    • pub const fn new(module: &'static str, name: &'static str, run: fn()) -> Trial. A registration, as #[trial] writes it.
    • pub const fn ignored(module: &'static str, name: &'static str, run: fn()) -> Trial. The registration of an #[ignore]d trial, as #[trial] writes it.
    • pub fn full_name(&self) -> String. The name filters match: the module path below the crate, then the function.
  • craft_ui::testing::registered_in: pub fn registered_in(crate_name: &str) -> Vec<&'static Registration>. Every registration declared in the library crate of the package crate_name and linked into the running
  • craft_ui::testing::run: pub fn run(crate_root: &str, package: &'static str, registered: &[&'static Registration]) ->!. Runs a test executable and exits: the #[trial]s declared in the crate whose root module is crate_root or in
  • craft_ui::testing::trials: pub fn trials() -> Vec<&'static Trial>. Every #[trial] linked into the running binary, by full name.
  • craft_ui::testing::Fixture: re-export of craft_ui::testing::fixture::Fixture.
  • craft_ui::testing::Frames: re-export of craft_ui::testing::frames::Frames.
  • craft_ui::testing::Impure: re-export of craft_ui::testing::fixture::Impure.
  • craft_ui::testing::Room: re-export of craft_ui::testing::fixture::Room.
  • craft_ui::testing::Target: re-export of craft_ui::testing::fixture::Target.
  • craft_ui::testing::forget_measurements: re-export of craft_ui::runtime::layout_memory::forget_kept.
  • craft_ui::testing::in_edge_pane: pub fn in_edge_pane<R>(ui: &mut Ui, edge: PaneEdge, story: impl FnOnce(&mut Ui) -> R) -> R. Runs story as the content of an edge pane at edge, as a rail or panel docked at that edge of an app window
  • craft_ui::testing::install_spec: re-export of craft_ui::testing::windows::install_spec.
  • craft_ui::testing::is_measuring: re-export of craft_ui::runtime::measure::active (defined outside these crates).
  • craft_ui::testing::last_pass_measuring_runs: re-export of craft_ui::runtime::measure::last_pass_body_runs (defined outside these crates).
  • craft_ui::testing::last_pass_runs: re-export of craft_ui::runtime::measure::last_pass_runs (defined outside these crates).
  • craft_ui::testing::measured_contributions: re-export of craft_ui::runtime::measure::contributions (defined outside these crates).
  • craft_ui::testing::measuring_run: re-export of craft_ui::runtime::measure::run (defined outside these crates).
  • craft_ui::testing::measuring_runs: re-export of craft_ui::runtime::measure::body_runs (defined outside these crates).
  • craft_ui::testing::room_height: pub fn room_height(ui: &Ui) -> f32. The height of the room ui offers a story whose root has no content height and fills it (a window, a full-window
  • craft_ui::testing::shrink_least_runs: re-export of craft_ui::runtime::measure::least_runs (defined outside these crates).
  • craft_ui::testing::stage: pub fn stage(ui: &mut Ui) -> Rect. Allocates the stage of a story of a canvas control or a root that fills both axes, and returns its rect: the width
  • craft_ui::testing::stage_fitting: pub fn stage_fitting(ui: &mut Ui, height: impl FnOnce(f32) -> f32) -> Rect. Allocates a stage as wide as [stage]'s and as tall as the story's content at that width, which height gives,
  • craft_ui::testing::stage_width: pub fn stage_width(ui: &Ui) -> f32. The width of the stage [stage_fitting] allocates: the width left in ui between the least and greatest stage
  • craft_ui::testing::story: re-export of craft_ui_macros::story (outside these crates).
  • craft_ui::testing::take_effects: re-export of craft_ui::runtime::measure::take_effects (defined outside these crates).
  • craft_ui::testing::trial: re-export of craft_ui_macros::trial (outside these crates).
  • craft_ui::testing::widest_runs: re-export of craft_ui::runtime::measure::widest_runs (defined outside these crates).

craft_ui::testing::access

What the accessibility trials read: the AccessKit tree a frame produced, and the label scope a container opens.

  • craft_ui::testing::access::begin_label_scope: pub fn begin_label_scope(ctx: &Context, container: Id, label: FieldLabel). Opens the label scope of container with label, as a field container's body step does; the container's
  • craft_ui::testing::access::focused_key: pub fn focused_key(tree: &AccessTree) -> NodeKey. The node AccessKit reports as focused.
  • craft_ui::testing::access::is_interactive: pub fn is_interactive(tree: &AccessTree, key: NodeKey) -> bool. Whether the node declares an action a user can take: focus, click or a value change.
  • craft_ui::testing::access::name: pub fn name(tree: &AccessTree, key: NodeKey) -> Option<&str>. The accessible name of the node, when it has a non-empty one: its own, else the first non-empty name of the nodes
  • craft_ui::testing::access::tree_of: pub fn tree_of(output: &mut crate::runtime::egui::fixture::FullOutput) -> AccessTree. The AccessKit tree a finished pass of a viewport produced, taken out of its output; empty when it made none.
  • craft_ui::testing::access::violations: pub fn violations(ctx: &Context, tree: &AccessTree) -> Vec<String>. The rule violations of a frame: interactive nodes with no name, and every finding the runtime's role rules
  • craft_ui::testing::access::AccessTree: pub struct AccessTree. The AccessKit tree update of one frame.
    • pub fn has(&self, id: Id) -> bool. Whether the node of id exists.
    • pub fn role(&self, id: Id) -> Option<Role>. The role of the node of id.
    • pub fn name(&self, id: Id) -> Option<&str>. The name of the node of id.
    • pub fn description(&self, id: Id) -> Option<&str>. The description of the node of id.
    • pub fn description_of(&self, key: NodeKey) -> Option<&str>. The description of a node by key.
    • pub fn shortcut_of(&self, key: NodeKey) -> Option<&str>. The keyboard shortcut a node by key lists.
    • pub fn value_of(&self, key: NodeKey) -> Option<&str>. The text value of a node by key.
    • pub fn value(&self, id: Id) -> Option<&str>. The text value of the node of id.
    • pub fn numeric(&self, id: Id) -> Option<Numeric>. The numeric value and range of the node of id.
    • pub fn numeric_of(&self, key: NodeKey) -> Option<Numeric>. The numeric value and range of a node by key.
    • pub fn is_disabled(&self, id: Id) -> bool. Whether the node of id is reported as disabled.
    • pub fn declares(&self, id: Id, action: Declared) -> bool. Whether the node of id declares action.
    • pub fn labelled_by(&self, id: Id) -> Vec<NodeKey>. The nodes that name the node of id.
    • pub fn labelled_by_key(&self, key: NodeKey) -> Vec<NodeKey>. [AccessTree::labelled_by] for a node by key.
    • pub fn described_by(&self, id: Id) -> Vec<NodeKey>. The nodes that describe the node of id.
    • pub fn position(&self, id: Id) -> Option<(usize, usize)>. The place of the node of id in its set: its zero-based index and the size of the set.
    • pub fn grid_of(&self, key: NodeKey) -> GridPlace. The row and column indexes and counts of a node by key.
    • pub fn sort_of(&self, key: NodeKey) -> Option<bool>. The sort order a column header node by key shows: true descending.
    • pub fn declares_sort(&self, key: NodeKey) -> bool. Whether a column header node declares a sort direction: it sorts when activated, sorted now or not.
    • pub fn expanded(&self, id: Id) -> Option<bool>. The expanded state of the node of id.
    • pub fn has_popup(&self, id: Id) -> Option<PopupKind>. The kind of popup the node of id opens.
    • pub fn controls(&self, id: Id) -> Vec<NodeKey>. The nodes the node of id controls.
    • pub fn is_modal(&self, key: NodeKey) -> bool. Whether the node of key is modal.
    • pub fn live(&self, id: Id) -> Option<Politeness>. The live politeness of the node of id.
    • pub fn invalid(&self, id: Id) -> bool. Whether the node of id is marked invalid.
    • pub fn run_texts(&self, id: Id) -> Vec<String>. The text of each TextRun node below id, in order.
    • pub fn text_selection(&self, id: Id) -> Option<((NodeKey, usize),(NodeKey, usize))>. The selection of the text node id as the run node and character index of its anchor and focus.
    • pub fn name_of(&self, key: NodeKey) -> Option<&str>. The name of a node by key.
    • pub fn toggled_of(&self, key: NodeKey) -> Option<craft_behavior::Mixed<bool>>. The toggled state of a node by key.
    • pub fn expanded_of(&self, key: NodeKey) -> Option<bool>. The expanded state of a node by key.
    • pub fn has_popup_of(&self, key: NodeKey) -> Option<PopupKind>. The kind of popup the node of key opens.
    • pub fn access_key_of(&self, key: NodeKey) -> Option<char>. The access key of the node of key.
    • pub fn current_of(&self, key: NodeKey) -> bool. Whether the node of key is the current item of its set (the current page).
    • pub fn parent_of(&self, id: Id) -> Option<NodeKey>. The nearest ancestor of id that screen readers see: AccessKit's consumer drops generic containers.
    • pub fn parent_of_key(&self, key: NodeKey) -> Option<NodeKey>. [AccessTree::parent_of] for a node by key.
    • pub fn in_ltr_axis(&self, key: NodeKey) -> bool. Whether the node is, or lies inside, a component whose horizontal axis keeps its left-to-right order
    • pub fn keys(&self) -> Vec<NodeKey>. Every node that assistive technology reports.
    • pub fn node_count(&self) -> usize. The number of nodes that assistive technology reports.
    • pub fn role_of(&self, key: NodeKey) -> Option<Role>. The role of a node by key.
    • pub fn selected_of(&self, key: NodeKey) -> Option<bool>. Whether a node by key is reported as selected: None for a node that reports no selected state.
    • pub fn bounds_of(&self, key: NodeKey) -> Option<egui::Rect>. The bounds of a node by key, in points.
    • pub fn is_disabled_key(&self, key: NodeKey) -> bool. Whether a node by key is reported as disabled.
    • pub fn declares_key(&self, key: NodeKey, action: Declared) -> bool. Whether a node by key declares action.
    • pub fn children_of(&self, key: NodeKey) -> Vec<NodeKey>. The children of a node by key.
  • craft_ui::testing::access::Declared: pub enum Declared { Focus, Click, Increment, Decrement, SetValue, SetTextSelection, Expand, Collapse, Custom, ScrollUp, ScrollDown, ScrollLeft, ScrollRight }. An action a node declares.
  • craft_ui::testing::access::NodeKey: pub struct NodeKey. A node's number in the tree.
    • pub fn of(id: Id) -> NodeKey. The key of the node of id.

craft_ui::testing::bypass

Bypass detection (24.2): the pass-end walk that finds what a component made without the runtime.

  • craft_ui::testing::bypass::findings: pub fn findings(fixture: &Fixture) -> Vec<String>. What the latest frame's widgets and nodes show of code that bypassed the runtime; empty when nothing did. The

craft_ui::testing::contract

What the contract trials read: the decision records and findings of the pipeline.

  • craft_ui::testing::contract::allocate: pub fn allocate(ui: &mut egui::Ui, size: egui::Vec2). Allocates a widget of size in ui.
  • craft_ui::testing::contract::canvas_controls: pub fn canvas_controls(ctx: &Context) -> Vec<&'static str>. The canvas-control types that have shown on ctx.
  • craft_ui::testing::contract::clicked: pub fn clicked(response: &egui::Response) -> bool. Whether response reports a click, by pointer or by keyboard activation.
  • craft_ui::testing::contract::edit_response: pub fn edit_response<T>(response: egui::Response) -> crate::contract::EditResponse<T>. An edit response with no events, for a trial component that has no cx.edit_response() to call.
  • craft_ui::testing::contract::findings: pub fn findings(ctx: &Context) -> Vec<Finding>. Every finding reported on ctx.
  • craft_ui::testing::contract::queue_reveal: pub fn queue_reveal(ctx: &Context, owner: Id, rect: egui::Rect). Queues a reveal of rect for the scroll owner owner, as a component that asked for it leaves it for the owner's
  • craft_ui::testing::contract::raw_widget: pub fn raw_widget(ui: &mut egui::Ui, rect: egui::Rect). Places a clickable egui widget in rect by hand, the way a bypass of the components does.
  • craft_ui::testing::contract::steps: pub fn steps(ctx: &Context, id: Id) -> Vec<&'static str>. The steps the latest show of id ran, in order.
  • craft_ui::testing::contract::take_reveal: pub fn take_reveal(ctx: &Context, owner: Id) -> Option<egui::Rect>. The reveal request addressed to the scroll owner owner, once.

craft_ui::testing::dump

Text dumps for tests: ordered key = value lines compared exactly with a file, so a change in

  • craft_ui::testing::dump::BUDGET: pub const BUDGET: usize. The most lines the committed style dumps may hold in total.
  • craft_ui::testing::dump::Dump: pub struct Dump. Ordered key = value lines.
    • pub fn new() -> Self. An empty dump.
    • pub fn comment(&mut self, text: &str) -> &mut Self. A # text line, e.g. naming the test that writes the file.
    • pub fn line(&mut self, key: &str, value: impl DumpValue) -> &mut Self. Appends key = value, with key under the current group prefix.
    • pub fn group(&mut self, prefix: &str, f: impl FnOnce(&mut Dump)) -> &mut Self. Runs f with prefix. put before every key it writes.
    • pub fn text(&self) -> &str. The lines written so far.
    • pub fn entries(&self) -> impl Iterator<Item =(String, &str)>. The (key, value) pairs written so far, keys with their group prefixes; comments are
    • pub fn compare(&self, path: impl AsRef<Path>) -> Result<(), String>. Compares with the file at path, or rewrites it when [update_requested]. The error
    • pub fn check(&self, path: impl AsRef<Path>). compare, failing the test on a mismatch.
  • craft_ui::testing::dump::DumpValue: pub trait DumpValue. A value's text in a dump.
    • fn dump_value(&self) -> String. The value as dump text.
  • craft_ui::testing::dump::Entries: pub type Entries = Vec<(String, String)>. The (key, value) lines of one theme, collected to be written with the other themes' (see [Themed]).
  • craft_ui::testing::dump::Themed: pub struct Themed. Dump lines of one group in several themes, written as one line per key plus one per differing theme.
    • pub fn new() -> Self. No themes yet.
    • pub fn theme(&mut self, name: &str, entries: Entries) -> &mut Self. Adds the lines entries of theme name.
    • pub fn write(&self, dump: &mut Dump). Writes each key once, in first-seen order, with its most frequent value (the first of equals), then
  • craft_ui::testing::dump::check_budget: pub fn check_budget(skip: &[&str]). Fails when the dumps outside skip hold more than [BUDGET] lines.
  • craft_ui::testing::dump::check_dir: pub fn check_dir(dir: impl AsRef<Path>, dumps: &[(String, Dump)]). Checks a directory one test owns: every (file name, dump) pair, and no other .txt files
  • craft_ui::testing::dump::diff: pub fn diff(old: &str, new: &str) -> String. The lines only in old (- ) and only in new (+ ), at most 20. Dump keys are unique, so
  • craft_ui::testing::dump::dump_lines: pub fn dump_lines(skip: &[&str]) -> usize. The lines of every dump file under crates/*/tests/dumps except those of the crates in skip, comments
  • craft_ui::testing::dump::dump_resolved: pub fn dump_resolved<T: std::fmt::Debug>(dump: &mut Dump, name: &str, resolve: impl Fn(&UiTokens) -> T). What resolve reads from the tokens of every theme of [themes], written into dump under name: each key
  • craft_ui::testing::dump::dump_style: pub fn dump_style<K: StyleKey, S: ComponentStyle + std::fmt::Debug>(dump: &mut Dump, ctx: &egui::Context, name: &str, variants: &[Variant], size: ControlSize, key: K, default: for<'a> fn(&StyleCx<'a>, K) -> S,). The resolved style of the component whose style function is default, for each of variants and in every
  • craft_ui::testing::dump::flatten_debug: pub fn flatten_debug(value: &dyn std::fmt::Debug) -> Entries. The fields of a value as (path, text) pairs, read from its pretty Debug form: a struct field is its name, a
  • craft_ui::testing::dump::themes: pub fn themes() -> Vec<(String, UiTokens)>. Every built-in theme in each mode it has, at standard contrast, as (<theme>.<mode>, tokens).
  • craft_ui::testing::dump::update_requested: pub fn update_requested() -> bool. Whether UPDATE_DUMPS is set (to anything but 0).

craft_ui::testing::fixture

Fixture: one story or closure shown over [Frames], with the env a test varies and input by AccessKit query or part.

  • craft_ui::testing::fixture::Fixture: pub struct Fixture. A closure or story shown frame by frame.
    • pub fn new(show: impl FnMut(&mut Ui) + 'static) -> Self. A fixture that shows show in a room of 400 by 300 points.
    • pub fn story(story: &Story) -> Self. A fixture that shows story; its data and outputs are read with [Fixture::data] and [Fixture::take_outputs].
    • pub fn story_scoped(story: &Story, scope: fn(&mut Overrides)) -> Self. A fixture that shows story inside an env scope scope changes: disabled, read-only, or both.
    • pub fn probe_purity(&mut self) -> &mut Self. Runs every following pass of the story under the purity probe: a measuring run of the story before each real
    • pub fn impure(&self) -> Vec<Impure>. The impure passes the fixture has seen so far under [Fixture::probe_purity]; see [Impure].
    • pub fn command_state(&mut self, command: impl Into<CommandRef>, state: CommandState) -> &mut Self. Gives app-scope command this state in every following pass, as an app's FrameInput.commands does; a later
    • pub fn room(&mut self, room: Vec2) -> &mut Self. The room the story is shown in.
    • pub fn in_room(&mut self, room: Room) -> &mut Self. The room of a host kind: the same as [Fixture::room] with that kind's size.
    • pub fn direction(&mut self, direction: Direction) -> &mut Self. The layout direction.
    • pub fn theme(&mut self, mode: Mode, contrast: Contrast) -> &mut Self. Light or dark, and standard or high contrast.
    • pub fn motion(&mut self, motion: MotionMode) -> &mut Self. The motion mode.
    • pub fn text_size(&mut self, text_size: TextSize) -> &mut Self. The text-size step.
    • pub fn density(&mut self, density: Size) -> &mut Self. The density preset.
    • pub fn scale(&mut self, scale: Scale) -> &mut Self. The interface scale.
    • pub fn host(&mut self, host: std::sync::Arc<craft_host::Host>) -> &mut Self. The host every following frame is given: its language, catalogs and services.
    • pub fn os(&mut self, os: Os) -> &mut Self. The operating system the keys and chrome follow: the shell's OS and capabilities, and egui's own OS for its
    • pub fn chrome(&mut self, chrome: craft_host::target::WindowChrome) -> &mut Self. Who draws the root window's frame. A native shell puts its menu bar in the window when the app draws the frame
    • pub fn advance(&mut self, seconds: f64) -> &mut Self. The manual clock, moved on by seconds before the next frame.
    • pub fn ctx(&self) -> &egui::Context. The frames' context.
    • pub fn data(&self) -> std::cell::RefMut<'_, StoryData>. The story's data.
    • pub fn take_outputs(&mut self) -> Vec<StoryOutput>. The outputs the story gave since the last call, one per pass.
    • pub fn root_id(&self) -> Option<Id>. The component id of the latest shown output, kept when the outputs are taken.
    • pub fn drag_part(&self) -> Option<PartRef>. The first part of the shown component that senses a drag.
    • pub fn click_part(&self) -> Option<PartRef>. The first part of the shown component that senses a click: what a click activates when the component has
    • pub fn styles_of(&self, type_name: &str) -> Vec<std::sync::Arc<super::style::StyleSeen>>. The styles the pipeline resolved for the component type type_name in this fixture.
    • pub fn texts(&self) -> &[fixture::PaintedText]. The text runs the latest frame painted.
    • pub fn copied(&self) -> &[String]. The texts the latest frame put on the clipboard.
    • pub fn opened(&self) -> &[(String, bool)]. Every URL the fixture's frames asked to open, in order, each with whether it asked for a new tab.
    • pub fn shape_bounds(&self) -> &[Rect]. The visual bounds of the shapes the latest frame painted.
    • pub fn shape_overshoot(&self) -> &[f32]. Half the stroke width of the shape behind each of shape_bounds.
    • pub fn repaint_requested(&self) -> bool. Whether anything asked for another pass since the latest frame ended.
    • pub fn ime(&self) -> Option<&fixture::ImeSeen>. The IME output of the latest frame.
    • pub fn shown(&self) -> Rect. The area the latest pass allocated.
    • pub fn passes(&self) -> usize. The passes the latest frame ran.
    • pub fn frame(&mut self, events: Vec<Event>) -> &mut Self. One frame with events.
    • pub fn frame_shapes(&mut self) -> Vec<egui::Shape>. One frame with no events; returns the shapes it painted, nested shapes flattened.
    • pub fn idle(&mut self, n: usize) -> &mut Self. n frames with no events.
    • pub fn settle(&mut self) -> &mut Self. Frames with no events until the latest one is stable, where an app stops painting: it ran one pass, asked for
    • pub fn tree(&self) -> &AccessTree. The AccessKit tree of the latest frame.
    • pub fn target(&self, node: NodeKey) -> Option<Target>. The node by key, with its bounds, when the latest tree has it.
    • pub fn by_label(&self, label: &str) -> Option<Target>. The node named label: the interactive node whose name resolves to it (its own, or the node that labels it
    • pub fn by_role(&self, role: Role) -> Vec<Target>. The nodes of role in tree order.
    • pub fn part(&self, component: Id, part: impl Into<PartRef>) -> Option<Target>. The sub-node of part below the component component.
    • pub fn part_rect(&self, owner: Id, part: impl Into<PartRef>) -> Option<Rect>. The rect of the part part of the component owner as the sensing step recorded it, for parts that have no
    • pub fn click(&mut self, target: &Target) -> &mut Self. Hover, press and release on target, in separate frames, then one idle frame.
    • pub fn click_at(&mut self, pos: Pos2) -> &mut Self. Hover, press and release at pos, in separate frames, then one idle frame.
    • pub fn hold(&mut self, modifiers: Modifiers) -> &mut Self. The modifiers held in every following frame, until the next call. A key sent while they are held carries
    • pub fn press(&mut self, target: &Target) -> &mut Self. Press on target.
    • pub fn release(&mut self, target: &Target) -> &mut Self. Release at the middle of target.
    • pub fn drag(&mut self, target: &Target, by: Vec2) -> &mut Self. Press on target, move by by in four steps, release.
    • pub fn drag_at(&mut self, from: Pos2, by: Vec2) -> &mut Self. A drag from the point from by by: the same frames as [Fixture::drag], for a point that is no target.
    • pub fn drag_hold_at(&mut self, from: Pos2, by: Vec2) -> &mut Self. The first half of a drag that pauses: press at from, move by by in four steps, and one frame with the
    • pub fn release_at(&mut self, at: Pos2) -> &mut Self. Releases the button at at, then a frame with no input.
    • pub fn drag_at_pausing(&mut self, from: Pos2, by: Vec2, halt: impl FnOnce(&mut Fixture)) -> &mut Self. A drag from from by by that pauses before the release: [Fixture::drag_hold_at], halt with the gesture
    • pub fn key(&mut self, key: Key, modifiers: Modifiers) -> &mut Self. A key press and release with modifiers and the ones [Fixture::hold] keeps, as a keyboard reports them:
    • pub fn type_text(&mut self, text: &str) -> &mut Self. Typed text.
    • pub fn access(&mut self, kind: AccessActionKind, target: &Target) -> &mut Self. An AccessKit action on target.
    • pub fn focused_stop(&self) -> Option<(Id, Option<PartRef>)>. The stop that holds focus: the id of its component and the part when focus is on a part.
    • pub fn press_only_stops(&self) -> Vec<Rect>. Where the stops that only a press reaches sit (read-only text, selection parts), in stop order: the bounds of
    • pub fn focused_role(&self) -> Option<craft_behavior::KeyRole>. The key role of the stop that holds focus: which key rows it takes (type-ahead, rename, reorder).
    • pub fn focused(&self) -> Option<Id>. The id of the widget egui has focused.
    • pub fn frame_through(&mut self, events: Vec<Event>) -> &mut Self. events as one OS frame, followed by the frames an app runs for it: one for each step of input the one-press
  • craft_ui::testing::fixture::Impure: pub struct Impure { pub pass: usize, pub measuring: bool, pub changed: Vec<&'static str>, pub effects: Vec<&'static str> }. A pass in which a story's drawing code changed state it must leave alone, as a fixture under
  • craft_ui::testing::fixture::Room: pub enum Room { Panel, Dialog, Window }. The room of a trial, named by the kind of host the component sits in. A trial that needs another size gives it to
    • pub fn size(self) -> Vec2. The room's size in points.
  • craft_ui::testing::fixture::Target: pub struct Target { pub node: NodeKey, pub rect: Rect }. A node of the AccessKit tree, as input addresses it.
    • pub fn center(&self) -> Pos2. The middle of the node's bounds.

craft_ui::testing::focus

The focus service's fixture: egui widgets for stops, the egui focus, and the events the key and press

  • craft_ui::testing::focus::access_request: pub fn access_request(kind: AccessActionKind, target: Id) -> Event. An AccessKit action request for the node numbered by target.
  • craft_ui::testing::focus::activated_member: pub fn activated_member(ctx: &Context, root: Id) -> Option<Id>. The member whose Activate the group root reads this pass.
  • craft_ui::testing::focus::active_part: pub fn active_part(ctx: &Context, id: Id) -> Option<PartRef>. The part of id that is the focus stop, when one is.
  • craft_ui::testing::focus::begin_body: pub fn begin_body(ctx: &Context). Marks the stops registered from here on in the innermost open scope as its body's.
  • craft_ui::testing::focus::claim: pub fn claim(ctx: &Context, owner: Id, chord: Chord). A state-dependent claim of owner.
  • craft_ui::testing::focus::commit_now: pub fn commit_now(ctx: &Context) -> Option<Id>. The text part that commits its draft in this pass because a press moved focus away from it.
  • craft_ui::testing::focus::context_request: pub fn context_request(ctx: &Context, id: Id) -> Option<Rect>. The rect id's context request of this pass opens at, when it made one.
  • craft_ui::testing::focus::egui_focused: pub fn egui_focused(ctx: &Context) -> Option<Id>. The widget egui holds key focus on.
  • craft_ui::testing::focus::focus_visible: pub fn focus_visible(ctx: &Context, id: Id) -> bool. is_focused with focus visible.
  • craft_ui::testing::focus::intents_of: pub fn intents_of(ctx: &Context, id: Option<Id>, rtl: bool) -> Intents. The intents routed to id this pass, with horizontal moves read in the component's direction.
  • craft_ui::testing::focus::is_focused: pub fn is_focused(ctx: &Context, id: Id) -> bool. Whether the focus stop is the component id.
  • craft_ui::testing::focus::key_release: pub fn key_release(key: Key, modifiers: Modifiers) -> Event. A key release.
  • craft_ui::testing::focus::named_id: pub fn named_id(name: &str) -> Id. A globally unique id named by name.
  • craft_ui::testing::focus::pop_scope: pub fn pop_scope(ctx: &Context). Closes the innermost open scope.
  • craft_ui::testing::focus::press_shape: pub fn press_shape(ui: &Ui, rect: Rect, sense: Sense, owner: Id). Registers a shape of owner at rect on the layer of ui that senses a press as sense says, as a
  • craft_ui::testing::focus::primary_button: pub fn primary_button(pos: Pos2, pressed: bool) -> Event. A primary button press or release at pos.
  • craft_ui::testing::focus::push_scope: pub fn push_scope(ctx: &Context, id: Id, policy: FocusPolicy, label: Option<Arc<str>>). Opens the scope id for the stops registered until the matching [pop_scope].
  • craft_ui::testing::focus::register_doc: pub fn register_doc(ctx: &Context, key: DocKey, id: Id). Registers the component that FocusTarget::Doc(key) focuses.
  • craft_ui::testing::focus::register_group: pub fn register_group(ctx: &Context, group: Group). Registers a roving group of the running pass.
  • craft_ui::testing::focus::register_node: pub fn register_node(ctx: &Context, node: Id, owner: Id, part: Option<PartRef>, focusable: bool). Registers an AccessKit node so a request that targets it reaches owner.
  • craft_ui::testing::focus::register_stop: pub fn register_stop(ctx: &Context, stop: Stop). Registers stop in the innermost open scope of the running pass.
  • craft_ui::testing::focus::scope_escape: pub fn scope_escape(ctx: &Context, rule: CancelRule, press_captured: bool, scope_clearable: bool) -> Option<EscapeStep>. What an untaken Escape does in a scope.
  • craft_ui::testing::focus::set_value: pub fn set_value(target: Id, value: f64) -> Event. An AccessKit SetValue request of value for the node of target.
  • craft_ui::testing::focus::settle: pub fn settle(ctx: &Context, id: Option<Id>, intents: &Intents). Writes back what a component left untaken.
  • craft_ui::testing::focus::take_claimed: pub fn take_claimed(ctx: &Context, id: Id, chord: Chord) -> bool. Whether the claimed chord arrived this pass for id, consuming it.
  • craft_ui::testing::focus::take_reveal: pub fn take_reveal(ctx: &Context) -> Option<(Id, Option<PartRef>)>. The component the last focus request or Tab move asked the enclosing scroll owner to reveal.
  • craft_ui::testing::focus::take_submit: pub fn take_submit(ctx: &Context) -> bool. Takes an untaken Submit for the innermost scope with a default action.
  • craft_ui::testing::focus::widget: pub fn widget(ui: &mut Ui, id: Id) -> Rect. Shows a focusable egui widget of id, as a component root's sensing core does, and returns its rect.
  • craft_ui::testing::focus::AccessActionKind: pub enum AccessActionKind { Focus, Click, Increment, Decrement, SetValue(f64), Expand, Collapse, ScrollUp, ScrollDown, ScrollLeft, ScrollRight }. The actions the focus trials request.
    • pub fn is(self, action: &craft_behavior::AccessRequest) -> bool. Whether action is this one.
  • craft_ui::testing::focus::Group: re-export of craft_ui::runtime::focus::registration::Group (defined outside these crates).
  • craft_ui::testing::focus::Intents: pub struct Intents. An owned copy of the intents routed to one id this pass; read through cx.intents().
    • pub fn take_digit(&mut self) -> Option<u8>. Takes the next typed digit.
    • pub fn take(&mut self, intent: Intent) -> bool. Takes an intent of the kind of intent, once per pass: the first taker gets it.
    • pub fn take_exact(&mut self, intent: &Intent) -> bool. Takes an intent equal to intent in every field, once per pass: Intent::delete(false, Granularity::Grapheme)
    • pub fn take_move(&mut self) -> Option<(NavMove, MoveMods)>. Takes the next move.
    • pub fn take_move_where(&mut self, wanted: impl Fn(NavMove, MoveMods) -> bool) -> Option<(NavMove, MoveMods)>. Takes the next move that wanted accepts; the others stay for a later taker, or for the scroll owner around a
    • pub fn take_scroll_access(&mut self, into_view: bool) -> Option<AccessRequest>. Takes the next AccessKit request that asks a scroll region to scroll, or with into_view to show its target.
    • pub fn take_edit(&mut self) -> Option<EditCommand>. Takes the next edit command.
    • pub fn take_text(&mut self) -> Option<Arc<str>>. Takes the next typed text.
    • pub fn take_nudge(&mut self) -> Option<(Vec2, Mods)>. Takes the physical arrow nudge for canvas content: a unit direction and the modifiers.
    • pub fn take_chords(&mut self) -> Vec<Chord>. Takes the chords this pass's presses spell, for a component whose key use is KeyUse::RECORDER; empty for any
    • pub fn take_set_value(&mut self) -> Option<f64>. Takes the AccessKit SetValue request aimed at the component's own node.
    • pub fn take_set_value_at(&mut self, part: impl Into<PartRef>) -> Option<f64>. Takes the AccessKit SetValue request aimed at the sub-node of part.
    • pub fn untaken(&self, intent: &Intent) -> bool. Whether an intent of the kind of intent is routed and not taken.
    • pub fn take_access(&mut self) -> Option<AccessRequest>. Takes the next Intent::Access request.
  • craft_ui::testing::focus::Stop: re-export of craft_ui::runtime::focus::registration::Stop (defined outside these crates).

craft_ui::testing::frames

A fixed-rate frame driver over a context.

  • craft_ui::testing::frames::Frames: pub struct Frames { pub ctx: Context }. One context, advanced frame by frame at 60 Hz.
    • pub fn screen(&mut self, room: Vec2). The size of the egui screen rect in every following frame: room where it is larger than the default
    • pub fn new() -> Self. A fresh context with the runtime installed.
    • pub fn pixels_per_point(&mut self, pixels_per_point: f32). The window's pixels per point in every following frame.
    • pub fn record_paint(&mut self). Keeps what every following frame paints, for [Frames::take_paint].
    • pub fn take_paint(&mut self) -> Option<fixture::FullOutput>. What the frames painted since the last call, as a renderer takes it: the last frame's shapes and every
    • pub fn uninstalled() -> Self. A fresh context without the runtime, for frames that ran before install.
    • pub fn install(&mut self). Installs the runtime on the context.
    • pub fn host(&mut self, host: Arc<Host>). The host every following frame is given.
    • pub fn root(&mut self, root: RootEnv). The root values every following frame is given.
    • pub fn commands(&mut self, commands: CommandInput). The command input every following frame is given.
    • pub fn frame(&mut self, events: Vec<Event>, mut ui: impl FnMut(&mut Ui)) -> usize. One frame with events; ui runs once per pass. Returns the number of passes.
    • pub fn frame_without_input(&mut self, events: Vec<Event>, ui: impl FnMut(&mut Ui)) -> bool. One frame with no set_input, as an app that never calls it would drive it: the root values and the
    • pub fn frame_in_viewport(&mut self, viewport: egui::ViewportId, ui: impl FnMut(&mut Ui)). One pass with no events in viewport, a child window of the root, between two frames of the root.
    • pub fn frame_shapes(&mut self, mut ui: impl FnMut(&mut Ui)) -> Vec<egui::Shape>. One frame with no events; returns the shapes it painted, nested shapes flattened.
    • pub fn hold(&mut self, modifiers: egui::Modifiers). The modifiers held in every following frame.
    • pub fn hover_files(&mut self, names: &[&str]). Files named names are dragged over the window from the OS, in this frame and every following one until they
    • pub fn hover_typed_files(&mut self, files: &[(&str, &str)]). Like hover_files, with the media type the OS reports for each file while it hovers.
    • pub fn leave_files(&mut self). The hovering files leave the window without a drop.
    • pub fn drop_files(&mut self, names: &[&str]). The hovering files drop on the window in the next frame; names are what the OS reports as dropped.
    • pub fn advance(&mut self, seconds: f64). Moves the clock on by seconds before the next frame.
    • pub fn idle(&mut self, n: usize, mut ui: impl FnMut(&mut Ui)). n frames with no events.
    • pub fn ime(&self) -> Option<&fixture::ImeSeen>. The IME output of the last frame: None when it wrote none.
    • pub fn copied(&self) -> &[String]. The texts the last frame put on the clipboard.
    • pub fn opened(&self) -> &[(String, bool)]. Every URL the frames so far asked to open, in order, each with whether it asked for a new tab.
    • pub fn texts(&self) -> &[fixture::PaintedText]. The text runs the last frame painted.
    • pub fn shape_bounds(&self) -> &[egui::Rect]. The visual bounds of the shapes the last frame painted.
    • pub fn shape_overshoot(&self) -> &[f32]. Half the stroke width of the shape behind each of shape_bounds.
    • pub fn tree(&mut self) -> AccessTree. The AccessKit tree the last frame produced.
    • pub fn repaint_delay(&self) -> Option<Duration>. The wait the last frame asked for before the next pass: Duration::ZERO for an immediate repaint,
    • pub fn repaint_requested(&self) -> bool. Whether anything asked for a pass since the last frame ended.
    • pub fn cursor_icon(&self) -> egui::CursorIcon. The system cursor the last frame's output asked for.
  • craft_ui::testing::frames::announce_text: pub fn announce_text(ctx: &Context, text: &str). Adds text to the next frame output's announcements, as the runtime's access service does.
  • craft_ui::testing::frames::show_area: pub fn show_area<R>(ctx: &Context, name: &'static str, body: impl FnOnce(&mut Ui) -> R) -> R. Shows an egui Area and runs body on its Ui.
  • craft_ui::testing::frames::widest_layer: pub fn widest_layer(ctx: &Context) -> f32. The width of the widest layer above the background, 0 when there is none.

craft_ui::testing::index

The components index: every registered component type with its module and the purpose its derive recorded

  • craft_ui::testing::index::components_index: pub fn components_index(root: &Path, registered: &[&'static Registration]) -> String. The text of docs/components-index.md for the workspace at root and the types of registered.
  • craft_ui::testing::index::types_without_purpose: pub fn types_without_purpose(registered: &[&'static Registration]) -> Vec<String>. The types of registered that have no purpose: their types lack a doc comment.

craft_ui::testing::input

Key events and the egui input options, for trials that drive frames themselves.

  • craft_ui::testing::input::allow_zoom_keys: pub fn allow_zoom_keys(ctx: &Context). Gives egui back the option the runtime turns off at install: Cmd with = or - zooms the interface.
  • craft_ui::testing::input::key_press: pub fn key_press(key: Key, modifiers: Modifiers) -> Event. A key press event with modifiers.
  • craft_ui::testing::input::key_reached: pub fn key_reached(ctx: &Context, key: Key) -> bool. Whether a press of key is still in this pass's input: no component claimed it.
  • craft_ui::testing::input::key_repeat: pub fn key_repeat(key: Key, modifiers: Modifiers) -> Event. The auto-repeat event of a held key.
  • craft_ui::testing::input::slop: pub fn slop(ctx: &Context) -> f32. How far a press may move and still be a click, in points: the framework's slop.
  • craft_ui::testing::input::text: pub fn text(text: &str) -> Event. An event of typed text.

craft_ui::testing::layout

The layout services the trials check: bodies, measured blocks, the label column, measure_slot and

  • craft_ui::testing::layout::Block: pub struct Block. A placeholder child of a fixed size: a leaf that measures size, senses nothing and paints nothing.
    • pub const fn new(size: Vec2) -> Self. A child that takes size.
    • pub fn counted(mut self, measures: &Arc<AtomicUsize>) -> Self. Counts each call of its measure in measures.
  • craft_ui::testing::layout::BlockStyle: pub struct BlockStyle. The style of a Block: no padding.
  • craft_ui::testing::layout::allocate: pub fn allocate(ui: &mut Ui, size: Vec2) -> egui::Rect. Takes size in the layout of ui and returns its rect.
  • craft_ui::testing::layout::body: pub fn body(ui: &mut Ui, key: &'static str, layout: &BodyLayout, sizes: &[Vec2]) -> Vec<Rect>. Runs a body laid out by layout under key and places one child per entry of sizes in flow, as step 6
  • craft_ui::testing::layout::entry_id: pub fn entry_id(ui: &Ui, key: &'static str) -> Id. The id a keyed entry of this Ui lives under.
  • craft_ui::testing::layout::in_region: pub fn in_region<R>(ui: &mut Ui, rect: egui::Rect, body: impl FnOnce(&mut Ui) -> R) -> R. Runs body in a child Ui whose region is rect.
  • craft_ui::testing::layout::in_row_region: pub fn in_row_region<R>(ui: &mut Ui, rect: egui::Rect, body: impl FnOnce(&mut Ui) -> R) -> R. Runs body in a child Ui whose region is rect, laid out as a row with its items centred across.
  • craft_ui::testing::layout::is_animating: pub fn is_animating(ui: &Ui, key: &'static str) -> bool. Whether the tween under key is still running.
  • craft_ui::testing::layout::measured_block: pub fn measured_block(ui: &Ui, key: &'static str, real: Vec2) -> Option<Vec2>. A block that placed itself from key's entry of last pass and measured real this pass. Returns the size
  • craft_ui::testing::layout::peek_size: pub fn peek_size(ui: &Ui, key: &'static str) -> Option<Vec2>. The size under key without a placement using it.
  • craft_ui::testing::layout::read_size: pub fn read_size(ui: &Ui, key: &'static str) -> Option<Vec2>. The size under key as a placement reads it.
  • craft_ui::testing::layout::reordered_fonts: pub fn reordered_fonts() -> egui::FontDefinitions. The test font definitions in another order.
  • craft_ui::testing::layout::start_tween: pub fn start_tween(ui: &Ui, key: &'static str, from: Vec2, to: Vec2, duration: f64). Starts a size tween under key.
  • craft_ui::testing::layout::wrapped_text: pub fn wrapped_text(ui: &mut Ui, text: &str). Shows text wrapped to the available width of a sizing slot, for measure_slot trials.

craft_ui::testing::memory

The memory services the trials check: a stage fixture that implements Remember, eviction, forget and

  • craft_ui::testing::memory::Stage: pub struct Stage. A memory stage opened the way the pipeline opens one at step 3: the owner is registered, then the stage
    • pub fn open(ctx: &Context, base: Id) -> Self. A stage whose entries belong to base, which is registered as its own owner.
    • pub fn open_owned(ctx: &Context, base: Id, owner: Id) -> Self. A stage keyed by base whose entries belong to owner, registered here.
    • pub fn open_peek(ctx: &Context, base: Id) -> Self. The stage of a sizing pass: it reads kept values and writes nothing.
    • pub fn finish(self). Writes every slot back to context data.
  • craft_ui::testing::memory::dispose_evicted: pub fn dispose_evicted(ctx: &Context). Drops the slots the end hook evicted.
  • craft_ui::testing::memory::facts_of_last_pass: pub fn facts_of_last_pass<T: Clone + Send + Sync + 'static>(ctx: &Context) -> Vec<T>. The facts the running viewport's previous pass registered.
  • craft_ui::testing::memory::forget: pub fn forget(ctx: &Context, id: Id). Removes the session slots under id.
  • craft_ui::testing::memory::forget_saved: pub fn forget_saved(ctx: &Context, key: &SaveKey). Removes the saved slots of key.
  • craft_ui::testing::memory::global: pub fn global(name: &'static str, scope: impl Hash + Debug) -> Id. The id of a runtime singleton named name under scope.
  • craft_ui::testing::memory::put: pub fn put<T: std::any::Any + Clone + Send + Sync>(ctx: &Context, id: Id, value: T). Stores value in context data under id, as a slot's Drop may.
  • craft_ui::testing::memory::records_written: pub fn records_written(ctx: &Context) -> usize. How many slot records the stages' write-backs have written in ctx so far.
  • craft_ui::testing::memory::register_fact: pub fn register_fact<T: Clone + Send + Sync + 'static>(ctx: &Context, fact: T). Registers fact for the next pass of the running viewport.
  • craft_ui::testing::memory::scoped: pub fn scoped<R>(ui: &mut Ui, f: impl FnOnce(&mut Ui) -> R) -> R. Runs f on a child Ui of ui.
  • craft_ui::testing::memory::scoped_by: pub fn scoped_by<R>(ui: &mut Ui, salt: impl std::hash::Hash + std::fmt::Debug, f: impl FnOnce(&mut Ui) -> R) -> R. Runs f on a child Ui of ui with its own id scope named by salt.
  • craft_ui::testing::memory::sub: pub fn sub(base: Id, tag: impl Hash + Debug) -> Id. The runtime sub-id of base for tag.

craft_ui::testing::pictures

Sample content for stories in every crate: photos for tiles and previews, and the brush tips and strokes a

  • craft_ui::testing::pictures::SampleTip: pub enum SampleTip { Hard, Soft, Star, Sampled }. The shape of a sample brush tip.
  • craft_ui::testing::pictures::StoryPictures: pub struct StoryPictures. The photos of the stories in one context, keyed by a number: the same key shows the same picture everywhere.
    • pub fn of(ctx: &Context) -> Self. The pictures stored in ctx.
    • pub fn thumb(&self, key: u64) -> impl FnOnce(&ContentPainterCx, Rect) + 'static. A thumbnail painter that fills its rect with the photo of key, cropped to the rect's shape.
  • craft_ui::testing::pictures::TEST_CARD_SIZE: pub const TEST_CARD_SIZE: [usize; 2]. The size of [test_card] in pixels: 4:3.
  • craft_ui::testing::pictures::paint_contour: pub fn paint_contour(cx: &ContentPainterCx, rect: Rect, n: u32). Contour n across rect in the ink of the surface: a power curve for even n, a cosine wave for odd.
  • craft_ui::testing::pictures::paint_tip: pub fn paint_tip(cx: &ContentPainterCx, rect: Rect, tip: SampleTip, color: Color32). The tip of tip centred in rect, in color.
  • craft_ui::testing::pictures::paint_wave: pub fn paint_wave(cx: &ContentPainterCx, rect: Rect, width: f32, color: Color32). A stroke as one wave across rect, width as a share of the rect's height, in color.
  • craft_ui::testing::pictures::sample_picture: pub fn sample_picture(key: u64, [width, height]: [u32; 2]) -> ColorImage. The photo of key as an image size pixels wide and high: the picture [StoryPictures::thumb] paints.
  • craft_ui::testing::pictures::stamped_stroke: pub fn stamped_stroke(size: [usize; 2], samples: &[[f64; 3]], diameter: f64, color: Color32) -> ColorImage. A stroke size pixels wide and high: round dabs of diameter pixels times the pressure stamped along
  • craft_ui::testing::pictures::test_card: pub fn test_card() -> ColorImage. A 4:3 video test card: eight colour bars over the top two thirds, a black to white ramp under them.

craft_ui::testing::pointer

Pointer events and gestures for trials that drive frames themselves.

  • craft_ui::testing::pointer::cancel_captured_presses: pub fn cancel_captured_presses(ctx: &egui::Context). Asks the pointer service to end every captured press in the running pass, as Escape does. Call it from the
  • craft_ui::testing::pointer::click: pub fn click(frames: &mut Frames, at: Pos2, show: &mut impl FnMut(&mut Ui)). Hover in one frame, press in the next, release in the next, then one idle frame.
  • craft_ui::testing::pointer::drag: pub fn drag(frames: &mut Frames, from: Pos2, by: Vec2, show: &mut impl FnMut(&mut Ui)). Press at from, move to from + by in four steps over four frames, release.
  • craft_ui::testing::pointer::gone: pub fn gone() -> Event. The pointer leaving the window.
  • craft_ui::testing::pointer::middle: pub fn middle(pos: Pos2, pressed: bool) -> Event. The middle button going down or up at pos.
  • craft_ui::testing::pointer::moved: pub fn moved(pos: Pos2) -> Event. The pointer moving to pos.
  • craft_ui::testing::pointer::press: pub fn press(pos: Pos2) -> Event. The primary button going down at pos.
  • craft_ui::testing::pointer::press_captured: pub fn press_captured(ctx: &egui::Context) -> bool. Whether an open press holds the pointer in the running viewport, as Escape reads it.
  • craft_ui::testing::pointer::release: pub fn release(pos: Pos2) -> Event. The primary button going up at pos.
  • craft_ui::testing::pointer::secondary: pub fn secondary(pos: Pos2, pressed: bool) -> Event. The secondary button going down or up at pos.
  • craft_ui::testing::pointer::tap: pub fn tap(frames: &mut Frames, at: Pos2, gone_after: bool, show: &mut impl FnMut(&mut Ui)). A touchpad tap: hover in one frame, then press and release inside the next. gone adds the pointer
  • craft_ui::testing::pointer::wheel: pub fn wheel(dy: f32) -> Event. A vertical wheel event of dy points.
  • craft_ui::testing::pointer::wheel_lines: pub fn wheel_lines(dy: f32) -> Event. A mouse wheel turning dy lines at the pointer.
  • craft_ui::testing::pointer::window_blurred: pub fn window_blurred() -> Event. The window losing focus.
  • craft_ui::testing::pointer::zoom_wheel: pub fn zoom_wheel(dy: f32) -> Event. A vertical wheel event of dy points with Ctrl or Cmd held, which zooms.

craft_ui::testing::relations

Relation assertions between rects and lengths: the tests compare layouts to each other and to tokens, never to

  • craft_ui::testing::relations::above: pub fn above(a: Rect, b: Rect) -> bool. a ends above where b begins or earlier.
  • craft_ui::testing::relations::equals_token: pub fn equals_token(measured: f32, token: f32) -> bool. measured equals the token value token.
  • craft_ui::testing::relations::grows_with: pub fn grows_with(base: f32, grown: f32) -> bool. grown is at least base along one axis: a measure under a larger text size grows or stays.
  • craft_ui::testing::relations::inside: pub fn inside(inner: Rect, outer: Rect) -> bool. inner lies within outer.
  • craft_ui::testing::relations::left_of: pub fn left_of(a: Rect, b: Rect) -> bool. a ends where b begins or earlier.
  • craft_ui::testing::relations::mirrored: pub fn mirrored(left_to_right: Rect, right_to_left: Rect, within: Rect) -> bool. right_to_left is left_to_right reflected across the vertical middle of within, with the same size and height.
  • craft_ui::testing::relations::same_height: pub fn same_height(a: Rect, b: Rect) -> bool. a and b are equally tall.

craft_ui::testing::sensing

Probe components for the sensing core: roots, members and parts described as data, shown through the same

  • craft_ui::testing::sensing::PartReport: pub struct PartReport { pub key: PartKey, pub index: Option<u64>, pub press: PressState, pub hovered: bool }. What one part read this pass.
  • craft_ui::testing::sensing::ProbeMember: pub struct ProbeMember. A member of a probe arena, or a body child that is a root of its own in a probe that is no arena.
    • pub fn new(name: &'static str, rect: Rect, sense: Sense) -> Self. A member named name over rect sensing sense.
    • pub fn part(mut self, part: ProbePart) -> Self. Adds a part.
  • craft_ui::testing::sensing::ProbePart: pub struct ProbePart. A part of a probe.
    • pub fn new(key: PartKey, rect: Rect, sense: Sense) -> Self. A part key over rect sensing sense.
    • pub fn level(mut self, level: HitLevel, sub: u8) -> Self. The part's tier among the shapes of its stack position.
    • pub fn over(mut self) -> Self. The part sits above the body members.
    • pub fn cursor(mut self, icon: CursorIcon) -> Self. The cursor the part asks for while hovered.
    • pub fn at(mut self, index: u64) -> Self. One of a repeated part.
  • craft_ui::testing::sensing::ProbeRoot: pub struct ProbeRoot. A root: a leaf component, or with arena an arena root whose members join it.
    • pub fn new(name: &'static str, rect: Rect, sense: Sense) -> Self. A root named name over rect sensing sense.
    • pub fn part(mut self, part: ProbePart) -> Self. Adds an own part.
    • pub fn member(mut self, member: ProbeMember) -> Self. Adds a body member.
    • pub fn arena(mut self) -> Self. Makes the root an arena: its members join it and have no egui widget.
    • pub fn transformed(mut self, transform: CanvasTransform) -> Self. Shows the body through transform on its own egui layer (an arena only).
    • pub fn blocker(mut self, size: Vec2) -> Self. Adds an allocating egui widget of size over the body, as app code may.
    • pub fn requests(mut self, cursor: impl Into<Cursor>, priority: CursorPriority) -> Self. A cursor the root requests while the pointer is over it, as a tool does.
    • pub fn disabled(mut self) -> Self. Turns the root disabled.
    • pub fn id(name: &'static str) -> Id. The id of the root named name.
    • pub fn transform_widget(name: &'static str) -> Id. The id of a transformed root's forwarding widget.
  • craft_ui::testing::sensing::RootReport: pub struct RootReport { pub root: SenseReport, pub activated_member: Option<Id>, pub members: Vec<SenseReport>, pub body: Option<TSTransform> }. What a root and its members read this pass.
    • pub fn to_screen(&self, local: Pos2) -> Pos2. Where a point of the body appears on screen.
    • pub fn member(&self, name: &'static str) -> Option<&SenseReport>. The report of the member named name.
  • craft_ui::testing::sensing::SenseReport: pub struct SenseReport { pub id: Id, pub press: PressState, pub parts: Vec<PartReport>, pub activated: bool, pub clicked: bool, pub hovered: bool }. What a member, or a root's own shape and parts, read this pass.
    • pub fn phase(&self, key: PartKey) -> PressPhase. The press phase of the part key, Idle when the part is unknown.
  • craft_ui::testing::sensing::cover: pub fn cover(ctx: &Context, size: Vec2). Shows an egui area of size over everything else, as a popup does.
  • craft_ui::testing::sensing::egui_click_target: pub fn egui_click_target(ctx: &Context) -> Option<Id>. The widget id egui's hit test chose as the click target at the latest pointer position.
  • craft_ui::testing::sensing::press_focus: pub fn press_focus(ctx: &Context, at: Pos2) -> Option<PressFocus>. How the focus service classifies a press at at, from last pass's shape record and egui's hit test at the
  • craft_ui::testing::sensing::show: pub fn show(ui: &mut Ui, roots: &[ProbeRoot]) -> Vec<RootReport>. Shows roots in order on ui, each through the sensing core, and reads back what each saw.

craft_ui::testing::snapshot

Stories rendered to images offscreen: egui's wgpu test renderer over what Frames recorded with

  • craft_ui::testing::snapshot::Renderer: pub struct Renderer. A wgpu device and egui renderer that renders one context's frames after another's.
    • pub fn new() -> Self. A renderer on the preferred adapter.
    • pub fn render(&mut self, ctx: &Context, mut paint: FullOutput) -> Result<RgbaImage, String>. The image of paint (from Frames::take_paint) at the context's pixels per point,
    • pub fn finish(&mut self). Frees the textures of the context rendered last, before the renderer takes another context's frames.
  • craft_ui::testing::snapshot::layer_rects: pub fn layer_rects(ctx: &Context) -> Vec<Rect>. The screen rects the layers shown last frame and not fading out paint in: popups, dialogs, windows shown as layers,
  • craft_ui::testing::snapshot::modal_open: pub fn modal_open(ctx: &Context) -> bool. Whether a layer shown last frame and not fading out is modal (a dialog over the window).
  • craft_ui::testing::snapshot::RgbaImage: re-export of image::RgbaImage (outside these crates).

craft_ui::testing::story

Stories: named ways to show one registered type, and the data and output the runner reads from them.

  • craft_ui::testing::story::CollectionKind: pub enum CollectionKind { Selection, LeadMoved, Activate, EmptyActivated, Preview, ContextMenu, CommandClick, Delete, Open, Reorder(EditKind), Move(EditKind), Dropped, Zoom, Rename(EditKind), Toggle(EditKind), Column, Item }. The kind of a collection event, with the edit kind of the events that carry one.
    • pub fn of<K, E>(event: &CollectionEvent<K, E>) -> Option<CollectionKind>. The kind of event, None for an edit event of a kind the runner does not know.
  • craft_ui::testing::story::Drive: pub enum Drive { Auto, Activate, Step, Drag(Grip), DragChild(Grip), Type(&'static str), Pick { row: usize }, Custom(fn(&mut Fixture)), Never }. How the runner changes the value a story shows.
  • craft_ui::testing::story::EditKind: pub enum EditKind { Begin, Update, Commit, Cancel, Set }. The kind of an edit event.
    • pub fn of<T>(event: &EditEvent<T>) -> Option<EditKind>. The kind of event.
  • craft_ui::testing::story::Grip: pub struct Grip { pub part: PartRef, pub toward: Vec2 }. The part a [Drive::Drag] or [Drive::DragChild] presses and the way the drag moves it.
    • pub const fn new(key: PartKey) -> Self. The part key, a part that occurs once, dragged along x.
    • pub const fn part(part: PartRef) -> Self. The part part, one of a repeated part (HANDLE.at(i)), dragged along x.
    • pub const fn toward(mut self, toward: Vec2) -> Self. The grip dragged along toward.
  • craft_ui::testing::story::Required: pub enum Required { Default, Mixed, Invalid, LongText, Open, Empty, One, Many }. A state a registered type must show in some story.
  • craft_ui::testing::story::Story: pub struct Story { pub name: &'static str, pub covers: &'static [Required], pub show: fn(&mut Ui, &mut StoryData) -> StoryOutput, pub drive: Drive, pub disabled_text: Option<&'static str>, pub title: Option<&'static str>, pub group: Option<&'static str> }. A named way to show one registered type.
    • pub const fn new(name: &'static str, show: fn(&mut Ui, &mut StoryData) -> StoryOutput) -> Self. A story that shows with show.
    • pub const fn title(mut self, title: &'static str) -> Self. The caption a viewer shows over the story.
    • pub const fn group(mut self, group: &'static str) -> Self. The group a viewer shows the story in.
    • pub fn group_name(&self, type_name: &str) -> String. The name of the story's group as a story of the type whose display name is type_name: its group, else its
    • pub fn caption(&self, type_name: &str) -> String. The story's caption as a story of the type whose display name is type_name: its title, else the one its
    • pub const fn covers(mut self, covers: &'static [Required]) -> Self. The states the story shows.
    • pub const fn disabled_text(mut self, text: &'static str) -> Self. The reason the story's control shows while disabled. The story gives its tooltip this text through
    • pub const fn drive(mut self, drive: Drive) -> Self. The drive the story names.
  • craft_ui::testing::story::StoryData: pub struct StoryData { pub values: HashMap<(&'static str, TypeId), Box<dyn Shown>>, pub how: HashMap<(&'static str, TypeId), Edit> }. The values a story shows, by name. Each is a Value, so the runner compares them before and after a drive.
    • pub fn tooltip(&self, text: &'static str) -> TooltipSpec. A tooltip of text, with the story's disabled_text as the text it shows while disabled.
    • pub fn value<T: Value>(&mut self, name: &'static str, init: T) -> &mut T. The value named name of type T, created from init on first use. A name used with two types names two
    • pub fn present<T: Value>(&mut self, name: &'static str) -> Option<&mut T>. The value named name of type T when a run has created it; never creates one, so asking does not make a
    • pub fn note<T: Any>(&mut self, name: &'static str, init: T) -> &mut T. The note named name of type T, created from init on first use: what the story keeps about what happened in
    • pub fn ranged<T: Value>(&mut self, name: &'static str, init: T, range: RangeInclusive<f64>) -> &mut T. Like [StoryData::value] for a number the Properties editor keeps inside range.
    • pub fn choice<T: Value>(&mut self, name: &'static str, init: T, options: &[(&'static str, T)]) -> &mut T. Like [StoryData::value] for a value that is one of options, which the Properties editor offers by label.
    • pub fn restore(&mut self, before: &StorySnapshot). Puts every value that was there in before back to what it was then. A value added since stays.
    • pub fn changed_since(&self, before: &StorySnapshot) -> Vec<&'static str>. The names of the values that differ from before; a value added since counts as changed.
    • pub fn snapshot(&self) -> StorySnapshot. A copy of every value.
  • craft_ui::testing::story::StoryOutput: pub struct StoryOutput { pub id: Option<Id>, pub edits: Vec<EditKind>, pub clicked: bool, pub collection: Vec<CollectionKind>, pub visible: Option<Range<usize>>, pub value_text: Option<String>, pub readout: Option<String> }. What a story showed, type-erased: the response id, the kinds of its edit events and of its collection events.
    • pub fn readout(mut self, text: impl Into<String>) -> Self. The same output with text as its readout.
  • craft_ui::testing::story::StorySnapshot: pub struct StorySnapshot. The values of a [StoryData] at one moment.
  • craft_ui::testing::story::show_as_only_item: pub fn show_as_only_item<C>(ui: &mut Ui, row: C) -> C::Output where C: crate::contract::Component + crate::contract::Props + crate::contract::Show,. Shows row as the only item of a collection: the item step gives an item its id and its place in the set, which

craft_ui::testing::style

Style and paint helpers: token sets, a StyleCx, the style cache and a Draw over a frame.

  • craft_ui::testing::style::Recorded: pub struct Recorded { pub elided: Option<String>, pub baseline: Option<f32> }. What Draw recorded in one frame.
  • craft_ui::testing::style::StyleLooks: pub struct StyleLooks { pub variants: &'static [craft_theme::Variant], pub surface: Option<crate::style::SurfaceLook>, pub focus: Option<crate::style::FocusLook>, pub texts: Vec<crate::style::TextLook>, pub icons: Vec<crate::style::IconLook> }. A resolved style as the style cases read it: the variants its type lists and the looks that state colours
    • pub fn same_as(&self, other: &StyleLooks) -> bool. Whether other is the same style, in every field.
  • craft_ui::testing::style::StyleSeen: pub struct StyleSeen { pub type_name: &'static str, pub variant: craft_theme::Variant, pub size: ControlSize, pub looks: StyleLooks }. A style the pipeline resolved for a component run: what it looked like in the env it was resolved in, and how to
    • pub fn resolve_in(&self, cx: &crate::style::StyleCx<'_>) -> StyleLooks. The style of the same component, from the same style key, under another style context.
  • craft_ui::testing::style::env_key: pub fn env_key(tokens: &UiTokens) -> EnvKey. The EnvKey of tokens in a left-to-right Linux window at scale 1 with no style-affecting app values.
  • craft_ui::testing::style::face_id: pub fn face_id(composite: &str, part: craft_behavior::PartRef) -> egui::Id. The base id of the face painted for part of the composite id.
  • craft_ui::testing::style::paint_frame: pub fn paint_frame(frames: &mut Frames, tokens: &UiTokens, direction: Direction, ink: Ink, mut paint: impl FnMut(&Draw<'_>),) -> (Vec<Shape>, Recorded). Runs one frame in which paint draws through a Draw over the root Ui's painter, in direction and on
  • craft_ui::testing::style::root_token_entries: pub fn root_token_entries(ctx: &Context) -> usize. How many root-token entries the root env cache of ctx holds.
  • craft_ui::testing::style::style_of: pub fn style_of<K: StyleKey, S: ComponentStyle>(ctx: &Context, cx: &StyleCx<'_>, key: K, default: for<'a> fn(&StyleCx<'a>, K) -> S) -> Arc<S>. The cached style for key in cx, built by default on a miss.
  • craft_ui::testing::style::themes_at: pub fn themes_at(contrast: Contrast) -> Vec<(String, UiTokens)>. Every built-in theme in each mode it has, at contrast, as (<theme>.<mode>, tokens). Built once per thread and
  • craft_ui::testing::style::tokens: pub fn tokens(mode: Mode, contrast: Contrast) -> UiTokens. The suite's default built-in theme resolved for mode and contrast.
  • craft_ui::testing::style::tokens_named: pub fn tokens_named(name: &str, mode: Mode, contrast: Contrast) -> UiTokens. The built-in theme craft.<name> resolved for mode and contrast. The built-ins are static, so each set is
  • craft_ui::testing::style::with_cx: pub fn with_cx<R>(ctx: &Context, tokens: &UiTokens, variant: Variant, size: ControlSize, f: impl FnOnce(&StyleCx<'_>) -> R) -> R. Runs f with a StyleCx over tokens in a left-to-right Linux window at scale 1.

craft_ui::testing::suite

The suite runner: one trial per registered type and group of cases, running the group's shared cases over the

  • craft_ui::testing::suite::trials: pub fn trials(package: &'static str, registered: &[&'static Registration]) -> Vec<Trial>. The trials of one package: a trial per registered type and group of cases, suite::<type>::<group>; the same for
  • craft_ui::testing::suite::measure_pure_case: pub fn measure_pure_case(probe: &Probe, story: &Story) -> Result<(), String>. The measure-pure case over one story of the type probe describes: settled and then driven by each way of its
  • craft_ui::testing::suite::reflowed: pub fn reflowed(base: &[(&str, Rect)], grown: &[(&str, Rect)]) -> bool. Whether the layout reflowed from base to grown: two texts lie beside each other in base and one above the
  • craft_ui::testing::suite::required_states: pub fn required_states(probe: &Probe) -> Vec<Required>. The states a registered type must show, from the facts of its probe, less the states it is exempt from.
  • craft_ui::testing::suite::rtl_case: pub fn rtl_case(story: &Story) -> Result<(), String>. The suite's right-to-left case for one story.
  • craft_ui::testing::suite::text_size_case: pub fn text_size_case(story: &Story) -> Result<(), String>. The suite's text-size case for one story: under a larger text size, either density and scale 2 the story grows
  • craft_ui::testing::suite::title_case: pub fn title_case(story: &Story) -> Result<(), String>. The title case for one story.
  • craft_ui::testing::suite::values_case: pub fn values_case(probe: &Probe, story: &Story) -> Result<Vec<&'static str>, String>. The values case over one story of the type probe describes: each way of the story's drive runs in its own

craft_ui::testing::surface

The egui behaviours the runtime relies on, as scenarios on a bare egui context: the egui_surface trials

  • craft_ui::testing::surface::HookFacts: pub struct HookFacts { pub child_input_hooks: usize, pub input_hooks_see_parent: bool, pub child_begin_hooks: usize }. What the plugin hooks of one context saw around a nested immediate viewport.
  • craft_ui::testing::surface::LayerOrder: re-export of craft_ui::runtime::egui::areas::LayerOrder.
  • craft_ui::testing::surface::PassFacts: pub struct PassFacts { pub events: usize, pub frame: u64, pub pass: u64 }. What a pass saw of one frame that discarded its first pass.
  • craft_ui::testing::surface::PressHits: pub struct PressHits { pub press_last_is_press_target: bool, pub move_last_is_move_target: bool }. The widget ViewportState::hits names for a press, by the order of the frame's pointer events.
  • craft_ui::testing::surface::child_viewport_hooks: pub fn child_viewport_hooks() -> HookFacts. Two frames of a root viewport that shows an immediate child viewport, with a recording plugin on the context.
  • craft_ui::testing::surface::discard_passes: pub fn discard_passes() -> Vec<PassFacts>. One frame with a key event whose first pass asks for a discard.
  • craft_ui::testing::surface::focus_survives_escape: pub fn focus_survives_escape(keep: bool) -> bool. Whether a widget that took focus with request_focus_with_filter still holds it after a bare Escape: keep
  • craft_ui::testing::surface::layer_order: re-export of craft_ui::runtime::egui::areas::layer_order.
  • craft_ui::testing::surface::preset_style_direction: pub fn preset_style_direction(ctx: &Context, right_to_left: bool). Writes the direction into the context's styles before any pass, as an egui backend that derives it from the
  • craft_ui::testing::surface::press_hits: pub fn press_hits() -> PressHits. Three frames over two click widgets: one to register them, then the two event orders.
  • craft_ui::testing::surface::registered_parent_owns_member_node: pub fn registered_parent_owns_member_node() -> bool. Whether a member that registered no egui widget, given register_accesskit_parent, has its node among the

craft_ui::testing::text

Reading text parts in trials: the widget id, the caret and the text a frame painted.

  • craft_ui::testing::text::caret: pub fn caret(ctx: &Context, widget: Id) -> Option<usize>. The caret of a text widget as a character index.
  • craft_ui::testing::text::editor_widget_id: pub fn editor_widget_id(id: Id, key: PartKey) -> Id. The egui widget id of the editor part key of component id.
  • craft_ui::testing::text::painted: pub fn painted(shapes: &[Shape]) -> Vec<String>. The texts of the text shapes among shapes.
  • craft_ui::testing::text::run_end: pub fn run_end(owner: Id, runs: &[(usize, std::ops::Range<usize>, &str)], pos: craft_behavior::TextPos) -> Option<(Id, usize)>. The run node and character index a position maps to among runs given as (line, bytes, text).
  • craft_ui::testing::text::run_node: pub fn run_node(owner: Id, line: usize, run: usize) -> Id. The id of the run node run of line line below the text component owner.
  • craft_ui::testing::text::widget_id: pub fn widget_id(id: Id, key: PartKey) -> Id. The egui widget id of the text part key of component id.
  • craft_ui::testing::text::ImeSeen: pub struct ImeSeen { pub owner: egui::Id, pub interrupt: bool, pub caret: Rect }. The IME output of a frame: the owner widget, whether it asks the OS to interrupt a composition, the caret rect.
  • craft_ui::testing::text::ime_preedit: pub fn ime_preedit(text: &str) -> Event. An IME preedit event of text with no cursor range.
  • craft_ui::testing::text::set_value_request: pub fn set_value_request(target: egui::Id, text: &str) -> Event. An AccessKit SetValue request carrying text for the node of target.
  • craft_ui::testing::text::text_selection_request: pub fn text_selection_request(target: egui::Id, anchor:(egui::Id, usize), focus:(egui::Id, usize)) -> Event. An AccessKit SetTextSelection request for the node of target, from character anchor.1 of the run node

craft_ui::testing::wheel

The wheel service from a trial's side: registering takers and reading their shares.

  • craft_ui::testing::wheel::focus: pub fn focus(ctx: &Context, id: Id). Gives key focus to the widget id.
  • craft_ui::testing::wheel::nearest_scroll_owner: pub fn nearest_scroll_owner(ctx: &Context, rect: egui::Rect) -> Option<Id>. The taker of last pass a reveal of rect goes to outside every declared scroll owner: the innermost scroll region
  • craft_ui::testing::wheel::register: pub fn register(ctx: &Context, taker: WheelTaker<Id>). Registers taker for the next pass's split.
  • craft_ui::testing::wheel::take: pub fn take(ctx: &Context, id: Id) -> Option<Vec2>. The scroll id takes this pass, if it has a share.
  • craft_ui::testing::wheel::take_share: pub fn take_share(ctx: &Context, id: Id) -> Option<craft_behavior::Wheel>. The whole share id takes this pass: scroll, zoom and the pointer a zoom is about.

craft_ui::testing::windows

The window host's fixtures: install inputs that open no OS windows, and the scripted system.

  • craft_ui::testing::windows::applied_actions: pub fn applied_actions(ctx: &egui::Context) -> Vec<(egui::ViewportId, crate::runtime::windows::WindowAction)>. The window actions the platform applies out of reach of egui's commands (SetOpacity) since the last call.
  • craft_ui::testing::windows::begin_window_drag: pub fn begin_window_drag(ctx: &egui::Context, source: egui::Id). Starts the drag of the window container source (what the title row of a dock window does), with the pointer
  • craft_ui::testing::windows::install_spec: pub fn install_spec() -> InstallSpec. An install spec for the running build's shell and a system with no OS services.
  • craft_ui::testing::windows::keeps_app_drag: pub fn keeps_app_drag(ctx: &egui::Context, viewport: egui::ViewportId) -> bool. Whether the window of viewport has a component that runs its own drag from the window's move band.
  • craft_ui::testing::windows::show_drop_mark: pub fn show_drop_mark(ctx: &egui::Context, over: Option<egui::Rect>). Shows (or removes) the mark of a drop target in another window over the running drag.
  • craft_ui::testing::windows::FakeSystem: re-export of craft_window::system::FakeSystem (outside these crates).
  • craft_ui::testing::windows::FullOutput: re-export of craft_ui::runtime::egui::fixture::FullOutput (defined outside these crates).
  • craft_ui::testing::windows::NoWindows: re-export of craft_window::system::NoWindows (outside these crates).
  • craft_ui::testing::windows::RawInput: re-export of craft_ui::runtime::egui::fixture::RawInput (defined outside these crates).
  • craft_ui::testing::windows::dragged_id: pub fn dragged_id(ctx: &Context) -> Option<egui::Id>. The id of the widget egui is dragging.
  • craft_ui::testing::windows::record_input_hooks: pub fn record_input_hooks(ctx: &Context, log: std::sync::Arc<std::sync::Mutex<Vec<(egui::ViewportId, egui::ViewportId)>>>). Adds a plugin to ctx that records, for each input hook call, the viewport of the raw input and the