leyoda/winit
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Rename internal structs for consistency (#2149)

Browse source 
Proxy -> EventLoopProxy
Id -> WindowId or DeviceId
WindowTarget -> EventLoopWindowTarget
Handle -> MonitorHandle
Mode -> VideoMode
PlatformSpecificBuilderAttributes -> PlatformSpecificWindowBuilderAttributes
SuperWindowId -> RootWindowId
This commit is contained in:
Mads Marquart 2022-03-18 14:09:39 +01:00 • committed by GitHub
parent 85baf79d17
commit a438091266
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
12 changed files with 134 additions and 135 deletions
Download patch file Download diff file Expand all files Collapse all files

20
src/platform_impl/web/event_loop/mod.rs
View file

@ -3,17 +3,17 @@ mod runner;
mod state;
mod window_target;
pub use self::proxy::Proxy;
pub use self::window_target::WindowTarget;
pub use self::proxy::EventLoopProxy;
pub use self::window_target::EventLoopWindowTarget;
use super::{backend, device, window};
use crate::event::Event;
use crate::event_loop as root;
use crate::event_loop::{ControlFlow, EventLoopWindowTarget as RootEventLoopWindowTarget};
use std::marker::PhantomData;
pub struct EventLoop<T: 'static> {
elw: root::EventLoopWindowTarget<T>,
elw: RootEventLoopWindowTarget<T>,
}
#[derive(Default, Debug, Copy, Clone, PartialEq, Hash)]
@ -22,8 +22,8 @@ pub(crate) struct PlatformSpecificEventLoopAttributes {}
impl<T> EventLoop<T> {
pub(crate) fn new(_: &PlatformSpecificEventLoopAttributes) -> Self {
EventLoop {
elw: root::EventLoopWindowTarget {
p: WindowTarget::new(),
elw: RootEventLoopWindowTarget {
p: EventLoopWindowTarget::new(),
_marker: PhantomData,
},
}
@ -31,9 +31,9 @@ impl<T> EventLoop<T> {
pub fn run<F>(self, mut event_handler: F) -> !
where
F: 'static + FnMut(Event<'_, T>, &root::EventLoopWindowTarget<T>, &mut root::ControlFlow),
F: 'static + FnMut(Event<'_, T>, &RootEventLoopWindowTarget<T>, &mut ControlFlow),
{
let target = root::EventLoopWindowTarget {
let target = RootEventLoopWindowTarget {
p: self.elw.p.clone(),
_marker: PhantomData,
};
@ -51,11 +51,11 @@ impl<T> EventLoop<T> {
unreachable!();
}
pub fn create_proxy(&self) -> Proxy<T> {
pub fn create_proxy(&self) -> EventLoopProxy<T> {
self.elw.p.proxy()
}
pub fn window_target(&self) -> &root::EventLoopWindowTarget<T> {
pub fn window_target(&self) -> &RootEventLoopWindowTarget<T> {
&self.elw
}
}

10
src/platform_impl/web/event_loop/proxy.rs
View file

@ -2,13 +2,13 @@ use super::runner;
use crate::event::Event;
use crate::event_loop::EventLoopClosed;
pub struct Proxy<T: 'static> {
pub struct EventLoopProxy<T: 'static> {
runner: runner::Shared<T>,
}
impl<T: 'static> Proxy<T> {
impl<T: 'static> EventLoopProxy<T> {
pub fn new(runner: runner::Shared<T>) -> Self {
Proxy { runner }
Self { runner }
}
pub fn send_event(&self, event: T) -> Result<(), EventLoopClosed<T>> {
@ -17,9 +17,9 @@ impl<T: 'static> Proxy<T> {
}
}
impl<T: 'static> Clone for Proxy<T> {
impl<T: 'static> Clone for EventLoopProxy<T> {
fn clone(&self) -> Self {
Proxy {
Self {
runner: self.runner.clone(),
}
}

49
src/platform_impl/web/event_loop/runner.rs
View file

@ -1,6 +1,6 @@
use super::{super::ScaleChangeArgs, backend, state::State};
use crate::event::{Event, StartCause};
use crate::event_loop as root;
use crate::event_loop::ControlFlow;
use crate::window::WindowId;
use instant::{Duration, Instant};
@ -54,11 +54,11 @@ impl<T: 'static> RunnerEnum<T> {
struct Runner<T: 'static> {
state: State,
event_handler: Box<dyn FnMut(Event<'_, T>, &mut root::ControlFlow)>,
event_handler: Box<dyn FnMut(Event<'_, T>, &mut ControlFlow)>,
}
impl<T: 'static> Runner<T> {
pub fn new(event_handler: Box<dyn FnMut(Event<'_, T>, &mut root::ControlFlow)>) -> Self {
pub fn new(event_handler: Box<dyn FnMut(Event<'_, T>, &mut ControlFlow)>) -> Self {
Runner {
state: State::Init,
event_handler,
@ -83,14 +83,14 @@ impl<T: 'static> Runner<T> {
})
}
fn handle_single_event(&mut self, event: Event<'_, T>, control: &mut root::ControlFlow) {
let is_closed = matches!(*control, root::ControlFlow::ExitWithCode(_));
fn handle_single_event(&mut self, event: Event<'_, T>, control: &mut ControlFlow) {
let is_closed = matches!(*control, ControlFlow::ExitWithCode(_));
(self.event_handler)(event, control);
// Maintain closed state, even if the callback changes it
if is_closed {
*control = root::ControlFlow::Exit;
*control = ControlFlow::Exit;
}
}
}
@ -123,10 +123,7 @@ impl<T: 'static> Shared<T> {
// Set the event callback to use for the event loop runner
// This the event callback is a fairly thin layer over the user-provided callback that closes
// over a RootEventLoopWindowTarget reference
pub fn set_listener(
&self,
event_handler: Box<dyn FnMut(Event<'_, T>, &mut root::ControlFlow)>,
) {
pub fn set_listener(&self, event_handler: Box<dyn FnMut(Event<'_, T>, &mut ControlFlow)>) {
{
let mut runner = self.0.runner.borrow_mut();
assert!(matches!(*runner, RunnerEnum::Pending));
@ -245,7 +242,7 @@ impl<T: 'static> Shared<T> {
// Process the destroy-pending windows. This should only be called from
// `run_until_cleared` and `handle_scale_changed`, somewhere between emitting
// `NewEvents` and `MainEventsCleared`.
fn process_destroy_pending_windows(&self, control: &mut root::ControlFlow) {
fn process_destroy_pending_windows(&self, control: &mut ControlFlow) {
while let Some(id) = self.0.destroy_pending.borrow_mut().pop_front() {
self.0
.all_canvases
@ -369,7 +366,7 @@ impl<T: 'static> Shared<T> {
}
fn handle_unload(&self) {
self.apply_control_flow(root::ControlFlow::Exit);
self.apply_control_flow(ControlFlow::Exit);
let mut control = self.current_control_flow();
// We don't call `handle_loop_destroyed` here because we don't need to
// perform cleanup when the web browser is going to destroy the page.
@ -379,9 +376,9 @@ impl<T: 'static> Shared<T> {
// handle_single_event_sync takes in an event and handles it synchronously.
//
// It should only ever be called from `scale_changed`.
fn handle_single_event_sync(&self, event: Event<'_, T>, control: &mut root::ControlFlow) {
fn handle_single_event_sync(&self, event: Event<'_, T>, control: &mut ControlFlow) {
if self.is_closed() {
*control = root::ControlFlow::Exit;
*control = ControlFlow::Exit;
}
match *self.0.runner.borrow_mut() {
RunnerEnum::Running(ref mut runner) => {
@ -394,9 +391,9 @@ impl<T: 'static> Shared<T> {
// handle_event takes in events and either queues them or applies a callback
//
// It should only ever be called from `run_until_cleared` and `scale_changed`.
fn handle_event(&self, event: Event<'static, T>, control: &mut root::ControlFlow) {
fn handle_event(&self, event: Event<'static, T>, control: &mut ControlFlow) {
if self.is_closed() {
*control = root::ControlFlow::Exit;
*control = ControlFlow::Exit;
}
match *self.0.runner.borrow_mut() {
RunnerEnum::Running(ref mut runner) => {
@ -409,7 +406,7 @@ impl<T: 'static> Shared<T> {
RunnerEnum::Destroyed => return,
}
let is_closed = matches!(*control, root::ControlFlow::ExitWithCode(_));
let is_closed = matches!(*control, ControlFlow::ExitWithCode(_));
// Don't take events out of the queue if the loop is closed or the runner doesn't exist
// If the runner doesn't exist and this method recurses, it will recurse infinitely
@ -425,18 +422,18 @@ impl<T: 'static> Shared<T> {
// Apply the new ControlFlow that has been selected by the user
// Start any necessary timeouts etc
fn apply_control_flow(&self, control_flow: root::ControlFlow) {
fn apply_control_flow(&self, control_flow: ControlFlow) {
let new_state = match control_flow {
root::ControlFlow::Poll => {
ControlFlow::Poll => {
let cloned = self.clone();
State::Poll {
request: backend::AnimationFrameRequest::new(move || cloned.poll()),
}
}
root::ControlFlow::Wait => State::Wait {
ControlFlow::Wait => State::Wait {
start: Instant::now(),
},
root::ControlFlow::WaitUntil(end) => {
ControlFlow::WaitUntil(end) => {
let start = Instant::now();
let delay = if end <= start {
@ -456,7 +453,7 @@ impl<T: 'static> Shared<T> {
),
}
}
root::ControlFlow::ExitWithCode(_) => State::Exit,
ControlFlow::ExitWithCode(_) => State::Exit,
};
match *self.0.runner.borrow_mut() {
@ -467,7 +464,7 @@ impl<T: 'static> Shared<T> {
}
}
fn handle_loop_destroyed(&self, control: &mut root::ControlFlow) {
fn handle_loop_destroyed(&self, control: &mut ControlFlow) {
self.handle_event(Event::LoopDestroyed, control);
let all_canvases = std::mem::take(&mut *self.0.all_canvases.borrow_mut());
*self.0.scale_change_detector.borrow_mut() = None;
@ -510,11 +507,11 @@ impl<T: 'static> Shared<T> {
}
// Get the current control flow state
fn current_control_flow(&self) -> root::ControlFlow {
fn current_control_flow(&self) -> ControlFlow {
match *self.0.runner.borrow() {
RunnerEnum::Running(ref runner) => runner.state.control_flow(),
RunnerEnum::Pending => root::ControlFlow::Poll,
RunnerEnum::Destroyed => root::ControlFlow::Exit,
RunnerEnum::Pending => ControlFlow::Poll,
RunnerEnum::Destroyed => ControlFlow::Exit,
}
}
}

86
src/platform_impl/web/event_loop/window_target.rs
View file

@ -1,37 +1,41 @@
use super::{super::monitor, backend, device, proxy::Proxy, runner, window};
use super::{
super::monitor::MonitorHandle, backend, device::DeviceId, proxy::EventLoopProxy, runner,
window::WindowId,
};
use crate::dpi::{PhysicalSize, Size};
use crate::event::{
DeviceEvent, DeviceId, ElementState, Event, KeyboardInput, TouchPhase, WindowEvent,
DeviceEvent, DeviceId as RootDeviceId, ElementState, Event, KeyboardInput, TouchPhase,
WindowEvent,
};
use crate::event_loop::ControlFlow;
use crate::monitor::MonitorHandle as RootMH;
use crate::window::{Theme, WindowId};
use crate::window::{Theme, WindowId as RootWindowId};
use std::cell::RefCell;
use std::clone::Clone;
use std::collections::{vec_deque::IntoIter as VecDequeIter, VecDeque};
use std::rc::Rc;
pub struct WindowTarget<T: 'static> {
pub struct EventLoopWindowTarget<T: 'static> {
pub(crate) runner: runner::Shared<T>,
}
impl<T> Clone for WindowTarget<T> {
impl<T> Clone for EventLoopWindowTarget<T> {
fn clone(&self) -> Self {
WindowTarget {
Self {
runner: self.runner.clone(),
}
}
}
impl<T> WindowTarget<T> {
impl<T> EventLoopWindowTarget<T> {
pub fn new() -> Self {
WindowTarget {
Self {
runner: runner::Shared::new(),
}
}
pub fn proxy(&self) -> Proxy<T> {
Proxy::new(self.runner.clone())
pub fn proxy(&self) -> EventLoopProxy<T> {
EventLoopProxy::new(self.runner.clone())
}
pub fn run(&self, event_handler: Box<dyn FnMut(Event<'_, T>, &mut ControlFlow)>) {
@ -42,19 +46,19 @@ impl<T> WindowTarget<T> {
});
}
pub fn generate_id(&self) -> window::Id {
window::Id(self.runner.generate_id())
pub fn generate_id(&self) -> WindowId {
WindowId(self.runner.generate_id())
}
pub fn register(&self, canvas: &Rc<RefCell<backend::Canvas>>, id: window::Id) {
self.runner.add_canvas(WindowId(id), canvas);
pub fn register(&self, canvas: &Rc<RefCell<backend::Canvas>>, id: WindowId) {
self.runner.add_canvas(RootWindowId(id), canvas);
let mut canvas = canvas.borrow_mut();
canvas.set_attribute("data-raw-handle", &id.0.to_string());
let runner = self.runner.clone();
canvas.on_blur(move || {
runner.send_event(Event::WindowEvent {
window_id: WindowId(id),
window_id: RootWindowId(id),
event: WindowEvent::Focused(false),
});
});
@ -62,7 +66,7 @@ impl<T> WindowTarget<T> {
let runner = self.runner.clone();
canvas.on_focus(move || {
runner.send_event(Event::WindowEvent {
window_id: WindowId(id),
window_id: RootWindowId(id),
event: WindowEvent::Focused(true),
});
});
@ -71,9 +75,9 @@ impl<T> WindowTarget<T> {
canvas.on_keyboard_press(move |scancode, virtual_keycode, modifiers| {
#[allow(deprecated)]
runner.send_event(Event::WindowEvent {
window_id: WindowId(id),
window_id: RootWindowId(id),
event: WindowEvent::KeyboardInput {
device_id: DeviceId(unsafe { device::Id::dummy() }),
device_id: RootDeviceId(unsafe { DeviceId::dummy() }),
input: KeyboardInput {
scancode,
state: ElementState::Pressed,
@ -89,9 +93,9 @@ impl<T> WindowTarget<T> {
canvas.on_keyboard_release(move |scancode, virtual_keycode, modifiers| {
#[allow(deprecated)]
runner.send_event(Event::WindowEvent {
window_id: WindowId(id),
window_id: RootWindowId(id),
event: WindowEvent::KeyboardInput {
device_id: DeviceId(unsafe { device::Id::dummy() }),
device_id: RootDeviceId(unsafe { DeviceId::dummy() }),
input: KeyboardInput {
scancode,
state: ElementState::Released,
@ -106,7 +110,7 @@ impl<T> WindowTarget<T> {
let runner = self.runner.clone();
canvas.on_received_character(move |char_code| {
runner.send_event(Event::WindowEvent {
window_id: WindowId(id),
window_id: RootWindowId(id),
event: WindowEvent::ReceivedCharacter(char_code),
});
});
@ -114,9 +118,9 @@ impl<T> WindowTarget<T> {
let runner = self.runner.clone();
canvas.on_cursor_leave(move |pointer_id| {
runner.send_event(Event::WindowEvent {
window_id: WindowId(id),
window_id: RootWindowId(id),
event: WindowEvent::CursorLeft {
device_id: DeviceId(device::Id(pointer_id)),
device_id: RootDeviceId(DeviceId(pointer_id)),
},
});
});
@ -124,9 +128,9 @@ impl<T> WindowTarget<T> {
let runner = self.runner.clone();
canvas.on_cursor_enter(move |pointer_id| {
runner.send_event(Event::WindowEvent {
window_id: WindowId(id),
window_id: RootWindowId(id),
event: WindowEvent::CursorEntered {
device_id: DeviceId(device::Id(pointer_id)),
device_id: RootDeviceId(DeviceId(pointer_id)),
},
});
});
@ -134,15 +138,15 @@ impl<T> WindowTarget<T> {
let runner = self.runner.clone();
canvas.on_cursor_move(move |pointer_id, position, delta, modifiers| {
runner.send_event(Event::WindowEvent {
window_id: WindowId(id),
window_id: RootWindowId(id),
event: WindowEvent::CursorMoved {
device_id: DeviceId(device::Id(pointer_id)),
device_id: RootDeviceId(DeviceId(pointer_id)),
position,
modifiers,
},
});
runner.send_event(Event::DeviceEvent {
device_id: DeviceId(device::Id(pointer_id)),
device_id: RootDeviceId(DeviceId(pointer_id)),
event: DeviceEvent::MouseMotion {
delta: (delta.x, delta.y),
},
@ -156,17 +160,17 @@ impl<T> WindowTarget<T> {
// user code has the correct cursor position.
runner.send_events(
std::iter::once(Event::WindowEvent {
window_id: WindowId(id),
window_id: RootWindowId(id),
event: WindowEvent::CursorMoved {
device_id: DeviceId(device::Id(pointer_id)),
device_id: RootDeviceId(DeviceId(pointer_id)),
position,
modifiers,
},
})
.chain(std::iter::once(Event::WindowEvent {
window_id: WindowId(id),
window_id: RootWindowId(id),
event: WindowEvent::MouseInput {
device_id: DeviceId(device::Id(pointer_id)),
device_id: RootDeviceId(DeviceId(pointer_id)),
state: ElementState::Pressed,
button,
modifiers,
@ -178,9 +182,9 @@ impl<T> WindowTarget<T> {
let runner = self.runner.clone();
canvas.on_mouse_release(move |pointer_id, button, modifiers| {
runner.send_event(Event::WindowEvent {
window_id: WindowId(id),
window_id: RootWindowId(id),
event: WindowEvent::MouseInput {
device_id: DeviceId(device::Id(pointer_id)),
device_id: RootDeviceId(DeviceId(pointer_id)),
state: ElementState::Released,
button,
modifiers,
@ -191,9 +195,9 @@ impl<T> WindowTarget<T> {
let runner = self.runner.clone();
canvas.on_mouse_wheel(move |pointer_id, delta, modifiers| {
runner.send_event(Event::WindowEvent {
window_id: WindowId(id),
window_id: RootWindowId(id),
event: WindowEvent::MouseWheel {
device_id: DeviceId(device::Id(pointer_id)),
device_id: RootDeviceId(DeviceId(pointer_id)),
delta,
phase: TouchPhase::Moved,
modifiers,
@ -225,10 +229,10 @@ impl<T> WindowTarget<T> {
backend::set_canvas_size(&raw, Size::Physical(new_size));
runner.send_event(Event::WindowEvent {
window_id: WindowId(id),
window_id: RootWindowId(id),
event: WindowEvent::Resized(new_size),
});
runner.request_redraw(WindowId(id));
runner.request_redraw(RootWindowId(id));
});
let runner = self.runner.clone();
@ -239,19 +243,19 @@ impl<T> WindowTarget<T> {
Theme::Light
};
runner.send_event(Event::WindowEvent {
window_id: WindowId(id),
window_id: RootWindowId(id),
event: WindowEvent::ThemeChanged(theme),
});
});
}
pub fn available_monitors(&self) -> VecDequeIter<monitor::Handle> {
pub fn available_monitors(&self) -> VecDequeIter<MonitorHandle> {
VecDeque::new().into_iter()
}
pub fn primary_monitor(&self) -> Option<RootMH> {
Some(RootMH {
inner: monitor::Handle,
inner: MonitorHandle,
})
}
}