README- UControlledValue
- UEffect
- UEnvironment
- UFeature
- UFocusRequest
- UProgram
- UProgramCommand
- UScopedFeature
- UScrollRequest
- USemanticId
- USubscription
- UTheme
- UView
- UViewEnvironment
wzzc-dev/moui/core does not have a README file
TextGraphemeBoundaries
The grapheme boundary scanner, backed by the Unicode 17.0 property table.
ViewNode
pub(open) trait ViewNode {
fn identity(Self) -> ViewIdentity
fn declaration(Self) -> ViewDeclaration = _
fn child_constraints(Self, Constraints) -> Constraints = _
fn child_environment(Self, Environment) -> Environment = _
fn child_style(Self, ViewStyle) -> ViewStyle = _
fn layout(Self, ViewLayoutContext) -> ViewLayoutResult
fn place_overlays(Self, OverlayPlacementContext) -> Array[(Int, Rect)]? = _
fn paint(Self, ViewPaintContext) -> ViewPaintPlan = _
fn platform_views(Self, ViewPlatformContext) -> Array[PlatformViewPlacement] = _
fn text_input_state(Self, ViewPaintContext) -> TextInputState? = _
fn semantics(Self) -> ViewSemanticsInfo = _
fn focusable(Self) -> Bool = _
fn focus_trap(Self) -> Bool = _
fn keyboard_policy(Self) -> KeyboardPolicy = _
fn flex_weight(Self) -> Double = _
}Message-independent behavior for a low-level custom view node.
The trait is open so downstream packages can define renderer-neutral
controls. Typed children and messages are attached with View::from_node.
identity controls element reuse: equal identities preserve transient
runtime control state, while a changed kind or key remounts the element.
declaration classifies immutable declaration data independently for
layout, paint, semantics, and platform work. Its conservative default marks
every channel uncacheable; performance-sensitive nodes opt into exact or
constant channels explicitly. Application state belongs in the TEA model
and transient interaction state belongs in runtime-owned element state
exposed through the typed adapters.
ViewStateValue
pub(open) trait ViewStateValue {
fn view_state_type_key() -> DeclarationKey
fn encode_view_state(Self) -> Bytes
fn decode_view_state(Self, Bytes) -> Self?
}A value that can be stored in a runtime-owned view-state slot.
The type key is part of slot identity, so two slots with the same logical
key but different value types cannot alias. Implementations must use a
stable, versioned type key and an exact, deterministic byte encoding.
impl ViewStateValue for Boolfn decode_view_state(_self : Bool, bytes : Bytes) -> Bool?fn encode_view_state(self : Bool) -> Bytesimpl ViewStateValue for Intfn decode_view_state(_self : Int, bytes : Bytes) -> Int?fn encode_view_state(self : Int) -> Bytesimpl ViewStateValue for Doublefn decode_view_state(_self : Double, bytes : Bytes) -> Double?fn encode_view_state(self : Double) -> Bytesimpl ViewStateValue for Stringfn decode_view_state(_self : String, bytes : Bytes) -> String?fn encode_view_state(self : String) -> Bytesimpl ViewStateValue for Bytesfn decode_view_state(_self : Bytes, bytes : Bytes) -> Bytes?fn encode_view_state(self : Bytes) -> BytesAccessibilityContrast
AccessibilityContrast::equal
AccessibilityContrast::not_equal
AccessibilityContrast::to_json
AccessibilityContrast::to_repr
AccessibilityLabelModifier
pub(all) struct AccessibilityLabelModifier {
label : String
}AccessibilityLabelModifier::to_any_modifier
fn[Msg] AccessibilityLabelModifier::to_any_modifier(self : AccessibilityLabelModifier) -> AnyModifier[Msg]ActionCommand
pub(all) struct ActionCommand {
intent : CommandIntent
shortcut : KeyboardShortcut?
label : String
enabled : Bool
group : String
description : String
context_menu : Bool
} derive(Eq, ToJson, Debug)ActionCommand::matches
ActionCommand::new
fn ActionCommand::new(intent~ : CommandIntent, label? : String, shortcut? : KeyboardShortcut?, enabled? : Bool, group? : String, description? : String, context_menu? : Bool) -> ActionCommandActionCommand::not_equal
ActionCommandMap
type ActionCommandMapActionCommandMap::commands
ActionCommandMap::dispatch_command
ActionCommandMap::dispatch_intent
ActionCommandMap::dispatch_shortcut
fn ActionCommandMap::dispatch_shortcut(self : ActionCommandMap, event : KeyboardEvent) -> CommandIntent?ActionCommandMap::find_shortcut
fn ActionCommandMap::find_shortcut(self : ActionCommandMap, event : KeyboardEvent) -> ActionCommand?ActionCommandMap::new
AlignModifier
AlignModifier::to_any_modifier
Alignment
AlignmentGuideSet
AlignmentGuideSet::equal
AlignmentGuideSet::from_size
AlignmentGuideSet::not_equal
AnimationStatus
AnimationStatus::not_equal
AnyModifier
pub(all) struct AnyModifier[Msg] {
identity_kind : String
identity_key : Key?
declaration : ViewDeclaration
child_constraints : (Constraints) -> Constraints
child_environment : (Environment) -> Environment
child_style : (ViewStyle) -> ViewStyle
layout : (ViewLayoutContext) -> ViewLayoutResult
paint : (ViewPaintContext) -> ViewPaintPlan
event : (ViewEventContext) -> ViewEventResult[Msg]
semantics : ViewSemanticsInfo
semantics_actions : Array[ViewSemanticsActionHandler[Msg]]
focusable : Bool
focus_trap : Bool
flex_weight : Double
}A type-erased modifier that dispatches to concrete modifier implementations
via closures. Replaces the 50-variant ViewModifier[Msg] enum.
Each concrete modifier (Padding, Frame, Background, OnTap, etc.) is a
standalone type that implements the subset of modifier behavior it needs
and converts to AnyModifier via a to_any_modifier method.
AppEvent
pub(all) enum AppEvent {
FrameTick(Frame)
Pointer(PointerEvent)
Keyboard(KeyboardEvent)
TextInput(TextInputEvent)
DragDrop(DragDropEvent)
PlatformView(String, PlatformViewEvent)
Resize(Size)
Redraw(RedrawReason)
CloseRequested
} derive(Eq, ToJson, Debug)AspectRatioModifier
pub(all) struct AspectRatioModifier {
ratio : Double
}AspectRatioModifier::to_any_modifier
Axis
BackgroundModifier
BackgroundModifier::to_any_modifier
BlendMode
BorderModifier
BorderModifier::to_any_modifier
BorderStyle
Brush
pub(all) enum Brush {
Solid(Color)
LinearGradient(LinearGradientSpec)
RadialGradient(RadialGradientSpec)
} derive(Eq, ToJson, Debug)Brush::linear_gradient
Brush::radial_gradient
ChildLayoutInfo
pub(all) struct ChildLayoutInfo {
size : Size
first_baseline : Double?
priority : Double
alignment_guides : AlignmentGuideSet
flex_weight : Double
} derive(Eq, Debug)Layout-side metadata for a single child of a custom children layout.
Replaces the previous parallel arrays (child_sizes, child_baselines,
child_priorities, child_alignment_guides) with a single, typed record
per child. The runtime fills this from the measured/placed child element,
so custom layouts no longer have to rely on guessed baseline values or
hard-coded priorities.
ChildLayoutInfo::baseline_or_estimate
Convenience accessor: the child's resolved baseline, falling back to the
historical size.height * 0.8 estimate when the child does not expose one.
Keeping the fallback here lets custom layouts stop special-casing the
"no baseline" branch while still preserving prior behavior for children
that genuinely lack a baseline.
ChildLayoutInfo::new
fn ChildLayoutInfo::new(size~ : Size, first_baseline? : Double?, priority? : Double, flex_weight? : Double) -> ChildLayoutInfoConstruct a ChildLayoutInfo from measured child data. The runtime uses
this when assembling CustomLayoutContext.children; downstream packages
use it when building tests for custom layout delegates.
ChildLayoutInfo::not_equal
ClipModifier
pub(all) struct ClipModifier {
}ClipModifier::to_any_modifier
Color
Color::darken
Blend this color toward black by amount (clamped to 0..1). Useful for
deriving press/active shades from a base palette color.
Color::lerp
Linearly interpolate between this color and other by t (clamped to
0..1). t = 0 returns self, t = 1 returns other. Used to derive
hover/press shades and drive color transitions without a full animation
pipeline.
Color::lighten
Blend this color toward white by amount (clamped to 0..1). Useful for
deriving hover shades from a base palette color.
Color::mix
Alias of Color::lerp with the conventional weight naming: a weight
of 0.0 keeps self, 1.0 fully adopts other.
ColorMode
Color mode: force light, force dark, or follow the system.
ColorPalette
pub(all) struct ColorPalette {
foreground : Color
background : Color
surface : Color
surface_variant : Color
primary : Color
on_primary : Color
primary_container : Color
on_primary_container : Color
secondary : Color
on_secondary : Color
secondary_container : Color
on_secondary_container : Color
tertiary : Color
on_tertiary : Color
tertiary_container : Color
on_tertiary_container : Color
error : Color
on_error : Color
error_container : Color
on_error_container : Color
on_foreground : Color
on_surface : Color
on_surface_variant : Color
outline : Color
outline_variant : Color
muted : Color
success : Color
on_success : Color
warning : Color
on_warning : Color
info : Color
on_info : Color
danger : Color
on_danger : Color
focus : Color
scrim : Color
} derive(Eq, ToJson, Debug)Full semantic color palette. Extended from the original 8-role palette to
the complete on*/container matrix used by Material 3 / Fluent 2 so a
branded design system can express primary/secondary/tertiary/error
container pairs and their on-colors instead of deriving them ad hoc with
multiply_alpha/lerp. Semantic colors (success/warning/danger/info) are
folded in directly; the separate SemanticColorScale is removed.
Role naming follows Compose Material 3 ColorScheme:
- on_<role> is the text/icon color drawn on top of <role>.
- <role>_container is a tinted surface variant; on_<role>_container is the text color on that container. on_foreground is an explicit alias of background for symmetry.
ColorPalette::dark
Minimal dark palette (zinc neutrals, near-white primary). Mirrors light.
ColorPalette::from_seed
fn ColorPalette::from_seed(primary~ : Color, scheme : ColorScheme, foreground? : Color, background? : Color, surface? : Color, surface_variant? : Color, outline? : Color, muted? : Color) -> ColorPaletteBuild a palette from a primary color and scheme, deriving every on*/container
role programmatically. This is the shared derivation used by both the
Minimal preset and (optionally) branded addons that want a seed-driven
palette without hand-writing 30+ colors.
Derivation rules:
- on_primary/on_secondary/on_tertiary/on_error = white on dark primaries, near-black on light primaries (contrast-aware).
- <role>_container = the role color lerped toward the surface by ~0.85 (a soft tint); on_<role>_container = the role color darkened (light) or lightened (dark) for legibility on the tint.
- secondary/tertiary default to a desaturated primary analog so the palette stays coherent when only a seed is supplied.
ColorPalette::light
Minimal light palette (zinc neutrals, near-black primary). Equivalent to
the legacy hand-written palette but now fills the full on*/container matrix
via from_seed.
ColorScheme
CommandBinding
type CommandBindingCommandBinding::new
CommandIntent
CommandIntent::not_equal
CompositionUpdate
CompositionUpdate::equal
CompositionUpdate::new
CompositionUpdate::not_equal
Constraints
Constraints::deflate
Constraints::tighten
ContentSizeCategory
ContentSizeCategory::equal
ContentSizeCategory::not_equal
ContentSizeCategory::text_scale
ControlledValue
pub struct ControlledValue[T, Msg] {
// private fields
}Immutable controlled input for composite controls.
The current value is a snapshot from the application model. User
interaction can only construct a typed message; the control has no setter
or mutable model capability.
ControlledValue::changed
ControlledValue::new
CornerRadiusModifier
pub(all) struct CornerRadiusModifier {
radius : Double
}CornerRadiusModifier::to_any_modifier
CrossAxisAlignment
CrossAxisAlignment::equal
CrossAxisAlignment::not_equal
CrossAxisAlignmentModifier
CrossAxisAlignmentModifier::to_any_modifier
fn[Msg] CrossAxisAlignmentModifier::to_any_modifier(_self : CrossAxisAlignmentModifier) -> AnyModifier[Msg]CustomLayoutContext
pub(all) struct CustomLayoutContext {
constraints : Constraints
children : Array[ChildLayoutInfo]
layout_direction : LayoutDirection
safe_area : Insets
viewport : Size?
}Layout context for a custom children-layout delegate. The runtime measures
each child first, then hands the resulting children array (plus the
ambient environment, viewport and reading direction) to the delegate's
measure callback.
The previous API exposed cache / cache_key and several parallel arrays
(child_sizes, child_baselines, …). The cache was mutable state stored
on the immutable declaration node (a violation of view_node.mbt's contract)
and the parallel arrays made it easy to read the wrong index. Both are gone
in favor of children : Array[ChildLayoutInfo].
CustomPlacementContext
pub(all) struct CustomPlacementContext {
frame : Rect
measured_size : Size
children : Array[ChildLayoutInfo]
layout_direction : LayoutDirection
safe_area : Insets
viewport : Size?
}Placement context handed to a custom children-layout delegate's place
callback. children mirrors the order of CustomLayoutContext.children;
the delegate returns one Rect per child in that same order.
CustomPlacementContext::mirror_x
fn CustomPlacementContext::mirror_x(self : CustomPlacementContext, x~ : Double, width~ : Double) -> DoubleMirror an LTR x coordinate into the RTL frame. Layout authors should pass
every child x through this helper so a single placement routine works in
both reading directions.
DamageRegion
DamageRegion::from_rects
DamageRegion::union_with
fn DamageRegion::union_with(self : DamageRegion, other : DamageRegion, surface~ : Rect) -> DamageRegionMerge a newly computed damage region into one already accumulated for the
frame being built. The runtime can paint more than once between two
presented frames (event handling runs ensure_render_tree), and every
painted change must reach the renderer, so the shipped damage is the union
across all paints since the last frame build.
DateValue
DateValue::new
DeclarationChanges
Effective changes between two declarations.
A layout change always implies paint, semantics, and platform changes.
DeclarationChanges::equal
DeclarationChanges::is_clean
DeclarationChanges::not_equal
DeclarationChanges::platform
DeclarationChanges::semantics
DeclarationChannel
Cache behavior for one declaration channel.
DeclarationChannel::equal
DeclarationChannel::not_equal
DeclarationKey
An immutable, canonical declaration identity.
Keys compare their complete encoded bytes. Hashing is only an acceleration
used by hashed containers before exact equality; it is not identity.
DeclarationKey::array
Builds an ordered array key from complete child keys.
DeclarationKey::bool
Builds a key for a boolean value.
DeclarationKey::bytes
Builds a key from immutable bytes.
DeclarationKey::double
Builds a bit-exact IEEE-754 key. This distinguishes signed zero and NaN
payloads as well as adjacent finite values.
DeclarationKey::int
Builds a key for an exact signed 32-bit Int value.
DeclarationKey::int64
Builds a key for an exact signed 64-bit integer value.
DeclarationKey::not_equal
DeclarationKey::option
Builds an option key. Presence and the complete child key are framed.
DeclarationKey::record
fn DeclarationKey::record(type_tag~ : String, fields~ : Array[(String, DeclarationKey)]) -> DeclarationKeyBuilds a record key. type_tag identifies the declared record type;
fields are encoded in the supplied declaration order, including each field
name and complete child key.
DeclarationKey::string
Builds a key from the value's exact UTF-8 encoding without a BOM.
DeclarationKey::uint
Builds a key for an exact unsigned 32-bit UInt value.
DeclarationKey::uint64
Builds a key for an exact unsigned 64-bit integer value.
DisabledModifier
pub(all) struct DisabledModifier {
disabled : Bool
}DisabledModifier::to_any_modifier
DragDropEvent
DragDropEvent::new
fn DragDropEvent::new(phase~ : DragDropPhase, paths? : Array[String], position? : Point?) -> DragDropEventDragDropEvent::not_equal
DragDropPhase
DragDropPhase::not_equal
DragGestureEvent
DragGestureEvent::new
fn DragGestureEvent::new(phase~ : DragGesturePhase, start~ : Point, position~ : Point, delta~ : Point, translation~ : Point) -> DragGestureEventDragGestureEvent::not_equal
DragGesturePhase
DragGesturePhase::not_equal
DrawCommand
pub(all) enum DrawCommand {
Clear(Color)
FillRect(Rect, Color)
StrokeRect(Rect, Color, Double)
FillRoundedRect(RoundedRect, Color)
StrokeRoundedRect(RoundedRect, Color, Double)
FillRoundedRectBrush(RoundedRect, Brush)
StrokeRoundedRectBrush(RoundedRect, Brush, Double)
DrawShadow(ShadowSpec)
DrawText(TextRun)
DrawImage(ImageRun)
PushClip(Rect)
PopClip
PushRoundedClip(RoundedRect)
PopRoundedClip
PushTransform(Transform2D)
PopTransform
PushOpacity(Double)
PopOpacity
PushLayer(LayerSpec)
PopLayer
BeginRetainedLayer(RetainedLayerSpec)
EndRetainedLayer(String)
PushFilter(FilterEffect)
PopFilter
DrawPath(PathSpec)
DrawShaderEffect(ShaderEffectSpec)
} derive(Eq, ToJson, Debug)DrawFrame
pub(all) struct DrawFrame {
commands : Array[DrawCommand]
platform_views : Array[PlatformViewPlacement]
overlay_bounds : Rect?
damage : DamageRegion
clear_color : Color
} derive(Eq, ToJson, Debug)Renderer-facing frame payload. clear_color owns frame initialization;
commands contains view content and does not need a leading Clear.
Adapters for legacy command-only renderers must materialize that clear when
lowering a frame back to an Array[DrawCommand].
DrawFrame::new
fn DrawFrame::new(commands~ : Array[DrawCommand], platform_views? : Array[PlatformViewPlacement], overlay_bounds? : Rect?, damage~ : DamageRegion, clear_color? : Color) -> DrawFrameEasing
Effect
pub(all) enum Effect[Msg] {
NoEffect
Batch(Array[Effect[Msg]])
Send(Msg)
Dispatch(((Msg) -> Unit) -> Unit)
Run(EffectDescriptor, ((Msg) -> Unit) -> Unit)
Task(EffectDescriptor, ((Msg) -> Unit) -> () -> Unit?)
}Effect::map
Effect::run
Effect::runtime_visit
fn[Msg] Effect::runtime_visit(self : Effect[Msg], send : (Msg) -> Unit, dispatch_effect : (((Msg) -> Unit) -> Unit) -> Unit, run_effect : (EffectDescriptor, ((Msg) -> Unit) -> Unit) -> Unit, start_task : (EffectDescriptor, ((Msg) -> Unit) -> () -> Unit?) -> Unit) -> UnitEffect::service_task
EffectDescriptor
EffectDescriptor::not_equal
Environment
pub(all) struct Environment {
theme_spec : ThemeSpec
system_scheme : ColorScheme
theme : Theme
scale_factor : Double
text_scale : Double
locale : String
layout_direction : LayoutDirection
accessibility_contrast : AccessibilityContrast
reduced_motion : Bool
content_size_category : ContentSizeCategory
enabled : Bool
} derive(Eq, ToJson, Debug)Runtime environment snapshot. Carries the user's theme_spec (intent), the
current system_scheme (host-reported), and the resolved theme derived
from both. Changing system_scheme rebuilds the full theme via
with_system_scheme; the legacy with_color_scheme (which only flipped a
flag and left the palette stale) is removed.
Environment::color_scheme
Read the effective color scheme (from the resolved theme). Kept as a
convenience accessor so callers do not have to reach into theme.scheme.
Environment::neutral
Neutral environment: Minimal theme following a light system scheme, standard
density/contrast, full motion. The theme_spec records the intent so a
later ThemeChanged(Dark) event rebuilds the full dark theme instead of
leaving a stale light palette.
Environment::with_accessibility_contrast
fn Environment::with_accessibility_contrast(self : Environment, accessibility_contrast : AccessibilityContrast) -> EnvironmentUpdate accessibility contrast. Also updates theme_spec.contrast so a
subsequent system-scheme change re-resolves with the new contrast.
Environment::with_content_size_category
fn Environment::with_content_size_category(self : Environment, content_size_category : ContentSizeCategory) -> EnvironmentEnvironment::with_enabled
Environment::with_layout_direction
fn Environment::with_layout_direction(self : Environment, layout_direction : LayoutDirection) -> EnvironmentEnvironment::with_locale
Environment::with_reduced_motion
Update reduced motion. Also updates theme_spec.reduced_motion so a
subsequent re-resolve zeroes motion durations.
Environment::with_scale_factor
Environment::with_system_scheme
Replace the system color scheme and rebuild the full theme from
theme_spec. This is the host-facing entry point: a ThemeChanged(Dark)
event calls this so the palette/surfaces/shadows actually switch to dark,
fixing the old bug where only the scheme flag flipped.
Environment::with_text_scale
Environment::with_theme
Replace the theme. Also updates system_scheme to match the theme's scheme
so the two stay consistent. Use with_theme_spec + with_system_scheme
for the resolver-driven path; this helper is for callers that already have
a fully resolved Theme (e.g. a branded addon that built one directly).
Environment::with_theme_spec
Replace the theme spec and rebuild the full theme against the current
system scheme. App code calls this when the user picks a new preset,
density, or contrast.
EnvironmentModifier
EnvironmentModifier::to_any_modifier
Feature
type Feature[Model, Msg]A composable TEA unit: the same five-tuple as Program (init, update,
view, subscriptions, commands) packaged as a value that can be defined,
tested, and mounted into a parent with Feature::scope independently of
the runtime root. Program stays the runtime-facing root; bridge the two
with Program::from_feature.
P13 note: the write half of a Feature::scope lens is a pure function
(Child, Parent) -> Parent. It is not an arbitrary setter — application
state still changes only inside update, and Feature introduces no
lifecycle state machine, binding, context, or mutable holder. Lens laws
expected of every read/write pair: read(write(child, parent)) ==child, write(read(parent), parent) == parent, and a later write
supersedes an earlier one (last writer wins).
There is intentionally no Feature::map: a one-way message map is not
closed over update, because the input side would also need the inverse
function. Message lifting lives in Feature::scope(wrap), where the
parent match arm has already unwrapped the child message — the same shape
as hand-written wrapper variants that lift with Effect::map.
Terminology: this Feature (core TEA composition unit) is unrelated to
RendererFeature (renderer capability tags) and to the feature-status /
feature-proof documentation pages.
Feature::new
Feature::new_with_environment
fn[Model, Msg] Feature::new_with_environment(init~ : () -> (Model, Effect[Msg]), update~ : (Model, Msg) -> (Model, Effect[Msg]), view~ : (Model, ViewEnvironment) -> View[Msg], subscriptions? : (Model) -> Subscription[Msg]) -> Feature[Model, Msg]Feature::runtime_commands
fn[Model, Msg] Feature::runtime_commands(self : Feature[Model, Msg], model : Model) -> Array[ProgramCommand[Msg]]Feature::runtime_init
Feature::runtime_subscriptions
fn[Model, Msg] Feature::runtime_subscriptions(self : Feature[Model, Msg], model : Model) -> Subscription[Msg]Feature::runtime_update
Feature::runtime_view
fn[Model, Msg] Feature::runtime_view(self : Feature[Model, Msg], model : Model, environment : ViewEnvironment) -> View[Msg]Feature::scope
fn[Child, ChildMsg, Parent, ParentMsg] Feature::scope(self : Feature[Child, ChildMsg], read~ : (Parent) -> Child, write~ : (Child, Parent) -> Parent, wrap~ : (ChildMsg) -> ParentMsg) -> ScopedFeature[Parent, Child, ChildMsg, ParentMsg]Mount self into a parent model through a read/write lens pair and a
wrap message constructor. The returned handle lifts child messages,
effects, views, subscriptions, and commands into the parent's types; the
parent update routes through one match arm per wrapper variant, exactly
like the hand-written delegation this replaces.
FilterEffect
FlexibleModifier
pub(all) struct FlexibleModifier {
weight : Double
}FlexibleModifier::to_any_modifier
FocusRequest
Immutable programmatic focus request. Reusing an id is a no-op for an
already mounted target.
FocusScope
FocusScope::command_target
FocusScope::focus_target_or_first
FocusScope::new
fn FocusScope::new(items~ : Array[FocusScopeItem], current? : String?, wrap? : Bool, default_action? : String, dismiss_action? : String) -> FocusScopeFocusScope::traverse
FocusScopeItem
FocusScopeItem::new
FocusScopeItem::not_equal
FocusTrapModifier
pub(all) struct FocusTrapModifier {
trap : Bool
}FocusTrapModifier::to_any_modifier
FocusTraversalDirection
FocusTraversalDirection::equal
FocusTraversalDirection::not_equal
fn FocusTraversalDirection::not_equal(x : FocusTraversalDirection, y : FocusTraversalDirection) -> BoolFocusTraversalDirection::to_json
FocusTraversalDirection::to_repr
FocusableModifier
pub(all) struct FocusableModifier {
focusable : Bool
}FocusableModifier::to_any_modifier
FontFamily
FontFamilyStack
FontFamilyStack::not_equal
FontFamilyStack::with_fallback
FontModifier
FontModifier::to_any_modifier
FontSpec
pub(all) struct FontSpec {
families : FontFamilyStack
size : Double
weight : Int
style : FontStyle
variations : Array[FontVariation]
} derive(Eq, ToJson, Debug)FontSpec::new
fn FontSpec::new(families? : FontFamilyStack, size? : Double, weight? : Int, style? : FontStyle, variations? : Array[FontVariation]) -> FontSpecFontSpec::variation_value
FontStyle
FontVariation
A single variation axis of a variable font. axis is the 4-character
OpenType tag (e.g. "wght", "wdth", "ital", "opsz", "slnt").
FontVariation::not_equal
ForegroundModifier
ForegroundModifier::to_any_modifier
Frame
FrameModifier
pub(all) struct FrameModifier {
width : Double?
height : Double?
min_width : Double?
min_height : Double?
max_width : Double?
max_height : Double?
}FrameModifier::to_any_modifier
ImageFit
ImageRun
Insets
InteractionState
Neutral interaction state machine. This is the token-layer state enum used
to select a resolved style from a component theme. It is the union of
states every component theme needs to resolve
(normal/hovered/pressed/focused/disabled/selected/invalid); individual
controls only pass the subset they support.
InteractionState stays in core (ADR 0017) because it is the neutral
gesture/interaction state machine consumed by core's own view-tree,
gesture, and semantics layers — it is not control vocabulary. The concrete
control theme token structs (ButtonTheme, ControlStateTokens,
ComponentThemes, …) moved to moui/views as ControlThemeSet; this
file no longer carries control-specific types.
InteractionState::not_equal
IntrinsicHeightModifier
pub(all) struct IntrinsicHeightModifier {
}IntrinsicHeightModifier::to_any_modifier
fn[Msg] IntrinsicHeightModifier::to_any_modifier(_self : IntrinsicHeightModifier) -> AnyModifier[Msg]IntrinsicWidthModifier
pub(all) struct IntrinsicWidthModifier {
}IntrinsicWidthModifier::to_any_modifier
Key
KeyModifier
KeyModifier::to_any_modifier
KeyModifiers
KeyModifiers::new
KeyboardEvent
pub(all) struct KeyboardEvent {
key : String
text : String?
pressed : Bool
repeat : Bool
modifiers : KeyModifiers
} derive(Eq, ToJson, Debug)KeyboardEvent::new
fn KeyboardEvent::new(key~ : String, pressed? : Bool, text? : String?, repeat? : Bool, modifiers? : KeyModifiers) -> KeyboardEventKeyboardEvent::not_equal
KeyboardPolicy
pub(all) enum KeyboardPolicy {
Passthrough
TopMostDismissal
ShortcutScope
}Keyboard dispatch policy for a node.
TopMostDismissal marks an overlay host: it owns top-most-first dismissal
(Escape/Back) and receives keyboard events before its subtree, as
registered in the runtime layer stack. ShortcutScope marks a keyboard
shortcut wrapper whose own shortcut handling runs before children.
KeyboardShortcut
KeyboardShortcut::display_label
KeyboardShortcut::matches
KeyboardShortcut::new
KeyboardShortcut::not_equal
KeyboardShortcutModifier
KeyboardShortcutModifier::to_any_modifier
fn[Msg] KeyboardShortcutModifier::to_any_modifier(self : KeyboardShortcutModifier) -> AnyModifier[Msg]LayerMask
LayerSpec
LayerSpec::new
LayoutDirection
LayoutDirection::not_equal
LayoutPriorityModifier
pub(all) struct LayoutPriorityModifier {
priority : Double
}LayoutPriorityModifier::to_any_modifier
LayoutResult
Recursive layout tree produced by the layout pass. Unlike
ViewLayoutResult (a single node's measured size + child frames),
LayoutResult is the fully-nested tree emitted by AppRuntime::layout.
LinearGradientSpec
LinearGradientSpec::equal
LinearGradientSpec::new
fn LinearGradientSpec::new(start~ : Point, end~ : Point, start_color~ : Color, end_color~ : Color) -> LinearGradientSpecLinearGradientSpec::not_equal
MainAxisAlignment
MainAxisAlignment::equal
MainAxisAlignment::not_equal
MainAxisAlignmentModifier
MainAxisAlignmentModifier::to_any_modifier
fn[Msg] MainAxisAlignmentModifier::to_any_modifier(_self : MainAxisAlignmentModifier) -> AnyModifier[Msg]MotionScale
OffsetModifier
pub(all) struct OffsetModifier {
dx : Double
dy : Double
}OffsetModifier::to_any_modifier
OnDoubleTapModifier
pub(all) struct OnDoubleTapModifier[Msg] {
message : Msg
}OnDoubleTapModifier::to_any_modifier
OnDragModifier
OnDragModifier::to_any_modifier
OnDragWithFrameModifier
OnDragWithFrameModifier::to_any_modifier
fn[Msg] OnDragWithFrameModifier::to_any_modifier(self : OnDragWithFrameModifier[Msg]) -> AnyModifier[Msg]OnFileDropModifier
OnFileDropModifier::to_any_modifier
OnLongPressModifier
pub(all) struct OnLongPressModifier[Msg] {
message : Msg
}OnLongPressModifier::to_any_modifier
OnTapModifier
pub(all) struct OnTapModifier[Msg] {
message : Msg
}OnTapModifier::to_any_modifier
OpacityModifier
pub(all) struct OpacityModifier {
opacity : Double
}OpacityModifier::to_any_modifier
OverlayPlacementContext
Context for the post-layout overlay placement pass. Anchored overlay hosts
resolve their popup frames here — after base layout and anchor-registry
collection — instead of during layout, so anchoring never re-enters the
layout fixpoint nor keys layout caches.
PaddingModifier
Layout modifiers: Padding, Frame, Flexible, Offset, Align, AspectRatio,
Spacing, LayoutPriority, MainAxisAlignment, CrossAxisAlignment,
IntrinsicWidth, IntrinsicHeight, Key.
PaddingModifier::to_any_modifier
PathSpec
PathSpec::new
PathVerb
PlatformViewEvent
PlatformViewEvent::equal
PlatformViewEvent::not_equal
PlatformViewPixelSink
pub struct PlatformViewPixelSink {
// private fields
}Renderer-neutral sink for host-owned platform-view pixels.
PlatformViewPixelSink::draw
fn PlatformViewPixelSink::draw(self : PlatformViewPixelSink, pixels : Bytes, width : Int, height : Int, stride : Int, x : Double, y : Double, draw_width : Double, draw_height : Double) -> UnitPlatformViewPixelSink::new
fn PlatformViewPixelSink::new(draw~ : (Bytes, Int, Int, Int, Double, Double, Double, Double) -> Unit) -> PlatformViewPixelSinkPlatformViewPlacement
PlatformViewPlacement::equal
PlatformViewPlacement::new
fn PlatformViewPlacement::new(id~ : String, kind~ : String, frame~ : Rect, clip? : Rect?, properties? : Array[PlatformViewProperty]) -> PlatformViewPlacementPlatformViewPlacement::not_equal
PlatformViewPlacement::property
PlatformViewPlacement::property_or
fn PlatformViewPlacement::property_or(self : PlatformViewPlacement, key : String, default : String) -> StringPlatformViewPlacement::to_json
PlatformViewPlacement::to_repr
PlatformViewProperty
PlatformViewProperty::equal
PlatformViewProperty::new
PlatformViewProperty::not_equal
Point
PointerEvent
pub(all) struct PointerEvent {
position : Point
phase : PointerPhase
button : Int
wheel_delta : Point
time_ms : Double
modifiers : KeyModifiers
} derive(Eq, ToJson, Debug)PointerEvent::new
fn PointerEvent::new(position~ : Point, phase~ : PointerPhase, button? : Int, wheel_delta? : Point, time_ms? : Double, modifiers? : KeyModifiers) -> PointerEventPointerPhase
Pointer interaction phase. Move/Down/Up/Cancel are produced by host
backends from raw input. Exit is a synthetic, runtime-only phase: the
runtime emits it to the previously hovered element when the pointer leaves
its bounds (host backends never produce it). Views use it to clear hover
state that they otherwise could not, because a normal Move outside the
element is never delivered to it by hit-testing.
PressableState
PressableState::not_equal
PressableState::to_interaction
Convert a runtime PressableState (gesture-driven three-state, defined in
view_style.mbt) into the token-layer InteractionState for component
theme resolution. Kept in core because both sides are neutral core
types; moui/views reads this when resolving a ControlThemeSet.
Program
type Program[Model, Msg]Program::from_feature
Bridge a Feature into the runtime-facing Program root. The two types
are field-isomorphic; this is a record copy, not a wrapper with extra
behavior. App roots stay Program; children stay Feature until they
are scoped.
Program::new
Program::new_with_environment
fn[Model, Msg] Program::new_with_environment(init~ : () -> (Model, Effect[Msg]), update~ : (Model, Msg) -> (Model, Effect[Msg]), view~ : (Model, ViewEnvironment) -> View[Msg], subscriptions? : (Model) -> Subscription[Msg]) -> Program[Model, Msg]Program::runtime_commands
fn[Model, Msg] Program::runtime_commands(self : Program[Model, Msg], model : Model) -> Array[ProgramCommand[Msg]]Program::runtime_init
Program::runtime_subscriptions
fn[Model, Msg] Program::runtime_subscriptions(self : Program[Model, Msg], model : Model) -> Subscription[Msg]Program::runtime_update
Program::runtime_view
fn[Model, Msg] Program::runtime_view(self : Program[Model, Msg], model : Model, environment : ViewEnvironment) -> View[Msg]Program::simple
fn[Model, Msg] Program::simple(init~ : Model, update~ : (Model, Msg) -> Model, view~ : (Model) -> View[Msg], subscriptions? : (Model) -> Subscription[Msg]) -> Program[Model, Msg]Program::simple_with_environment
fn[Model, Msg] Program::simple_with_environment(init~ : Model, update~ : (Model, Msg) -> Model, view~ : (Model, ViewEnvironment) -> View[Msg], subscriptions? : (Model) -> Subscription[Msg]) -> Program[Model, Msg]ProgramCommand
A host-visible command declaration whose action re-enters the Program as a
typed message. The runtime owns dispatch; applications only describe the
command and its message.
ProgramCommand::command
ProgramCommand::map
fn[Msg, NextMsg] ProgramCommand::map(self : ProgramCommand[Msg], map : (Msg) -> NextMsg) -> ProgramCommand[NextMsg]ProgramCommand::new
RadialGradientSpec
RadialGradientSpec::equal
RadialGradientSpec::new
fn RadialGradientSpec::new(center~ : Point, radius~ : Double, center_color~ : Color, edge_color~ : Color) -> RadialGradientSpecRadialGradientSpec::not_equal
RadiusScale
Rect
RedrawReason
RepaintBoundaryModifier
pub(all) struct RepaintBoundaryModifier {
}RepaintBoundaryModifier::to_any_modifier
fn[Msg] RepaintBoundaryModifier::to_any_modifier(_self : RepaintBoundaryModifier) -> AnyModifier[Msg]RetainedLayerSpec
RetainedLayerSpec::equal
RetainedLayerSpec::new
fn RetainedLayerSpec::new(key~ : String, frame~ : Rect, content_revision~ : Int, scale_factor? : Double) -> RetainedLayerSpecRetainedLayerSpec::not_equal
RoundedRect
ScaleModifier
pub(all) struct ScaleModifier {
sx : Double
sy : Double
}ScaleModifier::to_any_modifier
ScopedFeature
pub struct ScopedFeature[Parent, Child, ChildMsg, ParentMsg] {
// private fields
}A Feature mounted into a parent model, produced by Feature::scope.
Holds only pure functions (lens pair, message constructor, and the child
feature); it carries no state and can be rebuilt at any time.
ScopedFeature::commands
fn[Parent, Child, ChildMsg, ParentMsg] ScopedFeature::commands(self : ScopedFeature[Parent, Child, ChildMsg, ParentMsg], parent : Parent) -> Array[ProgramCommand[ParentMsg]]Derive the child program commands from the parent model and lift their
messages to the parent's message type.
ScopedFeature::init
fn[Parent, Child, ChildMsg, ParentMsg] ScopedFeature::init(self : ScopedFeature[Parent, Child, ChildMsg, ParentMsg]) -> (Child, Effect[ParentMsg])Run the child feature's init, returning the initial child model for the
parent to place and the startup effect already lifted to the parent's
message type. Batch several scopes' startup effects with
Effect::batch.
ScopedFeature::subscriptions
fn[Parent, Child, ChildMsg, ParentMsg] ScopedFeature::subscriptions(self : ScopedFeature[Parent, Child, ChildMsg, ParentMsg], parent : Parent) -> Subscription[ParentMsg]Derive the child subscriptions from the parent model and lift their
messages to the parent's message type.
ScopedFeature::update
fn[Parent, Child, ChildMsg, ParentMsg] ScopedFeature::update(self : ScopedFeature[Parent, Child, ChildMsg, ParentMsg], parent : Parent, message : ChildMsg) -> (Parent, Effect[ParentMsg])Delegate one child message: read the child model through the lens, run
the child update, write the result back, and lift the effect to the
parent's message type.
ScopedFeature::view
fn[Parent, Child, ChildMsg, ParentMsg] ScopedFeature::view(self : ScopedFeature[Parent, Child, ChildMsg, ParentMsg], parent : Parent, environment : ViewEnvironment) -> View[ParentMsg]Build the child view from the parent model and lift its messages to the
parent's message type.
ScrollAlignment
ScrollAlignment::not_equal
ScrollRequest
Immutable programmatic scroll request. A monotonically increasing id
lets the runtime-owned element slot apply each request at most once.
ScrollRequest::not_equal
SemanticId
A stable application-owned identifier for one effective semantic boundary.
Values are exact and case-sensitive. Parsing rejects empty values, values
longer than 255 UTF-8 bytes, and values containing Unicode whitespace or
control characters.
impl ToJson for SemanticIdSemanticId::new
Parses and validates a stable semantic identifier declared in UI code,
aborting the process when the value is not a legal SemanticId.
UI code declares these identifiers as literals, so an invalid literal is a
programming error that must surface at the first view construction instead
of being silently dropped. Use SemanticId::parse for values that
originate outside the program.
SemanticId::parse
Parses and validates a stable semantic identifier.
SemanticId::value
Returns the exact, non-normalized identifier value.
SemanticIdModifier
SemanticIdModifier::to_any_modifier
SemanticsAction
pub(all) enum SemanticsAction {
Activate
Focus
SetText(String)
Submit
Scroll(SemanticsScrollDirection)
Select
Expand
Collapse
Dismiss
Increment
Decrement
SetNumericValue(Double)
SetSelection(TextRange)
ShowMenu
} derive(Eq, ToJson, Debug)A typed semantic invocation. Payload requirements are encoded by the
constructor rather than represented by an optional side channel.
SemanticsAction::not_equal
SemanticsActionKind
A payload-free semantic capability advertised by a committed node.
SemanticsActionKind::equal
SemanticsActionKind::not_equal
SemanticsCheckedModifier
SemanticsCheckedModifier::to_any_modifier
fn[Msg] SemanticsCheckedModifier::to_any_modifier(self : SemanticsCheckedModifier) -> AnyModifier[Msg]SemanticsCheckedState
SemanticsCheckedState::equal
SemanticsCheckedState::not_equal
SemanticsCheckedState::to_json
SemanticsCheckedState::to_repr
SemanticsCollectionInfo
SemanticsCollectionInfo::equal
SemanticsCollectionInfo::new
fn SemanticsCollectionInfo::new(row_index? : Int, row_count? : Int, row_span? : Int, column_index? : Int, column_count? : Int, column_span? : Int, set_size? : Int, set_position? : Int) -> SemanticsCollectionInfoSemanticsCollectionInfo::not_equal
fn SemanticsCollectionInfo::not_equal(x : SemanticsCollectionInfo, y : SemanticsCollectionInfo) -> BoolSemanticsCollectionInfo::to_json
SemanticsCollectionInfo::to_repr
SemanticsComposition
Controls how one view declaration contributes to the effective semantics
tree.
SemanticsComposition::equal
SemanticsComposition::not_equal
SemanticsCompositionModifier
SemanticsCompositionModifier::to_any_modifier
fn[Msg] SemanticsCompositionModifier::to_any_modifier(self : SemanticsCompositionModifier) -> AnyModifier[Msg]SemanticsDescriptionModifier
pub(all) struct SemanticsDescriptionModifier {
description : String
}SemanticsDescriptionModifier::to_any_modifier
fn[Msg] SemanticsDescriptionModifier::to_any_modifier(self : SemanticsDescriptionModifier) -> AnyModifier[Msg]SemanticsExpandedModifier
pub(all) struct SemanticsExpandedModifier {
expanded : Bool
}SemanticsExpandedModifier::to_any_modifier
fn[Msg] SemanticsExpandedModifier::to_any_modifier(self : SemanticsExpandedModifier) -> AnyModifier[Msg]SemanticsGeneration
Version of one runtime's atomically committed public semantics snapshot.
impl ToJson for SemanticsGenerationSemanticsGeneration::compare
SemanticsGeneration::equal
SemanticsGeneration::hash_combine
SemanticsGeneration::not_equal
SemanticsGeneration::op_ge
SemanticsGeneration::op_gt
SemanticsGeneration::op_le
SemanticsGeneration::op_lt
SemanticsGeneration::to_json
SemanticsGeneration::to_wire
Returns the lossless decimal wire representation.
SemanticsInvalidModifier
pub(all) struct SemanticsInvalidModifier {
invalid : Bool
}SemanticsInvalidModifier::to_any_modifier
fn[Msg] SemanticsInvalidModifier::to_any_modifier(self : SemanticsInvalidModifier) -> AnyModifier[Msg]SemanticsLevelModifier
pub(all) struct SemanticsLevelModifier {
level : Int
}SemanticsLevelModifier::to_any_modifier
SemanticsLive
SemanticsLive::not_equal
SemanticsMetadataModifier
Grouped advanced semantics metadata with an exact cache key.
SemanticsMetadataModifier::to_any_modifier
fn[Msg] SemanticsMetadataModifier::to_any_modifier(self : SemanticsMetadataModifier) -> AnyModifier[Msg]SemanticsNode
pub(all) struct SemanticsNode {
node_id : SemanticsNodeId
semantic_id : SemanticId?
role : SemanticsRole
level : Int?
url : String
label : String
value : String
description : String
state : SemanticsState
numeric : SemanticsNumericValue?
text : SemanticsTextValue?
collection : SemanticsCollectionInfo?
relations : SemanticsRelations
live : SemanticsLive
live_atomic : Bool
actions : Array[SemanticsActionKind]
focus_order : Int?
frame : Rect
children : Array[SemanticsNodeId]
} derive(Eq, ToJson, Debug)SemanticsNode::not_equal
SemanticsNodeId
Runtime-session-local identity for one committed semantics node.
impl ToJson for SemanticsNodeIdSemanticsNodeId::hash_combine
SemanticsNodeId::not_equal
SemanticsNodeId::op_ge
SemanticsNodeId::op_gt
SemanticsNodeId::op_le
SemanticsNodeId::op_lt
SemanticsNodeId::to_wire
Returns the lossless decimal wire representation.
SemanticsNumericValue
SemanticsNumericValue::equal
SemanticsNumericValue::new
fn SemanticsNumericValue::new(current? : Double, min? : Double, max? : Double, step? : Double, value_text? : String) -> SemanticsNumericValueSemanticsNumericValue::not_equal
SemanticsNumericValue::to_json
SemanticsNumericValue::to_repr
SemanticsPathSegment
pub(all) struct SemanticsPathSegment {
index : Int
role : SemanticsRole?
label : String?
value : String?
semantic_id : SemanticId?
} derive(Eq, ToJson, Debug)One step of a ByPath walk, resolved from the committed semantics tree.
A step selects the index-th child of the current node whose effective
values satisfy every supplied filter; an absent filter matches anything.
SemanticsRole::None cannot be filtered on, because its absence already
means "no role filter" — filter on label or value for those nodes.
A step that supplies no filter at all addresses a position rather than a
node. The wire decoder rejects such a step, and runtime resolution treats
it as no match, so an agent cannot request one.
SemanticsPathSegment::equal
SemanticsPathSegment::not_equal
SemanticsPressedModifier
pub(all) struct SemanticsPressedModifier {
pressed : Bool
}SemanticsPressedModifier::to_any_modifier
fn[Msg] SemanticsPressedModifier::to_any_modifier(self : SemanticsPressedModifier) -> AnyModifier[Msg]SemanticsRelationKind
SemanticsRelationKind::equal
SemanticsRelationKind::not_equal
SemanticsRelationKind::to_json
SemanticsRelationKind::to_repr
SemanticsRelations
pub(all) struct SemanticsRelations {
labelled_by : Array[SemanticsNodeId]
described_by : Array[SemanticsNodeId]
controls : Array[SemanticsNodeId]
error_message : Array[SemanticsNodeId]
active_descendant : Array[SemanticsNodeId]
} derive(Eq, ToJson, Debug)Relations in a committed snapshot contain only resolved runtime node IDs.
SemanticsRelations::equal
SemanticsRelations::not_equal
SemanticsRelationsDeclaration
pub(all) struct SemanticsRelationsDeclaration {
labelled_by : Array[SemanticId]
described_by : Array[SemanticId]
controls : Array[SemanticId]
error_message : Array[SemanticId]
active_descendant : Array[SemanticId]
} derive(Eq, ToJson, Debug)Relations declared by views use application-stable semantic IDs.
SemanticsRelationsDeclaration::equal
fn SemanticsRelationsDeclaration::equal(SemanticsRelationsDeclaration, SemanticsRelationsDeclaration) -> BoolSemanticsRelationsDeclaration::new
fn SemanticsRelationsDeclaration::new(labelled_by? : Array[SemanticId], described_by? : Array[SemanticId], controls? : Array[SemanticId], error_message? : Array[SemanticId], active_descendant? : Array[SemanticId]) -> SemanticsRelationsDeclarationSemanticsRelationsDeclaration::not_equal
fn SemanticsRelationsDeclaration::not_equal(x : SemanticsRelationsDeclaration, y : SemanticsRelationsDeclaration) -> BoolSemanticsRelationsDeclaration::to_json
SemanticsRelationsDeclaration::to_repr
SemanticsRequiredModifier
pub(all) struct SemanticsRequiredModifier {
required : Bool
}SemanticsRequiredModifier::to_any_modifier
fn[Msg] SemanticsRequiredModifier::to_any_modifier(self : SemanticsRequiredModifier) -> AnyModifier[Msg]SemanticsRole
pub(all) enum SemanticsRole {
None
Text
Link
Heading
Navigation
Main
Button
Checkbox
TextField
List
ListItem
Grid
ScrollView
Switch
Radio
Slider
Progress
Tab
Dialog
Tooltip
Menu
ButtonGroup
Form
FormField
Tree
TreeItem
Group
WebView
Image
Alert
Status
ComboBox
Option
Table
Row
Cell
Separator
} derive(Eq, ToJson, Debug)SemanticsRole::not_equal
SemanticsRoleModifier
SemanticsRoleModifier::to_any_modifier
SemanticsScrollDirection
SemanticsScrollDirection::equal
SemanticsScrollDirection::not_equal
fn SemanticsScrollDirection::not_equal(x : SemanticsScrollDirection, y : SemanticsScrollDirection) -> BoolSemanticsScrollDirection::to_json
SemanticsScrollDirection::to_repr
SemanticsSelectedModifier
pub(all) struct SemanticsSelectedModifier {
selected : Bool
}SemanticsSelectedModifier::to_any_modifier
fn[Msg] SemanticsSelectedModifier::to_any_modifier(self : SemanticsSelectedModifier) -> AnyModifier[Msg]SemanticsState
pub(all) struct SemanticsState {
focused : Bool
disabled : Bool
selected : Bool
pressed : Bool
checked : SemanticsCheckedState?
expanded : Bool
invalid : Bool
required : Bool
read_only : Bool
busy : Bool
multiline : Bool
password : Bool
modal : Bool
} derive(Eq, ToJson, Debug)SemanticsState::not_equal
SemanticsTarget
pub(all) enum SemanticsTarget {
BySemanticId(SemanticId)
ByNodeId(SemanticsNodeId)
ByPath(Array[SemanticsPathSegment])
} derive(Eq, ToJson, Debug)Selects either an application-owned stable ID, a session-local committed
node ID, or a stepwise walk of the committed semantics hierarchy.
SemanticsTarget::not_equal
SemanticsTextValue
SemanticsTextValue::equal
SemanticsTextValue::new
fn SemanticsTextValue::new(selection? : TextRange, caret? : Int, editable? : Bool) -> SemanticsTextValueSemanticsTextValue::not_equal
SemanticsUrlModifier
pub(all) struct SemanticsUrlModifier {
url : String
}SemanticsUrlModifier::to_any_modifier
ShaderEffectSpec
ShaderEffectSpec::new
fn ShaderEffectSpec::new(name~ : String, frame~ : Rect, uniforms? : Array[Double], fallback? : Brush) -> ShaderEffectSpecShaderEffectSpec::not_equal
ShadowModifier
ShadowModifier::to_any_modifier
ShadowScale
pub(all) struct ShadowScale {
sm : ShadowStyle
md : ShadowStyle
lg : ShadowStyle
} derive(Eq, ToJson, Debug)ShadowSpec
ShadowSpec::new
fn ShadowSpec::new(rect~ : RoundedRect, color~ : Color, offset? : Point, blur_radius? : Double, spread? : Double) -> ShadowSpecShadowStyle
ShadowStyle::new
fn ShadowStyle::new(color~ : Color, offset? : Point, blur_radius? : Double, spread? : Double) -> ShadowStyleSize
SpacingModifier
pub(all) struct SpacingModifier {
spacing : Double
}SpacingModifier::to_any_modifier
SpacingScale
Subscription
pub struct Subscription[Msg] {
// private fields
}Subscription::animation_tick
fn[Msg] Subscription::animation_tick(key~ : String, start~ : ((Msg) -> Unit) -> () -> Unit?, label? : String) -> Subscription[Msg]Subscription::batch
Subscription::descriptors
Subscription::host_event
fn[Msg] Subscription::host_event(key~ : String, start~ : ((Msg) -> Unit) -> () -> Unit?, label? : String) -> Subscription[Msg]Subscription::listen
fn[Msg] Subscription::listen(key~ : String, start~ : ((Msg) -> Unit) -> () -> Unit?, kind? : String, label? : String) -> Subscription[Msg]Subscription::map
fn[Msg, NextMsg] Subscription::map(self : Subscription[Msg], map : (Msg) -> NextMsg) -> Subscription[NextMsg]Subscription::route_event
fn[Msg] Subscription::route_event(key~ : String, start~ : ((Msg) -> Unit) -> () -> Unit?, label? : String) -> Subscription[Msg]Subscription::run
fn[Msg] Subscription::run(key~ : String, start~ : ((Msg) -> Unit) -> () -> Unit?, kind? : String, label? : String) -> Subscription[Msg]Subscription::runtime_sources
fn[Msg] Subscription::runtime_sources(self : Subscription[Msg]) -> Array[SubscriptionRuntimeSource[Msg]]Subscription::runtime_visit
fn[Msg] Subscription::runtime_visit(self : Subscription[Msg], none : (Int) -> Unit, batch : (Int, Int) -> Unit, source : (Int, SubscriptionDescriptor) -> Unit) -> UnitSubscription::timer
fn[Msg] Subscription::timer(key~ : String, start~ : ((Msg) -> Unit) -> () -> Unit?, label? : String) -> Subscription[Msg]Subscription::window_event
fn[Msg] Subscription::window_event(key~ : String, start~ : ((Msg) -> Unit) -> () -> Unit?, label? : String) -> Subscription[Msg]SubscriptionDescriptor
SubscriptionDescriptor::equal
SubscriptionDescriptor::key
SubscriptionDescriptor::kind
SubscriptionDescriptor::label
SubscriptionDescriptor::not_equal
fn SubscriptionDescriptor::not_equal(x : SubscriptionDescriptor, y : SubscriptionDescriptor) -> BoolSubscriptionDescriptor::to_json
SubscriptionDescriptor::to_repr
SubscriptionRuntimeSource
pub struct SubscriptionRuntimeSource[Msg] {
// private fields
}SubscriptionRuntimeSource::descriptor
fn[Msg] SubscriptionRuntimeSource::descriptor(self : SubscriptionRuntimeSource[Msg]) -> SubscriptionDescriptorSubscriptionRuntimeSource::key
SubscriptionRuntimeSource::kind
SubscriptionRuntimeSource::label
SubscriptionRuntimeSource::start
fn[Msg] SubscriptionRuntimeSource::start(self : SubscriptionRuntimeSource[Msg], dispatch : (Msg) -> Unit) -> () -> Unit?SurfaceLevel
SurfaceMetrics
Logical and physical dimensions of a presentation surface.
This is the neutral contract shared by window backends and renderers. The
scale factor is always positive; constructors normalize invalid values to
one so callers cannot accidentally divide by zero when converting input.
SurfaceMetrics::from_logical
SurfaceMetrics::new
fn SurfaceMetrics::new(logical_size~ : Size, physical_size~ : Size, scale_factor? : Double) -> SurfaceMetricsSurfaceMetrics::not_equal
SurfaceScale
SurfaceScale::default
TextAlign
TextCommandResult
TextCommandResult::equal
TextCommandResult::handled
TextCommandResult::not_equal
TextControlStateContext
pub(all) struct TextControlStateContext {
caret : Int
selection : TextRange?
text_selection_anchor : Int?
text_selection_origin : Point?
composition : String?
composition_cursor : TextRange?
undo_stack : Array[TextHistoryEntryContext]
redo_stack : Array[TextHistoryEntryContext]
goal_column : Double?
} derive(Eq, ToJson, Debug)TextControlStateContext::equal
TextControlStateContext::not_equal
fn TextControlStateContext::not_equal(x : TextControlStateContext, y : TextControlStateContext) -> BoolTextControlStateContext::to_json
TextControlStateContext::to_repr
TextHistoryEntryContext
One undo/redo step as a delta: replacing before with after at
start (character indices in the pre-edit text) produced the new
document; undoing re-applies the replacement backwards. Entries
stay the size of the edit instead of the document, so keeping the
whole undo stack alive — and copying it per frame in the element
tree — costs proportional to user keystrokes, not document size.
caret/selection restore the editor position to what it was
before the edit when the entry is undone. The entry is symmetric:
moving it onto the opposite stack (the same delta with the live
position written into caret/selection) is all a redo step needs,
because before and after already describe both directions of
the edit.
TextHistoryEntryContext::equal
TextHistoryEntryContext::not_equal
fn TextHistoryEntryContext::not_equal(x : TextHistoryEntryContext, y : TextHistoryEntryContext) -> BoolTextHistoryEntryContext::redo_text
Current text -> text with the entry's edit applied forward (redo).
TextHistoryEntryContext::to_json
TextHistoryEntryContext::to_repr
TextHistoryEntryContext::undo_text
Current text -> text with the entry's edit reverted (undo).
TextInputEvent
TextInputEvent::not_equal
TextInputState
TextInputState::not_equal
TextLayoutInput
TextLayoutInput::new
TextLayoutInput::not_equal
TextLayoutResult
TextLayoutResult::not_equal
TextParagraphHitTestResult
TextParagraphHitTestResult::equal
fn TextParagraphHitTestResult::equal(TextParagraphHitTestResult, TextParagraphHitTestResult) -> BoolTextParagraphHitTestResult::not_equal
fn TextParagraphHitTestResult::not_equal(x : TextParagraphHitTestResult, y : TextParagraphHitTestResult) -> BoolTextParagraphHitTestResult::to_json
TextParagraphHitTestResult::to_repr
TextParagraphLayoutMetadata
TextParagraphLayoutMetadata::equal
fn TextParagraphLayoutMetadata::equal(TextParagraphLayoutMetadata, TextParagraphLayoutMetadata) -> BoolTextParagraphLayoutMetadata::not_equal
fn TextParagraphLayoutMetadata::not_equal(x : TextParagraphLayoutMetadata, y : TextParagraphLayoutMetadata) -> BoolTextParagraphLayoutMetadata::to_json
TextParagraphLayoutMetadata::to_repr
TextParagraphLayoutResult
pub(all) struct TextParagraphLayoutResult {
text : String
size : Size
baseline : Double
lines : Array[TextParagraphLineMetrics]
caret_rects : Array[Rect]
visual_order : TextParagraphVisualOrderMetadata
metadata : TextParagraphLayoutMetadata
} derive(Eq, ToJson, Debug)TextParagraphLayoutResult::caret_rect_at
TextParagraphLayoutResult::equal
TextParagraphLayoutResult::hit_test
fn TextParagraphLayoutResult::hit_test(self : TextParagraphLayoutResult, point : Point) -> TextParagraphHitTestResultTextParagraphLayoutResult::line_count
TextParagraphLayoutResult::not_equal
fn TextParagraphLayoutResult::not_equal(x : TextParagraphLayoutResult, y : TextParagraphLayoutResult) -> BoolTextParagraphLayoutResult::selection_rects
fn TextParagraphLayoutResult::selection_rects(self : TextParagraphLayoutResult, range : TextRange) -> Array[Rect]TextParagraphLayoutResult::to_json
TextParagraphLayoutResult::to_repr
TextParagraphLineMetrics
TextParagraphLineMetrics::equal
TextParagraphLineMetrics::not_equal
fn TextParagraphLineMetrics::not_equal(x : TextParagraphLineMetrics, y : TextParagraphLineMetrics) -> BoolTextParagraphLineMetrics::to_json
TextParagraphLineMetrics::to_repr
TextParagraphVisualOrderMetadata
TextParagraphVisualOrderMetadata::equal
TextParagraphVisualOrderMetadata::not_equal
fn TextParagraphVisualOrderMetadata::not_equal(x : TextParagraphVisualOrderMetadata, y : TextParagraphVisualOrderMetadata) -> BoolTextParagraphVisualOrderMetadata::to_json
TextParagraphVisualOrderMetadata::to_repr
TextRange
TextRun
TextRun::new
TextSystem
pub struct TextSystem {
id : String
measure : (TextLayoutInput) -> TextLayoutResult
paragraph_layout : (TextLayoutInput) -> TextParagraphLayoutResult
register_font_data : (FontFamily, Bytes) -> Unit
}TextSystem::layout_paragraph
fn TextSystem::layout_paragraph(self : TextSystem, input : TextLayoutInput) -> TextParagraphLayoutResultTextSystem::measure_text
TextSystem::new
fn TextSystem::new(id~ : String, measure~ : (TextLayoutInput) -> TextLayoutResult, paragraph_layout? : (TextLayoutInput) -> TextParagraphLayoutResult?, register_font_data? : (FontFamily, Bytes) -> Unit) -> TextSystemTextSystem::register_font_data
Theme
pub(all) struct Theme {
scheme : ColorScheme
palette : ColorPalette
spacing_scale : SpacingScale
radius_scale : RadiusScale
typography : TypographyScale
shadow_scale : ShadowScale
motion : MotionScale
surfaces : SurfaceScale
} derive(Eq, ToJson, Debug)Resolved, drawable neutral theme. A Theme is the output of
resolve_theme(spec, system_scheme): it carries the palette, all scale
tiers, surfaces, and motion — the neutral theme base. Concrete
control theme tokens (ButtonTheme, TextFieldTheme, …) are not on
Theme; they live in moui/views as ControlThemeSet (ADR 0017) so
core carries no control vocabulary. Controls read a ControlThemeSet
resolved views-side from this neutral Theme at paint time; style? on
a control constructor is a one-shot override.
Theme::neutral
Neutral fallback theme. Equivalent to resolving ThemeSpec::default() with
a light system scheme. Carries the neutral palette + scales only; concrete
control tokens are resolved views-side as a ControlThemeSet (ADR 0017).
Theme::with_radius_scale
Theme::with_shadow_scale
Theme::with_spacing_scale
Theme::with_typography
ThemeDensity
Density tier. Compact shrinks spacing by ~18%, Comfortable grows it by
~18%; Standard is 1.0.
ThemeModifier
ThemeModifier::to_any_modifier
ThemePreset
Which design-system preset the user selected. core only resolves
Minimal itself; branded presets (Material/Carbon/Primer/Fluent) are
resolved by the moui_theme addon, which produces a complete @core.Theme
(including components). The enum lives in core so Environment can
record the user's choice without core depending on the addon.
ThemeSpec
pub(all) struct ThemeSpec {
preset : ThemePreset
color_mode : ColorMode
density : ThemeDensity
contrast : AccessibilityContrast
seed : Color?
reduced_motion : Bool
} derive(Eq, ToJson, Debug)User theme intent. Built by app code (or by a branded addon helper) and
stored on Environment.theme_spec; the resolver consumes it whenever the
system scheme changes so a ThemeChanged event rebuilds the full theme.
ThemeSpec::default
Default spec: MoUI Minimal, follow the system, standard density, standard
contrast, no seed, full motion.
ThemeSpec::minimal_dark
Minimal-dark spec (forced dark, used by the legacy dark_theme() helper).
ThemeSpec::minimal_light
Minimal-light spec (forced light, used by the legacy light_theme() helper).
ThemeSpec::resolve_scheme
Resolve the effective color scheme for a spec given the current system
scheme. System defers to the platform; Light/Dark override it.
ThemeSpec::with_color_mode
ThemeSpec::with_contrast
ThemeSpec::with_density
ThemeSpec::with_preset
ThemeSpec::with_reduced_motion
Transform2D
Transform2D::translation
TransitionSample
pub struct TransitionSample {
progress : Double
style : TransitionStyle
present : Bool
} derive(Eq, ToJson, Debug)TransitionSample::not_equal
TransitionSpec
pub struct TransitionSpec {
from : TransitionStyle
to : TransitionStyle
duration_ms : Double
easing : Easing
} derive(Eq, ToJson, Debug)TransitionSpec::fade
fn TransitionSpec::fade(from_opacity? : Double, to_opacity? : Double, duration_ms? : Double, easing? : Easing) -> TransitionSpecTransitionSpec::new
fn TransitionSpec::new(from? : TransitionStyle, to? : TransitionStyle, duration_ms? : Double, easing? : Easing) -> TransitionSpecTransitionSpec::not_equal
TransitionSpec::presence
fn TransitionSpec::presence(self : TransitionSpec, present~ : Bool, progress~ : Double, reduced_motion? : Bool) -> TransitionSampleTransitionSpec::sample
fn TransitionSpec::sample(self : TransitionSpec, progress : Double, reduced_motion? : Bool) -> TransitionSampleTransitionSpec::sample_elapsed
fn TransitionSpec::sample_elapsed(self : TransitionSpec, elapsed_ms : Double, reduced_motion? : Bool) -> TransitionSampleTransitionSpec::scale
fn TransitionSpec::scale(from_scale? : Double, to_scale? : Double, duration_ms? : Double, easing? : Easing) -> TransitionSpecTransitionSpec::slide
fn TransitionSpec::slide(from_offset~ : Point, to_offset? : Point, duration_ms? : Double, easing? : Easing) -> TransitionSpecTransitionStyle
TransitionStyle::interpolate
fn TransitionStyle::interpolate(self : TransitionStyle, to : TransitionStyle, progress~ : Double, easing? : Easing, reduced_motion? : Bool) -> TransitionStyleTransitionStyle::new
fn TransitionStyle::new(opacity? : Double, offset? : Point, scale? : Point, foreground? : Color?) -> TransitionStyleTransitionStyle::not_equal
TransitionStyle::with_foreground
TransitionStyle::with_offset
fn TransitionStyle::with_offset(self : TransitionStyle, dx? : Double, dy? : Double) -> TransitionStyleTransitionStyle::with_opacity
TransitionStyle::with_scale
fn TransitionStyle::with_scale(self : TransitionStyle, sx? : Double, sy? : Double) -> TransitionStyleTypographyScale
TypographyScale::not_equal
View
pub struct View[Msg] {
// private fields
}View::accessibility_label
View::background_brush
View::child_constraints
View::child_environment
View::corner_radius
View::cross_axis_alignment
View::dispatch_semantics_action
fn[Msg] View::dispatch_semantics_action(self : View[Msg], context : ViewSemanticsActionContext, action : SemanticsAction) -> ViewSemanticsActionResult[Msg]View::environment
View::event
View::frame
View::from_node
fn[Node : ViewNode, Msg] View::from_node(node : Node, children? : (Node) -> Array[View[Msg]], event? : (Node, ViewEventContext) -> ViewEventResult[Msg], text_command? : (Node, ViewEventContext, CommandIntent, String?) -> ViewTextCommandResult[Msg], semantics_actions? : (Node) -> Array[ViewSemanticsActionHandler[Msg]]) -> View[Msg]Construct a typed view from a concrete message-independent node.
The node supplies layout, paint, semantics, focus, and reconciliation
behavior through ViewNode. Optional adapters attach typed children,
events, and text commands without erasing Msg from the
public view. Identity, declaration, semantics metadata, and static children
are sampled exactly once here. View::map maps only typed adapters and
preserves those frozen snapshots.
View::keyboard_shortcut
View::layout
View::layout_priority
View::main_axis_alignment
View::map
View::merge_descendant_semantics
View::on_drag
View::on_drag_with_frame
fn[Msg] View::on_drag_with_frame(self : View[Msg], handler : (DragGestureEvent, Rect) -> Msg) -> View[Msg]View::on_file_drop
View::on_hover
Hover observer: calls handler with true when the pointer enters this
view and false when it leaves.
The handler runs only on transitions. The runtime delivers a Move for
every pointer sample inside the view, so a per-Move callback would flood
the app's update loop; continuous motion inside the view emits nothing.
Deliberately transparent, matching on_secondary_tap: hover feedback is an
observer, not a control. It adds no semantics role, no semantics action, and
no focus stop, and it never captures the pointer or alters press state, so
wrapping a region does not turn a container into a Button or break clicking
and dragging inside it. Pair it with an app-owned Model flag to restyle
the region.
View::on_secondary_tap
View::on_secondary_tap_with_frame
Secondary (right-button) tap with hit-test geometry: hands the pointer
position plus the child frame, so a context-menu host can hit-test which
item the menu belongs to.
Why this exists next to on_secondary_tap: that one carries a fixed
message, which is enough for "open the context menu" but not for "open the
context menu for the block under the cursor". Canvas surfaces that own
their own hit-testing (the blocks canvas) need the point.
View::on_tap_with_frame
Tap with hit-test geometry: fires on a plain click (press+release inside
the view) and hands the pointer position plus the child frame to the
handler. Use for canvas/custom-drawn surfaces that need the tap point;
pair with on_drag_with_frame for drag support on the same surface.
View::place_overlays
fn[Msg] View::place_overlays(self : View[Msg], context : OverlayPlacementContext) -> Array[(Int, Rect)]?View::platform_views
fn[Msg] View::platform_views(self : View[Msg], context : ViewPlatformContext) -> Array[PlatformViewPlacement]View::presence
fn[Msg] View::presence(self : View[Msg], present~ : Bool, spec? : TransitionSpec, progress? : Double, reduced_motion? : Bool) -> View[Msg]View::semantic_id
Declares the application-owned address of this effective semantic boundary.
The value is validated by SemanticId::new, so an invalid literal aborts
the process at the first view construction.
View::semantics_action_kinds
View::semantics_checked
View::semantics_collection
fn[Msg] View::semantics_collection(self : View[Msg], collection : SemanticsCollectionInfo) -> View[Msg]View::semantics_composition
fn[Msg] View::semantics_composition(self : View[Msg], composition : SemanticsComposition) -> View[Msg]View::semantics_description
View::semantics_expanded
View::semantics_invalid
View::semantics_level
View::semantics_live
fn[Msg] View::semantics_live(self : View[Msg], live : SemanticsLive, live_atomic? : Bool) -> View[Msg]View::semantics_numeric
View::semantics_pressed
View::semantics_relations
fn[Msg] View::semantics_relations(self : View[Msg], relations : SemanticsRelationsDeclaration) -> View[Msg]View::semantics_required
View::semantics_role
View::semantics_selected
View::semantics_state
View::semantics_text_metadata
View::text_command
fn[Msg] View::text_command(self : View[Msg], context : ViewEventContext, intent : CommandIntent, paste_text? : String?) -> TextCommandResultView::text_command_result
fn[Msg] View::text_command_result(self : View[Msg], context : ViewEventContext, intent : CommandIntent, paste_text? : String?) -> ViewTextCommandResult[Msg]View::text_input_state
View::transition
fn[Msg] View::transition(self : View[Msg], spec? : TransitionSpec, progress? : Double, reduced_motion? : Bool) -> View[Msg]ViewDeclaration
pub struct ViewDeclaration {
layout : DeclarationChannel
paint : DeclarationChannel
semantics : DeclarationChannel
platform : DeclarationChannel
} derive(Eq)The four independently declared invalidation channels for a view node.
ViewDeclaration::changes_from
fn ViewDeclaration::changes_from(self : ViewDeclaration, previous : ViewDeclaration) -> DeclarationChangesClassifies effective invalidation from previous to this declaration.
ViewDeclaration::channels
fn ViewDeclaration::channels(layout~ : DeclarationChannel, paint~ : DeclarationChannel, semantics~ : DeclarationChannel, platform~ : DeclarationChannel) -> ViewDeclarationDeclares cache behavior independently for all four channels.
ViewDeclaration::constant
Declares four channels that remain constant for a reused view identity.
ViewDeclaration::layout
ViewDeclaration::not_equal
ViewDeclaration::platform
ViewDeclaration::semantics
ViewDeclaration::uncacheable
Declares four channels that must be recomputed on every reconciliation.
ViewDirtyHint
ViewDirtyHint::not_equal
ViewEnvironment
Immutable environment snapshot passed to an application's Program view.
ViewEnvironment::environment
ViewEnvironment::new
ViewEnvironment::viewport_size
ViewEventContext
pub(all) struct ViewEventContext {
frame : Rect
child_frames : Array[Rect]
event : AppEvent
focused : Bool
state : ViewStateContext
text_control : TextControlStateContext
text_system : TextSystem
environment : Environment
style : ViewStyle
now_ms : Double
}ViewEventResult
pub(all) struct ViewEventResult[Msg] {
changed : Bool
activated : Bool
focused : Bool
captured : Bool
state : ViewStateContext?
text_control : TextControlStateContext?
dirty : ViewDirtyHint
messages : Array[Msg]
} derive(Eq, Debug)ViewEventResult::equal
ViewEventResult::message
ViewEventResult::not_equal
ViewEventResult::to_repr
ViewIdentity
ViewLayoutContext
pub(all) struct ViewLayoutContext {
constraints : Constraints
child_sizes : Array[Size]
child_flex_weights : Array[Double]
state : ViewStateContext
text_system : TextSystem
environment : Environment
style : ViewStyle
}ViewLayoutResult
ViewLayoutResult::new
fn ViewLayoutResult::new(size~ : Size, child_frames? : Array[Rect], clips_children? : Bool, child_frames_tight? : Bool) -> ViewLayoutResultViewLayoutResult::not_equal
ViewPaintContext
pub(all) struct ViewPaintContext {
frame : Rect
child_frames : Array[Rect]
focused : Bool
state : ViewStateContext
text_control : TextControlStateContext
environment : Environment
style : ViewStyle
text_system : TextSystem
now_ms : Double
}ViewPaintLayer
pub(all) struct ViewPaintLayer {
frame : Rect
cache_key : String
content_revision : Int
commands : Array[DrawCommand]
overlay_commands : Array[DrawCommand]
} derive(Eq, Debug)ViewPaintLayer::new
fn ViewPaintLayer::new(frame~ : Rect, cache_key~ : String, content_revision~ : Int, commands? : Array[DrawCommand], overlay_commands? : Array[DrawCommand]) -> ViewPaintLayerViewPaintLayer::not_equal
ViewPaintPlan
pub(all) struct ViewPaintPlan {
commands : Array[DrawCommand]
child_layers : Array[ViewPaintLayer]
post_commands : Array[DrawCommand]
overlay_commands : Array[DrawCommand]
repaint_boundary : Bool
animating : Bool
} derive(Eq, Debug)ViewPaintPlan::animating_commands
Like ViewPaintPlan::commands but flags the paint as a mid-animation
sample. The runtime keeps requesting redraws while any painted plan in the
tree reports animating=true. Controls set this when their transition
progress < 1.0 (and reduced_motion is not in effect).
ViewPaintPlan::commands
ViewPaintPlan::not_equal
ViewPlatformContext
pub(all) struct ViewPlatformContext {
frame : Rect
child_frames : Array[Rect]
environment : Environment
style : ViewStyle
}Context for the platform-tree pass. Platform placements are produced
independently from paint so native child views can update without creating
draw commands or scheduling a renderer frame.
ViewSemanticsActionContext
pub(all) struct ViewSemanticsActionContext {
frame : Rect
child_frames : Array[Rect]
focused : Bool
state : ViewStateContext
text_control : TextControlStateContext
text_system : TextSystem
environment : Environment
style : ViewStyle
}Runtime inputs available to a typed semantics-action handler.
The context contains only the reconciled node's transient UI state and
resolved declaration environment. Application model mutation still occurs
through the returned typed messages and the program's TEA update.
ViewSemanticsActionHandler
pub struct ViewSemanticsActionHandler[Msg] {
kind : SemanticsActionKind
handle : (ViewSemanticsActionContext, SemanticsAction) -> ViewSemanticsActionResult[Msg]
}One capability-paired semantic action adapter.
Public constructors pair each capability with a payload-correct callback;
callers cannot advertise SetText or Scroll without handling its typed
payload.
ViewSemanticsActionHandler::activate
fn[Msg] ViewSemanticsActionHandler::activate(handle : (ViewSemanticsActionContext) -> ViewSemanticsActionResult[Msg]) -> ViewSemanticsActionHandler[Msg]ViewSemanticsActionHandler::collapse
fn[Msg] ViewSemanticsActionHandler::collapse(handle : (ViewSemanticsActionContext) -> ViewSemanticsActionResult[Msg]) -> ViewSemanticsActionHandler[Msg]ViewSemanticsActionHandler::decrement
fn[Msg] ViewSemanticsActionHandler::decrement(handle : (ViewSemanticsActionContext) -> ViewSemanticsActionResult[Msg]) -> ViewSemanticsActionHandler[Msg]ViewSemanticsActionHandler::dismiss
fn[Msg] ViewSemanticsActionHandler::dismiss(handle : (ViewSemanticsActionContext) -> ViewSemanticsActionResult[Msg]) -> ViewSemanticsActionHandler[Msg]ViewSemanticsActionHandler::expand
fn[Msg] ViewSemanticsActionHandler::expand(handle : (ViewSemanticsActionContext) -> ViewSemanticsActionResult[Msg]) -> ViewSemanticsActionHandler[Msg]ViewSemanticsActionHandler::increment
fn[Msg] ViewSemanticsActionHandler::increment(handle : (ViewSemanticsActionContext) -> ViewSemanticsActionResult[Msg]) -> ViewSemanticsActionHandler[Msg]ViewSemanticsActionHandler::kind
fn[Msg] ViewSemanticsActionHandler::kind(self : ViewSemanticsActionHandler[Msg]) -> SemanticsActionKindViewSemanticsActionHandler::scroll
fn[Msg] ViewSemanticsActionHandler::scroll(handle : (ViewSemanticsActionContext, SemanticsScrollDirection) -> ViewSemanticsActionResult[Msg]) -> ViewSemanticsActionHandler[Msg]ViewSemanticsActionHandler::select
fn[Msg] ViewSemanticsActionHandler::select(handle : (ViewSemanticsActionContext) -> ViewSemanticsActionResult[Msg]) -> ViewSemanticsActionHandler[Msg]ViewSemanticsActionHandler::set_numeric_value
fn[Msg] ViewSemanticsActionHandler::set_numeric_value(handle : (ViewSemanticsActionContext, Double) -> ViewSemanticsActionResult[Msg]) -> ViewSemanticsActionHandler[Msg]ViewSemanticsActionHandler::set_selection
fn[Msg] ViewSemanticsActionHandler::set_selection(handle : (ViewSemanticsActionContext, TextRange) -> ViewSemanticsActionResult[Msg]) -> ViewSemanticsActionHandler[Msg]ViewSemanticsActionHandler::set_text
fn[Msg] ViewSemanticsActionHandler::set_text(handle : (ViewSemanticsActionContext, String) -> ViewSemanticsActionResult[Msg]) -> ViewSemanticsActionHandler[Msg]fn[Msg] ViewSemanticsActionHandler::show_menu(handle : (ViewSemanticsActionContext) -> ViewSemanticsActionResult[Msg]) -> ViewSemanticsActionHandler[Msg]ViewSemanticsActionHandler::submit
fn[Msg] ViewSemanticsActionHandler::submit(handle : (ViewSemanticsActionContext) -> ViewSemanticsActionResult[Msg]) -> ViewSemanticsActionHandler[Msg]ViewSemanticsActionResult
pub(all) struct ViewSemanticsActionResult[Msg] {
accepted : Bool
state : ViewStateContext?
text_control : TextControlStateContext?
dirty : ViewDirtyHint
messages : Array[Msg]
deferred_commits : Array[() -> Unit]
}Result of invoking one typed semantic action adapter.
ViewSemanticsActionResult::accepted
fn[Msg] ViewSemanticsActionResult::accepted(state? : ViewStateContext?, text_control? : TextControlStateContext?, dirty? : ViewDirtyHint, messages? : Array[Msg], commit? : () -> Unit?) -> ViewSemanticsActionResult[Msg]ViewSemanticsActionResult::message
ViewSemanticsActionResult::rejected
ViewSemanticsInfo
pub(all) struct ViewSemanticsInfo {
composition : SemanticsComposition
semantic_id : SemanticId?
role : SemanticsRole?
level : Int?
url : String?
label : String?
value : String?
description : String?
disabled : Bool?
selected : Bool?
pressed : Bool?
checked : SemanticsCheckedState?
expanded : Bool?
invalid : Bool?
required : Bool?
read_only : Bool?
busy : Bool?
multiline : Bool?
password : Bool?
modal : Bool?
numeric : SemanticsNumericValue?
text : SemanticsTextValue?
collection : SemanticsCollectionInfo?
relations : SemanticsRelationsDeclaration?
live : SemanticsLive?
live_atomic : Bool?
} derive(Eq, ToJson, Debug)ViewSemanticsInfo::equal
ViewSemanticsInfo::new
fn ViewSemanticsInfo::new(composition? : SemanticsComposition, semantic_id? : SemanticId, role? : SemanticsRole, level? : Int, url? : String, label? : String, value? : String, description? : String, disabled? : Bool, selected? : Bool, pressed? : Bool, checked? : SemanticsCheckedState, expanded? : Bool, invalid? : Bool, required? : Bool, read_only? : Bool, busy? : Bool, multiline? : Bool, password? : Bool, modal? : Bool, numeric? : SemanticsNumericValue, text? : SemanticsTextValue, collection? : SemanticsCollectionInfo, relations? : SemanticsRelationsDeclaration, live? : SemanticsLive, live_atomic? : Bool) -> ViewSemanticsInfoViewSemanticsInfo::not_equal
ViewSemanticsInfo::overlaying
fn ViewSemanticsInfo::overlaying(self : ViewSemanticsInfo, base : ViewSemanticsInfo) -> ViewSemanticsInfoMerge this info (a modifier's contribution) over base (the wrapped
child's info). Fields set explicitly on self win; unset fields pass
through from base.
Two fields are deliberately not inherited from base:
- composition keeps self.composition: composition is structural (how this node's subtree contributes), and inheriting a child's Boundary/MergeDescendants would re-wrap the child's own grouping.
- text keeps self.text: it is element-instance-scoped state (caret/selection are injected by the owning element at overlay time), so re-inheriting it from a wrapper would clobber the text control's live state.
ViewStateContext
pub(all) struct ViewStateContext {
focused : Bool
hovered : Bool
pressed : Bool
selected : Bool
checked : Bool
expanded : Bool
disabled : Bool
slots : ViewStateSlots
} derive(Eq, Debug)ViewStateContext::not_equal
ViewStateContext::read_slot
fn[T : ViewStateValue] ViewStateContext::read_slot(self : ViewStateContext, slot : ViewStateSlot[T]) -> TRead a typed slot, returning the descriptor's initial value when this
element has not written the slot yet.
ViewStateContext::with_slot
fn[T : ViewStateValue] ViewStateContext::with_slot(self : ViewStateContext, slot : ViewStateSlot[T], value : T) -> ViewStateContextReturn a state proposal with one typed slot updated. The current context is
never mutated, so runtimes can validate an event or semantic action before
committing the returned state.
ViewStateContext::without_slot
fn[T] ViewStateContext::without_slot(self : ViewStateContext, slot : ViewStateSlot[T]) -> ViewStateContextReturn a state proposal with one slot reset to its initial value.
ViewStateSlot
pub struct ViewStateSlot[T] {
// private fields
}A typed descriptor for one node-scoped transient state value.
Descriptors are immutable declaration-time values. The stored bytes live in
the reconciled runtime element and are preserved only while that element's
identity is reused.
ViewStateSlot::new
ViewStateSlots
Runtime-owned storage behind ViewStateContext.
ViewStateSlots::not_equal
ViewStyle
ViewTextCommandResult
pub(all) struct ViewTextCommandResult[Msg] {
result : TextCommandResult
text_control : TextControlStateContext?
messages : Array[Msg]
} derive(Eq, Debug)ViewTextCommandResult::equal
fn[Msg : Eq] ViewTextCommandResult::equal(ViewTextCommandResult[Msg], ViewTextCommandResult[Msg]) -> BoolViewTextCommandResult::ignored
ViewTextCommandResult::new
fn[Msg] ViewTextCommandResult::new(result~ : TextCommandResult, text_control? : TextControlStateContext?, messages? : Array[Msg]) -> ViewTextCommandResult[Msg]ViewTextCommandResult::not_equal
fn[Msg : Eq] ViewTextCommandResult::not_equal(x : ViewTextCommandResult[Msg], y : ViewTextCommandResult[Msg]) -> BoolViewTextCommandResult::to_repr
VisualStyle
pub(all) struct VisualStyle {
background : Brush?
foreground : Color?
border : BorderStyle?
shadow : ShadowStyle?
radius : Double?
opacity : Double?
} derive(Eq, ToJson, Debug)animated_color
animated_point
animated_value
fn animated_value(from~ : Double, to~ : Double, progress~ : Double, easing? : Easing, reduced_motion? : Bool) -> Doublecomposition_cursor_offset
composition_start_index
delete_grapheme_range
fn delete_grapheme_range(boundaries : TextGraphemeBoundaries, caret : Int, before : Int, after : Int) -> TextRangebridges the core TextRange contract to the unicode package's API.
fallback_stabilize_grapheme_cluster_carets
the cluster's leading caret coordinate.
focus_scope_command_intent
move_text_caret
fn move_text_caret(text : String, caret : Int, selection : TextRange?, direction : TextCaretDirection, extend_selection~ : Bool) -> TextCaretMoveResultnoop_modifier
A modifier that does nothing — used as default for all vtable slots.
normalize_grapheme_range
TextRange contract to the unicode package's GraphemeRange API.
replace_text_range
replace_text_range_edit
fn replace_text_range_edit(text~ : String, range : TextRange, replacement : String) -> (String, String, Int)Replace a grapheme-normalized range in one document scan: returns the
next text, the deleted slice, and the normalized start — no char-array
or boundary-table copies.
resolve_minimal_theme
Resolve the Minimal preset. This is the canonical resolver: it picks the
palette by scheme, applies density to spacing, applies contrast adjustment,
zeroes motion when reduced motion is requested, and assembles the neutral
scales/surfaces. Concrete control theme tokens are not produced here;
they live in moui/views as ControlThemeSet (ADR 0017) and are resolved
views-side from this neutral Theme.
resolve_theme
Resolve a ThemeSpec against a system color scheme. For branded presets
this resolves the Minimal base; branded addons must call
resolve_minimal_theme and then replace the palette themselves. Component
themes are resolved views-side as a ControlThemeSet.
surrounding_delete_range
text_history_delta
fn text_history_delta(previous : String, next : String) -> (Int, String, String)Minimal prefix/suffix-anchored delta (start, before, after)
between two texts. Used by edit paths that only observe the before
and after documents; a single replacement stays exact, while a
whole-document swap degrades to the (still O(edit)) replacement of
the shared-affix-free middle.
text_input_grapheme_selection
fn text_input_grapheme_selection(boundaries : TextGraphemeBoundaries, selection : TextRange?) -> TextRange?text_next_grapheme_caret_boundary
fn text_next_grapheme_caret_boundary(text : String, caret : Int) -> IntReturns the next grapheme boundary after caret.
text_previous_grapheme_caret_boundary
fn text_previous_grapheme_caret_boundary(text : String, caret : Int) -> IntReturns the previous grapheme boundary before caret.
Source Files
- animation.mbt
- any_modifier.mbt
- control_requests.mbt
- controlled_value.mbt
- custom_layout.mbt
- damage.mbt
- date_value.mbt
- declaration.mbt
- event.mbt
- feature.mbt
- focus_scope.mbt
- geometry.mbt
- gesture.mbt
- identity.mbt
- modifier_env.mbt
- modifier_event.mbt
- modifier_hover.mbt
- modifier_layout.mbt
- modifier_paint.mbt
- modifier_semantics.mbt
- paint.mbt
- platform_view_pixels.mbt
- program.mbt
- program_subscription.mbt
- semantics.mbt
- semantics_action_handler.mbt
- surface_metrics.mbt
- text_editing.mbt
- text_grapheme_aliases.mbt
- text_history.mbt
- text_input_state.mbt
- text_layout.mbt
- text_paragraph_cache.mbt
- theme.mbt
- theme_components.mbt
- theme_resolver.mbt
- theme_spec.mbt
- view_environment.mbt
- view_modifier_declaration.mbt
- view_modifier_labels.mbt
- view_modifier_node.mbt
- view_modifiers.mbt
- view_node.mbt
- view_protocol.mbt
- view_state_slot.mbt
- view_style.mbt
- view_tree.mbt
- web_view.mbt
Install
Download zipMoUI is a multi-platform MoonBit GUI framework
mouiguiframework
Apache-2.0
Updated yesterday
1K downloadsDependencies
- wzzc-dev/window0.5.4-0.2.1
- Milky2018/moon_accesskit0.3.0
- Milky2018/moon_zeno0.1.3
- Milky2018/svg0.5.3
- moonbitlang/async0.22.4
- moonbitlang/x0.5.5