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
| field | type | |
|---|---|---|
nodes | usize | Maximum scene slot capacity, including currently empty admitted slots. |
source_pixels | usize | Maximum private source area; two RGBA8 renderer planes are separate. |
source_commands | usize | |
retained_bytes | usize | Sum of retained raster image payload lengths, not all heap metadata. |
mask_bytes | usize | Sum of full-output u16 sample-mask payloads. |
vectors | Option<VectorLimits> | |
sampling | ImageSampling | Explicit 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
| field | type | |
|---|---|---|
bounds | super::LogicalRect | |
status | AnimationStatus |
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
| field | type | |
|---|---|---|
changed | bool | True when the target description actually changed. |
bounds | super::LogicalRect | |
status | AnimationStatus |
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) -> f64fn repeat(&self) -> RepeatPolicyfn reduced_motion(&self) -> ReducedMotionfn total_duration(&self) -> f64— Total elapsed time covered by the track, including repeats.fn keyframe_count(&self) -> usizefn 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) -> usizefn 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>—timeis 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) -> f64fn bounds(&self) -> LogicalRectfn easing(&self) -> Easing
Trait implementations: Clone, Copy, Debug, PartialEq, StructuralPartialEq
structaster_ui::CapturedPointer
pub struct CapturedPointer { /* see fields */ }Public fields
| field | type | |
|---|---|---|
pointer | PointerId | |
target | InteractionTarget |
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
| field | type | |
|---|---|---|
events | usize | Events taken from the queue. |
callbacks | usize | Plugin callbacks invoked. |
failures | usize | Plugin callbacks that reported an error during this pass. |
last_failure | Option<PluginFailure> | The most recent plugin failure observed by this bus. |
pending | usize | Events still queued after this pass. |
rejected_total | u64 | Lifetime 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
| field | type | |
|---|---|---|
kind | TextChangeKind | |
revision | DocumentRevision | |
previous_source | SourceStamp | |
source | SourceStamp | |
replaced | TextRange | Old-source replacement range; meaningful for Text changes only. |
inserted_bytes | usize | |
selection | TextSelection |
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
| field | type | |
|---|---|---|
stop_propagation | bool | |
prevent_default | bool |
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
| field | type | |
|---|---|---|
previous | Option<InteractionTarget> | |
current | Option<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) -> FontIdfn native_weight(&self) -> u16fn native_slant(&self) -> FontSlantfn 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
| field | type | |
|---|---|---|
ascent | f64 | |
descent | f64 | |
line_gap | f64 | |
underline_position | f64 | |
underline_thickness | f64 |
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) -> Outputfn stride_bytes(&self) -> usizefn 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) -> Outputfn 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) -> OutputIdfn revision(self) -> u64fn frame_index(self) -> u64fn source(self) -> FrameSourcefn 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 mostmaximum_masksmasks of at mostmaximum_bytesmask 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) -> NodeIdfn 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) -> usizefn storage_bytes(self) -> usize— Last row requires only its active pixels, not trailing padding.fn alpha(self) -> ImageAlphafn 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) -> ImageIdfn descriptor(&self) -> ImageDescriptorfn 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) -> usizefn 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) -> usizefn 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) -> usizefn 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) -> Selffn focusable(node: NodeId, tab_order: Option<u32>) -> Selffn with_pointer(self, enabled: bool) -> Selffn node(self) -> NodeIdfn accepts_pointer(self) -> boolfn accepts_focus(self) -> boolfn 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) -> NodeIdfn model_key(self) -> Option<ModelKey>
Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq
structaster_ui::KeyDispatch
pub struct KeyDispatch { /* see fields */ }Public fields
| field | type | |
|---|---|---|
route | RouteOutcome | |
focus | Option<FocusChange> |
Trait implementations: Clone, Copy, Debug, Default, Eq, PartialEq, StructuralPartialEq
structaster_ui::KeyEvent
pub struct KeyEvent { /* see fields */ }Public fields
| field | type | |
|---|---|---|
code | KeyCode | |
state | KeyState | |
modifiers | KeyModifiers |
Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq
structaster_ui::KeyModifiers
pub struct KeyModifiers { /* see fields */ }Public fields
| field | type | |
|---|---|---|
shift | bool | |
control | bool | |
alt | bool | |
meta | bool |
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) -> usizefn managed_nodes(self) -> usizefn 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() -> Selffn overlay() -> Selffn stack(axis: Axis, gap: f64) -> Result<Self, Error>fn wrap(axis: Axis, item_gap: f64, line_gap: f64) -> Result<Self, Error>— Wrapping flow alongaxis: items fill one line and overflow to the next line.item_gapseparates items inside a line,line_gapseparates 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 alongaxis: children keep a basis taken from their ownExactorAutosizing and share or surrender the free space of the container by their grow and shrink controls.gapmust 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
| field | type | |
|---|---|---|
0 | u128 |
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) -> Selffn animation(&self) -> &BoundsAnimationfn 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) -> Selffn painted(bounds: LogicalRect, paint: Paint) -> Selffn 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) -> Selffn with_key(self, key: ModelKey) -> Selffn 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) -> BlendModefn with_bounds(self, bounds: LogicalRect) -> Selffn with_corner_radius(self, radius: f64) -> Result<Self, Error>fn bounds(&self) -> LogicalRectfn 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) -> f64fn 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
| field | type | |
|---|---|---|
0 | u32 |
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
| field | type | |
|---|---|---|
handle | PluginHandle | The plugin that failed. |
code | u32 | The 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
| field | type | |
|---|---|---|
route | RouteOutcome | |
focus | Option<FocusChange> | |
released_capture | Option<CapturedPointer> |
Trait implementations: Clone, Copy, Debug, Default, Eq, PartialEq, StructuralPartialEq
structaster_ui::PointerEvent
pub struct PointerEvent { /* see fields */ }Public fields
| field | type | |
|---|---|---|
pointer | PointerId | |
kind | PointerKind | |
position | DevicePoint |
Trait implementations: Clone, Copy, Debug, PartialEq, StructuralPartialEq
structaster_ui::PointerId
pub struct PointerId(..)Public fields
| field | type | |
|---|---|---|
0 | u64 |
Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq
structaster_ui::PreparationStats
pub struct PreparationStats { /* see fields */ }Public fields
| field | type | |
|---|---|---|
source_captures | usize | |
source_reuses | usize | |
mask_builds | usize | |
mask_reuses | usize | |
group_captures | usize | |
group_reuses | usize |
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) -> PreparedSceneIdfn scene_stamp(&self) -> SceneStampfn output(&self) -> Outputfn layer_count(&self) -> usizefn 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
| field | type | |
|---|---|---|
presentation | Option<PresentationId> | |
focus | Option<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
| field | type | |
|---|---|---|
node | NodeId | |
model_key | Option<ModelKey> | |
parent | Option<NodeId> | |
bounds | super::LogicalRect | |
paint_map | transform::Affine2D | |
interactive | bool |
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 (defaultSourceOver). 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) -> RecordingIdfn 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
| field | type | |
|---|---|---|
rasterizations | u64 | |
reused_frames | u64 | |
partial_rasterizations | u64 | |
layered_rasterizations | u64 | Frames drawn as a retained base layer plus a repainted full-screen overlay. |
banded_rasterizations | u64 | Frames 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_repaints | u64 | Incremental region repaints (frame or retained base layer) shared across band workers. |
accelerated_rasterizations | u64 | Full renders drawn by an installed [accel::RasterAccelerator]. |
accelerator_fallbacks | u64 | Full 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_budgetis a ceiling, not a reservation; usewith_output_capacityfor 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 withNoneremove) 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) -> boolfn 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>— Rendersceneas an update ofprevious, the scene this renderer's last accepted frame was drawn from with the sameclear. 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 exactlyrender_scene.fn diagnostics(&self) -> RenderDiagnosticsfn 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
| field | type | |
|---|---|---|
visits | usize | |
default_prevented | bool |
Trait implementations: Clone, Copy, Debug, Default, Eq, PartialEq, StructuralPartialEq
structaster_ui::RoutedKey
pub struct RoutedKey { /* see fields */ }Public fields
| field | type | |
|---|---|---|
presentation | PresentationId | |
frame | FrameReceipt | |
phase | EventPhase | |
target | NodeId | |
current | NodeId | |
model_key | Option<ModelKey> | |
event | KeyEvent |
Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq
structaster_ui::RoutedPointer
pub struct RoutedPointer { /* see fields */ }Public fields
| field | type | |
|---|---|---|
presentation | PresentationId | |
frame | FrameReceipt | |
phase | EventPhase | |
target | NodeId | |
current | HitTarget | |
event | PointerEvent |
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) -> usizefn reserved_bytes(&self) -> usizefn 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) -> TextPositionfn 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
| field | type | |
|---|---|---|
logical_size | f64 | |
direction | RunDirection | |
script | Option<[u8; 4]> | |
language | Option<&'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) -> boolfn 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) -> boolfn 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) -> SceneStampfn node_count(&self) -> usizefn command_count(&self) -> usizefn 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
| field | type | |
|---|---|---|
retained_pixel_bytes | usize | Retained RGBA8 captures plus u16 masks, excluding metadata/source leases. |
transaction_pixel_bytes | usize | Conservative 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
| field | type | |
|---|---|---|
groups | usize | |
working_pixels | usize | One reusable full-output RGBA8 working plane, in physical pixels. |
retained_bytes | usize | Conservative 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) -> usizefn 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) -> u32fn source(self) -> TextRangefn 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) -> ShapingStampfn font(&self) -> FontIdfn source(&self) -> SourceStampfn source_range(&self) -> TextRangefn logical_size(&self) -> f64— Actual resolved f32 native size, represented as f64 logical pixels.fn direction(&self) -> RunDirectionfn advance_width(&self) -> f64fn metrics(&self) -> FontMetricsfn 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: Selfconst fn rgba(r: u8, g: u8, b: u8, a: u8) -> Selfconst 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) -> DocumentRevisionfn selection(&self) -> TextSelectionfn selected_text(&self) -> &strfn 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) -> TextDrawingIdfn font(&self) -> FontIdfn source(&self) -> SourceStampfn source_range(&self) -> TextRangefn logical_size(&self) -> f64fn output_scale(&self) -> f64fn metrics(&self) -> FontMetricsfn glyph_count(&self) -> usizefn unique_glyph_count(&self) -> usizefn rasterization(&self) -> TextRasterizationfn prepared_mask_count(&self) -> usizefn mask_storage_bytes(&self) -> usizefn 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
| field | type | |
|---|---|---|
maximum_glyphs | usize | |
maximum_mask_bytes | usize | Unique mask pixels plus one transparent guard byte per row. |
maximum_glyph_extent | u32 |
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) -> SourceStampfn 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) -> TextPositionfn end(self) -> TextPositionfn source(self) -> SourceStampfn 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) -> TextPositionfn focus(self) -> TextPositionfn 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) -> SourceStampfn text(self) -> &'a strfn 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
| field | type | |
|---|---|---|
preparations | u64 | |
paints | u64 | |
declared_tolerance | f64 | |
normalized_tolerance | f32 | |
last_curve_error_bound | f64 | |
last_arc_error_bound | f64 | End-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) -> VectorIdfn 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
| field | type | |
|---|---|---|
commands | usize | |
edges | usize | |
contours | usize | |
stroke_pieces | usize | |
stroke_primitives | usize | |
dash_steps | usize | |
curve_tolerance | f64 | Device-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
| field | type | |
|---|---|---|
color | Srgb8 |
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
RunningCompleted
Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq
enumaster_ui::Axis
pub enum Axis { Horizontal, Vertical }Variants
HorizontalVertical
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
NoneBounds
Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq
enumaster_ui::ColorProcessing
pub enum ColorProcessing { FastSrgb, LinearAccurate }Variants
FastSrgbLinearAccurate
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
InvalidGeometryInvalidImageInvalidOutputCapacityAllocationIdentityExhaustedRevisionExhaustedUnpublishedRenderFailureStaleNodeInvalidHierarchyCycleDuplicateKeyUnsupportedStaleTextInvalidTextBoundaryCompositionActiveInvalidFontInvalidTextStyleMissingGlyphShapingFailureLayoutRequiredLayoutNotConvergedFrameMismatchStalePresentationDuplicateBindingNotInteractiveInvalidAnimation— 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
CaptureTargetBubble
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
NormalItalicOblique
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
RecordingScenePreparedScene
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
StraightPremultiplied
Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq
enumaster_ui::ImageOrigin
pub enum ImageOrigin { TopLeft, BottomLeft }Variants
TopLeftBottomLeft
Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq
enumaster_ui::ImageSampling
pub enum ImageSampling { Nearest, Bilinear, Anisotropic }Variants
NearestBilinearAnisotropic
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
TabEnterEscapeBackspaceDeleteLeftRightUpDownHomeEndPageUpPageDownSpaceCharacterOtherContextMenu— 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
DownUp
Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq
enumaster_ui::LayoutAlign
pub enum LayoutAlign { Start, Center, End, Stretch }Variants
StartCenterEndStretch
Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq
enumaster_ui::LayoutLength
pub enum LayoutLength { Auto, Exact, Fill }Variants
AutoExactFill
Trait implementations: Clone, Copy, Debug, PartialEq, StructuralPartialEq
enumaster_ui::Paint
pub enum Paint { Solid, Linear }Variants
SolidLinear
Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq
enumaster_ui::PointerButton
pub enum PointerButton { Primary, Secondary, Middle, Auxiliary }Variants
PrimarySecondaryMiddleAuxiliary
Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq
enumaster_ui::PointerKind
pub enum PointerKind { Move, Down, Up, Cancel }Variants
MoveDownUpCancel
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
KeepInstant
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 playsntimes in total;nmust be at least one.
Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq
enumaster_ui::RunDirection
pub enum RunDirection { LeftToRight, RightToLeft }Variants
LeftToRightRightToLeft
Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq
enumaster_ui::TextChangeKind
pub enum TextChangeKind { Text, Selection, Composition }Variants
TextSelectionComposition
Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq
enumaster_ui::TextMovement
pub enum TextMovement { PreviousGrapheme, NextGrapheme, PreviousWord, NextWord, LineStart, LineEnd, DocumentStart, DocumentEnd }Variants
PreviousGraphemeNextGraphemePreviousWordNextWordLineStartLineEndDocumentStartDocumentEnd
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 ofPixelMask(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, likeSubpixel8x8.AreaX4— The blueprint default: the quarter-pixel placement ofSubpixelX4with 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
ButtRoundSquare
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
MoveToLineToQuadraticToCubicToArcToClose
Trait implementations: Clone, Copy, Debug, PartialEq, StructuralPartialEq
enumaster_ui::VectorFillRule
pub enum VectorFillRule { NonZero, EvenOdd }Variants
NonZeroEvenOdd
Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq
enumaster_ui::VectorJoin
pub enum VectorJoin { Miter, Bevel, Round }Variants
MiterBevelRound
Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq
enumaster_ui::VectorStrokeAlignment
pub enum VectorStrokeAlignment { Center, Inner, Outer }Variants
CenterInnerOuter
Trait implementations: Clone, Copy, Debug, Eq, PartialEq, StructuralPartialEq
Traits
traitaster_ui::Plugin
pub trait PluginAn 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() -> usizeThe 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: usizeMaximum number of keyframes admitted in one bounds track.
constaster_ui::MIN_EXTENSION_KIND
pub const MIN_EXTENSION_KIND: u64Lowest 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.