🥮 mooncakes.io
    Sign in

    wzzc-dev/moui/backend/common/lifecycle does not have a README file

    EmbeddedHostLifecyclePhase

    source
    pub enum EmbeddedHostLifecyclePhase {
      Idle
      Resumed
      SurfaceAttached
      Exited
    } derive(Eq, 
    Debug    )

    Logical lifecycle phase owned by MoUI for an embedded host.

    EmbeddedHostLifecyclePhase::equal

    source

    EmbeddedHostLifecyclePhase::not_equal

    source

    EmbeddedHostLifecyclePhase::to_repr

    source

    EmbeddedHostSurface

    source
    pub struct EmbeddedHostSurface {
      handle : UInt64
      metrics : 
    SurfaceMetrics
      generation : Int
    } derive(Eq, 
    Debug    )

    Surface identity crossing the physical window adapter boundary. The generation is created here; embedded transport has its own session generation and must never mint a surface epoch.

    EmbeddedHostSurface::equal

    source

    EmbeddedHostSurface::not_equal

    source

    EmbeddedHostSurface::to_repr

    source

    EmbeddedLifecycle

    source
    pub struct EmbeddedLifecycle {
      phase : EmbeddedHostLifecyclePhase
      generation : Int
      surface : EmbeddedHostSurface?
      primary_window : 
    WindowId    ?
      exit_intent : Int?
    }

    The embedded lifecycle adapter shared by Android, iOS, and HarmonyOS. It has no native queue and no event-loop handle; those remain in wzzc-dev/window. It owns only MoUI logical phase, surface generation, primary-window identity, detach semantics, and application exit intent.

    EmbeddedLifecycle::attach_surface

    source

    EmbeddedLifecycle::detach_surface

    source

    EmbeddedLifecycle::exit_intent

    source
    fn EmbeddedLifecycle::exit_intent(self : EmbeddedLifecycle) -> Int?

    EmbeddedLifecycle::new

    source

    EmbeddedLifecycle::phase

    source

    EmbeddedLifecycle::primary_window

    source

    EmbeddedLifecycle::register_window

    source

    EmbeddedLifecycle::request_exit

    source
    fn EmbeddedLifecycle::request_exit(self : EmbeddedLifecycle, code : Int) -> EmbeddedWindowHostAction

    EmbeddedLifecycle::resize_surface

    source

    EmbeddedLifecycle::resumed

    source

    EmbeddedLifecycle::surface

    source

    EmbeddedLifecycle::surface_generation

    source
    fn EmbeddedLifecycle::surface_generation(self : EmbeddedLifecycle) -> Int

    EmbeddedLifecycle::suspended

    source

    EmbeddedLifecycle::unregister_window

    source

    EmbeddedWindowHostAction

    source
    pub enum EmbeddedWindowHostAction {
      Resumed
      CanCreateSurfaces
      SurfaceAttached(EmbeddedHostSurface)
      SurfaceDetached(Int)
      DestroySurfaces
      Suspended
      Exit(Int)
    } derive(Eq, 
    Debug    )

    EmbeddedWindowHostAction::equal

    source

    EmbeddedWindowHostAction::not_equal

    source

    EmbeddedWindowHostAction::to_repr

    source

    PlatformWindowBinding

    source
    pub(all) struct PlatformWindowBinding {
      platform_id : 
    WindowId
      host_id : 
    WindowId
    } derive(Eq, 
    Debug    )

    PlatformWindowBinding::equal

    source

    PlatformWindowBinding::not_equal

    source

    PlatformWindowBinding::to_repr

    source

    PlatformWindowMap

    source
    pub struct PlatformWindowMap {
      bindings : Array[PlatformWindowBinding]
    }

    PlatformWindowMap::bind

    source

    PlatformWindowMap::count

    source
    fn PlatformWindowMap::count(self : PlatformWindowMap) -> Int

    PlatformWindowMap::is_empty

    source
    fn PlatformWindowMap::is_empty(self : PlatformWindowMap) -> Bool

    PlatformWindowMap::lookup_host

    source

    PlatformWindowMap::lookup_platform

    source

    PlatformWindowMap::new

    source

    PlatformWindowMap::remove_host

    source

    PlatformWindowMap::remove_platform

    source

    WindowActions

    source
    pub struct WindowActions {
      queue : WindowRequestQueue
    }

    App-facing capability for requesting host-managed windows.

    The platform host owns draining the queue, resolving scenes, and creating native windows. Apps describe the scene they want to open and can enqueue lifecycle requests (close / focus / set_primary) by @backend_host.WindowId. Requests remain fire-and-forget on the shared queue; hosts record completions on the queue when they drain it.

    WindowActions::close

    source

    Request that the host close the window identified by id.

    WindowActions::focus

    source

    Request that the host focus the window identified by id.

    WindowActions::minimize

    source

    Request that the host minimize the window identified by id.

    WindowActions::new

    source

    WindowActions::open

    source
    fn WindowActions::open(self : WindowActions, title~ : String, scene? : 
    WindowScene    , metrics~ : 
    SurfaceMetrics    , primary? : Bool) -> Unit

    WindowActions::queue

    source

    Shared request queue used by the host entrypoint. Prefer the typed helpers below from app code; entrypoints may pass this queue into AppBuilder::window_requests.

    WindowActions::resize

    source

    Request a resize for the window identified by id.

    WindowActions::set_primary

    source

    Request that the host treat id as the primary window.

    WindowActions::show

    source

    Request that the host show the window identified by id.

    WindowActions::unavailable

    source
    fn WindowActions::unavailable() -> WindowActions

    WindowCommands

    source
    pub struct WindowCommands {
      queue : WindowRequestQueue
    }

    WindowCommands::close

    source

    WindowCommands::completed_count

    source
    fn WindowCommands::completed_count(self : WindowCommands) -> Int

    WindowCommands::drain

    source

    WindowCommands::drain_completed

    source

    WindowCommands::drain_to_registry

    source

    WindowCommands::drain_with_handler

    source

    WindowCommands::focus

    source

    WindowCommands::is_empty

    source
    fn WindowCommands::is_empty(self : WindowCommands) -> Bool

    WindowCommands::minimize

    source

    WindowCommands::new

    source

    WindowCommands::open

    source
    fn WindowCommands::open(self : WindowCommands, title~ : String, scene? : 
    WindowScene    , metrics~ : 
    SurfaceMetrics    , primary? : Bool) -> Unit

    WindowCommands::open_window

    source

    WindowCommands::pending_count

    source
    fn WindowCommands::pending_count(self : WindowCommands) -> Int

    WindowCommands::queue

    source

    WindowCommands::record_result

    source

    WindowCommands::resize

    source

    WindowCommands::set_primary

    source

    WindowCommands::show

    source

    WindowLifecycle

    source
    pub struct WindowLifecycle {
      // private fields
    }

    Logical host-window owner. It intentionally contains no renderer, image, input-session, or service-bridge state.

    WindowLifecycle::active_runtime_slot

    source
    fn WindowLifecycle::active_runtime_slot(self : WindowLifecycle) -> WindowRuntimeSlot?

    WindowLifecycle::apply_host_event

    source

    WindowLifecycle::apply_request_state

    source

    WindowLifecycle::attach_surface

    source

    WindowLifecycle::begin_close

    source

    WindowLifecycle::bind_platform_window

    source
    fn WindowLifecycle::bind_platform_window(self : WindowLifecycle, platform_id~ : 
    WindowId    , window_id~ : 
    WindowId    ) -> Bool

    WindowLifecycle::detach_surface

    source

    WindowLifecycle::drain_window_requests

    source

    WindowLifecycle::exit_intent

    source
    fn WindowLifecycle::exit_intent(self : WindowLifecycle) -> Int?

    WindowLifecycle::finish_close

    source

    WindowLifecycle::lookup_window

    source

    WindowLifecycle::new

    source

    WindowLifecycle::open_resolution

    source

    WindowLifecycle::register_primary_runtime_slot

    source

    WindowLifecycle::register_runtime_slot

    source
    fn WindowLifecycle::register_runtime_slot(self : WindowLifecycle, slot : WindowRuntimeSlot) -> Bool

    WindowLifecycle::request_exit

    source
    fn WindowLifecycle::request_exit(self : WindowLifecycle, code : Int) -> Unit

    WindowLifecycle::rollback_window_record

    source
    fn WindowLifecycle::rollback_window_record(self : WindowLifecycle, id : 
    WindowId    ) -> Unit

    WindowLifecycle::runtime_slot_lookup

    source

    WindowLifecycle::runtime_slots

    source

    WindowLifecycle::runtime_slots_empty

    source
    fn WindowLifecycle::runtime_slots_empty(self : WindowLifecycle) -> Bool

    WindowLifecycle::surface_actions

    source

    WindowLifecycle::surface_generation

    source
    fn WindowLifecycle::surface_generation(self : WindowLifecycle) -> Int

    WindowLifecycle::sync_runtime_slot

    source
    fn WindowLifecycle::sync_runtime_slot(self : WindowLifecycle, id : 
    WindowId    ) -> Unit

    WindowLifecycle::sync_runtime_slots

    source
    fn WindowLifecycle::sync_runtime_slots(self : WindowLifecycle) -> Unit

    WindowLifecycle::unbind_platform_window

    source

    WindowLifecycle::window_registry

    source
    fn WindowLifecycle::window_registry(self : WindowLifecycle) -> WindowRegistry

    WindowOpenResolution

    source
    pub(all) enum WindowOpenResolution {
      OpenResolved(WindowResolvedOpen)
      OpenRejected(String)
    }

    WindowRegistry

    source
    pub struct WindowRegistry {
      next_value : Int
      records : Array[
    WindowRecord    ]
    }

    WindowRegistry::apply_host_event

    source

    WindowRegistry::apply_request

    source

    WindowRegistry::close

    source

    WindowRegistry::focus

    source

    WindowRegistry::focused_window

    source

    WindowRegistry::lookup

    source

    WindowRegistry::minimize

    source

    WindowRegistry::new

    source

    WindowRegistry::open

    source

    WindowRegistry::open_window_count

    source
    fn WindowRegistry::open_window_count(self : WindowRegistry) -> Int

    WindowRegistry::open_windows

    source

    WindowRegistry::primary_window

    source

    WindowRegistry::remove_closed

    source
    fn WindowRegistry::remove_closed(self : WindowRegistry) -> Int

    WindowRegistry::request_close

    source

    WindowRegistry::resize

    source

    WindowRegistry::set_primary

    source

    WindowRegistry::show

    source

    WindowRequestQueue

    source

    WindowRequestQueue::close_window

    source

    WindowRequestQueue::completed_count

    source
    fn WindowRequestQueue::completed_count(self : WindowRequestQueue) -> Int

    WindowRequestQueue::drain

    source

    WindowRequestQueue::drain_completed

    source

    WindowRequestQueue::drain_with_handler

    source

    WindowRequestQueue::focus_window

    source

    WindowRequestQueue::is_empty

    source
    fn WindowRequestQueue::is_empty(self : WindowRequestQueue) -> Bool

    WindowRequestQueue::minimize_window

    source

    WindowRequestQueue::new

    source

    WindowRequestQueue::open_window

    source
    fn WindowRequestQueue::open_window(self : WindowRequestQueue, title~ : String, scene? : 
    WindowScene    , metrics~ : 
    SurfaceMetrics    , primary? : Bool) -> Unit

    WindowRequestQueue::pending_count

    source
    fn WindowRequestQueue::pending_count(self : WindowRequestQueue) -> Int

    WindowRequestQueue::push

    source

    WindowRequestQueue::record_result

    source

    WindowRequestQueue::requests

    source

    Erase queue storage behind the root backend request protocol.

    WindowRequestQueue::resize_window

    source

    WindowRequestQueue::set_primary_window

    source

    WindowRequestQueue::show_window

    source

    WindowRequestQueue::subscribe_completed

    source
    fn WindowRequestQueue::subscribe_completed(self : WindowRequestQueue, handle : (
    WindowRequestCompletion    ) -> Unit) -> (() -> Unit)

    Observe request completions without consuming the diagnostic completion queue. The returned callback removes the observer.

    WindowResolvedOpen

    source

    WindowRuntimeSlot

    source

    WindowRuntimeSlot::from_driver

    source

    WindowRuntimeSlot::from_resolved_open

    source
    fn WindowRuntimeSlot::from_resolved_open(resolved : WindowResolvedOpen, schedule_redraw~ : () -> Unit) -> WindowRuntimeSlot

    WindowRuntimeSlot::new

    source

    WindowRuntimeSlots

    source
    pub struct WindowRuntimeSlots {
      slots : Array[WindowRuntimeSlot]
    }

    WindowRuntimeSlots::apply_host_event

    source

    WindowRuntimeSlots::apply_request

    source

    WindowRuntimeSlots::count

    source
    fn WindowRuntimeSlots::count(self : WindowRuntimeSlots) -> Int

    WindowRuntimeSlots::focused_slot

    source

    WindowRuntimeSlots::insert

    source
    fn WindowRuntimeSlots::insert(self : WindowRuntimeSlots, slot : WindowRuntimeSlot) -> Bool

    WindowRuntimeSlots::insert_from_registry

    source

    WindowRuntimeSlots::is_empty

    source
    fn WindowRuntimeSlots::is_empty(self : WindowRuntimeSlots) -> Bool

    WindowRuntimeSlots::lookup

    source

    WindowRuntimeSlots::new

    source

    WindowRuntimeSlots::open_slots

    source

    WindowRuntimeSlots::primary_slot

    source

    WindowRuntimeSlots::remove

    source

    WindowRuntimeSlots::remove_closed

    source
    fn WindowRuntimeSlots::remove_closed(self : WindowRuntimeSlots) -> Int

    WindowRuntimeSlots::sync_from_registry

    source
    fn WindowRuntimeSlots::sync_from_registry(self : WindowRuntimeSlots, registry : WindowRegistry, id : 
    WindowId    ) -> Bool

    WindowRuntimeSlots::sync_open_from_registry

    source
    fn WindowRuntimeSlots::sync_open_from_registry(self : WindowRuntimeSlots, registry : WindowRegistry) -> Int

    WindowRuntimeSlots::sync_record

    source

    WindowSceneInstance

    source

    WindowSceneResolution

    source
    pub(all) enum WindowSceneResolution {
      SceneResolved(WindowSceneInstance)
      SceneRejected(String)
    }

    WindowSceneResolver

    source

    WindowSceneResolver::new

    source

    WindowSceneResolver::resolve

    source

    WindowSceneResolver::unavailable

    source
    fn WindowSceneResolver::unavailable(reason? : String) -> WindowSceneResolver

    WindowSlot

    source
    pub struct WindowSlot[W, X] {
      host_id : 
    WindowId
      window : W
      extra : X
    }

    Shared platform resource slot. Platform-id mapping belongs exclusively to the lifecycle owner; this table is keyed only by the backend window id. The generic extra carries platform-private per-window state (Linux client decorations, Unit elsewhere).

    WindowSlot::new

    source
    fn[W, X] WindowSlot::new(host_id~ : 
    WindowId    , window~ : W, extra~ : X) -> WindowSlot[W, X]

    WindowSlot::set_extra

    source
    fn[W, X] WindowSlot::set_extra(self : WindowSlot[W, X], extra~ : X) -> Unit

    Replace the platform-private per-window state (Linux client decorations).

    WindowSlotMap

    source
    pub struct WindowSlotMap[W, X] {
      slots : Array[WindowSlot[W, X]]
    }

    Ordered backend-id resource registry with duplicate rejection.

    WindowSlotMap::insert

    source
    fn[W, X] WindowSlotMap::insert(self : WindowSlotMap[W, X], slot : WindowSlot[W, X]) -> Bool

    WindowSlotMap::lookup_host

    source
    fn[W, X] WindowSlotMap::lookup_host(self : WindowSlotMap[W, X], host_id : 
    WindowId    ) -> WindowSlot[W, X]?

    WindowSlotMap::new

    source
    fn[W, X] WindowSlotMap::new() -> WindowSlotMap[W, X]

    WindowSlotMap::remove_host

    source
    fn[W, X] WindowSlotMap::remove_host(self : WindowSlotMap[W, X], host_id : 
    WindowId    ) -> WindowSlot[W, X]?

    WindowSurfaceActions

    source
    pub(all) struct WindowSurfaceActions {
      focus : () -> Unit
      request_resize : (
    SurfaceMetrics    ) -> 
    SurfaceMetrics
      sync_observed_resize : (
    SurfaceMetrics    ) -> 
    SurfaceMetrics
      set_minimized : (Bool) -> Unit
      set_visible : (Bool) -> Unit
      request_redraw : () -> Unit
      request_ime_update : (
    TextInputSessionAction    ) -> Unit
      set_drag_region : (
    Rect    ?) -> Unit
      drop : () -> Unit
      native_view_handle : () -> UInt64?
      dispose_platform_views : () -> Unit
    }

    Platform projection owned by the logical window lifecycle. The closures carry native effects; frame, image, input, and service state remain in their dedicated owners.

    WindowSurfaceActions::new

    source
    fn WindowSurfaceActions::new(focus~ : () -> Unit, request_resize~ : (
    SurfaceMetrics    ) -> 
    SurfaceMetrics    , sync_observed_resize~ : (
    SurfaceMetrics    ) -> 
    SurfaceMetrics    , set_minimized~ : (Bool) -> Unit, set_visible~ : (Bool) -> Unit, request_redraw~ : () -> Unit, request_ime_update~ : (
    TextInputSessionAction    ) -> Unit, set_drag_region? : (
    Rect    ?) -> Unit, drop~ : () -> Unit, native_view_handle~ : () -> UInt64?, dispose_platform_views~ : () -> Unit) -> WindowSurfaceActions

    drain_to_runtime_slots

    source

    resolve_open_request

    source

    Resolve a runtime scene and register its backend window atomically.

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io