// Copyright © SixtyFPS GmbH // SPDX-License-Identifier: GPL-3.0-only OR LicenseRef-Slint-Royalty-free-2.0 OR LicenseRef-Slint-Software-3.0 // cSpell: ignore binfmt dlsym GETNONCLIENTMETRICS NONCLIENTMETRICSW RTLD testui #![doc = include_str!("README.md")] #![doc(html_logo_url = "https://slint.dev/logo/slint-logo-square-light.svg")] #![warn(missing_docs)] #![cfg_attr(slint_nightly_test, feature(non_exhaustive_omitted_patterns_lint))] #![cfg_attr(slint_nightly_test, warn(non_exhaustive_omitted_patterns))] extern crate alloc; use event_loop::{CustomEvent, EventLoopState}; use i_slint_core::api::EventLoopError; use i_slint_core::graphics::RequestedGraphicsAPI; use i_slint_core::lengths::LogicalPoint; use i_slint_core::platform::{EventLoopProxy, PlatformError}; use i_slint_core::window::WindowAdapter; use renderer::WinitCompatibleRenderer; use std::cell::Cell; use std::cell::OnceCell; use std::cell::RefCell; use std::collections::HashMap; use std::rc::Rc; use std::rc::Weak; use std::sync::Arc; use std::sync::atomic::AtomicUsize; use winit::event_loop::ActiveEventLoop; #[cfg(not(target_arch = "wasm32"))] mod clipboard; mod drag_resize_window; mod winit_compat; mod winitwindowadapter; use winitwindowadapter::*; pub(crate) mod event_loop; mod frame_throttle; #[cfg(target_os = "ios")] mod ios; #[cfg(target_os = "macos")] mod macos; mod touch_finger_id; /// Re-export of the winit crate. pub use winit; /// Internal type used by the winit backend for thread communication and window system updates. /// /// See also [`EventLoopBuilder`] #[non_exhaustive] #[derive(Debug)] pub struct SlintEvent(CustomEvent); #[i_slint_core_macros::slint_doc] /// Convenience alias for the event loop builder used by Slint. /// /// It can be used to configure the event loop with /// [`slint::BackendSelector::with_winit_event_loop_builder()`](slint:rust:slint/struct.BackendSelector.html#method.with_winit_event_loop_builder) pub type EventLoopBuilder = winit::event_loop::EventLoopBuilder; /// Returned by callbacks passed to [`Window::on_winit_window_event`](WinitWindowAccessor::on_winit_window_event) /// to determine if winit events should propagate to the Slint event loop. #[derive(Clone, Copy, Debug, Eq, PartialEq)] pub enum EventResult { /// The winit event should propagate normally. Propagate, /// The winit event shouldn't be processed further. PreventDefault, } mod renderer { use std::rc::Weak; use std::sync::Arc; use i_slint_core::platform::PlatformError; use i_slint_core::renderer::DrawOutcome; use winit::event_loop::ActiveEventLoop; pub trait WinitCompatibleRenderer: std::any::Any { fn render(&self, window: &i_slint_core::api::Window) -> Result; fn as_core_renderer(&self) -> &dyn i_slint_core::renderer::Renderer; // Got WindowEvent::Occluded fn occluded(&self, _: bool) {} fn suspend(&self) -> Result<(), PlatformError>; // The window's transparency changed after the window was created. Renderers that pick // their surface's alpha mode up front have to reconfigure it to match. #[cfg(target_os = "macos")] fn set_transparent(&self, _transparent: bool) -> Result<(), PlatformError> { Ok(()) } // Got winit::Event::Resumed fn resume( &self, active_event_loop: &ActiveEventLoop, window_attributes: winit::window::WindowAttributes, window_adapter_weak: Weak, ) -> Result, PlatformError>; } #[cfg(enable_femtovg_renderer)] pub(crate) mod femtovg; #[cfg(enable_skia_renderer)] pub(crate) mod skia; #[cfg(feature = "renderer-software")] pub(crate) mod sw; #[cfg(feature = "renderer-vello")] pub(crate) mod vello; } #[cfg(enable_accesskit)] mod accesskit; #[cfg(muda)] mod muda; #[cfg(xdg_desktop_settings)] mod xdg_desktop_settings; #[cfg(target_arch = "wasm32")] pub(crate) mod wasm_input_helper; cfg_if::cfg_if! { if #[cfg(enable_femtovg_renderer)] { const DEFAULT_RENDERER_NAME: &str = "FemtoVG"; } else if #[cfg(enable_skia_renderer)] { const DEFAULT_RENDERER_NAME: &str = "Skia"; } else if #[cfg(feature = "renderer-software")] { const DEFAULT_RENDERER_NAME: &str = "Software"; } else if #[cfg(feature = "renderer-vello")] { const DEFAULT_RENDERER_NAME: &str = "Vello"; } else { compile_error!("Please select a feature to build with the winit backend: `renderer-femtovg`, `renderer-skia`, `renderer-skia-opengl`, `renderer-skia-vulkan`, `renderer-software` or `renderer-vello`"); } } fn default_renderer_factory( shared_backend_data: &Rc, ) -> Result, PlatformError> { cfg_if::cfg_if! { if #[cfg(enable_skia_renderer)] { renderer::skia::WinitSkiaRenderer::new_suspended(shared_backend_data) } else if #[cfg(feature = "renderer-femtovg-wgpu")] { renderer::femtovg::WGPUFemtoVGRenderer::new_suspended(shared_backend_data) } else if #[cfg(all(feature = "renderer-femtovg", supports_opengl))] { renderer::femtovg::GlutinFemtoVGRenderer::new_suspended(shared_backend_data) } else if #[cfg(feature = "renderer-software")] { renderer::sw::WinitSoftwareRenderer::new_suspended(shared_backend_data) } else if #[cfg(feature = "renderer-vello")] { // Last in the chain: vello is opt-in and only becomes the default // when it is the only renderer built in. renderer::vello::WinitVelloRenderer::new_suspended(shared_backend_data) } else { compile_error!("Please select a feature to build with the winit backend: `renderer-femtovg`, `renderer-skia`, `renderer-skia-opengl`, `renderer-skia-vulkan`, `renderer-software` or `renderer-vello`"); } } } fn try_create_window_with_fallback_renderer( shared_backend_data: &Rc, attrs: winit::window::WindowAttributes, _proxy: &winit::event_loop::EventLoopProxy, #[cfg(all(muda, target_os = "macos"))] muda_enable_default_menu_bar: bool, ) -> Option> { [ #[cfg(any( feature = "renderer-skia", feature = "renderer-skia-opengl", feature = "renderer-skia-vulkan" ))] renderer::skia::WinitSkiaRenderer::new_suspended, #[cfg(feature = "renderer-femtovg-wgpu")] renderer::femtovg::WGPUFemtoVGRenderer::new_suspended, #[cfg(all( feature = "renderer-femtovg", supports_opengl, not(feature = "renderer-femtovg-wgpu") ))] renderer::femtovg::GlutinFemtoVGRenderer::new_suspended, #[cfg(feature = "renderer-software")] renderer::sw::WinitSoftwareRenderer::new_suspended, #[cfg(feature = "renderer-vello")] renderer::vello::WinitVelloRenderer::new_suspended, ] .into_iter() .find_map(|renderer_factory| { Some(WinitWindowAdapter::new( shared_backend_data.clone(), renderer_factory(shared_backend_data).ok()?, attrs.clone(), #[cfg(any(enable_accesskit, muda))] _proxy.clone(), #[cfg(all(muda, target_os = "macos"))] muda_enable_default_menu_bar, )) }) } #[doc(hidden)] pub type NativeWidgets = (); #[doc(hidden)] pub type NativeGlobals = (); #[doc(hidden)] pub const HAS_NATIVE_STYLE: bool = false; #[doc(hidden)] pub mod native_widgets {} /// Use this trait to intercept events from winit. /// /// It imitates [`winit::application::ApplicationHandler`] with two changes: /// - All functions are invoked before Slint sees them. Use the [`EventResult`] return value to /// optionally prevent Slint from seeing the event. /// - The [`Self::window_event()`] function has additional parameters to provide access to the Slint Window and /// Winit window, if applicable. #[allow(unused_variables)] pub trait CustomApplicationHandler { /// Re-implement to intercept the [`ApplicationHandler::resumed()`](winit::application::ApplicationHandler::resumed()) event. fn resumed(&mut self, _event_loop: &ActiveEventLoop) -> EventResult { EventResult::Propagate } /// Re-implement to intercept the [`ApplicationHandler::window_event()`](winit::application::ApplicationHandler::window_event()) event. fn window_event( &mut self, event_loop: &ActiveEventLoop, window_id: winit::window::WindowId, winit_window: Option<&winit::window::Window>, slint_window: Option<&i_slint_core::api::Window>, event: &winit::event::WindowEvent, ) -> EventResult { EventResult::Propagate } /// Re-implement to intercept the [`ApplicationHandler::new_events()`](winit::application::ApplicationHandler::new_events()) event. fn new_events( &mut self, event_loop: &ActiveEventLoop, cause: winit::event::StartCause, ) -> EventResult { EventResult::Propagate } /// Re-implement to intercept the [`ApplicationHandler::device_event()`](winit::application::ApplicationHandler::device_event()) event. fn device_event( &mut self, event_loop: &ActiveEventLoop, device_id: winit::event::DeviceId, event: winit::event::DeviceEvent, ) -> EventResult { EventResult::Propagate } /// Re-implement to intercept the [`ApplicationHandler::about_to_wait()`](winit::application::ApplicationHandler::about_to_wait()) event. fn about_to_wait(&mut self, event_loop: &ActiveEventLoop) -> EventResult { EventResult::Propagate } /// Re-implement to intercept the [`ApplicationHandler::suspended()`](winit::application::ApplicationHandler::suspended()) event. fn suspended(&mut self, event_loop: &ActiveEventLoop) -> EventResult { EventResult::Propagate } /// Re-implement to intercept the [`ApplicationHandler::exiting()`](winit::application::ApplicationHandler::exiting()) event. fn exiting(&mut self, event_loop: &ActiveEventLoop) -> EventResult { EventResult::Propagate } /// Re-implement to intercept the [`ApplicationHandler::memory_warning()`](winit::application::ApplicationHandler::memory_warning()) event. fn memory_warning(&mut self, event_loop: &ActiveEventLoop) -> EventResult { EventResult::Propagate } } /// Use the BackendBuilder to configure the properties of the Winit Backend before creating it. /// Create the builder using [`Backend::builder()`], then configure it for example with [`Self::with_renderer_name`], /// and build the backend using [`Self::build`]. pub struct BackendBuilder { /// Allow fallback if the desired renderer is not found allow_fallback: bool, requested_graphics_api: Option, window_attributes_hook: Option winit::window::WindowAttributes>>, renderer_name: Option, event_loop_builder: Option, #[cfg(all(muda, target_os = "macos"))] muda_enable_default_menu_bar_bar: bool, #[cfg(target_family = "wasm")] spawn_event_loop: bool, custom_application_handler: Option>, } impl BackendBuilder { /// Configures this builder to require a renderer that supports the specified graphics API. #[must_use] pub fn request_graphics_api(mut self, graphics_api: RequestedGraphicsAPI) -> Self { self.requested_graphics_api = Some(graphics_api); self } /// Configures this builder to use the specified renderer name when building the backend later. /// Pass `renderer-software` for example to configure the backend to use the Slint software renderer. #[must_use] pub fn with_renderer_name(mut self, name: impl Into) -> Self { self.renderer_name = Some(name.into()); self } /// Configures this builder to use the specified hook that will be called before a Window is created. /// /// It can be used to adjust settings of window that will be created. /// /// # Example /// /// ```rust,no_run /// let mut backend = i_slint_backend_winit::Backend::builder() /// .with_window_attributes_hook(|attributes| attributes.with_content_protected(true)) /// .build() /// .unwrap(); /// slint::platform::set_platform(Box::new(backend)); /// ``` #[must_use] pub fn with_window_attributes_hook( mut self, hook: impl Fn(winit::window::WindowAttributes) -> winit::window::WindowAttributes + 'static, ) -> Self { self.window_attributes_hook = Some(Box::new(hook)); self } /// Configures this builder to use the specified event loop builder when creating the event /// loop during a subsequent call to [`Self::build`]. #[must_use] pub fn with_event_loop_builder(mut self, event_loop_builder: EventLoopBuilder) -> Self { self.event_loop_builder = Some(event_loop_builder); self } /// Configures this builder to enable or disable the default menu bar. /// By default, the menu bar is provided by Slint. Set this to false /// if you're providing your own menu bar. /// Note that an application provided menu bar will be overridden by a `MenuBar` /// declared in Slint code. #[must_use] #[cfg(all(muda, target_os = "macos"))] pub fn with_default_menu_bar(mut self, enable: bool) -> Self { self.muda_enable_default_menu_bar_bar = enable; self } #[cfg(target_family = "wasm")] /// Configures this builder to spawn the event loop using [`winit::platform::web::EventLoopExtWebSys::spawn()`] /// run `run_event_loop()` is called. pub fn with_spawn_event_loop(mut self, enable: bool) -> Self { self.spawn_event_loop = enable; self } /// Configures this builder to use the specified [`CustomApplicationHandler`]. /// /// This allow application developer to intercept events from winit. /// Similar to [`winit::application::ApplicationHandler`]. #[must_use] pub fn with_custom_application_handler( mut self, handler: Box, ) -> Self { self.custom_application_handler = Some(handler); self } /// Builds the backend with the parameters configured previously. Set the resulting backend /// with `slint::platform::set_platform()`: /// /// # Example /// /// ```rust,no_run /// let mut backend = i_slint_backend_winit::Backend::builder() /// .with_renderer_name("renderer-software") /// .build() /// .unwrap(); /// slint::platform::set_platform(Box::new(backend)); /// ``` pub fn build(self) -> Result { #[allow(unused_mut)] let mut event_loop_builder = self.event_loop_builder.unwrap_or_else(winit::event_loop::EventLoop::with_user_event); // Never use winit's menu bar. Either we provide one ourselves with muda, or // the user provides one. #[cfg(all(feature = "muda", target_os = "macos"))] winit::platform::macos::EventLoopBuilderExtMacOS::with_default_menu( &mut event_loop_builder, false, ); // Initialize the winit event loop and propagate errors if for example `DISPLAY` or `WAYLAND_DISPLAY` isn't set. let shared_data = Rc::new(SharedBackendData::new( event_loop_builder, self.renderer_name, self.requested_graphics_api.clone(), self.allow_fallback, )?); Ok(Backend { event_loop_state: Default::default(), window_attributes_hook: self.window_attributes_hook, shared_data, #[cfg(all(muda, target_os = "macos"))] muda_enable_default_menu_bar_bar: self.muda_enable_default_menu_bar_bar, #[cfg(target_family = "wasm")] spawn_event_loop: self.spawn_event_loop, custom_application_handler: self.custom_application_handler.into(), #[cfg(xdg_desktop_settings)] xdg_watcher: RefCell::new(None), }) } } fn dispatch_mouse_move(window: &Weak, position: LogicalPoint) { if let Some(window) = window.upgrade() { window.window().dispatch_event(i_slint_core::platform::WindowEvent::internal( i_slint_core::input::BackendMouseEvent::Moved { position, touch_finger_id: 0 }, )); } } pub(crate) struct SharedBackendData { context: OnceCell, /// Allow fallback if the desired renderer is not found allow_fallback: bool, renderer_name: Option, requested_graphics_api: Option, #[cfg(enable_skia_renderer)] skia_context: i_slint_renderer_skia::SkiaSharedContext, active_windows: Rc>>>, /// List of visible windows that have been created when without the event loop and /// need to be mapped to a winit Window as soon as the event loop becomes active. inactive_windows: RefCell>>, /// Buffered mouse move event pending dispatch. Consecutive `CursorMoved` events are coalesced, /// as winit sends them so frequently that it can cause performance issues (see #9038 and #10912). /// At most one window buffers a move at a time. pending_mouse_move: Cell, LogicalPoint)>>, /// Hidden windows, checked by [`SharedBackendData::warn_about_windows_kept_alive`]. hidden_winit_windows: RefCell>>, #[cfg(not(target_arch = "wasm32"))] clipboard: std::cell::RefCell, not_running_event_loop: RefCell>>, event_loop_proxy: winit::event_loop::EventLoopProxy, /// The generation is used to determine if a quit_event_loop call is meant for the current /// event loop or is from a stale event. event_loop_generation: Arc, is_wayland: bool, /// Desktop settings read from the XDG portal (cursor blink, appearance query). #[cfg(xdg_desktop_settings)] desktop_settings: xdg_desktop_settings::DesktopSettings, #[cfg(target_os = "ios")] #[allow(unused)] keyboard_notifications: ios::KeyboardNotifications, #[cfg(target_os = "ios")] #[allow(unused)] scene_lifecycle: ios::SceneLifecycle, } impl SharedBackendData { /// Panics if the backend is not bound: an event loop only runs inside a live context. pub(crate) fn context(&self) -> i_slint_core::SlintContext { self.context .get() .and_then(|ctx| ctx.upgrade()) .expect("the winit event loop runs inside the context that owns this backend") } fn new( mut builder: EventLoopBuilder, renderer_name: Option, requested_graphics_api: Option, allow_fallback: bool, ) -> Result { #[cfg(not(target_arch = "wasm32"))] use raw_window_handle::HasDisplayHandle; #[cfg(all(unix, not(target_vendor = "apple")))] { #[cfg(feature = "wayland")] { use winit::platform::wayland::EventLoopBuilderExtWayland; builder.with_any_thread(true); } #[cfg(feature = "x11")] { use winit::platform::x11::EventLoopBuilderExtX11; builder.with_any_thread(true); // Under WSL, the compositor sometimes crashes. Since we cannot reconnect after the compositor // was restarted, the application panics. This does not happen when using XWayland. Therefore, // when running under WSL, try to connect to X11 instead. #[cfg(feature = "wayland")] if std::fs::metadata("/proc/sys/fs/binfmt_misc/WSLInterop").is_ok() || std::fs::metadata("/run/WSL").is_ok() { builder.with_x11(); } } } #[cfg(target_family = "windows")] { use winit::platform::windows::EventLoopBuilderExtWindows; builder.with_any_thread(true); } let event_loop = builder.build().map_err(|e| format!("Error initializing winit event loop: {e}"))?; #[cfg(target_os = "macos")] Self::disable_macos_automatic_shortcut_localization(); cfg_if::cfg_if! { if #[cfg(all(unix, not(target_vendor = "apple"), feature = "wayland"))] { use winit::platform::wayland::EventLoopExtWayland; let is_wayland = event_loop.is_wayland(); } else { let is_wayland = false; } } let active_windows = Rc::>>>::default(); #[cfg(target_os = "ios")] let keyboard_notifications = ios::register_keyboard_notifications(Rc::downgrade(&active_windows)); #[cfg(target_os = "ios")] let scene_lifecycle = ios::install_scene_lifecycle(Rc::downgrade(&active_windows)); let event_loop_proxy = event_loop.create_proxy(); #[cfg(not(target_arch = "wasm32"))] let clipboard = crate::clipboard::create_clipboard( &event_loop .display_handle() .map_err(|display_err| PlatformError::OtherError(display_err.into()))?, ); Ok(Self { context: Default::default(), allow_fallback, renderer_name, requested_graphics_api, #[cfg(enable_skia_renderer)] skia_context: Default::default(), active_windows, inactive_windows: Default::default(), pending_mouse_move: Default::default(), hidden_winit_windows: Default::default(), #[cfg(not(target_arch = "wasm32"))] clipboard: RefCell::new(clipboard), not_running_event_loop: RefCell::new(Some(event_loop)), event_loop_proxy, event_loop_generation: Default::default(), is_wayland, #[cfg(xdg_desktop_settings)] desktop_settings: xdg_desktop_settings::DesktopSettings::new(), #[cfg(target_os = "ios")] keyboard_notifications, #[cfg(target_os = "ios")] scene_lifecycle, }) } // Disable automatic keyboard shortcut localization on macOS by injecting // applicationShouldAutomaticallyLocalizeKeyEquivalents: into winit's delegate class. // // This is necessary to make the keyboard shortcuts declared in Slint work as intended on macOS, instead of being automatically localized by the system. // // This is done at runtime because winit 0.30 doesn't allow replacing its delegate. // TODO: Replace with a proper delegate class when upgrading to the next winit version. #[cfg(target_os = "macos")] fn disable_macos_automatic_shortcut_localization() { use objc2::runtime::{AnyClass, AnyObject, Bool, Imp, Sel}; use objc2::sel; unsafe extern "C-unwind" fn should_not_localize( _this: *mut AnyObject, _cmd: Sel, _app: *mut AnyObject, ) -> Bool { Bool::NO } let sel = sel!(applicationShouldAutomaticallyLocalizeKeyEquivalents:); if let Some(cls) = AnyClass::get(c"WinitApplicationDelegate") && cls.instance_method(sel).is_none() { unsafe { objc2::ffi::class_addMethod( (cls as *const AnyClass).cast_mut(), sel, core::mem::transmute::< unsafe extern "C-unwind" fn(*mut AnyObject, Sel, *mut AnyObject) -> Bool, Imp, >(should_not_localize), c"B@:@".as_ptr(), ); } } } pub fn register_window(&self, id: winit::window::WindowId, window: Rc) { self.active_windows.borrow_mut().insert(id, Rc::downgrade(&window)); } pub fn register_inactive_window(&self, window: Rc) { let window = Rc::downgrade(&window); let mut inactive_windows = self.inactive_windows.borrow_mut(); if !inactive_windows.iter().any(|w| Weak::ptr_eq(w, &window)) { inactive_windows.push(window); } } pub fn unregister_window(&self, id: Option) { if let Some(id) = id { self.active_windows.borrow_mut().remove(&id); } else { // Use this opportunity of a Window being removed to tidy up. self.inactive_windows .borrow_mut() .retain(|inactive_weak_window| inactive_weak_window.strong_count() > 0) } } pub fn create_inactive_windows( &self, event_loop: &winit::event_loop::ActiveEventLoop, ) -> Result<(), PlatformError> { // Wait for the appearance query so windows aren't shown with default colors; // the next `about_to_wait` retries once it clears. #[cfg(xdg_desktop_settings)] if self.desktop_settings.is_appearance_pending() { return Ok(()); } let mut inactive_windows = self.inactive_windows.take(); let mut result = Ok(()); while let Some(window_weak) = inactive_windows.pop() { if let Some(err) = window_weak.upgrade().and_then(|w| w.ensure_window(event_loop).err()) { result = Err(err); break; } } self.inactive_windows.borrow_mut().extend(inactive_windows); result } pub fn window_by_id(&self, id: winit::window::WindowId) -> Option> { self.active_windows.borrow().get(&id).and_then(|weakref| weakref.upgrade()) } /// Buffer a mouse move event for the given window, coalescing it with the previously buffered /// one. A move buffered for another window is dispatched first, to keep the events in order. pub(crate) fn buffer_mouse_move( &self, window: &Weak, position: LogicalPoint, ) { if let Some((pending_window, pending_position)) = self.pending_mouse_move.replace(Some((window.clone(), position))) && !Weak::ptr_eq(&pending_window, window) { dispatch_mouse_move(&pending_window, pending_position); } } /// Dispatch the buffered mouse move event, if any. pub(crate) fn flush_pending_mouse_move(&self) { if let Some((window, position)) = self.pending_mouse_move.take() { dispatch_mouse_move(&window, position); } } pub(crate) fn watch_hidden_window(&self, window: &Arc) { self.hidden_winit_windows.borrow_mut().push(Arc::downgrade(window)); } /// Call this only once the event being dispatched let go of its own reference, or a window /// hidden while handling one of its events looks kept alive. pub(crate) fn warn_about_windows_kept_alive(&self) { if self.hidden_winit_windows.take().iter().any(|window| window.strong_count() > 0) { i_slint_core::debug_log!( "Slint winit backend: a window was hidden but references to it still exist, so it stays on screen. Drop the winit window if the application obtained one with WinitWindowAccessor::winit_window()" ); } } } #[i_slint_core_macros::slint_doc] /// This struct implements the Slint Platform trait. /// Use this in conjunction with [`slint::platform::set_platform`](slint:rust:slint/platform/fn.set_platform.html) to initialize. /// Slint to use winit for all windowing system interaction. /// /// ```rust,no_run /// use i_slint_backend_winit::Backend; /// slint::platform::set_platform(Box::new(Backend::new().unwrap())); /// ``` pub struct Backend { event_loop_state: RefCell>, shared_data: Rc, custom_application_handler: RefCell>>, /// Backend-wide XDG desktop portal watcher. Spawned in `bind_context` /// and aborted on backend drop. #[cfg(xdg_desktop_settings)] xdg_watcher: RefCell>>, /// This hook is called before a Window is created. /// /// It can be used to adjust settings of window that will be created /// /// See also [`BackendBuilder::with_window_attributes_hook`]. /// /// # Example /// /// ```rust,no_run /// let mut backend = i_slint_backend_winit::Backend::new().unwrap(); /// backend.window_attributes_hook = Some(Box::new(|attributes| attributes.with_content_protected(true))); /// slint::platform::set_platform(Box::new(backend)); /// ``` pub window_attributes_hook: Option winit::window::WindowAttributes>>, #[cfg(all(muda, target_os = "macos"))] muda_enable_default_menu_bar_bar: bool, #[cfg(target_family = "wasm")] spawn_event_loop: bool, } impl Backend { #[i_slint_core_macros::slint_doc] /// Creates a new winit backend with the default renderer that's compiled in. /// /// See the [backend documentation](slint:backends_and_renderers) for details on how to select the default renderer. pub fn new() -> Result { Self::builder().build() } #[i_slint_core_macros::slint_doc] /// Creates a new winit backend with the renderer specified by name. /// /// See the [backend documentation](slint:backends_and_renderers) for details on how to select the default renderer. /// /// If the renderer name is `None` or the name is not recognized, the default renderer is selected. pub fn new_with_renderer_by_name(renderer_name: Option<&str>) -> Result { let mut builder = Self::builder(); if let Some(name) = renderer_name { builder = builder.with_renderer_name(name.to_string()); } builder.build() } /// Creates a new BackendBuilder for configuring aspects of the Winit backend before /// setting it as the platform backend. pub fn builder() -> BackendBuilder { BackendBuilder { allow_fallback: true, requested_graphics_api: None, window_attributes_hook: None, renderer_name: None, event_loop_builder: None, #[cfg(all(muda, target_os = "macos"))] muda_enable_default_menu_bar_bar: true, #[cfg(target_family = "wasm")] spawn_event_loop: false, custom_application_handler: None, } } } /// Proxy of the event loop of the winit backend that was installed as the platform, so /// that [`invoke_from_active_event_loop`] can reach it from any thread. static GLOBAL_PROXY: std::sync::Mutex>> = std::sync::Mutex::new(None); /// Schedules a callback to be invoked in the winit event loop, and passes winit's /// [`ActiveEventLoop`] to it. /// /// This is similar to [`slint::invoke_from_event_loop`](i_slint_core::api::invoke_from_event_loop), /// but the callback also receives the [`ActiveEventLoop`], which winit only exposes while the /// event loop is running. Use it to call winit APIs that need it, for example to create custom /// windows. /// /// This function can be called from any thread. It returns an error if the winit backend hasn't /// been installed yet, or if the event loop has terminated. pub fn invoke_from_active_event_loop( func: impl FnOnce(&ActiveEventLoop) + Send + 'static, ) -> Result<(), EventLoopError> { let proxy = GLOBAL_PROXY.lock().unwrap().clone().ok_or(EventLoopError::NoEventLoopProvider)?; proxy .send_event(SlintEvent(CustomEvent::UserEventWithEventLoop(Box::new(func)))) .map_err(|_| EventLoopError::EventLoopTerminated) } #[allow(unused)] const DEFAULT_CURSOR_FLASH_CYCLE: core::time::Duration = core::time::Duration::from_millis(1000); #[cfg(any(target_os = "macos", target_os = "ios"))] fn prefers_non_blinking_text_insertion_indicator() -> Option { use core::ffi::{c_char, c_int, c_void}; unsafe extern "C" { fn dlopen(path: *const c_char, mode: c_int) -> *mut c_void; fn dlsym(handle: *mut c_void, symbol: *const c_char) -> *mut c_void; } type AxPrefersNonBlinkingTextInsertionIndicator = unsafe extern "C" fn() -> objc2::runtime::Bool; // AXPrefersNonBlinkingTextInsertionIndicator is available starting with macOS 15 and iOS 18, // and the Accessibility framework itself only exists since macOS 11 and iOS 14. // Load both dynamically: a `#[link]` attribute would emit a strong load command that makes // dyld abort before main() on older systems. When the framework or the symbol is // unavailable, the accessibility setting is unavailable and we keep the existing cursor // blink behavior. const RTLD_LAZY: c_int = 0x1; let framework = unsafe { dlopen( c"/System/Library/Frameworks/Accessibility.framework/Accessibility".as_ptr(), RTLD_LAZY, ) }; if framework.is_null() { return None; } let symbol = unsafe { dlsym(framework, c"AXPrefersNonBlinkingTextInsertionIndicator".as_ptr()) }; if symbol.is_null() { return None; } let function: AxPrefersNonBlinkingTextInsertionIndicator = unsafe { core::mem::transmute(symbol) }; Some(unsafe { function() }.as_bool()) } #[cfg(xdg_desktop_settings)] impl Drop for Backend { fn drop(&mut self) { if let Some(handle) = self.xdg_watcher.borrow_mut().take() { handle.abort(); } } } impl i_slint_core::platform::Platform for Backend { fn bind_context(&self, _ctx: i_slint_core::SlintContextWeak, _: i_slint_core::InternalToken) { let _ = self.shared_data.context.set(_ctx.clone()); #[cfg(xdg_desktop_settings)] { *self.xdg_watcher.borrow_mut() = crate::xdg_desktop_settings::spawn(&self.shared_data, &_ctx); } #[cfg(target_os = "windows")] if let Some(ctx) = _ctx.upgrade() { use windows::Win32::UI::HiDpi::SystemParametersInfoForDpi; use windows::Win32::UI::WindowsAndMessaging::{ NONCLIENTMETRICSW, SPI_GETNONCLIENTMETRICS, }; let mut metrics = NONCLIENTMETRICSW { cbSize: core::mem::size_of::() as u32, ..NONCLIENTMETRICSW::default() }; let ok = unsafe { SystemParametersInfoForDpi( SPI_GETNONCLIENTMETRICS.0, metrics.cbSize, Some(&mut metrics as *mut _ as *mut core::ffi::c_void), 0, 96, ) } .is_ok(); // `lfMessageFont.lfHeight` is in pixels at 96 DPI = Slint logical pixels; // negative means em height, positive means cell height — magnitude is fine here. let height = metrics.lfMessageFont.lfHeight.unsigned_abs(); if ok && height > 0 { ctx.set_platform_default_font_size(Some( i_slint_core::lengths::LogicalLength::new(height as f32), )); } } } fn create_window_adapter(&self) -> Result, PlatformError> { let mut attrs = WinitWindowAdapter::window_attributes()?; if let Some(hook) = &self.window_attributes_hook { attrs = hook(attrs); } let adapter = create_renderer(&self.shared_data).map_or_else( |e| { try_create_window_with_fallback_renderer( &self.shared_data, attrs.clone(), &self.shared_data.event_loop_proxy.clone(), #[cfg(all(muda, target_os = "macos"))] self.muda_enable_default_menu_bar_bar, ) .ok_or_else(|| format!("Winit backend failed to find a suitable renderer: {e}")) }, |renderer| { Ok(WinitWindowAdapter::new( self.shared_data.clone(), renderer, attrs.clone(), #[cfg(any(enable_accesskit, muda))] self.shared_data.event_loop_proxy.clone(), #[cfg(all(muda, target_os = "macos"))] self.muda_enable_default_menu_bar_bar, )) }, )?; Ok(adapter) } fn run_event_loop(&self) -> Result<(), PlatformError> { let loop_state = self.event_loop_state.borrow_mut().take().unwrap_or_else(|| { EventLoopState::new(self.shared_data.clone(), self.custom_application_handler.take()) }); #[cfg(target_family = "wasm")] { if self.spawn_event_loop { return loop_state.spawn(); } } // Note: fetch_add wraps around on overflow, which is what we want. self.shared_data.event_loop_generation.fetch_add(1, std::sync::atomic::Ordering::Relaxed); let new_state = loop_state.run()?; *self.event_loop_state.borrow_mut() = Some(new_state); Ok(()) } #[cfg(all(not(target_arch = "wasm32"), not(ios_and_friends)))] fn process_events( &self, timeout: Option, _: i_slint_core::InternalToken, ) -> Result, PlatformError> { let loop_state = self.event_loop_state.borrow_mut().take().unwrap_or_else(|| { EventLoopState::new(self.shared_data.clone(), self.custom_application_handler.take()) }); let (new_state, status) = loop_state.pump_events(timeout)?; *self.event_loop_state.borrow_mut() = Some(new_state); match status { winit::platform::pump_events::PumpStatus::Continue => { Ok(core::ops::ControlFlow::Continue(())) } winit::platform::pump_events::PumpStatus::Exit(code) => { if code == 0 { Ok(core::ops::ControlFlow::Break(())) } else { Err(format!("Event loop exited with non-zero code {code}").into()) } } } } fn new_event_loop_proxy(&self) -> Option> { struct Proxy(winit::event_loop::EventLoopProxy, Arc); impl EventLoopProxy for Proxy { fn quit_event_loop(&self) -> Result<(), EventLoopError> { let generation = self.1.load(std::sync::atomic::Ordering::Relaxed); self.0 .send_event(SlintEvent(CustomEvent::Exit(generation))) .map_err(|_| EventLoopError::EventLoopTerminated) } fn invoke_from_event_loop( &self, event: Box, ) -> Result<(), EventLoopError> { // Calling send_event is usually done by winit at the bottom of the stack, // in event handlers, and thus winit might decide to process the event // immediately within that stack. // To prevent re-entrancy issues that might happen by getting the application // event processed on top of the current stack, set winit in Poll mode so that // events are queued and process on top of a clean stack during a requested animation // frame a few moments later. // This also allows batching multiple post_event calls and redraw their state changes // all at once. #[cfg(target_arch = "wasm32")] self.0 .send_event(SlintEvent(CustomEvent::WakeEventLoopWorkaround)) .map_err(|_| EventLoopError::EventLoopTerminated)?; self.0 .send_event(SlintEvent(CustomEvent::UserEvent(event))) .map_err(|_| EventLoopError::EventLoopTerminated) } } *GLOBAL_PROXY.lock().unwrap() = Some(self.shared_data.event_loop_proxy.clone()); Some(Box::new(Proxy( self.shared_data.event_loop_proxy.clone(), Arc::clone(&self.shared_data.event_loop_generation), ))) } #[cfg(target_arch = "wasm32")] fn set_clipboard_text(&self, text: &str, clipboard: i_slint_core::platform::Clipboard) { crate::wasm_input_helper::set_clipboard_text(text.into(), clipboard); } #[cfg(not(target_arch = "wasm32"))] fn set_clipboard_text(&self, text: &str, clipboard: i_slint_core::platform::Clipboard) { let mut pair = self.shared_data.clipboard.borrow_mut(); if let Some(clipboard) = clipboard::select_clipboard(&mut pair, clipboard) { clipboard.set_contents(text.into()).ok(); } } #[cfg(target_arch = "wasm32")] fn clipboard_text(&self, clipboard: i_slint_core::platform::Clipboard) -> Option { crate::wasm_input_helper::get_clipboard_text(clipboard) } #[cfg(not(target_arch = "wasm32"))] fn clipboard_text(&self, clipboard: i_slint_core::platform::Clipboard) -> Option { let mut pair = self.shared_data.clipboard.borrow_mut(); clipboard::select_clipboard(&mut pair, clipboard).and_then(|c| c.get_contents().ok()) } #[cfg(target_os = "windows")] fn cursor_flash_cycle(&self) -> core::time::Duration { use windows::Win32::UI::WindowsAndMessaging::GetCaretBlinkTime; let ms = unsafe { GetCaretBlinkTime() }; if ms == u32::MAX { // INFINITE — blinking disabled core::time::Duration::ZERO } else if ms == 0 { DEFAULT_CURSOR_FLASH_CYCLE } else { // Win32 returns the half-cycle duration core::time::Duration::from_millis(ms as u64 * 2) } } #[cfg(target_os = "macos")] fn cursor_flash_cycle(&self) -> core::time::Duration { if prefers_non_blinking_text_insertion_indicator() == Some(true) { return core::time::Duration::ZERO; } let defaults = objc2_foundation::NSUserDefaults::standardUserDefaults(); let key = objc2_foundation::NSString::from_str("NSTextInsertionPointBlinkPeriod"); let period = defaults.integerForKey(&key); if period < 0 { core::time::Duration::ZERO } else if period == 0 { DEFAULT_CURSOR_FLASH_CYCLE } else { core::time::Duration::from_millis(period as u64) } } #[cfg(target_os = "ios")] fn cursor_flash_cycle(&self) -> core::time::Duration { if prefers_non_blinking_text_insertion_indicator() == Some(true) { core::time::Duration::ZERO } else { DEFAULT_CURSOR_FLASH_CYCLE } } #[cfg(xdg_desktop_settings)] fn cursor_flash_cycle(&self) -> core::time::Duration { self.shared_data.desktop_settings.cursor_flash_cycle() } fn open_url(&self, url: &str) -> Result<(), i_slint_core::platform::PlatformError> { webbrowser::open(url).map_err(|e| { i_slint_core::platform::PlatformError::Other(format!("Failed to open URL: {e}")) }) } } mod private { pub trait WinitWindowAccessorSealed {} } #[i_slint_core_macros::slint_doc] /// This helper trait can be used to obtain access to the [`winit::window::Window`] for a given /// [`slint::Window`](slint:rust:slint/struct.window). /// /// Note that the association of a Slint window with a winit window relies on two factors: /// /// - The winit backend must be in use. You can ensure this programmatically by calling [`slint::BackendSelector::backend_name()`](slint:rust:slint/struct.BackendSelector#method.backend_name) /// with "winit" as argument. /// - The winit window must've been created. Windowing systems, and by extension winit, require that windows can only be properly /// created when certain conditions of the event loop are met. For example, on Android the application can't be suspended. Therefore, /// functions like [`Self::has_winit_window()`] or [`Self::with_winit_window()`] will only succeed when the event loop is active. /// This is typically the case when callbacks are invoked from the event loop, such as through timers, user input events, or when window /// receives events (see also [`Self::on_winit_window_event()`]). pub trait WinitWindowAccessor: private::WinitWindowAccessorSealed { /// Returns true if a [`winit::window::Window`] exists for this window. This is the case if the window is /// backed by this winit backend. fn has_winit_window(&self) -> bool; /// Invokes the specified callback with a reference to the [`winit::window::Window`] that exists for this Slint window /// and returns `Some(T)`; otherwise `None`. fn with_winit_window(&self, callback: impl FnOnce(&winit::window::Window) -> T) -> Option; /// Registers a window event filter callback for this Slint window. /// /// The callback is invoked in the winit event loop whenever a window event is received with a reference to the /// [`slint::Window`](i_slint_core::api::Window) and the [`winit::event::WindowEvent`]. The return value of the /// callback specifies whether Slint should handle this event. /// /// If this window [is not backed by winit](WinitWindowAccessor::has_winit_window), this function is a no-op. fn on_winit_window_event( &self, callback: impl FnMut(&i_slint_core::api::Window, &winit::event::WindowEvent) -> EventResult + 'static, ); /// Returns a future that resolves to the [`winit::window::Window`] for this Slint window. /// When the future is ready, the output it resolves to is either `Ok(Arc)` if the window exists, /// or an error if the window has been deleted in the meanwhile or isn't backed by the winit backend. /// /// Hiding the Slint window doesn't destroy a window that's still referenced this way, so it stays /// on screen. Use [`Self::with_winit_window()`] to borrow the window for the time of a callback instead. /// /// ```rust,no_run /// // Bring winit and accessor traits into scope. /// use slint::winit_030::{WinitWindowAccessor, winit}; /// /// slint::slint!{ /// import { VerticalBox, Button } from "std-widgets.slint"; /// export component HelloWorld inherits Window { /// callback clicked; /// VerticalBox { /// Text { /// text: "hello world"; /// color: green; /// } /// Button { /// text: "Click me"; /// clicked => { root.clicked(); } /// } /// } /// } /// } /// fn main() -> Result<(), Box> { /// // Make sure the winit backed is selected: /// slint::BackendSelector::new() /// .backend_name("winit".into()) /// .select()?; /// /// let app = HelloWorld::new()?; /// let app_weak = app.as_weak(); /// /// slint::spawn_local(async move { /// let app = app_weak.unwrap(); /// let winit_window = app.window().winit_window().await.unwrap(); /// eprintln!("window id = {:#?}", winit_window.id()); /// }).unwrap(); /// app.run()?; /// Ok(()) /// } /// ``` fn winit_window( &self, ) -> impl std::future::Future, PlatformError>>; } impl WinitWindowAccessor for i_slint_core::api::Window { fn has_winit_window(&self) -> bool { i_slint_core::window::WindowInner::from_pub(self) .window_adapter() .internal(i_slint_core::InternalToken) .and_then(|wa| (wa as &dyn core::any::Any).downcast_ref::()) .is_some_and(|adapter| adapter.winit_window().is_some()) } fn with_winit_window( &self, callback: impl FnOnce(&winit::window::Window) -> T, ) -> Option { i_slint_core::window::WindowInner::from_pub(self) .window_adapter() .internal(i_slint_core::InternalToken) .and_then(|wa| (wa as &dyn core::any::Any).downcast_ref::()) .and_then(|adapter| adapter.winit_window().map(|w| callback(&w))) } fn winit_window( &self, ) -> impl std::future::Future, PlatformError>> { Box::pin(async move { let adapter_weak = i_slint_core::window::WindowInner::from_pub(self) .window_adapter() .internal(i_slint_core::InternalToken) .and_then(|wa| (wa as &dyn core::any::Any).downcast_ref::()) .map(|wa| wa.self_weak.clone()) .ok_or_else(|| { PlatformError::OtherError( "Slint window is not backed by a Winit window adapter".to_string().into(), ) })?; WinitWindowAdapter::async_winit_window(adapter_weak).await }) } fn on_winit_window_event( &self, mut callback: impl FnMut(&i_slint_core::api::Window, &winit::event::WindowEvent) -> EventResult + 'static, ) { if let Some(adapter) = i_slint_core::window::WindowInner::from_pub(self) .window_adapter() .internal(i_slint_core::InternalToken) .and_then(|wa| (wa as &dyn core::any::Any).downcast_ref::()) { adapter .window_event_filter .set(Some(Box::new(move |window, event| callback(window, event)))); } } } /// Creates a new renderer from the backend properties in `shared_data` fn create_renderer( shared_data: &Rc, ) -> Result, PlatformError> { match (shared_data.renderer_name.as_deref(), shared_data.requested_graphics_api.as_ref()) { #[cfg(all(feature = "renderer-femtovg", supports_opengl))] (Some("gl"), maybe_graphics_api) | (Some("femtovg"), maybe_graphics_api) => { // If a graphics API was requested, double check that it's GL. FemtoVG doesn't support Metal, etc. if let Some(api) = maybe_graphics_api { i_slint_core::graphics::RequestedOpenGLVersion::try_from(api)?; } renderer::femtovg::GlutinFemtoVGRenderer::new_suspended(shared_data) } #[cfg(feature = "renderer-femtovg-wgpu")] (Some("femtovg-wgpu"), maybe_graphics_api) => { if let Some(_api) = maybe_graphics_api { #[cfg(feature = "unstable-wgpu-30")] if !matches!(_api, RequestedGraphicsAPI::WGPU30(..)) { return Err( "The FemtoVG WGPU renderer only supports the WGPU30 graphics API selection" .into(), ); } } renderer::femtovg::WGPUFemtoVGRenderer::new_suspended(shared_data) } #[cfg(enable_skia_renderer)] (Some("skia"), maybe_graphics_api) => { (renderer::skia::WinitSkiaRenderer::factory_for_graphics_api(maybe_graphics_api)?)( shared_data, ) } #[cfg(all(enable_skia_renderer, supports_opengl))] (Some("skia-opengl"), maybe_graphics_api) => { // If a graphics API was requested, double check that it's GL. if let Some(api) = maybe_graphics_api { i_slint_core::graphics::RequestedOpenGLVersion::try_from(api)?; } renderer::skia::WinitSkiaRenderer::new_opengl_suspended(shared_data) } #[cfg(enable_skia_renderer)] (Some("skia-wgpu"), maybe_graphics_api) => match maybe_graphics_api { None => renderer::skia::WinitSkiaRenderer::new_wgpu_30_suspended(shared_data), #[cfg(feature = "unstable-wgpu-30")] // this is always enabled when skia is enabled, but rust-analyzer can get confused Some(RequestedGraphicsAPI::WGPU30(..)) => { renderer::skia::WinitSkiaRenderer::new_wgpu_30_suspended(shared_data) } #[cfg(feature = "unstable-wgpu-29")] Some(RequestedGraphicsAPI::WGPU29(..)) => { renderer::skia::WinitSkiaRenderer::new_wgpu_29_suspended(shared_data) } Some(_) => { Err("Skia with WGPU doesn't support non-WGPU graphics API".to_string().into()) } }, #[cfg(all(enable_skia_renderer, not(target_os = "android")))] (Some("skia-software"), None) => { renderer::skia::WinitSkiaRenderer::new_software_suspended(shared_data) } #[cfg(feature = "renderer-software")] (Some("sw"), None) | (Some("software"), None) => { renderer::sw::WinitSoftwareRenderer::new_suspended(shared_data) } #[cfg(feature = "renderer-vello")] (Some("vello"), maybe_graphics_api) => { // vello renders through WGPU 29; anything else was not created by // this renderer and cannot be adopted. if let Some(api) = maybe_graphics_api && !matches!(api, RequestedGraphicsAPI::WGPU29(..)) { return Err( "The vello renderer only supports the WGPU29 graphics API selection".into() ); } renderer::vello::WinitVelloRenderer::new_suspended(shared_data) } (None, None) => default_renderer_factory(shared_data), (Some(renderer_name), _) => { if shared_data.allow_fallback { eprintln!( "slint winit: unrecognized renderer {renderer_name}, falling back to {DEFAULT_RENDERER_NAME}" ); default_renderer_factory(shared_data) } else { Err(PlatformError::NoPlatform) } } #[cfg(feature = "unstable-wgpu-29")] (None, Some(RequestedGraphicsAPI::WGPU29(..))) => { cfg_if::cfg_if! { if #[cfg(enable_skia_renderer)] { renderer::skia::WinitSkiaRenderer::new_wgpu_29_suspended(shared_data) } else if #[cfg(feature = "renderer-vello")] { renderer::vello::WinitVelloRenderer::new_suspended(shared_data) } else { Err("unstable-wgpu-29 was enabled but no renderer was selected. Please select renderer-skia* or renderer-vello".into()) } } } #[cfg(feature = "unstable-wgpu-30")] (None, Some(RequestedGraphicsAPI::WGPU30(..))) => { cfg_if::cfg_if! { if #[cfg(enable_skia_renderer)] { renderer::skia::WinitSkiaRenderer::new_wgpu_30_suspended(shared_data) } else if #[cfg(feature = "renderer-femtovg-wgpu")] { renderer::femtovg::WGPUFemtoVGRenderer::new_suspended(shared_data) } else { Err("unstable-wgpu-30 was enabled but no renderer was selected. Please select either renderer-skia* or renderer-femtovg-wgpu".into()) } } } (None, Some(_requested_graphics_api)) => { cfg_if::cfg_if! { if #[cfg(enable_skia_renderer)] { renderer::skia::WinitSkiaRenderer::factory_for_graphics_api(Some(_requested_graphics_api))?(shared_data) } else if #[cfg(all(feature = "renderer-femtovg", supports_opengl))] { // If a graphics API was requested, double check that it's GL. FemtoVG doesn't support Metal, etc. i_slint_core::graphics::RequestedOpenGLVersion::try_from(_requested_graphics_api)?; renderer::femtovg::GlutinFemtoVGRenderer::new_suspended(shared_data) } else { return Err(format!("Graphics API use requested by the compile-time enabled renderers don't support that").into()) } } } } } impl private::WinitWindowAccessorSealed for i_slint_core::api::Window {} #[cfg(test)] mod testui { slint::slint! { export component App inherits Window { Text { text: "Ok"; } } } } // Sorry, can't test with rust test harness and multiple threads. #[cfg(not(any(target_arch = "wasm32", target_vendor = "apple")))] #[test] fn test_window_accessor_and_rwh() { slint::platform::set_platform(Box::new(crate::Backend::new().unwrap())).unwrap(); use testui::*; slint::spawn_local(async move { let app = App::new().unwrap(); let slint_window = app.window(); assert!(!slint_window.has_winit_window()); // Show() won't immediately create the window, the event loop will have to // spin first. app.show().unwrap(); let result = slint_window.winit_window().await; assert!(result.is_ok(), "Failed to get winit window: {:?}", result.err()); assert!(slint_window.has_winit_window()); let handle = slint_window.window_handle(); use raw_window_handle::{HasDisplayHandle, HasWindowHandle}; assert!(handle.window_handle().is_ok()); assert!(handle.display_handle().is_ok()); slint::quit_event_loop().unwrap(); }) .unwrap(); slint::run_event_loop().unwrap(); }