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

Merge pull request #22 from Drakulix/refactor/egl_surface 

Decouple EGLSurface from EGLContext
This commit is contained in:
Victor Berger 2017-06-20 11:47:29 +02:00 committed by GitHub
parent 9ddce76d7f 206007f5a5
commit 3363846d84
12 changed files with 785 additions and 532 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Cargo.toml
View File

@ -17,6 +17,7 @@ winit = { git = "https://github.com/tomaka/winit.git", optional = true }
glium = { version = "~0.16.0", optional = true }
input = { version = "~0.2.0", optional = true }
clippy = { version = "*", optional = true }
rental = "0.4.11"
[build-dependencies]
gl_generator = "0.5"

11
build.rs
View File

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

7
examples/simple.rs
View File

@ -17,9 +17,10 @@ fn main() {
// Insert the ShmGlobal as a handler to your event loop
// Here, we specify tha the standard Argb8888 and Xrgb8888 is the only supported.
let handler_id =
event_loop.add_handler_with_init(ShmGlobal::new(vec![],
None /* we don't provide a logger here */));
let handler_id = event_loop.add_handler_with_init(ShmGlobal::new(
vec![],
None, /* we don't provide a logger here */
));
// 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);

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

@ -10,12 +10,14 @@ use super::GraphicsBackend;
use libloading::Library;
use nix::{c_int, c_void};
use slog;
use std::error::{self, Error};
use std::ffi::{CStr, CString};
use std::fmt;
use std::io;
use std::mem;
use std::ops::Deref;
use std::ptr;
#[allow(non_camel_case_types, dead_code)]
@ -44,16 +46,35 @@ mod ffi {
/// Native types to create an `EGLContext` from.
/// Currently supported providers are X11, Wayland and GBM.
#[derive(Clone, Copy)]
pub enum Native {
/// X11 Display and Window objects to create an `EGLContext` upon.
X11(ffi::NativeDisplayType, ffi::NativeWindowType),
/// Wayland Display and Surface objects to create an `EGLContext` upon.
Wayland(ffi::NativeDisplayType, ffi::NativeWindowType),
pub enum NativeDisplay {
/// X11 Display to create an `EGLContext` upon.
X11(ffi::NativeDisplayType),
/// Wayland Display to create an `EGLContext` upon.
Wayland(ffi::NativeDisplayType),
/// GBM Display
Gbm(ffi::NativeDisplayType, ffi::NativeWindowType),
Gbm(ffi::NativeDisplayType),
}
/// Error that can happen while creating an `EGLContext`
/// Native types to create an `EGLSurface` from.
/// Currently supported providers are X11, Wayland and GBM.
#[derive(Clone, Copy)]
pub enum NativeSurface {
/// X11 Window to create an `EGLSurface` upon.
X11(ffi::NativeWindowType),
/// Wayland Surface to create an `EGLSurface` upon.
Wayland(ffi::NativeWindowType),
/// GBM Surface
Gbm(ffi::NativeWindowType),
}
#[derive(Clone, Copy, PartialEq)]
enum NativeType {
X11,
Wayland,
Gbm,
}
/// Error that can happen while creating an `EGLContext` or `EGLSurface`
#[derive(Debug)]
pub enum CreationError {
/// I/O error from the underlying system
@ -64,6 +85,10 @@ pub enum CreationError {
OpenGlVersionNotSupported,
/// There is no pixel format available that fulfills all requirements
NoAvailablePixelFormat,
/// Surface creation from an unsupport combination
///
/// E.g creating a surface from an X11 window on a context created from a wayland display
NonMatchingSurfaceType,
/// Context creation is not supported on this system
NotSupported,
}
@ -97,6 +122,7 @@ impl error::Error for CreationError {
"Couldn't find any pixel format that matches \
the criterias."
}
CreationError::NonMatchingSurfaceType => "Surface type does not match the context type.",
CreationError::NotSupported => "Context creation is not supported on the current window system",
}
}
@ -115,8 +141,24 @@ pub struct EGLContext {
context: ffi::egl::types::EGLContext,
display: ffi::egl::types::EGLDisplay,
egl: ffi::egl::Egl,
surface: ffi::egl::types::EGLSurface,
config_id: ffi::egl::types::EGLConfig,
surface_attributes: Vec<c_int>,
pixel_format: PixelFormat,
backend_type: NativeType,
logger: slog::Logger,
}
/// EGL surface of a given egl context for rendering
pub struct EGLSurface<'a> {
context: &'a EGLContext,
surface: ffi::egl::types::EGLSurface,
}
impl<'a> Deref for EGLSurface<'a> {
type Target = EGLContext;
fn deref(&self) -> &Self::Target {
self.context
}
}
impl EGLContext {
@ -124,12 +166,13 @@ impl EGLContext {
///
/// # Unsafety
///
/// This method is marked unsafe, because the contents of `Native` cannot be verified and msy
/// contain dangeling pointers are similar unsafe content
pub unsafe fn new<L>(native: Native, mut attributes: GlAttributes, reqs: PixelFormatRequirements,
/// This method is marked unsafe, because the contents of `NativeDisplay` cannot be verified and may
/// contain dangling pointers or similar unsafe content
pub unsafe fn new<L>(native: NativeDisplay, mut attributes: GlAttributes, reqs: PixelFormatRequirements,
logger: L)
-> Result<EGLContext, CreationError>
where L: Into<Option<::slog::Logger>>
where
L: Into<Option<::slog::Logger>>,
{
let logger = logger.into();
let log = ::slog_or_stdlog(logger.clone()).new(o!("smithay_module" => "renderer_egl"));
@ -154,14 +197,18 @@ impl EGLContext {
}
}
Some((1, _)) => {
error!(log,
"OpenGLES 1.* is not supported by the EGL renderer backend");
error!(
log,
"OpenGLES 1.* is not supported by the EGL renderer backend"
);
return Err(CreationError::OpenGlVersionNotSupported);
}
Some(version) => {
error!(log,
error!(
log,
"OpenGLES {:?} is unknown and not supported by the EGL renderer backend",
version);
version
);
return Err(CreationError::OpenGlVersionNotSupported);
}
};
@ -196,51 +243,59 @@ impl EGLContext {
let has_dp_extension = |e: &str| dp_extensions.iter().any(|s| s == e);
let display = match native {
Native::X11(display, _) if has_dp_extension("EGL_KHR_platform_x11") &&
egl.GetPlatformDisplay.is_loaded() => {
NativeDisplay::X11(display)
if has_dp_extension("EGL_KHR_platform_x11") && egl.GetPlatformDisplay.is_loaded() => {
trace!(log, "EGL Display Initialization via EGL_KHR_platform_x11");
egl.GetPlatformDisplay(ffi::egl::PLATFORM_X11_KHR, display as *mut _, ptr::null())
}
Native::X11(display, _) if has_dp_extension("EGL_EXT_platform_x11") &&
egl.GetPlatformDisplayEXT.is_loaded() => {
NativeDisplay::X11(display)
if has_dp_extension("EGL_EXT_platform_x11") && egl.GetPlatformDisplayEXT.is_loaded() => {
trace!(log, "EGL Display Initialization via EGL_EXT_platform_x11");
egl.GetPlatformDisplayEXT(ffi::egl::PLATFORM_X11_EXT, display as *mut _, ptr::null())
}
Native::Gbm(display, _) if has_dp_extension("EGL_KHR_platform_gbm") &&
egl.GetPlatformDisplay.is_loaded() => {
NativeDisplay::Gbm(display)
if has_dp_extension("EGL_KHR_platform_gbm") && egl.GetPlatformDisplay.is_loaded() => {
trace!(log, "EGL Display Initialization via EGL_KHR_platform_gbm");
egl.GetPlatformDisplay(ffi::egl::PLATFORM_GBM_KHR, display as *mut _, ptr::null())
}
Native::Gbm(display, _) if has_dp_extension("EGL_MESA_platform_gbm") &&
egl.GetPlatformDisplayEXT.is_loaded() => {
NativeDisplay::Gbm(display)
if has_dp_extension("EGL_MESA_platform_gbm") && egl.GetPlatformDisplayEXT.is_loaded() => {
trace!(log, "EGL Display Initialization via EGL_MESA_platform_gbm");
egl.GetPlatformDisplayEXT(ffi::egl::PLATFORM_GBM_KHR, display as *mut _, ptr::null())
}
Native::Wayland(display, _) if has_dp_extension("EGL_KHR_platform_wayland") &&
egl.GetPlatformDisplay.is_loaded() => {
trace!(log,
"EGL Display Initialization via EGL_KHR_platform_wayland");
egl.GetPlatformDisplay(ffi::egl::PLATFORM_WAYLAND_KHR,
NativeDisplay::Wayland(display)
if has_dp_extension("EGL_KHR_platform_wayland") && egl.GetPlatformDisplay.is_loaded() => {
trace!(
log,
"EGL Display Initialization via EGL_KHR_platform_wayland"
);
egl.GetPlatformDisplay(
ffi::egl::PLATFORM_WAYLAND_KHR,
display as *mut _,
ptr::null())
ptr::null(),
)
}
Native::Wayland(display, _) if has_dp_extension("EGL_EXT_platform_wayland") &&
egl.GetPlatformDisplayEXT.is_loaded() => {
trace!(log,
"EGL Display Initialization via EGL_EXT_platform_wayland");
egl.GetPlatformDisplayEXT(ffi::egl::PLATFORM_WAYLAND_EXT,
NativeDisplay::Wayland(display)
if has_dp_extension("EGL_EXT_platform_wayland") && egl.GetPlatformDisplayEXT.is_loaded() => {
trace!(
log,
"EGL Display Initialization via EGL_EXT_platform_wayland"
);
egl.GetPlatformDisplayEXT(
ffi::egl::PLATFORM_WAYLAND_EXT,
display as *mut _,
ptr::null())
ptr::null(),
)
}
Native::X11(display, _) |
Native::Gbm(display, _) |
Native::Wayland(display, _) => {
NativeDisplay::X11(display) |
NativeDisplay::Gbm(display) |
NativeDisplay::Wayland(display) => {
trace!(log, "Default EGL Display Initialization via GetDisplay");
egl.GetDisplay(display as *mut _)
}
@ -266,7 +321,6 @@ impl EGLContext {
let p = CStr::from_ptr(egl.QueryString(display, ffi::egl::EXTENSIONS as i32));
let list = String::from_utf8(p.to_bytes().to_vec()).unwrap_or_else(|_| String::new());
list.split(' ').map(|e| e.to_string()).collect::<Vec<_>>()
} else {
vec![]
};
@ -274,8 +328,10 @@ impl EGLContext {
info!(log, "EGL Extensions: {:?}", extensions);
if egl_version >= (1, 2) && egl.BindAPI(ffi::egl::OPENGL_ES_API) == 0 {
error!(log,
"OpenGLES not supported by the underlying EGL implementation");
error!(
log,
"OpenGLES not supported by the underlying EGL implementation"
);
return Err(CreationError::OpenGlVersionNotSupported);
}
@ -298,8 +354,10 @@ impl EGLContext {
match version {
(3, _) => {
if egl_version < (1, 3) {
error!(log,
"OpenglES 3.* is not supported on EGL Versions lower then 1.3");
error!(
log,
"OpenglES 3.* is not supported on EGL Versions lower then 1.3"
);
return Err(CreationError::NoAvailablePixelFormat);
}
trace!(log, "Setting RENDERABLE_TYPE to OPENGL_ES3");
@ -311,8 +369,10 @@ impl EGLContext {
}
(2, _) => {
if egl_version < (1, 3) {
error!(log,
"OpenglES 2.* is not supported on EGL Versions lower then 1.3");
error!(
log,
"OpenglES 2.* is not supported on EGL Versions lower then 1.3"
);
return Err(CreationError::NoAvailablePixelFormat);
}
trace!(log, "Setting RENDERABLE_TYPE to OPENGL_ES2");
@ -340,14 +400,18 @@ impl EGLContext {
trace!(log, "Setting RED_SIZE to {}", color / 3);
out.push(ffi::egl::RED_SIZE as c_int);
out.push((color / 3) as c_int);
trace!(log,
trace!(
log,
"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((color / 3 + if color % 3 != 0 { 1 } else { 0 }) as c_int);
trace!(log,
trace!(
log,
"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((color / 3 + if color % 3 == 2 { 1 } else { 0 }) as c_int);
}
@ -388,12 +452,17 @@ impl EGLContext {
// calling `eglChooseConfig`
let mut config_id = mem::uninitialized();
let mut num_configs = mem::uninitialized();
if egl.ChooseConfig(display,
if egl.ChooseConfig(
display,
descriptor.as_ptr(),
&mut config_id,
1,
&mut num_configs) == 0 {
return Err(CreationError::OsError(String::from("eglChooseConfig failed")));
&mut num_configs,
) == 0
{
return Err(CreationError::OsError(
String::from("eglChooseConfig failed"),
));
}
if num_configs == 0 {
error!(log, "No matching color format found");
@ -468,8 +537,10 @@ impl EGLContext {
if context.is_null() {
match egl.GetError() as u32 {
ffi::egl::BAD_ATTRIBUTE => {
error!(log,
"Context creation failed as one or more requirements could not be met. Try removing some gl attributes or pixel format requirements");
error!(
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);
}
e => panic!("eglCreateContext failed: 0x{:x}", e),
@ -478,7 +549,7 @@ impl EGLContext {
debug!(log, "EGL context successfully created");
let surface_attributes = {
let mut out: Vec<c_int> = Vec::with_capacity(2);
let mut out: Vec<c_int> = Vec::with_capacity(3);
match reqs.double_buffer {
Some(true) => {
@ -494,52 +565,69 @@ impl EGLContext {
None => {}
}
out.push(ffi::egl::NONE as i32);
out
};
trace!(log, "Creating EGL window surface...");
let surface = {
let surface = match native {
Native::X11(_, window) |
Native::Wayland(_, window) |
Native::Gbm(_, window) => {
egl.CreateWindowSurface(display, config_id, window, surface_attributes.as_ptr())
}
};
if surface.is_null() {
return Err(CreationError::OsError(String::from("eglCreateWindowSurface failed")));
}
surface
};
debug!(log, "EGL window surface successfully created");
info!(log, "EGL context created");
Ok(EGLContext {
_lib: lib,
context: context as *const _,
display: display as *const _,
egl: egl,
surface: surface as *const _,
config_id: config_id,
surface_attributes: surface_attributes,
pixel_format: desc,
backend_type: match native {
NativeDisplay::X11(_) => NativeType::X11,
NativeDisplay::Wayland(_) => NativeType::Wayland,
NativeDisplay::Gbm(_) => NativeType::Gbm,
},
logger: log,
})
}
/// Swaps buffers at the end of a frame.
pub fn swap_buffers(&self) -> Result<(), SwapBuffersError> {
let ret = unsafe {
self.egl
.SwapBuffers(self.display as *const _, self.surface as *const _)
/// Creates a surface bound to the given egl context for rendering
///
/// # Unsafety
///
/// This method is marked unsafe, because the contents of `NativeSurface` cannot be verified and may
/// contain dangling pointers or similar unsafe content
pub unsafe fn create_surface<'a>(&'a self, native: NativeSurface)
-> Result<EGLSurface<'a>, CreationError> {
trace!(self.logger, "Creating EGL window surface...");
let surface = {
let surface = match (native, self.backend_type) {
(NativeSurface::X11(window), NativeType::X11) |
(NativeSurface::Wayland(window), NativeType::Wayland) |
(NativeSurface::Gbm(window), NativeType::Gbm) => {
self.egl.CreateWindowSurface(
self.display,
self.config_id,
window,
self.surface_attributes.as_ptr(),
)
}
_ => return Err(CreationError::NonMatchingSurfaceType),
};
if ret == 0 {
match unsafe { self.egl.GetError() } as u32 {
ffi::egl::CONTEXT_LOST => Err(SwapBuffersError::ContextLost),
err => panic!("eglSwapBuffers failed (eglGetError returned 0x{:x})", err),
}
} else {
Ok(())
if surface.is_null() {
return Err(CreationError::OsError(
String::from("eglCreateWindowSurface failed"),
));
}
surface
};
debug!(self.logger, "EGL window surface successfully created");
Ok(EGLSurface {
context: &self,
surface: surface,
})
}
/// Returns the address of an OpenGL function.
@ -556,6 +644,32 @@ impl EGLContext {
unsafe { self.egl.GetCurrentContext() == self.context as *const _ }
}
/// Returns the pixel format of the main framebuffer of the context.
pub fn get_pixel_format(&self) -> PixelFormat {
self.pixel_format
}
}
impl<'a> EGLSurface<'a> {
/// Swaps buffers at the end of a frame.
pub fn swap_buffers(&self) -> Result<(), SwapBuffersError> {
let ret = unsafe {
self.context.egl.SwapBuffers(
self.context.display as *const _,
self.surface as *const _,
)
};
if ret == 0 {
match unsafe { self.context.egl.GetError() } as u32 {
ffi::egl::CONTEXT_LOST => Err(SwapBuffersError::ContextLost),
err => panic!("eglSwapBuffers failed (eglGetError returned 0x{:x})", err),
}
} else {
Ok(())
}
}
/// Makes the OpenGL context the current context in the current thread.
///
/// # Unsafety
@ -563,14 +677,15 @@ impl EGLContext {
/// This function is marked unsafe, because the context cannot be made current
/// on multiple threads.
pub unsafe fn make_current(&self) -> Result<(), SwapBuffersError> {
let ret = self.egl
.MakeCurrent(self.display as *const _,
let ret = self.context.egl.MakeCurrent(
self.context.display as *const _,
self.surface as *const _,
self.surface as *const _,
self.context as *const _);
self.context.context as *const _,
);
if ret == 0 {
match self.egl.GetError() as u32 {
match self.context.egl.GetError() as u32 {
ffi::egl::CONTEXT_LOST => Err(SwapBuffersError::ContextLost),
err => panic!("eglMakeCurrent failed (eglGetError returned 0x{:x})", err),
}
@ -578,30 +693,38 @@ impl EGLContext {
Ok(())
}
}
/// Returns the pixel format of the main framebuffer of the context.
pub fn get_pixel_format(&self) -> PixelFormat {
self.pixel_format
}
}
unsafe impl Send for EGLContext {}
unsafe impl Sync for EGLContext {}
unsafe impl<'a> Send for EGLSurface<'a> {}
unsafe impl<'a> Sync for EGLSurface<'a> {}
impl Drop for EGLContext {
fn drop(&mut self) {
unsafe {
// we don't call MakeCurrent(0, 0) because we are not sure that the context
// is still the current one
self.egl
.DestroyContext(self.display as *const _, self.context as *const _);
self.egl
.DestroySurface(self.display as *const _, self.surface as *const _);
self.egl.DestroyContext(
self.display as *const _,
self.context as *const _,
);
self.egl.Terminate(self.display as *const _);
}
}
}
impl<'a> Drop for EGLSurface<'a> {
fn drop(&mut self) {
unsafe {
self.context.egl.DestroySurface(
self.context.display as *const _,
self.surface as *const _,
);
}
}
}
/// Error that can happen when swapping buffers.
#[derive(Debug, Clone)]
pub enum SwapBuffersError {

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.
#[inline]
pub fn draw(&self) -> Frame {
Frame::new(self.context.clone(),
self.backend.get_framebuffer_dimensions())
Frame::new(
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 {
fn hash<H>(&self, state: &mut H)
where H: ::std::hash::Hasher
where
H: ::std::hash::Hasher,
{
self.id.hash(state);
}
@ -275,7 +276,10 @@ pub trait PointerMotionAbsoluteEvent: Event {
/// Device position converted to the targets coordinate space.
/// E.g. the focused output's resolution.
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.
@ -336,7 +340,10 @@ pub trait TouchDownEvent: Event {
/// Touch position converted into the target coordinate space.
/// E.g. the focused output's resolution.
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
@ -395,7 +402,10 @@ pub trait TouchMotionEvent: Event {
/// Touch position converted into the target coordinate space.
/// E.g. the focused output's resolution.
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

85
src/backend/libinput.rs
View File

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

223
src/backend/winit.rs
View File

@ -2,8 +2,8 @@
use backend::{SeatInternal, TouchSlotInternal};
use backend::graphics::GraphicsBackend;
use backend::graphics::egl::{CreationError, EGLContext, EGLGraphicsBackend, GlAttributes, Native,
PixelFormat, PixelFormatRequirements, SwapBuffersError};
use backend::graphics::egl::{CreationError, EGLContext, EGLGraphicsBackend, GlAttributes, NativeDisplay,
NativeSurface, PixelFormat, PixelFormatRequirements, SwapBuffersError};
use backend::input::{Axis, AxisSource, Event as BackendEvent, InputBackend, InputHandler, KeyState,
KeyboardKeyEvent, MouseButton, MouseButtonState, PointerAxisEvent, PointerButtonEvent,
PointerMotionAbsoluteEvent, Seat, SeatCapabilities, TouchCancelEvent, TouchDownEvent,
@ -20,11 +20,25 @@ use winit::{CreationError as WinitCreationError, ElementState, Event, EventsLoop
WindowBuilder, WindowEvent};
use winit::os::unix::{WindowExt, get_x11_xconnection};
rental! {
mod egl {
use std::boxed::Box;
use ::backend::graphics::egl::{EGLContext, EGLSurface};
#[rental(deref_suffix)]
pub struct RentEGL {
context: Box<EGLContext>,
surface: EGLSurface<'context>,
}
}
}
/// Window with an active EGL Context created by `winit`. Implements the
/// `EGLGraphicsBackend` graphics backend trait
pub struct WinitGraphicsBackend {
window: Rc<Window>,
context: EGLContext,
context: egl::RentEGL,
logger: ::slog::Logger,
}
@ -47,13 +61,16 @@ pub struct WinitInputBackend {
/// graphics backend trait and a corresponding `WinitInputBackend`, which implements
/// the `InputBackend` trait
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_title("Smithay")
.with_visibility(true),
logger)
logger,
)
}
/// Create a new `WinitGraphicsBackend`, which implements the `EGLGraphicsBackend`
@ -61,26 +78,30 @@ pub fn init<L>(logger: L) -> Result<(WinitGraphicsBackend, WinitInputBackend), C
/// `WinitInputBackend`, which implements the `InputBackend` trait
pub fn init_from_builder<L>(builder: WindowBuilder, logger: L)
-> 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 {
version: None,
profile: None,
debug: cfg!(debug_assertions),
vsync: true,
},
logger)
logger,
)
}
/// Create a new `WinitGraphicsBackend`, which implements the `EGLGraphicsBackend`
/// 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<L>
(builder: WindowBuilder, attributes: GlAttributes, logger: L)
pub fn init_from_builder_with_gl_attr<L>(
builder: WindowBuilder, attributes: GlAttributes, logger: L)
-> 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"));
info!(log, "Initializing a winit backend");
@ -89,23 +110,36 @@ pub fn init_from_builder_with_gl_attr<L>
let window = Rc::new(builder.build(&events_loop)?);
debug!(log, "Window created");
let (native, surface) = if let (Some(conn), Some(window)) =
(get_x11_xconnection(), window.get_xlib_window()) {
let (native_display, native_surface, surface) =
if let (Some(conn), Some(window)) = (get_x11_xconnection(), window.get_xlib_window()) {
debug!(log, "Window is backed by X11");
(Native::X11(conn.display as *const _, window), None)
(
NativeDisplay::X11(conn.display as *const _),
NativeSurface::X11(window),
None,
)
} 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");
let (w, h) = window.get_inner_size().unwrap();
let egl_surface = wegl::WlEglSurface::new(surface, w as i32, h as i32);
(Native::Wayland(display, egl_surface.ptr() as *const _), Some(egl_surface))
(
NativeDisplay::Wayland(display),
NativeSurface::Wayland(egl_surface.ptr() as *const _),
Some(egl_surface),
)
} else {
error!(log, "Window is backed by an unsupported graphics framework");
return Err(CreationError::NotSupported);
};
let context = unsafe {
match EGLContext::new(native,
match EGLContext::new(
native_display,
attributes,
PixelFormatRequirements {
hardware_accelerated: Some(true),
@ -113,7 +147,8 @@ pub fn init_from_builder_with_gl_attr<L>
alpha_bits: Some(8),
..Default::default()
},
log.clone()) {
log.clone(),
) {
Ok(context) => context,
Err(err) => {
error!(log, "EGLContext creation failed:\n {}", err);
@ -122,9 +157,15 @@ pub fn init_from_builder_with_gl_attr<L>
}
};
Ok((WinitGraphicsBackend {
Ok((
WinitGraphicsBackend {
window: window.clone(),
context: context,
context: match egl::RentEGL::try_new(Box::new(context), move |context| unsafe {
context.create_surface(native_surface)
}) {
Ok(x) => x,
Err(::rental::TryNewError(err, _)) => return Err(err),
},
logger: log.new(o!("smithay_winit_component" => "graphics")),
},
WinitInputBackend {
@ -133,16 +174,19 @@ pub fn init_from_builder_with_gl_attr<L>
surface: surface,
time_counter: 0,
key_counter: 0,
seat: Seat::new(0,
seat: Seat::new(
0,
SeatCapabilities {
pointer: true,
keyboard: true,
touch: true,
}),
},
),
input_config: (),
handler: None,
logger: log.new(o!("smithay_winit_component" => "input")),
}))
},
))
}
impl GraphicsBackend for WinitGraphicsBackend {
@ -163,7 +207,7 @@ impl GraphicsBackend for WinitGraphicsBackend {
impl EGLGraphicsBackend for WinitGraphicsBackend {
fn swap_buffers(&self) -> Result<(), SwapBuffersError> {
trace!(self.logger, "Swapping buffers");
self.context.swap_buffers()
self.context.rent(|surface| surface.swap_buffers())
}
unsafe fn get_proc_address(&self, symbol: &str) -> *const c_void {
@ -172,9 +216,9 @@ impl EGLGraphicsBackend for WinitGraphicsBackend {
}
fn get_framebuffer_dimensions(&self) -> (u32, u32) {
self.window
.get_inner_size_pixels()
.expect("Window does not exist anymore")
self.window.get_inner_size_pixels().expect(
"Window does not exist anymore",
)
}
fn is_current(&self) -> bool {
@ -183,7 +227,7 @@ impl EGLGraphicsBackend for WinitGraphicsBackend {
unsafe fn make_current(&self) -> Result<(), SwapBuffersError> {
debug!(self.logger, "Setting EGL context to be the current context");
self.context.make_current()
self.context.rent(|surface| surface.make_current())
}
fn get_pixel_format(&self) -> PixelFormat {
@ -267,16 +311,17 @@ impl PointerMotionAbsoluteEvent for WinitMouseMovedEvent {
}
fn x_transformed(&self, width: u32) -> u32 {
cmp::min((self.x * width as f64 /
self.window.get_inner_size_points().unwrap_or((width, 0)).0 as f64) as u32,
0)
cmp::min(
(self.x * width as f64 / self.window.get_inner_size_points().unwrap_or((width, 0)).0 as f64) as u32,
0,
)
}
fn y_transformed(&self, height: u32) -> u32 {
cmp::min((self.y * height as f64 /
self.window.get_inner_size_points().unwrap_or((0, height)).1 as f64) as
u32,
0)
cmp::min(
(self.y * height as f64 / self.window.get_inner_size_points().unwrap_or((0, height)).1 as f64) as u32,
0,
)
}
}
@ -369,15 +414,19 @@ impl TouchDownEvent for WinitTouchStartedEvent {
}
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,
0) as u32
0,
) as 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,
0) as u32
0,
) as u32
}
}
@ -482,16 +531,18 @@ impl InputBackend for WinitInputBackend {
}
fn get_handler(&mut self) -> Option<&mut InputHandler<Self>> {
self.handler
.as_mut()
.map(|handler| handler as &mut InputHandler<Self>)
self.handler.as_mut().map(|handler| {
handler as &mut InputHandler<Self>
})
}
fn clear_handler(&mut self) {
if let Some(mut handler) = self.handler.take() {
trace!(self.logger,
trace!(
self.logger,
"Calling on_seat_destroyed with {:?}",
self.seat);
self.seat
);
handler.on_seat_destroyed(&self.seat);
}
info!(self.logger, "Removing input handler");
@ -531,8 +582,7 @@ impl InputBackend for WinitInputBackend {
let mut handler = self.handler.as_mut();
let logger = &self.logger;
self.events_loop
.poll_events(move |event| match event {
self.events_loop.poll_events(move |event| match event {
Event::WindowEvent { event, .. } => {
match (event, handler.as_mut()) {
(WindowEvent::Resized(x, y), _) => {
@ -552,29 +602,32 @@ impl InputBackend for WinitInputBackend {
*key_counter = key_counter.checked_sub(1).unwrap_or(0)
}
};
trace!(logger,
trace!(
logger,
"Calling on_keyboard_key with {:?}",
(scancode, state));
handler.on_keyboard_key(seat,
(scancode, state)
);
handler.on_keyboard_key(
seat,
WinitKeyboardInputEvent {
time: *time_counter,
key: scancode,
count: *key_counter,
state: state,
})
},
)
}
(WindowEvent::MouseMoved { position: (x, y), .. },
Some(handler)) => {
trace!(logger,
"Calling on_pointer_move_absolute with {:?}",
(x, y));
handler.on_pointer_move_absolute(seat,
(WindowEvent::MouseMoved { position: (x, y), .. }, Some(handler)) => {
trace!(logger, "Calling on_pointer_move_absolute with {:?}", (x, y));
handler.on_pointer_move_absolute(
seat,
WinitMouseMovedEvent {
window: window.clone(),
time: *time_counter,
x: x,
y: y,
})
},
)
}
(WindowEvent::MouseWheel { delta, .. }, Some(handler)) => {
match delta {
@ -586,9 +639,11 @@ impl InputBackend for WinitInputBackend {
time: *time_counter,
delta: delta,
};
trace!(logger,
trace!(
logger,
"Calling on_pointer_axis for Axis::Horizontal with {:?}",
x);
x
);
handler.on_pointer_axis(seat, event);
}
if y != 0.0 {
@ -597,24 +652,30 @@ impl InputBackend for WinitInputBackend {
time: *time_counter,
delta: delta,
};
trace!(logger,
trace!(
logger,
"Calling on_pointer_axis for Axis::Vertical with {:?}",
y);
y
);
handler.on_pointer_axis(seat, event);
}
}
}
}
(WindowEvent::MouseInput { state, button, .. }, Some(handler)) => {
trace!(logger,
trace!(
logger,
"Calling on_pointer_button with {:?}",
(button, state));
handler.on_pointer_button(seat,
(button, state)
);
handler.on_pointer_button(
seat,
WinitMouseInputEvent {
time: *time_counter,
button: button,
state: state,
})
},
)
}
(WindowEvent::Touch(Touch {
phase: TouchPhase::Started,
@ -624,13 +685,15 @@ impl InputBackend for WinitInputBackend {
}),
Some(handler)) => {
trace!(logger, "Calling on_touch_down at {:?}", (x, y));
handler.on_touch_down(seat,
handler.on_touch_down(
seat,
WinitTouchStartedEvent {
window: window.clone(),
time: *time_counter,
location: (x, y),
id: id,
})
},
)
}
(WindowEvent::Touch(Touch {
phase: TouchPhase::Moved,
@ -640,13 +703,15 @@ impl InputBackend for WinitInputBackend {
}),
Some(handler)) => {
trace!(logger, "Calling on_touch_motion at {:?}", (x, y));
handler.on_touch_motion(seat,
handler.on_touch_motion(
seat,
WinitTouchMovedEvent {
window: window.clone(),
time: *time_counter,
location: (x, y),
id: id,
})
},
)
}
(WindowEvent::Touch(Touch {
phase: TouchPhase::Ended,
@ -656,19 +721,23 @@ impl InputBackend for WinitInputBackend {
}),
Some(handler)) => {
trace!(logger, "Calling on_touch_motion at {:?}", (x, y));
handler.on_touch_motion(seat,
handler.on_touch_motion(
seat,
WinitTouchMovedEvent {
window: window.clone(),
time: *time_counter,
location: (x, y),
id: id,
});
},
);
trace!(logger, "Calling on_touch_up");
handler.on_touch_up(seat,
handler.on_touch_up(
seat,
WinitTouchEndedEvent {
time: *time_counter,
id: id,
});
},
);
}
(WindowEvent::Touch(Touch {
phase: TouchPhase::Cancelled,
@ -677,11 +746,13 @@ impl InputBackend for WinitInputBackend {
}),
Some(handler)) => {
trace!(logger, "Calling on_touch_cancel");
handler.on_touch_cancel(seat,
handler.on_touch_cancel(
seat,
WinitTouchCancelledEvent {
time: *time_counter,
id: id,
})
},
)
}
(WindowEvent::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
/// (like caps lock).
#[derive(Copy,Clone,Debug)]
#[derive(Copy, Clone, Debug)]
pub struct ModifiersState {
/// The "control" key
pub ctrl: bool,
@ -95,14 +95,15 @@ impl KbdInternal {
// FIXME: This is an issue with the xkbcommon-rs crate that does not reflect this
// non-threadsafety properly.
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,
&model,
&layout,
&variant,
options,
xkb::KEYMAP_COMPILE_NO_FLAGS)
.ok_or(())?;
xkb::KEYMAP_COMPILE_NO_FLAGS,
).ok_or(())?;
let state = xkb::State::new(&keymap);
Ok(KbdInternal {
focus: None,
@ -148,8 +149,10 @@ impl KbdInternal {
fn serialize_pressed_keys(&self) -> Vec<u8> {
let serialized = unsafe {
::std::slice::from_raw_parts(self.pressed_keys.as_ptr() as *const u8,
self.pressed_keys.len() * 4)
::std::slice::from_raw_parts(
self.pressed_keys.as_ptr() as *const u8,
self.pressed_keys.len() * 4,
)
};
serialized.into()
}
@ -167,7 +170,8 @@ pub enum Error {
pub fn create_keyboard_handler<L>(rules: &str, model: &str, layout: &str, variant: &str,
options: Option<String>, logger: L)
-> 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"));
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
let mut keymap_file = tempfile().map_err(Error::IoError)?;
let keymap_data = internal.keymap.get_as_string(xkb::KEYMAP_FORMAT_TEXT_V1);
keymap_file
.write_all(keymap_data.as_bytes())
.map_err(Error::IoError)?;
keymap_file.write_all(keymap_data.as_bytes()).map_err(
Error::IoError,
)?;
keymap_file.flush().map_err(Error::IoError)?;
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
/// 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)
where F: FnOnce(&ModifiersState, Keysym) -> bool
where
F: FnOnce(&ModifiersState, Keysym) -> bool,
{
trace!(self.arc.logger, "Handling keystroke"; "keycode" => keycode, "state" => format_args!("{:?}", state));
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.
pub fn send_keymap(&self, kbd: &wl_keyboard::WlKeyboard) {
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_len);
self.arc.keymap_len,
);
}
}

11
src/lib.rs
View File

@ -13,6 +13,8 @@ extern crate wayland_server;
extern crate nix;
extern crate xkbcommon;
extern crate tempfile;
#[macro_use]
extern crate rental;
#[cfg(feature = "backend_winit")]
extern crate winit;
@ -35,10 +37,11 @@ pub mod backend;
pub mod keyboard;
fn slog_or_stdlog<L>(logger: L) -> ::slog::Logger
where L: Into<Option<::slog::Logger>>
where
L: Into<Option<::slog::Logger>>,
{
use slog::Drain;
logger
.into()
.unwrap_or_else(|| ::slog::Logger::root(::slog_stdlog::StdLog.fuse(), o!()))
logger.into().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 additionnaly advertized.
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);
@ -147,7 +148,8 @@ impl ShmGlobalToken {
/// 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).
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) {
return Err(BufferAccessError::NotManaged);
@ -156,7 +158,8 @@ impl ShmGlobalToken {
if data.pool
.with_data_slice(|slice| f(slice, data.data))
.is_err() {
.is_err()
{
// SIGBUS error occured
buffer.post_error(wl_shm::Error::InvalidFd as u32, "Bad pool size.".into());
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,
pool: wl_shm_pool::WlShmPool, fd: RawFd, size: i32) {
if size <= 0 {
shm.post_error(wl_shm::Error::InvalidFd as u32,
"Invalid size for a new wl_shm_pool.".into());
shm.post_error(
wl_shm::Error::InvalidFd as u32,
"Invalid size for a new wl_shm_pool.".into(),
);
return;
}
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);
/// Details of the contents of a buffer relative to its pool
#[derive(Copy,Clone,Debug)]
#[derive(Copy, Clone, Debug)]
pub struct BufferData {
/// Offset of the start of the buffer relative to the beginning of the pool in bytes
pub offset: i32,
@ -280,8 +285,10 @@ impl wl_shm_pool::Handler for ShmHandler {
match arc_pool.resize(size) {
Ok(()) => {}
Err(ResizeError::InvalidSize) => {
pool.post_error(wl_shm::Error::InvalidFd as u32,
"Invalid new size for a wl_shm_pool.".into());
pool.post_error(
wl_shm::Error::InvalidFd as u32,
"Invalid new size for a wl_shm_pool.".into(),
);
}
Err(ResizeError::MremapFailed) => {
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?
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,
mman::PROT_READ,
mman::MAP_SHARED,
fd,
0);
0,
);
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<(), ()> {
let ret = mman::mmap(ptr as *mut _,
let ret = mman::mmap(
ptr as *mut _,
size,
mman::PROT_READ,
mman::MAP_ANONYMOUS | mman::MAP_PRIVATE | mman::MAP_FIXED,
-1,
0);
0,
);
ret.map(|_| ()).map_err(|_| ())
}
unsafe fn place_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::SigSet::empty());
signal::SigSet::empty(),
);
match signal::sigaction(Signal::SIGBUS, &action) {
Ok(old_signal) => {
OLD_SIGBUS_HANDLER = Box::into_raw(Box::new(old_signal));