🥮 mooncakes.io
    Sign in

    mizchi/tui/events does not have a README file

    ClickHandler

    source
    pub type ClickHandler () -> Unit

    Click handler type

    ClickHandler::inner

    source
    #deprecated("Use `struct T(A)` to declare a newtype and use `.0` access the underlying type instead.")
    fn ClickHandler::inner(self : ClickHandler) -> (() -> Unit)
    Convert newtype to its underlying type, automatically derived.

    ClickHandler::new

    source
    fn ClickHandler::new(handler : () -> Unit) -> ClickHandler

    Create a new click handler

    EventHandlers

    source
    pub struct EventHandlers {
      click_handlers : Map[String, ClickHandler]
    }

    Event handlers map (component ID -> handler)

    EventHandlers::get_click

    source
    fn EventHandlers::get_click(self : EventHandlers, id : String) -> ClickHandler?

    Get click handler for a component

    EventHandlers::new

    source

    EventHandlers::on_click

    source
    fn EventHandlers::on_click(self : EventHandlers, id : String, handler : ClickHandler) -> Unit

    Register a click handler for a component

    FocusManager

    source
    pub struct FocusManager {
      focus : FocusState
      mode : InputMode
      focusable_ids : Array[String]
    }

    Focus manager for handling focus state and navigation

    FocusManager::blur

    source
    fn FocusManager::blur(self : FocusManager) -> Unit

    Remove focus (blur)

    FocusManager::focus

    source
    fn FocusManager::focus(self : FocusManager, id : String) -> Unit

    Set focus to a specific component

    FocusManager::focus_next

    source
    fn FocusManager::focus_next(self : FocusManager) -> Unit

    Focus the next component in the focusable list (Tab navigation)

    FocusManager::focus_prev

    source
    fn FocusManager::focus_prev(self : FocusManager) -> Unit

    Focus the previous component in the focusable list (Shift+Tab navigation)

    FocusManager::focusable_count

    source
    fn FocusManager::focusable_count(self : FocusManager) -> Int

    Get the number of focusable elements

    FocusManager::get_focused

    source
    fn FocusManager::get_focused(self : FocusManager) -> String?

    Get the currently focused component ID

    FocusManager::get_mode

    source
    fn FocusManager::get_mode(self : FocusManager) -> InputMode

    Get current input mode

    FocusManager::is_editing

    source
    fn FocusManager::is_editing(self : FocusManager) -> Bool

    Check if currently in editing mode

    FocusManager::is_focused

    source
    fn FocusManager::is_focused(self : FocusManager, id : String) -> Bool

    Check if a component is currently focused

    FocusManager::new

    source

    Create a new focus manager

    FocusManager::register

    source
    fn FocusManager::register(self : FocusManager, id : String) -> Unit

    Register a focusable component ID

    FocusManager::start_editing

    source
    fn FocusManager::start_editing(self : FocusManager) -> Unit

    Enter editing mode

    FocusManager::stop_editing

    source
    fn FocusManager::stop_editing(self : FocusManager) -> Unit

    Exit editing mode

    FocusManager::unregister

    source
    fn FocusManager::unregister(self : FocusManager, id : String) -> Unit

    Unregister a focusable component ID

    FocusState

    source
    pub(all) enum FocusState {
      None
      Focused(String)
    }

    Focus state for the application

    HitTestResult

    source
    pub(all) struct HitTestResult {
      id : String
      x : Int
      y : Int
      width : Int
      height : Int
      role : 
    Role    ?
    }

    Hit test result

    InputEvent

    source
    pub(all) enum InputEvent {
      Key(KeyEvent)
      Mouse(MouseEvent)
      Resize(Int, Int)
      Unknown(String)
    }

    Input event
    impl Show for InputEvent

    InputEvent::is_arrow

    source
    fn InputEvent::is_arrow(self : InputEvent) -> SpecialKey?

    Check if the input event is an arrow key, returns the direction

    InputEvent::is_backtab

    source
    fn InputEvent::is_backtab(self : InputEvent) -> Bool

    Check if the input event is Shift+Tab or BackTab

    InputEvent::is_char

    source
    fn InputEvent::is_char(self : InputEvent, c : Char) -> Bool

    Check if the input event is a key matching a character (no modifier)

    InputEvent::is_ctrl

    source
    fn InputEvent::is_ctrl(self : InputEvent, c : Char) -> Bool

    Check if the input event is a key with Ctrl modifier

    InputEvent::is_ctrl_c

    source
    fn InputEvent::is_ctrl_c(self : InputEvent) -> Bool

    Check if the input event is Ctrl+C (quit)

    InputEvent::is_enter

    source
    fn InputEvent::is_enter(self : InputEvent) -> Bool

    Check if the input event is Enter

    InputEvent::is_escape

    source
    fn InputEvent::is_escape(self : InputEvent) -> Bool

    Check if the input event is Escape

    InputEvent::is_left_click

    source
    fn InputEvent::is_left_click(self : InputEvent) -> MouseEvent?

    Check if the input event is a left mouse button press

    InputEvent::is_quit

    source
    fn InputEvent::is_quit(self : InputEvent) -> Bool

    Check if the input event is a common quit key (q, Ctrl+C, Escape)

    InputEvent::is_right_click

    source
    fn InputEvent::is_right_click(self : InputEvent) -> MouseEvent?

    Check if the input event is a right mouse button press

    InputEvent::is_scroll_down

    source
    fn InputEvent::is_scroll_down(self : InputEvent) -> Bool

    Check if the input event is a scroll down

    InputEvent::is_scroll_up

    source
    fn InputEvent::is_scroll_up(self : InputEvent) -> Bool

    Check if the input event is a scroll up

    InputEvent::is_tab

    source
    fn InputEvent::is_tab(self : InputEvent) -> Bool

    Check if the input event is Tab

    InputMode

    source
    pub(all) enum InputMode {
      Normal
      Editing
    }

    Input mode for the application

    KeyEvent

    source
    pub(all) enum KeyEvent {
      Char(Char, KeyModifier)
      Special(SpecialKey, KeyModifier)
    }

    Keyboard event
    impl Show for KeyEvent

    KeyEvent::is_char

    source
    fn KeyEvent::is_char(self : KeyEvent, c : Char) -> Bool

    Check if key matches a specific character with optional modifier

    KeyEvent::is_ctrl_c

    source
    fn KeyEvent::is_ctrl_c(self : KeyEvent) -> Bool

    Check if key is Ctrl+C

    KeyEvent::is_ctrl_q

    source
    fn KeyEvent::is_ctrl_q(self : KeyEvent) -> Bool

    Check if key is Ctrl+Q (common quit)

    KeyEvent::is_special

    source
    fn KeyEvent::is_special(self : KeyEvent, special : SpecialKey) -> Bool

    Check if key matches a special key

    KeyModifier

    source
    pub(all) enum KeyModifier {
      None
      Shift
      Ctrl
      Alt
      CtrlShift
      CtrlAlt
      ShiftAlt
      CtrlShiftAlt
    }

    Key modifiers
    impl Show for KeyModifier

    MouseButton

    source
    pub(all) enum MouseButton {
      Left
      Middle
      Right
      ScrollUp
      ScrollDown
      None
    }

    Mouse button
    impl Show for MouseButton

    MouseEvent

    source
    pub(all) struct MouseEvent {
      button : MouseButton
      event_type : MouseEventType
      x : Int
      y : Int
      modifier : KeyModifier
    }

    Mouse event
    impl Show for MouseEvent

    MouseEventType

    source
    pub(all) enum MouseEventType {
      Press
      Release
      Move
      Drag
    }

    Mouse event type

    SpecialKey

    source
    pub(all) enum SpecialKey {
      Up
      Down
      Left
      Right
      Home
      End
      PageUp
      PageDown
      Insert
      Delete
      Tab
      BackTab
      Backspace
      Enter
      Escape
      F(Int)
    }

    Special keys
    impl Show for SpecialKey

    dump_layout

    source
    fn dump_layout(layout : 
    Layout    , offset_x : Int, offset_y : Int, depth : Int) -> String

    Debug: dump layout tree structure

    find_layout_by_id

    source
    fn find_layout_by_id(layout : 
    Layout    , target_id : String, offset_x : Int, offset_y : Int) -> HitTestResult?

    Find layout by ID Returns the position and size of the component with the given ID

    find_layout_by_id_root

    source
    fn find_layout_by_id_root(layout : 
    Layout    , target_id : String) -> HitTestResult?

    Find layout by ID from root

    handle_click

    source
    fn handle_click(layout : 
    Layout    , handlers : EventHandlers, mouse_x : Int, mouse_y : Int) -> Bool

    Handle mouse click event Returns true if a handler was invoked

    hit_test

    source
    fn hit_test(layout : 
    Layout    , mouse_x : Int, mouse_y : Int, offset_x : Int, offset_y : Int) -> HitTestResult?

    Perform hit test on layout tree Returns the deepest (most specific) node containing the point

    hit_test_root

    source
    fn hit_test_root(layout : 
    Layout    , mouse_x : Int, mouse_y : Int) -> HitTestResult?

    Hit test from root (convenience function)

    parse_input

    source
    fn parse_input(input : String) -> InputEvent

    Parse escape sequence

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io