🥮 mooncakes.io
README

#Proton Native

justjavac/proton/native is the direct MoonBit FFI binding for the standalone Proton native dynamic library.

The public API uses Proton-owned Runtime and Window values. Raw native handles are intentionally not part of the public surface.

///|
test "native ABI is loaded" {
  inspect(abi_version(), content="1")
  let info = runtime_info()
  inspect(info.abi_version, content="1")
  assert_true(info.build_mode == "abi-only" || info.build_mode == "runtime")
  assert_true(info.runtime_available == (info.build_mode == "runtime"))
  assert_true(info.features.contains("event_polling"))
  assert_true(info.features.contains("bridge_polling"))
}

Runtime configuration is typed on the MoonBit side and serialized to the stable proton_* C ABI JSON format.

///|
test "typed runtime config JSON" {
  let config = RuntimeConfig::new(
    runtime_root="app-runtime",
    helper_path="cef_process.exe",
    cache_dir="cache",
  )
  let json = config.to_json_string()
  assert_true(json.contains("\"abi_version\":1"))
  assert_true(json.contains("\"runtime_root\":\"app-runtime\""))
  assert_true(json.contains("\"helper_path\":\"cef_process.exe\""))
  assert_true(json.contains("\"cache_dir\":\"cache\""))
}

For packaged Proton runtimes, prefer RuntimeConfig::bundled(). It asks proton.dll to use the install layout beside the loaded DLL, including bin/cef_process.exe, instead of requiring application code to hard-code paths.

///|
test "bundled runtime config JSON" {
  let json = RuntimeConfig::bundled(cache_dir="cache").to_json_string()
  assert_true(json.contains("\"use_bundled\":true"))
  assert_true(json.contains("\"cache_dir\":\"cache\""))
}

The default no-engine build supports fake runtime/window handles for ABI and binding validation. Real runtime configs that include runtime_root or helper_path, or use RuntimeConfig::bundled(), are treated as engine configs and must pass RuntimeConfig::probe.

///|
test "runtime and window lifecycle" {
  let runtime = Runtime::new()
  let window = Window::new(
    runtime,
    config=WindowConfig::new(
      title="Proton",
      width=320,
      height=240,
      initial_url="about:blank",
    ),
  )
  match runtime.poll_event() {
    Some(event) => inspect(event.event_type(), content="window_created")
    _ => fail("expected window_created")
  }
  window.load_html("<p>Hello Proton</p>", "proton://app/")
  window.destroy()
  runtime.destroy()
}

Runtime::wait is a low-level primitive for hosts that own the external message pump. It reports which kinds of work may be ready, and the caller still drains events or bridge requests through the poll APIs. The root facade does not use it on macOS: run_app owns CEF's native message loop and wakes the MoonBit application thread through Runtime::set_wakeup_fd.

///|
test "runtime wait event readiness" {
  let runtime = Runtime::new()
  let empty = runtime.wait(interest_mask=runtime_wait_event, timeout_ms=0)

  inspect(empty.is_timeout(), content="true")
  let window = Window::new(runtime)
  let ready = runtime.wait(interest_mask=runtime_wait_event, timeout_ms=0)

  inspect(ready.has_event(), content="true")
  match runtime.poll_event() {
    Some(event) => inspect(event.event_type(), content="window_created")
    _ => fail("expected window_created")
  }
  window.destroy()
  runtime.destroy()
}

#
NativeError

source
pub(all) suberror NativeError {
  Status(status~ : Int, message~ : String)
  InvalidArgument(message~ : String)
  InvalidPayload(context~ : String, message~ : String)
} derive(Eq, 
Debug)

Failures at the MoonBit/native runtime boundary.

#
NativeError::is_stale_bridge_response

source
fn NativeError::is_stale_bridge_response(self : NativeError) -> Bool

Reports whether a bridge response lost its renderer request while an asynchronous handler was still completing.

#
NativeError::is_stale_browser_request

source
fn NativeError::is_stale_browser_request(self : NativeError) -> Bool

#
NativeError::is_stale_window_request

source
fn NativeError::is_stale_window_request(self : NativeError) -> Bool

#
NativeError::message

source
fn NativeError::message(self : NativeError) -> String

#
NativeError::status

source
fn NativeError::status(self : NativeError) -> Int

#
AppActivation

source
pub(all) struct AppActivation {
  abi_version : Int
  urls : Array[String]
  files : Array[String]
  reopen : Bool
} derive(Eq, ToJson, 
Debug)

Inputs forwarded by a second operating-system application instance.

#
AppActivation::new

source
fn AppActivation::new(urls? : Array[String], files? : Array[String], reopen? : Bool) -> AppActivation

#
AppInstance

source
type AppInstance

#
AppInstance::acquire

source
fn AppInstance::acquire(identifier : String, activation : AppActivation) -> AppInstanceAcquire raise NativeError

Claims one operating-system application identity. A secondary process forwards its activation before returning Forwarded.

#
AppInstance::attach_runtime

source
fn AppInstance::attach_runtime(self : AppInstance, runtime : Runtime) -> Unit raise NativeError

Attaches the primary instance listener to a runtime's existing wake source.

#
AppInstance::destroy

source
fn AppInstance::destroy(self : AppInstance) -> Unit raise NativeError

#
AppInstanceAcquire

source
pub enum AppInstanceAcquire {
  Primary(AppInstance)
  Forwarded
}

Result of claiming an operating-system application identity.

#
BridgeConfig

source
pub(all) struct BridgeConfig {
  raw_json : String?
  max_payload_bytes : Int
  request_timeout_ms : Int
  grants : Array[BridgeGrantConfig]
} derive(Eq, 
Debug)

#
BridgeConfig::new

source
fn BridgeConfig::new(grants~ : Array[BridgeGrantConfig], max_payload_bytes? : Int, request_timeout_ms? : Int) -> BridgeConfig

#
BridgeConfig::to_json_string

source
fn BridgeConfig::to_json_string(self : BridgeConfig) -> String

#
BridgeConfig::unsafe_from_json

source
fn BridgeConfig::unsafe_from_json(raw_json : String) -> BridgeConfig

#
BridgeDiagnostic

source
pub(all) struct BridgeDiagnostic {
  abi_version : Int
  stage : String
  code : String
  message : String
  page_instance : String
  url : String
  owner : String?
  source_url : String?
  source_line : String?
  line : Int?
  column : Int?
  stack : String?
  additional_failure_count : Int?
  details_truncated : Bool
} derive(Eq, 
Debug, 
FromJson)

#
BridgeExtensionConfig

source
pub(all) struct BridgeExtensionConfig {
  js_namespace : String
  apis : Array[String]
} derive(Eq, 
Debug)

One JavaScript namespace installed by the renderer bootstrap.

#
BridgeExtensionConfig::new

source
fn BridgeExtensionConfig::new(js_namespace : String, apis~ : Array[String]) -> BridgeExtensionConfig

#
BridgeGrantConfig

source
pub(all) struct BridgeGrantConfig {
  source_origin : String
  ops : Array[String]
  extensions : Array[BridgeExtensionConfig]
  initialization_units : Array[BridgeInitializationUnit]
} derive(Eq, 
Debug)

Renderer capabilities granted to one canonical source in one window.

#
BridgeGrantConfig::new

source
fn BridgeGrantConfig::new(source_origin : String, ops~ : Array[String], extensions? : Array[BridgeExtensionConfig], initialization_units? : Array[BridgeInitializationUnit]) -> BridgeGrantConfig

#
BridgeInitializationUnit

source
pub(all) struct BridgeInitializationUnit {
  owner : String
  name : String
  source : String
} derive(Eq, 
Debug)

One ordered JavaScript initialization unit owned by an extension.

#
BridgeInitializationUnit::new

source
fn BridgeInitializationUnit::new(owner : String, name : String, source : String) -> BridgeInitializationUnit

#
BridgeLifecycleState

source
pub(all) struct BridgeLifecycleState {
  abi_version : Int
  revision : String
  outcome : String
  page_instance : String
  url : String
  failure_pending : Bool
} derive(Eq, 
Debug, 
FromJson)

#
BridgeRequest

source
pub(all) struct BridgeRequest {
  request_id : Int64
  window : Int64
  op : String
  payload : Json
  page_instance : String?
  source_origin : String
} derive(
Debug)

#
BridgeRequest::op

source
fn BridgeRequest::op(self : BridgeRequest) -> String

#
BridgeRequest::page_instance

source
fn BridgeRequest::page_instance(self : BridgeRequest) -> String?

#
BridgeRequest::payload

source
fn BridgeRequest::payload(self : BridgeRequest) -> Json

#
BridgeRequest::request_id

source
fn BridgeRequest::request_id(self : BridgeRequest) -> Int64

#
BridgeRequest::source_origin

source
fn BridgeRequest::source_origin(self : BridgeRequest) -> String

#
BridgeRequest::window

source
fn BridgeRequest::window(self : BridgeRequest) -> Int64

#
BridgeResponse

source
pub(all) enum BridgeResponse {
  Ok(request_id~ : Int64, payload~ : Json)
  Err(request_id~ : Int64, code~ : String, message~ : String)
} derive(
Debug)

#
BridgeResponse::to_json_string

source
fn BridgeResponse::to_json_string(self : BridgeResponse) -> String

#
BrowserPolicy

source
pub(all) struct BrowserPolicy {
  navigation : BrowserPolicyMode
  popup : BrowserPolicyMode
  download : BrowserPolicyMode
  certificate : BrowserPolicyMode
  media : BrowserPolicyMode
  devtools : Bool
} derive(Eq, 
Debug)

#
BrowserPolicy::new

source
fn BrowserPolicy::new(navigation? : BrowserPolicyMode, popup? : BrowserPolicyMode, download? : BrowserPolicyMode, certificate? : BrowserPolicyMode, media? : BrowserPolicyMode, devtools? : Bool) -> BrowserPolicy

#
BrowserPolicyMode

source
pub(all) enum BrowserPolicyMode {
  Allow
  Deny
  Ask
} derive(Eq, 
Debug)

#
DialogLevel

source
pub(all) enum DialogLevel {
  Info
  Warning
  Error
} derive(Eq, 
Debug)

#
DialogPollResult

source
pub(all) enum DialogPollResult {
  Pending
  Ready(String)
} derive(Eq, 
Debug)

A top-level native menu and its items.
fn Menu::new(label : String, items~ : Array[MenuItem]) -> Menu

Creates a top-level menu.

An application-level native menu bar.
fn MenuBar::new(menus~ : Array[Menu]) -> MenuBar

Creates an application-level menu bar.
fn MenuBar::to_json_string(self : MenuBar) -> String

Encodes this menu bar for the native ABI.
fn MenuBar::unsafe_from_json(raw_json : String) -> MenuBar

Creates a menu bar from unchecked native ABI JSON.
type MenuItem derive(Eq, 
Debug)

A command, separator, or platform role in a native menu.
fn MenuItem::command(id : String, label : String, key? : String) -> MenuItem

Creates an app command item. Activating it emits menu_command.
fn MenuItem::role(role : String, label? : String, key? : String) -> MenuItem

Creates an item backed by a platform menu role such as close or quit.
fn MenuItem::separator() -> MenuItem

Creates a menu separator.

#
NativeBrowserRequest

source
pub(all) enum NativeBrowserRequest {
  Navigation(request_id~ : Int64, url~ : String, http_method~ : String, user_gesture~ : Bool, redirect~ : Bool)
  Popup(request_id~ : Int64, url~ : String, disposition~ : Int, user_gesture~ : Bool)
  Download(request_id~ : Int64, download_id~ : Int, url~ : String, suggested_name~ : String)
  Certificate(request_id~ : Int64, url~ : String, error_code~ : Int)
  Media(request_id~ : Int64, origin~ : String, permissions~ : Int)
} derive(Eq, 
Debug)

#
NativeDownloadUpdate

source
pub(all) struct NativeDownloadUpdate {
  download_id : Int
  state : String
  received_bytes : Int64
  total_bytes : Int64
  percent : Int
} derive(Eq, 
Debug)

#
NativeNotificationClick

source
pub(all) struct NativeNotificationClick {
  payload : String?
} derive(Eq, 
Debug)

A native notification activation, optionally carrying its application payload.

#
NativeNotificationResult

source
pub(all) enum NativeNotificationResult {
  Delivered
  Failed(String)
} derive(Eq, 
Debug)

#
ProcessResult

source
pub(all) enum ProcessResult {
  MainProcess
  SubprocessHandled(Int)
} derive(Eq, 
Debug)

#
Runtime

source
type Runtime

#
Runtime::activate_wakeup_source

source
fn Runtime::activate_wakeup_source(self : Runtime) -> Unit raise NativeError

Activates a prepared wakeup source after its reader is connected.

#
Runtime::begin_message_dialog

source
fn Runtime::begin_message_dialog(self : Runtime, title : String?, message : String, level : DialogLevel) -> Int64 raise NativeError

#
Runtime::destroy

source
fn Runtime::destroy(self : Runtime) -> Unit raise NativeError

#
Runtime::do_message_loop_work

source
fn Runtime::do_message_loop_work(self : Runtime) -> Unit raise NativeError

Advances one external-message-pump iteration for a low-level host.

Managed application runners own the native message loop and reject this operation.

#
Runtime::new

source
fn Runtime::new(config? : RuntimeConfig) -> Runtime raise NativeError

#
Runtime::next_wakeup_delay_ms

source
fn Runtime::next_wakeup_delay_ms(self : Runtime) -> Int? raise NativeError

Returns the delay until CEF next needs its external message pump serviced, or None when no delayed pump is scheduled.

Managed application runners own the native message loop and reject this operation.

#
Runtime::poll_bridge_request

source
fn Runtime::poll_bridge_request(self : Runtime) -> BridgeRequest? raise NativeError

#
Runtime::poll_bridge_request_json

source
fn Runtime::poll_bridge_request_json(self : Runtime) -> String? raise NativeError

#
Runtime::poll_event

source
fn Runtime::poll_event(self : Runtime) -> RuntimeEvent? raise NativeError

#
Runtime::poll_event_json

source
fn Runtime::poll_event_json(self : Runtime) -> String? raise NativeError

#
Runtime::poll_message_dialog

source
fn Runtime::poll_message_dialog(self : Runtime, dialog : Int64) -> Bool raise NativeError

#
Runtime::prepare_wakeup_source

source
fn Runtime::prepare_wakeup_source(self : Runtime) -> String raise NativeError

Prepares a platform-owned wakeup source and returns its locator.

Call activate_wakeup_source after opening the locator for reading.

#
Runtime::quit

source
fn Runtime::quit(self : Runtime) -> Unit raise NativeError

Requests that a low-level host's CEF message loop stop.

Managed application runners own the native message loop and reject this operation. Destroy the runtime to finish a managed application.

#
Runtime::respond_bridge_request

source
fn Runtime::respond_bridge_request(self : Runtime, response : BridgeResponse) -> Unit raise NativeError

#
Runtime::run

source
fn Runtime::run(self : Runtime) -> Unit raise NativeError

Runs CEF's message loop for a low-level host.

Managed application runners own this loop and reject this operation.

#
Runtime::set_menu

source
fn Runtime::set_menu(self : Runtime, menu : MenuBar) -> Unit raise NativeError

Replaces the application-level native menu bar for this runtime.

#
Runtime::set_wakeup_fd

source
fn Runtime::set_wakeup_fd(self : Runtime, wakeup_fd : Int) -> Unit raise NativeError

Installs the write end of a non-blocking pipe used to wake the host async runtime. The native runtime duplicates the descriptor and does not borrow the caller's ownership.

#
Runtime::wait

source
fn Runtime::wait(self : Runtime, interest_mask~ : Int, timeout_ms~ : Int) -> RuntimeWaitReady raise NativeError

Waits for low-level external-pump work.

Managed application runners use set_wakeup_fd instead and reject this operation.

#
RuntimeConfig

source
type RuntimeConfig derive(Eq, 
Debug)

#
RuntimeConfig::bundled

source
fn RuntimeConfig::bundled(helper_path? : String, cache_dir? : String, remote_debugging_port? : Int, headless? : Bool) -> RuntimeConfig

helper_path, when set, overrides the subprocess executable the bundled runtime launches. On macOS the helper must run from a nested .app so Chromium's outer-bundle walk yields the same base bundle id as the browser; otherwise the MachPort rendezvous service names mismatch and every child process terminates. Framework and resource discovery still run relative to the loaded libproton, so only the helper needs an explicit path. Set headless to enable CEF off-screen rendering for every window.

#
RuntimeConfig::new

source
fn RuntimeConfig::new(runtime_root? : String, helper_path? : String, resources_dir? : String, locales_dir? : String, cache_dir? : String, remote_debugging_port? : Int, headless? : Bool) -> RuntimeConfig

Builds an explicit native runtime configuration.

Set headless to enable CEF off-screen rendering for every window created by this runtime. Remote debugging remains independently configurable.

#
RuntimeConfig::probe

source
fn RuntimeConfig::probe(self : RuntimeConfig) -> Unit raise NativeError

#
RuntimeConfig::to_json_string

source
fn RuntimeConfig::to_json_string(self : RuntimeConfig) -> String

#
RuntimeConfig::unsafe_from_json

source
fn RuntimeConfig::unsafe_from_json(raw_json : String) -> RuntimeConfig

#
RuntimeEvent

source
type RuntimeEvent derive(Eq, 
Debug)

#
RuntimeEvent::bridge_request_cancellation

source
fn RuntimeEvent::bridge_request_cancellation(self : RuntimeEvent) -> Int64?

#
RuntimeEvent::browser_download_update

source
fn RuntimeEvent::browser_download_update(self : RuntimeEvent) -> NativeDownloadUpdate?

#
RuntimeEvent::browser_request

source
fn RuntimeEvent::browser_request(self : RuntimeEvent) -> NativeBrowserRequest?

#
RuntimeEvent::event_type

source
fn RuntimeEvent::event_type(self : RuntimeEvent) -> String

#
RuntimeEvent::has_window

source
fn RuntimeEvent::has_window(self : RuntimeEvent) -> Bool

#
RuntimeEvent::is_bridge_lifecycle_changed

source
fn RuntimeEvent::is_bridge_lifecycle_changed(self : RuntimeEvent) -> Bool

#
RuntimeEvent::is_window_closed

source
fn RuntimeEvent::is_window_closed(self : RuntimeEvent) -> Bool

#
RuntimeEvent::is_window_created

source
fn RuntimeEvent::is_window_created(self : RuntimeEvent) -> Bool

#
RuntimeEvent::launch_input

source
fn RuntimeEvent::launch_input(self : RuntimeEvent) -> RuntimeLaunchInput?

Returns the typed application launch input carried by this event.

#
RuntimeEvent::menu_command_id

source
fn RuntimeEvent::menu_command_id(self : RuntimeEvent) -> String?

The command id for an app-menu command item click, or None for every other event kind.

#
RuntimeEvent::notification_result

source
fn RuntimeEvent::notification_result(self : RuntimeEvent) -> NativeNotificationResult?

#
RuntimeEvent::window_close_request

source
fn RuntimeEvent::window_close_request(self : RuntimeEvent) -> Int64?

#
RuntimeEvent::window_id

source
fn RuntimeEvent::window_id(self : RuntimeEvent) -> Int64?

Returns the window associated with this event when one exists. For an app menu command this is the focused window at click time.

#
RuntimeEvent::window_state_change

source
fn RuntimeEvent::window_state_change(self : RuntimeEvent) -> WindowState?

#
RuntimeInfo

source
pub(all) struct RuntimeInfo {
  abi_version : Int
  runtime_available : Bool
  build_mode : String
  platform : String
  features : Array[String]
} derive(Eq, 
Debug, 
FromJson)

#
RuntimeLaunchInput

source
pub(all) enum RuntimeLaunchInput {
  OpenUrls(Array[String])
  OpenFiles(Array[String])
  Reopen
} derive(Eq, 
Debug)

A macOS application activation delivered by Launch Services or the Dock.

#
RuntimeWaitReady

source
pub(all) struct RuntimeWaitReady {
  mask : Int
} derive(Eq, 
Debug)

#
RuntimeWaitReady::has_bridge

source
fn RuntimeWaitReady::has_bridge(self : RuntimeWaitReady) -> Bool

#
RuntimeWaitReady::has_event

source
fn RuntimeWaitReady::has_event(self : RuntimeWaitReady) -> Bool

#
RuntimeWaitReady::has_platform

source
fn RuntimeWaitReady::has_platform(self : RuntimeWaitReady) -> Bool

#
RuntimeWaitReady::is_timeout

source
fn RuntimeWaitReady::is_timeout(self : RuntimeWaitReady) -> Bool

#
RuntimeWaitReady::mask

source
fn RuntimeWaitReady::mask(self : RuntimeWaitReady) -> Int

#
TitlebarStyle

source
pub(all) enum TitlebarStyle {
  Default
  Overlay
} derive(Eq, 
Debug)

#
Window

source
type Window

#
Window::as_ref

source
fn Window::as_ref(self : Window) -> WindowRef

Borrows this owning window handle for APIs that must not destroy it.

#
Window::bridge_lifecycle_state

source
fn Window::bridge_lifecycle_state(self : Window) -> BridgeLifecycleState raise NativeError

#
Window::browser_command

source
fn Window::browser_command(self : Window, command : String, download_id? : Int) -> Unit raise NativeError

#
Window::close

source
fn Window::close(self : Window) -> Unit raise NativeError

#
Window::destroy

source
fn Window::destroy(self : Window) -> Unit raise NativeError

#
Window::emit_bridge_event_json

source
fn Window::emit_bridge_event_json(self : Window, event_json : String) -> Unit raise NativeError

#
Window::eval

source
fn Window::eval(self : Window, script : String) -> Unit raise NativeError

#
Window::focus

source
fn Window::focus(self : Window) -> Unit raise NativeError

#
Window::hide

source
fn Window::hide(self : Window) -> Unit raise NativeError

#
Window::id

source
fn Window::id(self : Window) -> Int64

Returns the stable native handle used to correlate runtime events.

#
Window::load_html

source
fn Window::load_html(self : Window, html : String, base_url : String) -> Unit raise NativeError

#
Window::load_url

source
fn Window::load_url(self : Window, url : String) -> Unit raise NativeError

#
Window::maximize

source
fn Window::maximize(self : Window) -> Unit raise NativeError

#
Window::minimize

source
fn Window::minimize(self : Window) -> Unit raise NativeError

#
Window::new

source
fn Window::new(runtime : Runtime, config? : WindowConfig) -> Window raise NativeError

#
Window::respond_browser_request

source
fn Window::respond_browser_request(self : Window, request_id : Int64, action : String, path? : String) -> Unit raise NativeError

#
Window::respond_close_request

source
fn Window::respond_close_request(self : Window, request_id : Int64, allow : Bool) -> Unit raise NativeError

#
Window::restore

source
fn Window::restore(self : Window) -> Unit raise NativeError

#
Window::set_always_on_top

source
fn Window::set_always_on_top(self : Window, always_on_top : Bool) -> Unit raise NativeError

#
Window::set_close_interception

source
fn Window::set_close_interception(self : Window, enabled : Bool) -> Unit raise NativeError

#
Window::set_fullscreen

source
fn Window::set_fullscreen(self : Window, fullscreen : Bool) -> Unit raise NativeError

#
Window::set_position

source
fn Window::set_position(self : Window, x : Int, y : Int) -> Unit raise NativeError

#
Window::set_size

source
fn Window::set_size(self : Window, width : Int, height : Int) -> Unit raise NativeError

#
Window::set_title

source
fn Window::set_title(self : Window, title : String) -> Unit raise NativeError

#
Window::set_zoom_percent

source
fn Window::set_zoom_percent(self : Window, zoom_percent : Int) -> Unit raise NativeError

#
Window::show

source
fn Window::show(self : Window) -> Unit raise NativeError

#
Window::state

source
fn Window::state(self : Window) -> WindowState raise NativeError

#
Window::take_bridge_failure

source
fn Window::take_bridge_failure(self : Window) -> BridgeDiagnostic? raise NativeError

#
WindowConfig

source
type WindowConfig derive(Eq, 
Debug)

#
WindowConfig::new

source
fn WindowConfig::new(title? : String, width? : Int, height? : Int, initial_url? : String, size_hint? : WindowSizeHint, titlebar_style? : TitlebarStyle, browser? : BrowserPolicy, bridge? : BridgeConfig) -> WindowConfig

#
WindowConfig::to_json_string

source
fn WindowConfig::to_json_string(self : WindowConfig) -> String

#
WindowConfig::unsafe_from_json

source
fn WindowConfig::unsafe_from_json(raw_json : String) -> WindowConfig

#
WindowMonitor

source
pub(all) struct WindowMonitor {
  x : Int
  y : Int
  width : Int
  height : Int
  work_x : Int
  work_y : Int
  work_width : Int
  work_height : Int
  scale_factor_percent : Int
} derive(Eq, 
Debug, 
FromJson)

Geometry and scaling information for the monitor containing a window.

#
WindowRef

source
type WindowRef derive(Eq, 
Debug)

#
WindowRef::begin_choose_directory_dialog

source
fn WindowRef::begin_choose_directory_dialog(self : WindowRef, title : String?, path : String?) -> Int64 raise NativeError

#
WindowRef::begin_confirm_dialog

source
fn WindowRef::begin_confirm_dialog(self : WindowRef, title : String?, message : String, level : DialogLevel) -> Int64 raise NativeError

#
WindowRef::begin_message_dialog

source
fn WindowRef::begin_message_dialog(self : WindowRef, title : String?, message : String, level : DialogLevel) -> Int64 raise NativeError

#
WindowRef::begin_open_file_dialog

source
fn WindowRef::begin_open_file_dialog(self : WindowRef, title : String?, path : String?) -> Int64 raise NativeError

#
WindowRef::begin_save_file_dialog

source
fn WindowRef::begin_save_file_dialog(self : WindowRef, title : String?, path : String?) -> Int64 raise NativeError

#
WindowRef::poll_dialog_result

source
fn WindowRef::poll_dialog_result(self : WindowRef, dialog : Int64) -> DialogPollResult raise NativeError

#
WindowRef::unsafe_from_handle

source
fn WindowRef::unsafe_from_handle(handle : Int64) -> WindowRef

#
WindowSizeHint

source
pub(all) enum WindowSizeHint {
  Unconstrained
  Fixed
  Min
  Max
} derive(Eq, 
Debug)

Controls how the configured width and height constrain native resizing.

#
WindowState

source
pub(all) struct WindowState {
  x : Int
  y : Int
  width : Int
  height : Int
  monitor : WindowMonitor
  zoom_percent : Int
  visible : Bool
  focused : Bool
  minimized : Bool
  maximized : Bool
  fullscreen : Bool
  always_on_top : Bool
  theme : String
} derive(Eq, 
Debug, 
FromJson)

A point-in-time native window state snapshot.

#
abi_version

source
fn abi_version() -> Int

#
bridge_permission_grants_supported

source
fn bridge_permission_grants_supported() -> Bool

#
execute_process

source
fn execute_process(config? : RuntimeConfig) -> ProcessResult raise NativeError

#
last_error_message

source
fn last_error_message() -> String

#
notification_cleanup

source
fn notification_cleanup() -> Unit raise NativeError

Releases process-level notification hooks installed by Proton.

#
notification_poll_click

source
fn notification_poll_click() -> NativeNotificationClick? raise NativeError

Removes and returns the oldest pending notification activation.

#
notification_show

source
fn notification_show(title : String, body : String, payload? : String) -> Unit raise NativeError

Schedules a native notification with an optional activation payload.

#
notification_supported

source
fn notification_supported() -> Bool raise NativeError

Reports whether native notifications are available in the current process.

#
probe_runtime

source
fn probe_runtime(config? : RuntimeConfig) -> Unit raise NativeError

#
run_app

source
fn run_app(entry : FuncRef[() -> Unit]) -> Unit raise NativeError

Runs entry on Proton's application thread while the caller owns the platform UI loop on runtimes that advertise managed_app_runner. Other platforms may execute entry inline.

#
runtime_info

source
fn runtime_info() -> RuntimeInfo raise NativeError

#
runtime_info_json

source
fn runtime_info_json() -> String raise NativeError

#
runtime_wait_all

source
let runtime_wait_all : Int

#
runtime_wait_bridge

source
let runtime_wait_bridge : Int

#
runtime_wait_event

source
let runtime_wait_event : Int

#
runtime_wait_none

source
let runtime_wait_none : Int

#
runtime_wait_platform

source
let runtime_wait_platform : Int

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io