migrations/winit
1
0
Fork 0
mirror of https://github.com/rust-windowing/winit.git synced 2026-08-30 05:10:03 -04:00
Code Issues Packages Projects Releases Wiki Activity

Rename EventsLoop and associated types to EventLoop

Browse Source
This commit is contained in:
Osspial
2018-07-12 22:04:38 -04:00
parent 30aa5a5057
commit 529c08555f
38 changed files with 246 additions and 247 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
src/platform/android/mod.rs
View File

@@ -26,19 +26,19 @@ use CreationError::OsError;
use events::{Touch, TouchPhase};
use window::MonitorId as RootMonitorId;
pub struct EventsLoop {
pub struct EventLoop {
event_rx: Receiver<android_glue::Event>,
suspend_callback: RefCell<Option<Box<Fn(bool) -> ()>>>,
}
#[derive(Clone)]
pub struct EventsLoopProxy;
pub struct EventLoopProxy;
impl EventsLoop {
pub fn new() -> EventsLoop {
impl EventLoop {
pub fn new() -> EventLoop {
let (tx, rx) = channel();
android_glue::add_sender(tx);
EventsLoop {
EventLoop {
event_rx: rx,
suspend_callback: Default::default(),
}
@@ -155,13 +155,13 @@ impl EventsLoop {
}
}
pub fn create_proxy(&self) -> EventsLoopProxy {
EventsLoopProxy
pub fn create_proxy(&self) -> EventLoopProxy {
EventLoopProxy
}
}
impl EventsLoopProxy {
pub fn wakeup(&self) -> Result<(), ::EventsLoopClosed> {
impl EventLoopProxy {
pub fn wakeup(&self) -> Result<(), ::EventLoopClosed> {
android_glue::wake_event_loop();
Ok(())
}
@@ -236,7 +236,7 @@ pub struct PlatformSpecificWindowBuilderAttributes;
pub struct PlatformSpecificHeadlessBuilderAttributes;
impl Window {
pub fn new(_: &EventsLoop, win_attribs: WindowAttributes,
pub fn new(_: &EventLoop, win_attribs: WindowAttributes,
_: PlatformSpecificWindowBuilderAttributes)
-> Result<Window, CreationError>
{

18
src/platform/emscripten/mod.rs
View File

@@ -75,22 +75,22 @@ pub fn set_main_loop_callback<F>(callback : F) where F : FnMut() {
}
#[derive(Clone)]
pub struct EventsLoopProxy;
pub struct EventLoopProxy;
impl EventsLoopProxy {
pub fn wakeup(&self) -> Result<(), ::EventsLoopClosed> {
impl EventLoopProxy {
pub fn wakeup(&self) -> Result<(), ::EventLoopClosed> {
unimplemented!()
}
}
pub struct EventsLoop {
pub struct EventLoop {
window: Mutex<Option<Arc<Window2>>>,
interrupted: AtomicBool,
}
impl EventsLoop {
pub fn new() -> EventsLoop {
EventsLoop {
impl EventLoop {
pub fn new() -> EventLoop {
EventLoop {
window: Mutex::new(None),
interrupted: AtomicBool::new(false),
}
@@ -102,7 +102,7 @@ impl EventsLoop {
}
#[inline]
pub fn create_proxy(&self) -> EventsLoopProxy {
pub fn create_proxy(&self) -> EventLoopProxy {
unimplemented!()
}
@@ -366,7 +366,7 @@ fn em_try(res: ffi::EMSCRIPTEN_RESULT) -> Result<(), String> {
}
impl Window {
pub fn new(events_loop: &EventsLoop, attribs: ::WindowAttributes,
pub fn new(events_loop: &EventLoop, attribs: ::WindowAttributes,
_pl_attribs: PlatformSpecificWindowBuilderAttributes)
-> Result<Window, ::CreationError>
{

18
src/platform/ios/mod.rs
View File

@@ -204,13 +204,13 @@ pub struct EventsLoop {
}
#[derive(Clone)]
pub struct EventsLoopProxy;
pub struct EventLoopProxy;
impl EventsLoop {
pub fn new() -> EventsLoop {
impl EventLoop {
pub fn new() -> EventLoop {
unsafe {
if !msg_send![class!(NSThread), isMainThread] {
panic!("`EventsLoop` can only be created on the main thread on iOS");
panic!("`EventLoop` can only be created on the main thread on iOS");
}
}
EventsLoop { events_queue: Default::default() }
@@ -276,13 +276,13 @@ impl EventsLoop {
}
}
pub fn create_proxy(&self) -> EventsLoopProxy {
EventsLoopProxy
pub fn create_proxy(&self) -> EventLoopProxy {
EventLoopProxy
}
}
impl EventsLoopProxy {
pub fn wakeup(&self) -> Result<(), ::EventsLoopClosed> {
impl EventLoopProxy {
pub fn wakeup(&self) -> Result<(), ::EventLoopClosed> {
unimplemented!()
}
}
@@ -310,7 +310,7 @@ impl Default for PlatformSpecificWindowBuilderAttributes {
// so to be consistent with other platforms we have to change that.
impl Window {
pub fn new(
ev: &EventsLoop,
ev: &EventLoop,
_attributes: WindowAttributes,
pl_attributes: PlatformSpecificWindowBuilderAttributes,
) -> Result<Window, CreationError> {

82
src/platform/linux/mod.rs
View File

@@ -11,7 +11,7 @@ use sctk::reexports::client::ConnectError;
use {
CreationError,
EventsLoopClosed,
EventLoopClosed,
Icon,
MouseCursor,
ControlFlow,
@@ -122,15 +122,15 @@ impl MonitorId {
impl Window {
#[inline]
pub fn new(
events_loop: &EventsLoop,
events_loop: &EventLoop,
attribs: WindowAttributes,
pl_attribs: PlatformSpecificWindowBuilderAttributes,
) -> Result<Self, CreationError> {
match *events_loop {
EventsLoop::Wayland(ref events_loop) => {
EventLoop::Wayland(ref events_loop) => {
wayland::Window::new(events_loop, attribs).map(Window::Wayland)
},
EventsLoop::X(ref events_loop) => {
EventLoop::X(ref events_loop) => {
x11::Window::new(events_loop, attribs, pl_attribs).map(Window::X)
},
}
@@ -389,27 +389,27 @@ unsafe extern "C" fn x_error_callback(
0
}
pub enum EventsLoop {
Wayland(wayland::EventsLoop),
X(x11::EventsLoop)
pub enum EventLoop {
Wayland(wayland::EventLoop),
X(x11::EventLoop)
}
#[derive(Clone)]
pub enum EventsLoopProxy {
X(x11::EventsLoopProxy),
Wayland(wayland::EventsLoopProxy),
pub enum EventLoopProxy {
X(x11::EventLoopProxy),
Wayland(wayland::EventLoopProxy),
}
impl EventsLoop {
pub fn new() -> EventsLoop {
impl EventLoop {
pub fn new() -> EventLoop {
if let Ok(env_var) = env::var(BACKEND_PREFERENCE_ENV_VAR) {
match env_var.as_str() {
"x11" => {
// TODO: propagate
return EventsLoop::new_x11().expect("Failed to initialize X11 backend");
return EventLoop::new_x11().expect("Failed to initialize X11 backend");
},
"wayland" => {
return EventsLoop::new_wayland()
return EventLoop::new_wayland()
.expect("Failed to initialize Wayland backend");
},
_ => panic!(
@@ -419,12 +419,12 @@ impl EventsLoop {
}
}
let wayland_err = match EventsLoop::new_wayland() {
let wayland_err = match EventLoop::new_wayland() {
Ok(event_loop) => return event_loop,
Err(err) => err,
};
let x11_err = match EventsLoop::new_x11() {
let x11_err = match EventLoop::new_x11() {
Ok(event_loop) => return event_loop,
Err(err) => err,
};
@@ -437,30 +437,30 @@ impl EventsLoop {
panic!(err_string);
}
pub fn new_wayland() -> Result<EventsLoop, ConnectError> {
wayland::EventsLoop::new()
.map(EventsLoop::Wayland)
pub fn new_wayland() -> Result<EventLoop, ConnectError> {
wayland::EventLoop::new()
.map(EventLoop::Wayland)
}
pub fn new_x11() -> Result<EventsLoop, XNotSupported> {
pub fn new_x11() -> Result<EventLoop, XNotSupported> {
X11_BACKEND
.lock()
.as_ref()
.map(Arc::clone)
.map(x11::EventsLoop::new)
.map(EventsLoop::X)
.map(x11::EventLoop::new)
.map(EventLoop::X)
.map_err(|err| err.clone())
}
#[inline]
pub fn get_available_monitors(&self) -> VecDeque<MonitorId> {
match *self {
EventsLoop::Wayland(ref evlp) => evlp
EventLoop::Wayland(ref evlp) => evlp
.get_available_monitors()
.into_iter()
.map(MonitorId::Wayland)
.collect(),
EventsLoop::X(ref evlp) => evlp
EventLoop::X(ref evlp) => evlp
.x_connection()
.get_available_monitors()
.into_iter()
@@ -472,15 +472,15 @@ impl EventsLoop {
#[inline]
pub fn get_primary_monitor(&self) -> MonitorId {
match *self {
EventsLoop::Wayland(ref evlp) => MonitorId::Wayland(evlp.get_primary_monitor()),
EventsLoop::X(ref evlp) => MonitorId::X(evlp.x_connection().get_primary_monitor()),
EventLoop::Wayland(ref evlp) => MonitorId::Wayland(evlp.get_primary_monitor()),
EventLoop::X(ref evlp) => MonitorId::X(evlp.x_connection().get_primary_monitor()),
}
}
pub fn create_proxy(&self) -> EventsLoopProxy {
pub fn create_proxy(&self) -> EventLoopProxy {
match *self {
EventsLoop::Wayland(ref evlp) => EventsLoopProxy::Wayland(evlp.create_proxy()),
EventsLoop::X(ref evlp) => EventsLoopProxy::X(evlp.create_proxy()),
EventLoop::Wayland(ref evlp) => EventLoopProxy::Wayland(evlp.create_proxy()),
EventLoop::X(ref evlp) => EventLoopProxy::X(evlp.create_proxy()),
}
}
@@ -488,8 +488,8 @@ impl EventsLoop {
where F: FnMut(::Event)
{
match *self {
EventsLoop::Wayland(ref mut evlp) => evlp.poll_events(callback),
EventsLoop::X(ref mut evlp) => evlp.poll_events(callback)
EventLoop::Wayland(ref mut evlp) => evlp.poll_events(callback),
EventLoop::X(ref mut evlp) => evlp.poll_events(callback)
}
}
@@ -497,33 +497,33 @@ impl EventsLoop {
where F: FnMut(::Event) -> ControlFlow
{
match *self {
EventsLoop::Wayland(ref mut evlp) => evlp.run_forever(callback),
EventsLoop::X(ref mut evlp) => evlp.run_forever(callback)
EventLoop::Wayland(ref mut evlp) => evlp.run_forever(callback),
EventLoop::X(ref mut evlp) => evlp.run_forever(callback)
}
}
#[inline]
pub fn is_wayland(&self) -> bool {
match *self {
EventsLoop::Wayland(_) => true,
EventsLoop::X(_) => false,
EventLoop::Wayland(_) => true,
EventLoop::X(_) => false,
}
}
#[inline]
pub fn x_connection(&self) -> Option<&Arc<XConnection>> {
match *self {
EventsLoop::Wayland(_) => None,
EventsLoop::X(ref ev) => Some(ev.x_connection()),
EventLoop::Wayland(_) => None,
EventLoop::X(ref ev) => Some(ev.x_connection()),
}
}
}
impl EventsLoopProxy {
pub fn wakeup(&self) -> Result<(), EventsLoopClosed> {
impl EventLoopProxy {
pub fn wakeup(&self) -> Result<(), EventLoopClosed> {
match *self {
EventsLoopProxy::Wayland(ref proxy) => proxy.wakeup(),
EventsLoopProxy::X(ref proxy) => proxy.wakeup(),
EventLoopProxy::Wayland(ref proxy) => proxy.wakeup(),
EventLoopProxy::X(ref proxy) => proxy.wakeup(),
}
}
}

56
src/platform/linux/wayland/event_loop.rs
View File

@@ -4,7 +4,7 @@ use std::fmt;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, Mutex, Weak};
use {ControlFlow, EventsLoopClosed, PhysicalPosition, PhysicalSize};
use {ControlFlow, EventLoopClosed, PhysicalPosition, PhysicalSize};
use super::window::WindowStore;
use super::WindowId;
@@ -21,13 +21,13 @@ use sctk::reexports::client::protocol::wl_surface::RequestsTrait;
use ModifiersState;
pub struct EventsLoopSink {
pub struct EventLoopSink {
buffer: VecDeque<::Event>,
}
impl EventsLoopSink {
pub fn new() -> EventsLoopSink {
EventsLoopSink {
impl EventLoopSink {
pub fn new() -> EventLoopSink {
EventLoopSink {
buffer: VecDeque::new(),
}
}
@@ -54,11 +54,11 @@ impl EventsLoopSink {
}
}
pub struct EventsLoop {
pub struct EventLoop {
// The Event Queue
pub evq: RefCell<EventQueue>,
// our sink, shared with some handlers, buffering the events
sink: Arc<Mutex<EventsLoopSink>>,
sink: Arc<Mutex<EventLoopSink>>,
// Whether or not there is a pending `Awakened` event to be emitted.
pending_wakeup: Arc<AtomicBool>,
// The window store
@@ -73,43 +73,43 @@ pub struct EventsLoop {
pub seats: Arc<Mutex<Vec<(u32, Proxy<wl_seat::WlSeat>)>>>,
}
// A handle that can be sent across threads and used to wake up the `EventsLoop`.
// A handle that can be sent across threads and used to wake up the `EventLoop`.
//
// We should only try and wake up the `EventsLoop` if it still exists, so we hold Weak ptrs.
// We should only try and wake up the `EventLoop` if it still exists, so we hold Weak ptrs.
#[derive(Clone)]
pub struct EventsLoopProxy {
pub struct EventLoopProxy {
display: Weak<Display>,
pending_wakeup: Weak<AtomicBool>,
}
impl EventsLoopProxy {
// Causes the `EventsLoop` to stop blocking on `run_forever` and emit an `Awakened` event.
impl EventLoopProxy {
// Causes the `EventLoop` to stop blocking on `run_forever` and emit an `Awakened` event.
//
// Returns `Err` if the associated `EventsLoop` no longer exists.
pub fn wakeup(&self) -> Result<(), EventsLoopClosed> {
// Returns `Err` if the associated `EventLoop` no longer exists.
pub fn wakeup(&self) -> Result<(), EventLoopClosed> {
let display = self.display.upgrade();
let wakeup = self.pending_wakeup.upgrade();
match (display, wakeup) {
(Some(display), Some(wakeup)) => {
// Update the `EventsLoop`'s `pending_wakeup` flag.
// Update the `EventLoop`'s `pending_wakeup` flag.
wakeup.store(true, Ordering::Relaxed);
// Cause the `EventsLoop` to break from `dispatch` if it is currently blocked.
// Cause the `EventLoop` to break from `dispatch` if it is currently blocked.
let _ = display.sync(|callback| callback.implement(|_, _| {}, ()));
display.flush().map_err(|_| EventsLoopClosed)?;
display.flush().map_err(|_| EventLoopClosed)?;
Ok(())
}
_ => Err(EventsLoopClosed),
_ => Err(EventLoopClosed),
}
}
}
impl EventsLoop {
pub fn new() -> Result<EventsLoop, ConnectError> {
impl EventLoop {
pub fn new() -> Result<EventLoop, ConnectError> {
let (display, mut event_queue) = Display::connect_to_env()?;
let display = Arc::new(display);
let pending_wakeup = Arc::new(AtomicBool::new(false));
let sink = Arc::new(Mutex::new(EventsLoopSink::new()));
let sink = Arc::new(Mutex::new(EventLoopSink::new()));
let store = Arc::new(Mutex::new(WindowStore::new()));
let seats = Arc::new(Mutex::new(Vec::new()));
@@ -126,7 +126,7 @@ impl EventsLoop {
let env = Environment::from_display_with_cb(
&display,
&mut event_queue,
move |event, registry| {
move |event, registry| {
seat_manager.receive(event, registry)
},
).unwrap();
@@ -143,8 +143,8 @@ impl EventsLoop {
})
}
pub fn create_proxy(&self) -> EventsLoopProxy {
EventsLoopProxy {
pub fn create_proxy(&self) -> EventLoopProxy {
EventLoopProxy {
display: Arc::downgrade(&self.display),
pending_wakeup: Arc::downgrade(&self.pending_wakeup),
}
@@ -221,10 +221,10 @@ impl EventsLoop {
}
/*
* Private EventsLoop Internals
* Private EventLoop Internals
*/
impl EventsLoop {
impl EventLoop {
fn post_dispatch_triggers(&mut self) {
let mut sink = self.sink.lock().unwrap();
// process a possible pending wakeup call
@@ -279,7 +279,7 @@ impl EventsLoop {
*/
struct SeatManager {
sink: Arc<Mutex<EventsLoopSink>>,
sink: Arc<Mutex<EventLoopSink>>,
store: Arc<Mutex<WindowStore>>,
seats: Arc<Mutex<Vec<(u32, Proxy<wl_seat::WlSeat>)>>>,
events_loop_proxy: EventsLoopProxy,
@@ -332,7 +332,7 @@ impl SeatManager {
}
struct SeatData {
sink: Arc<Mutex<EventsLoopSink>>,
sink: Arc<Mutex<EventLoopSink>>,
store: Arc<Mutex<WindowStore>>,
pointer: Option<Proxy<wl_pointer::WlPointer>>,
keyboard: Option<Proxy<wl_keyboard::WlKeyboard>>,

4
src/platform/linux/wayland/keyboard.rs
View File

@@ -13,8 +13,8 @@ use {ElementState, KeyboardInput, ModifiersState, VirtualKeyCode, WindowEvent};
pub fn init_keyboard(
seat: &Proxy<wl_seat::WlSeat>,
sink: Arc<Mutex<EventsLoopSink>>,
events_loop_proxy: EventsLoopProxy,
sink: Arc<Mutex<EventLoopSink>>,
events_loop_proxy: EventLoopProxy,
modifiers_tracker: Arc<Mutex<ModifiersState>>,
) -> Proxy<wl_keyboard::WlKeyboard> {
// { variables to be captured by the closures

2
src/platform/linux/wayland/mod.rs
View File

@@ -2,7 +2,7 @@
target_os = "netbsd", target_os = "openbsd"))]
pub use self::window::Window;
pub use self::event_loop::{EventsLoop, EventsLoopProxy, EventsLoopSink, MonitorId};
pub use self::event_loop::{EventLoop, EventLoopProxy, EventLoopSink, MonitorId};
use sctk::reexports::client::protocol::wl_surface;
use sctk::reexports::client::Proxy;

4
src/platform/linux/wayland/pointer.rs
View File

@@ -4,7 +4,7 @@ use {ElementState, MouseButton, MouseScrollDelta, TouchPhase, WindowEvent};
use events::ModifiersState;
use super::DeviceId;
use super::event_loop::EventsLoopSink;
use super::event_loop::EventLoopSink;
use super::window::WindowStore;
use sctk::reexports::client::Proxy;
@@ -14,7 +14,7 @@ use sctk::reexports::client::protocol::wl_seat::RequestsTrait as SeatRequests;
pub fn implement_pointer(
seat: &Proxy<wl_seat::WlSeat>,
sink: Arc<Mutex<EventsLoopSink>>,
sink: Arc<Mutex<EventLoopSink>>,
store: Arc<Mutex<WindowStore>>,
modifiers_tracker: Arc<Mutex<ModifiersState>>,
) -> Proxy<WlPointer> {

4
src/platform/linux/wayland/touch.rs
View File

@@ -3,7 +3,7 @@ use std::sync::{Arc, Mutex};
use {TouchPhase, WindowEvent};
use super::{DeviceId, WindowId};
use super::event_loop::EventsLoopSink;
use super::event_loop::EventLoopSink;
use super::window::WindowStore;
use sctk::reexports::client::Proxy;
@@ -19,7 +19,7 @@ struct TouchPoint {
pub(crate) fn implement_touch(
seat: &Proxy<wl_seat::WlSeat>,
sink: Arc<Mutex<EventsLoopSink>>,
sink: Arc<Mutex<EventLoopSink>>,
store: Arc<Mutex<WindowStore>>,
) -> Proxy<WlTouch> {
let mut pending_ids = Vec::new();

4
src/platform/linux/wayland/window.rs
View File

@@ -13,7 +13,7 @@ use sctk::reexports::client::protocol::wl_compositor::RequestsTrait as Composito
use sctk::reexports::client::protocol::wl_surface::RequestsTrait as SurfaceRequests;
use sctk::output::OutputMgr;
use super::{make_wid, EventsLoop, MonitorId, WindowId};
use super::{make_wid, EventLoop, MonitorId, WindowId};
use platform::platform::wayland::event_loop::{get_available_monitors, get_primary_monitor};
pub struct Window {
@@ -28,7 +28,7 @@ pub struct Window {
}
impl Window {
pub fn new(evlp: &EventsLoop, attributes: WindowAttributes) -> Result<Window, CreationError> {
pub fn new(evlp: &EventLoop, attributes: WindowAttributes) -> Result<Window, CreationError> {
let (width, height) = attributes.dimensions.map(Into::into).unwrap_or((800, 600));
// Create the window
let size = Arc::new(Mutex::new((width, height)));

28
src/platform/linux/x11/mod.rs
View File

@@ -29,7 +29,7 @@ use {
CreationError,
DeviceEvent,
Event,
EventsLoopClosed,
EventLoopClosed,
KeyboardInput,
LogicalPosition,
LogicalSize,
@@ -41,7 +41,7 @@ use platform::PlatformSpecificWindowBuilderAttributes;
use self::dnd::{Dnd, DndState};
use self::ime::{ImeReceiver, ImeSender, ImeCreationError, Ime};
pub struct EventsLoop {
pub struct EventLoop {
xconn: Arc<XConnection>,
wm_delete_window: ffi::Atom,
dnd: Dnd,
@@ -60,14 +60,14 @@ pub struct EventsLoop {
}
#[derive(Clone)]
pub struct EventsLoopProxy {
pub struct EventLoopProxy {
pending_wakeup: Weak<AtomicBool>,
xconn: Weak<XConnection>,
wakeup_dummy_window: ffi::Window,
}
impl EventsLoop {
pub fn new(xconn: Arc<XConnection>) -> EventsLoop {
impl EventLoop {
pub fn new(xconn: Arc<XConnection>) -> EventLoop {
let root = unsafe { (xconn.xlib.XDefaultRootWindow)(xconn.display) };
let wm_delete_window = unsafe { xconn.get_atom_unchecked(b"WM_DELETE_WINDOW\0") };
@@ -142,7 +142,7 @@ impl EventsLoop {
)
};
let result = EventsLoop {
let result = EventLoop {
xconn,
wm_delete_window,
dnd,
@@ -177,8 +177,8 @@ impl EventsLoop {
&self.xconn
}
pub fn create_proxy(&self) -> EventsLoopProxy {
EventsLoopProxy {
pub fn create_proxy(&self) -> EventLoopProxy {
EventLoopProxy {
pending_wakeup: Arc::downgrade(&self.pending_wakeup),
xconn: Arc::downgrade(&self.xconn),
wakeup_dummy_window: self.wakeup_dummy_window,
@@ -1181,15 +1181,15 @@ impl EventsLoop {
}
}
impl EventsLoopProxy {
pub fn wakeup(&self) -> Result<(), EventsLoopClosed> {
// Update the `EventsLoop`'s `pending_wakeup` flag.
impl EventLoopProxy {
pub fn wakeup(&self) -> Result<(), EventLoopClosed> {
// Update the `EventLoop`'s `pending_wakeup` flag.
let display = match (self.pending_wakeup.upgrade(), self.xconn.upgrade()) {
(Some(wakeup), Some(display)) => {
wakeup.store(true, atomic::Ordering::Relaxed);
display
},
_ => return Err(EventsLoopClosed),
_ => return Err(EventLoopClosed),
};
// Push an event on the X event queue so that methods run_forever will advance.
@@ -1269,7 +1269,7 @@ impl Deref for Window {
impl Window {
pub fn new(
event_loop: &EventsLoop,
event_loop: &EventLoop,
attribs: WindowAttributes,
pl_attribs: PlatformSpecificWindowBuilderAttributes
) -> Result<Self, CreationError> {
@@ -1354,7 +1354,7 @@ enum ScrollOrientation {
}
impl Device {
fn new(el: &EventsLoop, info: &ffi::XIDeviceInfo) -> Self {
fn new(el: &EventLoop, info: &ffi::XIDeviceInfo) -> Self {
let name = unsafe { CStr::from_ptr(info.name).to_string_lossy() };
let mut scroll_axes = Vec::new();

4
src/platform/linux/x11/window.rs
View File

@@ -15,7 +15,7 @@ use platform::PlatformSpecificWindowBuilderAttributes;
use platform::x11::MonitorId as X11MonitorId;
use window::MonitorId as RootMonitorId;
use super::{ffi, util, ImeSender, XConnection, XError, WindowId, EventsLoop};
use super::{ffi, util, ImeSender, XConnection, XError, WindowId, EventLoop};
unsafe extern "C" fn visibility_predicate(
_display: *mut ffi::Display,
@@ -70,7 +70,7 @@ pub struct UnownedWindow {
impl UnownedWindow {
pub fn new(
event_loop: &EventsLoop,
event_loop: &EventLoop,
window_attrs: WindowAttributes,
pl_attribs: PlatformSpecificWindowBuilderAttributes,
) -> Result<UnownedWindow, CreationError> {

16
src/platform/macos/events_loop.rs
View File

@@ -1,4 +1,4 @@
use {ControlFlow, EventsLoopClosed};
use {ControlFlow, EventLoopClosed};
use cocoa::{self, appkit, foundation};
use cocoa::appkit::{NSApplication, NSEvent, NSEventMask, NSEventModifierFlags, NSEventPhase, NSView, NSWindow};
use events::{self, ElementState, Event, TouchPhase, WindowEvent, DeviceEvent, ModifiersState, KeyboardInput};
@@ -9,12 +9,12 @@ use std;
use std::os::raw::*;
use super::DeviceId;
pub struct EventsLoop {
pub struct EventLoop {
modifiers: Modifiers,
pub shared: Arc<Shared>,
}
// State shared between the `EventsLoop` and its registered windows.
// State shared between the `EventLoop` and its registered windows.
pub struct Shared {
pub windows: Mutex<Vec<Weak<Window2>>>,
pub pending_events: Mutex<VecDeque<Event>>,
@@ -42,7 +42,7 @@ struct Modifiers {
// Wrapping the user callback in a type allows us to:
//
// - ensure the callback pointer is never accidentally cloned
// - ensure that only the `EventsLoop` can `store` and `drop` the callback pointer
// - ensure that only the `EventLoop` can `store` and `drop` the callback pointer
// - Share access to the user callback with the NSWindow callbacks.
pub struct UserCallback {
mutex: Mutex<Option<*mut FnMut(Event)>>,
@@ -160,17 +160,17 @@ impl UserCallback {
}
impl EventsLoop {
impl EventLoop {
pub fn new() -> Self {
// Mark this thread as the main thread of the Cocoa event system.
//
// This must be done before any worker threads get a chance to call it
// (e.g., via `EventsLoopProxy::wakeup()`), causing a wrong thread to be
// (e.g., via `EventLoopProxy::wakeup()`), causing a wrong thread to be
// marked as the main thread.
unsafe { appkit::NSApp(); }
EventsLoop {
EventLoop {
shared: Arc::new(Shared::new()),
modifiers: Modifiers::new(),
}
@@ -521,7 +521,7 @@ impl EventsLoop {
}
impl Proxy {
pub fn wakeup(&self) -> Result<(), EventsLoopClosed> {
pub fn wakeup(&self) -> Result<(), EventLoopClosed> {
// Awaken the event loop by triggering `NSApplicationActivatedEventType`.
unsafe {
let pool = foundation::NSAutoreleasePool::new(cocoa::base::nil);

4
src/platform/macos/mod.rs
View File

@@ -1,6 +1,6 @@
#![cfg(target_os = "macos")]
pub use self::events_loop::{EventsLoop, Proxy as EventsLoopProxy};
pub use self::events_loop::{EventLoop, Proxy as EventLoopProxy};
pub use self::monitor::MonitorId;
pub use self::window::{Id as WindowId, PlatformSpecificWindowBuilderAttributes, Window2};
use std::sync::Arc;
@@ -24,7 +24,7 @@ impl ::std::ops::Deref for Window {
impl Window {
pub fn new(events_loop: &EventsLoop,
pub fn new(events_loop: &EventLoop,
attributes: ::WindowAttributes,
pl_attribs: PlatformSpecificWindowBuilderAttributes) -> Result<Self, CreationError>
{

4
src/platform/macos/monitor.rs
View File

@@ -7,7 +7,7 @@ use cocoa::foundation::{NSString, NSUInteger};
use core_graphics::display::{CGDirectDisplayID, CGDisplay, CGDisplayBounds};
use {PhysicalPosition, PhysicalSize};
use super::EventsLoop;
use super::EventLoop;
use super::window::{IdRef, Window2};
#[derive(Clone, PartialEq)]
@@ -30,7 +30,7 @@ pub fn get_primary_monitor() -> MonitorId {
id
}
impl EventsLoop {
impl EventLoop {
#[inline]
pub fn get_available_monitors(&self) -> VecDeque<MonitorId> {
get_available_monitors()

6
src/platform/macos/window.rs
View File

@@ -42,7 +42,7 @@ use {
use CreationError::OsError;
use os::macos::{ActivationPolicy, WindowExt};
use platform::platform::{ffi, util};
use platform::platform::events_loop::{EventsLoop, Shared};
use platform::platform::events_loop::{EventLoop, Shared};
use platform::platform::view::{new_view, set_ime_spot};
use window::MonitorId as RootMonitorId;
@@ -169,7 +169,7 @@ pub struct WindowDelegate {
}
impl WindowDelegate {
// Emits an event via the `EventsLoop`'s callback or stores it in the pending queue.
// Emits an event via the `EventLoop`'s callback or stores it in the pending queue.
pub fn emit_event(state: &mut DelegateState, window_event: WindowEvent) {
let window_id = get_window_id(*state.window);
let event = Event::WindowEvent {
@@ -543,7 +543,7 @@ unsafe fn get_current_monitor(window: id) -> RootMonitorId {
let key = IdRef::new(NSString::alloc(nil).init_str("NSScreenNumber"));
let value = NSDictionary::valueForKey_(desc, *key);
let display_id = msg_send![value, unsignedIntegerValue];
RootMonitorId { inner: EventsLoop::make_monitor_from_display(display_id) }
RootMonitorId { inner: EventLoop::make_monitor_from_display(display_id) }
}
impl Drop for Window2 {

28
src/platform/windows/events_loop.rs
View File

@@ -40,7 +40,7 @@ use winapi::um::winnt::{LONG, LPCSTR, SHORT};
use {
ControlFlow,
Event,
EventsLoopClosed,
EventLoopClosed,
KeyboardInput,
LogicalPosition,
LogicalSize,
@@ -133,19 +133,19 @@ impl Inserter {
}
}
pub struct EventsLoop {
pub struct EventLoop {
// Id of the background thread from the Win32 API.
thread_id: DWORD,
// Receiver for the events. The sender is in the background thread.
receiver: mpsc::Receiver<Event>,
}
impl EventsLoop {
pub fn new() -> EventsLoop {
impl EventLoop {
pub fn new() -> EventLoop {
Self::with_dpi_awareness(true)
}
pub fn with_dpi_awareness(dpi_aware: bool) -> EventsLoop {
pub fn with_dpi_awareness(dpi_aware: bool) -> EventLoop {
become_dpi_aware(dpi_aware);
// The main events transfer channel.
@@ -211,7 +211,7 @@ impl EventsLoop {
processthreadsapi::GetThreadId(handle)
};
EventsLoop {
EventLoop {
thread_id,
receiver: rx,
}
@@ -247,8 +247,8 @@ impl EventsLoop {
}
}
pub fn create_proxy(&self) -> EventsLoopProxy {
EventsLoopProxy {
pub fn create_proxy(&self) -> EventLoopProxy {
EventLoopProxy {
thread_id: self.thread_id,
}
}
@@ -267,7 +267,7 @@ impl EventsLoop {
}
}
impl Drop for EventsLoop {
impl Drop for EventLoop {
fn drop(&mut self) {
unsafe {
// Posting `WM_QUIT` will cause `GetMessage` to stop.
@@ -277,12 +277,12 @@ impl Drop for EventsLoop {
}
#[derive(Clone)]
pub struct EventsLoopProxy {
pub struct EventLoopProxy {
thread_id: DWORD,
}
impl EventsLoopProxy {
pub fn wakeup(&self) -> Result<(), EventsLoopClosed> {
impl EventLoopProxy {
pub fn wakeup(&self) -> Result<(), EventLoopClosed> {
unsafe {
if winuser::PostThreadMessageA(self.thread_id, *WAKEUP_MSG_ID, 0, 0) != 0 {
Ok(())
@@ -294,7 +294,7 @@ impl EventsLoopProxy {
// > idThread does not have a message queue. GetLastError returns
// > ERROR_NOT_ENOUGH_QUOTA when the message limit is hit.
// TODO: handle ERROR_NOT_ENOUGH_QUOTA
Err(EventsLoopClosed)
Err(EventLoopClosed)
}
}
}
@@ -335,7 +335,7 @@ impl EventsLoopProxy {
}
lazy_static! {
// Message sent by the `EventsLoopProxy` when we want to wake up the thread.
// Message sent by the `EventLoopProxy` when we want to wake up the thread.
// WPARAM and LPARAM are unused.
static ref WAKEUP_MSG_ID: u32 = {
unsafe {

2
src/platform/windows/mod.rs
View File

@@ -3,7 +3,7 @@
use winapi;
use winapi::shared::windef::HWND;
pub use self::events_loop::{EventsLoop, EventsLoopProxy};
pub use self::events_loop::{EventLoop, EventLoopProxy};
pub use self::monitor::MonitorId;
pub use self::window::Window;

4
src/platform/windows/monitor.rs
View File

@@ -6,7 +6,7 @@ use winapi::um::winuser;
use std::{mem, ptr};
use std::collections::VecDeque;
use super::{EventsLoop, util};
use super::{EventLoop, util};
use dpi::{PhysicalPosition, PhysicalSize};
use platform::platform::dpi::{dpi_to_scale_factor, get_monitor_dpi};
use platform::platform::window::Window;
@@ -71,7 +71,7 @@ pub fn get_primary_monitor() -> MonitorId {
MonitorId::from_hmonitor(hmonitor)
}
impl EventsLoop {
impl EventLoop {
// TODO: Investigate opportunities for caching
pub fn get_available_monitors(&self) -> VecDeque<MonitorId> {
get_available_monitors()

11
src/platform/windows/window.rs
View File

@@ -28,8 +28,7 @@ use {
};
use platform::platform::{Cursor, PlatformSpecificWindowBuilderAttributes, WindowId};
use platform::platform::dpi::{dpi_to_scale_factor, get_hwnd_dpi};
use platform::platform::events_loop::{self, EventsLoop, DESTROY_MSG_ID, INITIAL_DPI_MSG_ID};
use platform::platform::events_loop::WindowState;
use platform::platform::events_loop::{self, DESTROY_MSG_ID, EventLoop, INITIAL_DPI_MSG_ID, WindowState};
use platform::platform::icon::{self, IconType, WinIcon};
use platform::platform::monitor::get_available_monitors;
use platform::platform::raw_input::register_all_mice_and_keyboards_for_raw_input;
@@ -46,7 +45,7 @@ pub struct Window {
window_state: Arc<Mutex<WindowState>>,
// The events loop proxy.
events_loop_proxy: events_loop::EventsLoopProxy,
events_loop_proxy: events_loop::EventLoopProxy,
}
// https://blogs.msdn.microsoft.com/oldnewthing/20131017-00/?p=2903
@@ -73,7 +72,7 @@ unsafe fn unjust_window_rect(prc: &mut RECT, style: DWORD, ex_style: DWORD) -> B
impl Window {
pub fn new(
events_loop: &EventsLoop,
events_loop: &EventLoop,
w_attr: WindowAttributes,
pl_attr: PlatformSpecificWindowBuilderAttributes,
) -> Result<Window, CreationError> {
@@ -728,7 +727,7 @@ impl Window {
#[inline]
pub fn get_current_monitor(&self) -> RootMonitorId {
RootMonitorId {
inner: EventsLoop::get_current_monitor(self.window.0),
inner: EventLoop::get_current_monitor(self.window.0),
}
}
@@ -807,7 +806,7 @@ unsafe fn init(
mut attributes: WindowAttributes,
mut pl_attribs: PlatformSpecificWindowBuilderAttributes,
inserter: events_loop::Inserter,
events_loop_proxy: events_loop::EventsLoopProxy,
events_loop_proxy: events_loop::EventLoopProxy,
) -> Result<Window, CreationError> {
let title = OsStr::new(&attributes.title)
.encode_wide()