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

cargo fmt

This commit is contained in:
Victor Berger 2018-09-25 00:32:09 +02:00
parent 605895e30f
commit 454f874284
29 changed files with 394 additions and 609 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
anvil/src/glium_drawer.rs
View File

@ -2,10 +2,11 @@ use glium;
use glium::index::PrimitiveType;
use glium::texture::{MipmapsOption, Texture2d, UncompressedFloatFormat};
use glium::{Frame, GlObject, Surface};
use smithay::backend::graphics::egl::EGLGraphicsBackend;
use smithay::backend::graphics::egl::error::Result as EGLResult;
use smithay::backend::graphics::egl::wayland::{BufferAccessError, EGLDisplay, EGLImages,
EGLWaylandExtensions, Format};
use smithay::backend::graphics::egl::wayland::{
BufferAccessError, EGLDisplay, EGLImages, EGLWaylandExtensions, Format,
};
use smithay::backend::graphics::egl::EGLGraphicsBackend;
use smithay::backend::graphics::glium::GliumGraphicsBackend;
use smithay::wayland::compositor::roles::Role;
use smithay::wayland::compositor::{SubsurfaceRole, TraversalAction};
@ -199,8 +200,7 @@ impl<F: EGLGraphicsBackend + 'static> GliumDrawer<F> {
blend: blending,
..Default::default()
},
)
.unwrap();
).unwrap();
}
#[inline]
@ -282,8 +282,7 @@ impl<F: EGLGraphicsBackend + 'static> GliumDrawer<F> {
TraversalAction::SkipChildren
}
},
)
.unwrap();
).unwrap();
}
});
}

46
anvil/src/input_handler.rs
View File

@ -1,16 +1,17 @@
use std::cell::RefCell;
use std::process::Command;
use std::rc::Rc;
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::Arc;
use slog::Logger;
use smithay::backend::input::{
self, Event, InputBackend, InputHandler, KeyState, KeyboardKeyEvent, PointerAxisEvent,
PointerButtonEvent, PointerMotionAbsoluteEvent, PointerMotionEvent,
};
#[cfg(feature = "udev")]
use smithay::backend::session::auto::AutoSession;
use smithay::backend::input::{self, Event, InputBackend, InputHandler, KeyState, KeyboardKeyEvent,
PointerAxisEvent, PointerButtonEvent, PointerMotionAbsoluteEvent,
PointerMotionEvent};
use smithay::wayland::seat::{keysyms as xkb, KeyboardHandle, Keysym, ModifiersState, PointerHandle};
use smithay::wayland_server::protocol::wl_pointer;
@ -160,7 +161,8 @@ impl<B: InputBackend> InputHandler<B> for AnvilInputHandler {
// this event is never generated by winit so self.screen_size is relevant
location.0 = (location.0).max(0.0).min(self.screen_size.0 as f64);
location.1 = (location.1).max(0.0).min(self.screen_size.1 as f64);
let under = self.window_map
let under = self
.window_map
.borrow()
.get_surface_under((location.0, location.1));
self.pointer.motion(
@ -191,9 +193,7 @@ impl<B: InputBackend> InputHandler<B> for AnvilInputHandler {
};
*self.pointer_location.borrow_mut() = (x, y);
let serial = self.next_serial();
let under = self.window_map
.borrow()
.get_surface_under((x as f64, y as f64));
let under = self.window_map.borrow().get_surface_under((x as f64, y as f64));
self.pointer.motion(
under.as_ref().map(|&(ref s, (x, y))| (s, x, y)),
serial,
@ -212,7 +212,8 @@ impl<B: InputBackend> InputHandler<B> for AnvilInputHandler {
let state = match evt.state() {
input::MouseButtonState::Pressed => {
// change the keyboard focus
let under = self.window_map
let under = self
.window_map
.borrow_mut()
.get_surface_and_bring_to_top(*self.pointer_location.borrow());
self.keyboard
@ -230,9 +231,11 @@ impl<B: InputBackend> InputHandler<B> for AnvilInputHandler {
input::AxisSource::Finger => wl_pointer::AxisSource::Finger,
input::AxisSource::Wheel | input::AxisSource::WheelTilt => wl_pointer::AxisSource::Wheel,
};
let horizontal_amount = evt.amount(&input::Axis::Horizontal)
let horizontal_amount = evt
.amount(&input::Axis::Horizontal)
.unwrap_or_else(|| evt.amount_discrete(&input::Axis::Horizontal).unwrap() * 3.0);
let vertical_amount = evt.amount(&input::Axis::Vertical)
let vertical_amount = evt
.amount(&input::Axis::Vertical)
.unwrap_or_else(|| evt.amount_discrete(&input::Axis::Vertical).unwrap() * 3.0);
let horizontal_amount_discrete = evt.amount_discrete(&input::Axis::Horizontal);
let vertical_amount_discrete = evt.amount_discrete(&input::Axis::Vertical);
@ -241,11 +244,7 @@ impl<B: InputBackend> InputHandler<B> for AnvilInputHandler {
let mut event = self.pointer.axis();
event.source(source);
if horizontal_amount != 0.0 {
event.value(
wl_pointer::Axis::HorizontalScroll,
horizontal_amount,
evt.time(),
);
event.value(wl_pointer::Axis::HorizontalScroll, horizontal_amount, evt.time());
if let Some(discrete) = horizontal_amount_discrete {
event.discrete(wl_pointer::Axis::HorizontalScroll, discrete as i32);
}
@ -253,11 +252,7 @@ impl<B: InputBackend> InputHandler<B> for AnvilInputHandler {
event.stop(wl_pointer::Axis::HorizontalScroll, evt.time());
}
if vertical_amount != 0.0 {
event.value(
wl_pointer::Axis::VerticalScroll,
vertical_amount,
evt.time(),
);
event.value(wl_pointer::Axis::VerticalScroll, vertical_amount, evt.time());
if let Some(discrete) = vertical_amount_discrete {
event.discrete(wl_pointer::Axis::VerticalScroll, discrete as i32);
}
@ -304,10 +299,11 @@ enum KeyAction {
fn process_keyboard_shortcut(modifiers: &ModifiersState, keysym: Keysym) -> KeyAction {
if modifiers.ctrl && modifiers.alt && keysym == xkb::KEY_BackSpace
|| modifiers.logo && keysym == xkb::KEY_q {
// ctrl+alt+backspace = quit
// logo + q = quit
KeyAction::Quit
|| modifiers.logo && keysym == xkb::KEY_q
{
// ctrl+alt+backspace = quit
// logo + q = quit
KeyAction::Quit
} else if keysym >= xkb::KEY_XF86Switch_VT_1 && keysym <= xkb::KEY_XF86Switch_VT_12 {
// VTSwicth
KeyAction::VtSwitch((keysym - xkb::KEY_XF86Switch_VT_1 + 1) as i32)

2
anvil/src/main.rs
View File

@ -10,8 +10,8 @@ extern crate smithay;
extern crate xkbcommon;
use slog::Drain;
use smithay::wayland_server::Display;
use smithay::wayland_server::calloop::EventLoop;
use smithay::wayland_server::Display;
#[macro_use]
mod shaders;

29
anvil/src/raw_drm.rs
View File

@ -5,18 +5,18 @@ use std::os::unix::io::RawFd;
use std::rc::Rc;
use std::time::Duration;
use smithay::drm::Device as BasicDevice;
use smithay::drm::control::{Device as ControlDevice, ResourceInfo};
use smithay::backend::drm::{drm_device_bind, DrmBackend, DrmDevice, DrmHandler};
use smithay::backend::graphics::egl::wayland::EGLWaylandExtensions;
use smithay::drm::control::connector::{Info as ConnectorInfo, State as ConnectorState};
use smithay::drm::control::crtc;
use smithay::drm::control::encoder::Info as EncoderInfo;
use smithay::drm::control::{Device as ControlDevice, ResourceInfo};
use smithay::drm::result::Error as DrmError;
use smithay::backend::drm::{drm_device_bind, DrmBackend, DrmDevice, DrmHandler};
use smithay::backend::graphics::egl::wayland::EGLWaylandExtensions;
use smithay::drm::Device as BasicDevice;
use smithay::wayland::compositor::CompositorToken;
use smithay::wayland::shm::init_shm_global;
use smithay::wayland_server::Display;
use smithay::wayland_server::calloop::EventLoop;
use smithay::wayland_server::Display;
use glium::Surface;
use slog::Logger;
@ -44,10 +44,8 @@ pub fn run_raw_drm(mut display: Display, mut event_loop: EventLoop<()>, log: Log
let mut options = OpenOptions::new();
options.read(true);
options.write(true);
let mut device = DrmDevice::new(
Card(options.clone().open("/dev/dri/card0").unwrap()),
log.clone(),
).unwrap();
let mut device =
DrmDevice::new(Card(options.clone().open("/dev/dri/card0").unwrap()), log.clone()).unwrap();
// Get a set of all modesetting resource handles (excluding planes):
let res_handles = device.resource_handles().unwrap();
@ -124,10 +122,12 @@ pub fn run_raw_drm(mut display: Display, mut event_loop: EventLoop<()>, log: Log
logger: log,
},
).map_err(|(err, _)| err)
.unwrap();
.unwrap();
loop {
event_loop.dispatch(Some(::std::time::Duration::from_millis(16)), &mut ()).unwrap();
event_loop
.dispatch(Some(::std::time::Duration::from_millis(16)), &mut ())
.unwrap();
display.flush_clients();
window_map.borrow_mut().refresh();
@ -149,11 +149,8 @@ impl DrmHandler<Card> for DrmHandlerImpl {
_frame: u32,
_duration: Duration,
) {
self.drawer.draw_windows(
&*self.window_map.borrow(),
self.compositor_token,
&self.logger,
);
self.drawer
.draw_windows(&*self.window_map.borrow(), self.compositor_token, &self.logger);
}
fn error(&mut self, _device: &mut DrmDevice<Card>, error: DrmError) {

19
anvil/src/shell.rs
View File

@ -5,10 +5,13 @@ use std::sync::{Arc, Mutex};
use rand;
use smithay::wayland::compositor::{compositor_init, CompositorToken, SurfaceAttributes, SurfaceEvent};
use smithay::wayland::shell::legacy::{wl_shell_init, ShellRequest, ShellState as WlShellState,
ShellSurfaceKind, ShellSurfaceRole};
use smithay::wayland::shell::xdg::{xdg_shell_init, PopupConfigure, ShellState as XdgShellState,
ToplevelConfigure, XdgRequest, XdgSurfaceRole};
use smithay::wayland::shell::legacy::{
wl_shell_init, ShellRequest, ShellState as WlShellState, ShellSurfaceKind, ShellSurfaceRole,
};
use smithay::wayland::shell::xdg::{
xdg_shell_init, PopupConfigure, ShellState as XdgShellState, ToplevelConfigure, XdgRequest,
XdgSurfaceRole,
};
use smithay::wayland_server::protocol::{wl_buffer, wl_callback, wl_shell_surface, wl_surface};
use smithay::wayland_server::{Display, Resource};
@ -85,11 +88,12 @@ pub fn init_shell(
let (wl_shell_state, _) = wl_shell_init(
display,
compositor_token,
move |req: ShellRequest<_, _, ()>|
move |req: ShellRequest<_, _, ()>| {
if let ShellRequest::SetKind {
surface,
kind: ShellSurfaceKind::Toplevel,
} = req {
} = req
{
// place the window at a random location in the [0;300]x[0;300] square
use rand::distributions::{IndependentSample, Range};
let range = Range::new(0, 300);
@ -100,7 +104,8 @@ pub fn init_shell(
shell_window_map
.borrow_mut()
.insert(SurfaceKind::Wl(surface), (x, y));
},
}
},
log.clone(),
);

70
anvil/src/udev.rs
View File

@ -3,8 +3,8 @@ use std::collections::HashMap;
use std::io::Error as IoError;
use std::path::PathBuf;
use std::rc::Rc;
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::Arc;
use std::time::Duration;
use glium::Surface;
@ -13,31 +13,31 @@ use smithay::image::{ImageBuffer, Rgba};
use slog::Logger;
use smithay::drm::control::{Device as ControlDevice, ResourceInfo};
use smithay::backend::drm::{DevPath, DrmBackend, DrmDevice, DrmHandler};
use smithay::backend::graphics::egl::wayland::{EGLDisplay, EGLWaylandExtensions};
use smithay::backend::graphics::GraphicsBackend;
use smithay::backend::input::InputBackend;
use smithay::backend::libinput::{libinput_bind, LibinputInputBackend, LibinputSessionInterface};
use smithay::backend::session::auto::{auto_session_bind, AutoSession};
use smithay::backend::session::{Session, SessionNotifier};
use smithay::backend::udev::{primary_gpu, udev_backend_bind, SessionFdDrmDevice, UdevBackend, UdevHandler};
use smithay::drm::control::connector::{Info as ConnectorInfo, State as ConnectorState};
use smithay::drm::control::crtc;
use smithay::drm::control::encoder::Info as EncoderInfo;
use smithay::drm::control::{Device as ControlDevice, ResourceInfo};
use smithay::drm::result::Error as DrmError;
use smithay::backend::drm::{DevPath, DrmBackend, DrmDevice, DrmHandler};
use smithay::backend::graphics::GraphicsBackend;
use smithay::backend::graphics::egl::wayland::{EGLDisplay, EGLWaylandExtensions};
use smithay::backend::input::InputBackend;
use smithay::backend::libinput::{libinput_bind, LibinputInputBackend, LibinputSessionInterface};
use smithay::backend::session::{Session, SessionNotifier};
use smithay::backend::session::auto::{auto_session_bind, AutoSession};
use smithay::backend::udev::{primary_gpu, udev_backend_bind, SessionFdDrmDevice, UdevBackend, UdevHandler};
use smithay::input::Libinput;
use smithay::wayland::compositor::CompositorToken;
use smithay::wayland::output::{Mode, Output, PhysicalProperties};
use smithay::wayland::seat::Seat;
use smithay::wayland::shm::init_shm_global;
use smithay::wayland_server::Display;
use smithay::wayland_server::calloop::EventLoop;
use smithay::wayland_server::protocol::wl_output;
use smithay::input::Libinput;
use smithay::wayland_server::Display;
use glium_drawer::GliumDrawer;
use shell::{init_shell, MyWindowMap, Roles, SurfaceData};
use input_handler::AnvilInputHandler;
use shell::{init_shell, MyWindowMap, Roles, SurfaceData};
pub fn run_udev(mut display: Display, mut event_loop: EventLoop<()>, log: Logger) -> Result<(), ()> {
let name = display.add_socket_auto().unwrap().into_string().unwrap();
@ -51,16 +51,9 @@ pub fn run_udev(mut display: Display, mut event_loop: EventLoop<()>, log: Logger
/*
* Initialize the compositor
*/
init_shm_global(
&mut display.borrow_mut(),
vec![],
log.clone(),
);
init_shm_global(&mut display.borrow_mut(), vec![], log.clone());
let (compositor_token, _, _, window_map) = init_shell(
&mut display.borrow_mut(),
log.clone(),
);
let (compositor_token, _, _, window_map) = init_shell(&mut display.borrow_mut(), log.clone());
/*
* Initialize session
@ -100,11 +93,7 @@ pub fn run_udev(mut display: Display, mut event_loop: EventLoop<()>, log: Logger
let udev_session_id = notifier.register(&mut udev_backend);
let (mut w_seat, _) = Seat::new(
&mut display.borrow_mut(),
session.seat(),
log.clone(),
);
let (mut w_seat, _) = Seat::new(&mut display.borrow_mut(), session.seat(), log.clone());
let pointer = w_seat.add_pointer();
let keyboard = w_seat
@ -158,16 +147,16 @@ pub fn run_udev(mut display: Display, mut event_loop: EventLoop<()>, log: Logger
pointer_location,
session,
));
let libinput_event_source = libinput_bind(libinput_backend, event_loop.handle())
.unwrap();
let libinput_event_source = libinput_bind(libinput_backend, event_loop.handle()).unwrap();
let session_event_source = auto_session_bind(notifier, &event_loop.handle())
.unwrap();
let udev_event_source = udev_backend_bind(udev_backend)
.unwrap();
let session_event_source = auto_session_bind(notifier, &event_loop.handle()).unwrap();
let udev_event_source = udev_backend_bind(udev_backend).unwrap();
while running.load(Ordering::SeqCst) {
if event_loop.dispatch(Some(::std::time::Duration::from_millis(16)), &mut ()).is_err() {
if event_loop
.dispatch(Some(::std::time::Duration::from_millis(16)), &mut ())
.is_err()
{
running.store(false, Ordering::SeqCst);
} else {
display.borrow_mut().flush_clients();
@ -268,10 +257,9 @@ impl UdevHandler<DrmHandlerImpl> for UdevHandlerImpl {
*self.active_egl_context.borrow_mut() = device.bind_wl_display(&*self.display.borrow()).ok();
}
let backends = Rc::new(RefCell::new(self.scan_connectors(
device,
self.active_egl_context.clone(),
)));
let backends = Rc::new(RefCell::new(
self.scan_connectors(device, self.active_egl_context.clone()),
));
self.backends.insert(device.device_id(), backends.clone());
Some(DrmHandlerImpl {
@ -328,11 +316,7 @@ impl DrmHandler<SessionFdDrmDevice> for DrmHandlerImpl {
.set_cursor_position(x.trunc().abs() as u32, y.trunc().abs() as u32);
}
drawer.draw_windows(
&*self.window_map.borrow(),
self.compositor_token,
&self.logger,
);
drawer.draw_windows(&*self.window_map.borrow(), self.compositor_token, &self.logger);
}
}

6
anvil/src/window_map.rs
View File

@ -1,10 +1,10 @@
use smithay::utils::Rectangle;
use smithay::wayland::compositor::{CompositorToken, SubsurfaceRole, SurfaceAttributes, TraversalAction};
use smithay::wayland::compositor::roles::Role;
use smithay::wayland::shell::xdg::{ToplevelSurface, XdgSurfaceRole};
use smithay::wayland::compositor::{CompositorToken, SubsurfaceRole, SurfaceAttributes, TraversalAction};
use smithay::wayland::shell::legacy::{ShellSurface, ShellSurfaceRole};
use smithay::wayland_server::Resource;
use smithay::wayland::shell::xdg::{ToplevelSurface, XdgSurfaceRole};
use smithay::wayland_server::protocol::wl_surface;
use smithay::wayland_server::Resource;
pub enum Kind<U, R, SD, D> {
Xdg(ToplevelSurface<U, R, SD>),

26
anvil/src/winit.rs
View File

@ -1,24 +1,24 @@
use std::cell::RefCell;
use std::rc::Rc;
use std::sync::Arc;
use std::sync::atomic::AtomicBool;
use std::sync::Arc;
use smithay::wayland::shm::init_shm_global;
use smithay::wayland::seat::Seat;
use smithay::wayland::output::{Mode, Output, PhysicalProperties};
use smithay::backend::graphics::egl::wayland::EGLWaylandExtensions;
use smithay::backend::graphics::egl::EGLGraphicsBackend;
use smithay::backend::input::InputBackend;
use smithay::backend::winit;
use smithay::backend::graphics::egl::EGLGraphicsBackend;
use smithay::backend::graphics::egl::wayland::EGLWaylandExtensions;
use smithay::wayland_server::Display;
use smithay::wayland::output::{Mode, Output, PhysicalProperties};
use smithay::wayland::seat::Seat;
use smithay::wayland::shm::init_shm_global;
use smithay::wayland_server::calloop::EventLoop;
use smithay::wayland_server::protocol::wl_output;
use smithay::wayland_server::Display;
use slog::Logger;
use glium_drawer::GliumDrawer;
use shell::init_shell;
use input_handler::AnvilInputHandler;
use shell::init_shell;
pub fn run_winit(display: &mut Display, event_loop: &mut EventLoop<()>, log: Logger) -> Result<(), ()> {
let (renderer, mut input) = winit::init(log.clone()).map_err(|_| ())?;
@ -52,7 +52,8 @@ pub fn run_winit(display: &mut Display, event_loop: &mut EventLoop<()>, log: Log
let (mut seat, _) = Seat::new(display, "winit".into(), log.clone());
let pointer = seat.add_pointer();
let keyboard = seat.add_keyboard("", "fr", "oss", None, 1000, 500)
let keyboard = seat
.add_keyboard("", "fr", "oss", None, 1000, 500)
.expect("Failed to initialize the keyboard");
let (output, _) = Output::new(
@ -100,10 +101,9 @@ pub fn run_winit(display: &mut Display, event_loop: &mut EventLoop<()>, log: Log
drawer.draw_windows(&*window_map.borrow(), compositor_token, &log);
event_loop.dispatch(
Some(::std::time::Duration::from_millis(16)),
&mut ()
).unwrap();
event_loop
.dispatch(Some(::std::time::Duration::from_millis(16)), &mut ())
.unwrap();
display.flush_clients();
window_map.borrow_mut().refresh();

4
build.rs
View File

@ -32,7 +32,7 @@ fn main() {
"EGL_KHR_image_base",
],
).write_bindings(gl_generator::GlobalGenerator, &mut file)
.unwrap();
.unwrap();
let mut file = File::create(&dest.join("gl_bindings.rs")).unwrap();
Registry::new(
@ -42,5 +42,5 @@ fn main() {
Fallbacks::None,
["GL_OES_EGL_image"],
).write_bindings(gl_generator::GlobalGenerator, &mut file)
.unwrap();
.unwrap();
}

90
src/backend/drm/backend.rs
View File

@ -1,15 +1,17 @@
use super::DevPath;
use super::error::*;
use backend::graphics::GraphicsBackend;
use backend::graphics::egl::{EGLContext, EGLGraphicsBackend, EGLSurface, PixelFormat, SwapBuffersError};
use super::DevPath;
use backend::graphics::egl::error::Result as EGLResult;
use backend::graphics::egl::native::{Gbm, GbmSurfaceArguments};
use backend::graphics::egl::wayland::{EGLDisplay, EGLWaylandExtensions};
use drm::Device as BasicDevice;
use drm::control::{Device, ResourceInfo};
use backend::graphics::egl::{EGLContext, EGLGraphicsBackend, EGLSurface, PixelFormat, SwapBuffersError};
use backend::graphics::GraphicsBackend;
use drm::control::{connector, crtc, encoder, framebuffer, Mode};
use gbm::{BufferObject, BufferObjectFlags, Device as GbmDevice, Format as GbmFormat, Surface as GbmSurface,
SurfaceBufferHandle};
use drm::control::{Device, ResourceInfo};
use drm::Device as BasicDevice;
use gbm::{
BufferObject, BufferObjectFlags, Device as GbmDevice, Format as GbmFormat, Surface as GbmSurface,
SurfaceBufferHandle,
};
use image::{ImageBuffer, Rgba};
use nix::libc::c_void;
use std::cell::Cell;
@ -54,19 +56,12 @@ impl<A: Device + 'static> DrmBackend<A> {
size: (w as u32, h as u32),
format: GbmFormat::XRGB8888,
flags: BufferObjectFlags::SCANOUT | BufferObjectFlags::RENDERING,
})
.chain_err(|| ErrorKind::GbmInitFailed)?;
}).chain_err(|| ErrorKind::GbmInitFailed)?;
// make it active for the first `crtc::set`
// (which is needed before the first page_flip)
unsafe {
surface
.make_current()
.chain_err(|| ErrorKind::FailedToSwap)?
};
surface
.swap_buffers()
.chain_err(|| ErrorKind::FailedToSwap)?;
unsafe { surface.make_current().chain_err(|| ErrorKind::FailedToSwap)? };
surface.swap_buffers().chain_err(|| ErrorKind::FailedToSwap)?;
// init the first screen
// (must be done before calling page_flip for the first time)
@ -78,21 +73,11 @@ impl<A: Device + 'static> DrmBackend<A> {
// we need a framebuffer for the front buffer
let fb = framebuffer::create(&*context, &*front_bo).chain_err(|| {
ErrorKind::DrmDev(format!(
"Error creating framebuffer on {:?}",
context.dev_path()
))
ErrorKind::DrmDev(format!("Error creating framebuffer on {:?}", context.dev_path()))
})?;
debug!(log, "Initialize screen");
crtc::set(
&*context,
crtc,
fb.handle(),
&connectors,
(0, 0),
Some(mode),
).chain_err(|| {
crtc::set(&*context, crtc, fb.handle(), &connectors, (0, 0), Some(mode)).chain_err(|| {
ErrorKind::DrmDev(format!(
"Error setting crtc {:?} on {:?}",
crtc,
@ -108,8 +93,7 @@ impl<A: Device + 'static> DrmBackend<A> {
1,
GbmFormat::ARGB8888,
BufferObjectFlags::CURSOR | BufferObjectFlags::WRITE,
)
.chain_err(|| ErrorKind::GbmInitFailed)?,
).chain_err(|| ErrorKind::GbmInitFailed)?,
(0, 0),
));
@ -149,7 +133,8 @@ impl<A: Device + 'static> DrmBackend<A> {
// check if the connector can handle the current mode
if info.modes().contains(&self.mode) {
// check if there is a valid encoder
let encoders = info.encoders()
let encoders = info
.encoders()
.iter()
.map(|encoder| {
encoder::Info::load_from_device(&*self.backend.context, *encoder).chain_err(|| {
@ -158,8 +143,7 @@ impl<A: Device + 'static> DrmBackend<A> {
self.backend.context.dev_path()
))
})
})
.collect::<Result<Vec<encoder::Info>>>()?;
}).collect::<Result<Vec<encoder::Info>>>()?;
// and if any encoder supports the selected crtc
let resource_handles = self.backend.context.resource_handles().chain_err(|| {
@ -171,11 +155,11 @@ impl<A: Device + 'static> DrmBackend<A> {
if !encoders
.iter()
.map(|encoder| encoder.possible_crtcs())
.all(|crtc_list|
.all(|crtc_list| {
resource_handles
.filter_crtcs(crtc_list)
.contains(&self.backend.crtc)
) {
}) {
bail!(ErrorKind::NoSuitableEncoder(info, self.backend.crtc));
}
@ -232,8 +216,7 @@ impl<A: Device + 'static> DrmBackend<A> {
"Error loading connector info on {:?}",
self.backend.context.dev_path()
))
})?
.modes()
})?.modes()
.contains(&mode)
{
bail!(ErrorKind::ModeNotSuitable(mode));
@ -249,25 +232,19 @@ impl<A: Device + 'static> DrmBackend<A> {
self.backend.logger,
"Reinitializing surface for new mode: {}:{}", w, h
);
let surface = self.backend
let surface = self
.backend
.context
.create_surface(GbmSurfaceArguments {
size: (w as u32, h as u32),
format: GbmFormat::XRGB8888,
flags: BufferObjectFlags::SCANOUT | BufferObjectFlags::RENDERING,
})
.chain_err(|| ErrorKind::GbmInitFailed)?;
}).chain_err(|| ErrorKind::GbmInitFailed)?;
// make it active for the first `crtc::set`
// (which is needed before the first page_flip)
unsafe {
surface
.make_current()
.chain_err(|| ErrorKind::FailedToSwap)?
};
surface
.swap_buffers()
.chain_err(|| ErrorKind::FailedToSwap)?;
unsafe { surface.make_current().chain_err(|| ErrorKind::FailedToSwap)? };
surface.swap_buffers().chain_err(|| ErrorKind::FailedToSwap)?;
// Clean up next_buffer
{
@ -412,11 +389,7 @@ impl<A: Device + 'static> GraphicsBackend for DrmBackend<A> {
fn set_cursor_position(&self, x: u32, y: u32) -> Result<()> {
trace!(self.backend.logger, "Move the cursor to {},{}", x, y);
crtc::move_cursor(
&*self.backend.context,
self.backend.crtc,
(x as i32, y as i32),
).chain_err(|| {
crtc::move_cursor(&*self.backend.context, self.backend.crtc, (x as i32, y as i32)).chain_err(|| {
ErrorKind::DrmDev(format!(
"Error moving cursor on {:?}",
self.backend.context.dev_path()
@ -433,15 +406,15 @@ impl<A: Device + 'static> GraphicsBackend for DrmBackend<A> {
debug!(self.backend.logger, "Importing cursor");
// import the cursor into a buffer we can render
let mut cursor = self.backend
let mut cursor = self
.backend
.context
.create_buffer_object(
w,
h,
GbmFormat::ARGB8888,
BufferObjectFlags::CURSOR | BufferObjectFlags::WRITE,
)
.chain_err(|| ErrorKind::GbmInitFailed)?;
).chain_err(|| ErrorKind::GbmInitFailed)?;
cursor
.write(&**buffer)
.chain_err(|| ErrorKind::GbmInitFailed)?
@ -495,7 +468,8 @@ impl<A: Device + 'static> EGLGraphicsBackend for DrmBackend<A> {
// would most likely result in a lot of flickering.
// neither weston, wlc or wlroots bother with that as well.
// so we just assume we got at least two buffers to do flipping.
let mut next_bo = self.surface
let mut next_bo = self
.surface
.lock_front_buffer()
.expect("Surface only has one front buffer. Not supported by smithay");

128
src/backend/drm/mod.rs
View File

@ -215,11 +215,11 @@ use backend::graphics::egl::native::Gbm;
use backend::graphics::egl::wayland::{EGLDisplay, EGLWaylandExtensions};
#[cfg(feature = "backend_session")]
use backend::session::{AsSessionObserver, SessionObserver};
use drm::Device as BasicDevice;
use drm::control::{connector, crtc, encoder, Mode, ResourceInfo};
use drm::control::Device as ControlDevice;
use drm::control::framebuffer;
use drm::control::Device as ControlDevice;
use drm::control::{connector, crtc, encoder, Mode, ResourceInfo};
use drm::result::Error as DrmError;
use drm::Device as BasicDevice;
use gbm::{BufferObject, Device as GbmDevice};
use nix;
use nix::sys::stat::{self, dev_t, fstat};
@ -230,13 +230,13 @@ use std::io::Error as IoError;
use std::os::unix::io::{AsRawFd, RawFd};
use std::path::PathBuf;
use std::rc::{Rc, Weak};
use std::sync::{Arc, Once, ONCE_INIT};
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, Once, ONCE_INIT};
use std::time::Duration;
use wayland_server::calloop::generic::{EventedRawFd, Generic};
use wayland_server::calloop::{LoopHandle, Ready, Source};
use wayland_server::Display;
use wayland_server::calloop::{LoopHandle, Source, Ready};
use wayland_server::calloop::generic::{Generic, EventedRawFd};
mod backend;
pub mod error;
@ -308,17 +308,19 @@ impl<A: ControlDevice + 'static> DrmDevice<A> {
let mut drm = DrmDevice {
// Open the gbm device from the drm device and create a context based on that
context: Rc::new(EGLContext::new(
{
debug!(log, "Creating gbm device");
let gbm = GbmDevice::new(dev).chain_err(|| ErrorKind::GbmInitFailed)?;
debug!(log, "Creating egl context from gbm device");
gbm
},
attributes,
Default::default(),
log.clone(),
).map_err(Error::from)?),
context: Rc::new(
EGLContext::new(
{
debug!(log, "Creating gbm device");
let gbm = GbmDevice::new(dev).chain_err(|| ErrorKind::GbmInitFailed)?;
debug!(log, "Creating egl context from gbm device");
gbm
},
attributes,
Default::default(),
log.clone(),
).map_err(Error::from)?,
),
backends: Rc::new(RefCell::new(HashMap::new())),
device_id,
old_state: HashMap::new(),
@ -331,32 +333,20 @@ impl<A: ControlDevice + 'static> DrmDevice<A> {
// we want to mode-set, so we better be the master, if we run via a tty session
if drm.set_master().is_err() {
warn!(
log,
"Unable to become drm master, assuming unpriviledged mode"
);
warn!(log, "Unable to become drm master, assuming unpriviledged mode");
drm.priviledged = false;
};
let res_handles = drm.resource_handles().chain_err(|| {
ErrorKind::DrmDev(format!(
"Error loading drm resources on {:?}",
drm.dev_path()
))
ErrorKind::DrmDev(format!("Error loading drm resources on {:?}", drm.dev_path()))
})?;
for &con in res_handles.connectors() {
let con_info = connector::Info::load_from_device(&drm, con).chain_err(|| {
ErrorKind::DrmDev(format!(
"Error loading connector info on {:?}",
drm.dev_path()
))
ErrorKind::DrmDev(format!("Error loading connector info on {:?}", drm.dev_path()))
})?;
if let Some(enc) = con_info.current_encoder() {
let enc_info = encoder::Info::load_from_device(&drm, enc).chain_err(|| {
ErrorKind::DrmDev(format!(
"Error loading encoder info on {:?}",
drm.dev_path()
))
ErrorKind::DrmDev(format!("Error loading encoder info on {:?}", drm.dev_path()))
})?;
if let Some(crtc) = enc_info.current_crtc() {
let info = crtc::Info::load_from_device(&drm, crtc).chain_err(|| {
@ -402,10 +392,7 @@ impl<A: ControlDevice + 'static> DrmDevice<A> {
// check if we have an encoder for every connector and the mode mode
for connector in &connectors {
let con_info = connector::Info::load_from_device(self, *connector).chain_err(|| {
ErrorKind::DrmDev(format!(
"Error loading connector info on {:?}",
self.dev_path()
))
ErrorKind::DrmDev(format!("Error loading connector info on {:?}", self.dev_path()))
})?;
// check the mode
@ -419,20 +406,13 @@ impl<A: ControlDevice + 'static> DrmDevice<A> {
.iter()
.map(|encoder| {
encoder::Info::load_from_device(self, *encoder).chain_err(|| {
ErrorKind::DrmDev(format!(
"Error loading encoder info on {:?}",
self.dev_path()
))
ErrorKind::DrmDev(format!("Error loading encoder info on {:?}", self.dev_path()))
})
})
.collect::<Result<Vec<encoder::Info>>>()?;
}).collect::<Result<Vec<encoder::Info>>>()?;
// and if any encoder supports the selected crtc
let resource_handles = self.resource_handles().chain_err(|| {
ErrorKind::DrmDev(format!(
"Error loading drm resources on {:?}",
self.dev_path()
))
ErrorKind::DrmDev(format!("Error loading drm resources on {:?}", self.dev_path()))
})?;
if !encoders
.iter()
@ -514,18 +494,12 @@ impl<A: ControlDevice + 'static> Drop for DrmDevice<A> {
info.position(),
info.mode(),
) {
error!(
self.logger,
"Failed to reset crtc ({:?}). Error: {}", handle, err
);
error!(self.logger, "Failed to reset crtc ({:?}). Error: {}", handle, err);
}
}
if self.priviledged {
if let Err(err) = self.drop_master() {
error!(
self.logger,
"Failed to drop drm master state. Error: {}", err
);
error!(self.logger, "Failed to drop drm master state. Error: {}", err);
}
}
}
@ -563,17 +537,13 @@ where
let mut source = Generic::from_raw_fd(fd);
source.set_interest(Ready::readable());
match handle.insert_source(
source,
{
let device = device.clone();
move |_evt, _| {
let mut device = device.borrow_mut();
process_events(&mut *device, &mut handler);
}
match handle.insert_source(source, {
let device = device.clone();
move |_evt, _| {
let mut device = device.borrow_mut();
process_events(&mut *device, &mut handler);
}
) {
}) {
Ok(source) => Ok((source, device)),
Err(e) => {
let device = Rc::try_unwrap(device).unwrap_or_else(|_| unreachable!());
@ -583,7 +553,7 @@ where
}
fn process_events<A, H>(device: &mut DrmDevice<A>, handler: &mut H)
where
where
A: ControlDevice + 'static,
H: DrmHandler<A> + 'static,
{
@ -592,18 +562,12 @@ where
if let crtc::Event::PageFlip(event) = event {
if device.active.load(Ordering::SeqCst) {
let backends = device.backends.borrow().clone();
if let Some(backend) = backends
.get(&event.crtc)
.iter()
.flat_map(|x| x.upgrade())
.next()
{
if let Some(backend) = backends.get(&event.crtc).iter().flat_map(|x| x.upgrade()).next() {
// we can now unlock the buffer
backend.unlock_buffer();
trace!(device.logger, "Handling event for backend {:?}", event.crtc);
// and then call the user to render the next frame
handler
.ready(device, event.crtc, event.frame, event.duration);
handler.ready(device, event.crtc, event.frame, event.duration);
} else {
device.backends.borrow_mut().remove(&event.crtc);
}
@ -658,10 +622,7 @@ impl<A: ControlDevice + 'static> SessionObserver for DrmDeviceObserver<A> {
info.position(),
info.mode(),
) {
error!(
self.logger,
"Failed to reset crtc ({:?}). Error: {}", handle, err
);
error!(self.logger, "Failed to reset crtc ({:?}). Error: {}", handle, err);
}
}
}
@ -669,10 +630,7 @@ impl<A: ControlDevice + 'static> SessionObserver for DrmDeviceObserver<A> {
if self.priviledged {
if let Some(device) = self.context.upgrade() {
if let Err(err) = device.drop_master() {
error!(
self.logger,
"Failed to drop drm master state. Error: {}", err
);
error!(self.logger, "Failed to drop drm master state. Error: {}", err);
}
}
}
@ -694,11 +652,7 @@ impl<A: ControlDevice + 'static> SessionObserver for DrmDeviceObserver<A> {
if self.priviledged {
if let Some(device) = self.context.upgrade() {
if let Err(err) = device.set_master() {
crit!(
self.logger,
"Failed to acquire drm master again. Error: {}",
err
);
crit!(self.logger, "Failed to acquire drm master again. Error: {}", err);
}
}
}

79
src/backend/graphics/egl/context.rs
View File

@ -1,13 +1,13 @@
//! EGL context related structs
use super::{ffi, EGLSurface, PixelFormat};
use super::error::*;
use super::native;
#[cfg(feature = "backend_drm")]
use drm::Device as BasicDevice;
use super::{ffi, EGLSurface, PixelFormat};
#[cfg(feature = "backend_drm")]
use drm::control::Device as ControlDevice;
#[cfg(feature = "backend_drm")]
use drm::Device as BasicDevice;
#[cfg(feature = "backend_drm")]
use gbm::Device as GbmDevice;
use nix::libc::{c_int, c_void};
use slog;
@ -89,17 +89,15 @@ impl<B: native::Backend, N: native::NativeDisplay<B>> EGLContext<B, N> {
mut attributes: GlAttributes,
reqs: PixelFormatRequirements,
log: ::slog::Logger,
) -> Result<
(
Rc<ffi::egl::types::EGLContext>,
Rc<ffi::egl::types::EGLDisplay>,
ffi::egl::types::EGLConfig,
Vec<c_int>,
PixelFormat,
bool,
bool,
),
> {
) -> Result<(
Rc<ffi::egl::types::EGLContext>,
Rc<ffi::egl::types::EGLDisplay>,
ffi::egl::types::EGLConfig,
Vec<c_int>,
PixelFormat,
bool,
bool,
)> {
// If no version is given, try OpenGLES 3.0, if available,
// fallback to 2.0 otherwise
let version = match attributes.version {
@ -119,10 +117,7 @@ impl<B: native::Backend, N: native::NativeDisplay<B>> EGLContext<B, N> {
}
}
Some((1, x)) => {
error!(
log,
"OpenGLES 1.* is not supported by the EGL renderer backend"
);
error!(log, "OpenGLES 1.* is not supported by the EGL renderer backend");
bail!(ErrorKind::OpenGlVersionNotSupported((1, x)));
}
Some(version) => {
@ -178,11 +173,7 @@ impl<B: native::Backend, N: native::NativeDisplay<B>> EGLContext<B, N> {
debug!(log, "EGL No-Display Extensions: {:?}", dp_extensions);
let display = B::get_display(
ptr,
|e: &str| dp_extensions.iter().any(|s| s == e),
log.clone(),
);
let display = B::get_display(ptr, |e: &str| dp_extensions.iter().any(|s| s == e), log.clone());
if display == ffi::egl::NO_DISPLAY {
error!(log, "EGL Display is not valid");
bail!(ErrorKind::DisplayNotSupported);
@ -215,10 +206,7 @@ impl<B: native::Backend, N: native::NativeDisplay<B>> EGLContext<B, N> {
info!(log, "EGL Extensions: {:?}", extensions);
if egl_version >= (1, 2) && ffi::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");
bail!(ErrorKind::OpenGlesNotSupported);
}
@ -339,14 +327,7 @@ impl<B: native::Backend, N: native::NativeDisplay<B>> EGLContext<B, N> {
// calling `eglChooseConfig`
let mut config_id = mem::uninitialized();
let mut num_configs = mem::uninitialized();
if ffi::egl::ChooseConfig(
display,
descriptor.as_ptr(),
&mut config_id,
1,
&mut num_configs,
) == 0
{
if ffi::egl::ChooseConfig(display, descriptor.as_ptr(), &mut config_id, 1, &mut num_configs) == 0 {
bail!(ErrorKind::ConfigFailed);
}
if num_configs == 0 {
@ -356,17 +337,14 @@ impl<B: native::Backend, N: native::NativeDisplay<B>> EGLContext<B, N> {
// analyzing each config
macro_rules! attrib {
($display:expr, $config:expr, $attr:expr) => (
{
let mut value = mem::uninitialized();
let res = ffi::egl::GetConfigAttrib($display, $config,
$attr as ffi::egl::types::EGLint, &mut value);
if res == 0 {
bail!(ErrorKind::ConfigFailed);
}
value
($display:expr, $config:expr, $attr:expr) => {{
let mut value = mem::uninitialized();
let res = ffi::egl::GetConfigAttrib($display, $config, $attr as ffi::egl::types::EGLint, &mut value);
if res == 0 {
bail!(ErrorKind::ConfigFailed);
}
)
value
}};
};
let desc = PixelFormat {
@ -450,12 +428,7 @@ impl<B: native::Backend, N: native::NativeDisplay<B>> EGLContext<B, N> {
info!(log, "EGL context created");
// make current and get list of gl extensions
ffi::egl::MakeCurrent(
display as *const _,
ptr::null(),
ptr::null(),
context as *const _,
);
ffi::egl::MakeCurrent(display as *const _, ptr::null(), ptr::null(), context as *const _);
// the list of gl extensions supported by the context
let gl_extensions = {
@ -474,9 +447,7 @@ impl<B: native::Backend, N: native::NativeDisplay<B>> EGLContext<B, N> {
config_id,
surface_attributes,
desc,
extensions
.iter()
.any(|s| *s == "EGL_WL_bind_wayland_display"),
extensions.iter().any(|s| *s == "EGL_WL_bind_wayland_display"),
gl_extensions
.iter()
.any(|s| *s == "GL_OES_EGL_image" || *s == "GL_OES_EGL_image_base"),

10
src/backend/graphics/egl/ffi.rs
View File

@ -25,9 +25,7 @@ pub mod egl {
use std::sync::{Once, ONCE_INIT};
lazy_static! {
pub static ref LIB: Library = {
Library::new("libEGL.so.1").expect("Failed to load LibEGL")
};
pub static ref LIB: Library = { Library::new("libEGL.so.1").expect("Failed to load LibEGL") };
}
pub static LOAD: Once = ONCE_INIT;
@ -101,9 +99,9 @@ pub mod egl {
#[allow(non_snake_case)]
pub mod BindWaylandDisplayWL {
use super::{metaloadfn, wayland_storage};
use super::FnPtr;
use super::__gl_imports::raw;
use super::{metaloadfn, wayland_storage};
#[inline]
#[allow(dead_code)]
@ -125,9 +123,9 @@ pub mod egl {
#[allow(non_snake_case)]
pub mod UnbindWaylandDisplayWL {
use super::{metaloadfn, wayland_storage};
use super::FnPtr;
use super::__gl_imports::raw;
use super::{metaloadfn, wayland_storage};
#[inline]
#[allow(dead_code)]
@ -149,9 +147,9 @@ pub mod egl {
#[allow(non_snake_case)]
pub mod QueryWaylandBufferWL {
use super::{metaloadfn, wayland_storage};
use super::FnPtr;
use super::__gl_imports::raw;
use super::{metaloadfn, wayland_storage};
#[inline]
#[allow(dead_code)]

7
src/backend/graphics/egl/mod.rs
View File

@ -13,7 +13,12 @@ use std::fmt;
pub mod context;
pub use self::context::EGLContext;
pub mod error;
#[allow(non_camel_case_types, dead_code, unused_mut, non_upper_case_globals)]
#[allow(
non_camel_case_types,
dead_code,
unused_mut,
non_upper_case_globals
)]
pub mod ffi;
pub mod native;
pub mod surface;

26
src/backend/graphics/egl/native.rs
View File

@ -15,9 +15,9 @@ use std::ptr;
#[cfg(feature = "backend_winit")]
use wayland_client::egl as wegl;
#[cfg(feature = "backend_winit")]
use winit::Window as WinitWindow;
#[cfg(feature = "backend_winit")]
use winit::os::unix::WindowExt;
#[cfg(feature = "backend_winit")]
use winit::Window as WinitWindow;
/// Trait for typed backend variants (X11/Wayland/GBM)
pub trait Backend {
@ -53,26 +53,12 @@ impl Backend for Wayland {
F: Fn(&str) -> bool,
{
if has_dp_extension("EGL_KHR_platform_wayland") && ffi::egl::GetPlatformDisplay::is_loaded() {
trace!(
log,
"EGL Display Initialization via EGL_KHR_platform_wayland"
);
ffi::egl::GetPlatformDisplay(
ffi::egl::PLATFORM_WAYLAND_KHR,
display as *mut _,
ptr::null(),
)
trace!(log, "EGL Display Initialization via EGL_KHR_platform_wayland");
ffi::egl::GetPlatformDisplay(ffi::egl::PLATFORM_WAYLAND_KHR, display as *mut _, ptr::null())
} else if has_dp_extension("EGL_EXT_platform_wayland") && ffi::egl::GetPlatformDisplayEXT::is_loaded()
{
trace!(
log,
"EGL Display Initialization via EGL_EXT_platform_wayland"
);
ffi::egl::GetPlatformDisplayEXT(
ffi::egl::PLATFORM_WAYLAND_EXT,
display as *mut _,
ptr::null(),
)
trace!(log, "EGL Display Initialization via EGL_EXT_platform_wayland");
ffi::egl::GetPlatformDisplayEXT(ffi::egl::PLATFORM_WAYLAND_EXT, display as *mut _, ptr::null())
} else {
trace!(log, "Default EGL Display Initialization via GetDisplay");
ffi::egl::GetDisplay(display as *mut _)

2
src/backend/graphics/egl/surface.rs
View File

@ -1,9 +1,9 @@
//! EGL surface related structs
use super::{EGLContext, SwapBuffersError};
use super::error::*;
use super::ffi;
use super::native;
use super::{EGLContext, SwapBuffersError};
use std::ops::{Deref, DerefMut};
use std::rc::{Rc, Weak};

16
src/backend/graphics/egl/wayland.rs
View File

@ -10,14 +10,14 @@
//! You may then use the resulting `EGLDisplay` to recieve `EGLImages` of an egl-based `WlBuffer`
//! for rendering.
use backend::graphics::egl::{ffi, native, EGLContext, EglExtensionNotSupportedError};
use backend::graphics::egl::error::*;
use backend::graphics::egl::ffi::egl::types::EGLImage;
use backend::graphics::egl::{ffi, native, EGLContext, EglExtensionNotSupportedError};
use nix::libc::c_uint;
use std::fmt;
use std::rc::{Rc, Weak};
use wayland_server::{Display, Resource};
use wayland_server::protocol::wl_buffer::{self, WlBuffer};
use wayland_server::{Display, Resource};
use wayland_sys::server::wl_display;
/// Error that can occur when accessing an EGL buffer
@ -110,12 +110,9 @@ impl fmt::Display for TextureCreationError {
match *self {
TextureCreationError::ContextLost => write!(formatter, "{}", self.description()),
TextureCreationError::PlaneIndexOutOfBounds => write!(formatter, "{}", self.description()),
TextureCreationError::TextureBindingFailed(code) => write!(
formatter,
"{}. Gl error code: {:?}",
self.description(),
code
),
TextureCreationError::TextureBindingFailed(code) => {
write!(formatter, "{}. Gl error code: {:?}", self.description(), code)
}
}
}
}
@ -203,7 +200,8 @@ impl EGLImages {
ffi::gl::BindTexture(ffi::gl::TEXTURE_2D, tex_id);
ffi::gl::EGLImageTargetTexture2DOES(
ffi::gl::TEXTURE_2D,
*self.images
*self
.images
.get(plane)
.ok_or(TextureCreationError::PlaneIndexOutOfBounds)?,
);

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

@ -1,12 +1,12 @@
//! Glium compatibility module
use backend::graphics::egl::{EGLGraphicsBackend, SwapBuffersError};
use backend::graphics::egl::error::Result as EGLResult;
use backend::graphics::egl::wayland::{EGLDisplay, EGLWaylandExtensions};
use glium::Frame;
use glium::SwapBuffersError as GliumSwapBuffersError;
use backend::graphics::egl::{EGLGraphicsBackend, SwapBuffersError};
use glium::backend::{Backend, Context, Facade};
use glium::debug::DebugCallbackBehavior;
use glium::Frame;
use glium::SwapBuffersError as GliumSwapBuffersError;
use std::cell::{Ref, RefCell, RefMut};
use std::os::raw::c_void;
use std::rc::Rc;
@ -51,10 +51,7 @@ 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())
}
/// Borrow the underlying backend.

2
src/backend/graphics/mod.rs
View File

@ -36,7 +36,7 @@ pub trait GraphicsBackend {
) -> Result<(), Self::Error>;
}
pub mod software;
pub mod egl;
#[cfg(feature = "renderer_glium")]
pub mod glium;
pub mod software;

52
src/backend/libinput.rs
View File

@ -12,8 +12,8 @@ use std::io::Error as IoError;
use std::os::unix::io::RawFd;
use std::path::Path;
use wayland_server::calloop::{LoopHandle, Source, Ready};
use wayland_server::calloop::generic::{Generic, EventedRawFd};
use wayland_server::calloop::generic::{EventedRawFd, Generic};
use wayland_server::calloop::{LoopHandle, Ready, Source};
// No idea if this is the same across unix platforms
// Lets make this linux exclusive for now, once someone tries to build it for
@ -355,15 +355,18 @@ impl backend::InputBackend for LibinputInputBackend {
// update capabilities, so they appear correctly on `on_seat_changed` and `on_seat_destroyed`.
if let Some(seat) = self.seats.get_mut(&device_seat) {
let caps = seat.capabilities_mut();
caps.pointer = self.devices
caps.pointer = self
.devices
.iter()
.filter(|x| x.seat() == device_seat)
.any(|x| x.has_capability(libinput::DeviceCapability::Pointer));
caps.keyboard = self.devices
caps.keyboard = self
.devices
.iter()
.filter(|x| x.seat() == device_seat)
.any(|x| x.has_capability(libinput::DeviceCapability::Keyboard));
caps.touch = self.devices
caps.touch = self
.devices
.iter()
.filter(|x| x.seat() == device_seat)
.any(|x| x.has_capability(libinput::DeviceCapability::Touch));
@ -411,11 +414,7 @@ impl backend::InputBackend for LibinputInputBackend {
handler.on_touch_down(seat, down_event)
}
TouchEvent::Motion(motion_event) => {
trace!(
self.logger,
"Calling on_touch_motion with {:?}",
motion_event
);
trace!(self.logger, "Calling on_touch_motion with {:?}", motion_event);
handler.on_touch_motion(seat, motion_event)
}
TouchEvent::Up(up_event) => {
@ -423,11 +422,7 @@ impl backend::InputBackend for LibinputInputBackend {
handler.on_touch_up(seat, up_event)
}
TouchEvent::Cancel(cancel_event) => {
trace!(
self.logger,
"Calling on_touch_cancel with {:?}",
cancel_event
);
trace!(self.logger, "Calling on_touch_cancel with {:?}", cancel_event);
handler.on_touch_cancel(seat, cancel_event)
}
TouchEvent::Frame(frame_event) => {
@ -463,11 +458,7 @@ impl backend::InputBackend for LibinputInputBackend {
if let Some(ref seat) = self.seats.get(&device_seat) {
match pointer_event {
PointerEvent::Motion(motion_event) => {
trace!(
self.logger,
"Calling on_pointer_move with {:?}",
motion_event
);
trace!(self.logger, "Calling on_pointer_move with {:?}", motion_event);
handler.on_pointer_move(seat, motion_event);
}
PointerEvent::MotionAbsolute(motion_abs_event) => {
@ -483,11 +474,7 @@ impl backend::InputBackend for LibinputInputBackend {
handler.on_pointer_axis(seat, axis_event);
}
PointerEvent::Button(button_event) => {
trace!(
self.logger,
"Calling on_pointer_button with {:?}",
button_event
);
trace!(self.logger, "Calling on_pointer_button with {:?}", button_event);
handler.on_pointer_button(seat, button_event);
}
}
@ -606,13 +593,10 @@ pub fn libinput_bind<Data: 'static>(
) -> ::std::result::Result<Source<Generic<EventedRawFd>>, IoError> {
let mut source = Generic::from_raw_fd(unsafe { backend.context.fd() });
source.set_interest(Ready::readable());
handle.insert_source(
source,
move |_, _| {
use backend::input::InputBackend;
if let Err(error) = backend.dispatch_new_events() {
warn!(backend.logger, "Libinput errored: {}", error);
}
handle.insert_source(source, move |_, _| {
use backend::input::InputBackend;
if let Err(error) = backend.dispatch_new_events() {
warn!(backend.logger, "Libinput errored: {}", error);
}
)
}
})
}

6
src/backend/mod.rs
View File

@ -14,11 +14,9 @@
//! - winit
//! - libinput
pub mod input;
pub mod graphics;
pub mod input;
#[cfg(feature = "backend_winit")]
pub mod winit;
#[cfg(feature = "backend_drm")]
pub mod drm;
#[cfg(feature = "backend_libinput")]
@ -27,3 +25,5 @@ pub mod libinput;
pub mod session;
#[cfg(feature = "backend_udev")]
pub mod udev;
#[cfg(feature = "backend_winit")]
pub mod winit;

16
src/backend/session/auto.rs
View File

@ -28,10 +28,10 @@
//! automatically by the `UdevBackend`, if not done manually).
//! ```
use super::{AsErrno, AsSessionObserver, Session, SessionNotifier, SessionObserver};
use super::direct::{self, direct_session_bind, DirectSession, DirectSessionNotifier, BoundDirectSession};
use super::direct::{self, direct_session_bind, BoundDirectSession, DirectSession, DirectSessionNotifier};
#[cfg(feature = "backend_session_logind")]
use super::logind::{self, logind_session_bind, BoundLogindSession, LogindSession, LogindSessionNotifier};
use super::{AsErrno, AsSessionObserver, Session, SessionNotifier, SessionObserver};
use nix::fcntl::OFlag;
use std::cell::RefCell;
use std::io::Error as IoError;
@ -109,10 +109,7 @@ impl AutoSession {
)),
Err(err) => {
warn!(logger, "Failed to create direct session: {}", err);
error!(
logger,
"Could not create any session, possibilities exhausted"
);
error!(logger, "Could not create any session, possibilities exhausted");
None
}
}
@ -136,10 +133,7 @@ impl AutoSession {
)),
Err(err) => {
warn!(logger, "Failed to create direct session: {}", err);
error!(
logger,
"Could not create any session, possibilities exhausted"
);
error!(logger, "Could not create any session, possibilities exhausted");
None
}
}
@ -255,7 +249,7 @@ impl BoundAutoSession {
match self {
#[cfg(feature = "backend_session_logind")]
BoundAutoSession::Logind(logind) => AutoSessionNotifier::Logind(logind.unbind()),
BoundAutoSession::Direct(direct) => AutoSessionNotifier::Direct(direct.unbind())
BoundAutoSession::Direct(direct) => AutoSessionNotifier::Direct(direct.unbind()),
}
}
}

39
src/backend/session/dbus/logind.rs
View File

@ -31,8 +31,10 @@
//! ```
use backend::session::{AsErrno, AsSessionObserver, Session, SessionNotifier, SessionObserver};
use dbus::{BusName, BusType, Connection, ConnectionItem, ConnectionItems, Interface, Member, Message,
MessageItem, OwnedFd, Path as DbusPath, Watch, WatchEvent};
use dbus::{
BusName, BusType, Connection, ConnectionItem, ConnectionItems, Interface, Member, Message, MessageItem,
OwnedFd, Path as DbusPath, Watch, WatchEvent,
};
use nix::fcntl::OFlag;
use nix::sys::stat::{fstat, major, minor, stat};
use std::cell::RefCell;
@ -43,8 +45,8 @@ use std::rc::{Rc, Weak};
use std::sync::atomic::{AtomicBool, Ordering};
use systemd::login;
use wayland_server::calloop::{Loophandle, Source, Ready};
use wayland_server::calloop::generic::{Generic, EventedRawFd, Event};
use wayland_server::calloop::generic::{Event, EventedRawFd, Generic};
use wayland_server::calloop::{Loophandle, Ready, Source};
struct LogindSessionImpl {
conn: RefCell<Connection>,
@ -93,7 +95,7 @@ impl LogindSession {
"GetSession",
Some(vec![session_id.clone().into()]),
)?.get1::<DbusPath<'static>>()
.chain_err(|| ErrorKind::UnexpectedMethodReturn)?;
.chain_err(|| ErrorKind::UnexpectedMethodReturn)?;
// Match all signals that we want to receive and handle
let match1 = String::from(
@ -212,15 +214,14 @@ impl LogindSessionImpl {
message.append_items(&arguments)
};
let mut message = conn.send_with_reply_and_block(message, 1000)
.chain_err(|| {
ErrorKind::FailedToSendDbusCall(
destination.clone(),
path.clone(),
interface.clone(),
method.clone(),
)
})?;
let mut message = conn.send_with_reply_and_block(message, 1000).chain_err(|| {
ErrorKind::FailedToSendDbusCall(
destination.clone(),
path.clone(),
interface.clone(),
method.clone(),
)
})?;
match message.as_result() {
Ok(_) => Ok(message),
@ -290,8 +291,7 @@ impl LogindSessionImpl {
let (major, minor, fd) = message.get3::<u32, u32, OwnedFd>();
let major = major.chain_err(|| ErrorKind::UnexpectedMethodReturn)?;
let minor = minor.chain_err(|| ErrorKind::UnexpectedMethodReturn)?;
let fd = fd.chain_err(|| ErrorKind::UnexpectedMethodReturn)?
.into_fd();
let fd = fd.chain_err(|| ErrorKind::UnexpectedMethodReturn)?.into_fd();
debug!(self.logger, "Reactivating device ({},{})", major, minor);
for signal in &mut *self.signals.borrow_mut() {
if let &mut Some(ref mut signal) = signal {
@ -336,8 +336,7 @@ impl Session for LogindSession {
(minor(stat.st_rdev) as u32).into(),
]),
)?.get2::<OwnedFd, bool>();
let fd = fd.chain_err(|| ErrorKind::UnexpectedMethodReturn)?
.into_fd();
let fd = fd.chain_err(|| ErrorKind::UnexpectedMethodReturn)?.into_fd();
Ok(fd)
} else {
bail!(ErrorKind::SessionLost)
@ -510,8 +509,8 @@ impl LogindSessionNotifier {
} else if readiness.writable() {
WatchEvent::Writable as u32
} else {
return
}
return;
},
);
if let Err(err) = self.internal.handle_signals(items) {
error!(self.internal.logger, "Error handling dbus signals: {}", err);

59
src/backend/session/direct.rs
View File

@ -46,23 +46,23 @@
//! automatically by the `UdevBackend`, if not done manually).
use super::{AsErrno, AsSessionObserver, Session, SessionNotifier, SessionObserver};
use nix::{Error as NixError, Result as NixResult};
use nix::fcntl::{self, open, OFlag};
use nix::libc::c_int;
use nix::sys::signal::{self, Signal};
use nix::sys::stat::{dev_t, fstat, major, minor, Mode};
use nix::unistd::{close, dup};
use nix::{Error as NixError, Result as NixResult};
use std::cell::RefCell;
use std::rc::Rc;
use std::io::Error as IoError;
use std::os::unix::io::RawFd;
use std::path::Path;
use std::sync::Arc;
use std::rc::Rc;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::Arc;
#[cfg(feature = "backend_session_udev")]
use udev::Context;
use wayland_server::calloop::{LoopHandle, Source};
use wayland_server::calloop::signals::Signals;
use wayland_server::calloop::{LoopHandle, Source};
#[allow(dead_code)]
mod tty {
@ -172,13 +172,16 @@ impl DirectSession {
let logger = ::slog_or_stdlog(logger)
.new(o!("smithay_module" => "backend_session", "session_type" => "direct/vt"));
let fd = tty.map(|path| {
open(
path,
fcntl::OFlag::O_RDWR | fcntl::OFlag::O_CLOEXEC,
Mode::empty(),
).chain_err(|| ErrorKind::FailedToOpenTTY(String::from(path.to_string_lossy())))
}).unwrap_or_else(|| dup(0 /*stdin*/).chain_err(|| ErrorKind::FailedToOpenTTY(String::from("<stdin>"))))?;
let fd = tty
.map(|path| {
open(
path,
fcntl::OFlag::O_RDWR | fcntl::OFlag::O_CLOEXEC,
Mode::empty(),
).chain_err(|| ErrorKind::FailedToOpenTTY(String::from(path.to_string_lossy())))
}).unwrap_or_else(|| {
dup(0 /*stdin*/).chain_err(|| ErrorKind::FailedToOpenTTY(String::from("<stdin>")))
})?;
let active = Arc::new(AtomicBool::new(true));
@ -311,16 +314,10 @@ impl Drop for DirectSession {
info!(self.logger, "Deallocating tty {}", self.tty);
if let Err(err) = unsafe { tty::kd_set_kb_mode(self.tty, self.old_keyboard_mode) } {
warn!(
self.logger,
"Unable to restore vt keyboard mode. Error: {}", err
);
warn!(self.logger, "Unable to restore vt keyboard mode. Error: {}", err);
}
if let Err(err) = unsafe { tty::kd_set_mode(self.tty, tty::KD_TEXT as i32) } {
warn!(
self.logger,
"Unable to restore vt text mode. Error: {}", err
);
warn!(self.logger, "Unable to restore vt text mode. Error: {}", err);
}
if let Err(err) = unsafe {
tty::vt_set_mode(
@ -334,10 +331,7 @@ impl Drop for DirectSession {
error!(self.logger, "Failed to reset vt handling. Error: {}", err);
}
if let Err(err) = close(self.tty) {
error!(
self.logger,
"Failed to close tty file descriptor. Error: {}", err
);
error!(self.logger, "Failed to close tty file descriptor. Error: {}", err);
}
}
}
@ -403,7 +397,7 @@ impl DirectSessionNotifier {
/// See `direct_session_bind` for details.
pub struct BoundDirectSession {
source: Source<Signals>,
notifier: Rc<RefCell<DirectSessionNotifier>>
notifier: Rc<RefCell<DirectSessionNotifier>>,
}
impl BoundDirectSession {
@ -413,7 +407,7 @@ impl BoundDirectSession {
source.remove();
match Rc::try_unwrap(notifier) {
Ok(notifier) => notifier.into_inner(),
Err(_) => panic!("Notifier should have been freed from the event loop!")
Err(_) => panic!("Notifier should have been freed from the event loop!"),
}
}
}
@ -429,16 +423,11 @@ pub fn direct_session_bind<Data: 'static>(
) -> ::std::result::Result<BoundDirectSession, IoError> {
let signal = notifier.signal;
let notifier = Rc::new(RefCell::new(notifier));
let source = handle.insert_source(
Signals::new(&[signal])?,
{
let notifier = notifier.clone();
move |_, _| notifier.borrow_mut().signal_received()
}
)?;
Ok(BoundDirectSession {
source, notifier
})
let source = handle.insert_source(Signals::new(&[signal])?, {
let notifier = notifier.clone();
move |_, _| notifier.borrow_mut().signal_received()
})?;
Ok(BoundDirectSession { source, notifier })
}
error_chain! {

2
src/backend/session/mod.rs
View File

@ -181,6 +181,6 @@ impl AsErrno for () {
}
pub mod auto;
pub mod direct;
mod dbus;
pub mod direct;
pub use self::dbus::*;

133
src/backend/udev.rs
View File

@ -11,8 +11,8 @@
use backend::drm::{drm_device_bind, DrmDevice, DrmHandler};
use backend::session::{AsSessionObserver, Session, SessionObserver};
use drm::Device as BasicDevice;
use drm::control::Device as ControlDevice;
use drm::Device as BasicDevice;
use nix::fcntl;
use nix::sys::stat::dev_t;
use std::cell::RefCell;
@ -25,8 +25,8 @@ use std::path::{Path, PathBuf};
use std::rc::{Rc, Weak};
use udev::{Context, Enumerator, Event, EventType, MonitorBuilder, MonitorSocket, Result as UdevResult};
use wayland_server::calloop::{LoopHandle, Source, Ready};
use wayland_server::calloop::generic::{Generic, EventedRawFd};
use wayland_server::calloop::generic::{EventedRawFd, Generic};
use wayland_server::calloop::{LoopHandle, Ready, Source};
/// Udev's `DrmDevice` type based on the underlying session
pub struct SessionFdDrmDevice(RawFd);
@ -48,10 +48,20 @@ pub struct UdevBackend<
H: DrmHandler<SessionFdDrmDevice> + 'static,
S: Session + 'static,
T: UdevHandler<H> + 'static,
Data: 'static
Data: 'static,
> {
_handler: ::std::marker::PhantomData<H>,
devices: Rc<RefCell<HashMap<dev_t, (Source<Generic<EventedRawFd>>, Rc<RefCell<DrmDevice<SessionFdDrmDevice>>>)>>>,
devices: Rc<
RefCell<
HashMap<
dev_t,
(
Source<Generic<EventedRawFd>>,
Rc<RefCell<DrmDevice<SessionFdDrmDevice>>>,
),
>,
>,
>,
monitor: MonitorSocket,
session: S,
handler: T,
@ -59,8 +69,12 @@ pub struct UdevBackend<
handle: LoopHandle<Data>,
}
impl<H: DrmHandler<SessionFdDrmDevice> + 'static, S: Session + 'static, T: UdevHandler<H> + 'static, Data: 'static>
UdevBackend<H, S, T, Data>
impl<
H: DrmHandler<SessionFdDrmDevice> + 'static,
S: Session + 'static,
T: UdevHandler<H> + 'static,
Data: 'static,
> UdevBackend<H, S, T, Data>
{
/// Creates a new `UdevBackend` and adds it to the given `EventLoop`'s state.
///
@ -138,9 +152,7 @@ impl<H: DrmHandler<SessionFdDrmDevice> + 'static, S: Session + 'static, T: UdevH
builder
.match_subsystem("drm")
.chain_err(|| ErrorKind::FailedToInitMonitor)?;
let monitor = builder
.listen()
.chain_err(|| ErrorKind::FailedToInitMonitor)?;
let monitor = builder.listen().chain_err(|| ErrorKind::FailedToInitMonitor)?;
Ok(UdevBackend {
_handler: ::std::marker::PhantomData,
@ -165,10 +177,7 @@ impl<H: DrmHandler<SessionFdDrmDevice> + 'static, S: Session + 'static, T: UdevH
let fd = device.as_raw_fd();
drop(device);
if let Err(err) = self.session.close(fd) {
warn!(
self.logger,
"Failed to close device. Error: {:?}. Ignoring", err
);
warn!(self.logger, "Failed to close device. Error: {:?}. Ignoring", err);
};
}
info!(self.logger, "All devices closed");
@ -176,11 +185,12 @@ impl<H: DrmHandler<SessionFdDrmDevice> + 'static, S: Session + 'static, T: UdevH
}
impl<
H: DrmHandler<SessionFdDrmDevice> + 'static,
S: Session + 'static,
T: UdevHandler<H> + 'static,
Data: 'static,
> Drop for UdevBackend<H, S, T, Data> {
H: DrmHandler<SessionFdDrmDevice> + 'static,
S: Session + 'static,
T: UdevHandler<H> + 'static,
Data: 'static,
> Drop for UdevBackend<H, S, T, Data>
{
fn drop(&mut self) {
self.close();
}
@ -188,16 +198,26 @@ impl<
/// `SessionObserver` linked to the `UdevBackend` it was created from.
pub struct UdevBackendObserver {
devices: Weak<RefCell<HashMap<dev_t, (Source<Generic<EventedRawFd>>, Rc<RefCell<DrmDevice<SessionFdDrmDevice>>>)>>>,
devices: Weak<
RefCell<
HashMap<
dev_t,
(
Source<Generic<EventedRawFd>>,
Rc<RefCell<DrmDevice<SessionFdDrmDevice>>>,
),
>,
>,
>,
logger: ::slog::Logger,
}
impl<
H: DrmHandler<SessionFdDrmDevice> + 'static,
S: Session + 'static,
T: UdevHandler<H> + 'static,
Data: 'static,
> AsSessionObserver<UdevBackendObserver> for UdevBackend<H, S, T, Data>
H: DrmHandler<SessionFdDrmDevice> + 'static,
S: Session + 'static,
T: UdevHandler<H> + 'static,
Data: 'static,
> AsSessionObserver<UdevBackendObserver> for UdevBackend<H, S, T, Data>
{
fn observer(&mut self) -> UdevBackendObserver {
UdevBackendObserver {
@ -243,12 +263,9 @@ where
let handle = udev.handle.clone();
let mut source = Generic::from_raw_fd(fd);
source.set_interest(Ready::readable());
handle.insert_source(
source,
move |_, _| {
udev.process_events();
}
)
handle.insert_source(source, move |_, _| {
udev.process_events();
})
}
impl<H, S, T, Data> UdevBackend<H, S, T, Data>
@ -256,7 +273,7 @@ where
H: DrmHandler<SessionFdDrmDevice> + 'static,
T: UdevHandler<H> + 'static,
S: Session + 'static,
Data: 'static
Data: 'static,
{
fn process_events(&mut self) {
let events = self.monitor.clone().collect::<Vec<Event>>();
@ -272,7 +289,8 @@ where
let logger = self.logger.clone();
match self.session.open(
path,
fcntl::OFlag::O_RDWR | fcntl::OFlag::O_CLOEXEC
fcntl::OFlag::O_RDWR
| fcntl::OFlag::O_CLOEXEC
| fcntl::OFlag::O_NOCTTY
| fcntl::OFlag::O_NONBLOCK,
) {
@ -294,9 +312,7 @@ where
Err(err) => {
warn!(
self.logger,
"Failed to initialize device {:?}. Error: {}. Skipping",
path,
err
"Failed to initialize device {:?}. Error: {}. Skipping", path, err
);
continue;
}
@ -304,35 +320,27 @@ where
};
let fd = device.as_raw_fd();
match self.handler.device_added(&mut device) {
Some(drm_handler) => {
match drm_device_bind(&self.handle, device, drm_handler) {
Ok(fd_event_source) => {
self.devices.borrow_mut().insert(devnum, fd_event_source);
}
Err((err, mut device)) => {
Some(drm_handler) => match drm_device_bind(&self.handle, device, drm_handler) {
Ok(fd_event_source) => {
self.devices.borrow_mut().insert(devnum, fd_event_source);
}
Err((err, mut device)) => {
warn!(self.logger, "Failed to bind device. Error: {:?}.", err);
self.handler.device_removed(&mut device);
drop(device);
if let Err(err) = self.session.close(fd) {
warn!(
self.logger,
"Failed to bind device. Error: {:?}.", err
);
self.handler.device_removed(&mut device);
drop(device);
if let Err(err) = self.session.close(fd) {
warn!(
self.logger,
"Failed to close dropped device. Error: {:?}. Ignoring", err
);
};
}
};
}
}
},
None => {
self.handler.device_removed(&mut device);
drop(device);
if let Err(err) = self.session.close(fd) {
warn!(
self.logger,
"Failed to close unused device. Error: {:?}", err
);
warn!(self.logger, "Failed to close unused device. Error: {:?}", err);
}
}
};
@ -342,9 +350,7 @@ where
EventType::Remove => {
info!(self.logger, "Device Remove");
if let Some(devnum) = event.devnum() {
if let Some((fd_event_source, device)) =
self.devices.borrow_mut().remove(&devnum)
{
if let Some((fd_event_source, device)) = self.devices.borrow_mut().remove(&devnum) {
fd_event_source.remove();
let mut device = Rc::try_unwrap(device)
.unwrap_or_else(|_| unreachable!())
@ -429,7 +435,8 @@ pub fn primary_gpu<S: AsRef<str>>(context: &Context, seat: S) -> UdevResult<Opti
if device
.property_value("ID_SEAT")
.map(|x| x.to_os_string())
.unwrap_or(OsString::from("seat0")) == *seat.as_ref()
.unwrap_or(OsString::from("seat0"))
== *seat.as_ref()
{
if let Some(pci) = device.parent_with_subsystem(Path::new("pci"))? {
if let Some(id) = pci.attribute_value("boot_vga") {
@ -458,9 +465,9 @@ pub fn all_gpus<S: AsRef<str>>(context: &Context, seat: S) -> UdevResult<Vec<Pat
device
.property_value("ID_SEAT")
.map(|x| x.to_os_string())
.unwrap_or(OsString::from("seat0")) == *seat.as_ref()
})
.flat_map(|device| device.devnode().map(PathBuf::from))
.unwrap_or(OsString::from("seat0"))
== *seat.as_ref()
}).flat_map(|device| device.devnode().map(PathBuf::from))
.collect())
}

106
src/backend/winit.rs
View File

@ -1,16 +1,18 @@
//! Implementation of backend traits for types provided by `winit`
use backend::graphics::GraphicsBackend;
use backend::graphics::egl::{EGLContext, EGLGraphicsBackend, EGLSurface, PixelFormat, SwapBuffersError};
use backend::graphics::egl::context::GlAttributes;
use backend::graphics::egl::error as egl_error;
use backend::graphics::egl::error::Result as EGLResult;
use backend::graphics::egl::native;
use backend::graphics::egl::wayland::{EGLDisplay, EGLWaylandExtensions};
use backend::input::{Axis, AxisSource, Event as BackendEvent, InputBackend, InputHandler, KeyState,
KeyboardKeyEvent, MouseButton, MouseButtonState, PointerAxisEvent, PointerButtonEvent,
PointerMotionAbsoluteEvent, Seat, SeatCapabilities, TouchCancelEvent, TouchDownEvent,
TouchMotionEvent, TouchSlot, TouchUpEvent, UnusedEvent};
use backend::graphics::egl::{EGLContext, EGLGraphicsBackend, EGLSurface, PixelFormat, SwapBuffersError};
use backend::graphics::GraphicsBackend;
use backend::input::{
Axis, AxisSource, Event as BackendEvent, InputBackend, InputHandler, KeyState, KeyboardKeyEvent,
MouseButton, MouseButtonState, PointerAxisEvent, PointerButtonEvent, PointerMotionAbsoluteEvent, Seat,
SeatCapabilities, TouchCancelEvent, TouchDownEvent, TouchMotionEvent, TouchSlot, TouchUpEvent,
UnusedEvent,
};
use nix::libc::c_void;
use std::cmp;
use std::error;
@ -19,8 +21,10 @@ use std::rc::Rc;
use std::time::Instant;
use wayland_client::egl as wegl;
use wayland_server::Display;
use winit::{ElementState, Event, EventsLoop, KeyboardInput, MouseButton as WinitMouseButton, MouseCursor,
MouseScrollDelta, Touch, TouchPhase, Window as WinitWindow, WindowBuilder, WindowEvent};
use winit::{
ElementState, Event, EventsLoop, KeyboardInput, MouseButton as WinitMouseButton, MouseCursor,
MouseScrollDelta, Touch, TouchPhase, Window as WinitWindow, WindowBuilder, WindowEvent,
};
error_chain! {
errors {
@ -136,9 +140,7 @@ where
info!(log, "Initializing a winit backend");
let events_loop = EventsLoop::new();
let winit_window = builder
.build(&events_loop)
.chain_err(|| ErrorKind::InitFailed)?;
let winit_window = builder.build(&events_loop).chain_err(|| ErrorKind::InitFailed)?;
debug!(log, "Window created");
let reqs = Default::default();
@ -367,24 +369,16 @@ impl PointerMotionAbsoluteEvent for WinitMouseMovedEvent {
fn x_transformed(&self, width: u32) -> u32 {
cmp::max(
(self.x * width as f64
/ self.window
.window()
.get_inner_size()
.unwrap_or((width, 0))
.0 as f64) as i32,
(self.x * width as f64 / self.window.window().get_inner_size().unwrap_or((width, 0)).0 as f64)
as i32,
0,
) as u32
}
fn y_transformed(&self, height: u32) -> u32 {
cmp::max(
(self.y * height as f64
/ self.window
.window()
.get_inner_size()
.unwrap_or((0, height))
.1 as f64) as i32,
(self.y * height as f64 / self.window.window().get_inner_size().unwrap_or((0, height)).1 as f64)
as i32,
0,
) as u32
}
@ -483,11 +477,7 @@ impl TouchDownEvent for WinitTouchStartedEvent {
fn x_transformed(&self, width: u32) -> u32 {
cmp::min(
self.location.0 as i32 * width as i32
/ self.window
.window()
.get_inner_size()
.unwrap_or((width, 0))
.0 as i32,
/ self.window.window().get_inner_size().unwrap_or((width, 0)).0 as i32,
0,
) as u32
}
@ -495,11 +485,7 @@ impl TouchDownEvent for WinitTouchStartedEvent {
fn y_transformed(&self, height: u32) -> u32 {
cmp::min(
self.location.1 as i32 * height as i32
/ self.window
.window()
.get_inner_size()
.unwrap_or((0, height))
.1 as i32,
/ self.window.window().get_inner_size().unwrap_or((0, height)).1 as i32,
0,
) as u32
}
@ -534,21 +520,11 @@ impl TouchMotionEvent for WinitTouchMovedEvent {
}
fn x_transformed(&self, width: u32) -> u32 {
self.location.0 as u32 * width
/ self.window
.window()
.get_inner_size()
.unwrap_or((width, 0))
.0
self.location.0 as u32 * width / self.window.window().get_inner_size().unwrap_or((width, 0)).0
}
fn y_transformed(&self, height: u32) -> u32 {
self.location.1 as u32 * height
/ self.window
.window()
.get_inner_size()
.unwrap_or((0, height))
.1
self.location.1 as u32 * height / self.window.window().get_inner_size().unwrap_or((0, height)).1
}
}
@ -644,11 +620,7 @@ impl InputBackend for WinitInputBackend {
fn clear_handler(&mut self) {
if let Some(mut handler) = self.handler.take() {
trace!(
self.logger,
"Calling on_seat_destroyed with {:?}",
self.seat
);
trace!(self.logger, "Calling on_seat_destroyed with {:?}", self.seat);
handler.on_seat_destroyed(&self.seat);
}
info!(self.logger, "Removing input handler");
@ -714,10 +686,7 @@ impl InputBackend for WinitInputBackend {
}
(
WindowEvent::KeyboardInput {
input:
KeyboardInput {
scancode, state, ..
},
input: KeyboardInput { scancode, state, .. },
..
},
Some(handler),
@ -729,11 +698,7 @@ impl InputBackend for WinitInputBackend {
*key_counter = key_counter.checked_sub(1).unwrap_or(0)
}
};
trace!(
logger,
"Calling on_keyboard_key with {:?}",
(scancode, state)
);
trace!(logger, "Calling on_keyboard_key with {:?}", (scancode, state));
handler.on_keyboard_key(
seat,
WinitKeyboardInputEvent {
@ -744,13 +709,7 @@ impl InputBackend for WinitInputBackend {
},
)
}
(
WindowEvent::CursorMoved {
position: (x, y), ..
},
Some(handler),
_,
) => {
(WindowEvent::CursorMoved { position: (x, y), .. }, Some(handler), _) => {
trace!(logger, "Calling on_pointer_move_absolute with {:?}", (x, y));
handler.on_pointer_move_absolute(
seat,
@ -768,19 +727,8 @@ impl InputBackend for WinitInputBackend {
handler.on_pointer_axis(seat, event);
}
(WindowEvent::MouseInput { state, button, .. }, Some(handler), _) => {
trace!(
logger,
"Calling on_pointer_button with {:?}",
(button, state)
);
handler.on_pointer_button(
seat,
WinitMouseInputEvent {
time,
button,
state,
},
)
trace!(logger, "Calling on_pointer_button with {:?}", (button, state));
handler.on_pointer_button(seat, WinitMouseInputEvent { time, button, state })
}
(
WindowEvent::Touch(Touch {

2
src/lib.rs
View File

@ -49,8 +49,8 @@ extern crate error_chain;
extern crate lazy_static;
pub mod backend;
pub mod wayland;
pub mod utils;
pub mod wayland;
#[cfg(feature = "xwayland")]
pub mod xwayland;

2
src/wayland/mod.rs
View File

@ -15,5 +15,5 @@
pub mod compositor;
pub mod output;
pub mod seat;
pub mod shm;
pub mod shell;
pub mod shm;