#[cfg(any(
all(feature = "appkit", feature = "gtk"),
all(feature = "appkit", feature = "mock"),
all(feature = "gtk", feature = "mock"),
all(feature = "qt", feature = "appkit"),
all(feature = "qt", feature = "gtk"),
all(feature = "qt", feature = "mock"),
all(feature = "xaml", feature = "appkit"),
all(feature = "xaml", feature = "gtk"),
all(feature = "xaml", feature = "qt"),
all(feature = "xaml", feature = "mock"),
all(feature = "dom", feature = "appkit"),
all(feature = "dom", feature = "gtk"),
all(feature = "dom", feature = "qt"),
all(feature = "dom", feature = "xaml"),
all(feature = "dom", feature = "mock"),
))]
compile_error!("day: enable exactly one backend feature");
pub use day_core::frame;
pub use day_core::{
AnyPiece, Blocking, BlockingError, BuildCx, Piece, PieceSeq, TaskHandle, blocking_limit,
blocking_threads, dark_mode, reduce_motion, safe_area, set_app_badge, set_appearance,
size_class, sleep, spawn_blocking, task,
};
pub use day_core::{AssetDir, AssetName, FontFamily, ImageName, Resource, VectorName, resource};
pub use day_core::{
Bitmap, decode_image, decode_image_async, image_decode_support, image_encode_formats,
image_encode_support,
};
pub use day_core::{ElementId, IntoElementKey, id};
pub use day_core::{
application_handlers, default_browser, open_url_with_application, share_support, share_url,
};
pub use day_core::{focus_search, request_route};
pub use day_core::{testing, tween};
#[cfg(feature = "fs")]
pub use day_part_filesystem as fs;
#[cfg(feature = "permissions")]
pub use day_part_permissions as permissions;
#[cfg(feature = "settings")]
pub use day_piece_settings as settings;
#[cfg(feature = "swiftui")]
pub use day_piece_swiftui as swiftui;
#[cfg(feature = "text-editor")]
pub use day_piece_text_editor as texteditor;
#[cfg(feature = "text-editor")]
pub use day_piece_text_editor::{TextEditor, TextEditorBuilder, text_editor};
pub use day_pieces::{AsyncImage, AsyncImageBuilder, async_image};
pub use day_pieces::{
CanvasExports, Drawing, PdfDocument, RenderBitmap, RenderPdf, canvas_exports,
};
pub use day_pieces::{colorpicker, combobox, datetime, pager, pullrefresh, searchfield, stepper};
pub use day_spec::AppBadge;
pub use day_spec::applications::{
Application, ApplicationError, ApplicationHandlers, HandlerQuery,
};
pub use day_spec::present::app_temp_dir;
pub use day_spec::storage;
pub use day_spec::{
BitmapId, BitmapInfo, EncodeSpec, ImageError, ImageFormat, ImageProperties, ImageSource,
};
pub use day_spec::{EXPORT_MAX_PIXELS, EXPORT_MAX_SIDE, ExportError, PdfInfo, PdfPage};
pub use day_spec::{KeyEvent, Modifiers};
pub use day_core::{
WindowHandle, check_for_updates, current_window, focused_window, initial_window, open_about,
open_new_window, open_preferences, open_window, quit, register_about, register_about_window,
register_check_for_updates, register_new_window, register_new_window_for, register_preferences,
register_preferences_with, window_by_key, window_title,
};
pub use day_core::{KeepRunning, set_app_progress, set_dock_visible, set_keep_running};
pub use day_spec::{AppProgress, StatusImage};
pub use day_core::{monitors, set_launcher_shortcuts};
pub use day_spec::{LauncherShortcut, Monitor};
pub use day_spec::{
Attention, WindowBackground, WindowChrome, WindowKind, WindowLevel, WindowMaterial,
WindowPlacement, WindowState, WindowTabbing,
};
pub mod reactive {
pub use day_reactive::*;
}
#[cfg(feature = "model")]
pub mod model {
pub use day_model::*;
}
pub use day_core::{install_edit_bridge, invoke_edit};
pub use day_spec::EditState;
pub mod clipboard {
pub use day_part_clipboard::*;
}
pub use day_spec::EditOp;
#[cfg(feature = "model")]
pub fn install_undo(stack: &day_model::UndoStack) {
let s = stack.clone();
day_core::install_undo_bridge(
stack.can_undo(),
stack.can_redo(),
stack.undo_label(),
stack.redo_label(),
move |redo| {
if redo {
s.redo();
} else {
s.undo();
}
},
);
}
pub fn install_edit_commands(
can_copy: impl Fn() -> bool + 'static,
copy: impl Fn() -> Option<String> + 'static,
cut: impl Fn() -> Option<String> + 'static,
paste: impl Fn(&str) + 'static,
select_all: impl Fn() + 'static,
) {
let ours: std::rc::Rc<std::cell::RefCell<Option<String>>> = Default::default();
let (copied, pasted) = (ours.clone(), ours);
let place = move |payload: String| {
let _ = day_part_clipboard::set_text(&payload);
*copied.borrow_mut() = Some(payload);
};
day_core::install_edit_bridge(
move || {
let can = can_copy();
day_spec::EditState {
can_cut: can,
can_copy: can,
can_paste: true,
can_select_all: true,
}
},
move |op| match op {
day_spec::EditOp::Copy => {
if let Some(payload) = copy() {
place(payload);
}
}
day_spec::EditOp::Cut => {
if let Some(payload) = cut() {
place(payload);
}
}
day_spec::EditOp::Paste => {
let text = day_part_clipboard::get_text()
.filter(|t| !t.is_empty())
.or_else(|| {
let ours = pasted.borrow().clone();
if ours.is_some() {
log::warn!(
"clipboard read came back empty — pasting what this app last \
copied (docs/clipboard.md)"
);
}
ours
});
if let Some(text) = text {
paste(&text);
}
}
day_spec::EditOp::SelectAll => select_all(),
},
);
}
pub fn modifiers() -> day_spec::Modifiers {
day_core::modifiers()
}
#[cfg(feature = "prefs")]
pub mod prefs {
pub use day_part_preferences::*;
#[cfg(feature = "model")]
pub fn bind_json<T>(key: &str, store: day_model::Store<day_model::Keyed<T>>)
where
T: day_model::Identified + Clone + serde::Serialize + serde::de::DeserializeOwned,
{
use day_model::Source;
if let Some(json) = get(key) {
match serde_json::from_str::<Vec<T>>(&json) {
Ok(rows) => store.update("load", |k| *k = day_model::Keyed::new(rows)),
Err(error) => log::warn!("could not read `{key}` from preferences: {error}"),
}
}
let key = key.to_owned();
day_reactive::watch(
move || store.with(|_| ()),
move |_, _| match store.with_untracked(|k| serde_json::to_string(k.items())) {
Ok(json) if set(&key, &json) => log::debug!("saved `{key}` to preferences"),
Ok(_) => log::warn!("could not save `{key}` to preferences"),
Err(error) => log::warn!("could not encode `{key}`: {error}"),
},
);
}
}
pub use day_core::{lifecycle_supported, on_lifecycle};
pub mod cursor {
pub use day_spec::Cursor;
#[cfg(feature = "appkit")]
pub mod appkit {
use day_spec::Cursor;
pub const DISAPPEARING_ITEM: Cursor = Cursor::native("disappearingItem");
pub const DRAG_COPY: Cursor = Cursor::native("dragCopy");
pub const DRAG_LINK: Cursor = Cursor::native("dragLink");
pub const CONTEXTUAL_MENU: Cursor = Cursor::native("contextualMenu");
pub const I_BEAM_VERTICAL: Cursor = Cursor::native("IBeamCursorForVerticalLayout");
}
#[cfg(feature = "qt")]
pub mod qt {
use day_spec::Cursor;
pub const WHATS_THIS: Cursor = Cursor::native("WhatsThisCursor");
pub const BUSY: Cursor = Cursor::native("BusyCursor");
pub const UP_ARROW: Cursor = Cursor::native("UpArrowCursor");
pub const SPLIT_H: Cursor = Cursor::native("SplitHCursor");
pub const SPLIT_V: Cursor = Cursor::native("SplitVCursor");
}
#[cfg(feature = "xaml")]
pub mod xaml {
use day_spec::Cursor;
pub const PERSON: Cursor = Cursor::native("person");
pub const PIN: Cursor = Cursor::native("pin");
pub const UP_ARROW: Cursor = Cursor::native("uparrow");
pub const APP_STARTING: Cursor = Cursor::native("appstarting");
}
#[cfg(feature = "material")]
pub mod android {
use day_spec::Cursor;
pub const ALL_SCROLL: Cursor = Cursor::native("all_scroll");
pub const NO_DROP: Cursor = Cursor::native("no_drop");
pub const TOP_RIGHT_DIAGONAL: Cursor = Cursor::native("top_right_diagonal_double_arrow");
pub const TOP_LEFT_DIAGONAL: Cursor = Cursor::native("top_left_diagonal_double_arrow");
}
}
pub use day_localization_ui::{IntoFArg, IntoNumberFArg, LocalizedText, res, tr};
pub use ::log;
pub use day_core::set_log_level;
pub use log::{debug, error, info, log_enabled, trace, warn};
pub fn window_image() -> WindowImage {
WindowImage { chrome: false }
}
pub fn window_image_support() -> day_spec::Support {
day_core::with_tree(|t| t.window_image_support())
}
pub use day_core::{font_families, measure_text};
pub use day_core::{TextMetricsCacheStats, clear_text_metrics_cache, text_metrics_cache_stats};
#[derive(Clone, Copy, Debug)]
pub struct WindowImage {
chrome: bool,
}
impl WindowImage {
pub fn chrome(mut self) -> Self {
self.chrome = true;
self
}
pub fn capture(self) -> Result<Vec<u8>, String> {
day_core::with_tree(|t| {
if self.chrome {
t.snapshot_chrome()
} else {
t.snapshot()
}
})
}
}
pub fn env(key: &str) -> Option<String> {
#[cfg(all(target_arch = "wasm32", feature = "dom"))]
{
day_toolkit_dom::host_env(key)
}
#[cfg(not(all(target_arch = "wasm32", feature = "dom")))]
{
std::env::var(key).ok()
}
}
pub use day_localization_ui::install as install_locales;
pub use day_localization_ui::{Catalog, FArg, format_catalog, register_catalog, tr_in};
pub use day_localization_ui::{compare, compare_in, sort_localized};
pub use day_localization_ui::{format_decimal, format_decimal_in};
pub use day_localization_ui::{
DateFields, format_date, format_date_in, format_percent, format_percent_in,
};
pub use day_localization_ui::{matches_search, matches_search_in};
pub use day_localization_ui::locale;
pub use day_core::{RNode, invalidate_size};
pub use day_pieces::Command;
pub use day_pieces::NativeRef;
pub use day_core::conformance;
pub use day_core::conformance::{Case, Drive, Fail, TestResult};
#[cfg(target_arch = "wasm32")]
#[doc(hidden)]
pub use day_core::inventory;
pub use day_core::linkme;
#[doc(hidden)]
#[cfg(not(target_arch = "wasm32"))]
pub use day_core::shortcuts::LAUNCHER_SHORTCUTS;
pub use day_macros::builder;
pub use day_macros::test;
#[cfg(feature = "conformance")]
pub use day_pieces::conformance as builtin_tests;
pub use day_pieces::routes;
pub use day_pieces::test_host;
pub use day_spec::{Lifecycle, WindowOptions};
pub mod record {
pub use day_script::record::*;
}
pub fn play_script(yaml: &str) -> Result<(), String> {
day_script::play(yaml)
}
pub const fn toolkit_name() -> &'static str {
#[cfg(feature = "appkit")]
{
return "AppKit";
}
#[cfg(feature = "gtk")]
{
return "GTK";
}
#[cfg(feature = "qt")]
{
return "Qt";
}
#[cfg(feature = "uikit")]
{
return "UIKit";
}
#[cfg(feature = "material")]
{
return "Material Components";
}
#[cfg(feature = "winui")]
{
return "WinUI";
}
#[cfg(all(feature = "xaml", not(feature = "winui")))]
{
return "XAML";
}
#[cfg(feature = "arkui")]
{
return "ArkUI";
}
#[cfg(feature = "dom")]
{
return "DOM";
}
#[allow(unreachable_code)]
{
"Mock"
}
}
pub mod prelude {
pub use day_core::{ElementId, IntoElementKey, id};
pub use day_localization_ui::{
LocalizedText, install as install_locales, matches_search, set_locale, sort_localized, tr,
};
#[cfg(feature = "text-editor")]
pub use day_piece_text_editor::{TextEditor, TextEditorBuilder, text_editor};
pub use day_pieces::prelude::*;
pub use day_spec::{Lifecycle, Size, WindowOptions};
pub use day_spec::{CornerRadii, FillRule, LineCap, LineJoin, Path, PathSeg, StrokeStyle};
pub use day_macros::build_path;
#[cfg(feature = "model")]
pub use ::day_model;
#[cfg(feature = "model")]
#[doc(no_inline)]
pub use ::day_model::Uuid;
#[cfg(feature = "model")]
pub use ::day_model::{Elem, Field, Key, Keyed, ModelId, Source, Store};
#[cfg(feature = "model")]
pub use day_macros::Observable;
pub use day_spec::Point;
pub use super::{debug, error, info, log, log_enabled, set_log_level, trace, warn};
pub use {super::lifecycle_supported, super::on_lifecycle};
pub use day_core::{
AssetDir, AssetName, FontFamily, ImageName, Resource, VectorName, resource,
};
pub use day_spec::present::app_temp_dir;
pub use day_core::capability;
pub use day_core::safe_area;
pub use day_core::size_class;
pub use day_spec::{Cap, Cursor, HeightClass, SizeClass, Support, WidthClass};
pub use day_core::{is_rtl, layout_direction};
pub use day_spec::LayoutDirection;
}
pub mod lifecycle {
pub use day_core::{lifecycle_supported, on_lifecycle};
pub use day_spec::Lifecycle;
pub const fn supported(phase: Lifecycle) -> bool {
#[cfg(feature = "appkit")]
{
return day_toolkit_appkit::lifecycle_supported(phase);
}
#[cfg(feature = "gtk")]
{
return day_toolkit_gtk::lifecycle_supported(phase);
}
#[cfg(feature = "qt")]
{
return day_toolkit_qt::lifecycle_supported(phase);
}
#[cfg(all(feature = "uikit", target_os = "ios"))]
{
return day_toolkit_uikit::lifecycle_supported(phase);
}
#[cfg(all(feature = "material", target_os = "android"))]
{
return day_toolkit_material::lifecycle_supported(phase);
}
#[cfg(all(feature = "xaml", windows))]
{
return day_toolkit_winui::lifecycle_supported(phase);
}
#[cfg(all(feature = "arkui", target_env = "ohos"))]
{
return day_toolkit_arkui::lifecycle_supported(phase);
}
#[allow(unreachable_code)]
{
phase.is_universal()
}
}
}
#[macro_export]
macro_rules! require_lifecycle {
($phase:expr) => {
const {
::core::assert!(
$crate::lifecycle::supported($phase),
"this Day backend does not deliver that lifecycle phase (see docs/lifecycle.md)",
)
}
};
}
pub fn launch_external<P: day_spec::Platform, R: Piece>(
backend: P,
options: WindowOptions,
root: impl FnOnce() -> R + 'static,
) {
day_script::init();
start(backend, options, root);
}
#[allow(dead_code)]
fn start<P: day_spec::Platform, R: Piece>(
backend: P,
mut options: WindowOptions,
root: impl FnOnce() -> R + 'static,
) {
day_localization_ui::add_launch_locales(&backend.locale_hints());
#[cfg(feature = "prefs")]
if !day_core::has_nav_store() {
day_part_preferences::install_nav_store();
}
if let Some((default, catalog)) = options.locales {
day_localization_ui::install(default, catalog);
}
if let Some(f) = options.title_fn {
options.title = f();
}
day_core::launch_with(backend, options, move || AnyPiece::new(root()));
}
#[cfg(feature = "appkit")]
pub fn launch<P: Piece>(options: WindowOptions, root: impl FnOnce() -> P + 'static) {
day_script::init();
start(day_toolkit_appkit::AppKit::new(), options, root);
}
#[cfg(feature = "gtk")]
pub fn launch<P: Piece>(options: WindowOptions, root: impl FnOnce() -> P + 'static) {
day_script::init();
start(day_toolkit_gtk::Gtk::new(), options, root);
}
#[cfg(feature = "qt")]
pub fn launch<P: Piece>(options: WindowOptions, root: impl FnOnce() -> P + 'static) {
day_script::init();
start(day_toolkit_qt::Qt::new(), options, root);
}
#[cfg(all(feature = "uikit", target_os = "ios"))]
pub fn launch<P: Piece>(options: WindowOptions, root: impl FnOnce() -> P + 'static) {
day_script::init();
start(day_toolkit_uikit::Uikit::new(), options, root);
}
#[cfg(all(feature = "xaml", windows))]
pub fn launch<P: Piece>(options: WindowOptions, root: impl FnOnce() -> P + 'static) {
day_script::init();
start(day_toolkit_winui::Xaml::new(), options, root);
}
#[cfg(all(feature = "dom", target_arch = "wasm32"))]
pub fn launch<P: Piece>(options: WindowOptions, root: impl FnOnce() -> P + 'static) {
start(day_toolkit_dom::Dom::new(), options, root);
}
#[cfg(feature = "mock")]
pub fn launch<P: Piece>(options: WindowOptions, root: impl FnOnce() -> P + 'static) {
let (mock, _probe) = day_mock::MockToolkit::new();
start(mock, options, root);
}
#[doc(hidden)]
#[macro_export]
macro_rules! with_app_version {
($options:expr) => {{
let mut options: $crate::WindowOptions = $options;
if options.version.is_none() {
options.version =
::core::option::Option::Some(::core::env!("CARGO_PKG_VERSION").into());
}
options
}};
}
#[macro_export]
macro_rules! day_start {
($root:expr) => {
$crate::day_start!("", $root);
};
(options: $options:expr, $root:expr) => {
$crate::day_start_ios!(options: $options, $root);
$crate::day_start_macos!(options: $options, $root);
$crate::day_start_android!(options: $options, $root);
$crate::day_start_arkui!(options: $options, $root);
$crate::day_start_web!(options: $options, $root);
};
($title:expr, $root:expr) => {
$crate::day_start_ios!($title, $root);
$crate::day_start_macos!($title, $root);
$crate::day_start_android!($root);
$crate::day_start_arkui!($root);
$crate::day_start_web!($title, $root);
};
}
#[macro_export]
macro_rules! resources {
() => {
pub mod res {
include!(concat!(env!("OUT_DIR"), "/day_resources.rs"));
}
};
}
#[macro_export]
macro_rules! day_start_ios {
($root:expr) => {
$crate::day_start_ios!("", $root);
};
(options: $options:expr, $root:expr) => {
#[cfg(target_os = "ios")]
#[unsafe(no_mangle)]
pub extern "C" fn day_main() {
$crate::launch($crate::with_app_version!($options), $root);
}
};
($title:expr, $root:expr) => {
$crate::day_start_ios!(
options: $crate::WindowOptions::default().title($title),
$root
);
};
}
#[macro_export]
macro_rules! day_start_macos {
($root:expr) => {
$crate::day_start_macos!("", $root);
};
(options: $options:expr, $root:expr) => {
#[cfg(target_os = "macos")]
#[unsafe(no_mangle)]
pub extern "C" fn day_main() {
$crate::launch($crate::with_app_version!($options), $root);
}
};
($title:expr, $root:expr) => {
$crate::day_start_macos!(
options: $crate::WindowOptions::default().title($title).size(960.0, 640.0),
$root
);
};
}
#[macro_export]
macro_rules! day_start_android {
($root:expr) => {
$crate::day_start_android!(
options: $crate::WindowOptions::default(),
$root
);
};
(options: $options:expr, $root:expr) => {
#[cfg(target_os = "android")]
#[unsafe(no_mangle)]
pub extern "system" fn Java_dev_daybrite_day_bridge_DayBridge_nativeStart<'local>(
mut env: $crate::android::jni::EnvUnowned<'local>,
_class: $crate::android::jni::objects::JClass<'local>,
root: $crate::android::jni::objects::JObject<'local>,
density: $crate::android::jni::sys::jfloat,
w: $crate::android::jni::sys::jint,
h: $crate::android::jni::sys::jint,
autodrive: $crate::android::jni::objects::JString<'local>,
locale: $crate::android::jni::objects::JString<'local>,
env_blob: $crate::android::jni::objects::JString<'local>,
) {
let _ = env
.with_env(|env| {
let a = $crate::android::read_jstring(env, &autodrive);
let l = $crate::android::read_jstring(env, &locale);
let e = $crate::android::read_jstring(env, &env_blob);
$crate::android::start(env, root, density, w, h, a, l, e, $crate::with_app_version!($options), $root);
::core::result::Result::Ok::<(), $crate::android::jni::errors::Error>(())
})
.into_outcome();
}
#[cfg(target_os = "android")]
#[unsafe(no_mangle)]
pub extern "system" fn Java_dev_daybrite_day_bridge_DayBridge_nativeStartWindow<'local>(
mut env: $crate::android::jni::EnvUnowned<'local>,
_class: $crate::android::jni::objects::JClass<'local>,
root: $crate::android::jni::objects::JObject<'local>,
node: $crate::android::jni::sys::jlong,
_density: $crate::android::jni::sys::jfloat,
w: $crate::android::jni::sys::jint,
h: $crate::android::jni::sys::jint,
) -> $crate::android::jni::sys::jboolean {
let mut ok = false;
let _ = env
.with_env(|env| {
ok = $crate::android::window_started(env, root, node, w, h);
::core::result::Result::Ok::<(), $crate::android::jni::errors::Error>(())
})
.into_outcome();
ok as $crate::android::jni::sys::jboolean
}
};
}
#[cfg(all(feature = "material", target_os = "android"))]
pub mod android {
pub use day_toolkit_material::jni;
pub use day_toolkit_material::{mount_settled, read_jstring, window_started};
#[allow(clippy::too_many_arguments)]
pub fn start<R: crate::Piece>(
env: &mut jni::Env,
root: jni::objects::JObject,
density: f32,
w: i32,
h: i32,
autodrive: Option<String>,
locale: Option<String>,
env_blob: Option<String>,
options: crate::WindowOptions,
root_piece: impl FnOnce() -> R + 'static,
) {
day_toolkit_material::redirect_stdio_to_logcat();
let remount = day_core::is_mounted();
if remount {
day_core::prepare_remount();
day_localization_ui::set_launch_locales(&[]);
}
if let Some(a) = autodrive {
unsafe { std::env::set_var("DAY_AUTODRIVE", a) };
}
if let Some(l) = locale {
unsafe { std::env::set_var("DAY_LOCALE", l) };
}
if let Some(blob) = env_blob {
for line in blob.lines() {
if let Some((k, v)) = line.split_once('=') {
unsafe { std::env::set_var(k, v) };
}
}
}
day_toolkit_material::init(env, root, density, w, h);
if !remount {
day_script::init();
}
crate::start(day_toolkit_material::Material::new(), options, root_piece);
day_toolkit_material::mount_settled(remount);
}
}
#[macro_export]
macro_rules! day_start_arkui {
($root:expr) => {
$crate::day_start_arkui!(options: $crate::WindowOptions::default(), $root);
};
(options: $options:expr, $root:expr) => {
#[cfg(target_env = "ohos")]
#[unsafe(no_mangle)]
pub extern "C" fn day_arkui_start(
content: *mut ::core::ffi::c_void,
w: f64,
h: f64,
density: f64,
) {
$crate::arkui::start(content, w, h, density, $crate::with_app_version!($options), $root);
}
#[cfg(target_env = "ohos")]
#[unsafe(no_mangle)]
pub unsafe extern "C" fn day_arkui_deeplink(uri: *const ::core::ffi::c_char) {
unsafe { $crate::arkui::deeplink(uri) };
}
};
}
#[macro_export]
macro_rules! day_start_web {
($root:expr) => {
$crate::day_start_web!("", $root);
};
(options: $options:expr, $root:expr) => {
#[cfg(target_arch = "wasm32")]
#[unsafe(no_mangle)]
pub extern "C" fn day_dom_main() {
$crate::web::start($crate::with_app_version!($options), $root);
}
};
($title:expr, $root:expr) => {
$crate::day_start_web!(
options: $crate::WindowOptions::default().title($title),
$root
);
};
}
#[cfg(all(feature = "dom", target_arch = "wasm32"))]
pub mod web {
#[unsafe(no_mangle)]
pub extern "C" fn day_dom_script_line(ptr: *mut u8, len: usize) {
let line = day_toolkit_dom::take_alloc_string(ptr, len);
day_script::web_line(&line);
}
pub fn start<P: crate::Piece>(
options: crate::WindowOptions,
root: impl FnOnce() -> P + 'static,
) {
day_toolkit_dom::install_panic_hook();
day_core::set_log_sink(day_toolkit_dom::console_sink);
if let Some(level) = day_toolkit_dom::launch_log_level() {
day_core::set_log_level(level);
}
if let Some(locale) = day_toolkit_dom::launch_locale() {
day_localization_ui::set_launch_locale(&locale);
}
if let Some(url) = day_toolkit_dom::launch_open_url() {
day_core::request_open_url(&url);
}
if let Some(route) = day_toolkit_dom::launch_route() {
day_core::set_launch_deeplink(&route);
}
if let Some(token) = day_toolkit_dom::dayscript_token() {
day_script::web_init(token, day_toolkit_dom::script_send);
}
crate::launch(options, root);
}
}
#[cfg(all(feature = "arkui", target_env = "ohos"))]
pub mod arkui {
use core::ffi::c_void;
pub fn start<R: crate::Piece>(
content: *mut c_void,
w_vp: f64,
h_vp: f64,
density: f64,
options: crate::WindowOptions,
root: impl FnOnce() -> R + 'static,
) {
day_toolkit_arkui::init(content, w_vp, h_vp, density);
day_core::set_log_sink(day_toolkit_arkui::hilog_sink);
day_script::init();
crate::start(day_toolkit_arkui::ArkUi::new(), options, root);
}
pub unsafe fn deeplink(uri: *const core::ffi::c_char) {
if uri.is_null() {
return;
}
let uri = unsafe { core::ffi::CStr::from_ptr(uri) };
if let Ok(uri) = uri.to_str() {
if uri.starts_with("file://") {
day_core::request_open_files(vec![uri.into()]);
} else {
day_core::request_open_url(uri);
}
}
}
}
pub use day_spec::transfer;
pub use day_core::{on_open_files, on_open_url};
#[cfg(feature = "http-image")]
pub fn http_image(url: impl Into<String>) -> day_pieces::AsyncImage {
let source = day_reactive::Signal::new(None);
let request = day_part_http::Request::get(url);
let task = day_core::task(async move {
if let Ok(response) = day_part_http::fetch_future(request).await
&& (200..300).contains(&response.status)
{
source.set(Some(std::sync::Arc::new(response.body)));
}
});
day_reactive::Scope::current().on_cleanup(move || task.abort());
day_pieces::async_image(source)
}