#moonbit-community/proton

#Quick example

async fn main {
  @proton.html("Hello", "<h1>Hello</h1>")
  .identifier("dev.proton.hello")
  .run_or_abort()
}

#Application metadata and paths

#Single-instance runtime control

app_lifecycle(
  on_start=context => {
    println(context.has_single_instance_lock().to_string())
    context.release_single_instance_lock() catch { _ => () }
    context
  },
  on_shutdown=fn(_) { () },
)

#Browser task metrics

for metric in context.task_metrics() {
  println(metric.task_type.to_repr())
  println(metric.process_cpu_percent)
  println(metric.process_memory_bytes)
}

#Protocol and process control

#Application quit chain

let mut save_pending = true

@proton.html("Quit chain", page)
.identifier("com.example.quit-chain")
.on_before_quit(fn(_context) {
  if save_pending {
    @proton.ApplicationQuitDecision::Prevent
  } else {
    @proton.ApplicationQuitDecision::Allow
  }
})
.on_will_quit(fn(context) {
  context.relaunch() catch { _ => () }
  @proton.ApplicationQuitDecision::Allow
})
.on_quit(fn(_context, exit_code) {
  println("quitting with " + exit_code.to_string())
})
.run_or_abort()

#Application control

#Process-level events

#Page history and inserted CSS

let key = browser.insert_css("body { background: #101418; }")
browser.remove_inserted_css(key)

#webContents requests without a CEF equivalent

#Entry points

• @proton.html(title, html, ...) — inline HTML document.
• @proton.url(title, url, ...) — a remote or local URL.
• @proton.file(title, path, ...) — an HTML file on disk.
• @proton.asset(title, path, ...) — an HTML asset shipped with the app.

#Native images

#Commands and events

@proton.html("Commands", html)
.identifier("dev.proton.commands")
.commands(fn(registrar) raise { registrar.bind(ping_command, ping) })
.run_or_abort()

const reply = await window.__MoonBit__.core.invokeOp("ext:app/ping", {
  name: "proton",
});
window.__MoonBit__.events.on("app.tick", (event) => console.log(event.payload));

#Windows

@proton.html("Main", main_html)
.add_window(
  "settings",
  "Settings",
  @proton.AppEntry::Html(settings_html),
  width=420,
  height=320,
)

#Taskbar status

window.set_progress_bar(0.4)                                        // determinate
window.set_progress_bar(0.4, mode=@proton.ProgressBarMode::Paused)  // paused
window.set_progress_bar(-1.0, mode=@proton.ProgressBarMode::Cleared) // cleared

let overlay = @proton.native_image()
overlay.add_png(png_bytes, 16, 16)
window.set_overlay_icon(Some(overlay), "unread messages")
window.set_overlay_icon(None, "")

#Taskbar thumbnail toolbar

let previous = @proton.native_image()
previous.add_png(previous_png, 16, 16)
let applied = window.set_thumbar_buttons([
  @proton.ThumbarButton::{
    id: "previous",
    icon: previous,
    tooltip: "Previous",
    flags: [],
  },
  @proton.ThumbarButton::{
    id: "play",
    icon: play,
    tooltip: "Play or pause",
    flags: [@proton.ThumbarButtonFlag::NoBackground],
  },
])

@proton.html("Player", player_html)
.on_thumbar_button_click(fn(window, button_id) noraise {
  match button_id {
    "previous" => play_previous(window)
    "next" => play_next(window)
    _ => toggle_playback(window)
  }
})
.run_or_abort()

#Jump list

let result = @proton.set_jump_list(Some([
  @proton.JumpListCategory::{
    kind: @proton.JumpListCategoryKind::Tasks,
    name: "",
    items: [
      @proton.JumpListItem::{
        kind: @proton.JumpListItemKind::Task,
        path: executable,
        arguments: "--play",
        title: "Play or pause",
        description: "Starts playback in a new instance",
        icon_path: executable,
        icon_index: 0,
        working_directory: "",
      },
      // A separator is only allowed in the Tasks category.
      @proton.JumpListItem::{
        kind: @proton.JumpListItemKind::Separator,
        path: "",
        arguments: "",
        title: "",
        description: "",
        icon_path: "",
        icon_index: 0,
        working_directory: "",
      },
    ],
  },
  @proton.JumpListCategory::{
    kind: @proton.JumpListCategoryKind::Custom,
    name: "Recent sessions",
    items: [...],
  },
])) catch {
  error => abort(error.message())
}

#Logging

#Headless mode

#Accessibility

@proton.html("Accessible", "<main><h1>Hello</h1></main>")
.identifier("dev.proton.accessible")
.accessibility(@proton.AccessibilityMode::AlwaysEnabled)
.run_or_abort()

#System appearance

let appearance = @proton.system_appearance() catch {
  error => abort(error.message())
}
let dark = appearance.color_scheme == @proton.ColorScheme::Dark
let high_contrast = appearance.high_contrast

@proton.html("Theme aware", "<main><h1>Hello</h1></main>")
.on_system_appearance_change(fn(appearance) noraise {
  // Apply appearance.color_scheme and appearance.high_contrast to custom UI.
})
.run_or_abort()

#System preferences

let accent = @proton.system_accent_color()
let animation = @proton.system_animation_settings()
let microphone = @proton.system_media_access_status(
  @proton.MediaAccessKind::Microphone,
)
let trusted = @proton.system_is_trusted_accessibility_client(false)

• system_accent_color() returns RGBA hexadecimal digits without a leading #, the form getAccentColor returns. An empty value reports a platform or configuration without an accent color. Windows reads the DWM accent value through the same conversion Electron uses, so the stored alpha becomes full alpha; macOS keeps the color's own alpha; Linux reports an empty value because Proton does not read the XDG desktop portal yet.
• system_animation_settings() reports should_render_rich_animation, scroll_animations_enabled_by_system, and prefers_reduced_motion. Windows reads SPI_GETCLIENTAREAANIMATION and falls back to the session type when the parameter is unavailable; macOS reads the accessibility display options; Linux reads GTK's gtk-enable-animations and otherwise reports animations as enabled, which is Chromium's Linux behavior.
• system_media_access_status(kind) reports granted, denied, restricted, not-determined, or unknown for microphone, camera, and screen. Windows reads the capability access consent store that the privacy settings write, including the machine policy that makes a device restricted. Device and desktop-app (NonPackaged) denial takes precedence over per-app consent; missing per-app values fall back to desktop-app and then device consent. macOS reads the AVFoundation authorization and the screen-recording preflight; Linux reports an unsupported error, matching Electron's platform support.
• system_is_trusted_accessibility_client(prompt) is macOS only and maps to AXIsProcessTrustedWithOptions. Passing true lets macOS show its own prompt and register the application; other platforms report an unsupported error.

#Application locale

#Learn more

• Runnable demos live in the repository's examples/ directory.
• The CLI covers the project workflow: proton_cli new, proton_cli cef setup, proton_cli dev, proton_cli build, and proton_cli package.

#macOS traffic light position

#Update checks during startup