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

Migrate to 2018 edition. (#924)

Browse source 
* Migrate to 2018 edition.

* Use impl Iterator at one site.

* Fix more rust 2018 idioms.
This commit is contained in:
CrLF0710 2019-06-18 02:27:00 +08:00 • committed by Osspial
parent 2e0bbc091f
commit f879bca21c
71 changed files with 411 additions and 436 deletions
Download patch file Download diff file Expand all files Collapse all files

72
src/platform_impl/linux/wayland/event_loop.rs
View file

@ -5,24 +5,24 @@ use std::rc::Rc;
use std::sync::{Arc, Mutex};
use std::time::Instant;
use event_loop::{ControlFlow, EventLoopClosed, EventLoopWindowTarget as RootELW};
use event::ModifiersState;
use dpi::{PhysicalPosition, PhysicalSize};
use platform_impl::platform::sticky_exit_callback;
use monitor::VideoMode;
use crate::event_loop::{ControlFlow, EventLoopClosed, EventLoopWindowTarget as RootELW};
use crate::event::ModifiersState;
use crate::dpi::{PhysicalPosition, PhysicalSize};
use crate::platform_impl::platform::sticky_exit_callback;
use crate::monitor::VideoMode;
use super::window::WindowStore;
use super::WindowId;
use sctk::output::OutputMgr;
use sctk::reexports::client::protocol::{
use smithay_client_toolkit::output::OutputMgr;
use smithay_client_toolkit::reexports::client::protocol::{
wl_keyboard, wl_output, wl_pointer, wl_registry, wl_seat, wl_touch,
};
use sctk::reexports::client::{ConnectError, Display, EventQueue, GlobalEvent};
use sctk::Environment;
use smithay_client_toolkit::reexports::client::{ConnectError, Display, EventQueue, GlobalEvent};
use smithay_client_toolkit::Environment;
pub struct WindowEventsSink {
buffer: VecDeque<(::event::WindowEvent, ::window::WindowId)>,
buffer: VecDeque<(crate::event::WindowEvent, crate::window::WindowId)>,
}
impl WindowEventsSink {
@ -32,16 +32,16 @@ impl WindowEventsSink {
}
}
pub fn send_event(&mut self, evt: ::event::WindowEvent, wid: WindowId) {
self.buffer.push_back((evt, ::window::WindowId(::platform_impl::WindowId::Wayland(wid))));
pub fn send_event(&mut self, evt: crate::event::WindowEvent, wid: WindowId) {
self.buffer.push_back((evt, crate::window::WindowId(crate::platform_impl::WindowId::Wayland(wid))));
}
fn empty_with<F, T>(&mut self, mut callback: F)
where
F: FnMut(::event::Event<T>),
F: FnMut(crate::event::Event<T>),
{
for (evt, wid) in self.buffer.drain(..) {
callback(::event::Event::WindowEvent { event: evt, window_id: wid})
callback(crate::event::Event::WindowEvent { event: evt, window_id: wid})
}
}
}
@ -58,7 +58,7 @@ pub struct EventLoop<T: 'static> {
pending_user_events: Rc<RefCell<VecDeque<T>>>,
_user_source: ::calloop::Source<::calloop::channel::Channel<T>>,
user_sender: ::calloop::channel::Sender<T>,
_kbd_source: ::calloop::Source<::calloop::channel::Channel<(::event::WindowEvent, super::WindowId)>>,
_kbd_source: ::calloop::Source<::calloop::channel::Channel<(crate::event::WindowEvent, super::WindowId)>>,
window_target: RootELW<T>
}
@ -160,7 +160,7 @@ impl<T: 'static> EventLoop<T> {
user_sender,
_kbd_source: kbd_source,
window_target: RootELW {
p: ::platform_impl::EventLoopWindowTarget::Wayland(EventLoopWindowTarget {
p: crate::platform_impl::EventLoopWindowTarget::Wayland(EventLoopWindowTarget {
evq: RefCell::new(source),
store,
env,
@ -181,14 +181,14 @@ impl<T: 'static> EventLoop<T> {
}
pub fn run<F>(mut self, callback: F) -> !
where F: 'static + FnMut(::event::Event<T>, &RootELW<T>, &mut ControlFlow)
where F: 'static + FnMut(crate::event::Event<T>, &RootELW<T>, &mut ControlFlow)
{
self.run_return(callback);
::std::process::exit(0);
}
pub fn run_return<F>(&mut self, mut callback: F)
where F: FnMut(::event::Event<T>, &RootELW<T>, &mut ControlFlow)
where F: FnMut(crate::event::Event<T>, &RootELW<T>, &mut ControlFlow)
{
// send pending events to the server
self.display.flush().expect("Wayland connection lost.");
@ -198,7 +198,7 @@ impl<T: 'static> EventLoop<T> {
let sink = self.sink.clone();
let user_events = self.pending_user_events.clone();
callback(::event::Event::NewEvents(::event::StartCause::Init), &self.window_target, &mut control_flow);
callback(crate::event::Event::NewEvents(crate::event::StartCause::Init), &self.window_target, &mut control_flow);
loop {
self.post_dispatch_triggers();
@ -215,7 +215,7 @@ impl<T: 'static> EventLoop<T> {
let mut guard = user_events.borrow_mut();
for evt in guard.drain(..) {
sticky_exit_callback(
::event::Event::UserEvent(evt),
crate::event::Event::UserEvent(evt),
&self.window_target,
&mut control_flow,
&mut callback
@ -234,7 +234,7 @@ impl<T: 'static> EventLoop<T> {
// send Events cleared
{
sticky_exit_callback(
::event::Event::EventsCleared,
crate::event::Event::EventsCleared,
&self.window_target,
&mut control_flow,
&mut callback
@ -249,12 +249,12 @@ impl<T: 'static> EventLoop<T> {
ControlFlow::Poll => {
// non-blocking dispatch
self.inner_loop.dispatch(Some(::std::time::Duration::from_millis(0)), &mut ()).unwrap();
callback(::event::Event::NewEvents(::event::StartCause::Poll), &self.window_target, &mut control_flow);
callback(crate::event::Event::NewEvents(crate::event::StartCause::Poll), &self.window_target, &mut control_flow);
},
ControlFlow::Wait => {
self.inner_loop.dispatch(None, &mut ()).unwrap();
callback(
::event::Event::NewEvents(::event::StartCause::WaitCancelled {
crate::event::Event::NewEvents(crate::event::StartCause::WaitCancelled {
start: Instant::now(),
requested_resume: None
}),
@ -274,7 +274,7 @@ impl<T: 'static> EventLoop<T> {
let now = Instant::now();
if now < deadline {
callback(
::event::Event::NewEvents(::event::StartCause::WaitCancelled {
crate::event::Event::NewEvents(crate::event::StartCause::WaitCancelled {
start,
requested_resume: Some(deadline)
}),
@ -283,7 +283,7 @@ impl<T: 'static> EventLoop<T> {
);
} else {
callback(
::event::Event::NewEvents(::event::StartCause::ResumeTimeReached {
crate::event::Event::NewEvents(crate::event::StartCause::ResumeTimeReached {
start,
requested_resume: deadline
}),
@ -295,7 +295,7 @@ impl<T: 'static> EventLoop<T> {
}
}
callback(::event::Event::LoopDestroyed, &self.window_target, &mut control_flow);
callback(crate::event::Event::LoopDestroyed, &self.window_target, &mut control_flow);
}
pub fn primary_monitor(&self) -> MonitorHandle {
@ -323,7 +323,7 @@ impl<T> EventLoop<T> {
fn post_dispatch_triggers(&mut self) {
let mut sink = self.sink.lock().unwrap();
let window_target = match self.window_target.p {
::platform_impl::EventLoopWindowTarget::Wayland(ref wt) => wt,
crate::platform_impl::EventLoopWindowTarget::Wayland(ref wt) => wt,
_ => unreachable!()
};
// prune possible dead windows
@ -333,7 +333,7 @@ impl<T> EventLoop<T> {
let pruned = window_target.store.lock().unwrap().cleanup();
*cleanup_needed = false;
for wid in pruned {
sink.send_event(::event::WindowEvent::Destroyed, wid);
sink.send_event(crate::event::WindowEvent::Destroyed, wid);
}
}
}
@ -344,8 +344,8 @@ impl<T> EventLoop<T> {
if let Some((w, h)) = newsize {
frame.resize(w, h);
frame.refresh();
let logical_size = ::dpi::LogicalSize::new(w as f64, h as f64);
sink.send_event(::event::WindowEvent::Resized(logical_size), wid);
let logical_size = crate::dpi::LogicalSize::new(w as f64, h as f64);
sink.send_event(crate::event::WindowEvent::Resized(logical_size), wid);
*size = (w, h);
} else if frame_refresh {
frame.refresh();
@ -355,13 +355,13 @@ impl<T> EventLoop<T> {
}
}
if let Some(dpi) = new_dpi {
sink.send_event(::event::WindowEvent::HiDpiFactorChanged(dpi as f64), wid);
sink.send_event(crate::event::WindowEvent::HiDpiFactorChanged(dpi as f64), wid);
}
if refresh {
sink.send_event(::event::WindowEvent::RedrawRequested, wid);
sink.send_event(crate::event::WindowEvent::RedrawRequested, wid);
}
if closed {
sink.send_event(::event::WindowEvent::CloseRequested, wid);
sink.send_event(crate::event::WindowEvent::CloseRequested, wid);
}
},
)
@ -376,7 +376,7 @@ struct SeatManager {
sink: Arc<Mutex<WindowEventsSink>>,
store: Arc<Mutex<WindowStore>>,
seats: Arc<Mutex<Vec<(u32, wl_seat::WlSeat)>>>,
kbd_sender: ::calloop::channel::Sender<(::event::WindowEvent, super::WindowId)>
kbd_sender: ::calloop::channel::Sender<(crate::event::WindowEvent, super::WindowId)>
}
impl SeatManager {
@ -417,7 +417,7 @@ impl SeatManager {
struct SeatData {
sink: Arc<Mutex<WindowEventsSink>>,
store: Arc<Mutex<WindowStore>>,
kbd_sender: ::calloop::channel::Sender<(::event::WindowEvent, super::WindowId)>,
kbd_sender: ::calloop::channel::Sender<(crate::event::WindowEvent, super::WindowId)>,
pointer: Option<wl_pointer::WlPointer>,
keyboard: Option<wl_keyboard::WlKeyboard>,
touch: Option<wl_touch::WlTouch>,
@ -523,7 +523,7 @@ impl Clone for MonitorHandle {
}
impl fmt::Debug for MonitorHandle {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
#[derive(Debug)]
struct MonitorHandle {
name: Option<String>,

18
src/platform_impl/linux/wayland/keyboard.rs
View file

@ -1,16 +1,16 @@
use std::sync::{Arc, Mutex};
use super::{make_wid, DeviceId};
use sctk::keyboard::{
use smithay_client_toolkit::keyboard::{
self, map_keyboard_auto_with_repeat, Event as KbEvent, KeyRepeatEvent, KeyRepeatKind,
};
use sctk::reexports::client::protocol::{wl_keyboard, wl_seat};
use smithay_client_toolkit::reexports::client::protocol::{wl_keyboard, wl_seat};
use event::{ElementState, KeyboardInput, ModifiersState, VirtualKeyCode, WindowEvent};
use crate::event::{ElementState, KeyboardInput, ModifiersState, VirtualKeyCode, WindowEvent};
pub fn init_keyboard(
seat: &wl_seat::WlSeat,
sink: ::calloop::channel::Sender<(::event::WindowEvent, super::WindowId)>,
sink: ::calloop::channel::Sender<(crate::event::WindowEvent, super::WindowId)>,
modifiers_tracker: Arc<Mutex<ModifiersState>>,
) -> wl_keyboard::WlKeyboard {
// { variables to be captured by the closures
@ -23,7 +23,7 @@ pub fn init_keyboard(
let ret = map_keyboard_auto_with_repeat(
seat,
KeyRepeatKind::System,
move |evt: KbEvent, _| match evt {
move |evt: KbEvent<'_>, _| match evt {
KbEvent::Enter { surface, .. } => {
let wid = make_wid(&surface);
my_sink.send((WindowEvent::Focused(true), wid)).unwrap();
@ -50,7 +50,7 @@ pub fn init_keyboard(
let vkcode = key_to_vkey(rawkey, keysym);
my_sink.send(
(WindowEvent::KeyboardInput {
device_id: ::event::DeviceId(::platform_impl::DeviceId::Wayland(DeviceId)),
device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(DeviceId)),
input: KeyboardInput {
state: state,
scancode: rawkey,
@ -82,7 +82,7 @@ pub fn init_keyboard(
let vkcode = key_to_vkey(repeat_event.rawkey, repeat_event.keysym);
repeat_sink.send((
WindowEvent::KeyboardInput {
device_id: ::event::DeviceId(::platform_impl::DeviceId::Wayland(DeviceId)),
device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(DeviceId)),
input: KeyboardInput {
state: state,
scancode: repeat_event.rawkey,
@ -136,7 +136,7 @@ pub fn init_keyboard(
};
my_sink.send((
WindowEvent::KeyboardInput {
device_id: ::event::DeviceId(::platform_impl::DeviceId::Wayland(DeviceId)),
device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(DeviceId)),
input: KeyboardInput {
state: state,
scancode: key,
@ -173,7 +173,7 @@ fn key_to_vkey(rawkey: u32, keysym: u32) -> Option<VirtualKeyCode> {
}
fn keysym_to_vkey(keysym: u32) -> Option<VirtualKeyCode> {
use sctk::keyboard::keysyms;
use smithay_client_toolkit::keyboard::keysyms;
match keysym {
// letters
keysyms::XKB_KEY_A | keysyms::XKB_KEY_a => Some(VirtualKeyCode::A),

2
src/platform_impl/linux/wayland/mod.rs
View file

@ -4,7 +4,7 @@
pub use self::window::Window;
pub use self::event_loop::{EventLoop, EventLoopWindowTarget, EventLoopProxy, WindowEventsSink, MonitorHandle};
use sctk::reexports::client::protocol::wl_surface;
use smithay_client_toolkit::reexports::client::protocol::wl_surface;
mod event_loop;
mod pointer;

22
src/platform_impl/linux/wayland/pointer.rs
View file

@ -1,13 +1,13 @@
use std::sync::{Arc, Mutex};
use event::{ElementState, MouseButton, MouseScrollDelta, TouchPhase, WindowEvent, ModifiersState};
use crate::event::{ElementState, MouseButton, MouseScrollDelta, TouchPhase, WindowEvent, ModifiersState};
use super::DeviceId;
use super::event_loop::WindowEventsSink;
use super::window::WindowStore;
use sctk::reexports::client::protocol::wl_pointer::{self, Event as PtrEvent, WlPointer};
use sctk::reexports::client::protocol::wl_seat;
use smithay_client_toolkit::reexports::client::protocol::wl_pointer::{self, Event as PtrEvent, WlPointer};
use smithay_client_toolkit::reexports::client::protocol::wl_seat;
pub fn implement_pointer(
seat: &wl_seat::WlSeat,
@ -36,13 +36,13 @@ pub fn implement_pointer(
mouse_focus = Some(wid);
sink.send_event(
WindowEvent::CursorEntered {
device_id: ::event::DeviceId(::platform_impl::DeviceId::Wayland(DeviceId)),
device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(DeviceId)),
},
wid,
);
sink.send_event(
WindowEvent::CursorMoved {
device_id: ::event::DeviceId(::platform_impl::DeviceId::Wayland(DeviceId)),
device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(DeviceId)),
position: (surface_x, surface_y).into(),
modifiers: modifiers_tracker.lock().unwrap().clone(),
},
@ -56,7 +56,7 @@ pub fn implement_pointer(
if let Some(wid) = wid {
sink.send_event(
WindowEvent::CursorLeft {
device_id: ::event::DeviceId(::platform_impl::DeviceId::Wayland(DeviceId)),
device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(DeviceId)),
},
wid,
);
@ -70,7 +70,7 @@ pub fn implement_pointer(
if let Some(wid) = mouse_focus {
sink.send_event(
WindowEvent::CursorMoved {
device_id: ::event::DeviceId(::platform_impl::DeviceId::Wayland(DeviceId)),
device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(DeviceId)),
position: (surface_x, surface_y).into(),
modifiers: modifiers_tracker.lock().unwrap().clone(),
},
@ -94,7 +94,7 @@ pub fn implement_pointer(
};
sink.send_event(
WindowEvent::MouseInput {
device_id: ::event::DeviceId(::platform_impl::DeviceId::Wayland(DeviceId)),
device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(DeviceId)),
state: state,
button: button,
modifiers: modifiers_tracker.lock().unwrap().clone(),
@ -116,7 +116,7 @@ pub fn implement_pointer(
}
sink.send_event(
WindowEvent::MouseWheel {
device_id: ::event::DeviceId(::platform_impl::DeviceId::Wayland(DeviceId)),
device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(DeviceId)),
delta: MouseScrollDelta::PixelDelta((x as f64, y as f64).into()),
phase: TouchPhase::Moved,
modifiers: modifiers_tracker.lock().unwrap().clone(),
@ -146,7 +146,7 @@ pub fn implement_pointer(
if let Some((x, y)) = axis_discrete_buffer {
sink.send_event(
WindowEvent::MouseWheel {
device_id: ::event::DeviceId(::platform_impl::DeviceId::Wayland(DeviceId)),
device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(DeviceId)),
delta: MouseScrollDelta::LineDelta(x as f32, y as f32),
phase: axis_state,
modifiers: modifiers_tracker.lock().unwrap().clone(),
@ -156,7 +156,7 @@ pub fn implement_pointer(
} else if let Some((x, y)) = axis_buffer {
sink.send_event(
WindowEvent::MouseWheel {
device_id: ::event::DeviceId(::platform_impl::DeviceId::Wayland(DeviceId)),
device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(DeviceId)),
delta: MouseScrollDelta::PixelDelta((x as f64, y as f64).into()),
phase: axis_state,
modifiers: modifiers_tracker.lock().unwrap().clone(),

22
src/platform_impl/linux/wayland/touch.rs
View file

@ -1,13 +1,13 @@
use std::sync::{Arc, Mutex};
use event::{TouchPhase, WindowEvent};
use crate::event::{TouchPhase, WindowEvent};
use super::{DeviceId, WindowId};
use super::event_loop::WindowEventsSink;
use super::window::WindowStore;
use sctk::reexports::client::protocol::wl_touch::{Event as TouchEvent, WlTouch};
use sctk::reexports::client::protocol::wl_seat;
use smithay_client_toolkit::reexports::client::protocol::wl_touch::{Event as TouchEvent, WlTouch};
use smithay_client_toolkit::reexports::client::protocol::wl_seat;
struct TouchPoint {
wid: WindowId,
@ -32,8 +32,8 @@ pub(crate) fn implement_touch(
let wid = store.find_wid(&surface);
if let Some(wid) = wid {
sink.send_event(
WindowEvent::Touch(::event::Touch {
device_id: ::event::DeviceId(::platform_impl::DeviceId::Wayland(DeviceId)),
WindowEvent::Touch(crate::event::Touch {
device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(DeviceId)),
phase: TouchPhase::Started,
location: (x, y).into(),
id: id as u64,
@ -52,8 +52,8 @@ pub(crate) fn implement_touch(
if let Some(idx) = idx {
let pt = pending_ids.remove(idx);
sink.send_event(
WindowEvent::Touch(::event::Touch {
device_id: ::event::DeviceId(::platform_impl::DeviceId::Wayland(DeviceId)),
WindowEvent::Touch(crate::event::Touch {
device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(DeviceId)),
phase: TouchPhase::Ended,
location: pt.location.into(),
id: id as u64,
@ -67,8 +67,8 @@ pub(crate) fn implement_touch(
if let Some(pt) = pt {
pt.location = (x, y);
sink.send_event(
WindowEvent::Touch(::event::Touch {
device_id: ::event::DeviceId(::platform_impl::DeviceId::Wayland(DeviceId)),
WindowEvent::Touch(crate::event::Touch {
device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(DeviceId)),
phase: TouchPhase::Moved,
location: (x, y).into(),
id: id as u64,
@ -80,8 +80,8 @@ pub(crate) fn implement_touch(
TouchEvent::Frame => (),
TouchEvent::Cancel => for pt in pending_ids.drain(..) {
sink.send_event(
WindowEvent::Touch(::event::Touch {
device_id: ::event::DeviceId(::platform_impl::DeviceId::Wayland(DeviceId)),
WindowEvent::Touch(crate::event::Touch {
device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(DeviceId)),
phase: TouchPhase::Cancelled,
location: pt.location.into(),
id: pt.id as u64,

24
src/platform_impl/linux/wayland/window.rs
View file

@ -2,20 +2,20 @@ use std::collections::VecDeque;
use std::io::{Seek, SeekFrom, Write};
use std::sync::{Arc, Mutex, Weak};
use dpi::{LogicalPosition, LogicalSize};
use error::{ExternalError, NotSupportedError, OsError as RootOsError};
use platform_impl::{MonitorHandle as PlatformMonitorHandle, PlatformSpecificWindowBuilderAttributes as PlAttributes};
use monitor::MonitorHandle as RootMonitorHandle;
use window::{WindowAttributes, CursorIcon};
use crate::dpi::{LogicalPosition, LogicalSize};
use crate::error::{ExternalError, NotSupportedError, OsError as RootOsError};
use crate::platform_impl::{MonitorHandle as PlatformMonitorHandle, PlatformSpecificWindowBuilderAttributes as PlAttributes};
use crate::monitor::MonitorHandle as RootMonitorHandle;
use crate::window::{WindowAttributes, CursorIcon};
use sctk::surface::{get_dpi_factor, get_outputs};
use sctk::window::{ConceptFrame, Event as WEvent, State as WState, Window as SWindow, Theme};
use sctk::reexports::client::{Display, NewProxy};
use sctk::reexports::client::protocol::{wl_seat, wl_surface, wl_subsurface, wl_shm};
use sctk::output::OutputMgr;
use smithay_client_toolkit::surface::{get_dpi_factor, get_outputs};
use smithay_client_toolkit::window::{ConceptFrame, Event as WEvent, State as WState, Window as SWindow, Theme};
use smithay_client_toolkit::reexports::client::{Display, NewProxy};
use smithay_client_toolkit::reexports::client::protocol::{wl_seat, wl_surface, wl_subsurface, wl_shm};
use smithay_client_toolkit::output::OutputMgr;
use super::{make_wid, EventLoopWindowTarget, MonitorHandle, WindowId};
use platform_impl::platform::wayland::event_loop::{available_monitors, primary_monitor};
use crate::platform_impl::platform::wayland::event_loop::{available_monitors, primary_monitor};
pub struct Window {
_bg_surface: wl_surface::WlSurface,
@ -60,7 +60,7 @@ impl Window {
let my_bg_surface = bg_surface.clone();
// prepare a 1px buffer to display on the root window
let mut pool = sctk::utils::MemPool::new(&evlp.env.shm, || {}).unwrap();
let mut pool = smithay_client_toolkit::utils::MemPool::new(&evlp.env.shm, || {}).unwrap();
pool.resize(4).unwrap();
pool.seek(SeekFrom::Start(0)).unwrap();
pool.write(&[0, 0, 0, 0]).unwrap();