🥮 mooncakes.io
    Sign in

    wzzc-dev/moui/core does not have a README file

    RichTextFormatter

    source
    type RichTextFormatter = (String) -> RichTextDocument

    AccessibilityContrast

    source
    pub(all) enum AccessibilityContrast {
      Standard
      High
    } derive(Eq, ToJson, 
    Debug    )

    ActionCommand

    source
    pub(all) struct ActionCommand {
      intent : CommandIntent
      shortcut : KeyboardShortcut?
      label : String
      enabled : Bool
    } derive(Eq, ToJson, 
    Debug    )

    ActionCommand::matches

    source
    fn ActionCommand::matches(self : ActionCommand, event : KeyboardEvent) -> Bool

    ActionCommand::new

    source
    fn ActionCommand::new(intent~ : CommandIntent, label? : String, shortcut? : KeyboardShortcut?, enabled? : Bool) -> ActionCommand

    ActionCommandMap

    source
    pub(all) struct ActionCommandMap {
      bindings : Array[CommandBinding]
    }

    ActionCommandMap::commands

    source

    ActionCommandMap::dispatch_intent

    source
    fn ActionCommandMap::dispatch_intent(self : ActionCommandMap, intent : CommandIntent) -> Bool

    ActionCommandMap::dispatch_shortcut

    source
    fn ActionCommandMap::dispatch_shortcut(self : ActionCommandMap, event : KeyboardEvent) -> CommandIntent?

    ActionCommandMap::find_shortcut

    source
    fn ActionCommandMap::find_shortcut(self : ActionCommandMap, event : KeyboardEvent) -> ActionCommand?

    ActionCommandMap::new

    source

    Alignment

    source
    pub(all) struct Alignment {
      x : Double
      y : Double
    } derive(Eq, ToJson, 
    Debug    )

    Alignment::bottom_leading

    source
    fn Alignment::bottom_leading() -> Alignment

    Alignment::bottom_trailing

    source
    fn Alignment::bottom_trailing() -> Alignment

    Alignment::center

    source
    fn Alignment::center() -> Alignment

    Alignment::new

    source
    fn Alignment::new(x~ : Double, y~ : Double) -> Alignment

    Alignment::top_leading

    source
    fn Alignment::top_leading() -> Alignment

    Alignment::top_trailing

    source
    fn Alignment::top_trailing() -> Alignment

    AlignmentGuideSet

    source
    pub(all) struct AlignmentGuideSet {
      leading : Double
      center : Double
      trailing : Double
      first_baseline : Double?
    } derive(Eq, ToJson, 
    Debug    )

    AlignmentGuideSet::from_size

    source
    fn AlignmentGuideSet::from_size(size : Size, first_baseline? : Double?) -> AlignmentGuideSet

    AnimatedColor

    source
    pub(all) struct AnimatedColor {
      from : Color
      to : Color
      duration_ms : Double
      easing : Easing
    } derive(Eq, ToJson, 
    Debug    )

    AnimatedColor::new

    source
    fn AnimatedColor::new(from~ : Color, to~ : Color, duration_ms? : Double, easing? : Easing) -> AnimatedColor

    AnimatedColor::value

    source
    fn AnimatedColor::value(self : AnimatedColor, elapsed_ms : Double) -> Color

    AnimatedDouble

    source
    pub(all) struct AnimatedDouble {
      from : Double
      to : Double
      duration_ms : Double
      easing : Easing
    } derive(Eq, ToJson, 
    Debug    )

    AnimatedDouble::new

    source
    fn AnimatedDouble::new(from~ : Double, to~ : Double, duration_ms? : Double, easing? : Easing) -> AnimatedDouble

    AnimatedDouble::value

    source
    fn AnimatedDouble::value(self : AnimatedDouble, elapsed_ms : Double) -> Double

    AnimatedPoint

    source
    pub(all) struct AnimatedPoint {
      from : Point
      to : Point
      duration_ms : Double
      easing : Easing
    } derive(Eq, ToJson, 
    Debug    )

    AnimatedPoint::new

    source
    fn AnimatedPoint::new(from~ : Point, to~ : Point, duration_ms? : Double, easing? : Easing) -> AnimatedPoint

    AnimatedPoint::value

    source
    fn AnimatedPoint::value(self : AnimatedPoint, elapsed_ms : Double) -> Point

    AnimationController

    source
    pub(all) struct AnimationController {
      duration_ms : Double
      elapsed_ms : Double
      status : AnimationStatus
    } derive(Eq, ToJson, 
    Debug    )

    AnimationController::is_active

    source
    fn AnimationController::is_active(self : AnimationController) -> Bool

    AnimationController::new

    source
    fn AnimationController::new(duration_ms~ : Double) -> AnimationController

    AnimationController::progress

    source
    fn AnimationController::progress(self : AnimationController) -> Double

    AnimationController::reset

    source
    fn AnimationController::reset(self : AnimationController) -> Unit

    AnimationController::start

    source
    fn AnimationController::start(self : AnimationController) -> Unit

    AnimationController::stop

    source
    fn AnimationController::stop(self : AnimationController) -> Unit

    AnimationController::tick

    source
    fn AnimationController::tick(self : AnimationController, frame : Frame) -> Bool

    AnimationStatus

    source
    pub(all) enum AnimationStatus {
      Idle
      Running
      Completed
    } derive(Eq, ToJson, 
    Debug    )

    AppEvent

    source
    pub(all) enum AppEvent {
      FrameTick(Frame)
      Pointer(PointerEvent)
      Keyboard(KeyboardEvent)
      TextInput(TextInputEvent)
      DragDrop(DragDropEvent)
      Resize(Size)
      Redraw(RedrawReason)
      CloseRequested
    } derive(Eq, ToJson, 
    Debug    )

    AppRuntime

    source
    pub struct AppRuntime {
      state : RuntimeState
    }

    AppRuntime::action_commands

    source
    fn AppRuntime::action_commands(self : AppRuntime) -> Array[ActionCommand]

    AppRuntime::add_animation

    source
    fn AppRuntime::add_animation(self : AppRuntime, controller : AnimationController) -> Unit

    AppRuntime::advance_time

    source
    fn AppRuntime::advance_time(self : AppRuntime, time_ms : Double) -> Unit

    AppRuntime::animation_count

    source
    fn AppRuntime::animation_count(self : AppRuntime) -> Int

    AppRuntime::destroy

    source
    fn AppRuntime::destroy(self : AppRuntime) -> Unit

    AppRuntime::dirty_count

    source
    fn AppRuntime::dirty_count(self : AppRuntime) -> Int

    AppRuntime::dispatch_command

    source
    fn AppRuntime::dispatch_command(self : AppRuntime, intent : CommandIntent) -> Bool

    AppRuntime::dispatch_event

    source
    fn AppRuntime::dispatch_event(self : AppRuntime, event : AppEvent) -> Unit

    AppRuntime::dispatch_focused_text_command

    source
    fn AppRuntime::dispatch_focused_text_command(self : AppRuntime, intent : CommandIntent, paste_text? : String?) -> TextCommandResult

    AppRuntime::draw_commands

    source
    fn AppRuntime::draw_commands(self : AppRuntime) -> Array[DrawCommand]

    AppRuntime::environment

    source
    fn AppRuntime::environment(self : AppRuntime) -> Environment

    AppRuntime::focus_next

    source
    fn AppRuntime::focus_next(self : AppRuntime) -> Bool

    AppRuntime::focus_previous

    source
    fn AppRuntime::focus_previous(self : AppRuntime) -> Bool

    AppRuntime::focused_text_input

    source
    fn AppRuntime::focused_text_input(self : AppRuntime) -> TextInputState

    AppRuntime::layout

    source
    fn AppRuntime::layout(self : AppRuntime) -> LayoutResult

    AppRuntime::layout_pass

    source
    fn AppRuntime::layout_pass(self : AppRuntime) -> Unit

    AppRuntime::needs_layout

    source
    fn AppRuntime::needs_layout(self : AppRuntime) -> Bool

    AppRuntime::needs_paint

    source
    fn AppRuntime::needs_paint(self : AppRuntime) -> Bool

    AppRuntime::needs_rebuild

    source
    fn AppRuntime::needs_rebuild(self : AppRuntime) -> Bool

    AppRuntime::needs_redraw

    source
    fn AppRuntime::needs_redraw(self : AppRuntime) -> Bool

    AppRuntime::new_component_view

    source
    fn[Msg] AppRuntime::new_component_view(root~ : (BuildContext) -> View[Msg], size~ : Size, environment? : Environment, on_message? : (Msg) -> Unit?) -> AppRuntime

    AppRuntime::new_program

    source
    fn[Model, Msg] AppRuntime::new_program(program~ : Program[Model, Msg], size~ : Size, environment? : Environment) -> AppRuntime

    AppRuntime::new_view

    source
    fn[Msg] AppRuntime::new_view(root~ : View[Msg], size~ : Size, environment? : Environment, on_message? : (Msg) -> Unit?) -> AppRuntime

    AppRuntime::paint_pass

    source
    fn AppRuntime::paint_pass(self : AppRuntime) -> Array[DrawCommand]

    AppRuntime::rebuild

    source
    fn AppRuntime::rebuild(self : AppRuntime) -> Unit

    AppRuntime::register_font_data

    source
    fn AppRuntime::register_font_data(self : AppRuntime, family : FontFamily, data : Bytes) -> Unit

    AppRuntime::semantics

    source
    fn AppRuntime::semantics(self : AppRuntime) -> SemanticsNode

    AppRuntime::set_action_commands

    source
    fn AppRuntime::set_action_commands(self : AppRuntime, commands : ActionCommandMap) -> Unit

    AppRuntime::set_environment

    source
    fn AppRuntime::set_environment(self : AppRuntime, environment : Environment) -> Unit

    AppRuntime::set_redraw_callback

    source
    fn AppRuntime::set_redraw_callback(self : AppRuntime, callback : () -> Unit) -> Unit

    AppRuntime::set_text_system

    source
    fn AppRuntime::set_text_system(self : AppRuntime, text_system : TextSystem) -> Unit

    AppRuntime::size

    source
    fn AppRuntime::size(self : AppRuntime) -> Size

    AppRuntime::text_system

    source
    fn AppRuntime::text_system(self : AppRuntime) -> TextSystem

    Axis

    source
    pub(all) enum Axis {
      Horizontal
      Vertical
    } derive(Eq, ToJson, 
    Debug    )

    Binding

    source
    pub(all) struct Binding[T] {
      get_value : () -> T
      set_value : (T) -> Unit
    }

    Binding::get

    source
    fn[T] Binding::get(self : Binding[T]) -> T

    Binding::new

    source
    fn[T] Binding::new(get~ : () -> T, set~ : (T) -> Unit) -> Binding[T]

    Binding::set

    source
    fn[T] Binding::set(self : Binding[T], value : T) -> Unit

    Binding::update

    source
    fn[T] Binding::update(self : Binding[T], f : (T) -> T raise?) -> Unit raise?

    BlendMode

    source
    pub(all) enum BlendMode {
      SourceOver
      Multiply
      Screen
      Overlay
      Darken
      Lighten
    } derive(Eq, ToJson, 
    Debug    )

    BorderStyle

    source
    pub(all) struct BorderStyle {
      brush : Brush
      width : Double
    } derive(Eq, ToJson, 
    Debug    )

    BorderStyle::new

    source
    fn BorderStyle::new(brush~ : Brush, width? : Double) -> BorderStyle

    Brush

    source
    pub(all) enum Brush {
      Solid(Color)
      LinearGradient(LinearGradientSpec)
    } derive(Eq, ToJson, 
    Debug    )

    Brush::fallback_color

    source
    fn Brush::fallback_color(self : Brush) -> Color

    Brush::linear_gradient

    source
    fn Brush::linear_gradient(start~ : Point, end~ : Point, start_color~ : Color, end_color~ : Color) -> Brush

    Brush::multiply_alpha

    source
    fn Brush::multiply_alpha(self : Brush, opacity : Double) -> Brush

    Brush::solid

    source
    fn Brush::solid(color : Color) -> Brush

    BuildContext

    source
    pub struct BuildContext {
      runtime : RuntimeState
      component_id : ElementId
      subscriptions : Array[StateSubscription]
      effects : Array[ComponentEffect]
      old_effects : Array[ComponentEffect]
      environment : Environment
    }

    BuildContext::accessibility_contrast

    source
    fn BuildContext::accessibility_contrast(self : BuildContext) -> AccessibilityContrast

    BuildContext::binding

    source
    fn[T] BuildContext::binding(self : BuildContext, state : State[T]) -> Binding[T]

    BuildContext::color_scheme

    source
    fn BuildContext::color_scheme(self : BuildContext) -> ColorScheme

    BuildContext::content_size_category

    source
    fn BuildContext::content_size_category(self : BuildContext) -> ContentSizeCategory

    BuildContext::enabled

    source
    fn BuildContext::enabled(self : BuildContext) -> Bool

    BuildContext::environment

    source
    fn BuildContext::environment(self : BuildContext) -> Environment

    BuildContext::layout_direction

    source
    fn BuildContext::layout_direction(self : BuildContext) -> LayoutDirection

    BuildContext::locale

    source
    fn BuildContext::locale(self : BuildContext) -> String

    BuildContext::on_dispose

    source
    fn BuildContext::on_dispose(self : BuildContext, key~ : String, cleanup : () -> Unit) -> Unit

    BuildContext::on_mount

    source
    fn BuildContext::on_mount(self : BuildContext, key~ : String, effect : () -> Unit) -> Unit

    BuildContext::on_unmount

    source
    fn BuildContext::on_unmount(self : BuildContext, key~ : String, cleanup : () -> Unit) -> Unit

    BuildContext::on_unmount_with_reason

    source
    fn BuildContext::on_unmount_with_reason(self : BuildContext, key~ : String, cleanup : (ComponentEffectCancelReason) -> Unit) -> Unit

    BuildContext::on_update

    source
    fn BuildContext::on_update(self : BuildContext, key~ : String, deps~ : Array[String], effect : () -> () -> Unit?) -> Unit

    BuildContext::on_update_with_reason

    source
    fn BuildContext::on_update_with_reason(self : BuildContext, key~ : String, deps~ : Array[String], effect : () -> (ComponentEffectCancelReason) -> Unit?) -> Unit

    BuildContext::reduced_motion

    source
    fn BuildContext::reduced_motion(self : BuildContext) -> Bool

    BuildContext::restore

    source
    fn[T] BuildContext::restore(self : BuildContext, key~ : String, codec : SaveableCodec[T]) -> T?

    BuildContext::restore_bool

    source
    fn BuildContext::restore_bool(self : BuildContext, key~ : String) -> Bool?

    BuildContext::restore_int

    source
    fn BuildContext::restore_int(self : BuildContext, key~ : String) -> Int?

    BuildContext::restore_string

    source
    fn BuildContext::restore_string(self : BuildContext, key~ : String) -> String?

    BuildContext::run_effect

    source
    fn BuildContext::run_effect(self : BuildContext, key~ : String, effect : () -> () -> Unit?) -> Unit

    BuildContext::run_effect_with_reason

    source
    fn BuildContext::run_effect_with_reason(self : BuildContext, key~ : String, effect : () -> (ComponentEffectCancelReason) -> Unit?) -> Unit

    BuildContext::save

    source
    fn[T] BuildContext::save(self : BuildContext, key~ : String, value : T, codec : SaveableCodec[T]) -> Unit

    BuildContext::save_bool

    source
    fn BuildContext::save_bool(self : BuildContext, key~ : String, value : Bool) -> Unit

    BuildContext::save_int

    source
    fn BuildContext::save_int(self : BuildContext, key~ : String, value : Int) -> Unit

    BuildContext::save_string

    source
    fn BuildContext::save_string(self : BuildContext, key~ : String, value : String) -> Unit

    BuildContext::saveable

    source
    fn[T] BuildContext::saveable(self : BuildContext, key~ : String, initial : T, codec : SaveableCodec[T]) -> State[T]

    BuildContext::saveable_bool

    source
    fn BuildContext::saveable_bool(self : BuildContext, key~ : String, initial : Bool) -> State[Bool]

    BuildContext::saveable_int

    source
    fn BuildContext::saveable_int(self : BuildContext, key~ : String, initial : Int) -> State[Int]

    BuildContext::saveable_string

    source
    fn BuildContext::saveable_string(self : BuildContext, key~ : String, initial : String) -> State[String]

    BuildContext::scale_factor

    source
    fn BuildContext::scale_factor(self : BuildContext) -> Double

    BuildContext::text_scale

    source
    fn BuildContext::text_scale(self : BuildContext) -> Double

    BuildContext::theme

    source
    fn BuildContext::theme(self : BuildContext) -> Theme

    BuildContext::view_environment

    source
    fn BuildContext::view_environment(self : BuildContext) -> ViewEnvironment

    BuildContext::viewport_size

    source
    fn BuildContext::viewport_size(self : BuildContext) -> Size

    BuildContext::watch

    source
    fn[T] BuildContext::watch(self : BuildContext, state : State[T]) -> T

    BuildContext::watch_derived

    source
    fn[T] BuildContext::watch_derived(self : BuildContext, state : DerivedState[T]) -> T

    BuildContext::watch_focus

    source
    fn BuildContext::watch_focus(self : BuildContext, state : FocusState) -> String?

    BuildContext::watch_navigation

    source
    fn BuildContext::watch_navigation(self : BuildContext, state : NavigationState) -> Array[String]

    BuildContext::watch_scroll

    source
    fn BuildContext::watch_scroll(self : BuildContext, state : ScrollState) -> Point

    ButtonState

    source
    pub(all) enum ButtonState {
      Normal
      Hovered
      Pressed
    } derive(Eq, ToJson, 
    Debug    )

    ButtonStyle

    source
    pub(all) struct ButtonStyle {
      normal : ControlStateStyle
      hovered : ControlStateStyle
      pressed : ControlStateStyle
      disabled : ControlStateStyle
    } derive(Eq, ToJson, 
    Debug    )

    ButtonStyle::filled

    source
    fn ButtonStyle::filled(theme? : Theme) -> ButtonStyle

    ButtonStyle::ghost

    source
    fn ButtonStyle::ghost(theme? : Theme) -> ButtonStyle

    ButtonStyle::outline

    source
    fn ButtonStyle::outline(theme? : Theme) -> ButtonStyle

    ButtonStyle::tonal

    source
    fn ButtonStyle::tonal(theme? : Theme) -> ButtonStyle

    Clock

    source
    pub(all) struct Clock {
      last_time_ms : Double?
    } derive(Eq, ToJson, 
    Debug    )

    Clock::frame

    source
    fn Clock::frame(self : Clock, time_ms : Double) -> Frame

    Clock::new

    source
    fn Clock::new() -> Clock

    Color

    source
    pub(all) struct Color {
      r : Double
      g : Double
      b : Double
      a : Double
    } derive(Eq, ToJson, 
    Debug    )

    Color::black

    source
    fn Color::black() -> Color

    Color::blue

    source
    fn Color::blue() -> Color

    Color::gray

    source
    fn Color::gray() -> Color

    Color::multiply_alpha

    source
    fn Color::multiply_alpha(self : Color, opacity : Double) -> Color

    Color::rgba

    source
    fn Color::rgba(r~ : Double, g~ : Double, b~ : Double, a? : Double) -> Color

    Color::white

    source
    fn Color::white() -> Color

    Color::with_alpha

    source
    fn Color::with_alpha(self : Color, alpha : Double) -> Color

    ColorPalette

    source
    pub(all) struct ColorPalette {
      foreground : Color
      background : Color
      surface : Color
      surface_variant : Color
      primary : Color
      primary_foreground : Color
      outline : Color
      muted : Color
    } derive(Eq, ToJson, 
    Debug    )

    ColorPalette::dark

    source

    ColorPalette::light

    source
    fn ColorPalette::light() -> ColorPalette

    ColorScheme

    source
    pub(all) enum ColorScheme {
      Light
      Dark
    } derive(Eq, ToJson, 
    Debug    )

    CommandBinding

    source
    pub(all) struct CommandBinding {
      command : ActionCommand
      handle : () -> Unit
    }

    CommandBinding::new

    source
    fn CommandBinding::new(command~ : ActionCommand, handle~ : () -> Unit) -> CommandBinding

    CommandIntent

    source
    pub(all) enum CommandIntent {
      Activate
      Submit
      Cancel
      Copy
      Cut
      Paste
      Undo
      Redo
      SelectAll
      OpenContextMenu
    } derive(Eq, ToJson, 
    Debug    )

    ComponentEffect

    source
    pub(all) struct ComponentEffect {
      key : String
      cleanup : () -> Unit?
      cleanup_with_reason : (ComponentEffectCancelReason) -> Unit?
      status : ComponentEffectStatus
      cancel_reason : ComponentEffectCancelReason?
      reused : Bool
    }

    ComponentEffect::cancel

    source
    fn ComponentEffect::cancel(self : ComponentEffect) -> Unit

    ComponentEffect::cancel_with_reason

    source
    fn ComponentEffect::cancel_with_reason(self : ComponentEffect, reason : ComponentEffectCancelReason) -> Unit

    ComponentEffect::new

    source
    fn ComponentEffect::new(key~ : String, cleanup? : () -> Unit?, cleanup_with_reason? : (ComponentEffectCancelReason) -> Unit?) -> ComponentEffect

    ComponentEffectCancelReason

    source
    pub(all) enum ComponentEffectCancelReason {
      EffectKeyChanged
      EffectUnmounted
      EffectRuntimeDestroyed
    } derive(Eq, ToJson, 
    Debug    )

    ComponentEffectStatus

    source
    pub(all) enum ComponentEffectStatus {
      EffectActive
      EffectCancelled
    } derive(Eq, ToJson, 
    Debug    )

    CompositionUpdate

    source
    pub(all) struct CompositionUpdate {
      text : String
      cursor : TextRange?
    } derive(Eq, ToJson, 
    Debug    )

    CompositionUpdate::new

    source
    fn CompositionUpdate::new(text~ : String, cursor? : TextRange?) -> CompositionUpdate

    Constraints

    source
    pub(all) struct Constraints {
      min : Size
      max : Size
    } derive(Eq, ToJson, 
    Debug    )

    Constraints::constrain

    source
    fn Constraints::constrain(self : Constraints, size : Size) -> Size

    Constraints::deflate

    source
    fn Constraints::deflate(self : Constraints, insets : Insets) -> Constraints

    Constraints::is_tight

    source
    fn Constraints::is_tight(self : Constraints) -> Bool

    Constraints::loose

    source
    fn Constraints::loose(max : Size) -> Constraints

    Constraints::loosen

    source
    fn Constraints::loosen(self : Constraints) -> Constraints

    Constraints::tight

    source
    fn Constraints::tight(size : Size) -> Constraints

    Constraints::tighten

    source
    fn Constraints::tighten(self : Constraints, width? : Double, height? : Double) -> Constraints

    Constraints::unbounded

    source
    fn Constraints::unbounded() -> Constraints

    ContentSizeCategory

    source
    pub(all) enum ContentSizeCategory {
      Small
      Medium
      Large
      ExtraLarge
      Accessibility
    } derive(Eq, ToJson, 
    Debug    )

    ContentSizeCategory::text_scale

    source
    fn ContentSizeCategory::text_scale(self : ContentSizeCategory) -> Double

    ControlStateStyle

    source
    pub(all) struct ControlStateStyle {
      foreground : Color
      background : Brush
      border : BorderStyle?
      radius : Double
      shadow : ShadowStyle?
    } derive(Eq, ToJson, 
    Debug    )

    CrossAxisAlignment

    source
    pub(all) enum CrossAxisAlignment {
      CrossStart
      CrossCenter
      CrossEnd
      CrossStretch
    } derive(Eq, ToJson, 
    Debug    )

    CustomLayoutCache

    source
    pub(all) struct CustomLayoutCache {
      entries : Array[CustomLayoutCacheEntry]
    }

    CustomLayoutCache::clear

    source
    fn CustomLayoutCache::clear(self : CustomLayoutCache) -> Unit

    CustomLayoutCache::get

    source
    fn CustomLayoutCache::get(self : CustomLayoutCache, key : String) -> String?

    CustomLayoutCache::new

    source

    CustomLayoutCache::set

    source
    fn CustomLayoutCache::set(self : CustomLayoutCache, key : String, value : String) -> Unit

    CustomLayoutCacheEntry

    source
    pub(all) struct CustomLayoutCacheEntry {
      key : String
      value : String
    } derive(Eq, ToJson, 
    Debug    )

    CustomLayoutContext

    source
    pub(all) struct CustomLayoutContext {
      constraints : Constraints
      child_sizes : Array[Size]
      child_baselines : Array[Double?]
      child_priorities : Array[Double]
      child_alignment_guides : Array[AlignmentGuideSet]
      cache : CustomLayoutCache
      cache_key : String
      layout_direction : LayoutDirection
      safe_area : Insets
      viewport : Size?
    }

    CustomPlacementContext

    source
    pub(all) struct CustomPlacementContext {
      frame : Rect
      measured_size : Size
      child_sizes : Array[Size]
      child_baselines : Array[Double?]
      child_priorities : Array[Double]
      child_alignment_guides : Array[AlignmentGuideSet]
      cache : CustomLayoutCache
      cache_key : String
      layout_direction : LayoutDirection
      safe_area : Insets
      viewport : Size?
    }

    CustomPlacementContext::mirror_x

    source
    fn CustomPlacementContext::mirror_x(self : CustomPlacementContext, x~ : Double, width~ : Double) -> Double

    DatePickerMode

    source
    pub(all) enum DatePickerMode {
      Date
      DateAndTime
      Time
    } derive(Eq, ToJson, 
    Debug    )

    DateValue

    source
    pub(all) struct DateValue {
      year : Int
      month : Int
      day : Int
      hour : Int
      minute : Int
      second : Int
    } derive(Eq, ToJson, 
    Debug    )

    DateValue::format

    source
    fn DateValue::format(self : DateValue, mode : DatePickerMode) -> String

    DateValue::new

    source
    fn DateValue::new(year~ : Int, month~ : Int, day~ : Int, hour? : Int, minute? : Int, second? : Int) -> DateValue

    DateValue::today

    source
    fn DateValue::today() -> DateValue

    DerivedState

    source
    pub(all) struct DerivedState[T] {
      get_value : () -> T
      subscribe_value : (() -> Unit) -> Array[StateSubscription]
    }

    DerivedState::combine

    source
    fn[A, B, T] DerivedState::combine(left : State[A], right : State[B], project : (A, B) -> T) -> DerivedState[T]

    DerivedState::from_state

    source
    fn[T, U] DerivedState::from_state(state : State[T], project : (T) -> U) -> DerivedState[U]

    DerivedState::get

    source
    fn[T] DerivedState::get(self : DerivedState[T]) -> T

    DerivedState::new

    source
    fn[T] DerivedState::new(get~ : () -> T, subscribe~ : (() -> Unit) -> Array[StateSubscription]) -> DerivedState[T]

    DerivedState::subscribe

    source
    fn[T] DerivedState::subscribe(self : DerivedState[T], callback : () -> Unit) -> Array[StateSubscription]

    DirtyFlags

    source
    pub(all) struct DirtyFlags {
      needs_build : Bool
      needs_layout : Bool
      needs_paint : Bool
    } derive(Eq, ToJson, 
    Debug    )

    DirtyFlags::all

    source
    fn DirtyFlags::all() -> DirtyFlags

    DirtyFlags::clean

    source
    fn DirtyFlags::clean() -> DirtyFlags

    DirtyFlags::clear

    source
    fn DirtyFlags::clear(self : DirtyFlags) -> Unit

    DirtyFlags::mark_build

    source
    fn DirtyFlags::mark_build(self : DirtyFlags) -> Unit

    DirtyFlags::mark_layout

    source
    fn DirtyFlags::mark_layout(self : DirtyFlags) -> Unit

    DirtyFlags::mark_paint

    source
    fn DirtyFlags::mark_paint(self : DirtyFlags) -> Unit

    DragDropEvent

    source
    pub(all) struct DragDropEvent {
      phase : DragDropPhase
      paths : Array[String]
      position : Point?
    } derive(Eq, ToJson, 
    Debug    )

    DragDropEvent::new

    source
    fn DragDropEvent::new(phase~ : DragDropPhase, paths? : Array[String], position? : Point?) -> DragDropEvent

    DragDropPhase

    source
    pub(all) enum DragDropPhase {
      Entered
      Moved
      Dropped
      Left
    } derive(Eq, ToJson, 
    Debug    )

    DrawCommand

    source
    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
      PushFilter(FilterEffect)
      PopFilter
      DrawPath(PathSpec)
      DrawShaderEffect(ShaderEffectSpec)
    } derive(Eq, ToJson, 
    Debug    )

    Easing

    source
    pub(all) enum Easing {
      Linear
      EaseIn
      EaseOut
      EaseInOut
    } derive(Eq, ToJson, 
    Debug    )

    Easing::sample

    source
    fn Easing::sample(self : Easing, progress : Double) -> Double

    Effect

    source
    pub(all) enum Effect[Msg] {
      NoEffect
      Batch(Array[Effect[Msg]])
      Send(Msg)
    }

    Effect::batch

    source
    fn[Msg] Effect::batch(effects : Array[Effect[Msg]]) -> Effect[Msg]

    Effect::none

    source
    fn[Msg] Effect::none() -> Effect[Msg]

    Effect::send

    source
    fn[Msg] Effect::send(message : Msg) -> Effect[Msg]

    ElementEventResult

    source
    type ElementEventResult derive(Eq, ToJson, 
    Debug    )

    ElementId

    source
    pub(all) struct ElementId {
      value : Int
    } derive(Eq, ToJson, 
    Debug    )

    ElementId::new

    source
    fn ElementId::new(value : Int) -> ElementId

    Environment

    source
    pub(all) struct Environment {
      theme : Theme
      color_scheme : ColorScheme
      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    )

    Environment::default

    source
    fn Environment::default() -> Environment

    Environment::with_accessibility_contrast

    source
    fn Environment::with_accessibility_contrast(self : Environment, accessibility_contrast : AccessibilityContrast) -> Environment

    Environment::with_color_scheme

    source
    fn Environment::with_color_scheme(self : Environment, color_scheme : ColorScheme) -> Environment

    Environment::with_content_size_category

    source
    fn Environment::with_content_size_category(self : Environment, content_size_category : ContentSizeCategory) -> Environment

    Environment::with_enabled

    source
    fn Environment::with_enabled(self : Environment, enabled : Bool) -> Environment

    Environment::with_layout_direction

    source
    fn Environment::with_layout_direction(self : Environment, layout_direction : LayoutDirection) -> Environment

    Environment::with_locale

    source
    fn Environment::with_locale(self : Environment, locale : String) -> Environment

    Environment::with_reduced_motion

    source
    fn Environment::with_reduced_motion(self : Environment, reduced_motion : Bool) -> Environment

    Environment::with_scale_factor

    source
    fn Environment::with_scale_factor(self : Environment, scale_factor : Double) -> Environment

    Environment::with_text_scale

    source
    fn Environment::with_text_scale(self : Environment, text_scale : Double) -> Environment

    Environment::with_theme

    source
    fn Environment::with_theme(self : Environment, theme : Theme) -> Environment

    FilterEffect

    source
    pub(all) enum FilterEffect {
      Blur(Double)
      Saturate(Double)
      Brightness(Double)
      Contrast(Double)
      ColorMatrix(Array[Double])
    } derive(Eq, ToJson, 
    Debug    )

    FilterEffect::blur

    source
    fn FilterEffect::blur(radius : Double) -> FilterEffect

    FocusState

    source
    pub struct FocusState {
      key_slot : State[String?]
    }

    FocusState::binding

    source
    fn FocusState::binding(self : FocusState) -> Binding[String?]

    FocusState::clear

    source
    fn FocusState::clear(self : FocusState) -> Unit

    FocusState::focus

    source
    fn FocusState::focus(self : FocusState, key : String) -> Unit

    FocusState::focused_key

    source
    fn FocusState::focused_key(self : FocusState) -> String?

    FocusState::new

    source
    fn FocusState::new(key? : String?) -> FocusState

    FontFamily

    source
    pub(all) enum FontFamily {
      Name(String)
      SystemUi
      UiSansSerif
      UiSerif
      UiMonospace
      SansSerif
      Serif
      Monospace
      Emoji
      Math
      FangSong
    } derive(Eq, ToJson, 
    Debug    )

    FontFamily::css_name

    source
    fn FontFamily::css_name(self : FontFamily) -> String

    FontFamily::css_token

    source
    fn FontFamily::css_token(self : FontFamily) -> String

    FontFamilyStack

    source
    pub(all) struct FontFamilyStack {
      families : Array[FontFamily]
    } derive(Eq, ToJson, 
    Debug    )

    FontFamilyStack::css

    source
    fn FontFamilyStack::css(self : FontFamilyStack) -> String

    FontFamilyStack::monospace

    source
    fn FontFamilyStack::monospace() -> FontFamilyStack

    FontFamilyStack::named

    source
    fn FontFamilyStack::named(name : String) -> FontFamilyStack

    FontFamilyStack::new

    source

    FontFamilyStack::sans_serif

    source
    fn FontFamilyStack::sans_serif() -> FontFamilyStack

    FontFamilyStack::serif

    source

    FontFamilyStack::system_ui

    source
    fn FontFamilyStack::system_ui() -> FontFamilyStack

    FontFamilyStack::with_fallback

    source
    fn FontFamilyStack::with_fallback(self : FontFamilyStack, family : FontFamily) -> FontFamilyStack

    FontSpec

    source
    pub(all) struct FontSpec {
      families : FontFamilyStack
      size : Double
      weight : Int
      style : FontStyle
    } derive(Eq, ToJson, 
    Debug    )

    FontSpec::css_family

    source
    fn FontSpec::css_family(self : FontSpec) -> String

    FontSpec::css_style

    source
    fn FontSpec::css_style(self : FontSpec) -> String

    FontSpec::new

    source
    fn FontSpec::new(families? : FontFamilyStack, size? : Double, weight? : Int, style? : FontStyle) -> FontSpec

    FontStyle

    source
    pub(all) enum FontStyle {
      Normal
      Italic
    } derive(Eq, ToJson, 
    Debug    )

    FormFieldError

    source
    pub(all) struct FormFieldError {
      name : String
      message : String
    } derive(Eq, ToJson, 
    Debug    )

    FormFieldState

    source
    pub(all) struct FormFieldState {
      name : String
      value : State[String]
      validator : (String) -> String?
    }

    FormFieldState::binding

    source
    fn FormFieldState::binding(self : FormFieldState) -> Binding[String]

    FormFieldState::new

    source
    fn FormFieldState::new(name~ : String, initial? : String, validator? : (String) -> String?) -> FormFieldState

    FormFieldState::validate

    source

    FormValidationResult

    source
    pub(all) struct FormValidationResult {
      valid : Bool
      errors : Array[FormFieldError]
    } derive(Eq, ToJson, 
    Debug    )

    Frame

    source
    pub(all) struct Frame {
      time_ms : Double
      delta_ms : Double
    } derive(Eq, ToJson, 
    Debug    )

    Frame::new

    source
    fn Frame::new(time_ms~ : Double, delta_ms~ : Double) -> Frame

    FrameProfile

    source
    pub(all) struct FrameProfile {
      frame : Frame
      dirty_count : Int
      draw_command_count : Int
      active_animations : Int
    } derive(Eq, ToJson, 
    Debug    )

    FrameProfile::capture

    source
    fn FrameProfile::capture(runtime : AppRuntime, frame : Frame) -> FrameProfile

    GestureArenaDisposition

    source
    pub(all) enum GestureArenaDisposition {
      Pending
      Accepted
      Rejected
    } derive(Eq, ToJson, 
    Debug    )

    GestureArenaMember

    source
    pub(all) struct GestureArenaMember {
      element_id : ElementId
      kind : GestureKind
      priority : Int
      disposition : GestureArenaDisposition
    } derive(Eq, ToJson, 
    Debug    )

    GestureArenaMember::accept

    source
    fn GestureArenaMember::accept(self : GestureArenaMember) -> Unit

    GestureArenaMember::is_pending

    source
    fn GestureArenaMember::is_pending(self : GestureArenaMember) -> Bool

    GestureArenaMember::new

    source
    fn GestureArenaMember::new(element_id~ : ElementId, kind~ : GestureKind, priority? : Int) -> GestureArenaMember

    GestureArenaMember::reject

    source
    fn GestureArenaMember::reject(self : GestureArenaMember) -> Unit

    GestureArenaResult

    source
    pub(all) struct GestureArenaResult {
      winner : GestureArenaMember?
      members : Array[GestureArenaMember]
    } derive(Eq, ToJson, 
    Debug    )

    GestureKind

    source
    pub(all) enum GestureKind {
      Tap
      Drag
      LongPress
      PanZoom
      Wheel
      Hover
    } derive(Eq, ToJson, 
    Debug    )

    HitTestEntry

    source
    pub(all) struct HitTestEntry {
      element_id : ElementId
      local_position : Point
      frame : Rect
    } derive(Eq, ToJson, 
    Debug    )

    HitTestResult

    source
    pub(all) struct HitTestResult {
      path : Array[HitTestEntry]
    } derive(Eq, ToJson, 
    Debug    )

    ImageFit

    source
    pub(all) enum ImageFit {
      Contain
      Cover
    } derive(Eq, ToJson, 
    Debug    )

    ImageRun

    source
    pub(all) struct ImageRun {
      source : String
      frame : Rect
      opacity : Double
      fit : ImageFit
    } derive(Eq, ToJson, 
    Debug    )

    Insets

    source
    pub(all) struct Insets {
      top : Double
      right : Double
      bottom : Double
      left : Double
    } derive(Eq, ToJson, 
    Debug    )

    Insets::all

    source
    fn Insets::all(value : Double) -> Insets

    Insets::symmetric

    source
    fn Insets::symmetric(horizontal? : Double, vertical? : Double) -> Insets

    Key

    source
    pub(all) struct Key {
      value : String
    } derive(Eq, ToJson, 
    Debug    )

    Key::new

    source
    fn Key::new(value : String) -> Key

    KeyModifiers

    source
    pub(all) struct KeyModifiers {
      shift : Bool
      control : Bool
      alt : Bool
      meta : Bool
    } derive(Eq, ToJson, 
    Debug    )

    KeyModifiers::new

    source
    fn KeyModifiers::new(shift? : Bool, control? : Bool, alt? : Bool, meta? : Bool) -> KeyModifiers

    KeyModifiers::none

    source

    KeyboardEvent

    source
    pub(all) struct KeyboardEvent {
      key : String
      text : String?
      pressed : Bool
      repeat : Bool
      modifiers : KeyModifiers
    } derive(Eq, ToJson, 
    Debug    )

    KeyboardEvent::new

    source
    fn KeyboardEvent::new(key~ : String, pressed? : Bool, text? : String?, repeat? : Bool, modifiers? : KeyModifiers) -> KeyboardEvent

    KeyboardShortcut

    source
    pub(all) struct KeyboardShortcut {
      key : String
      modifiers : KeyModifiers
    } derive(Eq, ToJson, 
    Debug    )

    KeyboardShortcut::matches

    source
    fn KeyboardShortcut::matches(self : KeyboardShortcut, event : KeyboardEvent) -> Bool

    KeyboardShortcut::new

    source
    fn KeyboardShortcut::new(key~ : String, modifiers? : KeyModifiers) -> KeyboardShortcut

    LayerMask

    source
    pub(all) enum LayerMask {
      NoMask
      RectMask(Rect)
      RoundedMask(RoundedRect)
    } derive(Eq, ToJson, 
    Debug    )

    LayerSpec

    source
    pub(all) struct LayerSpec {
      opacity : Double
      blend_mode : BlendMode
      mask : LayerMask
      offscreen : Bool
    } derive(Eq, ToJson, 
    Debug    )

    LayerSpec::new

    source
    fn LayerSpec::new(opacity? : Double, blend_mode? : BlendMode, mask? : LayerMask, offscreen? : Bool) -> LayerSpec

    LayoutDirection

    source
    pub(all) enum LayoutDirection {
      LeftToRight
      RightToLeft
    } derive(Eq, ToJson, 
    Debug    )

    LayoutInspectorSnapshot

    source
    pub(all) struct LayoutInspectorSnapshot {
      root_frame : Rect
      node_count : Int
      leaf_count : Int
      max_depth : Int
    } derive(Eq, ToJson, 
    Debug    )

    LayoutInspectorSnapshot::from_runtime

    source

    LayoutResult

    source
    pub(all) struct LayoutResult {
      frame : Rect
      children : Array[LayoutResult]
    } derive(Eq, ToJson, 
    Debug    )

    LinearGradientSpec

    source
    pub(all) struct LinearGradientSpec {
      start : Point
      end : Point
      start_color : Color
      end_color : Color
    } derive(Eq, ToJson, 
    Debug    )

    LinearGradientSpec::new

    source
    fn LinearGradientSpec::new(start~ : Point, end~ : Point, start_color~ : Color, end_color~ : Color) -> LinearGradientSpec

    MainAxisAlignment

    source
    pub(all) enum MainAxisAlignment {
      MainStart
      MainCenter
      MainEnd
      SpaceBetween
      SpaceAround
      SpaceEvenly
    } derive(Eq, ToJson, 
    Debug    )

    MeasuredNode

    source
    pub(all) struct MeasuredNode {
      element_id : ElementId
      size : Size
      children : Array[MeasuredNode]
    } derive(Eq, ToJson, 
    Debug    )

    MotionScale

    source
    pub(all) struct MotionScale {
      fast_ms : Double
      normal_ms : Double
      slow_ms : Double
      easing : Easing
    } derive(Eq, ToJson, 
    Debug    )

    MotionScale::default

    source
    fn MotionScale::default() -> MotionScale

    pub struct NavigationState {
      stack_slot : State[Array[String]]
    }

    fn NavigationState::binding(self : NavigationState) -> Binding[Array[String]]

    fn NavigationState::current(self : NavigationState) -> String

    fn NavigationState::new(initial? : String) -> NavigationState

    fn NavigationState::pop(self : NavigationState) -> Bool

    fn NavigationState::push(self : NavigationState, route : String) -> Unit

    fn NavigationState::replace(self : NavigationState, route : String) -> Unit

    fn NavigationState::stack(self : NavigationState) -> Array[String]

    PathSpec

    source
    pub(all) struct PathSpec {
      verbs : Array[PathVerb]
      fill : Brush?
      stroke : Brush?
      stroke_width : Double
    } derive(Eq, ToJson, 
    Debug    )

    PathSpec::new

    source
    fn PathSpec::new(verbs~ : Array[PathVerb], fill? : Brush?, stroke? : Brush?, stroke_width? : Double) -> PathSpec

    PathVerb

    source
    pub(all) enum PathVerb {
      MoveTo(Point)
      LineTo(Point)
      QuadTo(Point, Point)
      CubicTo(Point, Point, Point)
      Close
    } derive(Eq, ToJson, 
    Debug    )

    PickerItem

    source
    pub(all) struct PickerItem {
      id : String
      label : String
    }

    PlacedNode

    source
    pub(all) struct PlacedNode {
      element_id : ElementId
      frame : Rect
      children : Array[PlacedNode]
    } derive(Eq, ToJson, 
    Debug    )

    PlacedNode::to_layout_result

    source
    fn PlacedNode::to_layout_result(self : PlacedNode) -> LayoutResult

    Point

    source
    pub(all) struct Point {
      x : Double
      y : Double
    } derive(Eq, ToJson, 
    Debug    )

    Point::new

    source
    fn Point::new(x~ : Double, y~ : Double) -> Point

    PointerEvent

    source
    pub(all) struct PointerEvent {
      position : Point
      phase : PointerPhase
      button : Int
      wheel_delta : Point
    } derive(Eq, ToJson, 
    Debug    )

    PointerEvent::new

    source
    fn PointerEvent::new(position~ : Point, phase~ : PointerPhase, button? : Int, wheel_delta? : Point) -> PointerEvent

    PointerPhase

    source
    pub(all) enum PointerPhase {
      Move
      Down
      Up
      Cancel
    } derive(Eq, ToJson, 
    Debug    )

    Program

    source
    pub(all) struct Program[Model, Msg] {
      init : () -> (Model, Effect[Msg])
      update : (Model, Msg) -> (Model, Effect[Msg])
      view : (Model, ViewEnvironment) -> View[Msg]
    }

    Program::new

    source
    fn[Model, Msg] Program::new(init~ : () -> (Model, Effect[Msg]), update~ : (Model, Msg) -> (Model, Effect[Msg]), view~ : (Model) -> View[Msg]) -> Program[Model, Msg]

    Program::new_with_environment

    source
    fn[Model, Msg] Program::new_with_environment(init~ : () -> (Model, Effect[Msg]), update~ : (Model, Msg) -> (Model, Effect[Msg]), view~ : (Model, ViewEnvironment) -> View[Msg]) -> Program[Model, Msg]

    Program::simple

    source
    fn[Model, Msg] Program::simple(init~ : Model, update~ : (Model, Msg) -> Model, view~ : (Model) -> View[Msg]) -> Program[Model, Msg]

    Program::simple_with_environment

    source
    fn[Model, Msg] Program::simple_with_environment(init~ : Model, update~ : (Model, Msg) -> Model, view~ : (Model, ViewEnvironment) -> View[Msg]) -> Program[Model, Msg]

    RadiusScale

    source
    pub(all) struct RadiusScale {
      sm : Double
      md : Double
      lg : Double
      pill : Double
    } derive(Eq, ToJson, 
    Debug    )

    RadiusScale::default

    source
    fn RadiusScale::default() -> RadiusScale

    Rect

    source
    pub(all) struct Rect {
      origin : Point
      size : Size
    } derive(Eq, ToJson, 
    Debug    )

    Rect::contains

    source
    fn Rect::contains(self : Rect, point : Point) -> Bool

    Rect::inset

    source
    fn Rect::inset(self : Rect, insets : Insets) -> Rect

    Rect::new

    source
    fn Rect::new(x~ : Double, y~ : Double, width~ : Double, height~ : Double) -> Rect

    Rect::offset

    source
    fn Rect::offset(self : Rect, dx? : Double, dy? : Double) -> Rect

    RedrawReason

    source
    pub(all) enum RedrawReason {
      Initial
      Input
      Resize
      Explicit
    } derive(Eq, ToJson, 
    Debug    )

    RenderInspectorSnapshot

    source
    pub(all) struct RenderInspectorSnapshot {
      command_count : Int
      text_count : Int
      image_count : Int
      clip_depth : Int
      open_clip_depth : Int
      layer_depth : Int
      open_layer_depth : Int
      filter_depth : Int
      open_filter_depth : Int
      path_count : Int
      shader_count : Int
      unbalanced_pop_count : Int
    } derive(Eq, ToJson, 
    Debug    )

    RenderInspectorSnapshot::from_commands

    source

    RenderInspectorSnapshot::from_runtime

    source

    RenderNode

    source
    type RenderNode derive(Eq, ToJson, 
    Debug    )

    RichTextBlock

    source
    pub(all) struct RichTextBlock {
      runs : Array[RichTextRun]
      table : RichTextTable?
      prefix : String
      font : FontSpec?
      color : Color?
      background : Brush?
      border_left : BorderStyle?
      inset : Insets
      line_height : Double?
      corner_radius : Double
      rule : Bool
      source_range : RichTextSourceRange?
      content_range : RichTextSourceRange?
    } derive(Eq, ToJson, 
    Debug    )

    RichTextBlock::new

    source
    fn RichTextBlock::new(runs~ : Array[RichTextRun], table? : RichTextTable?, prefix? : String, font? : FontSpec?, color? : Color?, background? : Brush?, border_left? : BorderStyle?, inset? : Insets, line_height? : Double?, corner_radius? : Double, rule? : Bool, source_range? : RichTextSourceRange?, content_range? : RichTextSourceRange?) -> RichTextBlock

    RichTextDecoration

    source
    pub(all) enum RichTextDecoration {
      Strikethrough
    } derive(Eq, ToJson, 
    Debug    )

    RichTextDocument

    source
    pub(all) struct RichTextDocument {
      blocks : Array[RichTextBlock]
    } derive(Eq, ToJson, 
    Debug    )

    RichTextDocument::new

    source

    RichTextDocument::plain

    source
    fn RichTextDocument::plain(text : String) -> RichTextDocument

    RichTextInputTransform

    source
    pub(all) struct RichTextInputTransform {
      text : String
      caret : Int
      selection : TextRange?
    } derive(Eq, ToJson, 
    Debug    )

    RichTextInputTransform::new

    source
    fn RichTextInputTransform::new(text~ : String, caret~ : Int, selection? : TextRange?) -> RichTextInputTransform

    RichTextRun

    source
    pub(all) struct RichTextRun {
      text : String
      visual_text : String?
      image_source : String?
      image_size : Size?
      image_fit : ImageFit
      font : FontSpec?
      color : Color?
      background : Brush?
      background_radius : Double
      decoration : RichTextDecoration?
      source_range : RichTextSourceRange?
    } derive(Eq, ToJson, 
    Debug    )

    RichTextRun::new

    source
    fn RichTextRun::new(text~ : String, visual_text? : String?, image_source? : String?, image_size? : Size?, image_fit? : ImageFit, font? : FontSpec?, color? : Color?, background? : Brush?, background_radius? : Double, decoration? : RichTextDecoration?, source_range? : RichTextSourceRange?) -> RichTextRun

    RichTextSourceRange

    source
    pub(all) struct RichTextSourceRange {
      start : Int
      end : Int
    } derive(Eq, ToJson, 
    Debug    )

    RichTextTable

    source
    pub(all) struct RichTextTable {
      rows : Array[Array[RichTextTableCell]]
      row_height : Double
      cell_padding : Insets
      border : Color
      header_background : Brush?
    } derive(Eq, ToJson, 
    Debug    )

    RichTextTableCell

    source
    pub(all) struct RichTextTableCell {
      text : String
      header : Bool
      align : TextAlign?
      source_range : RichTextSourceRange?
    } derive(Eq, ToJson, 
    Debug    )

    RoundedRect

    source
    pub(all) struct RoundedRect {
      rect : Rect
      radius : Double
    } derive(Eq, ToJson, 
    Debug    )

    RoundedRect::new

    source
    fn RoundedRect::new(rect~ : Rect, radius? : Double) -> RoundedRect

    RouteLocation

    source
    pub(all) struct RouteLocation {
      path : String
      query : Array[RouteQueryParam]
    } derive(Eq, ToJson, 
    Debug    )

    RouteLocation::new

    source
    fn RouteLocation::new(path~ : String, query? : Array[RouteQueryParam]) -> RouteLocation

    RouteLocation::parse

    source
    fn RouteLocation::parse(value : String) -> RouteLocation

    RouteLocation::query_value

    source
    fn RouteLocation::query_value(self : RouteLocation, key : String) -> String?

    RouteLocation::to_route

    source
    fn RouteLocation::to_route(self : RouteLocation) -> String

    RouteQueryParam

    source
    pub(all) struct RouteQueryParam {
      key : String
      value : String
    } derive(Eq, ToJson, 
    Debug    )

    RouterState

    source
    pub(all) struct RouterState {
      navigation : NavigationState
    }

    RouterState::current

    source
    fn RouterState::current(self : RouterState) -> RouteLocation

    RouterState::new

    source
    fn RouterState::new(initial? : RouteLocation) -> RouterState

    RouterState::pop

    source
    fn RouterState::pop(self : RouterState) -> Bool

    RouterState::push

    source
    fn RouterState::push(self : RouterState, location : RouteLocation) -> Unit

    RouterState::replace

    source
    fn RouterState::replace(self : RouterState, location : RouteLocation) -> Unit

    RuntimeInspectorSnapshot

    source
    pub(all) struct RuntimeInspectorSnapshot {
      size : Size
      dirty_count : Int
      needs_rebuild : Bool
      needs_layout : Bool
      needs_paint : Bool
      needs_redraw : Bool
      draw_command_count : Int
    }

    RuntimeInspectorSnapshot::from_runtime

    source

    RuntimeState

    source
    type RuntimeState

    RuntimeState::action_commands

    source
    fn RuntimeState::action_commands(self : RuntimeState) -> Array[ActionCommand]

    RuntimeState::add_animation

    source
    fn RuntimeState::add_animation(self : RuntimeState, controller : AnimationController) -> Unit

    RuntimeState::advance_time

    source
    fn RuntimeState::advance_time(self : RuntimeState, time_ms : Double) -> Unit

    RuntimeState::animation_count

    source
    fn RuntimeState::animation_count(self : RuntimeState) -> Int

    RuntimeState::build_draw_commands

    source
    fn RuntimeState::build_draw_commands(self : RuntimeState) -> Array[DrawCommand]

    RuntimeState::clear_dirty_queue

    source
    fn RuntimeState::clear_dirty_queue(self : RuntimeState) -> Unit

    RuntimeState::destroy

    source
    fn RuntimeState::destroy(self : RuntimeState) -> Unit

    RuntimeState::dirty_count

    source
    fn RuntimeState::dirty_count(self : RuntimeState) -> Int

    RuntimeState::dispatch_command

    source
    fn RuntimeState::dispatch_command(self : RuntimeState, intent : CommandIntent) -> Bool

    RuntimeState::dispatch_event

    source
    fn RuntimeState::dispatch_event(self : RuntimeState, event : AppEvent) -> Unit

    RuntimeState::dispatch_focused_text_command

    source
    fn RuntimeState::dispatch_focused_text_command(self : RuntimeState, intent : CommandIntent, paste_text? : String?) -> TextCommandResult

    RuntimeState::environment

    source
    fn RuntimeState::environment(self : RuntimeState) -> Environment

    RuntimeState::focused_text_input

    source
    fn RuntimeState::focused_text_input(self : RuntimeState) -> TextInputState

    RuntimeState::layout

    source
    fn RuntimeState::layout(self : RuntimeState) -> LayoutResult

    RuntimeState::layout_pass

    source
    fn RuntimeState::layout_pass(self : RuntimeState) -> Unit

    RuntimeState::mark_dirty

    source
    fn RuntimeState::mark_dirty(self : RuntimeState, id : ElementId) -> Unit

    RuntimeState::paint_pass

    source
    fn RuntimeState::paint_pass(self : RuntimeState) -> Array[DrawCommand]

    RuntimeState::rebuild

    source
    fn RuntimeState::rebuild(self : RuntimeState) -> Unit

    RuntimeState::rebuild_if_possible

    source
    fn RuntimeState::rebuild_if_possible(self : RuntimeState) -> Unit

    RuntimeState::register_font_data

    source
    fn RuntimeState::register_font_data(self : RuntimeState, family : FontFamily, data : Bytes) -> Unit

    RuntimeState::request_rebuild

    source
    fn RuntimeState::request_rebuild(self : RuntimeState) -> Unit

    RuntimeState::semantics

    source
    fn RuntimeState::semantics(self : RuntimeState) -> SemanticsNode

    RuntimeState::set_action_commands

    source
    fn RuntimeState::set_action_commands(self : RuntimeState, commands : ActionCommandMap) -> Unit

    RuntimeState::set_environment

    source
    fn RuntimeState::set_environment(self : RuntimeState, environment : Environment) -> Unit

    RuntimeState::set_redraw_callback

    source
    fn RuntimeState::set_redraw_callback(self : RuntimeState, callback : () -> Unit) -> Unit

    RuntimeState::set_text_system

    source
    fn RuntimeState::set_text_system(self : RuntimeState, text_system : TextSystem) -> Unit

    RuntimeState::text_system

    source
    fn RuntimeState::text_system(self : RuntimeState) -> TextSystem

    SaveableCodec

    source
    pub struct SaveableCodec[T] {
      encode : (T) -> String
      decode : (String) -> T?
    }

    SaveableCodec::bool

    source
    fn SaveableCodec::bool() -> SaveableCodec[Bool]

    SaveableCodec::int

    source
    fn SaveableCodec::int() -> SaveableCodec[Int]

    SaveableCodec::new

    source
    fn[T] SaveableCodec::new(encode~ : (T) -> String, decode~ : (String) -> T?) -> SaveableCodec[T]

    SaveableCodec::string

    source
    fn SaveableCodec::string() -> SaveableCodec[String]

    SaveableStateStore

    source
    pub struct SaveableStateStore {
      strings : Array[SaveableStringEntry]
    }

    SaveableStateStore::get

    source
    fn[T] SaveableStateStore::get(self : SaveableStateStore, key : String, codec : SaveableCodec[T]) -> T?

    SaveableStateStore::get_bool

    source
    fn SaveableStateStore::get_bool(self : SaveableStateStore, key : String) -> Bool?

    SaveableStateStore::get_int

    source
    fn SaveableStateStore::get_int(self : SaveableStateStore, key : String) -> Int?

    SaveableStateStore::get_string

    source
    fn SaveableStateStore::get_string(self : SaveableStateStore, key : String) -> String?

    SaveableStateStore::new

    source

    SaveableStateStore::remove

    source
    fn SaveableStateStore::remove(self : SaveableStateStore, key : String) -> Unit

    SaveableStateStore::set

    source
    fn[T] SaveableStateStore::set(self : SaveableStateStore, key : String, value : T, codec : SaveableCodec[T]) -> Unit

    SaveableStateStore::set_bool

    source
    fn SaveableStateStore::set_bool(self : SaveableStateStore, key : String, value : Bool) -> Unit

    SaveableStateStore::set_int

    source
    fn SaveableStateStore::set_int(self : SaveableStateStore, key : String, value : Int) -> Unit

    SaveableStateStore::set_string

    source
    fn SaveableStateStore::set_string(self : SaveableStateStore, key : String, value : String) -> Unit

    SaveableStringEntry

    source
    pub(all) struct SaveableStringEntry {
      key : String
      value : String
    } derive(Eq, ToJson, 
    Debug    )

    ScrollState

    source
    pub struct ScrollState {
      offset_slot : State[Point]
    }

    ScrollState::binding

    source
    fn ScrollState::binding(self : ScrollState) -> Binding[Point]

    ScrollState::new

    source
    fn ScrollState::new(offset? : Point) -> ScrollState

    ScrollState::offset

    source
    fn ScrollState::offset(self : ScrollState) -> Point

    ScrollState::scroll_to

    source
    fn ScrollState::scroll_to(self : ScrollState, x~ : Double, y~ : Double) -> Unit

    ScrollState::set_offset

    source
    fn ScrollState::set_offset(self : ScrollState, offset : Point) -> Unit

    SemanticsAction

    source
    pub(all) enum SemanticsAction {
      Activate
      Focus
      SetText
      Submit
      Scroll
    } derive(Eq, ToJson, 
    Debug    )

    SemanticsInspectorSnapshot

    source
    pub(all) struct SemanticsInspectorSnapshot {
      root_role : SemanticsRole
      node_count : Int
      focusable_count : Int
      action_count : Int
      max_depth : Int
    } derive(Eq, ToJson, 
    Debug    )

    SemanticsInspectorSnapshot::from_runtime

    source

    SemanticsNode

    source
    pub(all) struct SemanticsNode {
      element_id : ElementId
      role : SemanticsRole
      label : String
      value : String
      state : SemanticsState
      actions : Array[SemanticsAction]
      focus_order : Int?
      frame : Rect
      children : Array[SemanticsNode]
    } derive(Eq, ToJson, 
    Debug    )

    SemanticsRole

    source
    pub(all) enum SemanticsRole {
      None
      Text
      Button
      Checkbox
      TextField
      List
      ListItem
      Grid
      ScrollView
      Switch
      Radio
      Slider
      Progress
      Tab
      Dialog
      Tooltip
      Menu
      Group
    } derive(Eq, ToJson, 
    Debug    )

    SemanticsState

    source
    pub(all) struct SemanticsState {
      focused : Bool
      disabled : Bool
      selected : Bool
      checked : Bool
      expanded : Bool
    } derive(Eq, ToJson, 
    Debug    )

    SemanticsState::default

    source

    ShaderEffectSpec

    source
    pub(all) struct ShaderEffectSpec {
      name : String
      frame : Rect
      uniforms : Array[Double]
      fallback : Brush
    } derive(Eq, ToJson, 
    Debug    )

    ShaderEffectSpec::new

    source
    fn ShaderEffectSpec::new(name~ : String, frame~ : Rect, uniforms? : Array[Double], fallback? : Brush) -> ShaderEffectSpec

    ShadowScale

    source
    pub(all) struct ShadowScale {
      sm : ShadowStyle
      md : ShadowStyle
      lg : ShadowStyle
    } derive(Eq, ToJson, 
    Debug    )

    ShadowScale::default

    source
    fn ShadowScale::default(scheme? : ColorScheme) -> ShadowScale

    ShadowSpec

    source
    pub(all) struct ShadowSpec {
      rect : RoundedRect
      color : Color
      offset : Point
      blur_radius : Double
      spread : Double
    } derive(Eq, ToJson, 
    Debug    )

    ShadowSpec::new

    source
    fn ShadowSpec::new(rect~ : RoundedRect, color~ : Color, offset? : Point, blur_radius? : Double, spread? : Double) -> ShadowSpec

    ShadowStyle

    source
    pub(all) struct ShadowStyle {
      color : Color
      offset : Point
      blur_radius : Double
      spread : Double
    } derive(Eq, ToJson, 
    Debug    )

    ShadowStyle::new

    source
    fn ShadowStyle::new(color~ : Color, offset? : Point, blur_radius? : Double, spread? : Double) -> ShadowStyle

    SheetPresentationMode

    source
    pub(all) enum SheetPresentationMode {
      Modal
      BottomSheet
    } derive(Eq, ToJson, 
    Debug    )

    Size

    source
    pub(all) struct Size {
      width : Double
      height : Double
    } derive(Eq, ToJson, 
    Debug    )

    Size::clamp

    source
    fn Size::clamp(self : Size, constraints : Constraints) -> Size

    Size::inflate

    source
    fn Size::inflate(self : Size, insets : Insets) -> Size

    Size::new

    source
    fn Size::new(width~ : Double, height~ : Double) -> Size

    SpacingScale

    source
    pub(all) struct SpacingScale {
      xs : Double
      sm : Double
      md : Double
      lg : Double
      xl : Double
    } derive(Eq, ToJson, 
    Debug    )

    SpacingScale::default

    source
    fn SpacingScale::default() -> SpacingScale

    State

    source
    pub(all) struct State[T] {
      slot : StateSlot[T]
    }

    State::binding

    source
    fn[T] State::binding(self : State[T]) -> Binding[T]

    State::derived

    source
    fn[T, U] State::derived(self : State[T], project : (T) -> U) -> DerivedState[U]

    State::get

    source
    fn[T] State::get(self : State[T]) -> T

    State::new

    source
    fn[T] State::new(value : T) -> State[T]

    State::set

    source
    fn[T] State::set(self : State[T], value : T) -> Unit

    State::subscribe

    source
    fn[T] State::subscribe(self : State[T], callback : () -> Unit) -> StateSubscription

    State::update

    source
    fn[T] State::update(self : State[T], f : (T) -> T raise?) -> Unit raise?

    State::version

    source
    fn[T] State::version(self : State[T]) -> Int

    StateListener

    source
    pub(all) struct StateListener {
      active : Bool
      callback : () -> Unit
    }

    StateListener::new

    source
    fn StateListener::new(callback : () -> Unit) -> StateListener

    StateSlot

    source
    pub(all) struct StateSlot[T] {
      value : T
      version : Int
      listeners : Array[StateListener]
    }

    StateSlot::get

    source
    fn[T] StateSlot::get(self : StateSlot[T]) -> T

    StateSlot::new

    source
    fn[T] StateSlot::new(value : T) -> StateSlot[T]

    StateSlot::set

    source
    fn[T] StateSlot::set(self : StateSlot[T], value : T) -> Unit

    StateSlot::subscribe

    source
    fn[T] StateSlot::subscribe(self : StateSlot[T], callback : () -> Unit) -> StateSubscription

    StateSlot::update

    source
    fn[T] StateSlot::update(self : StateSlot[T], f : (T) -> T raise?) -> Unit raise?

    StateSubscription

    source
    pub(all) struct StateSubscription {
      listener : StateListener
    }

    StateSubscription::cancel

    source
    fn StateSubscription::cancel(self : StateSubscription) -> Unit

    StateSubscription::is_active

    source
    fn StateSubscription::is_active(self : StateSubscription) -> Bool

    SurfaceLevel

    source
    pub(all) enum SurfaceLevel {
      Base
      Raised
      Overlay
    } derive(Eq, ToJson, 
    Debug    )

    SurfaceScale

    source
    pub(all) struct SurfaceScale {
      base : Brush
      raised : Brush
      overlay : Brush
    } derive(Eq, ToJson, 
    Debug    )

    SurfaceScale::default

    source
    fn SurfaceScale::default(palette : ColorPalette, scheme : ColorScheme) -> SurfaceScale

    SurfaceStyle

    source
    pub(all) struct SurfaceStyle {
      brush : Brush
      border : BorderStyle?
      radius : Double
      shadow : ShadowStyle?
      padding : Insets
      level : SurfaceLevel
    } derive(Eq, ToJson, 
    Debug    )

    SurfaceStyle::default

    source
    fn SurfaceStyle::default(theme? : Theme) -> SurfaceStyle

    SurfaceStyle::raised

    source
    fn SurfaceStyle::raised(theme? : Theme) -> SurfaceStyle

    TapGestureResult

    source
    pub(all) struct TapGestureResult {
      next_state : ButtonState
      activated : Bool
    } derive(Eq, ToJson, 
    Debug    )

    TextAlign

    source
    pub(all) enum TextAlign {
      TextStart
      TextCenter
      TextEnd
    } derive(Eq, ToJson, 
    Debug    )

    TextCommandResult

    source
    pub(all) struct TextCommandResult {
      handled : Bool
      changed : Bool
      clipboard_text : String?
    } derive(Eq, ToJson, 
    Debug    )

    TextFieldStyle

    source
    pub(all) struct TextFieldStyle {
      normal : ControlStateStyle
      focused : ControlStateStyle
      disabled : ControlStateStyle
      placeholder_color : Color
      cursor_color : Color
      font : FontSpec
    } derive(Eq, ToJson, 
    Debug    )

    TextFieldStyle::filled

    source
    fn TextFieldStyle::filled(theme? : Theme) -> TextFieldStyle

    TextFieldStyle::outline

    source
    fn TextFieldStyle::outline(theme? : Theme) -> TextFieldStyle

    TextHistoryEntry

    source
    type TextHistoryEntry derive(Eq, ToJson, 
    Debug    )

    TextInputEvent

    source
    pub(all) enum TextInputEvent {
      InsertText(String)
      CompositionStart
      CompositionUpdate(CompositionUpdate)
      CompositionEnd(String)
      DeleteRange(TextRange)
      DeleteSurrounding(Int, Int)
    } derive(Eq, ToJson, 
    Debug    )

    TextInputState

    source
    pub(all) struct TextInputState {
      focused : Bool
      element_id : ElementId?
      text : String
      caret : Int
      selection : TextRange?
      composition : String?
      composition_cursor : TextRange?
      frame : Rect
      caret_rect : Rect
    } derive(Eq, ToJson, 
    Debug    )

    TextInputState::none

    source

    TextLayoutInput

    source
    pub(all) struct TextLayoutInput {
      text : String
      font : FontSpec
      max_width : Double?
    } derive(Eq, ToJson, 
    Debug    )

    TextLayoutInput::new

    source
    fn TextLayoutInput::new(text~ : String, font~ : FontSpec, max_width? : Double) -> TextLayoutInput

    TextLayoutResult

    source
    pub(all) struct TextLayoutResult {
      size : Size
      baseline : Double
      caret_positions : Array[Double]
    } derive(Eq, ToJson, 
    Debug    )

    TextRange

    source
    pub(all) struct TextRange {
      start : Int
      end : Int
    } derive(Eq, ToJson, 
    Debug    )

    TextRange::collapsed

    source
    fn TextRange::collapsed(index : Int) -> TextRange

    TextRange::is_collapsed

    source
    fn TextRange::is_collapsed(self : TextRange) -> Bool

    TextRange::new

    source
    fn TextRange::new(start~ : Int, end~ : Int) -> TextRange

    TextRange::normalized

    source
    fn TextRange::normalized(self : TextRange) -> TextRange

    TextRun

    source
    pub(all) struct TextRun {
      text : String
      frame : Rect
      font : FontSpec
      color : Color
      align : TextAlign
    } derive(Eq, ToJson, 
    Debug    )

    TextRun::new

    source
    fn TextRun::new(text~ : String, frame~ : Rect, font~ : FontSpec, color~ : Color, align? : TextAlign) -> TextRun

    TextStyle

    source
    pub(all) struct TextStyle {
      font : FontSpec
      color : Color
    } derive(Eq, ToJson, 
    Debug    )

    TextStyle::body

    source
    fn TextStyle::body(theme? : Theme) -> TextStyle

    TextStyle::title

    source
    fn TextStyle::title(theme? : Theme) -> TextStyle

    TextSystem

    source
    pub struct TextSystem {
      id : String
      measure : (TextLayoutInput) -> TextLayoutResult
      register_font_data : (FontFamily, Bytes) -> Unit
    }

    TextSystem::fallback

    source
    fn TextSystem::fallback() -> TextSystem

    TextSystem::id

    source
    fn TextSystem::id(self : TextSystem) -> String

    TextSystem::measure_text

    source
    fn TextSystem::measure_text(self : TextSystem, input : TextLayoutInput) -> TextLayoutResult

    TextSystem::new

    source
    fn TextSystem::new(id~ : String, measure~ : (TextLayoutInput) -> TextLayoutResult, register_font_data? : (FontFamily, Bytes) -> Unit) -> TextSystem

    TextSystem::register_font_data

    source
    fn TextSystem::register_font_data(self : TextSystem, family : FontFamily, data : Bytes) -> Unit

    Theme

    source
    pub(all) struct Theme {
      scheme : ColorScheme
      palette : ColorPalette
      spacing_scale : SpacingScale
      radius_scale : RadiusScale
      typography : TypographyScale
      shadow_scale : ShadowScale
      motion : MotionScale
      surfaces : SurfaceScale
      font : FontSpec
      foreground : Color
      background : Color
      accent : Color
      spacing : Double
      corner_radius : Double
    } derive(Eq, ToJson, 
    Debug    )

    Theme::dark

    source
    fn Theme::dark() -> Theme

    Theme::default

    source
    fn Theme::default() -> Theme

    Theme::light

    source
    fn Theme::light() -> Theme

    Theme::surface_brush

    source
    fn Theme::surface_brush(self : Theme, level : SurfaceLevel) -> Brush

    Theme::with_accent

    source
    fn Theme::with_accent(self : Theme, color : Color) -> Theme

    Theme::with_background

    source
    fn Theme::with_background(self : Theme, color : Color) -> Theme

    Theme::with_corner_radius

    source
    fn Theme::with_corner_radius(self : Theme, radius : Double) -> Theme

    Theme::with_font

    source
    fn Theme::with_font(self : Theme, font : FontSpec) -> Theme

    Theme::with_foreground

    source
    fn Theme::with_foreground(self : Theme, color : Color) -> Theme

    Theme::with_motion

    source
    fn Theme::with_motion(self : Theme, motion : MotionScale) -> Theme

    Theme::with_palette

    source
    fn Theme::with_palette(self : Theme, palette : ColorPalette) -> Theme

    Theme::with_radius_scale

    source
    fn Theme::with_radius_scale(self : Theme, radius_scale : RadiusScale) -> Theme

    Theme::with_shadow_scale

    source
    fn Theme::with_shadow_scale(self : Theme, shadow_scale : ShadowScale) -> Theme

    Theme::with_spacing

    source
    fn Theme::with_spacing(self : Theme, spacing : Double) -> Theme

    Theme::with_spacing_scale

    source
    fn Theme::with_spacing_scale(self : Theme, spacing_scale : SpacingScale) -> Theme

    Theme::with_surfaces

    source
    fn Theme::with_surfaces(self : Theme, surfaces : SurfaceScale) -> Theme

    Theme::with_typography

    source
    fn Theme::with_typography(self : Theme, typography : TypographyScale) -> Theme

    Transform2D

    source
    pub(all) struct Transform2D {
      a : Double
      b : Double
      c : Double
      d : Double
      tx : Double
      ty : Double
    } derive(Eq, ToJson, 
    Debug    )

    Transform2D::identity

    source
    fn Transform2D::identity() -> Transform2D

    Transform2D::scale

    source
    fn Transform2D::scale(sx~ : Double, sy~ : Double) -> Transform2D

    Transform2D::translation

    source
    fn Transform2D::translation(dx~ : Double, dy~ : Double) -> Transform2D

    Tween

    source
    pub(all) struct Tween {
      from : Double
      to : Double
      easing : Easing
    } derive(Eq, ToJson, 
    Debug    )

    Tween::new

    source
    fn Tween::new(from~ : Double, to~ : Double, easing? : Easing) -> Tween

    Tween::value

    source
    fn Tween::value(self : Tween, progress : Double) -> Double

    TypographyScale

    source
    pub(all) struct TypographyScale {
      body : FontSpec
      title : FontSpec
      caption : FontSpec
      control : FontSpec
    } derive(Eq, ToJson, 
    Debug    )

    TypographyScale::default

    source

    View

    source
    pub struct View[Msg] {
      // private fields
    }

    View::accessibility_label

    source
    fn[Msg] View::accessibility_label(self : View[Msg], label : String) -> View[Msg]

    View::align

    source
    fn[Msg] View::align(self : View[Msg], alignment? : Alignment) -> View[Msg]

    View::aspect_ratio

    source
    fn[Msg] View::aspect_ratio(self : View[Msg], ratio : Double) -> View[Msg]

    View::background

    source
    fn[Msg] View::background(self : View[Msg], color : Color) -> View[Msg]

    View::background_brush

    source
    fn[Msg] View::background_brush(self : View[Msg], brush : Brush) -> View[Msg]

    View::border

    source
    fn[Msg] View::border(self : View[Msg], style : BorderStyle) -> View[Msg]

    View::button

    source
    fn[Msg] View::button(text~ : String, size~ : Size, font~ : FontSpec, foreground~ : Color, background~ : Brush, hovered_background~ : Brush, pressed_background~ : Brush, border? : BorderStyle?, shadow? : ShadowStyle?, corner_radius? : Double, on_click? : Msg?) -> View[Msg]

    View::caption

    source
    fn[Msg] View::caption(self : View[Msg]) -> View[Msg]

    View::checkbox

    source
    fn[Msg] View::checkbox(label~ : String, checked~ : Binding[Bool], font~ : FontSpec, foreground~ : Color, check_color~ : Color, size~ : Size) -> View[Msg]

    View::clip

    source
    fn[Msg] View::clip(self : View[Msg]) -> View[Msg]

    View::component

    source
    fn[Msg] View::component(build : (BuildContext) -> View[Msg]) -> View[Msg]

    View::container

    source
    fn[Msg] View::container(child? : View[Msg]?, size? : Size?, background? : Brush?, border? : BorderStyle?, corner_radius? : Double, shadow? : ShadowStyle?) -> View[Msg]

    View::controlled_checkbox

    source
    fn[Msg] View::controlled_checkbox(label~ : String, checked~ : Bool, on_change~ : (Bool) -> Msg, font~ : FontSpec, foreground~ : Color, check_color~ : Color, size~ : Size) -> View[Msg]

    View::controlled_datepicker

    source
    fn[Msg] View::controlled_datepicker(selected~ : DateValue, on_select~ : (DateValue) -> Msg, mode~ : DatePickerMode, placeholder~ : String, font~ : FontSpec, foreground~ : Color, background~ : Brush, corner_radius~ : Double, min_date? : DateValue?, max_date? : DateValue?) -> View[Msg]

    View::controlled_picker

    source
    fn[Msg] View::controlled_picker(items~ : Array[PickerItem], selected~ : String, on_select~ : (String) -> Msg, placeholder~ : String, font~ : FontSpec, foreground~ : Color, background~ : Brush, corner_radius~ : Double, max_height~ : Double) -> View[Msg]

    View::controlled_rich_text_editor

    source
    fn[Msg] View::controlled_rich_text_editor(value~ : String, on_input~ : (String) -> Msg, placeholder~ : String, size~ : Size, format~ : (String) -> RichTextDocument, font~ : FontSpec, foreground~ : Color, placeholder_color~ : Color, background~ : Brush, border? : BorderStyle?, focused_border? : BorderStyle?, cursor_color~ : Color, corner_radius? : Double, on_selection_change? : (Int, TextRange?) -> Msg?, on_prefix_click? : (Int) -> Msg?, input_transform? : (String, Int, TextRange?, String) -> RichTextInputTransform??, accepts_tab_input? : Bool) -> View[Msg]

    fn[Msg] View::controlled_search_bar(query~ : String, on_input~ : (String) -> Msg, placeholder~ : String, font~ : FontSpec, foreground~ : Color, placeholder_color~ : Color, background~ : Brush, border? : BorderStyle?, focused_border? : BorderStyle?, cursor_color~ : Color, corner_radius~ : Double, on_submit? : Msg?, on_clear? : Msg?) -> View[Msg]

    View::controlled_text_field

    source
    fn[Msg] View::controlled_text_field(value~ : String, on_input~ : (String) -> Msg, placeholder~ : String, size~ : Size, font~ : FontSpec, foreground~ : Color, placeholder_color~ : Color, background~ : Brush, border? : BorderStyle?, focused_border? : BorderStyle?, cursor_color~ : Color, corner_radius? : Double, on_submit? : Msg?) -> View[Msg]

    View::corner_radius

    source
    fn[Msg] View::corner_radius(self : View[Msg], radius : Double) -> View[Msg]

    View::cross_axis_alignment

    source
    fn[Msg] View::cross_axis_alignment(self : View[Msg], alignment : CrossAxisAlignment) -> View[Msg]

    View::custom_children_layout

    source
    fn[Msg] View::custom_children_layout(children~ : Array[View[Msg]], measure~ : (CustomLayoutContext) -> Size, place~ : (CustomPlacementContext) -> Array[Rect], paint? : (Rect) -> Array[DrawCommand], semantics_role? : SemanticsRole, semantics_label? : String) -> View[Msg]

    View::custom_view

    source
    fn[Msg] View::custom_view(measure~ : (Constraints) -> Size, paint~ : (Rect) -> Array[DrawCommand], semantics_role? : SemanticsRole, semantics_label? : String) -> View[Msg]

    View::datepicker

    source
    fn[Msg] View::datepicker(selected~ : Binding[DateValue], mode~ : DatePickerMode, placeholder~ : String, font~ : FontSpec, foreground~ : Color, background~ : Brush, corner_radius~ : Double, min_date? : DateValue?, max_date? : DateValue?) -> View[Msg]

    View::disabled

    source
    fn[Msg] View::disabled(self : View[Msg], disabled? : Bool) -> View[Msg]

    View::empty

    source
    fn[Msg] View::empty() -> View[Msg]

    View::environment

    source
    fn[Msg] View::environment(self : View[Msg], environment : Environment) -> View[Msg]

    View::expanded

    source
    fn[Msg] View::expanded(self : View[Msg], weight? : Double) -> View[Msg]

    View::flex

    source
    fn[Msg] View::flex(children~ : Array[View[Msg]], axis~ : Axis, spacing? : Double, main_axis_alignment? : MainAxisAlignment, cross_axis_alignment? : CrossAxisAlignment) -> View[Msg]

    View::flexible

    source
    fn[Msg] View::flexible(self : View[Msg], weight? : Double) -> View[Msg]

    View::focusable

    source
    fn[Msg] View::focusable(self : View[Msg], focusable? : Bool) -> View[Msg]

    View::font

    source
    fn[Msg] View::font(self : View[Msg], font : FontSpec) -> View[Msg]

    View::foreground

    source
    fn[Msg] View::foreground(self : View[Msg], color : Color) -> View[Msg]

    View::frame

    source
    fn[Msg] View::frame(self : View[Msg], width? : Double, height? : Double, min_width? : Double, min_height? : Double, max_width? : Double, max_height? : Double) -> View[Msg]

    View::frame_spec

    source
    fn[Msg] View::frame_spec(child~ : View[Msg], width~ : Double?, height~ : Double?, min_width~ : Double?, min_height~ : Double?, max_width~ : Double?, max_height~ : Double?) -> View[Msg]

    View::grid

    source
    fn[Msg] View::grid(children~ : Array[View[Msg]], columns? : Int, row_spacing? : Double, column_spacing? : Double) -> View[Msg]

    View::image

    source
    fn[Msg] View::image(source~ : String, size? : Size?, opacity? : Double, corner_radius? : Double, fit? : ImageFit) -> View[Msg]

    View::intrinsic_height

    source
    fn[Msg] View::intrinsic_height(self : View[Msg]) -> View[Msg]

    View::intrinsic_width

    source
    fn[Msg] View::intrinsic_width(self : View[Msg]) -> View[Msg]

    View::key

    source
    fn[Msg] View::key(self : View[Msg], value : String) -> View[Msg]

    View::keyboard_shortcut

    source
    fn[Msg] View::keyboard_shortcut(self : View[Msg], shortcut : KeyboardShortcut) -> View[Msg]

    View::layout_priority

    source
    fn[Msg] View::layout_priority(self : View[Msg], priority : Double) -> View[Msg]

    View::list

    source
    fn[Msg] View::list(children~ : Array[View[Msg]], spacing? : Double) -> View[Msg]

    View::main_axis_alignment

    source
    fn[Msg] View::main_axis_alignment(self : View[Msg], alignment : MainAxisAlignment) -> View[Msg]

    View::map

    source
    fn[Msg, NextMsg] View::map(self : View[Msg], map : (Msg) -> NextMsg) -> View[NextMsg]

    View::mono

    source
    fn[Msg] View::mono(self : View[Msg]) -> View[Msg]

    View::offset

    source
    fn[Msg] View::offset(self : View[Msg], dx? : Double, dy? : Double) -> View[Msg]

    View::on_file_drop

    source
    fn[Msg] View::on_file_drop(self : View[Msg], handler : (Array[String], Point) -> Msg) -> View[Msg]

    View::on_tap

    source
    fn[Msg] View::on_tap(self : View[Msg], message : Msg) -> View[Msg]

    View::opacity

    source
    fn[Msg] View::opacity(self : View[Msg], opacity : Double) -> View[Msg]

    View::padding

    source
    fn[Msg] View::padding(self : View[Msg], value : Double) -> View[Msg]

    View::padding_insets

    source
    fn[Msg] View::padding_insets(child~ : View[Msg], insets~ : Insets) -> View[Msg]

    View::picker

    source
    fn[Msg] View::picker(items~ : Array[PickerItem], selected~ : Binding[String], placeholder~ : String, font~ : FontSpec, foreground~ : Color, background~ : Brush, corner_radius~ : Double, max_height~ : Double) -> View[Msg]

    View::rich_text_editor

    source
    fn[Msg] View::rich_text_editor(value~ : Binding[String], placeholder~ : String, size~ : Size, format~ : (String) -> RichTextDocument, font~ : FontSpec, foreground~ : Color, placeholder_color~ : Color, background~ : Brush, border? : BorderStyle?, focused_border? : BorderStyle?, cursor_color~ : Color, corner_radius? : Double, on_selection_change? : (Int, TextRange?) -> Msg?, on_prefix_click? : (Int) -> Msg?, input_transform? : (String, Int, TextRange?, String) -> RichTextInputTransform??, accepts_tab_input? : Bool) -> View[Msg]

    View::scale

    source
    fn[Msg] View::scale(self : View[Msg], sx? : Double, sy? : Double) -> View[Msg]

    View::scroll

    source
    fn[Msg] View::scroll(child~ : View[Msg], offset? : Point, viewport? : Size?, state? : ScrollState?, on_scroll? : (Point) -> Msg?) -> View[Msg]

    View::search_bar

    source
    fn[Msg] View::search_bar(query~ : Binding[String], placeholder~ : String, font~ : FontSpec, foreground~ : Color, placeholder_color~ : Color, background~ : Brush, border? : BorderStyle?, focused_border? : BorderStyle?, cursor_color~ : Color, corner_radius~ : Double, on_submit? : Msg?, on_clear? : Msg?) -> View[Msg]

    View::semantics_role

    source
    fn[Msg] View::semantics_role(self : View[Msg], role : SemanticsRole) -> View[Msg]

    View::shadow

    source
    fn[Msg] View::shadow(self : View[Msg], style : ShadowStyle) -> View[Msg]

    View::sheet

    source
    fn[Msg] View::sheet(content~ : View[Msg], presentation_mode~ : SheetPresentationMode, background~ : Brush, corner_radius~ : Double, shadow? : ShadowStyle?, on_dismiss? : Msg?) -> View[Msg]

    View::spacer

    source
    fn[Msg] View::spacer(min_length? : Double, weight? : Double) -> View[Msg]

    View::spacing

    source
    fn[Msg] View::spacing(self : View[Msg], spacing : Double) -> View[Msg]

    View::stack

    source
    fn[Msg] View::stack(children~ : Array[View[Msg]]) -> View[Msg]

    View::text

    source
    fn[Msg] View::text(text~ : String, size~ : Size, font~ : FontSpec, color~ : Color) -> View[Msg]

    View::text_field

    source
    fn[Msg] View::text_field(value~ : Binding[String], placeholder~ : String, size~ : Size, font~ : FontSpec, foreground~ : Color, placeholder_color~ : Color, background~ : Brush, border? : BorderStyle?, focused_border? : BorderStyle?, cursor_color~ : Color, corner_radius? : Double, on_submit? : Msg?) -> View[Msg]

    View::theme

    source
    fn[Msg] View::theme(self : View[Msg], theme : Theme) -> View[Msg]

    View::title

    source
    fn[Msg] View::title(self : View[Msg]) -> View[Msg]

    ViewEnvironment

    source
    pub(all) struct ViewEnvironment {
      viewport_size : Size
      environment : Environment
    }

    ViewEnvironment::environment

    source
    fn ViewEnvironment::environment(self : ViewEnvironment) -> Environment

    ViewEnvironment::new

    source
    fn ViewEnvironment::new(viewport_size~ : Size, environment~ : Environment) -> ViewEnvironment

    ViewEnvironment::viewport_size

    source
    fn ViewEnvironment::viewport_size(self : ViewEnvironment) -> Size

    ViewNode

    source
    type ViewNode[Msg]

    ViewStyle

    source
    pub(all) struct ViewStyle {
      font : FontSpec?
      foreground : Color?
      background : Brush?
      corner_radius : Double?
    } derive(Eq, ToJson, 
    Debug    )

    ViewStyle::empty

    source
    fn ViewStyle::empty() -> ViewStyle

    ViewStyle::from_theme

    source
    fn ViewStyle::from_theme(theme : Theme) -> ViewStyle

    ViewStyle::merge

    source
    fn ViewStyle::merge(self : ViewStyle, next : ViewStyle) -> ViewStyle

    VisualStyle

    source
    pub(all) struct VisualStyle {
      background : Brush?
      foreground : Color?
      border : BorderStyle?
      shadow : ShadowStyle?
      radius : Double?
      opacity : Double?
    } derive(Eq, ToJson, 
    Debug    )

    VisualStyle::empty

    source
    fn VisualStyle::empty() -> VisualStyle

    default_text_commands

    source
    fn default_text_commands() -> Array[ActionCommand]

    hit_test

    source
    fn hit_test(layout : LayoutResult, point : Point) -> Bool

    recognize_button_tap

    source
    fn recognize_button_tap(current : ButtonState, inside : Bool, phase : PointerPhase) -> TapGestureResult

    required_field

    source
    fn required_field(message? : String) -> ((String) -> String?)

    resolve_gesture_arena

    source
    fn resolve_gesture_arena(members : Array[GestureArenaMember]) -> GestureArenaResult

    rich_text_document_caret_rect_at_source

    source
    fn rich_text_document_caret_rect_at_source(document : RichTextDocument, source_caret : Int, content : Rect, base_font : FontSpec, text_system? : TextSystem) -> Rect?

    rich_text_document_height

    source
    fn rich_text_document_height(document : RichTextDocument, base_font : FontSpec) -> Double

    rich_text_editor_content_rect

    source
    fn rich_text_editor_content_rect(frame : Rect) -> Rect

    validate_form

    source
    fn validate_form(fields : Array[FormFieldState]) -> FormValidationResult

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io