@effindomv2/fui-rs 0.1.17 → 0.1.19

package/src/file.rs

@@ -1124,11 +1124,8 @@ fn finish_worker_process(
     Option<FileWorkerCompleteCallback>,
     Option<FileErrorCallback>,
 )> {
-    let Some(request) =
-        ACTIVE_WORKER_PROCESS_REQUESTS.with(|requests| requests.borrow_mut().remove(&request_id))
-    else {
-        return None;
-    };
+    let request = ACTIVE_WORKER_PROCESS_REQUESTS
+        .with(|requests| requests.borrow_mut().remove(&request_id))?;
     let mut inner = request.borrow_mut();
     if inner.finished {
         return None;
@@ -1160,8 +1157,10 @@ pub fn reset_file_runtime() {
     NEXT_FILE_REQUEST_ID.with(|slot| *slot.borrow_mut() = 1);
 }
 
-#[no_mangle]
-pub extern "C" fn __fui_on_file_pick_result(
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
+/// # Safety
+/// `payload_ptr` must be null for an empty payload or point to `payload_len` readable bytes.
+pub unsafe extern "C" fn __fui_on_file_pick_result(
     request_id: u32,
     status: u32,
     payload_ptr: *const u8,
@@ -1191,8 +1190,10 @@ pub extern "C" fn __fui_on_file_pick_result(
     );
 }
 
-#[no_mangle]
-pub extern "C" fn __fui_on_file_read_result(
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
+/// # Safety
+/// `payload_ptr` must be null for an empty payload or point to `payload_len` readable bytes.
+pub unsafe extern "C" fn __fui_on_file_read_result(
     request_id: u32,
     status: u32,
     offset_bytes: u64,
@@ -1227,8 +1228,10 @@ pub extern "C" fn __fui_on_file_read_result(
     );
 }
 
-#[no_mangle]
-pub extern "C" fn __fui_on_file_save_result(
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
+/// # Safety
+/// `payload_ptr` must be null for an empty payload or point to `payload_len` readable bytes.
+pub unsafe extern "C" fn __fui_on_file_save_result(
     request_id: u32,
     status: u32,
     written_bytes: u64,
@@ -1264,8 +1267,10 @@ pub extern "C" fn __fui_on_file_save_result(
     );
 }
 
-#[no_mangle]
-pub extern "C" fn __fui_on_file_writer_created(
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
+/// # Safety
+/// `payload_ptr` must be null for an empty payload or point to `payload_len` readable bytes.
+pub unsafe extern "C" fn __fui_on_file_writer_created(
     request_id: u32,
     status: u32,
     payload_ptr: *const u8,
@@ -1301,8 +1306,10 @@ pub extern "C" fn __fui_on_file_writer_created(
     );
 }
 
-#[no_mangle]
-pub extern "C" fn __fui_on_file_write_result(
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
+/// # Safety
+/// `payload_ptr` must be null for an empty payload or point to `payload_len` readable bytes.
+pub unsafe extern "C" fn __fui_on_file_write_result(
     request_id: u32,
     status: u32,
     written_bytes: u64,
@@ -1332,8 +1339,10 @@ pub extern "C" fn __fui_on_file_write_result(
     );
 }
 
-#[no_mangle]
-pub extern "C" fn __fui_on_file_finish_result(
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
+/// # Safety
+/// `payload_ptr` must be null for an empty payload or point to `payload_len` readable bytes.
+pub unsafe extern "C" fn __fui_on_file_finish_result(
     request_id: u32,
     status: u32,
     written_bytes: u64,
@@ -1370,8 +1379,10 @@ pub extern "C" fn __fui_on_file_finish_result(
     );
 }
 
-#[no_mangle]
-pub extern "C" fn __fui_on_file_worker_process_progress(
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
+/// # Safety
+/// `payload_ptr` must be null for an empty payload or point to `payload_len` readable bytes.
+pub unsafe extern "C" fn __fui_on_file_worker_process_progress(
     request_id: u32,
     processed_bytes: u64,
     total_bytes: u64,
@@ -1398,8 +1409,10 @@ pub extern "C" fn __fui_on_file_worker_process_progress(
     }
 }
 
-#[no_mangle]
-pub extern "C" fn __fui_on_file_worker_process_chunk(
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
+/// # Safety
+/// `payload_ptr` must be null for an empty payload or point to `payload_len` readable bytes.
+pub unsafe extern "C" fn __fui_on_file_worker_process_chunk(
     request_id: u32,
     offset_bytes: u64,
     file_size_bytes: u64,
@@ -1426,8 +1439,10 @@ pub extern "C" fn __fui_on_file_worker_process_chunk(
     }
 }
 
-#[no_mangle]
-pub extern "C" fn __fui_on_file_worker_process_complete(
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
+/// # Safety
+/// `payload_ptr` must be null for an empty payload or point to `payload_len` readable bytes.
+pub unsafe extern "C" fn __fui_on_file_worker_process_complete(
     request_id: u32,
     processed_bytes: u64,
     payload_ptr: *const u8,
@@ -1451,8 +1466,10 @@ pub extern "C" fn __fui_on_file_worker_process_complete(
     }
 }
 
-#[no_mangle]
-pub extern "C" fn __fui_on_file_worker_process_error(
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
+/// # Safety
+/// `payload_ptr` must be null for an empty payload or point to `payload_len` readable bytes.
+pub unsafe extern "C" fn __fui_on_file_worker_process_error(
     request_id: u32,
     status: u32,
     payload_ptr: *const u8,
@@ -1513,12 +1530,14 @@ mod tests {
         payload.extend_from_slice(b"note.txt");
         payload.extend_from_slice(&10u32.to_le_bytes());
         payload.extend_from_slice(b"text/plain");
-        super::__fui_on_file_pick_result(
-            1,
-            FILE_STATUS_SUCCESS,
-            payload.as_ptr(),
-            payload.len() as u32,
-        );
+        unsafe {
+            super::__fui_on_file_pick_result(
+                1,
+                FILE_STATUS_SUCCESS,
+                payload.as_ptr(),
+                payload.len() as u32,
+            );
+        }
 
         let picked = picked.borrow();
         assert_eq!(picked.len(), 1);
@@ -1542,14 +1561,16 @@ mod tests {
         assert!(calls.iter().any(|call| matches!(call, Call::FileReadChunk { request_id, file_id, offset_bytes, max_bytes } if *request_id == 1 && file_id == "picked-1" && *offset_bytes == 10 && *max_bytes == 8)));
 
         let bytes = b"1234".to_vec();
-        super::__fui_on_file_read_result(
-            1,
-            FILE_STATUS_SUCCESS,
-            10,
-            100,
-            bytes.as_ptr(),
-            bytes.len() as u32,
-        );
+        unsafe {
+            super::__fui_on_file_read_result(
+                1,
+                FILE_STATUS_SUCCESS,
+                10,
+                100,
+                bytes.as_ptr(),
+                bytes.len() as u32,
+            );
+        }
         let chunk = chunk.borrow().clone().expect("chunk");
         assert_eq!(chunk.offset_bytes, 10);
         assert_eq!(chunk.file_size_bytes, 100);
@@ -1585,12 +1606,14 @@ mod tests {
             "writer-1",
             Some("report.txt"),
         );
-        super::__fui_on_file_writer_created(
-            1,
-            FILE_STATUS_SUCCESS,
-            payload.as_ptr(),
-            payload.len() as u32,
-        );
+        unsafe {
+            super::__fui_on_file_writer_created(
+                1,
+                FILE_STATUS_SUCCESS,
+                payload.as_ptr(),
+                payload.len() as u32,
+            );
+        }
         let writer = writer.borrow().clone().expect("writer");
         assert_eq!(writer.file_name, "report.txt");
         assert_eq!(writer.mode, FileSaveMode::NativePicker);
@@ -1604,13 +1627,15 @@ mod tests {
         let calls = ffi::test::take_calls();
         assert!(calls.iter().any(|call| matches!(call, Call::FileWriterFinish { request_id, writer_id } if *request_id == 2 && writer_id == "writer-1")));
         let payload = writer_payload(FileSaveMode::NativePicker as u32, "report.txt", None);
-        super::__fui_on_file_finish_result(
-            2,
-            FILE_STATUS_SUCCESS,
-            44,
-            payload.as_ptr(),
-            payload.len() as u32,
-        );
+        unsafe {
+            super::__fui_on_file_finish_result(
+                2,
+                FILE_STATUS_SUCCESS,
+                44,
+                payload.as_ptr(),
+                payload.len() as u32,
+            );
+        }
         let finished = finished.borrow().clone().expect("finish");
         assert_eq!(finished.file_name, "report.txt");
         assert_eq!(finished.written_bytes, 44);
@@ -1657,18 +1682,22 @@ mod tests {
         let calls = ffi::test::take_calls();
         assert!(calls.iter().any(|call| matches!(call, Call::FileProcessWorkerStart { request_id, worker_wasm_path, worker_entry_name, file_id, suggested_name, chunk_bytes, save_to_picked_file } if *request_id == 1 && worker_wasm_path == "./workers/file_worker.wasm" && worker_entry_name == "entry" && file_id == "picked-1" && suggested_name == "copy.bin" && *chunk_bytes == 64 * 1024 && *save_to_picked_file)));
 
-        super::__fui_on_file_worker_process_progress(1, 20, 100, b"copy.bin".as_ptr(), 8);
+        unsafe {
+            super::__fui_on_file_worker_process_progress(1, 20, 100, b"copy.bin".as_ptr(), 8);
+        }
         let progress = progress.borrow().clone().expect("progress");
         assert_eq!(progress.processed_bytes, 20);
         assert_eq!(progress.output_file_name, Some("copy.bin".to_string()));
 
         let payload = b"copy.bin\0sha256".to_vec();
-        super::__fui_on_file_worker_process_complete(
-            1,
-            100,
-            payload.as_ptr(),
-            payload.len() as u32,
-        );
+        unsafe {
+            super::__fui_on_file_worker_process_complete(
+                1,
+                100,
+                payload.as_ptr(),
+                payload.len() as u32,
+            );
+        }
         let result = result.borrow().clone().expect("result");
         assert_eq!(result.processed_bytes, 100);
         assert_eq!(result.output_file_name, Some("copy.bin".to_string()));

package/src/host_events.rs

@@ -0,0 +1,41 @@
+#[must_use = "the host-event handler is removed when the subscription is dropped"]
+pub struct HostEventSubscription {
+    unsubscribe: Option<Box<dyn FnOnce()>>,
+}
+
+impl HostEventSubscription {
+    #[doc(hidden)]
+    pub fn new(unsubscribe: impl FnOnce() + 'static) -> Self {
+        Self {
+            unsubscribe: Some(Box::new(unsubscribe)),
+        }
+    }
+}
+
+impl Drop for HostEventSubscription {
+    fn drop(&mut self) {
+        if let Some(unsubscribe) = self.unsubscribe.take() {
+            unsubscribe();
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::cell::Cell;
+    use std::rc::Rc;
+
+    #[test]
+    fn dropping_host_event_subscription_runs_unsubscribe_once() {
+        let unsubscribe_count = Rc::new(Cell::new(0));
+        let captured_count = unsubscribe_count.clone();
+        let subscription = HostEventSubscription::new(move || {
+            captured_count.set(captured_count.get() + 1);
+        });
+
+        drop(subscription);
+
+        assert_eq!(unsubscribe_count.get(), 1);
+    }
+}

package/src/lib.rs

@@ -4,6 +4,7 @@ pub mod assets;
 #[doc(hidden)]
 pub mod bindings;
 pub mod bitmap;
+pub mod color;
 #[doc(hidden)]
 pub mod bridge_callbacks;
 pub(crate) mod context_menu_manager;
@@ -24,6 +25,7 @@ pub mod frame_scheduler;
 pub mod frame_signal;
 #[doc(hidden)]
 pub mod generated;
+pub mod host_events;
 pub mod host_services;
 pub mod image_sampling;
 pub(crate) mod keyboard_scroll;
@@ -77,6 +79,46 @@ macro_rules! fui_app {
     };
 }
 
+#[cfg(feature = "worker-runtime")]
+#[macro_export]
+macro_rules! fui_worker {
+    ($($entry:ident => $job:ty),+ $(,)?) => {
+        $(
+            #[doc = "Worker entrypoint generated by `fui_worker!`.\n\n# Safety\n`input_ptr` must reference `input_len` readable bytes when `input_len` is non-zero."]
+            #[no_mangle]
+            pub unsafe extern "C" fn $entry(input_ptr: usize, input_len: u32) {
+                ::std::thread_local! {
+                    static ACTIVE_JOB: ::std::cell::RefCell<Option<$job>> =
+                        const { ::std::cell::RefCell::new(None) };
+                }
+                let input = unsafe {
+                    $crate::WorkerRuntime::entry_input(input_ptr, input_len)
+                };
+                ACTIVE_JOB.with(|slot| {
+                    let mut active = slot.borrow_mut();
+                    if active.is_none() {
+                        $crate::worker_runtime::reset_worker_runtime();
+                    }
+                    let mut job = active.take().unwrap_or_default();
+                    if $crate::WorkerJob::resume(&mut job, input) {
+                        *active = Some(job);
+                    }
+                });
+            }
+        )+
+
+        #[no_mangle]
+        pub extern "C" fn __fui_worker_text_buffer() -> usize {
+            $crate::worker_runtime::worker_text_buffer_ptr()
+        }
+
+        #[no_mangle]
+        pub extern "C" fn __fui_worker_text_buffer_size() -> u32 {
+            $crate::worker_runtime::worker_text_buffer_size()
+        }
+    };
+}
+
 #[macro_export]
 macro_rules! fui_managed_app {
     ($page_ty:ty, $build_page:expr, $get_root:expr) => {
@@ -367,6 +409,7 @@ pub mod prelude {
     pub use crate::app::{Application, ApplicationRegistration, ManagedApplication};
     pub use crate::bitmap::{Bitmap, BitmapTextReadyEventArgs};
     pub use crate::bridge_callbacks::current_route;
+    pub use crate::color::{hsl_to_color, mix_color, rgb, rgba, with_alpha};
     pub use crate::controls::{
         anti_selection_area, button, checkbox, clear_control_templates, combo_box, context_menu,
         create_default_button_presenter, create_default_checkbox_indicator_presenter,
@@ -435,6 +478,9 @@ pub mod prelude {
     pub use crate::focus_visibility::show_keyboard_focus_for_key_event;
     pub use crate::frame_scheduler::{mark_needs_commit, on_loaded, LoadedEventArgs};
     pub use crate::fui_component;
+    #[cfg(feature = "worker-runtime")]
+    pub use crate::fui_worker;
+    pub use crate::host_events::HostEventSubscription;
     pub use crate::image_sampling::{ImageSampling, ImageSamplingMode};
     pub use crate::logger;
     pub use crate::navigation;
@@ -442,9 +488,10 @@ pub mod prelude {
         auto, column, custom_drawable, fill, flex_box, grid, image, pct, portal, px, row,
         scroll_box, scroll_view, svg, text, viewport_height, viewport_width, virtual_list, Border,
         Child, ContextMenuEventArgs, Corners, CustomDrawable, DrawableInvalidator, EdgeInsets,
-        FlexBox, FlexBoxSurface, GradientStop, Grid, GridTrack, HasFlexBoxRoot, Image, ImageNode, Length, Node,
-        PresenterHostStyle, ScrollBar, ScrollBarVisibility, ScrollBox, ScrollState, ScrollView,
-        Shadow, Svg, SvgNode, Text, TextCore, TextNode, ThemeBindable, VirtualList,
+        FlexBox, FlexBoxSurface, GradientStop, Grid, GridTrack, HasFlexBoxRoot, Image, ImageNode,
+        Length, Node, PresenterHostStyle, ScrollBar, ScrollBarStyle, ScrollBarVisibility,
+        ScrollBox, ScrollState, ScrollView, Shadow, Svg, SvgNode, Text, TextCore, TextNode,
+        ThemeBindable, VirtualList,
     };
     pub use crate::persisted;
     pub use crate::platform;
@@ -489,6 +536,7 @@ pub use app::{Application, ApplicationRegistration, ManagedApplication};
 pub use assets::*;
 pub use bitmap::{Bitmap, BitmapTextReadyEventArgs};
 pub use bridge_callbacks::current_route;
+pub use color::{hsl_to_color, mix_color, rgb, rgba, with_alpha};
 pub use controls::{
     anti_selection_area, button, checkbox, clear_control_templates, combo_box, context_menu,
     create_default_button_presenter, create_default_checkbox_indicator_presenter,
@@ -553,6 +601,7 @@ pub use file::{
 pub use focus_visibility::show_keyboard_focus_for_key_event;
 pub use frame_scheduler::{mark_needs_commit, on_loaded, LoadedEventArgs};
 pub use frame_signal::{frame_time_signal, FrameTimeSignalHandle};
+pub use host_events::HostEventSubscription;
 pub use image_sampling::{ImageSampling, ImageSamplingMode};
 pub use logger::*;
 pub use navigation::*;
@@ -561,8 +610,8 @@ pub use node::{
     scroll_view, svg, text, viewport_height, viewport_width, virtual_list, Border, Child,
     ContextMenuEventArgs, Corners, CustomDrawable, DrawableInvalidator, EdgeInsets, FlexBox,
     FlexBoxSurface, GradientStop, Grid, GridTrack, HasFlexBoxRoot, Image, ImageNode, Length, Node,
-    PresenterHostStyle, ScrollBar, ScrollBarVisibility, ScrollBox, ScrollState, ScrollView, Shadow,
-    Svg, SvgNode, Text, TextCore, TextNode, ThemeBindable, VirtualList,
+    PresenterHostStyle, ScrollBar, ScrollBarStyle, ScrollBarVisibility, ScrollBox, ScrollState,
+    ScrollView, Shadow, Svg, SvgNode, Text, TextCore, TextNode, ThemeBindable, VirtualList,
 };
 pub use persisted::*;
 pub use platform::*;
@@ -592,8 +641,5 @@ pub use worker::{Worker, WorkerCompletedEventArgs, WorkerErrorEventArgs, WorkerP
 pub use worker_job::{WorkerJob, WorkerJobState};
 #[cfg(feature = "worker-runtime")]
 pub use worker_runtime::{
-    file_read_chunk, file_worker_write_chunk, handle_fetch_complete as __fui_on_fetch_complete,
-    handle_fetch_error as __fui_on_fetch_error, reset_worker_runtime,
-    worker_text_buffer_ptr as __fui_worker_text_buffer,
-    worker_text_buffer_size as __fui_worker_text_buffer_size, WorkerRuntime,
+    file_read_chunk, file_worker_write_chunk, reset_worker_runtime, WorkerRuntime,
 };

package/src/node/core.rs

@@ -262,7 +262,7 @@ pub(crate) struct LinearGradient {
     pub(crate) offsets: Vec<f32>,
     pub(crate) colors: Vec<u32>,
 }
-#[derive(Clone)]
+#[derive(Clone, Default)]
 pub(crate) struct FlexBoxProps {
     pub(crate) width: Option<(f32, Unit)>,
     pub(crate) height: Option<(f32, Unit)>,
@@ -278,25 +278,6 @@ pub(crate) struct FlexBoxProps {
     pub(crate) transitions: Option<NodeTransitions>,
 }
 
-impl Default for FlexBoxProps {
-    fn default() -> Self {
-        Self {
-            width: None,
-            height: None,
-            bg_color: None,
-            padding: None,
-            flex_direction: None,
-            box_style: None,
-            opacity: None,
-            blur_sigma: None,
-            drop_shadow: None,
-            background_blur_sigma: None,
-            linear_gradient: None,
-            transitions: None,
-        }
-    }
-}
-
 #[derive(Clone, Default)]
 pub(crate) struct TextProps {
     pub(crate) content: String,
@@ -532,6 +513,26 @@ impl NodeRef {
         self.inner.borrow().handle
     }
 
+    pub(crate) fn set_semantic_checked(
+        &self,
+        state: SemanticCheckedState,
+        announce: bool,
+    ) {
+        let handle = {
+            let mut core = self.inner.borrow_mut();
+            core.behavior.semantic_checked = Some(state);
+            core.handle
+        };
+        if handle == NodeHandle::INVALID {
+            return;
+        }
+        ui::set_semantic_checked(handle.raw(), state as u32);
+        if announce {
+            ui::request_semantic_announcement(handle.raw());
+        }
+        crate::frame_scheduler::mark_needs_commit();
+    }
+
     pub(crate) fn ptr_eq(&self, other: &Self) -> bool {
         Rc::ptr_eq(&self.inner, &other.inner)
     }
@@ -2219,7 +2220,7 @@ pub trait Node: Clone {
     }
 }
 
-impl<T: Node + ?Sized> Node for &T {
+impl<T: Node> Node for &T {
     fn retained_node_ref(&self) -> NodeRef {
         (*self).retained_node_ref()
     }

package/src/node/helpers.rs

@@ -31,7 +31,7 @@ pub fn scroll_box() -> ScrollBox {
     ScrollBox::new()
 }
 
-pub fn virtual_list(total_items: i32, item_height: f32) -> VirtualList {
+pub fn virtual_list(total_items: i32, item_height: f32) -> VirtualList<FlexBox> {
     VirtualList::new(total_items, item_height)
 }
 

package/src/node/mod.rs

@@ -48,7 +48,7 @@ pub use helpers::{
 pub use image::ImageNode;
 pub(crate) use presenter_host_style::HostStyleLayers;
 pub use presenter_host_style::{Corners, EdgeInsets, PresenterHostStyle, Shadow};
-pub use scroll_bar::{ScrollBar, ScrollBarVisibility};
+pub use scroll_bar::{ScrollBar, ScrollBarStyle, ScrollBarVisibility};
 pub use scroll_box::ScrollBox;
 pub use scroll_state::ScrollState;
 pub use scroll_view::ScrollView;

package/src/node/scroll_bar.rs

@@ -12,6 +12,91 @@ const DEFAULT_TRACK_THICKNESS: f32 = 8.0;
 const DEFAULT_THUMB_THICKNESS: f32 = 8.0;
 const DEFAULT_MIN_THUMB_SIZE: f32 = 18.0;
 
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct ScrollBarStyle {
+    track_width: f32,
+    thumb_width: f32,
+    thumb_min_height: f32,
+    track_corner_radius: f32,
+    thumb_corner_radius: f32,
+    track_color: Option<u32>,
+    thumb_color: Option<u32>,
+}
+
+impl ScrollBarStyle {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub fn track_width(mut self, value: f32) -> Self {
+        self.track_width = value;
+        self
+    }
+
+    pub fn thumb_width(mut self, value: f32) -> Self {
+        self.thumb_width = value;
+        self
+    }
+
+    pub fn thumb_min_height(mut self, value: f32) -> Self {
+        self.thumb_min_height = value;
+        self
+    }
+
+    pub fn track_corner_radius(mut self, value: f32) -> Self {
+        self.track_corner_radius = value;
+        self
+    }
+
+    pub fn thumb_corner_radius(mut self, value: f32) -> Self {
+        self.thumb_corner_radius = value;
+        self
+    }
+
+    pub fn track_color(mut self, value: u32) -> Self {
+        self.track_color = Some(value);
+        self
+    }
+
+    pub fn thumb_color(mut self, value: u32) -> Self {
+        self.thumb_color = Some(value);
+        self
+    }
+
+    pub(crate) fn apply_to(self, scroll_bar: &ScrollBar) {
+        scroll_bar
+            .track_width(self.track_width)
+            .thumb_width(self.thumb_width)
+            .thumb_min_height(self.thumb_min_height)
+            .track_corner_radius(self.track_corner_radius)
+            .thumb_corner_radius(self.thumb_corner_radius);
+        if let Some(color) = self.track_color {
+            scroll_bar.track_color(color);
+        } else {
+            scroll_bar.clear_track_color();
+        }
+        if let Some(color) = self.thumb_color {
+            scroll_bar.thumb_color(color);
+        } else {
+            scroll_bar.clear_thumb_color();
+        }
+    }
+}
+
+impl Default for ScrollBarStyle {
+    fn default() -> Self {
+        Self {
+            track_width: DEFAULT_TRACK_THICKNESS,
+            thumb_width: DEFAULT_THUMB_THICKNESS,
+            thumb_min_height: DEFAULT_MIN_THUMB_SIZE,
+            track_corner_radius: 0.0,
+            thumb_corner_radius: 0.0,
+            track_color: None,
+            thumb_color: None,
+        }
+    }
+}
+
 fn clamp(value: f32, min: f32, max: f32) -> f32 {
     if value < min {
         return min;
@@ -237,6 +322,14 @@ impl ScrollBar {
         self
     }
 
+    fn clear_track_color(&self) {
+        self.inner.track_color_overridden.set(false);
+        self.inner
+            .track_color
+            .set(current_theme().colors.scrollbar_track);
+        self.apply_color_style();
+    }
+
     pub fn thumb_color(&self, color: u32) -> &Self {
         self.inner.thumb_color_overridden.set(true);
         self.inner.thumb_color.set(color);
@@ -244,6 +337,14 @@ impl ScrollBar {
         self
     }
 
+    fn clear_thumb_color(&self) {
+        self.inner.thumb_color_overridden.set(false);
+        self.inner
+            .thumb_color
+            .set(current_theme().colors.scrollbar_thumb);
+        self.apply_color_style();
+    }
+
     pub fn bind_scroll_handle(&self, handle: u64) {
         self.inner.target_handle.set(handle);
         self.inner

package/src/node/scroll_box.rs

@@ -219,6 +219,13 @@ impl ScrollBox {
         self
     }
 
+    pub fn scrollbar_style(&self, style: ScrollBarStyle) -> &Self {
+        style.apply_to(&self.inner.vertical_scrollbar);
+        style.apply_to(&self.inner.horizontal_scrollbar);
+        self.refresh_chrome();
+        self
+    }
+
     fn attach_listeners(&self) {
         let weak = Rc::downgrade(&self.inner);
         self.inner