Separate conversation drafts and voice view state, add native settings and restricted CSS themes, implement validated avatar cropping, and refresh dependencies with documented desktop compatibility backports.
1399 lines
57 KiB
Rust
Vendored
1399 lines
57 KiB
Rust
Vendored
// Copyright © SixtyFPS GmbH <info@slint.dev>
|
|
// 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<SlintEvent>;
|
|
|
|
/// 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<DrawOutcome, PlatformError>;
|
|
|
|
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<crate::winitwindowadapter::WinitWindowAdapter>,
|
|
) -> Result<Arc<winit::window::Window>, 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<SharedBackendData>,
|
|
) -> Result<Box<dyn WinitCompatibleRenderer>, 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<SharedBackendData>,
|
|
attrs: winit::window::WindowAttributes,
|
|
_proxy: &winit::event_loop::EventLoopProxy<SlintEvent>,
|
|
#[cfg(all(muda, target_os = "macos"))] muda_enable_default_menu_bar: bool,
|
|
) -> Option<Rc<WinitWindowAdapter>> {
|
|
[
|
|
#[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<RequestedGraphicsAPI>,
|
|
window_attributes_hook:
|
|
Option<Box<dyn Fn(winit::window::WindowAttributes) -> winit::window::WindowAttributes>>,
|
|
renderer_name: Option<String>,
|
|
event_loop_builder: Option<EventLoopBuilder>,
|
|
#[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<Box<dyn CustomApplicationHandler>>,
|
|
}
|
|
|
|
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<String>) -> 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<dyn CustomApplicationHandler + 'static>,
|
|
) -> 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<Backend, PlatformError> {
|
|
#[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<WinitWindowAdapter>, 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<i_slint_core::SlintContextWeak>,
|
|
/// Allow fallback if the desired renderer is not found
|
|
allow_fallback: bool,
|
|
renderer_name: Option<String>,
|
|
requested_graphics_api: Option<RequestedGraphicsAPI>,
|
|
#[cfg(enable_skia_renderer)]
|
|
skia_context: i_slint_renderer_skia::SkiaSharedContext,
|
|
active_windows: Rc<RefCell<HashMap<winit::window::WindowId, Weak<WinitWindowAdapter>>>>,
|
|
/// 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<Vec<Weak<WinitWindowAdapter>>>,
|
|
/// 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<Option<(Weak<WinitWindowAdapter>, LogicalPoint)>>,
|
|
/// Hidden windows, checked by [`SharedBackendData::warn_about_windows_kept_alive`].
|
|
hidden_winit_windows: RefCell<Vec<std::sync::Weak<winit::window::Window>>>,
|
|
#[cfg(not(target_arch = "wasm32"))]
|
|
clipboard: std::cell::RefCell<clipboard::ClipboardPair>,
|
|
not_running_event_loop: RefCell<Option<winit::event_loop::EventLoop<SlintEvent>>>,
|
|
event_loop_proxy: winit::event_loop::EventLoopProxy<SlintEvent>,
|
|
/// 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<AtomicUsize>,
|
|
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<String>,
|
|
requested_graphics_api: Option<RequestedGraphicsAPI>,
|
|
allow_fallback: bool,
|
|
) -> Result<Self, PlatformError> {
|
|
#[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::<RefCell<HashMap<winit::window::WindowId, Weak<WinitWindowAdapter>>>>::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<WinitWindowAdapter>) {
|
|
self.active_windows.borrow_mut().insert(id, Rc::downgrade(&window));
|
|
}
|
|
|
|
pub fn register_inactive_window(&self, window: Rc<WinitWindowAdapter>) {
|
|
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<winit::window::WindowId>) {
|
|
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<Rc<WinitWindowAdapter>> {
|
|
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<WinitWindowAdapter>,
|
|
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<winit::window::Window>) {
|
|
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<Option<crate::event_loop::EventLoopState>>,
|
|
shared_data: Rc<SharedBackendData>,
|
|
custom_application_handler: RefCell<Option<Box<dyn crate::CustomApplicationHandler>>>,
|
|
/// Backend-wide XDG desktop portal watcher. Spawned in `bind_context`
|
|
/// and aborted on backend drop.
|
|
#[cfg(xdg_desktop_settings)]
|
|
xdg_watcher: RefCell<Option<i_slint_core::future::JoinHandle<()>>>,
|
|
|
|
/// 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<Box<dyn Fn(winit::window::WindowAttributes) -> 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, PlatformError> {
|
|
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<Self, PlatformError> {
|
|
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<Option<winit::event_loop::EventLoopProxy<SlintEvent>>> =
|
|
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<bool> {
|
|
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::<NONCLIENTMETRICSW>() 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<Rc<dyn WindowAdapter>, 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<core::time::Duration>,
|
|
_: i_slint_core::InternalToken,
|
|
) -> Result<core::ops::ControlFlow<()>, 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<Box<dyn EventLoopProxy>> {
|
|
struct Proxy(winit::event_loop::EventLoopProxy<SlintEvent>, Arc<AtomicUsize>);
|
|
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<dyn FnOnce() + Send>,
|
|
) -> 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<String> {
|
|
crate::wasm_input_helper::get_clipboard_text(clipboard)
|
|
}
|
|
|
|
#[cfg(not(target_arch = "wasm32"))]
|
|
fn clipboard_text(&self, clipboard: i_slint_core::platform::Clipboard) -> Option<String> {
|
|
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<T>(&self, callback: impl FnOnce(&winit::window::Window) -> T)
|
|
-> Option<T>;
|
|
/// 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<winit::window::Window>)` 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<dyn std::error::Error>> {
|
|
/// // 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<Output = Result<Arc<winit::window::Window>, 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::<WinitWindowAdapter>())
|
|
.is_some_and(|adapter| adapter.winit_window().is_some())
|
|
}
|
|
|
|
fn with_winit_window<T>(
|
|
&self,
|
|
callback: impl FnOnce(&winit::window::Window) -> T,
|
|
) -> Option<T> {
|
|
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::<WinitWindowAdapter>())
|
|
.and_then(|adapter| adapter.winit_window().map(|w| callback(&w)))
|
|
}
|
|
|
|
fn winit_window(
|
|
&self,
|
|
) -> impl std::future::Future<Output = Result<Arc<winit::window::Window>, 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::<WinitWindowAdapter>())
|
|
.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::<WinitWindowAdapter>())
|
|
{
|
|
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<SharedBackendData>,
|
|
) -> Result<Box<dyn WinitCompatibleRenderer>, 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();
|
|
}
|