vtimofei
/
smithay
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

rustfmt 0.9 update

This commit is contained in:
Drakulix 2017-06-20 11:31:18 +02:00
parent b131f8168e
commit 206007f5a5
11 changed files with 648 additions and 505 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
build.rs
View File

@ -12,11 +12,13 @@ fn main() {
println!("cargo:rerun-if-changed=build.rs"); println!("cargo:rerun-if-changed=build.rs");
let mut file = File::create(&dest.join("egl_bindings.rs")).unwrap(); let mut file = File::create(&dest.join("egl_bindings.rs")).unwrap();
Registry::new(Api::Egl, Registry::new(
Api::Egl,
(1, 5), (1, 5),
Profile::Core, Profile::Core,
Fallbacks::All, Fallbacks::All,
["EGL_KHR_create_context", [
"EGL_KHR_create_context",
"EGL_EXT_create_context_robustness", "EGL_EXT_create_context_robustness",
"EGL_KHR_create_context_no_error", "EGL_KHR_create_context_no_error",
"EGL_KHR_platform_x11", "EGL_KHR_platform_x11",
@ -27,7 +29,8 @@ fn main() {
"EGL_EXT_platform_x11", "EGL_EXT_platform_x11",
"EGL_MESA_platform_gbm", "EGL_MESA_platform_gbm",
"EGL_EXT_platform_wayland", "EGL_EXT_platform_wayland",
"EGL_EXT_platform_device"]) "EGL_EXT_platform_device",
.write_bindings(gl_generator::StructGenerator, &mut file) ],
).write_bindings(gl_generator::StructGenerator, &mut file)
.unwrap(); .unwrap();
} }

7
examples/simple.rs
View File

@ -17,9 +17,10 @@ fn main() {
// Insert the ShmGlobal as a handler to your event loop // Insert the ShmGlobal as a handler to your event loop
// Here, we specify tha the standard Argb8888 and Xrgb8888 is the only supported. // Here, we specify tha the standard Argb8888 and Xrgb8888 is the only supported.
let handler_id = let handler_id = event_loop.add_handler_with_init(ShmGlobal::new(
event_loop.add_handler_with_init(ShmGlobal::new(vec![], vec![],
None /* we don't provide a logger here */)); None, /* we don't provide a logger here */
));
// Register this handler to advertise a wl_shm global of version 1 // Register this handler to advertise a wl_shm global of version 1
let shm_global = event_loop.register_global::<wl_shm::WlShm, ShmGlobal>(handler_id, 1); let shm_global = event_loop.register_global::<wl_shm::WlShm, ShmGlobal>(handler_id, 1);

153
src/backend/graphics/egl.rs
View File

@ -168,10 +168,11 @@ impl EGLContext {
/// ///
/// This method is marked unsafe, because the contents of `NativeDisplay` cannot be verified and may /// This method is marked unsafe, because the contents of `NativeDisplay` cannot be verified and may
/// contain dangling pointers or similar unsafe content /// contain dangling pointers or similar unsafe content
pub unsafe fn new<L>(native: NativeDisplay, mut attributes: GlAttributes, pub unsafe fn new<L>(native: NativeDisplay, mut attributes: GlAttributes, reqs: PixelFormatRequirements,
reqs: PixelFormatRequirements, logger: L) logger: L)
-> Result<EGLContext, CreationError> -> Result<EGLContext, CreationError>
where L: Into<Option<::slog::Logger>> where
L: Into<Option<::slog::Logger>>,
{ {
let logger = logger.into(); let logger = logger.into();
let log = ::slog_or_stdlog(logger.clone()).new(o!("smithay_module" => "renderer_egl")); let log = ::slog_or_stdlog(logger.clone()).new(o!("smithay_module" => "renderer_egl"));
@ -196,14 +197,18 @@ impl EGLContext {
} }
} }
Some((1, _)) => { Some((1, _)) => {
error!(log, error!(
"OpenGLES 1.* is not supported by the EGL renderer backend"); log,
"OpenGLES 1.* is not supported by the EGL renderer backend"
);
return Err(CreationError::OpenGlVersionNotSupported); return Err(CreationError::OpenGlVersionNotSupported);
} }
Some(version) => { Some(version) => {
error!(log, error!(
log,
"OpenGLES {:?} is unknown and not supported by the EGL renderer backend", "OpenGLES {:?} is unknown and not supported by the EGL renderer backend",
version); version
);
return Err(CreationError::OpenGlVersionNotSupported); return Err(CreationError::OpenGlVersionNotSupported);
} }
}; };
@ -238,46 +243,54 @@ impl EGLContext {
let has_dp_extension = |e: &str| dp_extensions.iter().any(|s| s == e); let has_dp_extension = |e: &str| dp_extensions.iter().any(|s| s == e);
let display = match native { let display = match native {
NativeDisplay::X11(display) if has_dp_extension("EGL_KHR_platform_x11") && NativeDisplay::X11(display)
egl.GetPlatformDisplay.is_loaded() => { if has_dp_extension("EGL_KHR_platform_x11") && egl.GetPlatformDisplay.is_loaded() => {
trace!(log, "EGL Display Initialization via EGL_KHR_platform_x11"); trace!(log, "EGL Display Initialization via EGL_KHR_platform_x11");
egl.GetPlatformDisplay(ffi::egl::PLATFORM_X11_KHR, display as *mut _, ptr::null()) egl.GetPlatformDisplay(ffi::egl::PLATFORM_X11_KHR, display as *mut _, ptr::null())
} }
NativeDisplay::X11(display) if has_dp_extension("EGL_EXT_platform_x11") && NativeDisplay::X11(display)
egl.GetPlatformDisplayEXT.is_loaded() => { if has_dp_extension("EGL_EXT_platform_x11") && egl.GetPlatformDisplayEXT.is_loaded() => {
trace!(log, "EGL Display Initialization via EGL_EXT_platform_x11"); trace!(log, "EGL Display Initialization via EGL_EXT_platform_x11");
egl.GetPlatformDisplayEXT(ffi::egl::PLATFORM_X11_EXT, display as *mut _, ptr::null()) egl.GetPlatformDisplayEXT(ffi::egl::PLATFORM_X11_EXT, display as *mut _, ptr::null())
} }
NativeDisplay::Gbm(display) if has_dp_extension("EGL_KHR_platform_gbm") && NativeDisplay::Gbm(display)
egl.GetPlatformDisplay.is_loaded() => { if has_dp_extension("EGL_KHR_platform_gbm") && egl.GetPlatformDisplay.is_loaded() => {
trace!(log, "EGL Display Initialization via EGL_KHR_platform_gbm"); trace!(log, "EGL Display Initialization via EGL_KHR_platform_gbm");
egl.GetPlatformDisplay(ffi::egl::PLATFORM_GBM_KHR, display as *mut _, ptr::null()) egl.GetPlatformDisplay(ffi::egl::PLATFORM_GBM_KHR, display as *mut _, ptr::null())
} }
NativeDisplay::Gbm(display) if has_dp_extension("EGL_MESA_platform_gbm") && NativeDisplay::Gbm(display)
egl.GetPlatformDisplayEXT.is_loaded() => { if has_dp_extension("EGL_MESA_platform_gbm") && egl.GetPlatformDisplayEXT.is_loaded() => {
trace!(log, "EGL Display Initialization via EGL_MESA_platform_gbm"); trace!(log, "EGL Display Initialization via EGL_MESA_platform_gbm");
egl.GetPlatformDisplayEXT(ffi::egl::PLATFORM_GBM_KHR, display as *mut _, ptr::null()) egl.GetPlatformDisplayEXT(ffi::egl::PLATFORM_GBM_KHR, display as *mut _, ptr::null())
} }
NativeDisplay::Wayland(display) if has_dp_extension("EGL_KHR_platform_wayland") && NativeDisplay::Wayland(display)
egl.GetPlatformDisplay.is_loaded() => { if has_dp_extension("EGL_KHR_platform_wayland") && egl.GetPlatformDisplay.is_loaded() => {
trace!(log, trace!(
"EGL Display Initialization via EGL_KHR_platform_wayland"); log,
egl.GetPlatformDisplay(ffi::egl::PLATFORM_WAYLAND_KHR, "EGL Display Initialization via EGL_KHR_platform_wayland"
);
egl.GetPlatformDisplay(
ffi::egl::PLATFORM_WAYLAND_KHR,
display as *mut _, display as *mut _,
ptr::null()) ptr::null(),
)
} }
NativeDisplay::Wayland(display) if has_dp_extension("EGL_EXT_platform_wayland") && NativeDisplay::Wayland(display)
egl.GetPlatformDisplayEXT.is_loaded() => { if has_dp_extension("EGL_EXT_platform_wayland") && egl.GetPlatformDisplayEXT.is_loaded() => {
trace!(log, trace!(
"EGL Display Initialization via EGL_EXT_platform_wayland"); log,
egl.GetPlatformDisplayEXT(ffi::egl::PLATFORM_WAYLAND_EXT, "EGL Display Initialization via EGL_EXT_platform_wayland"
);
egl.GetPlatformDisplayEXT(
ffi::egl::PLATFORM_WAYLAND_EXT,
display as *mut _, display as *mut _,
ptr::null()) ptr::null(),
)
} }
NativeDisplay::X11(display) | NativeDisplay::X11(display) |
@ -315,8 +328,10 @@ impl EGLContext {
info!(log, "EGL Extensions: {:?}", extensions); info!(log, "EGL Extensions: {:?}", extensions);
if egl_version >= (1, 2) && egl.BindAPI(ffi::egl::OPENGL_ES_API) == 0 { if egl_version >= (1, 2) && egl.BindAPI(ffi::egl::OPENGL_ES_API) == 0 {
error!(log, error!(
"OpenGLES not supported by the underlying EGL implementation"); log,
"OpenGLES not supported by the underlying EGL implementation"
);
return Err(CreationError::OpenGlVersionNotSupported); return Err(CreationError::OpenGlVersionNotSupported);
} }
@ -339,8 +354,10 @@ impl EGLContext {
match version { match version {
(3, _) => { (3, _) => {
if egl_version < (1, 3) { if egl_version < (1, 3) {
error!(log, error!(
"OpenglES 3.* is not supported on EGL Versions lower then 1.3"); log,
"OpenglES 3.* is not supported on EGL Versions lower then 1.3"
);
return Err(CreationError::NoAvailablePixelFormat); return Err(CreationError::NoAvailablePixelFormat);
} }
trace!(log, "Setting RENDERABLE_TYPE to OPENGL_ES3"); trace!(log, "Setting RENDERABLE_TYPE to OPENGL_ES3");
@ -352,8 +369,10 @@ impl EGLContext {
} }
(2, _) => { (2, _) => {
if egl_version < (1, 3) { if egl_version < (1, 3) {
error!(log, error!(
"OpenglES 2.* is not supported on EGL Versions lower then 1.3"); log,
"OpenglES 2.* is not supported on EGL Versions lower then 1.3"
);
return Err(CreationError::NoAvailablePixelFormat); return Err(CreationError::NoAvailablePixelFormat);
} }
trace!(log, "Setting RENDERABLE_TYPE to OPENGL_ES2"); trace!(log, "Setting RENDERABLE_TYPE to OPENGL_ES2");
@ -381,14 +400,18 @@ impl EGLContext {
trace!(log, "Setting RED_SIZE to {}", color / 3); trace!(log, "Setting RED_SIZE to {}", color / 3);
out.push(ffi::egl::RED_SIZE as c_int); out.push(ffi::egl::RED_SIZE as c_int);
out.push((color / 3) as c_int); out.push((color / 3) as c_int);
trace!(log, trace!(
log,
"Setting GREEN_SIZE to {}", "Setting GREEN_SIZE to {}",
color / 3 + if color % 3 != 0 { 1 } else { 0 }); color / 3 + if color % 3 != 0 { 1 } else { 0 }
);
out.push(ffi::egl::GREEN_SIZE as c_int); out.push(ffi::egl::GREEN_SIZE as c_int);
out.push((color / 3 + if color % 3 != 0 { 1 } else { 0 }) as c_int); out.push((color / 3 + if color % 3 != 0 { 1 } else { 0 }) as c_int);
trace!(log, trace!(
log,
"Setting BLUE_SIZE to {}", "Setting BLUE_SIZE to {}",
color / 3 + if color % 3 == 2 { 1 } else { 0 }); color / 3 + if color % 3 == 2 { 1 } else { 0 }
);
out.push(ffi::egl::BLUE_SIZE as c_int); out.push(ffi::egl::BLUE_SIZE as c_int);
out.push((color / 3 + if color % 3 == 2 { 1 } else { 0 }) as c_int); out.push((color / 3 + if color % 3 == 2 { 1 } else { 0 }) as c_int);
} }
@ -429,12 +452,17 @@ impl EGLContext {
// calling `eglChooseConfig` // calling `eglChooseConfig`
let mut config_id = mem::uninitialized(); let mut config_id = mem::uninitialized();
let mut num_configs = mem::uninitialized(); let mut num_configs = mem::uninitialized();
if egl.ChooseConfig(display, if egl.ChooseConfig(
display,
descriptor.as_ptr(), descriptor.as_ptr(),
&mut config_id, &mut config_id,
1, 1,
&mut num_configs) == 0 { &mut num_configs,
return Err(CreationError::OsError(String::from("eglChooseConfig failed"))); ) == 0
{
return Err(CreationError::OsError(
String::from("eglChooseConfig failed"),
));
} }
if num_configs == 0 { if num_configs == 0 {
error!(log, "No matching color format found"); error!(log, "No matching color format found");
@ -509,8 +537,10 @@ impl EGLContext {
if context.is_null() { if context.is_null() {
match egl.GetError() as u32 { match egl.GetError() as u32 {
ffi::egl::BAD_ATTRIBUTE => { ffi::egl::BAD_ATTRIBUTE => {
error!(log, error!(
"Context creation failed as one or more requirements could not be met. Try removing some gl attributes or pixel format requirements"); log,
"Context creation failed as one or more requirements could not be met. Try removing some gl attributes or pixel format requirements"
);
return Err(CreationError::OpenGlVersionNotSupported); return Err(CreationError::OpenGlVersionNotSupported);
} }
e => panic!("eglCreateContext failed: 0x{:x}", e), e => panic!("eglCreateContext failed: 0x{:x}", e),
@ -573,17 +603,20 @@ impl EGLContext {
(NativeSurface::X11(window), NativeType::X11) | (NativeSurface::X11(window), NativeType::X11) |
(NativeSurface::Wayland(window), NativeType::Wayland) | (NativeSurface::Wayland(window), NativeType::Wayland) |
(NativeSurface::Gbm(window), NativeType::Gbm) => { (NativeSurface::Gbm(window), NativeType::Gbm) => {
self.egl self.egl.CreateWindowSurface(
.CreateWindowSurface(self.display, self.display,
self.config_id, self.config_id,
window, window,
self.surface_attributes.as_ptr()) self.surface_attributes.as_ptr(),
)
} }
_ => return Err(CreationError::NonMatchingSurfaceType), _ => return Err(CreationError::NonMatchingSurfaceType),
}; };
if surface.is_null() { if surface.is_null() {
return Err(CreationError::OsError(String::from("eglCreateWindowSurface failed"))); return Err(CreationError::OsError(
String::from("eglCreateWindowSurface failed"),
));
} }
surface surface
@ -621,9 +654,10 @@ impl<'a> EGLSurface<'a> {
/// Swaps buffers at the end of a frame. /// Swaps buffers at the end of a frame.
pub fn swap_buffers(&self) -> Result<(), SwapBuffersError> { pub fn swap_buffers(&self) -> Result<(), SwapBuffersError> {
let ret = unsafe { let ret = unsafe {
self.context self.context.egl.SwapBuffers(
.egl self.context.display as *const _,
.SwapBuffers(self.context.display as *const _, self.surface as *const _) self.surface as *const _,
)
}; };
if ret == 0 { if ret == 0 {
@ -643,12 +677,12 @@ impl<'a> EGLSurface<'a> {
/// This function is marked unsafe, because the context cannot be made current /// This function is marked unsafe, because the context cannot be made current
/// on multiple threads. /// on multiple threads.
pub unsafe fn make_current(&self) -> Result<(), SwapBuffersError> { pub unsafe fn make_current(&self) -> Result<(), SwapBuffersError> {
let ret = self.context let ret = self.context.egl.MakeCurrent(
.egl self.context.display as *const _,
.MakeCurrent(self.context.display as *const _,
self.surface as *const _, self.surface as *const _,
self.surface as *const _, self.surface as *const _,
self.context.context as *const _); self.context.context as *const _,
);
if ret == 0 { if ret == 0 {
match self.context.egl.GetError() as u32 { match self.context.egl.GetError() as u32 {
@ -671,8 +705,10 @@ impl Drop for EGLContext {
unsafe { unsafe {
// we don't call MakeCurrent(0, 0) because we are not sure that the context // we don't call MakeCurrent(0, 0) because we are not sure that the context
// is still the current one // is still the current one
self.egl self.egl.DestroyContext(
.DestroyContext(self.display as *const _, self.context as *const _); self.display as *const _,
self.context as *const _,
);
self.egl.Terminate(self.display as *const _); self.egl.Terminate(self.display as *const _);
} }
} }
@ -681,9 +717,10 @@ impl Drop for EGLContext {
impl<'a> Drop for EGLSurface<'a> { impl<'a> Drop for EGLSurface<'a> {
fn drop(&mut self) { fn drop(&mut self) {
unsafe { unsafe {
self.context self.context.egl.DestroySurface(
.egl self.context.display as *const _,
.DestroySurface(self.context.display as *const _, self.surface as *const _); self.surface as *const _,
);
} }
} }
} }

6
src/backend/graphics/glium.rs
View File

@ -48,8 +48,10 @@ impl<T: EGLGraphicsBackend + 'static> GliumGraphicsBackend<T> {
/// Note that destroying a `Frame` is immediate, even if vsync is enabled. /// Note that destroying a `Frame` is immediate, even if vsync is enabled.
#[inline] #[inline]
pub fn draw(&self) -> Frame { pub fn draw(&self) -> Frame {
Frame::new(self.context.clone(), Frame::new(
self.backend.get_framebuffer_dimensions()) self.context.clone(),
self.backend.get_framebuffer_dimensions(),
)
} }
} }

18
src/backend/input.rs
View File

@ -49,7 +49,8 @@ impl ::std::cmp::PartialEq for Seat {
impl ::std::hash::Hash for Seat { impl ::std::hash::Hash for Seat {
fn hash<H>(&self, state: &mut H) fn hash<H>(&self, state: &mut H)
where H: ::std::hash::Hasher where
H: ::std::hash::Hasher,
{ {
self.id.hash(state); self.id.hash(state);
} }
@ -275,7 +276,10 @@ pub trait PointerMotionAbsoluteEvent: Event {
/// Device position converted to the targets coordinate space. /// Device position converted to the targets coordinate space.
/// E.g. the focused output's resolution. /// E.g. the focused output's resolution.
fn position_transformed(&self, coordinate_space: (u32, u32)) -> (u32, u32) { fn position_transformed(&self, coordinate_space: (u32, u32)) -> (u32, u32) {
(self.x_transformed(coordinate_space.0), self.y_transformed(coordinate_space.1)) (
self.x_transformed(coordinate_space.0),
self.y_transformed(coordinate_space.1),
)
} }
/// Device x position converted to the targets coordinate space's width. /// Device x position converted to the targets coordinate space's width.
@ -336,7 +340,10 @@ pub trait TouchDownEvent: Event {
/// Touch position converted into the target coordinate space. /// Touch position converted into the target coordinate space.
/// E.g. the focused output's resolution. /// E.g. the focused output's resolution.
fn position_transformed(&self, coordinate_space: (u32, u32)) -> (u32, u32) { fn position_transformed(&self, coordinate_space: (u32, u32)) -> (u32, u32) {
(self.x_transformed(coordinate_space.0), self.y_transformed(coordinate_space.1)) (
self.x_transformed(coordinate_space.0),
self.y_transformed(coordinate_space.1),
)
} }
/// Touch event's x-coordinate in the device's native coordinate space /// Touch event's x-coordinate in the device's native coordinate space
@ -395,7 +402,10 @@ pub trait TouchMotionEvent: Event {
/// Touch position converted into the target coordinate space. /// Touch position converted into the target coordinate space.
/// E.g. the focused output's resolution. /// E.g. the focused output's resolution.
fn position_transformed(&self, coordinate_space: (u32, u32)) -> (u32, u32) { fn position_transformed(&self, coordinate_space: (u32, u32)) -> (u32, u32) {
(self.x_transformed(coordinate_space.0), self.y_transformed(coordinate_space.1)) (
self.x_transformed(coordinate_space.0),
self.y_transformed(coordinate_space.1),
)
} }
/// Touch event's x-coordinate in the device's native coordinate space /// Touch event's x-coordinate in the device's native coordinate space

85
src/backend/libinput.rs
View File

@ -26,7 +26,8 @@ impl LibinputInputBackend {
/// Initialize a new `LibinputInputBackend` from a given already initialized libinput /// Initialize a new `LibinputInputBackend` from a given already initialized libinput
/// context. /// context.
pub fn new<L>(context: libinput::Libinput, logger: L) -> Self pub fn new<L>(context: libinput::Libinput, logger: L) -> Self
where L: Into<Option<::slog::Logger>> where
L: Into<Option<::slog::Logger>>,
{ {
let log = ::slog_or_stdlog(logger).new(o!("smithay_module" => "backend_libinput")); let log = ::slog_or_stdlog(logger).new(o!("smithay_module" => "backend_libinput"));
info!(log, "Initializing a libinput backend"); info!(log, "Initializing a libinput backend");
@ -270,9 +271,9 @@ impl backend::InputBackend for LibinputInputBackend {
} }
fn get_handler(&mut self) -> Option<&mut backend::InputHandler<Self>> { fn get_handler(&mut self) -> Option<&mut backend::InputHandler<Self>> {
self.handler self.handler.as_mut().map(|handler| {
.as_mut() handler as &mut backend::InputHandler<Self>
.map(|handler| handler as &mut backend::InputHandler<Self>) })
} }
fn clear_handler(&mut self) { fn clear_handler(&mut self) {
@ -328,8 +329,8 @@ impl backend::InputBackend for LibinputInputBackend {
Entry::Vacant(seat_entry) => { Entry::Vacant(seat_entry) => {
let mut hasher = DefaultHasher::default(); let mut hasher = DefaultHasher::default();
seat_entry.key().hash(&mut hasher); seat_entry.key().hash(&mut hasher);
let seat = seat_entry let seat =
.insert(backend::Seat::new(hasher.finish(), new_caps)); seat_entry.insert(backend::Seat::new(hasher.finish(), new_caps));
if let Some(ref mut handler) = self.handler { if let Some(ref mut handler) = self.handler {
trace!(self.logger, "Calling on_seat_created with {:?}", seat); trace!(self.logger, "Calling on_seat_created with {:?}", seat);
handler.on_seat_created(seat); handler.on_seat_created(seat);
@ -394,18 +395,20 @@ impl backend::InputBackend for LibinputInputBackend {
use input::event::touch::*; use input::event::touch::*;
if let Some(ref mut handler) = self.handler { if let Some(ref mut handler) = self.handler {
let device_seat = touch_event.device().seat(); let device_seat = touch_event.device().seat();
let seat = &self.seats let seat = &self.seats.get(&device_seat).expect(
.get(&device_seat) "Recieved touch event of non existing Seat",
.expect("Recieved touch event of non existing Seat"); );
match touch_event { match touch_event {
TouchEvent::Down(down_event) => { TouchEvent::Down(down_event) => {
trace!(self.logger, "Calling on_touch_down with {:?}", down_event); trace!(self.logger, "Calling on_touch_down with {:?}", down_event);
handler.on_touch_down(seat, down_event) handler.on_touch_down(seat, down_event)
} }
TouchEvent::Motion(motion_event) => { TouchEvent::Motion(motion_event) => {
trace!(self.logger, trace!(
self.logger,
"Calling on_touch_motion with {:?}", "Calling on_touch_motion with {:?}",
motion_event); motion_event
);
handler.on_touch_motion(seat, motion_event) handler.on_touch_motion(seat, motion_event)
} }
TouchEvent::Up(up_event) => { TouchEvent::Up(up_event) => {
@ -413,9 +416,11 @@ impl backend::InputBackend for LibinputInputBackend {
handler.on_touch_up(seat, up_event) handler.on_touch_up(seat, up_event)
} }
TouchEvent::Cancel(cancel_event) => { TouchEvent::Cancel(cancel_event) => {
trace!(self.logger, trace!(
self.logger,
"Calling on_touch_cancel with {:?}", "Calling on_touch_cancel with {:?}",
cancel_event); cancel_event
);
handler.on_touch_cancel(seat, cancel_event) handler.on_touch_cancel(seat, cancel_event)
} }
TouchEvent::Frame(frame_event) => { TouchEvent::Frame(frame_event) => {
@ -431,9 +436,9 @@ impl backend::InputBackend for LibinputInputBackend {
KeyboardEvent::Key(key_event) => { KeyboardEvent::Key(key_event) => {
if let Some(ref mut handler) = self.handler { if let Some(ref mut handler) = self.handler {
let device_seat = key_event.device().seat(); let device_seat = key_event.device().seat();
let seat = &self.seats let seat = &self.seats.get(&device_seat).expect(
.get(&device_seat) "Recieved key event of non existing Seat",
.expect("Recieved key event of non existing Seat"); );
trace!(self.logger, "Calling on_keyboard_key with {:?}", key_event); trace!(self.logger, "Calling on_keyboard_key with {:?}", key_event);
handler.on_keyboard_key(seat, key_event); handler.on_keyboard_key(seat, key_event);
} }
@ -444,49 +449,63 @@ impl backend::InputBackend for LibinputInputBackend {
use input::event::pointer::*; use input::event::pointer::*;
if let Some(ref mut handler) = self.handler { if let Some(ref mut handler) = self.handler {
let device_seat = pointer_event.device().seat(); let device_seat = pointer_event.device().seat();
let seat = &self.seats let seat = &self.seats.get(&device_seat).expect(
.get(&device_seat) "Recieved pointer event of non existing Seat",
.expect("Recieved pointer event of non existing Seat"); );
match pointer_event { match pointer_event {
PointerEvent::Motion(motion_event) => { PointerEvent::Motion(motion_event) => {
trace!(self.logger, trace!(
self.logger,
"Calling on_pointer_move with {:?}", "Calling on_pointer_move with {:?}",
motion_event); motion_event
);
handler.on_pointer_move(seat, motion_event); handler.on_pointer_move(seat, motion_event);
} }
PointerEvent::MotionAbsolute(motion_abs_event) => { PointerEvent::MotionAbsolute(motion_abs_event) => {
trace!(self.logger, trace!(
self.logger,
"Calling on_pointer_move_absolute with {:?}", "Calling on_pointer_move_absolute with {:?}",
motion_abs_event); motion_abs_event
);
handler.on_pointer_move_absolute(seat, motion_abs_event); handler.on_pointer_move_absolute(seat, motion_abs_event);
} }
PointerEvent::Axis(axis_event) => { PointerEvent::Axis(axis_event) => {
let rc_axis_event = Rc::new(axis_event); let rc_axis_event = Rc::new(axis_event);
if rc_axis_event.has_axis(Axis::Vertical) { if rc_axis_event.has_axis(Axis::Vertical) {
trace!(self.logger, trace!(
self.logger,
"Calling on_pointer_axis for Axis::Vertical with {:?}", "Calling on_pointer_axis for Axis::Vertical with {:?}",
*rc_axis_event); *rc_axis_event
handler.on_pointer_axis(seat, );
handler.on_pointer_axis(
seat,
self::PointerAxisEvent { self::PointerAxisEvent {
axis: Axis::Vertical, axis: Axis::Vertical,
event: rc_axis_event.clone(), event: rc_axis_event.clone(),
}); },
);
} }
if rc_axis_event.has_axis(Axis::Horizontal) { if rc_axis_event.has_axis(Axis::Horizontal) {
trace!(self.logger, trace!(
self.logger,
"Calling on_pointer_axis for Axis::Horizontal with {:?}", "Calling on_pointer_axis for Axis::Horizontal with {:?}",
*rc_axis_event); *rc_axis_event
handler.on_pointer_axis(seat, );
handler.on_pointer_axis(
seat,
self::PointerAxisEvent { self::PointerAxisEvent {
axis: Axis::Horizontal, axis: Axis::Horizontal,
event: rc_axis_event.clone(), event: rc_axis_event.clone(),
}); },
);
} }
} }
PointerEvent::Button(button_event) => { PointerEvent::Button(button_event) => {
trace!(self.logger, trace!(
self.logger,
"Calling on_pointer_button with {:?}", "Calling on_pointer_button with {:?}",
button_event); button_event
);
handler.on_pointer_button(seat, button_event); handler.on_pointer_button(seat, button_event);
} }
} }

192
src/backend/winit.rs
View File

@ -61,13 +61,16 @@ pub struct WinitInputBackend {
/// graphics backend trait and a corresponding `WinitInputBackend`, which implements /// graphics backend trait and a corresponding `WinitInputBackend`, which implements
/// the `InputBackend` trait /// the `InputBackend` trait
pub fn init<L>(logger: L) -> Result<(WinitGraphicsBackend, WinitInputBackend), CreationError> pub fn init<L>(logger: L) -> Result<(WinitGraphicsBackend, WinitInputBackend), CreationError>
where L: Into<Option<::slog::Logger>> where
L: Into<Option<::slog::Logger>>,
{ {
init_from_builder(WindowBuilder::new() init_from_builder(
WindowBuilder::new()
.with_dimensions(1280, 800) .with_dimensions(1280, 800)
.with_title("Smithay") .with_title("Smithay")
.with_visibility(true), .with_visibility(true),
logger) logger,
)
} }
/// Create a new `WinitGraphicsBackend`, which implements the `EGLGraphicsBackend` /// Create a new `WinitGraphicsBackend`, which implements the `EGLGraphicsBackend`
@ -75,26 +78,30 @@ pub fn init<L>(logger: L) -> Result<(WinitGraphicsBackend, WinitInputBackend), C
/// `WinitInputBackend`, which implements the `InputBackend` trait /// `WinitInputBackend`, which implements the `InputBackend` trait
pub fn init_from_builder<L>(builder: WindowBuilder, logger: L) pub fn init_from_builder<L>(builder: WindowBuilder, logger: L)
-> Result<(WinitGraphicsBackend, WinitInputBackend), CreationError> -> Result<(WinitGraphicsBackend, WinitInputBackend), CreationError>
where L: Into<Option<::slog::Logger>> where
L: Into<Option<::slog::Logger>>,
{ {
init_from_builder_with_gl_attr(builder, init_from_builder_with_gl_attr(
builder,
GlAttributes { GlAttributes {
version: None, version: None,
profile: None, profile: None,
debug: cfg!(debug_assertions), debug: cfg!(debug_assertions),
vsync: true, vsync: true,
}, },
logger) logger,
)
} }
/// Create a new `WinitGraphicsBackend`, which implements the `EGLGraphicsBackend` /// Create a new `WinitGraphicsBackend`, which implements the `EGLGraphicsBackend`
/// graphics backend trait, from a given `WindowBuilder` struct, as well as given /// graphics backend trait, from a given `WindowBuilder` struct, as well as given
/// `GlAttributes` for further customization of the rendering pipeline and a /// `GlAttributes` for further customization of the rendering pipeline and a
/// corresponding `WinitInputBackend`, which implements the `InputBackend` trait. /// corresponding `WinitInputBackend`, which implements the `InputBackend` trait.
pub fn init_from_builder_with_gl_attr<L> pub fn init_from_builder_with_gl_attr<L>(
(builder: WindowBuilder, attributes: GlAttributes, logger: L) builder: WindowBuilder, attributes: GlAttributes, logger: L)
-> Result<(WinitGraphicsBackend, WinitInputBackend), CreationError> -> Result<(WinitGraphicsBackend, WinitInputBackend), CreationError>
where L: Into<Option<::slog::Logger>> where
L: Into<Option<::slog::Logger>>,
{ {
let log = ::slog_or_stdlog(logger).new(o!("smithay_module" => "backend_winit")); let log = ::slog_or_stdlog(logger).new(o!("smithay_module" => "backend_winit"));
info!(log, "Initializing a winit backend"); info!(log, "Initializing a winit backend");
@ -103,25 +110,36 @@ pub fn init_from_builder_with_gl_attr<L>
let window = Rc::new(builder.build(&events_loop)?); let window = Rc::new(builder.build(&events_loop)?);
debug!(log, "Window created"); debug!(log, "Window created");
let (native_display, native_surface, surface) = if let (Some(conn), Some(window)) = let (native_display, native_surface, surface) =
(get_x11_xconnection(), window.get_xlib_window()) { if let (Some(conn), Some(window)) = (get_x11_xconnection(), window.get_xlib_window()) {
debug!(log, "Window is backed by X11"); debug!(log, "Window is backed by X11");
(NativeDisplay::X11(conn.display as *const _), NativeSurface::X11(window), None) (
NativeDisplay::X11(conn.display as *const _),
NativeSurface::X11(window),
None,
)
} else if let (Some(display), Some(surface)) = } else if let (Some(display), Some(surface)) =
(window.get_wayland_display(), window.get_wayland_client_surface()) { (
window.get_wayland_display(),
window.get_wayland_client_surface(),
)
{
debug!(log, "Window is backed by Wayland"); debug!(log, "Window is backed by Wayland");
let (w, h) = window.get_inner_size().unwrap(); let (w, h) = window.get_inner_size().unwrap();
let egl_surface = wegl::WlEglSurface::new(surface, w as i32, h as i32); let egl_surface = wegl::WlEglSurface::new(surface, w as i32, h as i32);
(NativeDisplay::Wayland(display), (
NativeDisplay::Wayland(display),
NativeSurface::Wayland(egl_surface.ptr() as *const _), NativeSurface::Wayland(egl_surface.ptr() as *const _),
Some(egl_surface)) Some(egl_surface),
)
} else { } else {
error!(log, "Window is backed by an unsupported graphics framework"); error!(log, "Window is backed by an unsupported graphics framework");
return Err(CreationError::NotSupported); return Err(CreationError::NotSupported);
}; };
let context = unsafe { let context = unsafe {
match EGLContext::new(native_display, match EGLContext::new(
native_display,
attributes, attributes,
PixelFormatRequirements { PixelFormatRequirements {
hardware_accelerated: Some(true), hardware_accelerated: Some(true),
@ -129,7 +147,8 @@ pub fn init_from_builder_with_gl_attr<L>
alpha_bits: Some(8), alpha_bits: Some(8),
..Default::default() ..Default::default()
}, },
log.clone()) { log.clone(),
) {
Ok(context) => context, Ok(context) => context,
Err(err) => { Err(err) => {
error!(log, "EGLContext creation failed:\n {}", err); error!(log, "EGLContext creation failed:\n {}", err);
@ -138,7 +157,8 @@ pub fn init_from_builder_with_gl_attr<L>
} }
}; };
Ok((WinitGraphicsBackend { Ok((
WinitGraphicsBackend {
window: window.clone(), window: window.clone(),
context: match egl::RentEGL::try_new(Box::new(context), move |context| unsafe { context: match egl::RentEGL::try_new(Box::new(context), move |context| unsafe {
context.create_surface(native_surface) context.create_surface(native_surface)
@ -154,16 +174,19 @@ pub fn init_from_builder_with_gl_attr<L>
surface: surface, surface: surface,
time_counter: 0, time_counter: 0,
key_counter: 0, key_counter: 0,
seat: Seat::new(0, seat: Seat::new(
0,
SeatCapabilities { SeatCapabilities {
pointer: true, pointer: true,
keyboard: true, keyboard: true,
touch: true, touch: true,
}), },
),
input_config: (), input_config: (),
handler: None, handler: None,
logger: log.new(o!("smithay_winit_component" => "input")), logger: log.new(o!("smithay_winit_component" => "input")),
})) },
))
} }
impl GraphicsBackend for WinitGraphicsBackend { impl GraphicsBackend for WinitGraphicsBackend {
@ -193,9 +216,9 @@ impl EGLGraphicsBackend for WinitGraphicsBackend {
} }
fn get_framebuffer_dimensions(&self) -> (u32, u32) { fn get_framebuffer_dimensions(&self) -> (u32, u32) {
self.window self.window.get_inner_size_pixels().expect(
.get_inner_size_pixels() "Window does not exist anymore",
.expect("Window does not exist anymore") )
} }
fn is_current(&self) -> bool { fn is_current(&self) -> bool {
@ -288,16 +311,17 @@ impl PointerMotionAbsoluteEvent for WinitMouseMovedEvent {
} }
fn x_transformed(&self, width: u32) -> u32 { fn x_transformed(&self, width: u32) -> u32 {
cmp::min((self.x * width as f64 / cmp::min(
self.window.get_inner_size_points().unwrap_or((width, 0)).0 as f64) as u32, (self.x * width as f64 / self.window.get_inner_size_points().unwrap_or((width, 0)).0 as f64) as u32,
0) 0,
)
} }
fn y_transformed(&self, height: u32) -> u32 { fn y_transformed(&self, height: u32) -> u32 {
cmp::min((self.y * height as f64 / cmp::min(
self.window.get_inner_size_points().unwrap_or((0, height)).1 as f64) as (self.y * height as f64 / self.window.get_inner_size_points().unwrap_or((0, height)).1 as f64) as u32,
u32, 0,
0) )
} }
} }
@ -390,15 +414,19 @@ impl TouchDownEvent for WinitTouchStartedEvent {
} }
fn x_transformed(&self, width: u32) -> u32 { fn x_transformed(&self, width: u32) -> u32 {
cmp::min(self.location.0 as i32 * width as i32 / cmp::min(
self.location.0 as i32 * width as i32 /
self.window.get_inner_size_points().unwrap_or((width, 0)).0 as i32, self.window.get_inner_size_points().unwrap_or((width, 0)).0 as i32,
0) as u32 0,
) as u32
} }
fn y_transformed(&self, height: u32) -> u32 { fn y_transformed(&self, height: u32) -> u32 {
cmp::min(self.location.1 as i32 * height as i32 / cmp::min(
self.location.1 as i32 * height as i32 /
self.window.get_inner_size_points().unwrap_or((0, height)).1 as i32, self.window.get_inner_size_points().unwrap_or((0, height)).1 as i32,
0) as u32 0,
) as u32
} }
} }
@ -503,16 +531,18 @@ impl InputBackend for WinitInputBackend {
} }
fn get_handler(&mut self) -> Option<&mut InputHandler<Self>> { fn get_handler(&mut self) -> Option<&mut InputHandler<Self>> {
self.handler self.handler.as_mut().map(|handler| {
.as_mut() handler as &mut InputHandler<Self>
.map(|handler| handler as &mut InputHandler<Self>) })
} }
fn clear_handler(&mut self) { fn clear_handler(&mut self) {
if let Some(mut handler) = self.handler.take() { if let Some(mut handler) = self.handler.take() {
trace!(self.logger, trace!(
self.logger,
"Calling on_seat_destroyed with {:?}", "Calling on_seat_destroyed with {:?}",
self.seat); self.seat
);
handler.on_seat_destroyed(&self.seat); handler.on_seat_destroyed(&self.seat);
} }
info!(self.logger, "Removing input handler"); info!(self.logger, "Removing input handler");
@ -552,8 +582,7 @@ impl InputBackend for WinitInputBackend {
let mut handler = self.handler.as_mut(); let mut handler = self.handler.as_mut();
let logger = &self.logger; let logger = &self.logger;
self.events_loop self.events_loop.poll_events(move |event| match event {
.poll_events(move |event| match event {
Event::WindowEvent { event, .. } => { Event::WindowEvent { event, .. } => {
match (event, handler.as_mut()) { match (event, handler.as_mut()) {
(WindowEvent::Resized(x, y), _) => { (WindowEvent::Resized(x, y), _) => {
@ -573,29 +602,32 @@ impl InputBackend for WinitInputBackend {
*key_counter = key_counter.checked_sub(1).unwrap_or(0) *key_counter = key_counter.checked_sub(1).unwrap_or(0)
} }
}; };
trace!(logger, trace!(
logger,
"Calling on_keyboard_key with {:?}", "Calling on_keyboard_key with {:?}",
(scancode, state)); (scancode, state)
handler.on_keyboard_key(seat, );
handler.on_keyboard_key(
seat,
WinitKeyboardInputEvent { WinitKeyboardInputEvent {
time: *time_counter, time: *time_counter,
key: scancode, key: scancode,
count: *key_counter, count: *key_counter,
state: state, state: state,
}) },
)
} }
(WindowEvent::MouseMoved { position: (x, y), .. }, (WindowEvent::MouseMoved { position: (x, y), .. }, Some(handler)) => {
Some(handler)) => { trace!(logger, "Calling on_pointer_move_absolute with {:?}", (x, y));
trace!(logger, handler.on_pointer_move_absolute(
"Calling on_pointer_move_absolute with {:?}", seat,
(x, y));
handler.on_pointer_move_absolute(seat,
WinitMouseMovedEvent { WinitMouseMovedEvent {
window: window.clone(), window: window.clone(),
time: *time_counter, time: *time_counter,
x: x, x: x,
y: y, y: y,
}) },
)
} }
(WindowEvent::MouseWheel { delta, .. }, Some(handler)) => { (WindowEvent::MouseWheel { delta, .. }, Some(handler)) => {
match delta { match delta {
@ -607,9 +639,11 @@ impl InputBackend for WinitInputBackend {
time: *time_counter, time: *time_counter,
delta: delta, delta: delta,
}; };
trace!(logger, trace!(
logger,
"Calling on_pointer_axis for Axis::Horizontal with {:?}", "Calling on_pointer_axis for Axis::Horizontal with {:?}",
x); x
);
handler.on_pointer_axis(seat, event); handler.on_pointer_axis(seat, event);
} }
if y != 0.0 { if y != 0.0 {
@ -618,24 +652,30 @@ impl InputBackend for WinitInputBackend {
time: *time_counter, time: *time_counter,
delta: delta, delta: delta,
}; };
trace!(logger, trace!(
logger,
"Calling on_pointer_axis for Axis::Vertical with {:?}", "Calling on_pointer_axis for Axis::Vertical with {:?}",
y); y
);
handler.on_pointer_axis(seat, event); handler.on_pointer_axis(seat, event);
} }
} }
} }
} }
(WindowEvent::MouseInput { state, button, .. }, Some(handler)) => { (WindowEvent::MouseInput { state, button, .. }, Some(handler)) => {
trace!(logger, trace!(
logger,
"Calling on_pointer_button with {:?}", "Calling on_pointer_button with {:?}",
(button, state)); (button, state)
handler.on_pointer_button(seat, );
handler.on_pointer_button(
seat,
WinitMouseInputEvent { WinitMouseInputEvent {
time: *time_counter, time: *time_counter,
button: button, button: button,
state: state, state: state,
}) },
)
} }
(WindowEvent::Touch(Touch { (WindowEvent::Touch(Touch {
phase: TouchPhase::Started, phase: TouchPhase::Started,
@ -645,13 +685,15 @@ impl InputBackend for WinitInputBackend {
}), }),
Some(handler)) => { Some(handler)) => {
trace!(logger, "Calling on_touch_down at {:?}", (x, y)); trace!(logger, "Calling on_touch_down at {:?}", (x, y));
handler.on_touch_down(seat, handler.on_touch_down(
seat,
WinitTouchStartedEvent { WinitTouchStartedEvent {
window: window.clone(), window: window.clone(),
time: *time_counter, time: *time_counter,
location: (x, y), location: (x, y),
id: id, id: id,
}) },
)
} }
(WindowEvent::Touch(Touch { (WindowEvent::Touch(Touch {
phase: TouchPhase::Moved, phase: TouchPhase::Moved,
@ -661,13 +703,15 @@ impl InputBackend for WinitInputBackend {
}), }),
Some(handler)) => { Some(handler)) => {
trace!(logger, "Calling on_touch_motion at {:?}", (x, y)); trace!(logger, "Calling on_touch_motion at {:?}", (x, y));
handler.on_touch_motion(seat, handler.on_touch_motion(
seat,
WinitTouchMovedEvent { WinitTouchMovedEvent {
window: window.clone(), window: window.clone(),
time: *time_counter, time: *time_counter,
location: (x, y), location: (x, y),
id: id, id: id,
}) },
)
} }
(WindowEvent::Touch(Touch { (WindowEvent::Touch(Touch {
phase: TouchPhase::Ended, phase: TouchPhase::Ended,
@ -677,19 +721,23 @@ impl InputBackend for WinitInputBackend {
}), }),
Some(handler)) => { Some(handler)) => {
trace!(logger, "Calling on_touch_motion at {:?}", (x, y)); trace!(logger, "Calling on_touch_motion at {:?}", (x, y));
handler.on_touch_motion(seat, handler.on_touch_motion(
seat,
WinitTouchMovedEvent { WinitTouchMovedEvent {
window: window.clone(), window: window.clone(),
time: *time_counter, time: *time_counter,
location: (x, y), location: (x, y),
id: id, id: id,
}); },
);
trace!(logger, "Calling on_touch_up"); trace!(logger, "Calling on_touch_up");
handler.on_touch_up(seat, handler.on_touch_up(
seat,
WinitTouchEndedEvent { WinitTouchEndedEvent {
time: *time_counter, time: *time_counter,
id: id, id: id,
}); },
);
} }
(WindowEvent::Touch(Touch { (WindowEvent::Touch(Touch {
phase: TouchPhase::Cancelled, phase: TouchPhase::Cancelled,
@ -698,11 +746,13 @@ impl InputBackend for WinitInputBackend {
}), }),
Some(handler)) => { Some(handler)) => {
trace!(logger, "Calling on_touch_cancel"); trace!(logger, "Calling on_touch_cancel");
handler.on_touch_cancel(seat, handler.on_touch_cancel(
seat,
WinitTouchCancelledEvent { WinitTouchCancelledEvent {
time: *time_counter, time: *time_counter,
id: id, id: id,
}) },
)
} }
(WindowEvent::Closed, _) => { (WindowEvent::Closed, _) => {
warn!(logger, "Window closed"); warn!(logger, "Window closed");

33
src/keyboard/mod.rs
View File

@ -37,7 +37,7 @@ pub use xkbcommon::xkb::{Keysym, keysyms};
/// ///
/// For some modifiers, this means that the key is currently pressed, others are toggled /// For some modifiers, this means that the key is currently pressed, others are toggled
/// (like caps lock). /// (like caps lock).
#[derive(Copy,Clone,Debug)] #[derive(Copy, Clone, Debug)]
pub struct ModifiersState { pub struct ModifiersState {
/// The "control" key /// The "control" key
pub ctrl: bool, pub ctrl: bool,
@ -95,14 +95,15 @@ impl KbdInternal {
// FIXME: This is an issue with the xkbcommon-rs crate that does not reflect this // FIXME: This is an issue with the xkbcommon-rs crate that does not reflect this
// non-threadsafety properly. // non-threadsafety properly.
let context = xkb::Context::new(xkb::CONTEXT_NO_FLAGS); let context = xkb::Context::new(xkb::CONTEXT_NO_FLAGS);
let keymap = xkb::Keymap::new_from_names(&context, let keymap = xkb::Keymap::new_from_names(
&context,
&rules, &rules,
&model, &model,
&layout, &layout,
&variant, &variant,
options, options,
xkb::KEYMAP_COMPILE_NO_FLAGS) xkb::KEYMAP_COMPILE_NO_FLAGS,
.ok_or(())?; ).ok_or(())?;
let state = xkb::State::new(&keymap); let state = xkb::State::new(&keymap);
Ok(KbdInternal { Ok(KbdInternal {
focus: None, focus: None,
@ -148,8 +149,10 @@ impl KbdInternal {
fn serialize_pressed_keys(&self) -> Vec<u8> { fn serialize_pressed_keys(&self) -> Vec<u8> {
let serialized = unsafe { let serialized = unsafe {
::std::slice::from_raw_parts(self.pressed_keys.as_ptr() as *const u8, ::std::slice::from_raw_parts(
self.pressed_keys.len() * 4) self.pressed_keys.as_ptr() as *const u8,
self.pressed_keys.len() * 4,
)
}; };
serialized.into() serialized.into()
} }
@ -167,7 +170,8 @@ pub enum Error {
pub fn create_keyboard_handler<L>(rules: &str, model: &str, layout: &str, variant: &str, pub fn create_keyboard_handler<L>(rules: &str, model: &str, layout: &str, variant: &str,
options: Option<String>, logger: L) options: Option<String>, logger: L)
-> Result<KbdHandle, Error> -> Result<KbdHandle, Error>
where L: Into<Option<::slog::Logger>> where
L: Into<Option<::slog::Logger>>,
{ {
let log = ::slog_or_stdlog(logger).new(o!("smithay_module" => "xkbcommon_handler")); let log = ::slog_or_stdlog(logger).new(o!("smithay_module" => "xkbcommon_handler"));
info!(log, "Initializing a xkbcommon handler with keymap"; info!(log, "Initializing a xkbcommon handler with keymap";
@ -184,9 +188,9 @@ pub fn create_keyboard_handler<L>(rules: &str, model: &str, layout: &str, varian
// prepare a tempfile with the keymap, to send it to clients // prepare a tempfile with the keymap, to send it to clients
let mut keymap_file = tempfile().map_err(Error::IoError)?; let mut keymap_file = tempfile().map_err(Error::IoError)?;
let keymap_data = internal.keymap.get_as_string(xkb::KEYMAP_FORMAT_TEXT_V1); let keymap_data = internal.keymap.get_as_string(xkb::KEYMAP_FORMAT_TEXT_V1);
keymap_file keymap_file.write_all(keymap_data.as_bytes()).map_err(
.write_all(keymap_data.as_bytes()) Error::IoError,
.map_err(Error::IoError)?; )?;
keymap_file.flush().map_err(Error::IoError)?; keymap_file.flush().map_err(Error::IoError)?;
trace!(log, "Keymap loaded and copied to tempfile."; trace!(log, "Keymap loaded and copied to tempfile.";
@ -235,7 +239,8 @@ impl KbdHandle {
/// The module `smithay::keyboard::keysyms` exposes definitions of all possible keysyms /// The module `smithay::keyboard::keysyms` exposes definitions of all possible keysyms
/// to be compared against. This includes non-characted keysyms, such as XF86 special keys. /// to be compared against. This includes non-characted keysyms, such as XF86 special keys.
pub fn input<F>(&self, keycode: u32, state: KeyState, serial: u32, filter: F) pub fn input<F>(&self, keycode: u32, state: KeyState, serial: u32, filter: F)
where F: FnOnce(&ModifiersState, Keysym) -> bool where
F: FnOnce(&ModifiersState, Keysym) -> bool,
{ {
trace!(self.arc.logger, "Handling keystroke"; "keycode" => keycode, "state" => format_args!("{:?}", state)); trace!(self.arc.logger, "Handling keystroke"; "keycode" => keycode, "state" => format_args!("{:?}", state));
let mut guard = self.arc.internal.lock().unwrap(); let mut guard = self.arc.internal.lock().unwrap();
@ -315,8 +320,10 @@ impl KbdHandle {
/// This should be done first, before anything else is done with this keyboard. /// This should be done first, before anything else is done with this keyboard.
pub fn send_keymap(&self, kbd: &wl_keyboard::WlKeyboard) { pub fn send_keymap(&self, kbd: &wl_keyboard::WlKeyboard) {
trace!(self.arc.logger, "Sending keymap to client"); trace!(self.arc.logger, "Sending keymap to client");
kbd.keymap(wl_keyboard::KeymapFormat::XkbV1, kbd.keymap(
wl_keyboard::KeymapFormat::XkbV1,
self.arc.keymap_file.as_raw_fd(), self.arc.keymap_file.as_raw_fd(),
self.arc.keymap_len); self.arc.keymap_len,
);
} }
} }

9
src/lib.rs
View File

@ -37,10 +37,11 @@ pub mod backend;
pub mod keyboard; pub mod keyboard;
fn slog_or_stdlog<L>(logger: L) -> ::slog::Logger fn slog_or_stdlog<L>(logger: L) -> ::slog::Logger
where L: Into<Option<::slog::Logger>> where
L: Into<Option<::slog::Logger>>,
{ {
use slog::Drain; use slog::Drain;
logger logger.into().unwrap_or_else(|| {
.into() ::slog::Logger::root(::slog_stdlog::StdLog.fuse(), o!())
.unwrap_or_else(|| ::slog::Logger::root(::slog_stdlog::StdLog.fuse(), o!())) })
} }

23
src/shm/mod.rs
View File

@ -89,7 +89,8 @@ impl ShmGlobal {
/// as they are required by the protocol. Formats given as argument /// as they are required by the protocol. Formats given as argument
/// as additionnaly advertized. /// as additionnaly advertized.
pub fn new<L>(mut formats: Vec<wl_shm::Format>, logger: L) -> ShmGlobal pub fn new<L>(mut formats: Vec<wl_shm::Format>, logger: L) -> ShmGlobal
where L: Into<Option<::slog::Logger>> where
L: Into<Option<::slog::Logger>>,
{ {
let log = ::slog_or_stdlog(logger); let log = ::slog_or_stdlog(logger);
@ -147,7 +148,8 @@ impl ShmGlobalToken {
/// If the buffer is not managed by the associated ShmGlobal, the closure is not called /// If the buffer is not managed by the associated ShmGlobal, the closure is not called
/// and this method will return `Err(())` (this will be the case for an EGL buffer for example). /// and this method will return `Err(())` (this will be the case for an EGL buffer for example).
pub fn with_buffer_contents<F>(&self, buffer: &wl_buffer::WlBuffer, f: F) -> Result<(), BufferAccessError> pub fn with_buffer_contents<F>(&self, buffer: &wl_buffer::WlBuffer, f: F) -> Result<(), BufferAccessError>
where F: FnOnce(&[u8], BufferData) where
F: FnOnce(&[u8], BufferData),
{ {
if !resource_is_registered::<_, ShmHandler>(buffer, self.hid) { if !resource_is_registered::<_, ShmHandler>(buffer, self.hid) {
return Err(BufferAccessError::NotManaged); return Err(BufferAccessError::NotManaged);
@ -156,7 +158,8 @@ impl ShmGlobalToken {
if data.pool if data.pool
.with_data_slice(|slice| f(slice, data.data)) .with_data_slice(|slice| f(slice, data.data))
.is_err() { .is_err()
{
// SIGBUS error occured // SIGBUS error occured
buffer.post_error(wl_shm::Error::InvalidFd as u32, "Bad pool size.".into()); buffer.post_error(wl_shm::Error::InvalidFd as u32, "Bad pool size.".into());
return Err(BufferAccessError::BadMap); return Err(BufferAccessError::BadMap);
@ -205,8 +208,10 @@ impl wl_shm::Handler for ShmHandler {
fn create_pool(&mut self, evqh: &mut EventLoopHandle, _client: &Client, shm: &wl_shm::WlShm, fn create_pool(&mut self, evqh: &mut EventLoopHandle, _client: &Client, shm: &wl_shm::WlShm,
pool: wl_shm_pool::WlShmPool, fd: RawFd, size: i32) { pool: wl_shm_pool::WlShmPool, fd: RawFd, size: i32) {
if size <= 0 { if size <= 0 {
shm.post_error(wl_shm::Error::InvalidFd as u32, shm.post_error(
"Invalid size for a new wl_shm_pool.".into()); wl_shm::Error::InvalidFd as u32,
"Invalid size for a new wl_shm_pool.".into(),
);
return; return;
} }
let mmap_pool = match Pool::new(fd, size as usize, self.log.clone()) { let mmap_pool = match Pool::new(fd, size as usize, self.log.clone()) {
@ -232,7 +237,7 @@ impl Destroy<wl_shm_pool::WlShmPool> for ShmHandler {
declare_handler!(ShmHandler, wl_shm::Handler, wl_shm::WlShm); declare_handler!(ShmHandler, wl_shm::Handler, wl_shm::WlShm);
/// Details of the contents of a buffer relative to its pool /// Details of the contents of a buffer relative to its pool
#[derive(Copy,Clone,Debug)] #[derive(Copy, Clone, Debug)]
pub struct BufferData { pub struct BufferData {
/// Offset of the start of the buffer relative to the beginning of the pool in bytes /// Offset of the start of the buffer relative to the beginning of the pool in bytes
pub offset: i32, pub offset: i32,
@ -280,8 +285,10 @@ impl wl_shm_pool::Handler for ShmHandler {
match arc_pool.resize(size) { match arc_pool.resize(size) {
Ok(()) => {} Ok(()) => {}
Err(ResizeError::InvalidSize) => { Err(ResizeError::InvalidSize) => {
pool.post_error(wl_shm::Error::InvalidFd as u32, pool.post_error(
"Invalid new size for a wl_shm_pool.".into()); wl_shm::Error::InvalidFd as u32,
"Invalid new size for a wl_shm_pool.".into(),
);
} }
Err(ResizeError::MremapFailed) => { Err(ResizeError::MremapFailed) => {
pool.post_error(wl_shm::Error::InvalidFd as u32, "mremap failed.".into()); pool.post_error(wl_shm::Error::InvalidFd as u32, "mremap failed.".into());

18
src/shm/pool.rs
View File

@ -160,12 +160,14 @@ impl Drop for MemMap {
// mman::mmap should really be unsafe... why isn't it? // mman::mmap should really be unsafe... why isn't it?
unsafe fn map(fd: RawFd, size: usize) -> Result<*mut u8, ()> { unsafe fn map(fd: RawFd, size: usize) -> Result<*mut u8, ()> {
let ret = mman::mmap(ptr::null_mut(), let ret = mman::mmap(
ptr::null_mut(),
size, size,
mman::PROT_READ, mman::PROT_READ,
mman::MAP_SHARED, mman::MAP_SHARED,
fd, fd,
0); 0,
);
ret.map(|p| p as *mut u8).map_err(|_| ()) ret.map(|p| p as *mut u8).map_err(|_| ())
} }
@ -176,20 +178,24 @@ unsafe fn unmap(ptr: *mut u8, size: usize) -> Result<(), ()> {
} }
unsafe fn nullify_map(ptr: *mut u8, size: usize) -> Result<(), ()> { unsafe fn nullify_map(ptr: *mut u8, size: usize) -> Result<(), ()> {
let ret = mman::mmap(ptr as *mut _, let ret = mman::mmap(
ptr as *mut _,
size, size,
mman::PROT_READ, mman::PROT_READ,
mman::MAP_ANONYMOUS | mman::MAP_PRIVATE | mman::MAP_FIXED, mman::MAP_ANONYMOUS | mman::MAP_PRIVATE | mman::MAP_FIXED,
-1, -1,
0); 0,
);
ret.map(|_| ()).map_err(|_| ()) ret.map(|_| ()).map_err(|_| ())
} }
unsafe fn place_sigbus_handler() { unsafe fn place_sigbus_handler() {
// create our sigbus handler // create our sigbus handler
let action = SigAction::new(SigHandler::SigAction(sigbus_handler), let action = SigAction::new(
SigHandler::SigAction(sigbus_handler),
signal::SA_NODEFER, signal::SA_NODEFER,
signal::SigSet::empty()); signal::SigSet::empty(),
);
match signal::sigaction(Signal::SIGBUS, &action) { match signal::sigaction(Signal::SIGBUS, &action) {
Ok(old_signal) => { Ok(old_signal) => {
OLD_SIGBUS_HANDLER = Box::into_raw(Box::new(old_signal)); OLD_SIGBUS_HANDLER = Box::into_raw(Box::new(old_signal));