API reference

aster_ui crate root

Pre-1.0: signatures are not frozen. Generated from rustdoc JSON of the compiled crate; rustdoc JSON format version 60. Only public items are listed.

Structs

structaster_ui::AffineSceneLimits

pub struct AffineSceneLimits { /* see fields */ }

Public fields

fieldtype
nodesusizeMaximum scene slot capacity, including currently empty admitted slots.
source_pixelsusizeMaximum private source area; two RGBA8 renderer planes are separate.
source_commandsusize
retained_bytesusizeSum of retained raster image payload lengths, not all heap metadata.
mask_bytesusizeSum of full-output u16 sample-mask payloads.
vectorsOption<VectorLimits>
samplingImageSamplingExplicit raster isolation; no analytic transformed glyph/path claim.

Trait implementations: Clone, Copy, Debug

structaster_ui::AnimationSample

pub struct AnimationSample { /* see fields */ }

One deterministic sample of a bounds track.

Public fields

fieldtype
boundssuper::LogicalRect
statusAnimationStatus

Trait implementations: Clone, Copy, Debug, PartialEq, StructuralPartialEq

structaster_ui::ApplyOutcome

pub struct ApplyOutcome { /* see fields */ }

Result of applying a sampled track to a bound node.

Public fields

fieldtype
changedboolTrue when the target description actually changed.
boundssuper::LogicalRect
statusAnimationStatus

Trait implementations: Clone, Copy, Debug, PartialEq, StructuralPartialEq

structaster_ui::BoundsAnimation

pub struct BoundsAnimation { /* see fields */ }

Immutable, deterministic bounds track.

Methods

  • fn builder(duration: f64, repeat: RepeatPolicy, reduced_motion: ReducedMotion, capacity: usize) -> Result<BoundsAnimationBuilder, Error> — Begin a bounded track with an explicit duration, repeat policy and reduced-motion policy.
  • fn duration(&self) -> f64
  • fn repeat(&self) -> RepeatPolicy
  • fn reduced_motion(&self) -> ReducedMotion
  • fn total_duration(&self) -> f64 — Total elapsed time covered by the track, including repeats.
  • fn keyframe_count(&self) -> usize
  • fn final_bounds(&self) -> LogicalRect — The bounds presented at the end of the track.
  • fn status(&self, elapsed_seconds: f64) -> Result<AnimationStatus, Error> — Completion status at the supplied elapsed time. A zero-duration track is complete at every elapsed time.
  • fn sample(&self, elapsed_seconds: f64, reduced_motion_active: bool) -> Result<AnimationSample, Error> — Sample the track at host-supplied elapsed seconds.

structaster_ui::BoundsAnimationBuilder

pub struct BoundsAnimationBuilder { /* see fields */ }

Bounded builder for an immutable bounds track.

Keyframes may be supplied in any order; they are sorted by time when the track is finished. Duplicate times are rejected, so the authored value at any instant is unique.

Methods

  • fn capacity(&self) -> usize — Declared maximum keyframe count of this track.
  • fn keyframe_count(&self) -> usize
  • fn push(&mut self, keyframe: BoundsKeyframe) -> Result<(), Error> — Append one keyframe. The time must lie inside the declared duration, and duplicate times are rejected.
  • fn keyframe(&mut self, time: f64, bounds: LogicalRect, easing: Easing) -> Result<(), Error> — Convenience form of [Self::push].
  • fn finish(self) -> Result<BoundsAnimation, Error>

structaster_ui::BoundsKeyframe

pub struct BoundsKeyframe { /* see fields */ }

One authored keyframe: an elapsed time in seconds and the bounds at it.

Methods

  • fn new(time: f64, bounds: LogicalRect, easing: Easing) -> Result<Self, Error> — time is elapsed seconds from the start of the track and must be finite and nonnegative. Ordering and duplication rules are enforced by the track builder.
  • fn time(&self) -> f64
  • fn bounds(&self) -> LogicalRect
  • fn easing(&self) -> Easing

Trait implementations: Clone, Copy, Debug, PartialEq, StructuralPartialEq

structaster_ui::CapturedPointer

pub struct CapturedPointer { /* see fields */ }

Public fields

fieldtype
pointerPointerId
targetInteractionTarget

Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq

structaster_ui::DevicePoint

pub struct DevicePoint(..)

Finite physical-pixel coordinates supplied by an output's host adapter.

Methods

  • fn new(x: f64, y: f64) -> Result<Self, Error>
  • fn components(self) -> [f64; 2]

Trait implementations: Clone, Copy, Debug, PartialEq, StructuralPartialEq

structaster_ui::DispatchReport

pub struct DispatchReport { /* see fields */ }

Result of one dispatch pass.

Public fields

fieldtype
eventsusizeEvents taken from the queue.
callbacksusizePlugin callbacks invoked.
failuresusizePlugin callbacks that reported an error during this pass.
last_failureOption<PluginFailure>The most recent plugin failure observed by this bus.
pendingusizeEvents still queued after this pass.
rejected_totalu64Lifetime count of queue-capacity refusals, excluding frame-policy refusals.

Trait implementations: Clone, Copy, Debug, Default, Eq, PartialEq, StructuralPartialEq

structaster_ui::DocumentChange

pub struct DocumentChange { /* see fields */ }

Public fields

fieldtype
kindTextChangeKind
revisionDocumentRevision
previous_sourceSourceStamp
sourceSourceStamp
replacedTextRangeOld-source replacement range; meaningful for Text changes only.
inserted_bytesusize
selectionTextSelection

Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq

structaster_ui::DocumentRevision

pub struct DocumentRevision { /* see fields */ }

Full editor state, including selection and composition. Queued commands must match it.

Methods

  • fn revision(self) -> u64

Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq

structaster_ui::Edit

pub struct Edit<'a> { /* see fields */ }

A failed operation poisons the complete candidate. Dropping aborts it. IDs issued by aborted edits stay distinct from all future insertions.

Methods

  • fn set_group_opacity(&mut self, id: NodeId, opacity: f64) -> Result<bool, Error> — Publishes subtree appearance with the scene transaction, independently of measurement. Rendering must isolate the whole subtree before fading.
  • fn set_group_isolation(&mut self, id: NodeId, isolation: GroupIsolation) -> Result<bool, Error> — Keep or release an explicit isolation boundary without changing layout. Common clipping occurs once after this node's complete subtree paints.
  • fn set_paint_transform(&mut self, id: NodeId, transform: Option<PaintTransform>) -> Result<bool, Error> — Transform policy publishes with the edit and inherits through children. Identity descriptors normalize to None, independently of pivot choice.
  • fn set_layout(&mut self, id: NodeId, style: Option<LayoutStyle>) -> Result<bool, Error> — None leaves a node absolute, outside its parent's content arrangement.
  • fn arrange(&mut self, viewport: LogicalRect, measure: impl FnMut(NodeId, LayoutConstraints) -> Result<LayoutSize, Error>) -> Result<LayoutReport, Error> — Measure outside paint, then arrange managed nodes. The callback must be deterministic for this edit's source/assets and constraints. Output is provisional until commit; failures poison the edit, preserving acceptance. At most 32 passes resolve width-sensitive content feedback.
  • fn insert(&mut self, parent: Option<NodeId>, description: NodeDescription) -> Result<NodeId, Error>
  • fn set(&mut self, id: NodeId, description: NodeDescription) -> Result<bool, Error>
  • fn set_bounds(&mut self, id: NodeId, bounds: LogicalRect) -> Result<bool, Error>
  • fn move_to(&mut self, id: NodeId, parent: Option<NodeId>) -> Result<bool, Error>
  • fn move_before(&mut self, id: NodeId, before: NodeId) -> Result<bool, Error>
  • fn remove(&mut self, id: NodeId) -> Result<usize, Error>
  • fn commit(self) -> Result<SceneStamp, Error>
  • fn commit_for_renderer(self, renderer: &mut Renderer) -> Result<SceneStamp, Error> — Admit the candidate against the supplied renderer before accepting it.

structaster_ui::EventBus

pub struct EventBus { /* see fields */ }

The owner-thread event bus.

The bus owns the plugin set, the bounded queue and the accepted frame clock. It is neither Send nor Sync: plugins and dispatch stay on the thread that built it.

Methods

  • fn builder(limits: EventLimits) -> Result<EventBusBuilder, Error> — Start a registration builder with explicit limits.
  • fn plugin_count(&self) -> usize — Number of registered plugins.
  • fn pending(&self) -> usize — Number of events currently queued.
  • fn failure_count(&self) -> u64 — Cumulative plugin failures observed by this bus.
  • fn is_closed(&self) -> bool — True once shutdown has begun.
  • fn last_failure(&self) -> Option<PluginFailure> — The most recent plugin failure observed by this bus.
  • fn is_enabled(&self, handle: PluginHandle) -> Result<bool, Error> — True while the plugin is registered and enabled.
  • fn removal_failure(&self, handle: PluginHandle) -> Result<Option<PluginFailure>, Error> — A latched cleanup failure, if the plugin's removal failed.
  • fn clear_removal_failure(&mut self, handle: PluginHandle) -> Result<(), Error> — Clear a latched cleanup failure after the host inspected the side effects. The plugin stays disabled.
  • fn schedule_frame(&mut self, elapsed_ns: u64) -> Result<FrameEvent, Error> — Accept a host frame time and publish the matching frame event.
  • fn emit_frame(&mut self, frame: FrameEvent) -> Result<(), Error> — Publish an explicit frame event.
  • fn emit_extension(&mut self, kind: ExtensionKind, payload: [u64; 4]) -> Result<(), Error> — Publish an application extension event.
  • fn dispatch(&mut self, budget: usize) -> DispatchReport — Deliver queued events, bounded by an explicit event budget.
  • fn set_enabled(&mut self, handle: PluginHandle, enabled: bool) -> Result<(), Error> — Enable or disable a registered plugin.
  • fn remove(&mut self, handle: PluginHandle) -> Result<(), Error> — Retire a plugin permanently.
  • fn shutdown(&mut self) -> Result<(), Error> — Close the bus and retire every plugin in reverse registration order.

structaster_ui::EventBusBuilder

pub struct EventBusBuilder { /* see fields */ }

Registration phase of an event bus.

Registration is a setup phase: the bus freezes its subscriptions when it is built, exactly like the backend bus it adapts.

Methods

  • fn new(limits: EventLimits) -> Result<Self, Error> — Start a builder with explicit limits.
  • fn register<P: Plugin + 'static>(&mut self, plugin: P, interests: &[EventKind], priority: i32) -> Result<PluginHandle, Error> — Register a plugin with its subscriptions and delivery priority.
  • fn plugin_count(&self) -> usize — Number of plugins registered so far.
  • fn listener_count(&self) -> usize — Number of subscriptions registered so far.
  • fn build(self) -> EventBus — Freeze the registrations and start the bus.

structaster_ui::EventEmitter

pub struct EventEmitter<'a> { /* see fields */ }

Bounded emitter handed to a plugin callback.

The emitter can only add events to the same bounded queue the bus uses. It never allocates: the queue storage is reserved when the bus is built and a full queue refuses the emission instead of growing.

Methods

  • fn emit_frame(&mut self, frame: FrameEvent) -> Result<(), EmitError> — Relay the most recently accepted host frame unchanged. A callback cannot author a new host timestamp, index or delta. Before any host frame has been accepted, no frame payload is valid here.
  • fn emit_extension(&mut self, kind: ExtensionKind, payload: [u64; 4]) -> Result<(), EmitError> — Publish an application extension event.
  • fn pending(&self) -> usize — Number of events currently queued.
  • fn failure_count(&self) -> u64 — Cumulative bus plugin failures observed before this callback.

structaster_ui::EventLimits

pub struct EventLimits { /* see fields */ }

Explicit capacity limits of one event bus.

Every limit is required: an unbounded queue, plugin set or listener set is not expressible.

Methods

  • const fn new(max_plugins: usize, max_listeners: usize, queue_capacity: usize) -> Result<Self, Error> — Build a limit set. Each limit must be at least one.
  • const fn max_plugins(self) -> usize — Maximum number of registered plugins.
  • const fn max_listeners(self) -> usize — Maximum number of plugin/kind subscriptions.
  • const fn queue_capacity(self) -> usize — Maximum number of queued events.

Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq

structaster_ui::EventReply

pub struct EventReply { /* see fields */ }

Replies affect this traversal only. Queue application changes for afterward.

Public fields

fieldtype
stop_propagationbool
prevent_defaultbool

Trait implementations: Clone, Copy, Debug, Default, Eq, PartialEq, StructuralPartialEq

structaster_ui::ExtensionKind

pub struct ExtensionKind(..)

An application-owned event kind.

The value space starts at [MIN_EXTENSION_KIND]. Kinds are plain numeric handles; the application owns their registry, exactly as the handoff requires. No raw internal event number is exposed to applications.

Methods

  • const fn new(raw: u64) -> Result<Self, Error> — Build an application kind. Values below [MIN_EXTENSION_KIND] are rejected instead of being silently remapped.
  • const fn raw(self) -> u64 — The numeric kind value.

Trait implementations: Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd, StructuralPartialEq

structaster_ui::FocusChange

pub struct FocusChange { /* see fields */ }

Public fields

fieldtype
previousOption<InteractionTarget>
currentOption<InteractionTarget>

Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq

structaster_ui::FontAsset

pub struct FontAsset { /* see fields */ }

One immutable, explicitly loaded default-location face. Owner-thread only. Family is a local alias; no filesystem/system-font lookup or substitution occurs.

Methods

  • fn from_opentype(bytes: Vec<u8>, collection_index: u32, family_alias: &str) -> Result<Self, Error>
  • fn id(&self) -> FontId
  • fn native_weight(&self) -> u16
  • fn native_slant(&self) -> FontSlant
  • fn metrics(&self, logical_size: f64) -> Result<FontMetrics, Error>

structaster_ui::FontId

pub struct FontId(..)

Trait implementations: Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd, StructuralPartialEq

structaster_ui::FontMetrics

pub struct FontMetrics { /* see fields */ }

Public fields

fieldtype
ascentf64
descentf64
line_gapf64
underline_positionf64
underline_thicknessf64

Trait implementations: Clone, Copy, Debug, PartialEq, StructuralPartialEq

structaster_ui::Frame

pub struct Frame<'a> { /* see fields */ }

Methods

  • fn info(&self) -> FrameInfo — Snapshot the produced identity without retaining or copying its pixels.
  • fn pixels(&self) -> &'a [u8]
  • fn output(&self) -> Output
  • fn stride_bytes(&self) -> usize
  • fn receipt(&self) -> FrameReceipt

structaster_ui::FrameEvent

pub struct FrameEvent { /* see fields */ }

A typed frame event.

The host owns the clock: elapsed_ns is host-supplied monotonic time and delta_ns is the difference to the previously accepted frame. index counts accepted frames.

Methods

  • const fn new(index: u64, elapsed_ns: u64, delta_ns: u64) -> Self — Build a frame event explicitly. Hosts normally use [EventBus::schedule_frame] so the index and delta are derived.
  • const fn index(self) -> u64 — Monotonic index of the accepted frame.
  • const fn elapsed_ns(self) -> u64 — Host-supplied elapsed time in nanoseconds.
  • const fn delta_ns(self) -> u64 — Elapsed time since the previously accepted frame, in nanoseconds.

Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq

structaster_ui::FrameInfo

pub struct FrameInfo { /* see fields */ }

Immutable identity and output description of a successfully produced frame.

Contains no pixel borrow and does not retain image storage. Only the renderer can mint its fields; copying it does not assert physical display submission. A host must acknowledge the exact frame it actually submitted.

use aster_ui::{FrameInfo, FrameReceipt, Output};
fn forge(output: Output, receipt: FrameReceipt) -> FrameInfo {
    FrameInfo { output, receipt }
}

Methods

  • fn output(self) -> Output
  • fn receipt(self) -> FrameReceipt

Trait implementations: Clone, Copy, Debug, PartialEq, StructuralPartialEq

structaster_ui::FrameReceipt

pub struct FrameReceipt { /* see fields */ }

Successful renderer production, distinct from physical-display presentation.

For CPU frames this records completed rasterization. An external renderer records successful staging reported by its trusted backend, which may represent command encoding rather than completed GPU execution. A receipt does not prove host submission, device completion or scanout.

Methods

  • fn output(self) -> OutputId
  • fn revision(self) -> u64
  • fn frame_index(self) -> u64
  • fn source(self) -> FrameSource
  • fn recording(self) -> Option<RecordingId>
  • fn content_revision(self) -> u64 — Changes only after successful raster publication, not unchanged reuse.

Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq

structaster_ui::GlyphMaskCache

pub struct GlyphMaskCache { /* see fields */ }

A bounded cache of rasterised glyph masks, shared by the labels of one owner thread.

Rasterising an outline is the expensive half of preparing a label, and a screen has many labels of the same face and size: with a cache the outline of a glyph is rasterised once per (face, glyph, device size, phase, policy) and every label that uses that glyph shares the result.

The cache holds masks only. A hit returns exactly the bytes the rasteriser produced for that key, so a label prepared through the cache draws the same pixels as one prepared without it. The cache never hands out an identity of its own and never changes what a drawing owns: a drawing still owns its masks (shared with the cache, never mutated).

The cache is bounded by the number of masks and by their bytes; the oldest quarter is dropped when a bound is reached, so a long-lived owner thread cannot grow it without limit.

Methods

  • fn new(maximum_masks: usize, maximum_bytes: usize) -> Result<Self, Error> — An empty cache that holds at most maximum_masks masks of at most maximum_bytes mask pixels in all.
  • fn len(&self) -> usize — The masks the cache holds.
  • fn is_empty(&self) -> bool — Whether the cache holds no mask.
  • fn hits(&self) -> u64 — The masks that were served from the cache.
  • fn misses(&self) -> u64 — The masks that had to be rasterised.
  • fn bytes(&self) -> usize — The mask pixels the cache holds.
  • fn clear(&mut self) — Drop every mask. The cache stays usable.

structaster_ui::HitTarget

pub struct HitTarget { /* see fields */ }

Methods

  • fn node(self) -> NodeId
  • fn model_key(self) -> Option<ModelKey>
  • fn local_position(self) -> [f64; 2]

Trait implementations: Clone, Copy, Debug, PartialEq, StructuralPartialEq

structaster_ui::ImageDescriptor

pub struct ImageDescriptor { /* see fields */ }

Methods

  • fn rgba8_srgb(width: u32, height: u32, stride_bytes: usize, alpha: ImageAlpha, origin: ImageOrigin) -> Result<Self, Error> — RGBA8 sRGB. Stride is explicit, including any row padding; no sentinel.
  • fn dimensions(self) -> [u32; 2]
  • fn stride_bytes(self) -> usize
  • fn storage_bytes(self) -> usize — Last row requires only its active pixels, not trailing padding.
  • fn alpha(self) -> ImageAlpha
  • fn origin(self) -> ImageOrigin

Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq

structaster_ui::ImageId

pub struct ImageId(..)

Methods

  • const fn as_u64(self) -> u64 — The identity number behind this id.

Trait implementations: Clone, Copy, Debug, Eq, Hash, PartialEq, StructuralPartialEq

structaster_ui::ImageResource

pub struct ImageResource { /* see fields */ }

Methods

  • fn copy_rgba8_srgb(descriptor: ImageDescriptor, pixels: &[u8], byte_budget: usize) -> Result<Self, Error> — Cold bounded copy; the caller's bytes may change or be dropped afterwards. Storage must match exactly. Premultiplied channels must not exceed alpha, including canonical zero RGB for zero alpha.
  • fn from_rgba8_srgb(descriptor: ImageDescriptor, pixels: Vec<u8>, byte_budget: usize) -> Result<Self, Error> — Adopt an immutable RGBA8 sRGB buffer without copying or reallocating it.
  • fn id(&self) -> ImageId
  • fn descriptor(&self) -> ImageDescriptor
  • fn pixels(&self) -> &[u8]

Trait implementations: Debug

structaster_ui::InputLimits

pub struct InputLimits { /* see fields */ }

Methods

  • fn new(nodes: usize, pointers: usize) -> Result<Self, Error>
  • fn node_capacity(self) -> usize
  • fn pointer_capacity(self) -> usize

Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq

structaster_ui::InputPresenter

pub struct InputPresenter { /* see fields */ }

Two preadmitted immutable coordinate planes plus bounded route scratch. Staging another scene/frame never changes the last acknowledged coordinates. Translation snapshots are the default. Explicit paint-map admission also supports prepared affine scenes and inverse-tested subtree clips. Host acknowledgement is an assertion, not an OS presentation or IME adapter.

Methods

  • fn new(node_capacity: usize) -> Result<Self, Error>
  • fn reserved_bytes(&self) -> usize
  • fn enable_paint_transforms(&mut self) -> Result<bool, Error> — Explicit cold world-map admission; old tickets/presented state survive.
  • fn stage(&mut self, scene: &Scene, frame: &Frame<'_>) -> Result<InputTicket, Error> — Captures only a matching accepted CPU frame and scene revision. A failed attempt preserves presented state and invalidates no successful ticket.
  • fn stage_info(&mut self, scene: &Scene, frame: FrameInfo) -> Result<InputTicket, Error> — Stage produced frame metadata without borrowing its pixel storage. The host still acknowledges only after the exact frame was submitted.
  • fn acknowledge(&mut self, ticket: InputTicket) -> Result<PresentationId, Error> — Host assertion of successful presentation, not an OS display operation.
  • fn presented(&self) -> Option<PresentationId>
  • fn presented_frame(&self) -> Option<FrameReceipt>
  • fn presented_nodes(&self, id: PresentationId) -> Result<PresentedNodes<'_>, Error> — Traverses accepted painter order after checking the complete ID. No live scene query, callback, allocation or publication occurs.
  • fn suspend(&mut self) — Invalidate input when display geometry/presentation becomes uncertain. Retains admitted storage; old presentation IDs and pending tickets fail.
  • fn presented_bounds(&self, id: PresentationId, node: NodeId) -> Result<LogicalRect, Error> — World logical border box from the acknowledged coordinate snapshot. This is not a query of the scene's current accepted layout.
  • fn presented_map(&self, id: PresentationId, node: NodeId) -> Result<Affine2D, Error> — Acknowledged node-local -> world logical paint map, not the live scene.
  • fn geometry_equals_pending(&self) -> bool — Exact equality of the pending and the presented input plane: the same nodes in the same order with the same bounds, clips, transforms, the same policies elsewhere and the same output. Paint is not part of the input plane, so a paint-only repaint leaves the two planes equal.
  • fn model_key_of(&self, id: PresentationId, node: NodeId) -> Result<Option<ModelKey>, Error> — The acknowledged model key of a node, or a stale node.
  • fn route_key(&mut self, id: PresentationId, node: NodeId, event: KeyEvent, handler: impl FnMut(RoutedKey) -> EventReply) -> Result<RouteOutcome, Error> — Keyboard routing has no invented pointer coordinates. Focus selection is owned by InputRouter or the application; this primitive routes explicitly.
  • fn route_key_readable(&self, route: &mut Vec<usize>, id: PresentationId, node: NodeId, event: KeyEvent, handler: impl FnMut(RoutedKey) -> EventReply) -> Result<RouteOutcome, Error> — Routes with an external scratch, leaving the acknowledged coordinates readable while the handler runs.
  • fn hit_test(&self, id: PresentationId, point: DevicePoint, accepts: impl FnMut(NodeId, Option<ModelKey>) -> bool) -> Result<Option<HitTarget>, Error> — Reverse painter order, half-open border boxes and inherited rectangular clips. The predicate selects app-interactive nodes; ink does not hit.
  • fn route_pointer(&mut self, id: PresentationId, node: NodeId, event: PointerEvent, handler: impl FnMut(RoutedPointer) -> EventReply) -> Result<RouteOutcome, Error> — Routes to a node in the presented snapshot, even if the live scene has since moved/removed it. The model key and local coordinates are likewise from that snapshot. Applications resolve stale live-node edits explicitly.
  • fn route_pointer_readable(&self, route: &mut Vec<usize>, id: PresentationId, node: NodeId, event: PointerEvent, handler: impl FnMut(RoutedPointer) -> EventReply) -> Result<RouteOutcome, Error> — Routes with an external scratch. The acknowledged coordinates stay readable while the handler runs, so a handler can bind, validate or hit test against the exact frame the event was routed against.

structaster_ui::InputRouter

pub struct InputRouter { /* see fields */ }

Bounded policy snapshots, focus and explicit multi-pointer capture. This is not a plugin scheduler, native input adapter or IME bridge.

Methods

  • fn new(limits: InputLimits) -> Result<Self, Error>
  • fn acknowledged_parts(&self) -> Option<AcknowledgedParts<'_>> — The read-only acknowledged pieces of the presented presentation. The application can read the exact geometry, policies, focus and identity, and has no way to stage, acknowledge or mutate the presentation.
  • fn presented_geometry(&self) -> Option<GeometryId> — The continuity identity of the visible accepted input plane. It is stable while the acknowledged geometry, policies and output are exactly unchanged, and fresh for every other acknowledged plane.
  • fn reserved_bytes(&self) -> usize
  • fn enable_paint_transforms(&mut self) -> Result<bool, Error>
  • fn stage(&mut self, scene: &Scene, frame: &Frame<'_>, policies: &[Interaction]) -> Result<InputTicket, Error> — Policy and coordinates publish together, after all policy validation. Failed staging retains both the visible and previous pending planes.
  • fn stage_info(&mut self, scene: &Scene, frame: FrameInfo, policies: &[Interaction]) -> Result<InputTicket, Error> — Stage policies and produced geometry without borrowing CPU pixels.
  • fn acknowledge(&mut self, ticket: InputTicket) -> Result<PresentationUpdate<'_>, Error>
  • fn suspend(&mut self) -> PresentationUpdate<'_> — Resize, focus loss, device/display loss or uncertain host presentation: invalidate all tickets, clear focus/captures, retain reserved storage.
  • fn presented(&self) -> Option<PresentationId>
  • fn coordinates(&self) -> &InputPresenter — Read-only coordinate access for consumers such as semantic snapshots. Staging and acknowledgement still require the router's reconciled API.
  • fn presented_frame(&self) -> Option<FrameReceipt>
  • fn presented_bounds(&self, id: PresentationId, node: NodeId) -> Result<LogicalRect, Error>
  • fn presented_map(&self, id: PresentationId, node: NodeId) -> Result<transform::Affine2D, Error>
  • fn hit_test(&self, id: PresentationId, point: DevicePoint) -> Result<Option<HitTarget>, Error>
  • fn focused(&self) -> Option<InteractionTarget>
  • fn focus_target(&mut self, id: PresentationId, node: Option<NodeId>) -> Result<Option<FocusChange>, Error>
  • fn focus_next(&mut self, id: PresentationId, reverse: bool) -> Result<Option<FocusChange>, Error> — Tab rank, then presented painter order; wraps. Programmatic-only focus does not invent a sequential rank. No temporary sorting/allocation.
  • fn captured(&self, pointer: PointerId) -> Option<InteractionTarget>
  • fn capture_pointer(&mut self, id: PresentationId, pointer: PointerId, node: NodeId) -> Result<Option<CapturedPointer>, Error> — Capture is explicit. Applications release after the final button-up; Cancel, removed/disabled targets and suspend release automatically.
  • fn release_pointer(&mut self, pointer: PointerId) -> Option<CapturedPointer> — Unconditional owner-thread action. Queued host events must first pass dispatch's PresentationId check; never blindly release a reused host ID.
  • fn dispatch_pointer(&mut self, id: PresentationId, event: PointerEvent, handler: impl FnMut(RoutedPointer) -> EventReply) -> Result<PointerDispatch, Error>
  • fn dispatch_pointer_with(&mut self, id: PresentationId, event: PointerEvent, handler: impl FnMut(RoutedPointer, AcknowledgedParts<'c>) -> EventReply) -> Result<PointerDispatch, Error> — Routes a pointer event and offers the handler a read-only view of the acknowledged presentation. The existing dispatch API is unchanged.
  • fn dispatch_key(&mut self, id: PresentationId, event: KeyEvent, handler: impl FnMut(RoutedKey) -> EventReply) -> Result<KeyDispatch, Error>
  • fn dispatch_key_with(&mut self, id: PresentationId, event: KeyEvent, handler: impl FnMut(RoutedKey, AcknowledgedParts<'c>) -> EventReply) -> Result<KeyDispatch, Error> — Routes a key event and offers the handler a read-only view of the acknowledged presentation. The existing dispatch API is unchanged.

structaster_ui::InputTicket

pub struct InputTicket { /* see fields */ }

A pending CPU frame/snapshot pair. A host acknowledges this exact ticket only after its own display operation succeeds; construction is not display.

Methods

  • fn frame(self) -> FrameReceipt

Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq

structaster_ui::Interaction

pub struct Interaction { /* see fields */ }

Immutable per-frame input policy. Omission disables targeting/focus. None tab order allows programmatic focus but excludes sequential navigation.

Methods

  • fn pointer(node: NodeId) -> Self
  • fn focusable(node: NodeId, tab_order: Option<u32>) -> Self
  • fn with_pointer(self, enabled: bool) -> Self
  • fn node(self) -> NodeId
  • fn accepts_pointer(self) -> bool
  • fn accepts_focus(self) -> bool
  • fn tab_order(self) -> Option<u32>

Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq

structaster_ui::InteractionTarget

pub struct InteractionTarget { /* see fields */ }

Methods

  • fn node(self) -> NodeId
  • fn model_key(self) -> Option<ModelKey>

Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq

structaster_ui::KeyDispatch

pub struct KeyDispatch { /* see fields */ }

Public fields

fieldtype
routeRouteOutcome
focusOption<FocusChange>

Trait implementations: Clone, Copy, Debug, Default, Eq, PartialEq, StructuralPartialEq

structaster_ui::KeyEvent

pub struct KeyEvent { /* see fields */ }

Public fields

fieldtype
codeKeyCode
stateKeyState
modifiersKeyModifiers

Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq

structaster_ui::KeyModifiers

pub struct KeyModifiers { /* see fields */ }

Public fields

fieldtype
shiftbool
controlbool
altbool
metabool

Trait implementations: Clone, Copy, Debug, Default, Eq, PartialEq, StructuralPartialEq

structaster_ui::LayoutConstraints

pub struct LayoutConstraints { /* see fields */ }

Definite content-box space assigned during this bounded preparation pass. A measurement may return larger content; minima are never silently violated.

Methods

  • fn available(self) -> LayoutSize

Trait implementations: Clone, Copy, Debug, PartialEq, StructuralPartialEq

structaster_ui::LayoutReport

pub struct LayoutReport { /* see fields */ }

Methods

  • fn iterations(self) -> usize
  • fn managed_nodes(self) -> usize
  • fn viewport(self) -> LogicalRect

Trait implementations: Clone, Copy, Debug, PartialEq, StructuralPartialEq

structaster_ui::LayoutSize

pub struct LayoutSize(..)

Methods

  • fn new(width: f64, height: f64) -> Result<Self, Error>
  • fn components(self) -> [f64; 2]

Trait implementations: Clone, Copy, Debug, PartialEq, StructuralPartialEq

structaster_ui::LayoutStyle

pub struct LayoutStyle { /* see fields */ }

Logical border-box sizing. Padding is left, top, right, bottom; appearance and ink remain independent. These are not full CSS flex/grid descriptors.

Methods

  • fn leaf() -> Self
  • fn overlay() -> Self
  • fn stack(axis: Axis, gap: f64) -> Result<Self, Error>
  • fn wrap(axis: Axis, item_gap: f64, line_gap: f64) -> Result<Self, Error> — Wrapping flow along axis: items fill one line and overflow to the next line. item_gap separates items inside a line, line_gap separates lines. Both must be finite and nonnegative. This is a bounded flow policy, not full CSS flex/grid.
  • fn flex(axis: Axis, gap: f64) -> Result<Self, Error> — Constrained one-dimensional flex along axis: children keep a basis taken from their own Exact or Auto sizing and share or surrender the free space of the container by their grow and shrink controls. gap must be finite and nonnegative. This is a bounded flex slice, not full CSS flex.
  • fn with_flex_grow(self, grow: f64) -> Result<Self, Error> — Growth control of this node inside a flex container. The factor must be finite and nonnegative; the default is zero.
  • fn with_flex_shrink(self, shrink: f64) -> Result<Self, Error> — Shrink control of this node inside a flex container, weighted by the basis of that node. The factor must be finite and nonnegative; the default is one.
  • fn with_size(self, width: LayoutLength, height: LayoutLength) -> Result<Self, Error>
  • fn with_limits(self, minimum: LayoutSize, maximum: [Option<f64>; 2]) -> Result<Self, Error>
  • fn with_padding(self, padding: [f64; 4]) -> Result<Self, Error>
  • fn with_alignment(self, align: LayoutAlign) -> Self

Trait implementations: Clone, Copy, Debug, PartialEq, StructuralPartialEq

structaster_ui::LogicalRect

pub struct LogicalRect(..)

Validated logical-pixel rectangle. Negative extents are rejected.

Methods

  • fn new(x: f64, y: f64, width: f64, height: f64) -> Result<Self, Error>
  • fn components(self) -> [f64; 4]

Trait implementations: Clone, Copy, Debug, PartialEq, StructuralPartialEq

structaster_ui::ModelKey

pub struct ModelKey(..)

Application model identity, distinct from runtime node/generation identity.

Public fields

fieldtype
0u128

Trait implementations: Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd, StructuralPartialEq

structaster_ui::NodeBoundsAnimator

pub struct NodeBoundsAnimator { /* see fields */ }

Small wrapper binding a bounds track to an optional retained node.

The binding is optional: an unbound animator samples without touching a scene. Applying writes the sampled bounds through the ordinary edit transaction, so geometry publication still requires a normal scene commit.

Methods

  • fn new(animation: BoundsAnimation) -> Self
  • fn animation(&self) -> &BoundsAnimation
  • fn node(&self) -> Option<NodeId>
  • fn bind(&mut self, node: NodeId) -> Option<NodeId> — Bind the track to a retained node identity.
  • fn unbind(&mut self) -> Option<NodeId>
  • fn apply(&self, edit: &mut Edit<'_>, elapsed_seconds: f64, reduced_motion_active: bool) -> Result<ApplyOutcome, Error> — Sample and apply the track to the bound node.

structaster_ui::NodeDescription

pub struct NodeDescription { /* see fields */ }

Methods

  • fn group(bounds: LogicalRect) -> Self
  • fn painted(bounds: LogicalRect, paint: Paint) -> Self
  • fn drawing(bounds: LogicalRect, recording: Arc<Recording>) -> Self — Recording coordinates stay local to this node; bounds do not rescale ink.
  • fn with_clip(self, clip: Clip) -> Self
  • fn with_key(self, key: ModelKey) -> Self
  • fn with_blend(self, mode: BlendMode) -> Result<Self, Error> — Blend this node's painted fill, or the fill/image/vector/effect commands of its drawing that did not choose a mode themselves (text stays source-over). Groups have nothing to blend. The mode is part of the description's equality.
  • fn blend(&self) -> BlendMode
  • fn with_bounds(self, bounds: LogicalRect) -> Self
  • fn with_corner_radius(self, radius: f64) -> Result<Self, Error>
  • fn bounds(&self) -> LogicalRect
  • fn model_key(&self) -> Option<ModelKey>

Trait implementations: Clone, Debug, PartialEq, StructuralPartialEq

structaster_ui::NodeId

pub struct NodeId { /* see fields */ }

Trait implementations: Clone, Copy, Debug, Eq, Hash, PartialEq, StructuralPartialEq

structaster_ui::Output

pub struct Output { /* see fields */ }

Validated physical output and explicit logical-to-device scale. Pixel storage is RGBA8 sRGB, straight alpha, top-left, tightly packed.

Methods

  • fn new(width: u32, height: u32, scale: f64, color: ColorProcessing) -> Result<Self, Error>
  • fn physical_size(self) -> [u32; 2]
  • fn scale(self) -> f64
  • fn color_processing(self) -> ColorProcessing

Trait implementations: Clone, Copy, Debug, PartialEq, StructuralPartialEq

structaster_ui::OutputId

pub struct OutputId(..)

Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq

structaster_ui::PluginError

pub struct PluginError(..)

A plugin-reported failure code.

The code is an application-defined number. Returning an error disables the reporting plugin only; peers keep running.

Public fields

fieldtype
0u32

Methods

  • const fn code(self) -> u32 — The application-defined failure code.

Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq

structaster_ui::PluginFailure

pub struct PluginFailure { /* see fields */ }

A plugin failure observed by the bus.

Public fields

fieldtype
handlePluginHandleThe plugin that failed.
codeu32The application-defined failure code.

Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq

structaster_ui::PluginHandle

pub struct PluginHandle { /* see fields */ }

A stable handle to a registered plugin.

Handles are stable: the index of a plugin never changes and is never reused, so a handle to a retired plugin stays detectably stale. A handle from another bus is foreign and is refused.

Methods

  • const fn index(self) -> usize — Registration index of the plugin within its bus.

Trait implementations: Clone, Copy, Debug, Eq, Hash, PartialEq, StructuralPartialEq

structaster_ui::PointerDispatch

pub struct PointerDispatch { /* see fields */ }

Public fields

fieldtype
routeRouteOutcome
focusOption<FocusChange>
released_captureOption<CapturedPointer>

Trait implementations: Clone, Copy, Debug, Default, Eq, PartialEq, StructuralPartialEq

structaster_ui::PointerEvent

pub struct PointerEvent { /* see fields */ }

Public fields

fieldtype
pointerPointerId
kindPointerKind
positionDevicePoint

Trait implementations: Clone, Copy, Debug, PartialEq, StructuralPartialEq

structaster_ui::PointerId

pub struct PointerId(..)

Public fields

fieldtype
0u64

Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq

structaster_ui::PreparationStats

pub struct PreparationStats { /* see fields */ }

Public fields

fieldtype
source_capturesusize
source_reusesusize
mask_buildsusize
mask_reusesusize
group_capturesusize
group_reusesusize

Trait implementations: Clone, Copy, Debug, Default, Eq, PartialEq, StructuralPartialEq

structaster_ui::PreparedScene

pub struct PreparedScene { /* see fields */ }

Methods

  • fn prepare(scene: &Scene, output: Output, limits: AffineSceneLimits) -> Result<Self, Error>
  • fn prepare_composited(scene: &Scene, output: Output, limits: AffineSceneLimits, groups: SceneGroupLimits) -> Result<Self, Error> — Cold postorder subtree isolation. Clips inherited from outside an isolation boundary apply once to that group's result, not to each child. This is explicitly RGBA8 raster isolation, not per-sample color storage.
  • fn id(&self) -> PreparedSceneId
  • fn scene_stamp(&self) -> SceneStamp
  • fn output(&self) -> Output
  • fn layer_count(&self) -> usize
  • fn pixel_payload_bytes(&self) -> usize — Retained image and mask payload only; graph/Arc/source/allocator storage separate.
  • fn retained_recording_count(&self) -> usize

Trait implementations: Debug

structaster_ui::PreparedSceneId

pub struct PreparedSceneId(..)

Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq

structaster_ui::PresentationId

pub struct PresentationId { /* see fields */ }

A particular coordinate snapshot, owned by one input presenter.

Methods

  • fn same_presenter(self, other: Self) -> bool — Checks originating presenter identity only, not whether either revision is still current. Actual routing must validate the complete ID.

Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq

structaster_ui::PresentationUpdate

pub struct PresentationUpdate<'a> { /* see fields */ }

Consume retirement information before handling subsequent host events.

Public fields

fieldtype
presentationOption<PresentationId>
focusOption<FocusChange>
lost_captures&'a [CapturedPointer]

structaster_ui::PresentedNode

pub struct PresentedNode { /* see fields */ }

Copied metadata from one acknowledged input snapshot. Bounds are logical world AABBs; the paint map retains rotation/shear. This is not live layout.

Public fields

fieldtype
nodeNodeId
model_keyOption<ModelKey>
parentOption<NodeId>
boundssuper::LogicalRect
paint_maptransform::Affine2D
interactivebool

Trait implementations: Clone, Copy, Debug

structaster_ui::PresentedNodes

pub struct PresentedNodes<'a> { /* see fields */ }

Immutable borrowing prevents acknowledgement/staging while this iterator is in use. Each item carries any map-construction failure explicitly.

Trait implementations: ExactSizeIterator, FusedIterator, Iterator

structaster_ui::Recorder

pub struct Recorder { /* see fields */ }

Cold bounded recording. Invalid commands never modify an accepted recording.

Methods

  • fn set_blend(&mut self, mode: BlendMode) -> &mut Self — Blend mode of the fill, image, vector and effect commands recorded after this call (default SourceOver). Text commands are always source-over. The mode is part of each command's equality, so changing it is a change the incremental renderer sees.
  • fn effect(&mut self, drawing: std::sync::Arc<effects::EffectDrawing>, origin: [f64; 2], clip: Option<LogicalRect>, sampling: ImageSampling) -> Result<(), Error> — Cold-prepared recording effect. Layout/hit geometry remains on the node. Fractional placements use the caller's explicit image sampling policy.
  • fn vector(&mut self, geometry: std::sync::Arc<VectorGeometry>, origin: [f64; 2], clip: Option<LogicalRect>, fill: Option<Srgb8>, stroke: Option<VectorStroke>) -> Result<(), Error>
  • fn image(&mut self, image: std::sync::Arc<ImageResource>, bounds: LogicalRect, clip: Option<LogicalRect>, sampling: ImageSampling) -> Result<(), Error> — Stretch the complete immutable image into logical bounds. Bilinear uses alpha-weighted taps in the output's declared color processing space.
  • fn new(command_limit: usize) -> Result<Self, Error>
  • fn fill(&mut self, bounds: LogicalRect, clip: Option<LogicalRect>, radius: f64, paint: Paint) -> Result<(), Error>
  • fn text(&mut self, drawing: std::sync::Arc<TextDrawing>, baseline: [f64; 2], clip: Option<LogicalRect>, color: Srgb8) -> Result<(), Error>
  • fn finish(self) -> Result<Recording, Error>

structaster_ui::Recording

pub struct Recording { /* see fields */ }

Methods

  • fn id(&self) -> RecordingId
  • fn command_count(&self) -> usize

Trait implementations: Debug

structaster_ui::RecordingId

pub struct RecordingId(..)

Immutable process-local resource identity; not a persistent asset ID.

Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq

structaster_ui::RenderDiagnostics

pub struct RenderDiagnostics { /* see fields */ }

Public fields

fieldtype
rasterizationsu64
reused_framesu64
partial_rasterizationsu64
layered_rasterizationsu64Frames drawn as a retained base layer plus a repainted full-screen overlay.
banded_rasterizationsu64Frames drawn by the parallel row-band rasteriser. A frame counts once, however many of its layers (the base layer and the overlay) the band workers drew.
banded_region_repaintsu64Incremental region repaints (frame or retained base layer) shared across band workers.
accelerated_rasterizationsu64Full renders drawn by an installed [accel::RasterAccelerator].
accelerator_fallbacksu64Full renders an installed accelerator failed or declined (drawn by the CPU instead).

Trait implementations: Clone, Copy, Debug, Default, Eq, PartialEq, StructuralPartialEq

structaster_ui::Renderer

pub struct Renderer { /* see fields */ }

Owner-thread renderer. Pool/scratch handles are private implementation details. Replay uses preadmitted storage; allocation qualification is tracked separately.

Methods

  • fn render_prepared_scene(&mut self, prepared: &PreparedScene, frame_index: u64, clear: Srgb8) -> Result<FrameReceipt, Error>
  • fn new(output: Output, pixel_budget: usize) -> Result<Self, Error> — Admit exactly the initial output's two pixel planes. pixel_budget is a ceiling, not a reservation; use with_output_capacity for larger resizes.
  • fn with_output_capacity(output: Output, pixel_capacity: usize) -> Result<Self, Error> — Cold admission of two fixed-capacity pixel planes. Subsequent output replacement and rendering never grow them. Scratch/resources are separate.
  • fn configured_output(&self) -> Output — Current target descriptor, which may differ from the last accepted Frame.
  • fn pixel_capacity(&self) -> usize — Actual admitted pixels per plane, independent of current dimensions.
  • fn replace_output(&mut self, output: Output) -> Result<bool, Error> — Configure the next render without changing the last accepted Frame. Equal configured descriptors return false and preserve identity/reuse. A change returns true, allocates a fresh output identity and invalidates reuse, including A -> B -> A before painting. Capacity/identity failures leave configuration and publication intact. Preparation failures on a later render retain the pending target and the previous accepted Frame. Host presentation/input changes require explicit acknowledgement or suspension; this method does not mutate presenters or input routers.
  • fn enable_vectors(&mut self, limits: VectorLimits) -> Result<(), Error> — One-time cold admission, separate from output pixel storage. Failure preserves the accepted frame and any previous successful admission.
  • fn enable_vectors_for_width(&mut self, limits: VectorLimits, max_width: usize) -> Result<(), Error> — Cold vector admission with explicit maximum physical row width, separate from pixel capacity. Replacement beyond it fails without reallocating.
  • fn vector_diagnostics(&self) -> Option<VectorDiagnostics>
  • fn vector_storage_bytes(&self) -> usize — Primary vector-workspace accounting: retained raster capacities plus fixed arc/prepared-cache allowances, including when caches are empty. Excludes band-worker workspaces, pixel planes, object/allocator metadata and immutable geometry/stroke resources. This is not process RSS or an exact measurement of currently allocated cache storage.
  • fn set_accelerator(&mut self, accelerator: Option<Box<dyn accel::RasterAccelerator + Send>>) -> Option<Box<dyn accel::RasterAccelerator + Send>> — Worker threads for full-frame rasterisation: 0 picks from the host (up to 8) and only bands large outputs, 1 is the serial renderer, n > 1 forces up to n bands workers. The pixels never depend on this value. Install (or with None remove) a frame accelerator and return the previous one. Without one (the default) every frame is drawn by the CPU exactly as before. See [accel].
  • fn take_accelerator(&mut self) -> Option<Box<dyn accel::RasterAccelerator + Send>> — Remove and return the installed accelerator, if any.
  • fn has_accelerator(&self) -> bool
  • fn accelerator_last_error(&self) -> Option<&accel::AccelError> — The installed accelerator's most recent failure (the frame it failed was drawn by the CPU).
  • fn set_raster_threads(&mut self, workers: usize)
  • fn render(&mut self, recording: &Recording, frame_index: u64, clear: Srgb8) -> Result<FrameReceipt, Error>
  • fn render_scene(&mut self, scene: &Scene, frame_index: u64, clear: Srgb8) -> Result<FrameReceipt, Error>
  • fn render_scene_incremental(&mut self, scene: &Scene, previous: &Scene, frame_index: u64, clear: Srgb8) -> Result<FrameReceipt, Error> — Render scene as an update of previous, the scene this renderer's last accepted frame was drawn from with the same clear. Only the device regions touched by commands that differ between the two scenes are re-rasterised (previous pixels are copied, the regions cleared and every intersecting command repainted, clipped to its region, in original order); the result is byte-identical to [Renderer::render_scene]. Whenever equivalence cannot be proven (no matching proof, affine/group or primitive-only scenes, a non-exact device grid, large damage) this is exactly render_scene.
  • fn diagnostics(&self) -> RenderDiagnostics
  • fn pixel_storage_bytes(&self) -> usize — Admitted pixel planes only; excludes pool metadata and scene resources.
  • fn last_damage(&self) -> Option<&[[usize; 4]]> — Where the last staged frame may differ from the frame accepted before it, as disjoint device rectangles [x, y, w, h]. Some(&[]): the pixels were republished unchanged. None: not known (a full, layered or banded-from-scratch render, a resize): treat the whole output as damaged. A presenter (a browser texture upload, a compositor) may copy only these rectangles.
  • fn frame(&self) -> Result<Frame<'_>, Error> — A borrow prevents output mutation for the complete readback lease.

structaster_ui::RouteOutcome

pub struct RouteOutcome { /* see fields */ }

Public fields

fieldtype
visitsusize
default_preventedbool

Trait implementations: Clone, Copy, Debug, Default, Eq, PartialEq, StructuralPartialEq

structaster_ui::RoutedKey

pub struct RoutedKey { /* see fields */ }

Public fields

fieldtype
presentationPresentationId
frameFrameReceipt
phaseEventPhase
targetNodeId
currentNodeId
model_keyOption<ModelKey>
eventKeyEvent

Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq

structaster_ui::RoutedPointer

pub struct RoutedPointer { /* see fields */ }

Public fields

fieldtype
presentationPresentationId
frameFrameReceipt
phaseEventPhase
targetNodeId
currentHitTarget
eventPointerEvent

Trait implementations: Clone, Copy, Debug, PartialEq, StructuralPartialEq

structaster_ui::RunGeometry

pub struct RunGeometry { /* see fields */ }

Owned bounded geometry in baseline-local logical pixels. Only cluster-edge carets are admitted. This does not itemize, wrap or resolve paragraph bidi. A historical snapshot is queryable, but its positions cannot edit new source.

Methods

  • fn new(maximum_clusters: usize) -> Result<Self, Error>
  • fn source(&self) -> Result<SourceStamp, Error>
  • fn source_range(&self) -> Result<TextRange, Error>
  • fn shaping_stamp(&self) -> Result<ShapingStamp, Error>
  • fn cluster_count(&self) -> usize
  • fn reserved_bytes(&self) -> usize
  • fn prepare(&mut self, source: TextSource<'_>, run: &ShapedRun<'_>) -> Result<(), Error> — All conversion, geometry and capacity checks precede publication. Native advance pens determine caret coordinates; glyph offsets/ink do not.
  • fn hit_test(&self, x: f64) -> Result<RunHit, Error> — Nearest cluster edge at baseline-local X. Exact midpoints choose the right visual edge; zero-advance clusters choose that same explicit edge.
  • fn caret_rect(&self, position: TextPosition, thickness: f64) -> Result<LogicalRect, Error> — Baseline-local ascent/descent box. Does not include glyph ink or line gap.
  • fn selection_rects(&self, range: TextRange, output: &mut [LogicalRect]) -> Result<usize, Error> — One contiguous single-run selection, or none when collapsed. An error leaves every caller output element unchanged; no hidden cluster snapping.

structaster_ui::RunHit

pub struct RunHit { /* see fields */ }

A source-stamped cluster edge, not an unqualified paragraph caret offset.

Methods

  • fn position(self) -> TextPosition
  • fn cluster(self) -> Option<TextRange> — The visual cluster whose edge was chosen; absent for an empty run.

Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq

structaster_ui::RunOptions

pub struct RunOptions<'a> { /* see fields */ }

One already-itemized horizontal run. This does not perform paragraph bidi, font fallback, line breaking or visual caret geometry.

Public fields

fieldtype
logical_sizef64
directionRunDirection
scriptOption<[u8; 4]>
languageOption<&'a str>
features&'a [TextFeature]

Methods

  • fn new(logical_size: f64, direction: RunDirection) -> Self

Trait implementations: Clone, Copy

structaster_ui::Scene

pub struct Scene { /* see fields */ }

Methods

  • fn enable_group_composition(&mut self) -> Result<bool, Error> — Cold admission for subtree appearance, including its world coordinate planes. Does not change accepted policy, layout or source revision.
  • fn has_group_composition(&self) -> bool
  • fn group_opacity(&self, id: NodeId) -> Result<f64, Error> — Accepted subtree opacity. Defaults to one; it is not per-child alpha.
  • fn group_isolation(&self, id: NodeId) -> Result<GroupIsolation, Error> — Authored isolation policy. Auto can still isolate when opacity is below one.
  • fn enable_paint_transforms(&mut self) -> Result<bool, Error> — Cold per-node policy/world admission. Existing accepted model/revision remains unchanged. Default scenes allocate no transform node planes.
  • fn has_paint_transforms(&self) -> bool
  • fn paint_transform(&self, id: NodeId) -> Result<Option<PaintTransform>, Error>
  • fn paint_map(&self, id: NodeId) -> Result<Affine2D, Error>
  • fn inverse_paint_map(&self, id: NodeId) -> Result<Option<InverseAffine2D>, Error> — None is a truly singular/collapsed map, not an invented hit coordinate.
  • fn enable_layout(&mut self) -> Result<bool, Error> — Explicit cold admission. Primitive-only users pay no per-node layout storage. Enabling changes no accepted descriptions, revision or pixels.
  • fn layout_style(&self, id: NodeId) -> Result<Option<LayoutStyle>, Error>
  • fn new(node_capacity: usize, command_capacity: usize) -> Result<Self, Error> — Cold node/expanded-command admission; both model planes are reserved. Accepted mixed-text coordinates are admitted once at the first successful mixed preparation, then retained for allocation-free warmed transitions.
  • fn stamp(&self) -> SceneStamp
  • fn node_count(&self) -> usize
  • fn command_count(&self) -> usize
  • fn reserved_bytes(&self) -> usize — Reserved model/projection storage; shared recording payloads excluded.
  • fn description(&self, id: NodeId) -> Result<&NodeDescription, Error>
  • fn find(&self, key: ModelKey) -> Option<NodeId>
  • fn parent(&self, id: NodeId) -> Result<Option<NodeId>, Error>
  • fn edit(&mut self) -> Edit<'_>

structaster_ui::SceneCacheLimits

pub struct SceneCacheLimits { /* see fields */ }

Public fields

fieldtype
retained_pixel_bytesusizeRetained RGBA8 captures plus u16 masks, excluding metadata/source leases.
transaction_pixel_bytesusizeConservative accepted + complete candidate + private raster working bytes. Vector scratch/metadata and caller-held old snapshots remain separate.

Trait implementations: Clone, Copy, Debug

structaster_ui::SceneGroupLimits

pub struct SceneGroupLimits { /* see fields */ }

Extra cold storage for whole-subtree raster isolation. The existing affine limits separately account for source captures and all geometric masks.

Public fields

fieldtype
groupsusize
working_pixelsusizeOne reusable full-output RGBA8 working plane, in physical pixels.
retained_bytesusizeConservative sum of every group's full-output capture, including nested captures that coexist temporarily. Original source bytes are separate.

Trait implementations: Clone, Copy, Debug

structaster_ui::ScenePreparationCache

pub struct ScenePreparationCache { /* see fields */ }

Incremental CPU preparation for one scene owner and one output/quality policy. Geometry/planning metadata may allocate; no warmed zero-allocation claim.

Methods

  • fn new(output: Output, source_limits: AffineSceneLimits, group_limits: SceneGroupLimits, pixel_limits: SceneCacheLimits) -> Result<Self, Error> — Construction stores explicit limits; first preparation admits resources.
  • fn prepare(&mut self, scene: &Scene) -> Result<PreparedScene, Error>
  • fn statistics(&self) -> Option<PreparationStats> — Last successful preparation only; failures leave this unchanged.
  • fn scene_stamp(&self) -> Option<SceneStamp>
  • fn retained_pixel_bytes(&self) -> usize
  • fn reserved_metadata_bytes(&self) -> usize — Fixed cache/state + owned node/dependency vector capacities. Excludes Arc allocations, recordings/resources, allocator overhead and pixel Vecs.
  • fn clear(&mut self) — Cold reset permits another scene owner. Existing prepared snapshots survive.

Trait implementations: Debug

structaster_ui::SceneStamp

pub struct SceneStamp { /* see fields */ }

Methods

  • fn revision(self) -> u64

Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq

structaster_ui::ShapedGlyph

pub struct ShapedGlyph { /* see fields */ }

Native glyph identity within the run's FontId, plus exact source cluster. Origins are baseline-relative logical coordinates, positive Y down.

Methods

  • fn id(self) -> u32
  • fn source(self) -> TextRange
  • fn baseline_origin(self) -> [f64; 2]
  • fn advance(self) -> f64

Trait implementations: Clone, Copy, Debug, PartialEq, StructuralPartialEq

structaster_ui::ShapedRun

pub struct ShapedRun<'a> { /* see fields */ }

Immutable accepted borrow. Calling shape again requires releasing this view.

Methods

  • fn stamp(&self) -> ShapingStamp
  • fn font(&self) -> FontId
  • fn source(&self) -> SourceStamp
  • fn source_range(&self) -> TextRange
  • fn logical_size(&self) -> f64 — Actual resolved f32 native size, represented as f64 logical pixels.
  • fn direction(&self) -> RunDirection
  • fn advance_width(&self) -> f64
  • fn metrics(&self) -> FontMetrics
  • fn glyphs(&self) -> &'a [ShapedGlyph]

structaster_ui::ShapingStamp

pub struct ShapingStamp { /* see fields */ }

Methods

  • fn revision(self) -> u64

Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq

structaster_ui::SourceStamp

pub struct SourceStamp { /* see fields */ }

Exact committed source identity. Selection and IME overlays do not change it.

Methods

  • fn revision(self) -> u64

Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq

structaster_ui::Srgb8

pub struct Srgb8(..)

Explicit byte sRGB, straight alpha; never an untagged linear color.

Methods

  • const TRANSPARENT: Self
  • const fn rgba(r: u8, g: u8, b: u8, a: u8) -> Self
  • const fn channels(self) -> [u8; 4]

Trait implementations: Clone, Copy, Debug, Eq, Hash, PartialEq, StructuralPartialEq

structaster_ui::TextDocument

pub struct TextDocument { /* see fields */ }

Bounded owner-thread editor. Source bytes, IME display and selection are distinct.

Methods

  • fn new(text: &str, max_bytes: usize, max_composition_bytes: usize) -> Result<Self, Error> — History-free document. Allocation profile and behaviour are unchanged.
  • fn new_with_history(text: &str, max_bytes: usize, max_composition_bytes: usize, max_edits: usize, max_history_bytes: usize) -> Result<Self, Error> — Opt-in document with bounded undo/redo history.
  • fn source(&self) -> TextSource<'_>
  • fn revision(&self) -> DocumentRevision
  • fn selection(&self) -> TextSelection
  • fn selected_text(&self) -> &str
  • fn adopt_run_geometry(&mut self, expected: DocumentRevision, geometry: &RunGeometry) -> Result<bool, Error> — Adopt cluster-edge editing for one complete current-source native run. Changed policy advances the editor revision, not committed source. Partial runs, active IME and interior selections reject without snapping.
  • fn composition(&self) -> Option<&str>
  • fn display_parts(&self) -> [&str; 3] — Three borrowed display spans. Overlay bytes are not committed-source offsets.
  • fn set_selection(&mut self, expected: DocumentRevision, anchor: TextPosition, focus: TextPosition) -> Result<Option<DocumentChange>, Error>
  • fn replace(&mut self, expected: DocumentRevision, range: TextRange, replacement: &str) -> Result<Option<DocumentChange>, Error>
  • fn replace_selection(&mut self, expected: DocumentRevision, replacement: &str) -> Result<Option<DocumentChange>, Error>
  • fn move_caret(&mut self, expected: DocumentRevision, movement: TextMovement, extend: bool) -> Result<Option<DocumentChange>, Error>
  • fn delete(&mut self, expected: DocumentRevision, backward: bool) -> Result<Option<DocumentChange>, Error>
  • fn update_composition(&mut self, expected: DocumentRevision, value: &str) -> Result<DocumentChange, Error>
  • fn cancel_composition(&mut self, expected: DocumentRevision) -> Result<Option<DocumentChange>, Error>
  • fn commit_composition(&mut self, expected: DocumentRevision) -> Result<Option<DocumentChange>, Error>
  • fn can_undo(&self) -> bool — Whether a content edit is available to undo.
  • fn can_redo(&self) -> bool — Whether a content edit is available to redo.
  • fn undo(&mut self, expected: DocumentRevision) -> Result<Option<DocumentChange>, Error> — Undo the last content edit.
  • fn redo(&mut self, expected: DocumentRevision) -> Result<Option<DocumentChange>, Error> — Redo the last undone content edit.

structaster_ui::TextDrawing

pub struct TextDrawing { /* see fields */ }

Cold owned glyph resource at one exact output scale. Safe to share between immutable recordings; neither the font nor the shaper must remain alive.

Methods

  • fn prepare(font: &FontAsset, run: &ShapedRun<'_>, output_scale: f64, limits: TextDrawingLimits) -> Result<Self, Error>
  • fn prepare_with_rasterization(font: &FontAsset, run: &ShapedRun<'_>, output_scale: f64, rasterization: TextRasterization, limits: TextDrawingLimits) -> Result<Self, Error> — Explicit cold admission of outline phases; existing prepare() remains unchanged.
  • fn prepare_with_scratch(font: &FontAsset, run: &ShapedRun<'_>, output_scale: f64, limits: TextDrawingLimits, scratch: &mut TextRasterScratch) -> Result<Self, Error> — Cold preparation through a caller-owned reusable scratch.
  • fn prepare_with_cache(font: &FontAsset, run: &ShapedRun<'_>, output_scale: f64, limits: TextDrawingLimits, cache: &mut GlyphMaskCache) -> Result<Self, Error> — Cold preparation through a caller-owned cache of rasterised glyph masks.
  • fn prepare_with_cache_and_scratch(font: &FontAsset, run: &ShapedRun<'_>, output_scale: f64, limits: TextDrawingLimits, cache: &mut GlyphMaskCache, scratch: &mut TextRasterScratch) -> Result<Self, Error> — Cold preparation through a caller-owned cache and a caller-owned scratch.
  • fn add_tracking(self, amount: f64) -> Result<Self, Error> — Add logical-pixel spacing between the already shaped clusters, preserving their glyph identities, joining forms, offsets within each cluster and masks. Repeated calls add spacing. The caller accounts for the extra spacing in its measured advance; font metrics and source identity remain unchanged.
  • fn id(&self) -> TextDrawingId
  • fn font(&self) -> FontId
  • fn source(&self) -> SourceStamp
  • fn source_range(&self) -> TextRange
  • fn logical_size(&self) -> f64
  • fn output_scale(&self) -> f64
  • fn metrics(&self) -> FontMetrics
  • fn glyph_count(&self) -> usize
  • fn unique_glyph_count(&self) -> usize
  • fn rasterization(&self) -> TextRasterization
  • fn prepared_mask_count(&self) -> usize
  • fn mask_storage_bytes(&self) -> usize
  • fn ink_bounds(&self) -> Option<LogicalRect> — Conservative baseline-local mask bounds, distinct from logical advance.

Trait implementations: Debug

structaster_ui::TextDrawingId

pub struct TextDrawingId(..)

Trait implementations: Clone, Copy, Debug, Eq, Hash, PartialEq, StructuralPartialEq

structaster_ui::TextDrawingLimits

pub struct TextDrawingLimits { /* see fields */ }

Public fields

fieldtype
maximum_glyphsusize
maximum_mask_bytesusizeUnique mask pixels plus one transparent guard byte per row.
maximum_glyph_extentu32

Trait implementations: Clone, Copy, Debug, Default

structaster_ui::TextFeature

pub struct TextFeature { /* see fields */ }

Methods

  • fn new(tag: &str, value: u32) -> Result<Self, Error>
  • fn tag(self) -> [u8; 4]
  • fn value(self) -> u32

Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq

structaster_ui::TextPosition

pub struct TextPosition { /* see fields */ }

Methods

  • fn source(self) -> SourceStamp
  • fn utf8_offset(self) -> usize

Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq

structaster_ui::TextRange

pub struct TextRange { /* see fields */ }

Ordered, scalar-boundary-valid UTF-8 range in exactly one source revision.

Methods

  • fn start(self) -> TextPosition
  • fn end(self) -> TextPosition
  • fn source(self) -> SourceStamp
  • fn utf8_offsets(self) -> std::ops::Range<usize>

Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq

structaster_ui::TextRasterScratch

pub struct TextRasterScratch { /* see fields */ }

Caller-owned reusable raster scratch for cold text preparation.

The scratch owns the private rasterizer workspace (outline buffer, path builder, flattener, fill and grayscale rasters, staging buffers) so that repeated preparations reuse one allocation set instead of one set per preparation. It borrows no font: the loaded face and the glyph registry are retained by shared ownership inside the rasterizer, so the scratch stays usable for the whole owner thread.

The scratch is a workspace, not a result cache: it never publishes its last rasterized key or image, never exposes a mutable view of its masks or caches and never hands out an identity of its own. Every prepared drawing still owns copied masks and a fresh drawing identity.

The scratch memory is separate from the per-drawing mask byte budget: TextDrawingLimits::maximum_mask_bytes bounds the masks a drawing owns, while the scratch owns its own bounded raster buffers. Pixel buffers grow to actual padded glyph boxes on demand, so preparation may allocate after scratch construction. Reuse does not promise allocation-free preparation.

Methods

  • fn new(font: &FontAsset, rasterization: TextRasterization, maximum_glyph_extent: u32) -> Result<Self, Error> — One reusable scratch for one font, one rasterization policy and one exact maximum glyph extent.
  • fn font(&self) -> FontId — The font this scratch was built for.
  • fn rasterization(&self) -> TextRasterization — The single rasterization policy this scratch may produce.
  • fn maximum_glyph_extent(&self) -> u32 — The exact maximum glyph extent this scratch may produce.

structaster_ui::TextSelection

pub struct TextSelection { /* see fields */ }

Methods

  • fn anchor(self) -> TextPosition
  • fn focus(self) -> TextPosition
  • fn range(self) -> TextRange

Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq

structaster_ui::TextShaper

pub struct TextShaper { /* see fields */ }

Bounded native scratch plus two public-output planes. Backend plan building may allocate; no zero-allocation shaping guarantee is inferred from capacity.

Methods

  • fn new(maximum_utf16: usize, maximum_glyphs: usize) -> Result<Self, Error> — Cold admission for up to 65,536 UTF-16 units and 65,536 output glyphs. This run budget is independent of document size and does not authorize arbitrary slicing across joining, grapheme or paragraph context.
  • fn run(&self) -> Result<ShapedRun<'_>, Error>
  • fn shape(&mut self, font: &FontAsset, source: TextSource<'_>, range: TextRange, options: RunOptions<'_>) -> Result<ShapedRun<'_>, Error>

structaster_ui::TextSource

pub struct TextSource<'a> { /* see fields */ }

Immutable borrow of accepted committed source. Cannot coexist with a document edit.

Methods

  • fn is_grapheme_boundary(self, position: TextPosition) -> Result<bool, Error> — Committed-source grapheme policy, independent of font-shaped clusters.
  • fn stamp(self) -> SourceStamp
  • fn text(self) -> &'a str
  • fn position(self, utf8_byte: usize) -> Result<TextPosition, Error>
  • fn range(self, start: usize, end: usize) -> Result<TextRange, Error>
  • fn slice(self, range: TextRange) -> Result<&'a str, Error>
  • fn position_from_utf16(self, offset: usize) -> Result<TextPosition, Error> — Strict native-service adapter: surrogate interiors/out-of-range offsets reject.
  • fn utf16_offset(self, position: TextPosition) -> Result<usize, Error>

Trait implementations: Clone, Copy

structaster_ui::VectorDiagnostics

pub struct VectorDiagnostics { /* see fields */ }

Public fields

fieldtype
preparationsu64
paintsu64
declared_tolerancef64
normalized_tolerancef32
last_curve_error_boundf64
last_arc_error_boundf64End-to-end geometric arc bound through placement, conics and f32 chords. Stroke coverage and subsequent raster-capture sampling are separate.

Trait implementations: Clone, Copy, Debug, Default, PartialEq, StructuralPartialEq

structaster_ui::VectorGeometry

pub struct VectorGeometry { /* see fields */ }

Methods

  • fn new(commands: &[VectorCommand], rule: VectorFillRule, command_budget: usize) -> Result<Self, Error> — Cold owned copy. At most 65,536 commands / 196,608 points / 4,096 contours. Open contours close implicitly for filling and remain open for stroking.
  • fn id(&self) -> VectorId
  • fn commands(&self) -> &[VectorCommand]
  • fn fill_rule(&self) -> VectorFillRule

Trait implementations: Debug

structaster_ui::VectorId

pub struct VectorId(..)

Trait implementations: Clone, Copy, Debug, Eq, Hash, PartialEq, StructuralPartialEq

structaster_ui::VectorLimits

pub struct VectorLimits { /* see fields */ }

Each generated plane has an explicit hard limit. Output row width is fixed by the Renderer; vector storage is separate from its pixel budget.

Public fields

fieldtype
commandsusize
edgesusize
contoursusize
stroke_piecesusize
stroke_primitivesusize
dash_stepsusize
curve_tolerancef64Device-space control-hull flatness; finite, >0 and <=0.25 pixels.

Trait implementations: Clone, Copy, Debug

structaster_ui::VectorStroke

pub struct VectorStroke { /* see fields */ }

Immutable logical stroke recipe. Width/dashes use the kernel's f32 precision.

Public fields

fieldtype
colorSrgb8

Methods

  • fn new(width: f32, alignment: VectorStrokeAlignment, cap: VectorCap, join: VectorJoin, miter_limit: f32, dashes: &[f32], offset: f32, color: Srgb8) -> Result<Self, Error>
  • fn solid(width: f32, color: Srgb8) -> Result<Self, Error>

Trait implementations: Clone, Debug, PartialEq, StructuralPartialEq

Enums

enumaster_ui::AnimationStatus

pub enum AnimationStatus { Running, Completed }

Whether the track has reached its end at the supplied elapsed time.

Variants

  • Running
  • Completed

Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq

enumaster_ui::Axis

pub enum Axis { Horizontal, Vertical }

Variants

  • Horizontal
  • Vertical

Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq

enumaster_ui::Clip

pub enum Clip { None, Bounds }

Rectangular final subtree clipping. General masks/rounded clips remain open.

Variants

  • None
  • Bounds

Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq

enumaster_ui::ColorProcessing

pub enum ColorProcessing { FastSrgb, LinearAccurate }

Variants

  • FastSrgb
  • LinearAccurate

Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq

enumaster_ui::EmitError

pub enum EmitError { QueueFull, UnadmittedFrame }

Why an emission was refused.

Variants

  • QueueFull — The bounded queue is at its declared capacity.
  • UnadmittedFrame — The payload is not the most recently accepted host frame.

Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq

enumaster_ui::Error

pub enum Error { InvalidGeometry, InvalidImage, InvalidOutput, Capacity, Allocation, IdentityExhausted, RevisionExhausted, Unpublished, RenderFailure, StaleNode, InvalidHierarchy, Cycle, DuplicateKey, Unsupported, StaleText, InvalidTextBoundary, CompositionActive, InvalidFont, InvalidTextStyle, MissingGlyph, ShapingFailure, LayoutRequired, LayoutNotConverged, FrameMismatch, StalePresentation, DuplicateBinding, NotInteractive, InvalidAnimation, InvalidEventKind, StaleFrame, EventQueueFull, BusClosed, ForeignPlugin, StalePlugin, PluginFailed }

Methods

  • const fn code(self) -> &'static str — Compact machine-readable identity, independent of diagnostic formatting.

Variants

  • InvalidGeometry
  • InvalidImage
  • InvalidOutput
  • Capacity
  • Allocation
  • IdentityExhausted
  • RevisionExhausted
  • Unpublished
  • RenderFailure
  • StaleNode
  • InvalidHierarchy
  • Cycle
  • DuplicateKey
  • Unsupported
  • StaleText
  • InvalidTextBoundary
  • CompositionActive
  • InvalidFont
  • InvalidTextStyle
  • MissingGlyph
  • ShapingFailure
  • LayoutRequired
  • LayoutNotConverged
  • FrameMismatch
  • StalePresentation
  • DuplicateBinding
  • NotInteractive
  • InvalidAnimation — An animation track, keyframe or elapsed time violated its declared policy.
  • InvalidEventKind — An event kind below the application extension range was used.
  • StaleFrame — A frame timestamp regressed, or repeated an accepted frame index.
  • EventQueueFull — The bounded event queue is at its declared capacity.
  • BusClosed — The event bus is closed and no longer accepts work.
  • ForeignPlugin — A plugin handle belongs to another event bus.
  • StalePlugin — A plugin handle refers to a retired plugin.
  • PluginFailed — A plugin callback or cleanup hook reported a failure code.

Trait implementations: Clone, Copy, Debug, Display, Eq, Error, From<Error>, From<ProgressError>, PartialEq, StructuralPartialEq

enumaster_ui::Event

pub enum Event { Frame, Extension }

One delivered event.

Events are Copy: the payload is a fixed four-word numeric array, never a pointer, never an owned string.

Methods

  • const fn kind(&self) -> EventKind — The kind of this event.
  • const fn frame(&self) -> Option<FrameEvent> — The frame event, if this is one.
  • const fn extension(&self) -> Option<(ExtensionKind, [u64; 4])> — The extension payload, if this is an extension event.

Variants

  • Frame — A host frame event.
  • Extension — An application extension event.

Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq

enumaster_ui::EventKind

pub enum EventKind { Frame, Extension }

The kind of an event a plugin can subscribe to.

Variants

  • Frame — The host frame event.
  • Extension — An application extension kind.

Trait implementations: Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd, StructuralPartialEq

enumaster_ui::EventPhase

pub enum EventPhase { Capture, Target, Bubble }

Variants

  • Capture
  • Target
  • Bubble

Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq

enumaster_ui::FontSlant

pub enum FontSlant { Normal, Italic, Oblique }

Slant already present in an explicitly loaded native font face.

Variants

  • Normal
  • Italic
  • Oblique

Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq

enumaster_ui::FrameSource

pub enum FrameSource { Recording, Scene, PreparedScene }

Methods

  • fn scene_stamp(self) -> Option<SceneStamp>

Variants

  • Recording
  • Scene
  • PreparedScene

Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq

enumaster_ui::GroupIsolation

pub enum GroupIsolation { Auto, Isolate }

Whole-subtree raster isolation, independently of its opacity.

Variants

  • Auto — Opacity below one creates a boundary; identity opacity stays flattened.
  • Isolate — Keep the boundary even at opacity one, including its common clip.

Trait implementations: Clone, Copy, Debug, Default, Eq, PartialEq, StructuralPartialEq

enumaster_ui::ImageAlpha

pub enum ImageAlpha { Straight, Premultiplied }

Variants

  • Straight
  • Premultiplied

Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq

enumaster_ui::ImageOrigin

pub enum ImageOrigin { TopLeft, BottomLeft }

Variants

  • TopLeft
  • BottomLeft

Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq

enumaster_ui::ImageSampling

pub enum ImageSampling { Nearest, Bilinear, Anisotropic }

Variants

  • Nearest
  • Bilinear
  • Anisotropic

Trait implementations: Clone, Copy, Debug, Eq, Hash, PartialEq, StructuralPartialEq

enumaster_ui::KeyCode

pub enum KeyCode { Tab, Enter, Escape, Backspace, Delete, Left, Right, Up, Down, Home, End, PageUp, PageDown, Space, Character, Other, ContextMenu }

Variants

  • Tab
  • Enter
  • Escape
  • Backspace
  • Delete
  • Left
  • Right
  • Up
  • Down
  • Home
  • End
  • PageUp
  • PageDown
  • Space
  • Character
  • Other
  • ContextMenu — The context-menu key (secondary button on a keyboard; NamedKey::ContextMenu).

Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq

enumaster_ui::KeyState

pub enum KeyState { Down, Up }

Variants

  • Down
  • Up

Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq

enumaster_ui::LayoutAlign

pub enum LayoutAlign { Start, Center, End, Stretch }

Variants

  • Start
  • Center
  • End
  • Stretch

Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq

enumaster_ui::LayoutLength

pub enum LayoutLength { Auto, Exact, Fill }

Variants

  • Auto
  • Exact
  • Fill

Trait implementations: Clone, Copy, Debug, PartialEq, StructuralPartialEq

enumaster_ui::Paint

pub enum Paint { Solid, Linear }

Variants

  • Solid
  • Linear

Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq

enumaster_ui::PointerButton

pub enum PointerButton { Primary, Secondary, Middle, Auxiliary }

Variants

  • Primary
  • Secondary
  • Middle
  • Auxiliary

Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq

enumaster_ui::PointerKind

pub enum PointerKind { Move, Down, Up, Cancel }

Variants

  • Move
  • Down
  • Up
  • Cancel

Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq

enumaster_ui::ReducedMotion

pub enum ReducedMotion { Keep, Instant }

Reduced-motion policy, authored when the animation is created.

Keep preserves the authored motion even when the host reports reduced motion; Instant presents the final value immediately instead.

Variants

  • Keep
  • Instant

Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq

enumaster_ui::RepeatPolicy

pub enum RepeatPolicy { Once, Times }

Finite repeat policy. Infinite repetition is deliberately absent.

Methods

  • fn count(self) -> u32

Variants

  • Once — The track plays exactly once.
  • Times — The track plays n times in total; n must be at least one.

Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq

enumaster_ui::RunDirection

pub enum RunDirection { LeftToRight, RightToLeft }

Variants

  • LeftToRight
  • RightToLeft

Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq

enumaster_ui::TextChangeKind

pub enum TextChangeKind { Text, Selection, Composition }

Variants

  • Text
  • Selection
  • Composition

Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq

enumaster_ui::TextMovement

pub enum TextMovement { PreviousGrapheme, NextGrapheme, PreviousWord, NextWord, LineStart, LineEnd, DocumentStart, DocumentEnd }

Variants

  • PreviousGrapheme
  • NextGrapheme
  • PreviousWord
  • NextWord
  • LineStart
  • LineEnd
  • DocumentStart
  • DocumentEnd

Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq

enumaster_ui::TextRasterization

pub enum TextRasterization { PixelMask, Subpixel8x8, SubpixelX4, AreaX4 }

Explicit outline phase preparation. This does not enable hinting or LCD color AA.

Variants

  • PixelMask — Existing phase-zero masks and legacy bitmap positioning.
  • Subpixel8x8 — 64 independently rasterized outline phases. Paint quantizes each device origin to the nearest eighth pixel (at most 1/16 pixel error per axis). Cold preparation and mask storage can grow by roughly 64 times. Uses fine grayscale span coverage with 64 vertical midpoint samples and 0.01 device-pixel curve flattening. This is unhinted grayscale, not LCD color subpixels or exact analytic curve integration.
  • SubpixelX4 — Tuned text: four independently rasterized horizontal outline phases (quarter pixels, the baseline on a whole device pixel), so a line of text has even stems wherever its glyphs fall, at four times the masks of PixelMask (not sixty-four). Stem darkening of the small sizes is baked into the masks, and the coverage is blended through a curve chosen by the luminance of the ink (linear-light blending with a contrast boost). Unhinted grayscale, like Subpixel8x8.
  • AreaX4 — The blueprint default: the quarter-pixel placement of SubpixelX4 with exact-area coverage, light vertical fitting (the x-height on whole pixels up to 24 device px) and, instead of stem darkening and the linear-light curve, a contrast curve for light ink only (dark ink blends its exact coverage unchanged).

Trait implementations: Clone, Copy, Debug, Default, Eq, PartialEq, StructuralPartialEq

enumaster_ui::VectorCap

pub enum VectorCap { Butt, Round, Square }

Variants

  • Butt
  • Round
  • Square

Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq

enumaster_ui::VectorCommand

pub enum VectorCommand { MoveTo, LineTo, QuadraticTo, CubicTo, ArcTo, Close }

Logical f64 source coordinates are retained until each output preflight.

Variants

  • MoveTo
  • LineTo
  • QuadraticTo
  • CubicTo
  • ArcTo
  • Close

Trait implementations: Clone, Copy, Debug, PartialEq, StructuralPartialEq

enumaster_ui::VectorFillRule

pub enum VectorFillRule { NonZero, EvenOdd }

Variants

  • NonZero
  • EvenOdd

Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq

enumaster_ui::VectorJoin

pub enum VectorJoin { Miter, Bevel, Round }

Variants

  • Miter
  • Bevel
  • Round

Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq

enumaster_ui::VectorStrokeAlignment

pub enum VectorStrokeAlignment { Center, Inner, Outer }

Variants

  • Center
  • Inner
  • Outer

Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq

Traits

traitaster_ui::Plugin

pub trait Plugin

An application plugin.

on_event runs on the owner thread during dispatch. Returning an error disables this plugin and leaves its peers untouched; the failure is reported in [DispatchReport]. A panic is not caught: it propagates to the host instead of being reported as a successful frame.

Required and provided methods

  • fn on_event(&mut self, event: &Event, out: &mut EventEmitter<'_>) -> Result<(), PluginError> — Handle one delivered event.
  • fn on_remove(&mut self) -> Result<(), PluginError> — Owner-thread cleanup before retirement.

Functions

fnaster_ui::host_parallelism

pub fn host_parallelism() -> usize

The host's thread count: the [set_host_parallelism] value if set, else std::thread::available_parallelism, else 1.

fnaster_ui::set_default_raster_threads

pub fn set_default_raster_threads(workers: usize)

Process-wide default for [Renderer::set_raster_threads] on renderers created afterwards (0 = auto, 1 = serial). Pixels never depend on it; it exists for tests and benchmarks.

fnaster_ui::set_host_parallelism

pub fn set_host_parallelism(threads: usize)

Tell Aster how many threads the host can really run (0 = ask the OS). Targets whose std cannot report it (wasm32-wasip1-threads in a browser: available_parallelism is unsupported there) set it once, before the first frame, so every internal worker pool (bands, fx, cuts, bakes) can use the Workers the page gave it. Pixels never depend on it.

Constants

constaster_ui::MAX_BOUNDS_KEYFRAMES

pub const MAX_BOUNDS_KEYFRAMES: usize

Maximum number of keyframes admitted in one bounds track.

constaster_ui::MIN_EXTENSION_KIND

pub const MIN_EXTENSION_KIND: u64

Lowest event kind an application may own.

Kinds below this value belong to the runtime and are rejected here, so an application extension can never collide with an internal kind.