mirror of
https://github.com/slint-ui/slint.git
synced 2025-08-30 07:07:25 +00:00
155b1443e2
On macOS and Windows, use winit's `Window::theme()` instead of dark-light, to detect the theme. Always react to WindowEvent::ThemeChange. It's delivered on macOS, Windows, and the web.
775 lines
31 KiB
Rust
775 lines
31 KiB
Rust
// Copyright © SixtyFPS GmbH <info@slint-ui.com>
|
|
// SPDX-License-Identifier: GPL-3.0-only OR LicenseRef-Slint-commercial
|
|
|
|
#![warn(missing_docs)]
|
|
/*!
|
|
This module contains the event loop implementation using winit, as well as the
|
|
[WindowAdapter] trait used by the generated code and the run-time to change
|
|
aspects of windows on the screen.
|
|
*/
|
|
use copypasta::ClipboardProvider;
|
|
use corelib::items::PointerEventButton;
|
|
use corelib::lengths::LogicalPoint;
|
|
use corelib::lengths::LogicalSize;
|
|
use corelib::SharedString;
|
|
use i_slint_core as corelib;
|
|
|
|
use corelib::api::EventLoopError;
|
|
use corelib::graphics::euclid;
|
|
use corelib::input::{KeyEventType, KeyInputEvent, MouseEvent};
|
|
use corelib::window::*;
|
|
use std::cell::{Cell, RefCell, RefMut};
|
|
use std::rc::{Rc, Weak};
|
|
|
|
use winit::event::WindowEvent;
|
|
#[cfg(not(target_arch = "wasm32"))]
|
|
use winit::platform::run_return::EventLoopExtRunReturn;
|
|
|
|
pub(crate) static QUIT_ON_LAST_WINDOW_CLOSED: std::sync::atomic::AtomicBool =
|
|
std::sync::atomic::AtomicBool::new(true);
|
|
|
|
pub trait WinitWindow: WindowAdapter {
|
|
fn currently_pressed_key_code(&self) -> &Cell<Option<winit::event::VirtualKeyCode>>;
|
|
/// Returns true if during the drawing request_redraw() was called.
|
|
fn draw(&self) -> bool;
|
|
fn with_window_handle(&self, callback: &mut dyn FnMut(&winit::window::Window));
|
|
fn constraints(&self) -> (corelib::layout::LayoutInfo, corelib::layout::LayoutInfo);
|
|
fn set_constraints(
|
|
&self,
|
|
constraints: (corelib::layout::LayoutInfo, corelib::layout::LayoutInfo),
|
|
);
|
|
|
|
/// Called by the event loop when a WindowEvent::Resized is received.
|
|
fn resize_event(&self, _size: winit::dpi::PhysicalSize<u32>) {}
|
|
|
|
/// Return true if the proxy element used for input method has the focus
|
|
fn input_method_focused(&self) -> bool {
|
|
false
|
|
}
|
|
/// Returns true if request_redraw() was called since the last event loop iteration
|
|
/// and resets the state back to false.
|
|
fn take_pending_redraw(&self) -> bool;
|
|
|
|
/// Notify the window if the system theme has changed from light to dark mode
|
|
fn set_dark_color_scheme(&self, dark_mode: bool);
|
|
}
|
|
|
|
/// The Default, and the selection clippoard
|
|
type ClipboardPair = (Box<dyn ClipboardProvider>, Box<dyn ClipboardProvider>);
|
|
|
|
struct NotRunningEventLoop {
|
|
clipboard: RefCell<ClipboardPair>,
|
|
instance: winit::event_loop::EventLoop<CustomEvent>,
|
|
event_loop_proxy: winit::event_loop::EventLoopProxy<CustomEvent>,
|
|
}
|
|
|
|
impl NotRunningEventLoop {
|
|
fn new() -> Self {
|
|
let instance = winit::event_loop::EventLoopBuilder::with_user_event().build();
|
|
let event_loop_proxy = instance.create_proxy();
|
|
let clipboard = RefCell::new(create_clipboard(&instance));
|
|
Self { clipboard, instance, event_loop_proxy }
|
|
}
|
|
}
|
|
|
|
struct RunningEventLoop<'a> {
|
|
event_loop_target: &'a winit::event_loop::EventLoopWindowTarget<CustomEvent>,
|
|
event_loop_proxy: &'a winit::event_loop::EventLoopProxy<CustomEvent>,
|
|
clipboard: &'a RefCell<ClipboardPair>,
|
|
}
|
|
|
|
pub(crate) trait EventLoopInterface {
|
|
fn event_loop_target(&self) -> &winit::event_loop::EventLoopWindowTarget<CustomEvent>;
|
|
fn event_loop_proxy(&self) -> &winit::event_loop::EventLoopProxy<CustomEvent>;
|
|
fn clipboard(
|
|
&self,
|
|
_: i_slint_core::platform::Clipboard,
|
|
) -> Option<RefMut<'_, dyn ClipboardProvider>>;
|
|
}
|
|
|
|
impl EventLoopInterface for NotRunningEventLoop {
|
|
fn event_loop_target(&self) -> &winit::event_loop::EventLoopWindowTarget<CustomEvent> {
|
|
&*self.instance
|
|
}
|
|
|
|
fn event_loop_proxy(&self) -> &winit::event_loop::EventLoopProxy<CustomEvent> {
|
|
&self.event_loop_proxy
|
|
}
|
|
|
|
fn clipboard(
|
|
&self,
|
|
clipboard: i_slint_core::platform::Clipboard,
|
|
) -> Option<RefMut<'_, dyn ClipboardProvider>> {
|
|
match clipboard {
|
|
corelib::platform::Clipboard::DefaultClipboard => {
|
|
Some(RefMut::map(self.clipboard.borrow_mut(), |p| p.0.as_mut()))
|
|
}
|
|
corelib::platform::Clipboard::SelectionClipboard => {
|
|
Some(RefMut::map(self.clipboard.borrow_mut(), |p| p.1.as_mut()))
|
|
}
|
|
_ => None,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<'a> EventLoopInterface for RunningEventLoop<'a> {
|
|
fn event_loop_target(&self) -> &winit::event_loop::EventLoopWindowTarget<CustomEvent> {
|
|
self.event_loop_target
|
|
}
|
|
|
|
fn event_loop_proxy(&self) -> &winit::event_loop::EventLoopProxy<CustomEvent> {
|
|
self.event_loop_proxy
|
|
}
|
|
|
|
fn clipboard(
|
|
&self,
|
|
clipboard: i_slint_core::platform::Clipboard,
|
|
) -> Option<RefMut<'_, dyn ClipboardProvider>> {
|
|
match clipboard {
|
|
corelib::platform::Clipboard::DefaultClipboard => {
|
|
Some(RefMut::map(self.clipboard.borrow_mut(), |p| p.0.as_mut()))
|
|
}
|
|
corelib::platform::Clipboard::SelectionClipboard => {
|
|
Some(RefMut::map(self.clipboard.borrow_mut(), |p| p.1.as_mut()))
|
|
}
|
|
_ => None,
|
|
}
|
|
}
|
|
}
|
|
|
|
thread_local! {
|
|
static ALL_WINDOWS: RefCell<std::collections::HashMap<winit::window::WindowId, Weak<dyn WinitWindow>>> = RefCell::new(std::collections::HashMap::new());
|
|
static MAYBE_LOOP_INSTANCE: RefCell<Option<NotRunningEventLoop>> = RefCell::new(Some(NotRunningEventLoop::new()));
|
|
}
|
|
|
|
scoped_tls_hkt::scoped_thread_local!(static CURRENT_WINDOW_TARGET : for<'a> &'a RunningEventLoop<'a>);
|
|
|
|
pub(crate) enum GlobalEventLoopProxyOrEventQueue {
|
|
Proxy(winit::event_loop::EventLoopProxy<CustomEvent>),
|
|
Queue(Vec<CustomEvent>),
|
|
}
|
|
|
|
impl GlobalEventLoopProxyOrEventQueue {
|
|
pub(crate) fn send_event(&mut self, event: CustomEvent) -> Result<(), EventLoopError> {
|
|
match self {
|
|
GlobalEventLoopProxyOrEventQueue::Proxy(proxy) => {
|
|
proxy.send_event(event).map_err(|_| EventLoopError::EventLoopTerminated)
|
|
}
|
|
GlobalEventLoopProxyOrEventQueue::Queue(queue) => {
|
|
queue.push(event);
|
|
Ok(())
|
|
}
|
|
}
|
|
}
|
|
|
|
fn set_proxy(&mut self, proxy: winit::event_loop::EventLoopProxy<CustomEvent>) {
|
|
match self {
|
|
GlobalEventLoopProxyOrEventQueue::Proxy(_) => {}
|
|
GlobalEventLoopProxyOrEventQueue::Queue(queue) => {
|
|
std::mem::take(queue)
|
|
.into_iter()
|
|
.for_each(|event| proxy.send_event(event).ok().unwrap());
|
|
*self = GlobalEventLoopProxyOrEventQueue::Proxy(proxy);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Default for GlobalEventLoopProxyOrEventQueue {
|
|
fn default() -> Self {
|
|
Self::Queue(Vec::new())
|
|
}
|
|
}
|
|
|
|
#[cfg(not(target_arch = "wasm32"))]
|
|
pub(crate) static GLOBAL_PROXY: once_cell::sync::OnceCell<
|
|
std::sync::Mutex<GlobalEventLoopProxyOrEventQueue>,
|
|
> = once_cell::sync::OnceCell::new();
|
|
|
|
#[cfg(target_arch = "wasm32")]
|
|
thread_local! {
|
|
pub(crate) static GLOBAL_PROXY: RefCell<Option<GlobalEventLoopProxyOrEventQueue>> = RefCell::new(None)
|
|
}
|
|
|
|
pub(crate) fn with_window_target<T>(callback: impl FnOnce(&dyn EventLoopInterface) -> T) -> T {
|
|
if CURRENT_WINDOW_TARGET.is_set() {
|
|
CURRENT_WINDOW_TARGET.with(|current_target| callback(current_target))
|
|
} else {
|
|
MAYBE_LOOP_INSTANCE.with(|loop_instance| {
|
|
if loop_instance.borrow().is_none() {
|
|
*loop_instance.borrow_mut() = Some(NotRunningEventLoop::new());
|
|
}
|
|
callback(loop_instance.borrow().as_ref().unwrap())
|
|
})
|
|
}
|
|
}
|
|
|
|
pub fn register_window(id: winit::window::WindowId, window: Rc<dyn WinitWindow>) {
|
|
ALL_WINDOWS.with(|windows| {
|
|
windows.borrow_mut().insert(id, Rc::downgrade(&window));
|
|
})
|
|
}
|
|
|
|
pub fn unregister_window(id: winit::window::WindowId) {
|
|
ALL_WINDOWS.with(|windows| {
|
|
windows.borrow_mut().remove(&id);
|
|
})
|
|
}
|
|
|
|
fn window_by_id(id: winit::window::WindowId) -> Option<Rc<dyn WinitWindow>> {
|
|
ALL_WINDOWS.with(|windows| windows.borrow().get(&id).and_then(|weakref| weakref.upgrade()))
|
|
}
|
|
|
|
/// This enum captures run-time specific events that can be dispatched to the event loop in
|
|
/// addition to the winit events.
|
|
pub enum CustomEvent {
|
|
/// On wasm request_redraw doesn't wake the event loop, so we need to manually send an event
|
|
/// so that the event loop can run
|
|
#[cfg(target_arch = "wasm32")]
|
|
WakeEventLoopWorkaround,
|
|
UpdateWindowProperties(winit::window::WindowId),
|
|
UserEvent(Box<dyn FnOnce() + Send>),
|
|
/// Called from `GLWindow::hide` so that we can check if we should quit the event loop
|
|
WindowHidden,
|
|
Exit,
|
|
}
|
|
|
|
impl std::fmt::Debug for CustomEvent {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
match self {
|
|
#[cfg(target_arch = "wasm32")]
|
|
Self::WakeEventLoopWorkaround => write!(f, "WakeEventLoopWorkaround"),
|
|
Self::UpdateWindowProperties(e) => write!(f, "UpdateWindowProperties({:?})", e),
|
|
Self::UserEvent(_) => write!(f, "UserEvent"),
|
|
Self::WindowHidden => write!(f, "WindowHidden"),
|
|
Self::Exit => write!(f, "Exit"),
|
|
}
|
|
}
|
|
}
|
|
|
|
mod key_codes {
|
|
macro_rules! winit_key_to_char_fn {
|
|
($($char:literal # $name:ident # $($_qt:ident)|* # $($winit:ident)|* ;)*) => {
|
|
pub fn winit_key_to_char(virtual_keycode: winit::event::VirtualKeyCode) -> Option<char> {
|
|
let char = match(virtual_keycode) {
|
|
$($(winit::event::VirtualKeyCode::$winit => $char,)*)*
|
|
_ => return None,
|
|
};
|
|
Some(char)
|
|
}
|
|
};
|
|
}
|
|
i_slint_common::for_each_special_keys!(winit_key_to_char_fn);
|
|
}
|
|
|
|
fn process_window_event(
|
|
window: Rc<dyn WinitWindow>,
|
|
event: WindowEvent,
|
|
cursor_pos: &mut LogicalPoint,
|
|
pressed: &mut bool,
|
|
) {
|
|
let runtime_window = WindowInner::from_pub(window.window());
|
|
match event {
|
|
WindowEvent::Resized(size) => {
|
|
window.resize_event(size);
|
|
}
|
|
WindowEvent::CloseRequested => {
|
|
if runtime_window.request_close() {
|
|
window.hide();
|
|
}
|
|
}
|
|
WindowEvent::ReceivedCharacter(ch) => {
|
|
// On Windows, X11 and Wayland sequences like Ctrl+C will send a ReceivedCharacter after the pressed keyboard input event,
|
|
// with a control character. We choose not to forward those but try to use the current key code instead.
|
|
//
|
|
// We do not want to change the text to the value of the key press when that was a
|
|
// control key itself: We already sent that event when handling the KeyboardInput.
|
|
let text: SharedString = if ch.is_control() {
|
|
if let Some(ch) = window
|
|
.currently_pressed_key_code()
|
|
.take()
|
|
.and_then(winit_key_code_to_string)
|
|
.filter(|ch| !ch.is_control())
|
|
{
|
|
ch
|
|
} else {
|
|
return;
|
|
}
|
|
} else {
|
|
ch
|
|
}
|
|
.into();
|
|
|
|
window
|
|
.window()
|
|
.dispatch_event(corelib::platform::WindowEvent::KeyPressed { text: text.clone() });
|
|
window.window().dispatch_event(corelib::platform::WindowEvent::KeyReleased { text });
|
|
}
|
|
WindowEvent::Focused(have_focus) => {
|
|
let have_focus = have_focus || window.input_method_focused();
|
|
// We don't render popups as separate windows yet, so treat
|
|
// focus to be the same as being active.
|
|
if have_focus != runtime_window.active() {
|
|
runtime_window.set_active(have_focus);
|
|
runtime_window.set_focus(have_focus);
|
|
}
|
|
}
|
|
WindowEvent::KeyboardInput { ref input, .. } => {
|
|
// For now: Match Qt's behavior of mapping command to control and control to meta (LWin/RWin).
|
|
let key_code = input.virtual_keycode.map(|key_code| match key_code {
|
|
#[cfg(target_os = "macos")]
|
|
winit::event::VirtualKeyCode::LControl => winit::event::VirtualKeyCode::LWin,
|
|
#[cfg(target_os = "macos")]
|
|
winit::event::VirtualKeyCode::RControl => winit::event::VirtualKeyCode::RWin,
|
|
#[cfg(target_os = "macos")]
|
|
winit::event::VirtualKeyCode::LWin => winit::event::VirtualKeyCode::LControl,
|
|
#[cfg(target_os = "macos")]
|
|
winit::event::VirtualKeyCode::RWin => winit::event::VirtualKeyCode::RControl,
|
|
code @ _ => code,
|
|
});
|
|
window.currently_pressed_key_code().set(match input.state {
|
|
winit::event::ElementState::Pressed => key_code,
|
|
_ => None,
|
|
});
|
|
if let Some(text) = key_code.and_then(key_codes::winit_key_to_char).map(|ch| ch.into())
|
|
{
|
|
window.window().dispatch_event(match input.state {
|
|
winit::event::ElementState::Pressed => {
|
|
corelib::platform::WindowEvent::KeyPressed { text }
|
|
}
|
|
winit::event::ElementState::Released => {
|
|
corelib::platform::WindowEvent::KeyReleased { text }
|
|
}
|
|
});
|
|
};
|
|
}
|
|
WindowEvent::Ime(winit::event::Ime::Preedit(string, preedit_selection)) => {
|
|
let preedit_selection = preedit_selection.unwrap_or((0, 0));
|
|
let event = KeyInputEvent {
|
|
event_type: KeyEventType::UpdateComposition,
|
|
text: string.into(),
|
|
preedit_selection_start: preedit_selection.0,
|
|
preedit_selection_end: preedit_selection.1,
|
|
..Default::default()
|
|
};
|
|
runtime_window.process_key_input(event);
|
|
}
|
|
WindowEvent::Ime(winit::event::Ime::Commit(string)) => {
|
|
let event = KeyInputEvent {
|
|
event_type: KeyEventType::CommitComposition,
|
|
text: string.into(),
|
|
..Default::default()
|
|
};
|
|
runtime_window.process_key_input(event);
|
|
}
|
|
WindowEvent::CursorMoved { position, .. } => {
|
|
let position = position.to_logical(runtime_window.scale_factor() as f64);
|
|
*cursor_pos = euclid::point2(position.x, position.y);
|
|
runtime_window.process_mouse_input(MouseEvent::Moved { position: *cursor_pos });
|
|
}
|
|
WindowEvent::CursorLeft { .. } => {
|
|
// On the html canvas, we don't get the mouse move or release event when outside the canvas. So we have no choice but canceling the event
|
|
if cfg!(target_arch = "wasm32") || !*pressed {
|
|
*pressed = false;
|
|
runtime_window.process_mouse_input(MouseEvent::Exit);
|
|
}
|
|
}
|
|
WindowEvent::MouseWheel { delta, .. } => {
|
|
let (delta_x, delta_y) = match delta {
|
|
winit::event::MouseScrollDelta::LineDelta(lx, ly) => (lx * 60., ly * 60.),
|
|
winit::event::MouseScrollDelta::PixelDelta(d) => {
|
|
let d = d.to_logical(runtime_window.scale_factor() as f64);
|
|
(d.x, d.y)
|
|
}
|
|
};
|
|
runtime_window.process_mouse_input(MouseEvent::Wheel {
|
|
position: *cursor_pos,
|
|
delta_x,
|
|
delta_y,
|
|
});
|
|
}
|
|
WindowEvent::MouseInput { state, button, .. } => {
|
|
let button = match button {
|
|
winit::event::MouseButton::Left => PointerEventButton::Left,
|
|
winit::event::MouseButton::Right => PointerEventButton::Right,
|
|
winit::event::MouseButton::Middle => PointerEventButton::Middle,
|
|
winit::event::MouseButton::Other(_) => PointerEventButton::Other,
|
|
};
|
|
let ev = match state {
|
|
winit::event::ElementState::Pressed => {
|
|
*pressed = true;
|
|
MouseEvent::Pressed { position: *cursor_pos, button, click_count: 0 }
|
|
}
|
|
winit::event::ElementState::Released => {
|
|
*pressed = false;
|
|
MouseEvent::Released { position: *cursor_pos, button, click_count: 0 }
|
|
}
|
|
};
|
|
runtime_window.process_mouse_input(ev);
|
|
}
|
|
WindowEvent::Touch(touch) => {
|
|
let location = touch.location.to_logical(runtime_window.scale_factor() as f64);
|
|
let position = euclid::point2(location.x, location.y);
|
|
let ev = match touch.phase {
|
|
winit::event::TouchPhase::Started => {
|
|
*pressed = true;
|
|
MouseEvent::Pressed {
|
|
position,
|
|
button: PointerEventButton::Left,
|
|
click_count: 0,
|
|
}
|
|
}
|
|
winit::event::TouchPhase::Ended | winit::event::TouchPhase::Cancelled => {
|
|
*pressed = false;
|
|
MouseEvent::Released {
|
|
position,
|
|
button: PointerEventButton::Left,
|
|
click_count: 0,
|
|
}
|
|
}
|
|
winit::event::TouchPhase::Moved => MouseEvent::Moved { position },
|
|
};
|
|
runtime_window.process_mouse_input(ev);
|
|
}
|
|
WindowEvent::ScaleFactorChanged { scale_factor, new_inner_size: size } => {
|
|
if std::env::var("SLINT_SCALE_FACTOR").is_err() {
|
|
let size = size.to_logical(scale_factor);
|
|
runtime_window.set_window_item_geometry(LogicalSize::new(size.width, size.height));
|
|
runtime_window.set_scale_factor(scale_factor as f32);
|
|
}
|
|
}
|
|
WindowEvent::ThemeChanged(theme) => {
|
|
window.set_dark_color_scheme(theme == winit::window::Theme::Dark)
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
|
|
/// Runs the event loop and renders the items in the provided `component` in its
|
|
/// own window.
|
|
#[allow(unused_mut)] // mut need changes for wasm
|
|
pub fn run() -> Result<(), corelib::platform::PlatformError> {
|
|
use winit::event::Event;
|
|
use winit::event_loop::{ControlFlow, EventLoopWindowTarget};
|
|
|
|
let not_running_loop_instance = MAYBE_LOOP_INSTANCE.with(|loop_instance| {
|
|
loop_instance.borrow_mut().take().unwrap_or_else(NotRunningEventLoop::new)
|
|
});
|
|
|
|
let event_loop_proxy = not_running_loop_instance.event_loop_proxy;
|
|
#[cfg(not(target_arch = "wasm32"))]
|
|
GLOBAL_PROXY.get_or_init(Default::default).lock().unwrap().set_proxy(event_loop_proxy.clone());
|
|
#[cfg(target_arch = "wasm32")]
|
|
GLOBAL_PROXY.with(|global_proxy| {
|
|
global_proxy
|
|
.borrow_mut()
|
|
.get_or_insert_with(Default::default)
|
|
.set_proxy(event_loop_proxy.clone())
|
|
});
|
|
|
|
let mut winit_loop = not_running_loop_instance.instance;
|
|
let clipboard = not_running_loop_instance.clipboard;
|
|
|
|
// Applying the property values of the `Window` item in .slint files to the underlying winit Window
|
|
// may for example set the width but preserve the height of the window. Winit only knows the entire
|
|
// size, so we need to query the existing size via `inner_size()`. The timing of when to call `inner_size()`
|
|
// is important to avoid jitter as described in https://github.com/slint-ui/slint/issues/1269 . We want to
|
|
// process pending resize events first. That is why this vector collects the window ids of windows that
|
|
// we have scheduled for a sync between the `Window` item properties the the winit window, so that we
|
|
// apply them at `MainEventsCleared` time.
|
|
let mut windows_with_pending_property_updates = Vec::new();
|
|
// With winit on Windows and with wasm, calling winit::Window::request_redraw() will not always deliver an
|
|
// Event::RedrawRequested (for example when the mouse cursor is outside of the window). So when we get woken
|
|
// up by the event loop to process new events from the operating system (NewEvents), we take note of all windows
|
|
// that called request_redraw() since the last iteration and we will call draw() ourselves, unless they received
|
|
// an Event::RedrawRequested in this new iteration. This vector collects the window ids of windows with pending
|
|
// redraw requests in the beginning of the loop iteration, removes ids that are covered by a windowing system
|
|
// supplied Event::RedrawRequested, and drains them for drawing at RedrawEventsCleared.
|
|
let mut windows_with_pending_redraw_requests = Vec::new();
|
|
|
|
// last seen cursor position
|
|
let mut cursor_pos = LogicalPoint::default();
|
|
let mut pressed = false;
|
|
|
|
let mut run_fn = move |event: Event<CustomEvent>, control_flow: &mut ControlFlow| match event {
|
|
Event::WindowEvent { event, window_id } => {
|
|
if let Some(window) = window_by_id(window_id) {
|
|
process_window_event(window, event, &mut cursor_pos, &mut pressed);
|
|
};
|
|
}
|
|
|
|
Event::RedrawRequested(id) => {
|
|
if let Some(window) = window_by_id(id) {
|
|
if let Ok(pos) = windows_with_pending_redraw_requests.binary_search(&id) {
|
|
windows_with_pending_redraw_requests.remove(pos);
|
|
}
|
|
let redraw_requested_during_draw = window.draw();
|
|
if redraw_requested_during_draw {
|
|
// If during rendering a new redraw_request() was issued (for example in a rendering notifier callback), then
|
|
// pretend that an animation is running, so that we return Poll from the event loop to ensure a repaint as
|
|
// soon as possible.
|
|
*control_flow = ControlFlow::Poll;
|
|
}
|
|
}
|
|
}
|
|
|
|
Event::UserEvent(CustomEvent::UpdateWindowProperties(window_id)) => {
|
|
if let Err(insert_pos) = windows_with_pending_property_updates.binary_search(&window_id)
|
|
{
|
|
windows_with_pending_property_updates.insert(insert_pos, window_id);
|
|
}
|
|
}
|
|
Event::UserEvent(CustomEvent::WindowHidden) => {
|
|
if QUIT_ON_LAST_WINDOW_CLOSED.load(std::sync::atomic::Ordering::Relaxed) {
|
|
let window_count = ALL_WINDOWS.with(|windows| windows.borrow().len());
|
|
if window_count == 0 {
|
|
*control_flow = ControlFlow::Exit;
|
|
}
|
|
}
|
|
}
|
|
|
|
Event::UserEvent(CustomEvent::Exit) => {
|
|
*control_flow = ControlFlow::Exit;
|
|
}
|
|
|
|
Event::UserEvent(CustomEvent::UserEvent(user)) => {
|
|
user();
|
|
}
|
|
|
|
#[cfg(target_arch = "wasm32")]
|
|
Event::UserEvent(CustomEvent::WakeEventLoopWorkaround) => {
|
|
*control_flow = ControlFlow::Poll;
|
|
}
|
|
|
|
Event::NewEvents(_) => {
|
|
*control_flow = ControlFlow::Wait;
|
|
|
|
windows_with_pending_redraw_requests.clear();
|
|
ALL_WINDOWS.with(|windows| {
|
|
for (window_id, window_weak) in windows.borrow().iter() {
|
|
if window_weak.upgrade().map_or(false, |window| window.take_pending_redraw()) {
|
|
if let Err(insert_pos) =
|
|
windows_with_pending_redraw_requests.binary_search(window_id)
|
|
{
|
|
windows_with_pending_redraw_requests.insert(insert_pos, *window_id);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
corelib::platform::update_timers_and_animations();
|
|
}
|
|
|
|
Event::MainEventsCleared => {
|
|
for window in windows_with_pending_property_updates
|
|
.drain(..)
|
|
.filter_map(|window_id| window_by_id(window_id))
|
|
{
|
|
WindowInner::from_pub(window.window()).update_window_properties();
|
|
}
|
|
}
|
|
|
|
Event::RedrawEventsCleared => {
|
|
if *control_flow != ControlFlow::Exit
|
|
&& ALL_WINDOWS.with(|windows| {
|
|
windows.borrow().iter().any(|(_, w)| {
|
|
w.upgrade().map_or(false, |w| w.window().has_active_animations())
|
|
})
|
|
})
|
|
{
|
|
*control_flow = ControlFlow::Poll;
|
|
}
|
|
|
|
for window in windows_with_pending_redraw_requests
|
|
.drain(..)
|
|
.filter_map(|window_id| window_by_id(window_id))
|
|
{
|
|
let redraw_requested_during_draw = window.draw();
|
|
if redraw_requested_during_draw {
|
|
// If during rendering a new redraw_request() was issued (for example in a rendering notifier callback), then
|
|
// pretend that an animation is running, so that we return Poll from the event loop to ensure a repaint as
|
|
// soon as possible.
|
|
*control_flow = ControlFlow::Poll;
|
|
}
|
|
}
|
|
|
|
if *control_flow == ControlFlow::Wait {
|
|
if let Some(next_timer) = corelib::platform::duration_until_next_timer_update() {
|
|
*control_flow = ControlFlow::WaitUntil(instant::Instant::now() + next_timer);
|
|
}
|
|
}
|
|
}
|
|
|
|
_ => (),
|
|
};
|
|
|
|
#[cfg(not(target_arch = "wasm32"))]
|
|
{
|
|
winit_loop.run_return(
|
|
|event: Event<CustomEvent>,
|
|
event_loop_target: &EventLoopWindowTarget<CustomEvent>,
|
|
control_flow: &mut ControlFlow| {
|
|
let running_instance = RunningEventLoop {
|
|
event_loop_target,
|
|
event_loop_proxy: &event_loop_proxy,
|
|
clipboard: &clipboard,
|
|
};
|
|
CURRENT_WINDOW_TARGET.set(&running_instance, || run_fn(event, control_flow))
|
|
},
|
|
);
|
|
|
|
*GLOBAL_PROXY.get_or_init(Default::default).lock().unwrap() = Default::default();
|
|
|
|
// Keep the EventLoop instance alive and re-use it in future invocations of run_event_loop().
|
|
// Winit does not support creating multiple instances of the event loop.
|
|
let nre = NotRunningEventLoop { clipboard, instance: winit_loop, event_loop_proxy };
|
|
MAYBE_LOOP_INSTANCE.with(|loop_instance| *loop_instance.borrow_mut() = Some(nre));
|
|
Ok(())
|
|
}
|
|
|
|
#[cfg(target_arch = "wasm32")]
|
|
{
|
|
winit_loop.run(
|
|
move |event: Event<CustomEvent>,
|
|
event_loop_target: &EventLoopWindowTarget<CustomEvent>,
|
|
control_flow: &mut ControlFlow| {
|
|
let running_instance = RunningEventLoop {
|
|
event_loop_target,
|
|
event_loop_proxy: &event_loop_proxy,
|
|
clipboard: &clipboard,
|
|
};
|
|
CURRENT_WINDOW_TARGET.set(&running_instance, || run_fn(event, control_flow))
|
|
},
|
|
)
|
|
}
|
|
}
|
|
|
|
// This function is called when we receive a control character via WindowEvent::ReceivedCharacter and
|
|
// instead want to use the last virtual key code. That happens when for example pressing Ctrl+some_key
|
|
// on Windows/X11/Wayland. This function may be missing mappings, it's trying to cover what we may be
|
|
// getting when we're getting control character sequences.
|
|
fn winit_key_code_to_string(virtual_keycode: winit::event::VirtualKeyCode) -> Option<char> {
|
|
use winit::event::VirtualKeyCode;
|
|
Some(match virtual_keycode {
|
|
VirtualKeyCode::Key1 => '1',
|
|
VirtualKeyCode::Key2 => '2',
|
|
VirtualKeyCode::Key3 => '3',
|
|
VirtualKeyCode::Key4 => '4',
|
|
VirtualKeyCode::Key5 => '5',
|
|
VirtualKeyCode::Key6 => '6',
|
|
VirtualKeyCode::Key7 => '7',
|
|
VirtualKeyCode::Key8 => '8',
|
|
VirtualKeyCode::Key9 => '9',
|
|
VirtualKeyCode::Key0 => '0',
|
|
VirtualKeyCode::A => 'a',
|
|
VirtualKeyCode::B => 'b',
|
|
VirtualKeyCode::C => 'c',
|
|
VirtualKeyCode::D => 'd',
|
|
VirtualKeyCode::E => 'e',
|
|
VirtualKeyCode::F => 'f',
|
|
VirtualKeyCode::G => 'g',
|
|
VirtualKeyCode::H => 'h',
|
|
VirtualKeyCode::I => 'i',
|
|
VirtualKeyCode::J => 'j',
|
|
VirtualKeyCode::K => 'k',
|
|
VirtualKeyCode::L => 'l',
|
|
VirtualKeyCode::M => 'm',
|
|
VirtualKeyCode::N => 'n',
|
|
VirtualKeyCode::O => 'o',
|
|
VirtualKeyCode::P => 'p',
|
|
VirtualKeyCode::Q => 'q',
|
|
VirtualKeyCode::R => 'r',
|
|
VirtualKeyCode::S => 's',
|
|
VirtualKeyCode::T => 't',
|
|
VirtualKeyCode::U => 'u',
|
|
VirtualKeyCode::V => 'v',
|
|
VirtualKeyCode::W => 'w',
|
|
VirtualKeyCode::X => 'x',
|
|
VirtualKeyCode::Y => 'y',
|
|
VirtualKeyCode::Z => 'z',
|
|
VirtualKeyCode::Space => ' ',
|
|
VirtualKeyCode::Caret => '^',
|
|
VirtualKeyCode::Apostrophe => '\'',
|
|
VirtualKeyCode::Asterisk => '*',
|
|
VirtualKeyCode::Backslash => '\\',
|
|
VirtualKeyCode::Colon => ':',
|
|
VirtualKeyCode::Comma => ',',
|
|
VirtualKeyCode::Equals => '=',
|
|
VirtualKeyCode::Grave => '`',
|
|
VirtualKeyCode::Minus => '-',
|
|
VirtualKeyCode::Period => '.',
|
|
VirtualKeyCode::Plus => '+',
|
|
VirtualKeyCode::Semicolon => ';',
|
|
VirtualKeyCode::Slash => '/',
|
|
VirtualKeyCode::Tab => '\t',
|
|
_ => return None,
|
|
})
|
|
}
|
|
|
|
fn create_clipboard<T>(_event_loop: &winit::event_loop::EventLoopWindowTarget<T>) -> ClipboardPair {
|
|
// Provide a truly silent no-op clipboard context, as copypasta's NoopClipboard spams stdout with
|
|
// println.
|
|
struct SilentClipboardContext;
|
|
impl copypasta::ClipboardProvider for SilentClipboardContext {
|
|
fn get_contents(
|
|
&mut self,
|
|
) -> Result<String, Box<dyn std::error::Error + Send + Sync + 'static>> {
|
|
Ok(Default::default())
|
|
}
|
|
|
|
fn set_contents(
|
|
&mut self,
|
|
_: String,
|
|
) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
cfg_if::cfg_if! {
|
|
if #[cfg(all(
|
|
unix,
|
|
not(any(
|
|
target_os = "macos",
|
|
target_os = "android",
|
|
target_os = "ios",
|
|
target_os = "emscripten"
|
|
))
|
|
))]
|
|
{
|
|
#[cfg(feature = "wayland")]
|
|
if let Some(wayland_display) =
|
|
winit::platform::wayland::EventLoopWindowTargetExtWayland::wayland_display(_event_loop)
|
|
{
|
|
let clipboard = unsafe {
|
|
copypasta::wayland_clipboard::create_clipboards_from_external(wayland_display)
|
|
};
|
|
return (Box::new(clipboard.1), Box::new(clipboard.0));
|
|
};
|
|
#[cfg(feature = "x11")]
|
|
{
|
|
use copypasta::x11_clipboard::{X11ClipboardContext, Primary, Clipboard};
|
|
let prim = X11ClipboardContext::<Primary>::new()
|
|
.map_or(
|
|
Box::new(SilentClipboardContext) as Box<dyn ClipboardProvider>,
|
|
|x| Box::new(x) as Box<dyn ClipboardProvider>,
|
|
);
|
|
let sec = X11ClipboardContext::<Clipboard>::new()
|
|
.map_or(
|
|
Box::new(SilentClipboardContext) as Box<dyn ClipboardProvider>,
|
|
|x| Box::new(x) as Box<dyn ClipboardProvider>,
|
|
);
|
|
(sec, prim)
|
|
}
|
|
#[cfg(not(feature = "x11"))]
|
|
(Box::new(NopClipboardContext), Box::new(NopClipboardContext))
|
|
} else {
|
|
(
|
|
copypasta::ClipboardContext::new().map_or(
|
|
Box::new(SilentClipboardContext) as Box<dyn ClipboardProvider>,
|
|
|x| Box::new(x) as Box<dyn ClipboardProvider>,
|
|
),
|
|
Box::new(SilentClipboardContext),
|
|
)
|
|
}
|
|
}
|
|
}
|