From 4207611e6de4417853ec82a5ebdc49bf4005a715 Mon Sep 17 00:00:00 2001 From: Drakulix Date: Fri, 15 Dec 2017 18:38:10 +0100 Subject: [PATCH] rustfmt code --- src/backend/drm/backend.rs | 76 +++++----- src/backend/drm/mod.rs | 121 +++++++++++----- src/backend/graphics/egl.rs | 44 +++--- src/backend/graphics/mod.rs | 5 +- src/backend/graphics/software.rs | 1 - src/backend/libinput.rs | 20 +-- src/backend/session/direct.rs | 147 +++++++++++-------- src/backend/session/mod.rs | 28 ++-- src/backend/udev.rs | 220 +++++++++++++++++++---------- src/backend/winit.rs | 32 +++-- src/wayland/compositor/handlers.rs | 22 +-- src/wayland/compositor/mod.rs | 57 ++++---- src/wayland/compositor/tree.rs | 35 ++--- src/wayland/output/mod.rs | 21 +-- src/wayland/seat/keyboard.rs | 16 +-- src/wayland/seat/mod.rs | 17 ++- src/wayland/shell/mod.rs | 88 ++++++------ src/wayland/shell/wl_handlers.rs | 56 ++++---- src/wayland/shell/xdg_handlers.rs | 134 +++++++++--------- src/wayland/shm/mod.rs | 6 +- src/wayland/shm/pool.rs | 2 - 21 files changed, 648 insertions(+), 500 deletions(-) diff --git a/src/backend/drm/backend.rs b/src/backend/drm/backend.rs index 4ff7533..f48feb2 100644 --- a/src/backend/drm/backend.rs +++ b/src/backend/drm/backend.rs @@ -60,7 +60,6 @@ rental! { } use self::graphics::{Graphics, Surface}; - /// Backend based on a `DrmDevice` and a given crtc pub struct DrmBackend { graphics: Graphics, @@ -71,9 +70,10 @@ pub struct DrmBackend { } impl DrmBackend { - pub(crate) fn new(context: Rc, crtc: crtc::Handle, mode: Mode, - connectors: Vec, logger: ::slog::Logger) - -> Result { + pub(crate) fn new( + context: Rc, crtc: crtc::Handle, mode: Mode, connectors: Vec, + logger: ::slog::Logger, + ) -> Result { // logger already initialized by the DrmDevice let log = ::slog_or_stdlog(logger); info!(log, "Initializing DrmBackend"); @@ -145,9 +145,7 @@ impl DrmBackend { &connectors, (0, 0), Some(mode), - ).chain_err( - || ErrorKind::DrmDev(format!("{:?}", context.devices.drm)), - )?; + ).chain_err(|| ErrorKind::DrmDev(format!("{:?}", context.devices.drm)))?; front_bo.set_userdata(fb); Ok(EGL { @@ -193,9 +191,7 @@ impl DrmBackend { /// Errors if the new connector does not support the currently set `Mode` pub fn add_connector(&mut self, connector: connector::Handle) -> Result<()> { let info = connector::Info::load_from_device(self.graphics.head().head().head(), connector) - .chain_err(|| { - ErrorKind::DrmDev(format!("{:?}", self.graphics.head().head().head())) - })?; + .chain_err(|| ErrorKind::DrmDev(format!("{:?}", self.graphics.head().head().head())))?; // check if the connector can handle the current mode if info.modes().contains(&self.mode) { @@ -203,9 +199,8 @@ impl DrmBackend { let encoders = info.encoders() .iter() .map(|encoder| { - encoder::Info::load_from_device(self.graphics.head().head().head(), *encoder).chain_err( - || ErrorKind::DrmDev(format!("{:?}", self.graphics.head().head().head())), - ) + encoder::Info::load_from_device(self.graphics.head().head().head(), *encoder) + .chain_err(|| ErrorKind::DrmDev(format!("{:?}", self.graphics.head().head().head()))) }) .collect::>>()?; @@ -215,9 +210,7 @@ impl DrmBackend { .head() .head() .resource_handles() - .chain_err(|| { - ErrorKind::DrmDev(format!("{:?}", self.graphics.head().head().head())) - })?; + .chain_err(|| ErrorKind::DrmDev(format!("{:?}", self.graphics.head().head().head())))?; if !encoders .iter() .map(|encoder| encoder.possible_crtcs()) @@ -272,9 +265,7 @@ impl DrmBackend { // check the connectors for connector in &self.connectors { if !connector::Info::load_from_device(self.graphics.head().head().head(), *connector) - .chain_err(|| { - ErrorKind::DrmDev(format!("{:?}", self.graphics.head().head().head())) - })? + .chain_err(|| ErrorKind::DrmDev(format!("{:?}", self.graphics.head().head().head())))? .modes() .contains(&mode) { @@ -295,9 +286,7 @@ impl DrmBackend { // resolution. debug!( logger_ref, - "Reinitializing surface for new mode: {}:{}", - w, - h + "Reinitializing surface for new mode: {}:{}", w, h ); graphics.gbm.surface = Surface::try_new( { @@ -340,9 +329,8 @@ impl DrmBackend { front_bo.format() ); // we need a framebuffer per front_buffer - let fb = framebuffer::create(graphics.context.devices.drm, &*front_bo).chain_err(|| { - ErrorKind::DrmDev(format!("{:?}", graphics.context.devices.drm)) - })?; + let fb = framebuffer::create(graphics.context.devices.drm, &*front_bo) + .chain_err(|| ErrorKind::DrmDev(format!("{:?}", graphics.context.devices.drm)))?; debug!(logger_ref, "Initialize screen"); crtc::set( @@ -352,9 +340,7 @@ impl DrmBackend { connectors_ref, (0, 0), Some(mode), - ).chain_err(|| { - ErrorKind::DrmDev(format!("{:?}", graphics.context.devices.drm)) - })?; + ).chain_err(|| ErrorKind::DrmDev(format!("{:?}", graphics.context.devices.drm)))?; front_bo.set_userdata(fb); Ok(EGL { @@ -424,13 +410,12 @@ impl GraphicsBackend for DrmBackend { self.graphics.head().head().head(), self.crtc, (x as i32, y as i32), - ).chain_err(|| { - ErrorKind::DrmDev(format!("{:?}", self.graphics.head().head().head())) - }) + ).chain_err(|| ErrorKind::DrmDev(format!("{:?}", self.graphics.head().head().head()))) } - fn set_cursor_representation(&self, buffer: &ImageBuffer, Vec>, hotspot: (u32, u32)) - -> Result<()> { + fn set_cursor_representation( + &self, buffer: &ImageBuffer, Vec>, hotspot: (u32, u32) + ) -> Result<()> { let (w, h) = buffer.dimensions(); debug!(self.logger, "Importing cursor"); @@ -463,9 +448,9 @@ impl GraphicsBackend for DrmBackend { (hotspot.0 as i32, hotspot.1 as i32), ).is_err() { - crtc::set_cursor(self.graphics.head().head().head(), self.crtc, &cursor).chain_err(|| { - ErrorKind::DrmDev(format!("{:?}", self.graphics.head().head().head())) - })?; + crtc::set_cursor(self.graphics.head().head().head(), self.crtc, &cursor).chain_err( + || ErrorKind::DrmDev(format!("{:?}", self.graphics.head().head().head())), + )?; } // and store it @@ -498,7 +483,10 @@ impl EGLGraphicsBackend for DrmBackend { // would most likely result in a lot of flickering. // neither weston, wlc or wlroots bother with that as well. // so we just assume we got at least two buffers to do flipping - let mut next_bo = surface.gbm.lock_front_buffer().expect("Surface only has one front buffer. Not supported by smithay"); + let mut next_bo = surface + .gbm + .lock_front_buffer() + .expect("Surface only has one front buffer. Not supported by smithay"); // create a framebuffer if the front buffer does not have one already // (they are reused by gbm) @@ -506,7 +494,8 @@ impl EGLGraphicsBackend for DrmBackend { let fb = if let Some(info) = maybe_fb { info } else { - let fb = framebuffer::create(graphics.context.devices.drm, &*next_bo).map_err(|_| SwapBuffersError::ContextLost)?; + let fb = framebuffer::create(graphics.context.devices.drm, &*next_bo) + .map_err(|_| SwapBuffersError::ContextLost)?; next_bo.set_userdata(fb); fb }; @@ -515,7 +504,12 @@ impl EGLGraphicsBackend for DrmBackend { trace!(self.logger, "Queueing Page flip"); // and flip - crtc::page_flip(graphics.context.devices.drm, self.crtc, fb.handle(), &[crtc::PageFlipFlags::PageFlipEvent]).map_err(|_| SwapBuffersError::ContextLost) + crtc::page_flip( + graphics.context.devices.drm, + self.crtc, + fb.handle(), + &[crtc::PageFlipFlags::PageFlipEvent], + ).map_err(|_| SwapBuffersError::ContextLost) }) }) } @@ -532,7 +526,9 @@ impl EGLGraphicsBackend for DrmBackend { } fn is_current(&self) -> bool { - self.graphics.rent_all(|graphics| graphics.context.egl.is_current() && graphics.gbm.surface.rent(|egl| egl.surface.is_current())) + self.graphics.rent_all(|graphics| { + graphics.context.egl.is_current() && graphics.gbm.surface.rent(|egl| egl.surface.is_current()) + }) } unsafe fn make_current(&self) -> ::std::result::Result<(), SwapBuffersError> { diff --git a/src/backend/drm/mod.rs b/src/backend/drm/mod.rs index c7aba96..bc321b6 100644 --- a/src/backend/drm/mod.rs +++ b/src/backend/drm/mod.rs @@ -188,9 +188,9 @@ //! ``` use backend::graphics::egl::{EGLContext, GlAttributes, PixelFormatRequirements}; +use backend::graphics::egl::EGLGraphicsBackend; #[cfg(feature = "backend_session")] use backend::session::SessionObserver; -use backend::graphics::egl::EGLGraphicsBackend; use drm::Device as BasicDevice; use drm::control::{connector, crtc, encoder, Mode, ResourceInfo}; use drm::control::Device as ControlDevice; @@ -204,11 +204,11 @@ use std::collections::HashMap; use std::fs::File; use std::hash::{Hash, Hasher}; use std::io::Result as IoResult; -use std::os::unix::io::{IntoRawFd, AsRawFd, RawFd}; -use std::rc::Rc; use std::mem; +use std::os::unix::io::{AsRawFd, IntoRawFd, RawFd}; +use std::rc::Rc; use std::time::Duration; -use wayland_server::{EventLoopHandle, StateToken, StateProxy}; +use wayland_server::{EventLoopHandle, StateProxy, StateToken}; use wayland_server::sources::{FdEventSource, FdEventSourceImpl, FdInterest}; mod backend; @@ -369,25 +369,21 @@ impl + Borrow + 'static> DrmDevice { let mut old_state = HashMap::new(); let res_handles = drm.resource_handles() - .chain_err(|| { - ErrorKind::DrmDev(format!("Loading drm resources on {:?}", drm)) - })?; + .chain_err(|| ErrorKind::DrmDev(format!("Loading drm resources on {:?}", drm)))?; for &con in res_handles.connectors() { let con_info = connector::Info::load_from_device(&drm, con) - .chain_err(|| { - ErrorKind::DrmDev(format!("Loading connector info on {:?}", drm)) - })?; + .chain_err(|| ErrorKind::DrmDev(format!("Loading connector info on {:?}", drm)))?; if let Some(enc) = con_info.current_encoder() { let enc_info = encoder::Info::load_from_device(&drm, enc) - .chain_err(|| { - ErrorKind::DrmDev(format!("Loading encoder info on {:?}", drm)) - })?; + .chain_err(|| ErrorKind::DrmDev(format!("Loading encoder info on {:?}", drm)))?; if let Some(crtc) = enc_info.current_crtc() { let info = crtc::Info::load_from_device(&drm, crtc) - .chain_err(|| { - ErrorKind::DrmDev(format!("Loading crtc info on {:?}", drm)) - })?; - old_state.entry(crtc).or_insert((info, Vec::new())).1.push(con); + .chain_err(|| ErrorKind::DrmDev(format!("Loading crtc info on {:?}", drm)))?; + old_state + .entry(crtc) + .or_insert((info, Vec::new())) + .1 + .push(con); } } } @@ -426,8 +422,9 @@ impl + Borrow + 'static> DrmDevice { /// /// Errors if initialization fails or the mode is not available on all given /// connectors. - pub fn create_backend<'a, I, S>(&mut self, state: S, crtc: crtc::Handle, mode: Mode, connectors: I) - -> Result<&StateToken> + pub fn create_backend<'a, I, S>( + &mut self, state: S, crtc: crtc::Handle, mode: Mode, connectors: I + ) -> Result<&StateToken> where I: Into>, S: Into>, @@ -447,7 +444,10 @@ impl + Borrow + 'static> DrmDevice { for connector in &connectors { let con_info = connector::Info::load_from_device(self.context.head().head(), *connector) .chain_err(|| { - ErrorKind::DrmDev(format!("Loading connector info on {:?}", self.context.head().head())) + ErrorKind::DrmDev(format!( + "Loading connector info on {:?}", + self.context.head().head() + )) })?; // check the mode @@ -461,21 +461,26 @@ impl + Borrow + 'static> DrmDevice { .iter() .map(|encoder| { encoder::Info::load_from_device(self.context.head().head(), *encoder).chain_err(|| { - ErrorKind::DrmDev(format!("Loading encoder info on {:?}", self.context.head().head())) + ErrorKind::DrmDev(format!( + "Loading encoder info on {:?}", + self.context.head().head() + )) }) }) .collect::>>()?; // and if any encoder supports the selected crtc let resource_handles = self.resource_handles().chain_err(|| { - ErrorKind::DrmDev(format!("Loading drm resources on {:?}", self.context.head().head())) + ErrorKind::DrmDev(format!( + "Loading drm resources on {:?}", + self.context.head().head() + )) })?; if !encoders .iter() .map(|encoder| encoder.possible_crtcs()) - .any(|crtc_list| { - resource_handles.filter_crtcs(crtc_list).contains(&crtc) - }) { + .any(|crtc_list| resource_handles.filter_crtcs(crtc_list).contains(&crtc)) + { bail!(ErrorKind::NoSuitableEncoder(con_info, crtc)) } } @@ -484,7 +489,8 @@ impl + Borrow + 'static> DrmDevice { let logger = self.logger.new(o!("crtc" => format!("{:?}", crtc))); let backend = DrmBackend::new(self.context.clone(), crtc, mode, connectors, logger)?; - self.backends.insert(crtc, state.into().insert(backend.into())); + self.backends + .insert(crtc, state.into().insert(backend.into())); Ok(self.backends.get(&crtc).unwrap()) } @@ -505,7 +511,7 @@ impl + Borrow + 'static> DrmDevice { /// Panics if the backend is already borrowed from the state pub fn destroy_backend<'a, S>(&mut self, state: S, crtc: &crtc::Handle) where - S: Into> + S: Into>, { if let Some(token) = self.backends.remove(crtc) { state.into().remove(token); @@ -540,12 +546,25 @@ impl + 'static> Drop for DrmDevice { panic!("Pending DrmBackends. Please free all backends before the DrmDevice gets destroyed"); } for (handle, (info, connectors)) in self.old_state.drain() { - if let Err(err) = crtc::set(self.context.head().head(), handle, info.fb(), &connectors, info.position(), info.mode()) { - error!(self.logger, "Failed to reset crtc ({:?}). Error: {}", handle, err); + if let Err(err) = crtc::set( + self.context.head().head(), + handle, + info.fb(), + &connectors, + info.position(), + info.mode(), + ) { + error!( + self.logger, + "Failed to reset crtc ({:?}). Error: {}", handle, err + ); } } if let Err(err) = self.drop_master() { - error!(self.logger, "Failed to drop drm master state. Error: {}", err); + error!( + self.logger, + "Failed to drop drm master state. Error: {}", err + ); } } } @@ -569,8 +588,10 @@ pub trait DrmHandler + 'static> { /// ## Panics /// The device is already borrowed from the given `state`. Borrowing it again will panic /// and is not necessary as it is already provided via the `device` parameter. - fn ready<'a, S: Into>>(&mut self, state: S, device: &mut DrmDevice, backend: &StateToken, - crtc: crtc::Handle, frame: u32, duration: Duration); + fn ready<'a, S: Into>>( + &mut self, state: S, device: &mut DrmDevice, backend: &StateToken, crtc: crtc::Handle, + frame: u32, duration: Duration, + ); /// The `DrmDevice` has thrown an error. /// /// The related backends are most likely *not* usable anymore and @@ -585,8 +606,9 @@ pub trait DrmHandler + 'static> { /// Bind a `DrmDevice` to an `EventLoop`, /// /// This will cause it to recieve events and feed them into an `DrmHandler` -pub fn drm_device_bind(evlh: &mut EventLoopHandle, device: StateToken>, handler: H) - -> IoResult>, H)>> +pub fn drm_device_bind( + evlh: &mut EventLoopHandle, device: StateToken>, handler: H +) -> IoResult>, H)>> where B: From + Borrow + 'static, H: DrmHandler + 'static, @@ -624,13 +646,22 @@ where state.get(&backend_token).borrow().unlock_buffer(); trace!(logger, "Handling event for backend {:?}", event.crtc); // and then call the user to render the next frame - handler.ready(state, &mut dev, &backend_token, event.crtc, event.frame, event.duration); + handler.ready( + state, + &mut dev, + &backend_token, + event.crtc, + event.frame, + event.duration, + ); } } }); } }, - Err(err) => evlh.state().with_value(dev_token, |state, mut dev| handler.error(state, &mut dev, err)), + Err(err) => evlh.state().with_value(dev_token, |state, mut dev| { + handler.error(state, &mut dev, err) + }), }; }, error: |evlh, &mut (ref mut dev_token, ref mut handler), _, error| { @@ -648,7 +679,10 @@ impl + 'static> SessionObserver for StateToken = state.get_mut(self); device.active = false; if let Err(err) = device.drop_master() { - error!(device.logger, "Failed to drop drm master state. Error: {}", err); + error!( + device.logger, + "Failed to drop drm master state. Error: {}", err + ); } } @@ -656,13 +690,22 @@ impl + 'static> SessionObserver for StateToken { impl<'a> EGLContext<'a, ()> { /// Create a new context from a given `winit`-`Window` #[cfg(feature = "backend_winit")] - pub fn new_from_winit(window: &'a WinitWindow, attributes: GlAttributes, - reqs: PixelFormatRequirements, logger: L) - -> Result> + pub fn new_from_winit( + window: &'a WinitWindow, attributes: GlAttributes, reqs: PixelFormatRequirements, logger: L + ) -> Result> where L: Into>, { @@ -268,9 +268,9 @@ impl<'a> EGLContext<'a, ()> { /// Create a new context from a given `gbm::Device` #[cfg(feature = "backend_drm")] - pub fn new_from_gbm(gbm: &'a GbmDevice<'a>, attributes: GlAttributes, - reqs: PixelFormatRequirements, logger: L) - -> Result>> + pub fn new_from_gbm( + gbm: &'a GbmDevice<'a>, attributes: GlAttributes, reqs: PixelFormatRequirements, logger: L + ) -> Result>> where L: Into>, { @@ -288,9 +288,10 @@ impl<'a> EGLContext<'a, ()> { } impl<'a, T: NativeSurface> EGLContext<'a, T> { - unsafe fn new(native: NativeDisplayPtr, mut attributes: GlAttributes, reqs: PixelFormatRequirements, - log: ::slog::Logger) - -> Result> + unsafe fn new( + native: NativeDisplayPtr, mut attributes: GlAttributes, reqs: PixelFormatRequirements, + log: ::slog::Logger, + ) -> Result> where T: NativeSurface, { @@ -322,8 +323,7 @@ impl<'a, T: NativeSurface> EGLContext<'a, T> { Some(version) => { error!( log, - "OpenGLES {:?} is unknown and not supported by the EGL renderer backend", - version + "OpenGLES {:?} is unknown and not supported by the EGL renderer backend", version ); bail!(ErrorKind::OpenGlVersionNotSupported(version)); } @@ -423,9 +423,9 @@ impl<'a, T: NativeSurface> EGLContext<'a, T> { ) } - NativeDisplayPtr::X11(display) | - NativeDisplayPtr::Gbm(display) | - NativeDisplayPtr::Wayland(display) => { + NativeDisplayPtr::X11(display) + | NativeDisplayPtr::Gbm(display) + | NativeDisplayPtr::Wayland(display) => { trace!(log, "Default EGL Display Initialization via GetDisplay"); egl.GetDisplay(display as *mut _) } @@ -727,9 +727,9 @@ impl<'a, T: NativeSurface> EGLContext<'a, T> { self.display, self.config_id, match surface { - NativeSurfacePtr::X11(ptr) | - NativeSurfacePtr::Wayland(ptr) | - NativeSurfacePtr::Gbm(ptr) => ptr, + NativeSurfacePtr::X11(ptr) + | NativeSurfacePtr::Wayland(ptr) + | NativeSurfacePtr::Gbm(ptr) => ptr, }, self.surface_attributes.as_ptr(), ) @@ -850,8 +850,10 @@ impl<'context, 'surface, T: NativeSurface> EGLSurface<'context, 'surface, T> { /// Returns true if the OpenGL surface is the current one in the thread. pub fn is_current(&self) -> bool { - unsafe { self.context.egl.GetCurrentSurface(ffi::egl::DRAW as _) == self.surface as *const _ && - self.context.egl.GetCurrentSurface(ffi::egl::READ as _) == self.surface as *const _ } + unsafe { + self.context.egl.GetCurrentSurface(ffi::egl::DRAW as _) == self.surface as *const _ + && self.context.egl.GetCurrentSurface(ffi::egl::READ as _) == self.surface as *const _ + } } } @@ -905,10 +907,8 @@ impl error::Error for SwapBuffersError { SwapBuffersError::ContextLost => "The context has been lost, it needs to be recreated", SwapBuffersError::AlreadySwapped => { "Buffers are already swapped, swap_buffers was called too many times" - }, - SwapBuffersError::Unknown(_) => { - "Unknown Open GL error occurred" } + SwapBuffersError::Unknown(_) => "Unknown Open GL error occurred", } } diff --git a/src/backend/graphics/mod.rs b/src/backend/graphics/mod.rs index 2f0917e..05d276e 100644 --- a/src/backend/graphics/mod.rs +++ b/src/backend/graphics/mod.rs @@ -29,8 +29,9 @@ pub trait GraphicsBackend { /// The format is entirely dictated by the concrete implementation and might range /// from raw image buffers over a fixed list of possible cursor types to simply the /// void type () to represent no possible customization of the cursor itself. - fn set_cursor_representation(&self, cursor: &Self::CursorFormat, hotspot: (u32, u32)) - -> Result<(), Self::Error>; + fn set_cursor_representation( + &self, cursor: &Self::CursorFormat, hotspot: (u32, u32) + ) -> Result<(), Self::Error>; } pub mod software; diff --git a/src/backend/graphics/software.rs b/src/backend/graphics/software.rs index e053c77..2a96606 100644 --- a/src/backend/graphics/software.rs +++ b/src/backend/graphics/software.rs @@ -1,6 +1,5 @@ //! Common traits and types used for software rendering on graphics backends - use super::GraphicsBackend; use std::error::Error; use wayland_server::protocol::wl_shm::Format; diff --git a/src/backend/libinput.rs b/src/backend/libinput.rs index 4c27a3b..7c5475b 100644 --- a/src/backend/libinput.rs +++ b/src/backend/libinput.rs @@ -1,16 +1,16 @@ //! Implementation of input backend trait for types provided by `libinput` +use backend::input as backend; #[cfg(feature = "backend_session")] use backend::session::{AsErrno, Session, SessionObserver}; -use backend::input as backend; use input as libinput; use input::event; use std::collections::hash_map::{DefaultHasher, Entry, HashMap}; use std::hash::{Hash, Hasher}; use std::io::{Error as IoError, Result as IoResult}; -use std::rc::Rc; -use std::path::Path; use std::os::unix::io::RawFd; +use std::path::Path; +use std::rc::Rc; use wayland_server::{EventLoopHandle, StateProxy}; use wayland_server::sources::{FdEventSource, FdEventSourceImpl, FdInterest}; @@ -583,7 +583,9 @@ impl From for LibinputSessionInterface { impl libinput::LibinputInterface for LibinputSessionInterface { fn open_restricted(&mut self, path: &Path, flags: i32) -> Result { use nix::fcntl::OFlag; - self.0.open(path, OFlag::from_bits_truncate(flags)).map_err(|err| err.as_errno().unwrap_or(1 /*Use EPERM by default*/)) + self.0 + .open(path, OFlag::from_bits_truncate(flags)) + .map_err(|err| err.as_errno().unwrap_or(1 /*Use EPERM by default*/)) } fn close_restricted(&mut self, fd: RawFd) { @@ -595,9 +597,9 @@ impl libinput::LibinputInterface for LibinputSessionInterface { /// /// Automatically feeds the backend with incoming events without any manual calls to /// `dispatch_new_events`. Should be used to achieve the smallest possible latency. -pub fn libinput_bind(backend: LibinputInputBackend, evlh: &mut EventLoopHandle) - -> IoResult> -{ +pub fn libinput_bind( + backend: LibinputInputBackend, evlh: &mut EventLoopHandle +) -> IoResult> { let fd = unsafe { backend.context.fd() }; evlh.add_fd_event_source( fd, @@ -610,13 +612,13 @@ pub fn libinput_bind(backend: LibinputInputBackend, evlh: &mut EventLoopHandle) fn fd_event_source_implementation() -> FdEventSourceImpl { FdEventSourceImpl { ready: |_evlh, ref mut backend, _, _| { - use ::backend::input::InputBackend; + use backend::input::InputBackend; if let Err(error) = backend.dispatch_new_events() { warn!(backend.logger, "Libinput errored: {}", error); } }, error: |_evlh, ref backend, _, error| { warn!(backend.logger, "Libinput fd errored: {}", error); - } + }, } } diff --git a/src/backend/session/direct.rs b/src/backend/session/direct.rs index 47b9a63..2b23d04 100644 --- a/src/backend/session/direct.rs +++ b/src/backend/session/direct.rs @@ -46,24 +46,22 @@ //! automatically by the `UdevBackend`, if not done manually). //! ``` -use std::io::Result as IoResult; -use std::path::Path; -use std::os::unix::io::RawFd; -use std::sync::Arc; -use std::sync::atomic::{AtomicBool, Ordering}; +use super::{AsErrno, Session, SessionNotifier, SessionObserver}; use nix::{Error as NixError, Result as NixResult}; use nix::fcntl::{self, open, OFlag}; use nix::libc::c_int; use nix::sys::signal::{self, Signal}; -use nix::sys::stat::{dev_t, major, minor, Mode, fstat}; -use nix::unistd::{dup, close}; -use wayland_server::EventLoopHandle; -use wayland_server::sources::SignalEventSource; - +use nix::sys::stat::{dev_t, fstat, major, minor, Mode}; +use nix::unistd::{close, dup}; +use std::io::Result as IoResult; +use std::os::unix::io::RawFd; +use std::path::Path; +use std::sync::Arc; +use std::sync::atomic::{AtomicBool, Ordering}; #[cfg(feature = "backend_session_udev")] use udev::Context; - -use super::{AsErrno, Session, SessionNotifier, SessionObserver}; +use wayland_server::EventLoopHandle; +use wayland_server::sources::SignalEventSource; #[allow(dead_code)] mod tty { @@ -102,7 +100,7 @@ mod tty { pub const VT_PROCESS: i8 = 0x01; pub const VT_ACKACQ: i32 = 0x02; - extern { + extern "C" { pub fn __libc_current_sigrtmin() -> i8; pub fn __libc_current_sigrtmax() -> i8; } @@ -139,8 +137,8 @@ fn is_tty_device(dev: dev_t, path: Option<&Path>) -> bool { major(dev) == TTY_MAJOR }; res || minor(dev) != 0 - }, - None => major(dev) == TTY_MAJOR || minor(dev) != 0 + } + None => major(dev) == TTY_MAJOR || minor(dev) != 0, } } @@ -167,34 +165,36 @@ impl DirectSession { /// /// If you do not provide a tty device path, it will try to open the currently active tty if any. pub fn new(tty: Option<&Path>, logger: L) -> Result<(DirectSession, DirectSessionNotifier)> - where - L: Into> + where + L: Into>, { - let logger = ::slog_or_stdlog(logger).new(o!("smithay_module" => "backend_session", "session_type" => "direct/vt")); + let logger = ::slog_or_stdlog(logger) + .new(o!("smithay_module" => "backend_session", "session_type" => "direct/vt")); - let fd = tty - .map(|path| open(path, fcntl::O_RDWR | fcntl::O_CLOEXEC, Mode::empty()) - .chain_err(|| ErrorKind::FailedToOpenTTY(String::from(path.to_string_lossy())))) - .unwrap_or(dup(0 /*stdin*/).chain_err(|| ErrorKind::FailedToOpenTTY(String::from(""))))?; + let fd = tty.map(|path| { + open(path, fcntl::O_RDWR | fcntl::O_CLOEXEC, Mode::empty()) + .chain_err(|| ErrorKind::FailedToOpenTTY(String::from(path.to_string_lossy()))) + }).unwrap_or(dup(0 /*stdin*/).chain_err(|| ErrorKind::FailedToOpenTTY(String::from(""))))?; let active = Arc::new(AtomicBool::new(true)); match DirectSession::setup_tty(tty, fd, logger.clone()) { - Ok((vt, old_keyboard_mode, signal)) => { - Ok((DirectSession { + Ok((vt, old_keyboard_mode, signal)) => Ok(( + DirectSession { tty: fd, active: active.clone(), vt, old_keyboard_mode, logger: logger.new(o!("vt" => format!("{}", vt), "component" => "session")), - }, DirectSessionNotifier { + }, + DirectSessionNotifier { tty: fd, active, signals: Vec::new(), signal, - logger: logger.new(o!("vt" => format!("{}", vt), "component" => "session_notifier")) - })) - }, + logger: logger.new(o!("vt" => format!("{}", vt), "component" => "session_notifier")), + }, + )), Err(err) => { let _ = close(fd); Err(err) @@ -226,9 +226,11 @@ impl DirectSession { let mut old_keyboard_mode = 0; unsafe { - tty::kd_get_kb_mode(tty, &mut old_keyboard_mode).chain_err(|| ErrorKind::FailedToSaveTTYState(vt_num))?; + tty::kd_get_kb_mode(tty, &mut old_keyboard_mode) + .chain_err(|| ErrorKind::FailedToSaveTTYState(vt_num))?; tty::kd_set_kb_mode(tty, tty::K_OFF).chain_err(|| ErrorKind::FailedToSetTTYKbMode(vt_num))?; - tty::kd_set_mode(tty, tty::KD_GRAPHICS as i32).chain_err(|| ErrorKind::FailedToSetTTYMode(vt_num))?; + tty::kd_set_mode(tty, tty::KD_GRAPHICS as i32) + .chain_err(|| ErrorKind::FailedToSetTTYMode(vt_num))?; } // TODO: Support realtime signals @@ -305,19 +307,33 @@ impl Drop for DirectSession { info!(self.logger, "Deallocating tty {}", self.tty); if let Err(err) = unsafe { tty::kd_set_kb_mode(self.tty, self.old_keyboard_mode) } { - warn!(self.logger, "Unable to restore vt keyboard mode. Error: {}", err); + warn!( + self.logger, + "Unable to restore vt keyboard mode. Error: {}", err + ); } if let Err(err) = unsafe { tty::kd_set_mode(self.tty, tty::KD_TEXT as i32) } { - warn!(self.logger, "Unable to restore vt text mode. Error: {}", err); + warn!( + self.logger, + "Unable to restore vt text mode. Error: {}", err + ); } - if let Err(err) = unsafe { tty::vt_set_mode(self.tty, &tty::VtMode { - mode: tty::VT_AUTO, - ..Default::default() - }) } { + if let Err(err) = unsafe { + tty::vt_set_mode( + self.tty, + &tty::VtMode { + mode: tty::VT_AUTO, + ..Default::default() + }, + ) + } { error!(self.logger, "Failed to reset vt handling. Error: {}", err); } if let Err(err) = close(self.tty) { - error!(self.logger, "Failed to close tty file descriptor. Error: {}", err); + error!( + self.logger, + "Failed to close tty file descriptor. Error: {}", err + ); } } } @@ -350,36 +366,45 @@ impl SessionNotifier for DirectSessionNotifier { /// Allows the `DirectSessionNotifier` to listen for the incoming signals signalling the session state. /// If you don't use this function `DirectSessionNotifier` will not correctly tell you the current /// session state. -pub fn direct_session_bind(notifier: DirectSessionNotifier, evlh: &mut EventLoopHandle, _logger: L) - -> IoResult> +pub fn direct_session_bind( + notifier: DirectSessionNotifier, evlh: &mut EventLoopHandle, _logger: L +) -> IoResult> where L: Into>, { let signal = notifier.signal; - evlh.add_signal_event_source(|evlh, notifier, _| { - if notifier.is_active() { - info!(notifier.logger, "Session shall become inactive"); - for signal in &mut notifier.signals { - if let &mut Some(ref mut signal) = signal {signal.pause(&mut evlh.state().as_proxy()); } + evlh.add_signal_event_source( + |evlh, notifier, _| { + if notifier.is_active() { + info!(notifier.logger, "Session shall become inactive"); + for signal in &mut notifier.signals { + if let &mut Some(ref mut signal) = signal { + signal.pause(&mut evlh.state().as_proxy()); + } + } + notifier.active.store(false, Ordering::SeqCst); + unsafe { + tty::vt_rel_disp(notifier.tty, 1).expect("Unable to release tty lock"); + } + debug!(notifier.logger, "Session is now inactive"); + } else { + debug!(notifier.logger, "Session will become active again"); + unsafe { + tty::vt_rel_disp(notifier.tty, tty::VT_ACKACQ).expect("Unable to acquire tty lock"); + } + for signal in &mut notifier.signals { + if let &mut Some(ref mut signal) = signal { + signal.activate(&mut evlh.state().as_proxy()); + } + } + notifier.active.store(true, Ordering::SeqCst); + info!(notifier.logger, "Session is now active again"); } - notifier.active.store(false, Ordering::SeqCst); - unsafe { - tty::vt_rel_disp(notifier.tty, 1).expect("Unable to release tty lock"); - } - debug!(notifier.logger, "Session is now inactive"); - } else { - debug!(notifier.logger, "Session will become active again"); - unsafe { - tty::vt_rel_disp(notifier.tty, tty::VT_ACKACQ).expect("Unable to acquire tty lock"); - } - for signal in &mut notifier.signals { - if let &mut Some(ref mut signal) = signal { signal.activate(&mut evlh.state().as_proxy()); } - } - notifier.active.store(true, Ordering::SeqCst); - info!(notifier.logger, "Session is now active again"); - } - }, notifier, signal) + }, + notifier, + signal, + ) } error_chain! { diff --git a/src/backend/session/mod.rs b/src/backend/session/mod.rs index 74a966f..0d16259 100644 --- a/src/backend/session/mod.rs +++ b/src/backend/session/mod.rs @@ -10,12 +10,12 @@ //! The following mechanisms are currently provided: //! - direct - legacy tty / virtual terminal kernel api //! -use std::path::Path; -use std::sync::{Arc, Mutex}; -use std::rc::Rc; +use nix::fcntl::OFlag; use std::cell::RefCell; use std::os::unix::io::RawFd; -use nix::fcntl::OFlag; +use std::path::Path; +use std::rc::Rc; +use std::sync::{Arc, Mutex}; use wayland_server::StateProxy; /// General session interface. @@ -83,13 +83,23 @@ pub trait SessionObserver { impl Session for () { type Error = (); - fn open(&mut self, _path: &Path, _flags: OFlag) -> Result { Err(()) } - fn close(&mut self, _fd: RawFd) -> Result<(), Self::Error> { Err(()) } + fn open(&mut self, _path: &Path, _flags: OFlag) -> Result { + Err(()) + } + fn close(&mut self, _fd: RawFd) -> Result<(), Self::Error> { + Err(()) + } - fn change_vt(&mut self, _vt: i32) -> Result<(), Self::Error> { Err(()) } + fn change_vt(&mut self, _vt: i32) -> Result<(), Self::Error> { + Err(()) + } - fn is_active(&self) -> bool { false } - fn seat(&self) -> String { String::from("seat0") } + fn is_active(&self) -> bool { + false + } + fn seat(&self) -> String { + String::from("seat0") + } } impl Session for Rc> { diff --git a/src/backend/udev.rs b/src/backend/udev.rs index 66fb0e3..a04b670 100644 --- a/src/backend/udev.rs +++ b/src/backend/udev.rs @@ -9,36 +9,51 @@ //! See also `examples/udev.rs` for pure hardware backed example of a compositor utilizing this //! backend. -use udev::{Context, MonitorBuilder, MonitorSocket, Event, EventType, Enumerator, Result as UdevResult}; +use backend::drm::{drm_device_bind, DrmBackend, DrmDevice, DrmHandler}; +use backend::session::{Session, SessionObserver}; use nix::fcntl; use nix::sys::stat::{dev_t, fstat}; use std::borrow::Borrow; use std::collections::HashMap; -use std::io::{Error as IoError, Result as IoResult}; use std::ffi::OsString; +use std::io::{Error as IoError, Result as IoResult}; use std::mem::drop; -use std::path::{PathBuf, Path}; use std::os::unix::io::AsRawFd; -use wayland_server::{EventLoopHandle, StateToken, StateProxy}; +use std::path::{Path, PathBuf}; +use udev::{Context, Enumerator, Event, EventType, MonitorBuilder, MonitorSocket, Result as UdevResult}; +use wayland_server::{EventLoopHandle, StateProxy, StateToken}; use wayland_server::sources::{FdEventSource, FdEventSourceImpl, FdInterest}; -use ::backend::drm::{DrmDevice, DrmBackend, DrmHandler, drm_device_bind}; -use ::backend::session::{Session, SessionObserver}; - /// Graphical backend that monitors available drm devices. /// /// Provides a way to automatically initialize a `DrmDevice` for available gpus and notifies the /// given handler of any changes. Can be used to provide hot-plug functionality for gpus and /// attached monitors. -pub struct UdevBackend + 'static, H: DrmHandler + 'static, S: Session + 'static, T: UdevHandler + 'static> { - devices: HashMap>, FdEventSource<(StateToken>, H)>)>, +pub struct UdevBackend< + B: Borrow + 'static, + H: DrmHandler + 'static, + S: Session + 'static, + T: UdevHandler + 'static, +> { + devices: HashMap< + dev_t, + ( + StateToken>, + FdEventSource<(StateToken>, H)>, + ), + >, monitor: MonitorSocket, session: S, handler: T, logger: ::slog::Logger, } -impl + Borrow + 'static, H: DrmHandler + 'static, S: Session + 'static, T: UdevHandler + 'static> UdevBackend { +impl< + B: From + Borrow + 'static, + H: DrmHandler + 'static, + S: Session + 'static, + T: UdevHandler + 'static, +> UdevBackend { /// Creates a new `UdevBackend` and adds it to the given `EventLoop`'s state. /// /// ## Arguments @@ -47,14 +62,11 @@ impl + Borrow + 'static, H: DrmHandler + 'sta /// `session` - A session used to open and close devices as they become available /// `handler` - User-provided handler to respond to any detected changes /// `logger` - slog Logger to be used by the backend and its `DrmDevices`. - pub fn new<'a, L>(mut evlh: &mut EventLoopHandle, - context: &Context, - mut session: S, - mut handler: T, - logger: L) - -> Result>> + pub fn new<'a, L>( + mut evlh: &mut EventLoopHandle, context: &Context, mut session: S, mut handler: T, logger: L + ) -> Result>> where - L: Into> + L: Into>, { let logger = ::slog_or_stdlog(logger).new(o!("smithay_module" => "backend_udev")); let seat = session.seat(); @@ -125,8 +137,12 @@ impl + Borrow + 'static, H: DrmHandler + 'sta .collect::>, FdEventSource<(StateToken>, H)>)>>(); let mut builder = MonitorBuilder::new(context).chain_err(|| ErrorKind::FailedToInitMonitor)?; - builder.match_subsystem("drm").chain_err(|| ErrorKind::FailedToInitMonitor)?; - let monitor = builder.listen().chain_err(|| ErrorKind::FailedToInitMonitor)?; + builder + .match_subsystem("drm") + .chain_err(|| ErrorKind::FailedToInitMonitor)?; + let monitor = builder + .listen() + .chain_err(|| ErrorKind::FailedToInitMonitor)?; Ok(evlh.state().insert(UdevBackend { devices, @@ -154,14 +170,22 @@ impl + Borrow + 'static, H: DrmHandler + 'sta let fd = device.as_raw_fd(); drop(device); if let Err(err) = self.session.close(fd) { - warn!(self.logger, "Failed to close device. Error: {:?}. Ignoring", err); + warn!( + self.logger, + "Failed to close device. Error: {:?}. Ignoring", err + ); }; } info!(self.logger, "All devices closed"); } } -impl + 'static, H: DrmHandler + 'static, S: Session + 'static, T: UdevHandler + 'static> SessionObserver for StateToken> { +impl< + B: Borrow + 'static, + H: DrmHandler + 'static, + S: Session + 'static, + T: UdevHandler + 'static, +> SessionObserver for StateToken> { fn pause<'a>(&mut self, state: &mut StateProxy<'a>) { state.with_value(self, |state, udev| { for &mut (ref mut device, _) in udev.devices.values_mut() { @@ -183,8 +207,9 @@ impl + 'static, H: DrmHandler + 'static, S: Session + ' /// /// Allows the backend to recieve kernel events and thus to drive the `UdevHandler`. /// No runtime functionality can be provided without using this function. -pub fn udev_backend_bind(evlh: &mut EventLoopHandle, udev: StateToken>) - -> IoResult>>> +pub fn udev_backend_bind( + evlh: &mut EventLoopHandle, udev: StateToken> +) -> IoResult>>> where B: From + Borrow + 'static, H: DrmHandler + 'static, @@ -192,16 +217,10 @@ where S: Session + 'static, { let fd = evlh.state().get(&udev).monitor.as_raw_fd(); - evlh.add_fd_event_source( - fd, - fd_event_source_implementation(), - udev, - FdInterest::READ, - ) + evlh.add_fd_event_source(fd, fd_event_source_implementation(), udev, FdInterest::READ) } -fn fd_event_source_implementation() - -> FdEventSourceImpl>> +fn fd_event_source_implementation() -> FdEventSourceImpl>> where B: From + Borrow + 'static, H: DrmHandler + 'static, @@ -210,7 +229,11 @@ where { FdEventSourceImpl { ready: |mut evlh, token, _, _| { - let events = evlh.state().get(token).monitor.clone().collect::>(); + let events = evlh.state() + .get(token) + .monitor + .clone() + .collect::>(); for event in events { match event.event_type() { // New device @@ -218,30 +241,49 @@ where info!(evlh.state().get(token).logger, "Device Added"); if let (Some(path), Some(devnum)) = (event.devnode(), event.devnum()) { let mut device = { - match unsafe { DrmDevice::new_from_fd( - { - let logger = evlh.state().get(token).logger.clone(); - match evlh.state().get_mut(token).session.open(path, fcntl::O_RDWR | fcntl::O_CLOEXEC | fcntl::O_NOCTTY | fcntl::O_NONBLOCK) { - Ok(fd) => fd, - Err(err) => { - warn!(logger, "Unable to open drm device {:?}, Error: {:?}. Skipping", path, err); - continue; + match unsafe { + DrmDevice::new_from_fd( + { + let logger = evlh.state().get(token).logger.clone(); + match evlh.state().get_mut(token).session.open( + path, + fcntl::O_RDWR | fcntl::O_CLOEXEC | fcntl::O_NOCTTY + | fcntl::O_NONBLOCK, + ) { + Ok(fd) => fd, + Err(err) => { + warn!(logger, "Unable to open drm device {:?}, Error: {:?}. Skipping", path, err); + continue; + } } - } - }, evlh.state().get(token).logger.clone() - ) } { + }, + evlh.state().get(token).logger.clone(), + ) + } { Ok(dev) => dev, Err(err) => { - warn!(evlh.state().get(token).logger, "Failed to initialize device {:?}. Error: {}. Skipping", path, err); + warn!( + evlh.state().get(token).logger, + "Failed to initialize device {:?}. Error: {}. Skipping", + path, + err + ); continue; } } }; - match evlh.state().with_value(token, |state, udev| udev.handler.device_added(state, &mut device)) { + match evlh.state().with_value(token, |state, udev| { + udev.handler.device_added(state, &mut device) + }) { Some(drm_handler) => { let dev_token = evlh.state().insert(device); - if let Ok(fd_event_source) = drm_device_bind(&mut evlh, dev_token.clone(), drm_handler) { - evlh.state().get_mut(token).devices.insert(devnum, (dev_token, fd_event_source)); + if let Ok(fd_event_source) = + drm_device_bind(&mut evlh, dev_token.clone(), drm_handler) + { + evlh.state() + .get_mut(token) + .devices + .insert(devnum, (dev_token, fd_event_source)); } else { evlh.state().with_value(token, |state, udev| { let mut state: StateProxy = state.into(); @@ -250,42 +292,52 @@ where let fd = device.as_raw_fd(); drop(device); if let Err(err) = udev.session.close(fd) { - warn!(udev.logger, "Failed to close dropped device. Error: {:?}. Ignoring", err); + warn!( + udev.logger, + "Failed to close dropped device. Error: {:?}. Ignoring", + err + ); }; }) } - }, + } None => { let fd = device.as_raw_fd(); drop(device); evlh.state().with_value(token, |_state, udev| { if let Err(err) = udev.session.close(fd) { - warn!(udev.logger, "Failed to close unused device. Error: {:?}", err); + warn!( + udev.logger, + "Failed to close unused device. Error: {:?}", err + ); } }) - }, + } }; } - }, + } // Device removed - EventType::Remove => { - evlh.state().with_value(token, |state, udev| { - info!(udev.logger, "Device Remove"); - if let Some(devnum) = event.devnum() { - if let Some((device, fd_event_source)) = udev.devices.remove(&devnum) { - fd_event_source.remove(); - let mut state: StateProxy = state.into(); - udev.handler.device_removed(&mut state, &device); - let device = state.remove(device); - let fd = device.as_raw_fd(); - drop(device); - if let Err(err) = udev.session.close(fd) { - warn!(udev.logger, "Failed to close device {:?}. Error: {:?}. Ignoring", event.sysname(), err); - }; - } + EventType::Remove => evlh.state().with_value(token, |state, udev| { + info!(udev.logger, "Device Remove"); + if let Some(devnum) = event.devnum() { + if let Some((device, fd_event_source)) = udev.devices.remove(&devnum) { + fd_event_source.remove(); + let mut state: StateProxy = state.into(); + udev.handler.device_removed(&mut state, &device); + let device = state.remove(device); + let fd = device.as_raw_fd(); + drop(device); + if let Err(err) = udev.session.close(fd) { + warn!( + udev.logger, + "Failed to close device {:?}. Error: {:?}. Ignoring", + event.sysname(), + err + ); + }; } - }) - }, + } + }), // New connector EventType::Change => evlh.state().with_value(token, |state, udev| { info!(udev.logger, "Device Changed"); @@ -301,25 +353,28 @@ where info!(udev.logger, "changed, but no devnum"); } }), - _ => {}, + _ => {} } } }, error: |evlh, token, _, err| { - evlh.state().with_value(token, |state, udev| udev.handler.error(state, err)) + evlh.state() + .with_value(token, |state, udev| udev.handler.error(state, err)) }, } } /// Handler for the `UdevBackend`, allows to open, close and update drm devices as they change during runtime. -pub trait UdevHandler + 'static, H: DrmHandler + 'static> { +pub trait UdevHandler + 'static, H: DrmHandler + 'static> + { /// Called on initialization for every known device and when a new device is detected. /// /// Returning a `DrmHandler` will initialize the device, returning `None` will ignore the device. /// /// ## Panics /// Panics if you try to borrow the token of the belonging `UdevBackend` using this `StateProxy`. - fn device_added<'a, S: Into>>(&mut self, state: S, device: &mut DrmDevice) -> Option; + fn device_added<'a, S: Into>>(&mut self, state: S, device: &mut DrmDevice) + -> Option; /// Called when an open device is changed. /// /// This usually indicates that some connectors did become available or were unplugged. The handler @@ -353,7 +408,11 @@ pub fn primary_gpu>(context: &Context, seat: S) -> UdevResult>(context: &Context, seat: S) -> UdevResult(builder: WindowBuilder, logger: L) - -> Result<(WinitGraphicsBackend, WinitInputBackend)> +pub fn init_from_builder( + builder: WindowBuilder, logger: L +) -> Result<(WinitGraphicsBackend, WinitInputBackend)> where L: Into>, { @@ -120,8 +121,9 @@ where /// graphics backend trait, from a given `WindowBuilder` struct, as well as given /// `GlAttributes` for further customization of the rendering pipeline and a /// corresponding `WinitInputBackend`, which implements the `InputBackend` trait. -pub fn init_from_builder_with_gl_attr(builder: WindowBuilder, attributes: GlAttributes, logger: L) - -> Result<(WinitGraphicsBackend, WinitInputBackend)> +pub fn init_from_builder_with_gl_attr( + builder: WindowBuilder, attributes: GlAttributes, logger: L +) -> Result<(WinitGraphicsBackend, WinitInputBackend)> where L: Into>, { @@ -190,8 +192,9 @@ impl GraphicsBackend for WinitGraphicsBackend { self.window.head().set_cursor_position(x as i32, y as i32) } - fn set_cursor_representation(&self, cursor: &Self::CursorFormat, _hotspot: (u32, u32)) - -> ::std::result::Result<(), ()> { + fn set_cursor_representation( + &self, cursor: &Self::CursorFormat, _hotspot: (u32, u32) + ) -> ::std::result::Result<(), ()> { // Cannot log this one, as `CursorFormat` is not `Debug` and should not be debug!(self.logger, "Changing cursor representation"); self.window.head().set_cursor(*cursor); @@ -228,7 +231,8 @@ impl EGLGraphicsBackend for WinitGraphicsBackend { } fn is_current(&self) -> bool { - self.window.rent(|egl| egl.rent_all(|egl| egl.context.is_current() && egl.surface.is_current())) + self.window + .rent(|egl| egl.rent_all(|egl| egl.context.is_current() && egl.surface.is_current())) } unsafe fn make_current(&self) -> ::std::result::Result<(), SwapBuffersError> { @@ -371,10 +375,10 @@ impl PointerAxisEvent for WinitMouseWheelEvent { fn amount(&self) -> f64 { match (self.axis, self.delta) { - (Axis::Horizontal, MouseScrollDelta::LineDelta(x, _)) | - (Axis::Horizontal, MouseScrollDelta::PixelDelta(x, _)) => x as f64, - (Axis::Vertical, MouseScrollDelta::LineDelta(_, y)) | - (Axis::Vertical, MouseScrollDelta::PixelDelta(_, y)) => y as f64, + (Axis::Horizontal, MouseScrollDelta::LineDelta(x, _)) + | (Axis::Horizontal, MouseScrollDelta::PixelDelta(x, _)) => x as f64, + (Axis::Vertical, MouseScrollDelta::LineDelta(_, y)) + | (Axis::Vertical, MouseScrollDelta::PixelDelta(_, y)) => y as f64, } } } @@ -624,8 +628,10 @@ impl InputBackend for WinitInputBackend { trace!(logger, "Resizing window to {:?}", (x, y)); window.head().set_inner_size(x, y); window.rent(|egl| { - egl.rent(|surface| if let Some(wegl_surface) = (**surface).as_ref() { - wegl_surface.resize(x as i32, y as i32, 0, 0) + egl.rent(|surface| { + if let Some(wegl_surface) = (**surface).as_ref() { + wegl_surface.resize(x as i32, y as i32, 0, 0) + } }) }); } diff --git a/src/wayland/compositor/handlers.rs b/src/wayland/compositor/handlers.rs index 7cf4df6..da2e760 100644 --- a/src/wayland/compositor/handlers.rs +++ b/src/wayland/compositor/handlers.rs @@ -11,9 +11,10 @@ use wayland_server::protocol::{wl_compositor, wl_region, wl_subcompositor, wl_su * wl_compositor */ -pub(crate) fn compositor_bind(evlh: &mut EventLoopHandle, idata: &mut SurfaceIData, - _: &Client, compositor: wl_compositor::WlCompositor) -where +pub(crate) fn compositor_bind( + evlh: &mut EventLoopHandle, idata: &mut SurfaceIData, _: &Client, + compositor: wl_compositor::WlCompositor, +) where U: Default + 'static, R: Default + 'static, ID: 'static, @@ -65,8 +66,9 @@ pub struct SurfaceIData { } impl SurfaceIData { - pub(crate) fn make(log: ::slog::Logger, implem: SurfaceUserImplementation, idata: ID) - -> SurfaceIData { + pub(crate) fn make( + log: ::slog::Logger, implem: SurfaceUserImplementation, idata: ID + ) -> SurfaceIData { SurfaceIData { log: log, implem: implem, @@ -86,9 +88,7 @@ impl Clone for SurfaceIData { } pub(crate) fn surface_implementation( - ) - -> wl_surface::Implementation> -{ +) -> wl_surface::Implementation> { wl_surface::Implementation { attach: |_, _, _, surface, buffer, x, y| unsafe { SurfaceData::::with_data(surface, |d| { @@ -199,9 +199,9 @@ fn destroy_region(region: &wl_region::WlRegion) { * wl_subcompositor */ -pub(crate) fn subcompositor_bind(evlh: &mut EventLoopHandle, _: &mut (), _: &Client, - subcompositor: wl_subcompositor::WlSubcompositor) -where +pub(crate) fn subcompositor_bind( + evlh: &mut EventLoopHandle, _: &mut (), _: &Client, subcompositor: wl_subcompositor::WlSubcompositor +) where R: RoleType + Role + 'static, U: 'static, { diff --git a/src/wayland/compositor/mod.rs b/src/wayland/compositor/mod.rs index 6cdc9b1..2265d6c 100644 --- a/src/wayland/compositor/mod.rs +++ b/src/wayland/compositor/mod.rs @@ -314,11 +314,11 @@ where /// /// If the surface not managed by the CompositorGlobal that provided this token, this /// will panic (having more than one compositor is not supported). - pub fn with_surface_tree_upward(&self, surface: &wl_surface::WlSurface, initial: T, f: F) - -> Result<(), ()> + pub fn with_surface_tree_upward( + &self, surface: &wl_surface::WlSurface, initial: T, f: F + ) -> Result<(), ()> where - F: FnMut(&wl_surface::WlSurface, &mut SurfaceAttributes, &mut R, &T) - -> TraversalAction, + F: FnMut(&wl_surface::WlSurface, &mut SurfaceAttributes, &mut R, &T) -> TraversalAction, { assert!( resource_is_registered( @@ -340,11 +340,11 @@ where /// supposed to be drawn: top-most first. /// /// Behavior is the same as `with_surface_tree_upward`. - pub fn with_surface_tree_downward(&self, surface: &wl_surface::WlSurface, initial: T, f: F) - -> Result<(), ()> + pub fn with_surface_tree_downward( + &self, surface: &wl_surface::WlSurface, initial: T, f: F + ) -> Result<(), ()> where - F: FnMut(&wl_surface::WlSurface, &mut SurfaceAttributes, &mut R, &T) - -> TraversalAction, + F: FnMut(&wl_surface::WlSurface, &mut SurfaceAttributes, &mut R, &T) -> TraversalAction, { assert!( resource_is_registered( @@ -426,7 +426,6 @@ impl CompositorToken { unsafe { SurfaceData::::has_role::(surface) } } - /// Register that this surface has given role with default data /// /// Fails if the surface already has a role. @@ -454,8 +453,9 @@ impl CompositorToken { /// /// If the surface is not managed by the CompositorGlobal that provided this token, this /// will panic (having more than one compositor is not supported). - pub fn give_role_with(&self, surface: &wl_surface::WlSurface, data: RoleData) - -> Result<(), RoleData> + pub fn give_role_with( + &self, surface: &wl_surface::WlSurface, data: RoleData + ) -> Result<(), RoleData> where R: Role, { @@ -475,8 +475,9 @@ impl CompositorToken { /// /// If the surface is not managed by the CompositorGlobal that provided this token, this /// will panic (having more than one compositor is not supported). - pub fn with_role_data(&self, surface: &wl_surface::WlSurface, f: F) - -> Result + pub fn with_role_data( + &self, surface: &wl_surface::WlSurface, f: F + ) -> Result where R: Role, F: FnOnce(&mut RoleData) -> T, @@ -533,12 +534,12 @@ impl CompositorToken { /// It also returns the two global handles, in case you whish to remove these /// globals from the event loop in the future. pub fn compositor_init( - evl: &mut EventLoop, implem: SurfaceUserImplementation, idata: ID, logger: L) - -> ( - CompositorToken, - Global>, - Global, - ) + evl: &mut EventLoop, implem: SurfaceUserImplementation, idata: ID, logger: L +) -> ( + CompositorToken, + Global>, + Global, +) where L: Into>, U: Default + 'static, @@ -580,10 +581,10 @@ pub struct SurfaceUserImplementation { /// See [`wayland_server::protocol::wl_surface::Implementation::commit`](https://docs.rs/wayland-server/0.10.1/wayland_server/protocol/wl_surface/struct.Implementation.html#structfield.commit) /// for more details pub commit: fn( - evlh: &mut EventLoopHandle, - idata: &mut ID, - surface: &wl_surface::WlSurface, - token: CompositorToken, + evlh: &mut EventLoopHandle, + idata: &mut ID, + surface: &wl_surface::WlSurface, + token: CompositorToken, ), /// The client asks to be notified when would be a good time to update the contents of this surface /// @@ -593,11 +594,11 @@ pub struct SurfaceUserImplementation { /// See [`wayland_server::protocol::wl_surface::Implementation::frame`](https://docs.rs/wayland-server/0.10.1/wayland_server/protocol/wl_surface/struct.Implementation.html#structfield.frame) /// for more details pub frame: fn( - evlh: &mut EventLoopHandle, - idata: &mut ID, - surface: &wl_surface::WlSurface, - callback: wl_callback::WlCallback, - token: CompositorToken, + evlh: &mut EventLoopHandle, + idata: &mut ID, + surface: &wl_surface::WlSurface, + callback: wl_callback::WlCallback, + token: CompositorToken, ), } diff --git a/src/wayland/compositor/tree.rs b/src/wayland/compositor/tree.rs index 7cbecc9..10fd2a1 100644 --- a/src/wayland/compositor/tree.rs +++ b/src/wayland/compositor/tree.rs @@ -132,8 +132,9 @@ impl SurfaceData { /// Register that this surface has a role with given data /// /// Fails if it already has one and returns the data - pub unsafe fn give_role_with(surface: &wl_surface::WlSurface, data: RoleData) - -> Result<(), RoleData> + pub unsafe fn give_role_with( + surface: &wl_surface::WlSurface, data: RoleData + ) -> Result<(), RoleData> where R: Role, { @@ -158,8 +159,9 @@ impl SurfaceData { } /// Access to the role data - pub unsafe fn with_role_data(surface: &wl_surface::WlSurface, f: F) - -> Result + pub unsafe fn with_role_data( + surface: &wl_surface::WlSurface, f: F + ) -> Result where R: Role, F: FnOnce(&mut RoleData) -> T, @@ -177,8 +179,9 @@ impl + 'static> SurfaceData /// /// if this surface already has a role, does nothing and fails, otherwise /// its role is now to be a subsurface - pub unsafe fn set_parent(child: &wl_surface::WlSurface, parent: &wl_surface::WlSurface) - -> Result<(), ()> { + pub unsafe fn set_parent( + child: &wl_surface::WlSurface, parent: &wl_surface::WlSurface + ) -> Result<(), ()> { debug_assert!(child.status() == Liveness::Alive); debug_assert!(parent.status() == Liveness::Alive); @@ -246,9 +249,9 @@ impl + 'static> SurfaceData /// Reorders a surface relative to one of its sibling /// /// Fails if `relative_to` is not a sibling or parent of `surface`. - pub unsafe fn reorder(surface: &wl_surface::WlSurface, to: Location, - relative_to: &wl_surface::WlSurface) - -> Result<(), ()> { + pub unsafe fn reorder( + surface: &wl_surface::WlSurface, to: Location, relative_to: &wl_surface::WlSurface + ) -> Result<(), ()> { let parent = { let data_mutex = Self::get_data(surface); let data_guard = data_mutex.lock().unwrap(); @@ -316,17 +319,15 @@ impl SurfaceData { /// false will cause an early-stopping. pub unsafe fn map_tree(root: &wl_surface::WlSurface, initial: T, mut f: F, reverse: bool) where - F: FnMut(&wl_surface::WlSurface, &mut SurfaceAttributes, &mut R, &T) - -> TraversalAction, + F: FnMut(&wl_surface::WlSurface, &mut SurfaceAttributes, &mut R, &T) -> TraversalAction, { // helper function for recursion - unsafe fn map(surface: &wl_surface::WlSurface, - root: &wl_surface::WlSurface, initial: &T, f: &mut F, - reverse: bool) - -> bool + unsafe fn map( + surface: &wl_surface::WlSurface, root: &wl_surface::WlSurface, initial: &T, f: &mut F, + reverse: bool, + ) -> bool where - F: FnMut(&wl_surface::WlSurface, &mut SurfaceAttributes, &mut R, &T) - -> TraversalAction, + F: FnMut(&wl_surface::WlSurface, &mut SurfaceAttributes, &mut R, &T) -> TraversalAction, { // stop if we met the root, so to not deadlock/inifinte loop if surface.equals(root) { diff --git a/src/wayland/output/mod.rs b/src/wayland/output/mod.rs index 3caf46a..9404d64 100644 --- a/src/wayland/output/mod.rs +++ b/src/wayland/output/mod.rs @@ -113,11 +113,11 @@ impl Output { /// returns the state token allowing you to access it, as well as the global handle, /// in case you whish to remove this global in the future. pub fn new( - evl: &mut EventLoop, name: String, physical: PhysicalProperties, logger: L) - -> ( - StateToken, - Global>, - ) + evl: &mut EventLoop, name: String, physical: PhysicalProperties, logger: L + ) -> ( + StateToken, + Global>, + ) where L: Into>, { @@ -229,8 +229,10 @@ impl Output { /// internal list. /// /// By default, transform status is `Normal`, and scale is `1`. - pub fn change_current_state(&mut self, new_mode: Option, - new_transform: Option, new_scale: Option) { + pub fn change_current_state( + &mut self, new_mode: Option, new_transform: Option, + new_scale: Option, + ) { if let Some(mode) = new_mode { if self.modes.iter().find(|&m| *m == mode).is_none() { self.modes.push(mode); @@ -283,8 +285,9 @@ impl Output { } } -fn output_bind(evlh: &mut EventLoopHandle, token: &mut StateToken, _: &Client, - global: wl_output::WlOutput) { +fn output_bind( + evlh: &mut EventLoopHandle, token: &mut StateToken, _: &Client, global: wl_output::WlOutput +) { evlh.register(&global, output_implementation(), token.clone(), None); evlh.state().get_mut(token).new_global(global); } diff --git a/src/wayland/seat/keyboard.rs b/src/wayland/seat/keyboard.rs index 4d23023..0a9c309 100644 --- a/src/wayland/seat/keyboard.rs +++ b/src/wayland/seat/keyboard.rs @@ -66,9 +66,10 @@ struct KbdInternal { } impl KbdInternal { - fn new(rules: &str, model: &str, layout: &str, variant: &str, options: Option, - repeat_rate: i32, repeat_delay: i32) - -> Result { + fn new( + rules: &str, model: &str, layout: &str, variant: &str, options: Option, repeat_rate: i32, + repeat_delay: i32, + ) -> Result { // we create a new contex for each keyboard because libxkbcommon is actually NOT threadsafe // so confining it inside the KbdInternal allows us to use Rusts mutability rules to make // sure nothing goes wrong. @@ -168,10 +169,10 @@ pub enum Error { } /// Create a keyboard handler from a set of RMLVO rules -pub(crate) fn create_keyboard_handler(rules: &str, model: &str, layout: &str, variant: &str, - options: Option, repeat_delay: i32, repeat_rate: i32, - logger: &::slog::Logger) - -> Result { +pub(crate) fn create_keyboard_handler( + rules: &str, model: &str, layout: &str, variant: &str, options: Option, repeat_delay: i32, + repeat_rate: i32, logger: &::slog::Logger, +) -> Result { let log = logger.new(o!("smithay_module" => "xkbcommon_handler")); info!(log, "Initializing a xkbcommon handler with keymap query"; "rules" => rules, "model" => model, "layout" => layout, "variant" => variant, @@ -192,7 +193,6 @@ pub(crate) fn create_keyboard_handler(rules: &str, model: &str, layout: &str, va info!(log, "Loaded Keymap"; "name" => internal.keymap.layouts().next()); - // prepare a tempfile with the keymap, to send it to clients let mut keymap_file = tempfile().map_err(Error::IoError)?; let keymap_data = internal.keymap.get_as_string(xkb::KEYMAP_FORMAT_TEXT_V1); diff --git a/src/wayland/seat/mod.rs b/src/wayland/seat/mod.rs index 45612d2..afa5e0f 100644 --- a/src/wayland/seat/mod.rs +++ b/src/wayland/seat/mod.rs @@ -87,8 +87,9 @@ impl Seat { /// You are provided with the state token to retrieve it (allowing /// you to add or remove capabilities from it), and the global handle, /// in case you want to remove it. - pub fn new(evl: &mut EventLoop, name: String, logger: L) - -> (StateToken, Global>) + pub fn new( + evl: &mut EventLoop, name: String, logger: L + ) -> (StateToken, Global>) where L: Into>, { @@ -158,9 +159,10 @@ impl Seat { /// Calling this method on a seat that already has a keyboard capability /// will overwrite it, and will be seen by the clients as if the /// keyboard was unplugged and a new one was plugged. - pub fn add_keyboard(&mut self, model: &str, layout: &str, variant: &str, options: Option, - repeat_delay: i32, repeat_rate: i32) - -> Result { + pub fn add_keyboard( + &mut self, model: &str, layout: &str, variant: &str, options: Option, repeat_delay: i32, + repeat_rate: i32, + ) -> Result { let keyboard = self::keyboard::create_keyboard_handler( "evdev", // we need this one model, @@ -229,8 +231,9 @@ impl Seat { } } -fn seat_global_bind(evlh: &mut EventLoopHandle, token: &mut StateToken, _: &Client, - seat: wl_seat::WlSeat) { +fn seat_global_bind( + evlh: &mut EventLoopHandle, token: &mut StateToken, _: &Client, seat: wl_seat::WlSeat +) { evlh.register(&seat, seat_implementation(), token.clone(), None); let seat_mgr = evlh.state().get_mut(token); seat.name(seat_mgr.name.clone()); diff --git a/src/wayland/shell/mod.rs b/src/wayland/shell/mod.rs index 835e310..6a4ca1a 100644 --- a/src/wayland/shell/mod.rs +++ b/src/wayland/shell/mod.rs @@ -302,12 +302,12 @@ impl Clone for ShellSurfaceIData { /// globals from the event loop in the future. pub fn shell_init( evl: &mut EventLoop, token: CompositorToken, - implementation: ShellSurfaceUserImplementation, idata: SID, logger: L) - -> ( - StateToken>, - Global>, - Global>, - ) + implementation: ShellSurfaceUserImplementation, idata: SID, logger: L, +) -> ( + StateToken>, + Global>, + Global>, +) where U: 'static, R: Role + 'static, @@ -449,7 +449,8 @@ impl ShellClient { } match self.kind { ShellClientKind::Wl(ref shell) => { - let mutex = unsafe { &*(shell.get_user_data() as *mut self::wl_handlers::ShellUserData) }; + let mutex = + unsafe { &*(shell.get_user_data() as *mut self::wl_handlers::ShellUserData) }; let mut guard = mutex.lock().unwrap(); if guard.0.pending_ping == 0 { return Err(()); @@ -486,7 +487,8 @@ impl ShellClient { } match self.kind { ShellClientKind::Wl(ref shell) => { - let mutex = unsafe { &*(shell.get_user_data() as *mut self::wl_handlers::ShellUserData) }; + let mutex = + unsafe { &*(shell.get_user_data() as *mut self::wl_handlers::ShellUserData) }; let mut guard = mutex.lock().unwrap(); Ok(f(&mut guard.0.data)) } @@ -844,46 +846,44 @@ pub struct ShellSurfaceUserImplementation { /// /// You need to return a `ToplevelConfigure` from this function, which will be sent /// to the client to configure this surface - pub new_toplevel: fn( - evlh: &mut EventLoopHandle, - idata: &mut SID, - surface: ToplevelSurface, - ) -> ToplevelConfigure, + pub new_toplevel: + fn(evlh: &mut EventLoopHandle, idata: &mut SID, surface: ToplevelSurface) + -> ToplevelConfigure, /// A new popup surface was created /// /// You need to return a `PopupConfigure` from this function, which will be sent /// to the client to configure this surface pub new_popup: fn(evlh: &mut EventLoopHandle, idata: &mut SID, surface: PopupSurface) - -> PopupConfigure, + -> PopupConfigure, /// The client requested the start of an interactive move for this surface pub move_: fn( - evlh: &mut EventLoopHandle, - idata: &mut SID, - surface: ToplevelSurface, - seat: &wl_seat::WlSeat, - serial: u32, + evlh: &mut EventLoopHandle, + idata: &mut SID, + surface: ToplevelSurface, + seat: &wl_seat::WlSeat, + serial: u32, ), /// The client requested the start of an interactive resize for this surface /// /// The `edges` argument specifies which part of the window's border is being dragged. pub resize: fn( - evlh: &mut EventLoopHandle, - idata: &mut SID, - surface: ToplevelSurface, - seat: &wl_seat::WlSeat, - serial: u32, - edges: zxdg_toplevel_v6::ResizeEdge, + evlh: &mut EventLoopHandle, + idata: &mut SID, + surface: ToplevelSurface, + seat: &wl_seat::WlSeat, + serial: u32, + edges: zxdg_toplevel_v6::ResizeEdge, ), /// This popup requests a grab of the pointer /// /// This means it requests to be sent a `popup_done` event when the pointer leaves /// the grab area. pub grab: fn( - evlh: &mut EventLoopHandle, - idata: &mut SID, - surface: PopupSurface, - seat: &wl_seat::WlSeat, - serial: u32, + evlh: &mut EventLoopHandle, + idata: &mut SID, + surface: PopupSurface, + seat: &wl_seat::WlSeat, + serial: u32, ), /// A toplevel surface requested its display state to be changed /// @@ -899,26 +899,26 @@ pub struct ShellSurfaceUserImplementation { /// You are to answer with a `ToplevelConfigure` that will be sent to the client in /// response. pub change_display_state: fn( - evlh: &mut EventLoopHandle, - idata: &mut SID, - surface: ToplevelSurface, - maximized: Option, - minimized: Option, - fullscreen: Option, - output: Option<&wl_output::WlOutput>, + evlh: &mut EventLoopHandle, + idata: &mut SID, + surface: ToplevelSurface, + maximized: Option, + minimized: Option, + fullscreen: Option, + output: Option<&wl_output::WlOutput>, ) -> ToplevelConfigure, /// The client requests the window menu to be displayed on this surface at this location /// /// This menu belongs to the compositor. It is typically expected to contain options for /// control of the window (maximize/minimize/close/move/etc...). pub show_window_menu: fn( - evlh: &mut EventLoopHandle, - idata: &mut SID, - surface: ToplevelSurface, - seat: &wl_seat::WlSeat, - serial: u32, - x: i32, - y: i32, + evlh: &mut EventLoopHandle, + idata: &mut SID, + surface: ToplevelSurface, + seat: &wl_seat::WlSeat, + serial: u32, + x: i32, + y: i32, ), } diff --git a/src/wayland/shell/wl_handlers.rs b/src/wayland/shell/wl_handlers.rs index 7c5ab41..0255f07 100644 --- a/src/wayland/shell/wl_handlers.rs +++ b/src/wayland/shell/wl_handlers.rs @@ -10,10 +10,10 @@ use wayland_protocols::unstable::xdg_shell::v6::server::{zxdg_positioner_v6 as x use wayland_server::{Client, EventLoopHandle, Resource}; use wayland_server::protocol::{wl_output, wl_shell, wl_shell_surface, wl_surface}; -pub(crate) fn wl_shell_bind(evlh: &mut EventLoopHandle, - idata: &mut ShellSurfaceIData, - _: &Client, shell: wl_shell::WlShell) -where +pub(crate) fn wl_shell_bind( + evlh: &mut EventLoopHandle, idata: &mut ShellSurfaceIData, _: &Client, + shell: wl_shell::WlShell, +) where U: 'static, R: Role + 'static, CID: 'static, @@ -56,8 +56,7 @@ pub fn make_shell_client(resource: &wl_shell::WlShell) -> ShellClient { } fn shell_implementation( - ) - -> wl_shell::Implementation> +) -> wl_shell::Implementation> where U: 'static, R: Role + 'static, @@ -122,9 +121,9 @@ fn destroy_shell_surface(shell_surface: &wl_shell_surface::WlShellSurface) { ::std::mem::drop(surface); } -fn make_toplevel_handle(token: CompositorToken, - resource: &wl_shell_surface::WlShellSurface) - -> super::ToplevelSurface { +fn make_toplevel_handle( + token: CompositorToken, resource: &wl_shell_surface::WlShellSurface +) -> super::ToplevelSurface { let ptr = resource.get_user_data(); let &(ref wl_surface, _) = unsafe { &*(ptr as *mut ShellSurfaceUserData) }; super::ToplevelSurface { @@ -135,9 +134,9 @@ fn make_toplevel_handle(token: CompositorToken, } } -fn make_popup_handle(token: CompositorToken, - resource: &wl_shell_surface::WlShellSurface) - -> super::PopupSurface { +fn make_popup_handle( + token: CompositorToken, resource: &wl_shell_surface::WlShellSurface +) -> super::PopupSurface { let ptr = resource.get_user_data(); let &(ref wl_surface, _) = unsafe { &*(ptr as *mut ShellSurfaceUserData) }; super::PopupSurface { @@ -158,12 +157,11 @@ pub fn send_popup_configure(resource: &wl_shell_surface::WlShellSurface, configu resource.configure(wl_shell_surface::Resize::empty(), w, h); } -fn wl_handle_display_state_change(evlh: &mut EventLoopHandle, - idata: &ShellSurfaceIData, - shell_surface: &wl_shell_surface::WlShellSurface, - maximized: Option, minimized: Option, - fullscreen: Option, - output: Option<&wl_output::WlOutput>) { +fn wl_handle_display_state_change( + evlh: &mut EventLoopHandle, idata: &ShellSurfaceIData, + shell_surface: &wl_shell_surface::WlShellSurface, maximized: Option, minimized: Option, + fullscreen: Option, output: Option<&wl_output::WlOutput>, +) { let handle = make_toplevel_handle(idata.compositor_token, shell_surface); // handler callback let mut user_idata = idata.idata.borrow_mut(); @@ -181,10 +179,10 @@ fn wl_handle_display_state_change(evlh: &mut EventLoopHandle shell_surface.configure(wl_shell_surface::Resize::None, w, h); } -fn wl_set_parent(idata: &ShellSurfaceIData, - shell_surface: &wl_shell_surface::WlShellSurface, - parent: Option) -where +fn wl_set_parent( + idata: &ShellSurfaceIData, shell_surface: &wl_shell_surface::WlShellSurface, + parent: Option, +) where U: 'static, R: Role + 'static, CID: 'static, @@ -204,10 +202,10 @@ where .unwrap(); } -fn wl_ensure_toplevel(evlh: &mut EventLoopHandle, - idata: &ShellSurfaceIData, - shell_surface: &wl_shell_surface::WlShellSurface) -where +fn wl_ensure_toplevel( + evlh: &mut EventLoopHandle, idata: &ShellSurfaceIData, + shell_surface: &wl_shell_surface::WlShellSurface, +) where U: 'static, R: Role + 'static, CID: 'static, @@ -263,8 +261,7 @@ where } fn shell_surface_implementation( - ) - -> wl_shell_surface::Implementation> +) -> wl_shell_surface::Implementation> where U: 'static, R: Role + 'static, @@ -274,7 +271,8 @@ where { wl_shell_surface::Implementation { pong: |evlh, idata, _, shell_surface, serial| { - let &(_, ref shell) = unsafe { &*(shell_surface.get_user_data() as *mut ShellSurfaceUserData) }; + let &(_, ref shell) = + unsafe { &*(shell_surface.get_user_data() as *mut ShellSurfaceUserData) }; let valid = { let mutex = unsafe { &*(shell.get_user_data() as *mut ShellUserData) }; let mut guard = mutex.lock().unwrap(); diff --git a/src/wayland/shell/xdg_handlers.rs b/src/wayland/shell/xdg_handlers.rs index 66b5380..203d665 100644 --- a/src/wayland/shell/xdg_handlers.rs +++ b/src/wayland/shell/xdg_handlers.rs @@ -10,10 +10,10 @@ use wayland_protocols::unstable::xdg_shell::v6::server::{zxdg_popup_v6, zxdg_pos use wayland_server::{Client, EventLoopHandle, Resource}; use wayland_server::protocol::{wl_output, wl_surface}; -pub(crate) fn xdg_shell_bind(evlh: &mut EventLoopHandle, - idata: &mut ShellSurfaceIData, - _: &Client, shell: zxdg_shell_v6::ZxdgShellV6) -where +pub(crate) fn xdg_shell_bind( + evlh: &mut EventLoopHandle, idata: &mut ShellSurfaceIData, _: &Client, + shell: zxdg_shell_v6::ZxdgShellV6, +) where U: 'static, R: Role + 'static, CID: 'static, @@ -53,8 +53,7 @@ pub(crate) fn make_shell_client(resource: &zxdg_shell_v6::ZxdgShellV6) -> Sh } fn shell_implementation( - ) - -> zxdg_shell_v6::Implementation> +) -> zxdg_shell_v6::Implementation> where U: 'static, R: Role + 'static, @@ -104,11 +103,10 @@ where ); return; } - xdg_surface.set_user_data( - Box::into_raw(Box::new((unsafe { wl_surface.clone_unchecked() }, unsafe { - shell.clone_unchecked() - }))) as *mut _, - ); + xdg_surface.set_user_data(Box::into_raw(Box::new(( + unsafe { wl_surface.clone_unchecked() }, + unsafe { shell.clone_unchecked() }, + ))) as *mut _); evlh.register( &xdg_surface, surface_implementation(), @@ -151,30 +149,34 @@ fn destroy_positioner(positioner: &zxdg_positioner_v6::ZxdgPositionerV6) { fn positioner_implementation() -> zxdg_positioner_v6::Implementation<()> { zxdg_positioner_v6::Implementation { destroy: |_, _, _, _| {}, - set_size: |_, _, _, positioner, width, height| if width < 1 || height < 1 { - positioner.post_error( - zxdg_positioner_v6::Error::InvalidInput as u32, - "Invalid size for positioner.".into(), - ); - } else { - let ptr = positioner.get_user_data(); - let state = unsafe { &mut *(ptr as *mut PositionerState) }; - state.rect_size = (width, height); + set_size: |_, _, _, positioner, width, height| { + if width < 1 || height < 1 { + positioner.post_error( + zxdg_positioner_v6::Error::InvalidInput as u32, + "Invalid size for positioner.".into(), + ); + } else { + let ptr = positioner.get_user_data(); + let state = unsafe { &mut *(ptr as *mut PositionerState) }; + state.rect_size = (width, height); + } }, - set_anchor_rect: |_, _, _, positioner, x, y, width, height| if width < 1 || height < 1 { - positioner.post_error( - zxdg_positioner_v6::Error::InvalidInput as u32, - "Invalid size for positioner's anchor rectangle.".into(), - ); - } else { - let ptr = positioner.get_user_data(); - let state = unsafe { &mut *(ptr as *mut PositionerState) }; - state.anchor_rect = Rectangle { - x, - y, - width, - height, - }; + set_anchor_rect: |_, _, _, positioner, x, y, width, height| { + if width < 1 || height < 1 { + positioner.post_error( + zxdg_positioner_v6::Error::InvalidInput as u32, + "Invalid size for positioner's anchor rectangle.".into(), + ); + } else { + let ptr = positioner.get_user_data(); + let state = unsafe { &mut *(ptr as *mut PositionerState) }; + state.anchor_rect = Rectangle { + x, + y, + width, + height, + }; + } }, set_anchor: |_, _, _, positioner, anchor| { use self::zxdg_positioner_v6::Anchor; @@ -228,15 +230,15 @@ fn destroy_surface(surface: &zxdg_surface_v6::ZxdgSurfaceV6) { let ptr = surface.get_user_data(); surface.set_user_data(::std::ptr::null_mut()); // drop the state - let data = - unsafe { Box::from_raw(ptr as *mut (zxdg_surface_v6::ZxdgSurfaceV6, zxdg_shell_v6::ZxdgShellV6)) }; + let data = unsafe { + Box::from_raw(ptr as *mut (zxdg_surface_v6::ZxdgSurfaceV6, zxdg_shell_v6::ZxdgShellV6)) + }; // explicit call to drop to not forget what we're doing here ::std::mem::drop(data); } fn surface_implementation( - ) - -> zxdg_surface_v6::Implementation> +) -> zxdg_surface_v6::Implementation> where U: 'static, R: Role + 'static, @@ -417,9 +419,9 @@ fn destroy_toplevel(surface: &zxdg_toplevel_v6::ZxdgToplevelV6) { } // Utility functions allowing to factor out a lot of the upcoming logic -fn with_surface_toplevel_data(idata: &ShellSurfaceIData, - toplevel: &zxdg_toplevel_v6::ZxdgToplevelV6, f: F) -where +fn with_surface_toplevel_data( + idata: &ShellSurfaceIData, toplevel: &zxdg_toplevel_v6::ZxdgToplevelV6, f: F +) where U: 'static, R: Role + 'static, CID: 'static, @@ -438,13 +440,11 @@ where .expect("xdg_toplevel exists but surface has not shell_surface role?!"); } -fn xdg_handle_display_state_change(evlh: &mut EventLoopHandle, - idata: &ShellSurfaceIData, - toplevel: &zxdg_toplevel_v6::ZxdgToplevelV6, - maximized: Option, minimized: Option, - fullscreen: Option, - output: Option<&wl_output::WlOutput>) -where +fn xdg_handle_display_state_change( + evlh: &mut EventLoopHandle, idata: &ShellSurfaceIData, + toplevel: &zxdg_toplevel_v6::ZxdgToplevelV6, maximized: Option, minimized: Option, + fullscreen: Option, output: Option<&wl_output::WlOutput>, +) where U: 'static, R: Role + 'static, CID: 'static, @@ -467,11 +467,10 @@ where send_toplevel_configure(idata.compositor_token, toplevel, configure); } - -pub fn send_toplevel_configure(token: CompositorToken, - resource: &zxdg_toplevel_v6::ZxdgToplevelV6, - configure: ToplevelConfigure) -where +pub fn send_toplevel_configure( + token: CompositorToken, resource: &zxdg_toplevel_v6::ZxdgToplevelV6, + configure: ToplevelConfigure, +) where U: 'static, R: Role + 'static, ID: 'static, @@ -497,9 +496,9 @@ where .expect("xdg_toplevel exists but surface has not shell_surface role?!"); } -fn make_toplevel_handle(token: CompositorToken, - resource: &zxdg_toplevel_v6::ZxdgToplevelV6) - -> super::ToplevelSurface { +fn make_toplevel_handle( + token: CompositorToken, resource: &zxdg_toplevel_v6::ZxdgToplevelV6 +) -> super::ToplevelSurface { let ptr = resource.get_user_data(); let &(ref wl_surface, _, _) = unsafe { &*(ptr as *mut ShellSurfaceUserData) }; super::ToplevelSurface { @@ -511,8 +510,7 @@ fn make_toplevel_handle(token: CompositorToken, } fn toplevel_implementation( - ) - -> zxdg_toplevel_v6::Implementation> +) -> zxdg_toplevel_v6::Implementation> where U: 'static, R: Role + 'static, @@ -546,8 +544,9 @@ where with_surface_toplevel_data(idata, toplevel, |toplevel_data| { toplevel_data.parent = parent.map(|toplevel_surface_parent| { let parent_ptr = toplevel_surface_parent.get_user_data(); - let &(ref parent_surface, _) = - unsafe { &*(parent_ptr as *mut (wl_surface::WlSurface, zxdg_shell_v6::ZxdgShellV6)) }; + let &(ref parent_surface, _) = unsafe { + &*(parent_ptr as *mut (wl_surface::WlSurface, zxdg_shell_v6::ZxdgShellV6)) + }; unsafe { parent_surface.clone_unchecked() } }) }); @@ -620,10 +619,9 @@ fn destroy_popup(surface: &zxdg_popup_v6::ZxdgPopupV6) { ::std::mem::drop(data); } -pub(crate) fn send_popup_configure(token: CompositorToken, - resource: &zxdg_popup_v6::ZxdgPopupV6, - configure: PopupConfigure) -where +pub(crate) fn send_popup_configure( + token: CompositorToken, resource: &zxdg_popup_v6::ZxdgPopupV6, configure: PopupConfigure +) where U: 'static, R: Role + 'static, ID: 'static, @@ -641,8 +639,9 @@ where .expect("xdg_toplevel exists but surface has not shell_surface role?!"); } -fn make_popup_handle(token: CompositorToken, resource: &zxdg_popup_v6::ZxdgPopupV6) - -> super::PopupSurface { +fn make_popup_handle( + token: CompositorToken, resource: &zxdg_popup_v6::ZxdgPopupV6 +) -> super::PopupSurface { let ptr = resource.get_user_data(); let &(ref wl_surface, _, _) = unsafe { &*(ptr as *mut ShellSurfaceUserData) }; super::PopupSurface { @@ -654,8 +653,7 @@ fn make_popup_handle(token: CompositorToken, resource: &zx } fn popup_implementation( - ) - -> zxdg_popup_v6::Implementation> +) -> zxdg_popup_v6::Implementation> where U: 'static, R: Role + 'static, diff --git a/src/wayland/shm/mod.rs b/src/wayland/shm/mod.rs index e60a02b..0346079 100644 --- a/src/wayland/shm/mod.rs +++ b/src/wayland/shm/mod.rs @@ -61,7 +61,6 @@ //! //! If you are already using an handler for this signal, you probably don't want to use this handler. - use self::pool::{Pool, ResizeError}; use std::rc::Rc; use std::sync::Arc; @@ -89,8 +88,9 @@ pub struct ShmGlobalData { /// The global is directly registered into the eventloop, and this function /// returns the global handle, in case you whish to remove this global in /// the future. -pub fn init_shm_global(evl: &mut EventLoop, mut formats: Vec, logger: L) - -> Global +pub fn init_shm_global( + evl: &mut EventLoop, mut formats: Vec, logger: L +) -> Global where L: Into>, { diff --git a/src/wayland/shm/pool.rs b/src/wayland/shm/pool.rs index 20faa62..b70442a 100644 --- a/src/wayland/shm/pool.rs +++ b/src/wayland/shm/pool.rs @@ -1,5 +1,3 @@ - - use nix::{libc, unistd}; use nix::sys::mman; use nix::sys::signal::{self, SigAction, SigHandler, Signal};