migrations/winit
1
0
Fork 0
mirror of https://github.com/rust-windowing/winit.git synced 2026-06-26 22:53:15 -04:00
Code Issues Packages Projects Releases Wiki Activity

Change instances of "events_loop" to "event_loop"

Browse Source
This commit is contained in:
Osspial
2018-08-23 20:16:52 -04:00
parent 0f34408763
commit 8d8d9b7cd1
34 changed files with 137 additions and 116 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
examples/cursor.rs
View File

@@ -5,14 +5,14 @@ use winit::event::{Event, WindowEvent, ElementState, KeyboardInput};
use winit::event_loop::{EventLoop, ControlFlow};
fn main() {
let events_loop = EventLoop::new();
let event_loop = EventLoop::new();
let window = WindowBuilder::new().build(&events_loop).unwrap();
let window = WindowBuilder::new().build(&event_loop).unwrap();
window.set_title("A fantastic window!");
let mut cursor_idx = 0;
events_loop.run(move |event, _, control_flow| {
event_loop.run(move |event, _, control_flow| {
match event {
Event::WindowEvent { event: WindowEvent::KeyboardInput { input: KeyboardInput { state: ElementState::Pressed, .. }, .. }, .. } => {
println!("Setting cursor to \"{:?}\"", CURSORS[cursor_idx]);

6
examples/cursor_grab.rs
View File

@@ -5,14 +5,14 @@ use winit::event::{Event, WindowEvent, ElementState, KeyboardInput};
use winit::event_loop::{EventLoop, ControlFlow};
fn main() {
let events_loop = EventLoop::new();
let event_loop = EventLoop::new();
let window = WindowBuilder::new()
.with_title("Super Cursor Grab'n'Hide Simulator 9000")
.build(&events_loop)
.build(&event_loop)
.unwrap();
events_loop.run(move |event, _, control_flow| {
event_loop.run(move |event, _, control_flow| {
*control_flow = ControlFlow::Wait;
if let Event::WindowEvent { event, .. } = event {
match event {

10
examples/fullscreen.rs
View File

@@ -6,11 +6,11 @@ use winit::event::{Event, WindowEvent, VirtualKeyCode, ElementState, KeyboardInp
use winit::event_loop::{EventLoop, ControlFlow};
fn main() {
let events_loop = EventLoop::new();
let event_loop = EventLoop::new();
// enumerating monitors
let monitor = {
for (num, monitor) in events_loop.get_available_monitors().enumerate() {
for (num, monitor) in event_loop.get_available_monitors().enumerate() {
println!("Monitor #{}: {:?}", num, monitor.get_name());
}
@@ -20,7 +20,7 @@ fn main() {
let mut num = String::new();
io::stdin().read_line(&mut num).unwrap();
let num = num.trim().parse().ok().expect("Please enter a number");
let monitor = events_loop.get_available_monitors().nth(num).expect("Please enter a valid ID");
let monitor = event_loop.get_available_monitors().nth(num).expect("Please enter a valid ID");
println!("Using {:?}", monitor.get_name());
@@ -30,14 +30,14 @@ fn main() {
let window = WindowBuilder::new()
.with_title("Hello world!")
.with_fullscreen(Some(monitor))
.build(&events_loop)
.build(&event_loop)
.unwrap();
let mut is_fullscreen = true;
let mut is_maximized = false;
let mut decorations = true;
events_loop.run(move |event, _, control_flow| {
event_loop.run(move |event, _, control_flow| {
println!("{:?}", event);
*control_flow = ControlFlow::Wait;

6
examples/handling_close.rs
View File

@@ -5,16 +5,16 @@ use winit::event::{Event, WindowEvent, KeyboardInput};
use winit::event_loop::{EventLoop, ControlFlow};
fn main() {
let events_loop = EventLoop::new();
let event_loop = EventLoop::new();
let _window = WindowBuilder::new()
.with_title("Your faithful window")
.build(&events_loop)
.build(&event_loop)
.unwrap();
let mut close_requested = false;
events_loop.run(move |event, _, control_flow| {
event_loop.run(move |event, _, control_flow| {
use winit::event::ElementState::Released;
use winit::event::VirtualKeyCode::{N, Y};

6
examples/min_max_size.rs
View File

@@ -6,16 +6,16 @@ use winit::event::{Event, WindowEvent};
use winit::event_loop::{EventLoop, ControlFlow};
fn main() {
let events_loop = EventLoop::new();
let event_loop = EventLoop::new();
let window = WindowBuilder::new()
.build(&events_loop)
.build(&event_loop)
.unwrap();
window.set_min_dimensions(Some(LogicalSize::new(400.0, 200.0)));
window.set_max_dimensions(Some(LogicalSize::new(800.0, 400.0)));
events_loop.run(move |event, _, control_flow| {
event_loop.run(move |event, _, control_flow| {
println!("{:?}", event);
match event {

8
examples/multiwindow.rs
View File

@@ -6,15 +6,15 @@ use winit::event::{Event, WindowEvent, ElementState, KeyboardInput};
use winit::event_loop::{EventLoop, ControlFlow};
fn main() {
let events_loop = EventLoop::new();
let event_loop = EventLoop::new();
let mut windows = HashMap::new();
for _ in 0..3 {
let window = Window::new(&events_loop).unwrap();
let window = Window::new(&event_loop).unwrap();
windows.insert(window.id(), window);
}
events_loop.run(move |event, events_loop, control_flow| {
event_loop.run(move |event, event_loop, control_flow| {
*control_flow = ControlFlow::Wait;
match event {
Event::WindowEvent { event, window_id } => {
@@ -30,7 +30,7 @@ fn main() {
}
},
WindowEvent::KeyboardInput { input: KeyboardInput { state: ElementState::Pressed, .. }, .. } => {
let window = Window::new(&events_loop).unwrap();
let window = Window::new(&event_loop).unwrap();
windows.insert(window.id(), window);
},
_ => ()

10
examples/proxy.rs
View File

@@ -4,18 +4,18 @@ use winit::event::{Event, WindowEvent};
use winit::event_loop::{EventLoop, ControlFlow};
fn main() {
let events_loop: EventLoop<i32> = EventLoop::new_user_event();
let event_loop: EventLoop<i32> = EventLoop::new_user_event();
let _window = WindowBuilder::new()
.with_title("A fantastic window!")
.build(&events_loop)
.build(&event_loop)
.unwrap();
let proxy = events_loop.create_proxy();
let proxy = event_loop.create_proxy();
std::thread::spawn(move || {
let mut counter = 0;
// Wake up the `events_loop` once every second.
// Wake up the `event_loop` once every second.
loop {
std::thread::sleep(std::time::Duration::from_secs(1));
proxy.send_event(counter).unwrap();
@@ -23,7 +23,7 @@ fn main() {
}
});
events_loop.run(move |event, _, control_flow| {
event_loop.run(move |event, _, control_flow| {
println!("{:?}", event);
match event {
Event::WindowEvent { event: WindowEvent::CloseRequested, .. } =>

6
examples/request_redraw.rs
View File

@@ -6,14 +6,14 @@ use winit::event::{Event, WindowEvent};
use winit::event_loop::{EventLoop, ControlFlow};
fn main() {
let events_loop = EventLoop::new();
let event_loop = EventLoop::new();
let window = WindowBuilder::new()
.with_title("A fantastic window!")
.build(&events_loop)
.build(&event_loop)
.unwrap();
events_loop.run(move |event, _, control_flow| {
event_loop.run(move |event, _, control_flow| {
println!("{:?}", event);
match event {

6
examples/resizable.rs
View File

@@ -4,7 +4,7 @@ use winit::event::{Event, WindowEvent, VirtualKeyCode, ElementState, KeyboardInp
use winit::event_loop::{EventLoop, ControlFlow};
fn main() {
let events_loop = EventLoop::new();
let event_loop = EventLoop::new();
let mut resizable = false;
@@ -12,10 +12,10 @@ fn main() {
.with_title("Hit space to toggle resizability.")
.with_dimensions((400, 200).into())
.with_resizable(resizable)
.build(&events_loop)
.build(&event_loop)
.unwrap();
events_loop.run(move |event, _, control_flow| {
event_loop.run(move |event, _, control_flow| {
*control_flow = ControlFlow::Wait;
match event {
Event::WindowEvent { event, .. } => match event {

6
examples/timer.rs
View File

@@ -5,14 +5,14 @@ use winit::event::{Event, WindowEvent, StartCause};
use winit::event_loop::{EventLoop, ControlFlow};
fn main() {
let events_loop = EventLoop::new();
let event_loop = EventLoop::new();
let _window = WindowBuilder::new()
.with_title("A fantastic window!")
.build(&events_loop)
.build(&event_loop)
.unwrap();
events_loop.run(move |event, _, control_flow| {
event_loop.run(move |event, _, control_flow| {
println!("{:?}", event);
match event {

6
examples/transparent.rs
View File

@@ -4,15 +4,15 @@ use winit::event::{Event, WindowEvent};
use winit::event_loop::{EventLoop, ControlFlow};
fn main() {
let events_loop = EventLoop::new();
let event_loop = EventLoop::new();
let window = WindowBuilder::new().with_decorations(false)
.with_transparency(true)
.build(&events_loop).unwrap();
.build(&event_loop).unwrap();
window.set_title("A fantastic window!");
events_loop.run(move |event, _, control_flow| {
event_loop.run(move |event, _, control_flow| {
println!("{:?}", event);
match event {

6
examples/window.rs
View File

@@ -4,14 +4,14 @@ use winit::event::{Event, WindowEvent};
use winit::event_loop::{EventLoop, ControlFlow};
fn main() {
let events_loop = EventLoop::new();
let event_loop = EventLoop::new();
let _window = WindowBuilder::new()
.with_title("A fantastic window!")
.build(&events_loop)
.build(&event_loop)
.unwrap();
events_loop.run(|event, _, control_flow| {
event_loop.run(|event, _, control_flow| {
println!("{:?}", event);
match event {

6
examples/window_icon.rs
View File

@@ -23,17 +23,17 @@ fn main() {
// feature enabled).
let icon = Icon::from_path(path).expect("Failed to open icon");
let events_loop = EventLoop::new();
let event_loop = EventLoop::new();
let window = WindowBuilder::new()
.with_title("An iconic window!")
// At present, this only does anything on Windows and X11, so if you want to save load
// time, you can put icon loading behind a function that returns `None` on other platforms.
.with_window_icon(Some(icon))
.build(&events_loop)
.build(&event_loop)
.unwrap();
events_loop.run(move |event, _, control_flow| {
event_loop.run(move |event, _, control_flow| {
*control_flow = ControlFlow::Wait;
if let Event::WindowEvent { event, .. } = event {
use winit::event::WindowEvent::*;

10
examples/window_run_return.rs
View File

@@ -6,15 +6,15 @@ use winit::event_loop::{EventLoop, ControlFlow};
use winit::platform::desktop::EventLoopExtDesktop;
fn main() {
let mut events_loop = EventLoop::new();
let mut event_loop = EventLoop::new();
let window = WindowBuilder::new()
.with_title("A fantastic window!")
.build(&events_loop)
.build(&event_loop)
.unwrap();
println!("Close the window to continue.");
events_loop.run_return(|event, _, control_flow| {
event_loop.run_return(|event, _, control_flow| {
match event {
Event::WindowEvent {
event: WindowEvent::CloseRequested,
@@ -27,11 +27,11 @@ fn main() {
let _window_2 = WindowBuilder::new()
.with_title("A second, fantasticer window!")
.build(&events_loop)
.build(&event_loop)
.unwrap();
println!("Wa ha ha! You thought that closing the window would finish this?!");
events_loop.run_return(|event, _, control_flow| {
event_loop.run_return(|event, _, control_flow| {
match event {
Event::WindowEvent {
event: WindowEvent::CloseRequested,

16
src/event_loop.rs
View File

@@ -30,7 +30,7 @@ use monitor::{AvailableMonitorsIter, MonitorId};
/// `Window` created from this `EventLoop` _can_ be sent to an other thread, and the
/// `EventLoopProxy` allows you to wakeup an `EventLoop` from an other thread.
pub struct EventLoop<T> {
pub(crate) events_loop: platform_impl::EventLoop<T>,
pub(crate) event_loop: platform_impl::EventLoop<T>,
pub(crate) _marker: ::std::marker::PhantomData<*mut ()> // Not Send nor Sync
}
@@ -85,7 +85,7 @@ impl<T> EventLoop<T> {
/// fallback on x11. If this variable is set with any other value, winit will panic.
pub fn new_user_event() -> EventLoop<T> {
EventLoop {
events_loop: platform_impl::EventLoop::new(),
event_loop: platform_impl::EventLoop::new(),
_marker: ::std::marker::PhantomData,
}
}
@@ -95,14 +95,14 @@ impl<T> EventLoop<T> {
// Note: should be replaced with `-> impl Iterator` once stable.
#[inline]
pub fn get_available_monitors(&self) -> AvailableMonitorsIter {
let data = self.events_loop.get_available_monitors();
let data = self.event_loop.get_available_monitors();
AvailableMonitorsIter{ data: data.into_iter() }
}
/// Returns the primary monitor of the system.
#[inline]
pub fn get_primary_monitor(&self) -> MonitorId {
MonitorId { inner: self.events_loop.get_primary_monitor() }
MonitorId { inner: self.event_loop.get_primary_monitor() }
}
/// Hijacks the calling thread and initializes the `winit` event loop with the provided
@@ -114,14 +114,14 @@ impl<T> EventLoop<T> {
pub fn run<F>(self, event_handler: F) -> !
where F: 'static + FnMut(Event<T>, &EventLoop<T>, &mut ControlFlow)
{
self.events_loop.run(event_handler)
self.event_loop.run(event_handler)
}
/// Creates an `EventLoopProxy` that can be used to wake up the `EventLoop` from another
/// thread.
pub fn create_proxy(&self) -> EventLoopProxy<T> {
EventLoopProxy {
events_loop_proxy: self.events_loop.create_proxy(),
event_loop_proxy: self.event_loop.create_proxy(),
}
}
}
@@ -129,7 +129,7 @@ impl<T> EventLoop<T> {
/// Used to send custom events to `EventLoop`.
#[derive(Clone)]
pub struct EventLoopProxy<T> {
events_loop_proxy: platform_impl::EventLoopProxy<T>,
event_loop_proxy: platform_impl::EventLoopProxy<T>,
}
impl<T> EventLoopProxy<T> {
@@ -139,7 +139,7 @@ impl<T> EventLoopProxy<T> {
///
/// Returns an `Err` if the associated `EventLoop` no longer exists.
pub fn send_event(&self, event: T) -> Result<(), EventLoopClosed> {
self.events_loop_proxy.send_event(event)
self.event_loop_proxy.send_event(event)
}
}

12
src/lib.rs
View File

@@ -7,13 +7,13 @@
//!
//! ```no_run
//! use winit::event_loop::EventLoop;
//! let events_loop = EventLoop::new();
//! let event_loop = EventLoop::new();
//! ```
//!
//! Once this is done there are two ways to create a [`Window`]:
//!
//! - Calling [`Window::new(&events_loop)`][window_new].
//! - Calling [`let builder = WindowBuilder::new()`][window_builder_new] then [`builder.build(&events_loop)`][window_builder_build].
//! - Calling [`Window::new(&event_loop)`][window_new].
//! - Calling [`let builder = WindowBuilder::new()`][window_builder_new] then [`builder.build(&event_loop)`][window_builder_build].
//!
//! The first way is the simplest way and will give you default values for everything.
//!
@@ -28,7 +28,7 @@
//! The events generated by a [`Window`] can be retreived from the [`EventLoop`] the [`Window`] was created
//! with.
//!
//! You do this by calling [`events_loop.run(...)`][event_loop_run]. This function will run forever
//! You do this by calling [`event_loop.run(...)`][event_loop_run]. This function will run forever
//! unless `control_flow` is set to [`ControlFlow`]`::`[`Exit`], at which point [`Event`]`::`[`LoopDestroyed`]
//! is emitted and the entire program terminates.
//!
@@ -36,9 +36,9 @@
//! use winit::event_loop::ControlFlow;
//! use winit::event::{Event, WindowEvent};
//! # use winit::event_loop::EventLoop;
//! # let events_loop = EventLoop::new();
//! # let event_loop = EventLoop::new();
//!
//! events_loop.run(move |event, _, control_flow| {
//! event_loop.run(move |event, _, control_flow| {
//! match event {
//! Event::WindowEvent { event: WindowEvent::CloseRequested, .. } => {
//! println!("The close button was pressed; stopping");

2
src/platform/android.rs
View File

@@ -13,7 +13,7 @@ pub trait EventLoopExtAndroid {
impl EventLoopExtAndroid for EventLoop {
fn set_suspend_callback(&self, cb: Option<Box<Fn(bool) -> ()>>) {
self.events_loop.set_suspend_callback(cb);
self.event_loop.set_suspend_callback(cb);
}
}

2
src/platform/desktop.rs
View File

@@ -26,6 +26,6 @@ impl<T> EventLoopExtDesktop for EventLoop<T> {
fn run_return<F>(&mut self, event_handler: F)
where F: FnMut(Event<T>, &EventLoop<T>, &mut ControlFlow)
{
self.events_loop.run_return(event_handler)
self.event_loop.run_return(event_handler)
}
}

10
src/platform/unix.rs
View File

@@ -50,7 +50,7 @@ impl EventLoopExtUnix for EventLoop {
fn new_x11() -> Result<Self, XNotSupported> {
LinuxEventLoop::new_x11().map(|ev|
EventLoop {
events_loop: ev,
event_loop: ev,
_marker: ::std::marker::PhantomData,
}
)
@@ -59,7 +59,7 @@ impl EventLoopExtUnix for EventLoop {
#[inline]
fn new_wayland() -> Self {
EventLoop {
events_loop: match LinuxEventLoop::new_wayland() {
event_loop: match LinuxEventLoop::new_wayland() {
Ok(e) => e,
Err(_) => panic!() // TODO: propagate
},
@@ -69,18 +69,18 @@ impl EventLoopExtUnix for EventLoop {
#[inline]
fn is_wayland(&self) -> bool {
self.events_loop.is_wayland()
self.event_loop.is_wayland()
}
#[inline]
fn is_x11(&self) -> bool {
!self.events_loop.is_wayland()
!self.event_loop.is_wayland()
}
#[inline]
#[doc(hidden)]
fn get_xlib_xconnection(&self) -> Option<Arc<XConnection>> {
self.events_loop.x_connection().cloned()
self.event_loop.x_connection().cloned()
}
}

2
src/platform/windows.rs
View File

@@ -22,7 +22,7 @@ impl<T> EventLoopExtWindows for EventLoop<T> {
#[inline]
fn new_dpi_unaware() -> Self {
EventLoop {
events_loop: WindowsEventLoop::with_dpi_awareness(false),
event_loop: WindowsEventLoop::with_dpi_awareness(false),
_marker: ::std::marker::PhantomData,
}
}

10
src/platform_impl/emscripten/mod.rs
View File

@@ -366,11 +366,11 @@ fn em_try(res: ffi::EMSCRIPTEN_RESULT) -> Result<(), String> {
}
impl Window {
pub fn new(events_loop: &EventLoop, attribs: ::WindowAttributes,
pub fn new(event_loop: &EventLoop, attribs: ::WindowAttributes,
_pl_attribs: PlatformSpecificWindowBuilderAttributes)
-> Result<Window, ::CreationError>
{
if events_loop.window.lock().unwrap().is_some() {
if event_loop.window.lock().unwrap().is_some() {
return Err(::CreationError::OsError("Cannot create another window".to_owned()));
}
@@ -419,7 +419,7 @@ impl Window {
window.set_inner_size(size);
}
*events_loop.window.lock().unwrap() = Some(window.window.clone());
*event_loop.window.lock().unwrap() = Some(window.window.clone());
Ok(window)
}
@@ -613,9 +613,9 @@ impl Window {
impl Drop for Window {
fn drop(&mut self) {
// Delete window from events_loop
// Delete window from event_loop
// TODO: ?
/*if let Some(ev) = self.events_loop.upgrade() {
/*if let Some(ev) = self.event_loop.upgrade() {
let _ = ev.window.lock().unwrap().take().unwrap();
}*/

6
src/platform_impl/ios/mod.rs
View File

@@ -199,7 +199,7 @@ impl MonitorId {
}
}
pub struct EventsLoop {
pub struct EventLoop {
events_queue: Arc<RefCell<VecDeque<Event>>>,
}
@@ -213,7 +213,7 @@ impl EventLoop {
panic!("`EventLoop` can only be created on the main thread on iOS");
}
}
EventsLoop { events_queue: Default::default() }
EventLoop { events_queue: Default::default() }
}
#[inline]
@@ -238,7 +238,7 @@ impl EventLoop {
unsafe {
// jump hack, so we won't quit on willTerminate event before processing it
assert!(JMPBUF.is_some(), "`EventsLoop::poll_events` must be called after window creation on iOS");
assert!(JMPBUF.is_some(), "`EventLoop::poll_events` must be called after window creation on iOS");
if setjmp(mem::transmute_copy(&mut JMPBUF)) != 0 {
if let Some(event) = self.events_queue.borrow_mut().pop_front() {
callback(event);

12
src/platform_impl/linux/mod.rs
View File

@@ -122,16 +122,16 @@ impl MonitorId {
impl Window {
#[inline]
pub fn new(
events_loop: &EventLoop,
event_loop: &EventLoop,
attribs: WindowAttributes,
pl_attribs: PlatformSpecificWindowBuilderAttributes,
) -> Result<Self, CreationError> {
match *events_loop {
EventLoop::Wayland(ref events_loop) => {
wayland::Window::new(events_loop, attribs).map(Window::Wayland)
match *event_loop {
EventLoop::Wayland(ref event_loop) => {
wayland::Window::new(event_loop, attribs).map(Window::Wayland)
},
EventLoop::X(ref events_loop) => {
x11::Window::new(events_loop, attribs, pl_attribs).map(Window::X)
EventLoop::X(ref event_loop) => {
x11::Window::new(event_loop, attribs, pl_attribs).map(Window::X)
},
}
}

25
src/platform_impl/linux/wayland/event_loop.rs
View File

@@ -131,7 +131,7 @@ impl EventLoop {
},
).unwrap();
Ok(EventsLoop {
Ok(EventLoop {
display,
evq: RefCell::new(event_queue),
sink,
@@ -282,7 +282,7 @@ struct SeatManager {
sink: Arc<Mutex<EventLoopSink>>,
store: Arc<Mutex<WindowStore>>,
seats: Arc<Mutex<Vec<(u32, Proxy<wl_seat::WlSeat>)>>>,
events_loop_proxy: EventsLoopProxy,
event_loop_proxy: EventLoopProxy,
}
impl SeatManager {
@@ -308,12 +308,25 @@ impl SeatManager {
modifiers_tracker: Arc::new(Mutex::new(ModifiersState::default())),
};
let seat = registry
<<<<<<< HEAD
.bind(min(version, 5), id, move |seat| {
seat.implement(move |event, seat| {
seat_data.receive(event, seat)
}, ())
})
.unwrap();
=======
.bind::<wl_seat::WlSeat>(min(version, 5), id)
.unwrap()
.implement(SeatData {
sink: self.sink.clone(),
store: self.store.clone(),
pointer: None,
keyboard: None,
touch: None,
event_loop_proxy: self.event_loop_proxy.clone(),
});
>>>>>>> Change instances of "events_loop" to "event_loop"
self.store.lock().unwrap().new_seat(&seat);
self.seats.lock().unwrap().push((id, seat));
}
@@ -337,8 +350,12 @@ struct SeatData {
pointer: Option<Proxy<wl_pointer::WlPointer>>,
keyboard: Option<Proxy<wl_keyboard::WlKeyboard>>,
touch: Option<Proxy<wl_touch::WlTouch>>,
<<<<<<< HEAD
events_loop_proxy: EventsLoopProxy,
modifiers_tracker: Arc<Mutex<ModifiersState>>,
=======
event_loop_proxy: EventLoopProxy,
>>>>>>> Change instances of "events_loop" to "event_loop"
}
impl SeatData {
@@ -369,8 +386,12 @@ impl SeatData {
self.keyboard = Some(super::keyboard::init_keyboard(
&seat,
self.sink.clone(),
<<<<<<< HEAD
self.events_loop_proxy.clone(),
self.modifiers_tracker.clone(),
=======
self.event_loop_proxy.clone(),
>>>>>>> Change instances of "events_loop" to "event_loop"
))
}
// destroy keyboard if applicable

6
src/platform_impl/linux/wayland/keyboard.rs
View File

@@ -1,6 +1,6 @@
use std::sync::{Arc, Mutex};
use super::{make_wid, DeviceId, EventsLoopProxy, EventsLoopSink};
use super::{make_wid, DeviceId, EventLoopProxy, EventLoopSink};
use sctk::keyboard::{
self, map_keyboard_auto_with_repeat, Event as KbEvent, KeyRepeatEvent, KeyRepeatKind,
};
@@ -14,7 +14,7 @@ use {ElementState, KeyboardInput, ModifiersState, VirtualKeyCode, WindowEvent};
pub fn init_keyboard(
seat: &Proxy<wl_seat::WlSeat>,
sink: Arc<Mutex<EventLoopSink>>,
events_loop_proxy: EventLoopProxy,
event_loop_proxy: EventLoopProxy,
modifiers_tracker: Arc<Mutex<ModifiersState>>,
) -> Proxy<wl_keyboard::WlKeyboard> {
// { variables to be captured by the closures
@@ -108,7 +108,7 @@ pub fn init_keyboard(
guard.send_event(WindowEvent::ReceivedCharacter(chr), wid);
}
}
events_loop_proxy.wakeup().unwrap();
event_loop_proxy.wakeup().unwrap();
}
},
);

0
src/platform_impl/macos/events_loop.rs → src/platform_impl/macos/event_loop.rs
View File

10
src/platform_impl/macos/mod.rs
View File

@@ -1,6 +1,6 @@
#![cfg(target_os = "macos")]
pub use self::events_loop::{EventLoop, Proxy as EventLoopProxy};
pub use self::event_loop::{EventLoop, Proxy as EventLoopProxy};
pub use self::monitor::MonitorId;
pub use self::window::{Id as WindowId, PlatformSpecificWindowBuilderAttributes, Window2};
use std::sync::Arc;
@@ -24,20 +24,20 @@ impl ::std::ops::Deref for Window {
impl Window {
pub fn new(events_loop: &EventLoop,
pub fn new(event_loop: &EventLoop,
attributes: ::WindowAttributes,
pl_attribs: PlatformSpecificWindowBuilderAttributes) -> Result<Self, CreationError>
{
let weak_shared = Arc::downgrade(&events_loop.shared);
let weak_shared = Arc::downgrade(&event_loop.shared);
let window = Arc::new(try!(Window2::new(weak_shared, attributes, pl_attribs)));
let weak_window = Arc::downgrade(&window);
events_loop.shared.windows.lock().unwrap().push(weak_window);
event_loop.shared.windows.lock().unwrap().push(weak_window);
Ok(Window { window: window })
}
}
mod events_loop;
mod event_loop;
mod ffi;
mod monitor;
mod util;

2
src/platform_impl/macos/view.rs
View File

@@ -14,7 +14,7 @@ use objc::declare::ClassDecl;
use objc::runtime::{Class, Object, Protocol, Sel, BOOL, YES};
use {ElementState, Event, KeyboardInput, MouseButton, WindowEvent, WindowId};
use platform_impl::platform::events_loop::{DEVICE_ID, event_mods, Shared, to_virtual_key_code, check_additional_virtual_key_codes};
use platform_impl::platform::event_loop::{DEVICE_ID, event_mods, Shared, to_virtual_key_code, check_additional_virtual_key_codes};
use platform_impl::platform::util;
use platform_impl::platform::ffi::*;
use platform_impl::platform::window::{get_window_id, IdRef};

2
src/platform_impl/macos/window.rs
View File

@@ -42,7 +42,7 @@ use {
use CreationError::OsError;
use os::macos::{ActivationPolicy, WindowExt};
use platform_impl::platform::{ffi, util};
use platform_impl::platform::events_loop::{EventLoop, Shared};
use platform_impl::platform::event_loop::{EventLoop, Shared};
use platform_impl::platform::view::{new_view, set_ime_spot};
use window::MonitorId as RootMonitorId;

0
src/platform_impl/windows/events_loop.rs → src/platform_impl/windows/event_loop.rs
View File

4
src/platform_impl/windows/mod.rs
View File

@@ -3,7 +3,7 @@
use winapi;
use winapi::shared::windef::HWND;
pub use self::events_loop::{EventLoop, EventLoopProxy};
pub use self::event_loop::{EventLoop, EventLoopProxy};
pub use self::monitor::MonitorId;
pub use self::window::Window;
@@ -54,7 +54,7 @@ unsafe impl Sync for WindowId {}
mod dpi;
mod drop_handler;
mod event;
mod events_loop;
mod event_loop;
mod icon;
mod monitor;
mod raw_input;

16
src/platform_impl/windows/window.rs
View File

@@ -23,8 +23,8 @@ use dpi::{LogicalPosition, LogicalSize, PhysicalSize};
use monitor::MonitorId as RootMonitorId;
use platform_impl::platform::{Cursor, PlatformSpecificWindowBuilderAttributes, WindowId};
use platform_impl::platform::dpi::{dpi_to_scale_factor, get_hwnd_dpi};
use platform_impl::platform::events_loop::{self, EventLoop, DESTROY_MSG_ID, INITIAL_DPI_MSG_ID, REQUEST_REDRAW_NO_NEWEVENTS_MSG_ID};
use platform_impl::platform::events_loop::WindowState;
use platform_impl::platform::event_loop::{self, EventLoop, DESTROY_MSG_ID, INITIAL_DPI_MSG_ID, REQUEST_REDRAW_NO_NEWEVENTS_MSG_ID};
use platform_impl::platform::event_loop::WindowState;
use platform_impl::platform::icon::{self, IconType, WinIcon};
use platform_impl::platform::monitor;
use platform_impl::platform::raw_input::register_all_mice_and_keyboards_for_raw_input;
@@ -42,7 +42,7 @@ pub struct Window {
window_state: Arc<Mutex<WindowState>>,
// The events loop proxy.
thread_executor: events_loop::EventLoopThreadExecutor,
thread_executor: event_loop::EventLoopThreadExecutor,
}
// https://blogs.msdn.microsoft.com/oldnewthing/20131017-00/?p=2903
@@ -98,13 +98,13 @@ impl Window {
file_drop_handler
};
let subclass_input = events_loop::SubclassInput {
let subclass_input = event_loop::SubclassInput {
window_state: win.window_state.clone(),
event_loop_runner: event_loop.runner_shared.clone(),
file_drop_handler,
};
events_loop::subclass_window(win.window.0, subclass_input);
event_loop::subclass_window(win.window.0, subclass_input);
win
})
}
@@ -517,7 +517,7 @@ impl Window {
if window_state.fullscreen.is_none() || window_state.saved_window_info.is_none() {
let rect = util::get_window_rect(self.window.0).expect("`GetWindowRect` failed");
let dpi_factor = Some(window_state.dpi_factor);
window_state.saved_window_info = Some(events_loop::SavedWindowInfo {
window_state.saved_window_info = Some(event_loop::SavedWindowInfo {
style: winuser::GetWindowLongW(self.window.0, winuser::GWL_STYLE),
ex_style: winuser::GetWindowLongW(self.window.0, winuser::GWL_EXSTYLE),
rect,
@@ -852,7 +852,7 @@ pub unsafe fn adjust_size(
unsafe fn init<T>(
mut attributes: WindowAttributes,
mut pl_attribs: PlatformSpecificWindowBuilderAttributes,
event_loop: &events_loop::EventLoop<T>,
event_loop: &event_loop::EventLoop<T>,
) -> Result<Window, CreationError> {
let title = OsStr::new(&attributes.title)
.encode_wide()
@@ -1043,7 +1043,7 @@ unsafe fn init<T>(
.map(|logical_size| PhysicalSize::from_logical(logical_size, dpi_factor));
let min_size = attributes.min_dimensions
.map(|logical_size| PhysicalSize::from_logical(logical_size, dpi_factor));
let mut window_state = events_loop::WindowState {
let mut window_state = event_loop::WindowState {
max_size,
min_size,
dpi_factor,

16
src/window.rs
View File

@@ -17,10 +17,10 @@ pub use icon::*;
/// use winit::event::{Event, WindowEvent};
/// use winit::event_loop::{EventLoop, ControlFlow};
///
/// let mut events_loop = EventLoop::new();
/// let window = Window::new(&events_loop).unwrap();
/// let mut event_loop = EventLoop::new();
/// let window = Window::new(&event_loop).unwrap();
///
/// events_loop.run(move |event, _, control_flow| {
/// event_loop.run(move |event, _, control_flow| {
/// match event {
/// Event::WindowEvent { event: WindowEvent::CloseRequested, .. } => {
/// *control_flow = ControlFlow::Exit
@@ -283,7 +283,7 @@ impl WindowBuilder {
/// Error should be very rare and only occur in case of permission denied, incompatible system,
/// out of memory, etc.
#[inline]
pub fn build<T>(mut self, events_loop: &EventLoop<T>) -> Result<Window, CreationError> {
pub fn build<T>(mut self, event_loop: &EventLoop<T>) -> Result<Window, CreationError> {
self.window.dimensions = Some(self.window.dimensions.unwrap_or_else(|| {
if let Some(ref monitor) = self.window.fullscreen {
// resizing the window to the dimensions of the monitor when fullscreen
@@ -296,7 +296,7 @@ impl WindowBuilder {
// building
platform_impl::Window::new(
&events_loop.events_loop,
&event_loop.event_loop,
self.window,
self.platform_specific,
).map(|window| Window { window })
@@ -306,14 +306,14 @@ impl WindowBuilder {
impl Window {
/// Creates a new Window for platforms where this is appropriate.
///
/// This function is equivalent to `WindowBuilder::new().build(events_loop)`.
/// This function is equivalent to `WindowBuilder::new().build(event_loop)`.
///
/// Error should be very rare and only occur in case of permission denied, incompatible system,
/// out of memory, etc.
#[inline]
pub fn new<T>(events_loop: &EventLoop<T>) -> Result<Window, CreationError> {
pub fn new<T>(event_loop: &EventLoop<T>) -> Result<Window, CreationError> {
let builder = WindowBuilder::new();
builder.build(events_loop)
builder.build(event_loop)
}
/// Modifies the title of the window.

2
tests/send_objects.rs
View File

@@ -3,7 +3,7 @@ extern crate winit;
fn needs_send<T:Send>() {}
#[test]
fn events_loop_proxy_send() {
fn event_loop_proxy_send() {
// ensures that `winit::EventLoopProxy` implements `Send`
needs_send::<winit::event_loop::EventLoopProxy<()>>();
}