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

compositor: rework roles

This commit is contained in:
Victor Berger 2017-09-03 19:53:29 +02:00
parent 571d2ed511
commit 5c46ba73e9
9 changed files with 626 additions and 227 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
examples/helpers/mod.rs
View File

@ -2,4 +2,4 @@ mod shell;
mod glium;
pub use self::glium::GliumDrawer;
pub use self::shell::WlShellStubHandler;
pub use self::shell::{ShellSurfaceRole, WlShellStubHandler};

56
examples/helpers/shell.rs
View File

@ -1,6 +1,7 @@
use smithay::compositor::{CompositorToken, Handler as CompositorHandler};
use smithay::compositor::roles::{Role, RoleType};
use wayland_server::{Client, EventLoopHandle, GlobalHandler, Init, Resource};
use wayland_server::protocol::{wl_shell, wl_shell_surface, wl_surface};
@ -10,14 +11,17 @@ use wayland_server::protocol::{wl_shell, wl_shell_surface, wl_surface};
/// as well as the roles associated to them.
///
/// That's it.
pub struct WlShellStubHandler<U, H> {
pub struct WlShellStubHandler<U, R, H> {
my_id: Option<usize>,
token: CompositorToken<U, H>,
token: CompositorToken<U, R, H>,
surfaces: Vec<(wl_shell_surface::WlShellSurface, wl_surface::WlSurface)>,
}
impl<U, H> WlShellStubHandler<U, H> {
pub fn new(compositor_token: CompositorToken<U, H>) -> WlShellStubHandler<U, H> {
#[derive(Default)]
pub struct ShellSurfaceRole;
impl<U, R, H> WlShellStubHandler<U, R, H> {
pub fn new(compositor_token: CompositorToken<U, R, H>) -> WlShellStubHandler<U, R, H> {
WlShellStubHandler {
my_id: None,
token: compositor_token,
@ -30,28 +34,42 @@ impl<U, H> WlShellStubHandler<U, H> {
}
}
impl<U, H> Init for WlShellStubHandler<U, H> {
impl<U, R, H> Init for WlShellStubHandler<U, R, H> {
fn init(&mut self, evqh: &mut EventLoopHandle, index: usize) {
self.my_id = Some(index)
}
}
impl<U, H> GlobalHandler<wl_shell::WlShell> for WlShellStubHandler<U, H>
where U: Send + 'static,
H: CompositorHandler<U> + Send + 'static
impl<U, R, H> GlobalHandler<wl_shell::WlShell> for WlShellStubHandler<U, R, H>
where
U: Send + 'static,
R: RoleType
+ Role<ShellSurfaceRole>
+ Send
+ 'static,
H: CompositorHandler<U, R>
+ Send
+ 'static,
{
fn bind(&mut self, evqh: &mut EventLoopHandle, client: &Client, global: wl_shell::WlShell) {
evqh.register::<_, Self>(&global,
self.my_id
.expect("WlShellStubHandler was not properly initialized."));
evqh.register::<_, Self>(
&global,
self.my_id.expect(
"WlShellStubHandler was not properly initialized.",
),
);
}
}
impl<U, H> wl_shell::Handler for WlShellStubHandler<U, H>
impl<U, R, H> wl_shell::Handler for WlShellStubHandler<U, R, H>
where
U: Send + 'static,
H: CompositorHandler<U> + Send + 'static,
R: RoleType
+ Role<ShellSurfaceRole>
+ Send
+ 'static,
H: CompositorHandler<U, R> + Send + 'static,
{
fn get_shell_surface(&mut self, evqh: &mut EventLoopHandle, client: &Client,
resource: &wl_shell::WlShell, id: wl_shell_surface::WlShellSurface,
@ -59,7 +77,7 @@ where
let surface = surface.clone().expect(
"WlShellStubHandler can only manage surfaces managed by Smithay's CompositorHandler.",
);
if self.token.give_role(&surface).is_err() {
if self.token.give_role::<ShellSurfaceRole>(&surface).is_err() {
// This surface already has a role, and thus cannot be given one!
resource.post_error(
wl_shell::Error::Role as u32,
@ -72,13 +90,15 @@ where
}
}
server_declare_handler!(WlShellStubHandler<U: [Send], H: [CompositorHandler<U>, Send]>, wl_shell::Handler, wl_shell::WlShell);
server_declare_handler!(WlShellStubHandler<U: [Send], R: [RoleType, Role<ShellSurfaceRole>, Send], H: [CompositorHandler<U, R>, Send]>, wl_shell::Handler, wl_shell::WlShell);
impl<U, H> wl_shell_surface::Handler for WlShellStubHandler<U, H>
impl<U, R, H> wl_shell_surface::Handler for WlShellStubHandler<U, R, H>
where
U: Send + 'static,
H: CompositorHandler<U> + Send + 'static,
H: CompositorHandler<U, R>
+ Send
+ 'static,
{
}
server_declare_handler!(WlShellStubHandler<U: [Send], H: [CompositorHandler<U>, Send]>, wl_shell_surface::Handler, wl_shell_surface::WlShellSurface);
server_declare_handler!(WlShellStubHandler<U: [Send], R: [Send], H: [CompositorHandler<U, R>, Send]>, wl_shell_surface::Handler, wl_shell_surface::WlShellSurface);

64
examples/simple.rs
View File

@ -1,5 +1,6 @@
#[macro_use(server_declare_handler)]
extern crate wayland_server;
#[macro_use(define_roles)]
extern crate smithay;
#[macro_use]
extern crate glium;
@ -13,18 +14,21 @@ mod helpers;
use glium::Surface;
use helpers::{GliumDrawer, WlShellStubHandler};
use slog::*;
use helpers::{GliumDrawer, ShellSurfaceRole, WlShellStubHandler};
use slog::{Drain, Logger};
use smithay::backend::graphics::glium::IntoGlium;
use smithay::backend::input::InputBackend;
use smithay::backend::winit;
use smithay::compositor::{self, CompositorHandler, CompositorToken, TraversalAction};
use smithay::compositor::{self, CompositorHandler, CompositorToken, SubsurfaceRole, TraversalAction};
use smithay::compositor::roles::Role;
use smithay::shm::{BufferData, ShmGlobal, ShmToken};
use wayland_server::{Client, EventLoopHandle, Liveness, Resource};
use wayland_server::protocol::{wl_compositor, wl_shell, wl_shm, wl_subcompositor, wl_surface};
define_roles!(Roles => [ ShellSurface, ShellSurfaceRole ] );
struct SurfaceHandler {
shm_token: ShmToken,
}
@ -34,9 +38,9 @@ struct SurfaceData {
buffer: Option<(Vec<u8>, (u32, u32))>,
}
impl compositor::Handler<SurfaceData> for SurfaceHandler {
impl compositor::Handler<SurfaceData, Roles> for SurfaceHandler {
fn commit(&mut self, evlh: &mut EventLoopHandle, client: &Client, surface: &wl_surface::WlSurface,
token: CompositorToken<SurfaceData, SurfaceHandler>) {
token: CompositorToken<SurfaceData, Roles, SurfaceHandler>) {
// we retrieve the contents of the associated buffer and copy it
token.with_surface_data(surface, |attributes| {
match attributes.buffer.take() {
@ -67,6 +71,8 @@ impl compositor::Handler<SurfaceData> for SurfaceHandler {
}
}
type MyCompositorHandler = CompositorHandler<SurfaceData, Roles, SurfaceHandler>;
fn main() {
// A logger facility, here we use the terminal for this example
let log = Logger::root(
@ -97,22 +103,19 @@ fn main() {
/*
* Initialize the compositor global
*/
let compositor_handler_id = event_loop.add_handler_with_init(CompositorHandler::<SurfaceData, _>::new(
let compositor_handler_id = event_loop.add_handler_with_init(MyCompositorHandler::new(
SurfaceHandler { shm_token: shm_token.clone() },
log.clone(),
));
// register it to handle wl_compositor and wl_subcompositor
event_loop.register_global::<wl_compositor::WlCompositor, MyCompositorHandler>(compositor_handler_id, 4);
event_loop
.register_global::<wl_compositor::WlCompositor, CompositorHandler<SurfaceData, SurfaceHandler>>(
compositor_handler_id,
4,
);
event_loop.register_global::<wl_subcompositor::WlSubcompositor, CompositorHandler<SurfaceData,SurfaceHandler>>(compositor_handler_id, 1);
.register_global::<wl_subcompositor::WlSubcompositor, MyCompositorHandler>(compositor_handler_id, 1);
// retrieve the tokens
let compositor_token = {
let state = event_loop.state();
state
.get_handler::<CompositorHandler<SurfaceData, SurfaceHandler>>(compositor_handler_id)
.get_handler::<MyCompositorHandler>(compositor_handler_id)
.get_token()
};
@ -121,7 +124,7 @@ fn main() {
*/
let shell_handler_id =
event_loop.add_handler_with_init(WlShellStubHandler::new(compositor_token.clone()));
event_loop.register_global::<wl_shell::WlShell, WlShellStubHandler<SurfaceData, SurfaceHandler>>(
event_loop.register_global::<wl_shell::WlShell, WlShellStubHandler<SurfaceData, Roles, SurfaceHandler>>(
shell_handler_id,
1,
);
@ -150,31 +153,30 @@ fn main() {
let state = event_loop.state();
for &(_, ref surface) in
state
.get_handler::<WlShellStubHandler<SurfaceData, SurfaceHandler>>(shell_handler_id)
.get_handler::<WlShellStubHandler<SurfaceData, Roles, SurfaceHandler>>(shell_handler_id)
.surfaces()
{
if surface.status() != Liveness::Alive {
continue;
}
// this surface is a root of a subsurface tree that needs to be drawn
compositor_token.with_surface_tree(
surface,
(100, 100),
|surface, attributes, &(mut x, mut y)| {
if let Some((ref contents, (w, h))) = attributes.user_data.buffer {
// there is actually something to draw !
if let Some(ref subdata) = attributes.subsurface_attributes {
x += subdata.x;
y += subdata.y;
}
drawer.draw(&mut frame, contents, (w, h), (x, y), screen_dimensions);
TraversalAction::DoChildren((x, y))
} else {
// we are not display, so our children are neither
TraversalAction::SkipChildren
compositor_token.with_surface_tree(surface, (100, 100), |surface,
attributes,
role,
&(mut x, mut y)| {
if let Some((ref contents, (w, h))) = attributes.user_data.buffer {
// there is actually something to draw !
if let Ok(subdata) = Role::<SubsurfaceRole>::data(role) {
x += subdata.x;
y += subdata.y;
}
},
);
drawer.draw(&mut frame, contents, (w, h), (x, y), screen_dimensions);
TraversalAction::DoChildren((x, y))
} else {
// we are not display, so our children are neither
TraversalAction::SkipChildren
}
});
}
}
frame.finish().unwrap();

23
src/compositor/global.rs
View File

@ -1,25 +1,34 @@
use super::{CompositorHandler, Handler as UserHandler};
use super::{CompositorHandler, Handler as UserHandler, Role, RoleType, SubsurfaceRole};
use wayland_server::{Client, EventLoopHandle, GlobalHandler};
use wayland_server::protocol::{wl_compositor, wl_subcompositor};
impl<U: Default, H: UserHandler<U>> GlobalHandler<wl_compositor::WlCompositor> for CompositorHandler<U, H>
where U: Send + 'static,
H: Send + 'static
impl<U, R, H> GlobalHandler<wl_compositor::WlCompositor> for CompositorHandler<U, R, H>
where
U: Default
+ Send
+ 'static,
R: Default
+ Send
+ 'static,
H: UserHandler<U, R>
+ Send
+ 'static,
{
fn bind(&mut self, evlh: &mut EventLoopHandle, _: &Client, global: wl_compositor::WlCompositor) {
debug!(self.log, "New compositor global binded.");
evlh.register::<_, CompositorHandler<U, H>>(&global, self.my_id);
evlh.register::<_, CompositorHandler<U, R, H>>(&global, self.my_id);
}
}
impl<U, H> GlobalHandler<wl_subcompositor::WlSubcompositor> for CompositorHandler<U, H>
impl<U, R, H> GlobalHandler<wl_subcompositor::WlSubcompositor> for CompositorHandler<U, R, H>
where
U: Send + 'static,
R: RoleType + Role<SubsurfaceRole> + Send + 'static,
H: Send + 'static,
{
fn bind(&mut self, evlh: &mut EventLoopHandle, _: &Client, global: wl_subcompositor::WlSubcompositor) {
debug!(self.log, "New subcompositor global binded.");
evlh.register::<_, CompositorHandler<U, H>>(&global, self.my_id);
evlh.register::<_, CompositorHandler<U, R, H>>(&global, self.my_id);
}
}

114
src/compositor/handlers.rs
View File

@ -1,50 +1,58 @@
use super::{CompositorHandler, Damage, Handler as UserHandler, Rectangle, RectangleKind,
SubsurfaceAttributes};
use super::{CompositorHandler, Damage, Handler as UserHandler, Rectangle, RectangleKind, Role, RoleType,
SubsurfaceRole};
use super::region::RegionData;
use super::tree::{Location, SurfaceData};
use wayland_server::{Client, Destroy, EventLoopHandle, Liveness, Resource};
use wayland_server::protocol::{wl_buffer, wl_callback, wl_compositor, wl_output, wl_region,
wl_subcompositor, wl_subsurface, wl_surface};
struct CompositorDestructor<U> {
struct CompositorDestructor<U, R> {
_t: ::std::marker::PhantomData<U>,
_r: ::std::marker::PhantomData<R>,
}
/*
* wl_compositor
*/
impl<U, H> wl_compositor::Handler for CompositorHandler<U, H>
impl<U, R, H> wl_compositor::Handler for CompositorHandler<U, R, H>
where
U: Default + Send + 'static,
H: UserHandler<U> + Send + 'static,
R: Default + Send + 'static,
H: UserHandler<U, R> + Send + 'static,
{
fn create_surface(&mut self, evqh: &mut EventLoopHandle, _: &Client, _: &wl_compositor::WlCompositor,
id: wl_surface::WlSurface) {
trace!(self.log, "New surface created.");
unsafe { SurfaceData::<U>::init(&id) };
evqh.register_with_destructor::<_, CompositorHandler<U, H>, CompositorDestructor<U>>(&id, self.my_id);
unsafe { SurfaceData::<U, R>::init(&id) };
evqh.register_with_destructor::<_, CompositorHandler<U, R, H>, CompositorDestructor<U, R>>(
&id,
self.my_id,
);
}
fn create_region(&mut self, evqh: &mut EventLoopHandle, _: &Client, _: &wl_compositor::WlCompositor,
id: wl_region::WlRegion) {
trace!(self.log, "New region created.");
unsafe { RegionData::init(&id) };
evqh.register_with_destructor::<_, CompositorHandler<U, H>, CompositorDestructor<U>>(&id, self.my_id);
evqh.register_with_destructor::<_, CompositorHandler<U, R, H>, CompositorDestructor<U, R>>(
&id,
self.my_id,
);
}
}
server_declare_handler!(CompositorHandler<U: [Default, Send], H: [UserHandler<U>, Send]>, wl_compositor::Handler, wl_compositor::WlCompositor);
server_declare_handler!(CompositorHandler<U: [Default, Send], R: [Default, Send], H: [UserHandler<U, R>, Send]>, wl_compositor::Handler, wl_compositor::WlCompositor);
/*
* wl_surface
*/
impl<U, H: UserHandler<U>> wl_surface::Handler for CompositorHandler<U, H> {
impl<U, R, H: UserHandler<U, R>> wl_surface::Handler for CompositorHandler<U, R, H> {
fn attach(&mut self, _: &mut EventLoopHandle, _: &Client, surface: &wl_surface::WlSurface,
buffer: Option<&wl_buffer::WlBuffer>, x: i32, y: i32) {
trace!(self.log, "Attaching buffer to surface.");
unsafe {
SurfaceData::<U>::with_data(surface, |d| {
SurfaceData::<U, R>::with_data(surface, |d| {
d.buffer = Some(buffer.map(|b| (b.clone_unchecked(), (x, y))))
});
}
@ -53,7 +61,7 @@ impl<U, H: UserHandler<U>> wl_surface::Handler for CompositorHandler<U, H> {
y: i32, width: i32, height: i32) {
trace!(self.log, "Registering damage to surface.");
unsafe {
SurfaceData::<U>::with_data(surface, |d| {
SurfaceData::<U, R>::with_data(surface, |d| {
d.damage = Damage::Surface(Rectangle {
x,
y,
@ -74,7 +82,7 @@ impl<U, H: UserHandler<U>> wl_surface::Handler for CompositorHandler<U, H> {
trace!(self.log, "Setting surface opaque region.");
unsafe {
let attributes = region.map(|r| RegionData::get_attributes(r));
SurfaceData::<U>::with_data(surface, |d| d.opaque_region = attributes);
SurfaceData::<U, R>::with_data(surface, |d| d.opaque_region = attributes);
}
}
fn set_input_region(&mut self, _: &mut EventLoopHandle, _: &Client, surface: &wl_surface::WlSurface,
@ -82,7 +90,7 @@ impl<U, H: UserHandler<U>> wl_surface::Handler for CompositorHandler<U, H> {
trace!(self.log, "Setting surface input region.");
unsafe {
let attributes = region.map(|r| RegionData::get_attributes(r));
SurfaceData::<U>::with_data(surface, |d| d.input_region = attributes);
SurfaceData::<U, R>::with_data(surface, |d| d.input_region = attributes);
}
}
fn commit(&mut self, evlh: &mut EventLoopHandle, client: &Client, surface: &wl_surface::WlSurface) {
@ -94,14 +102,14 @@ impl<U, H: UserHandler<U>> wl_surface::Handler for CompositorHandler<U, H> {
surface: &wl_surface::WlSurface, transform: wl_output::Transform) {
trace!(self.log, "Setting surface's buffer transform.");
unsafe {
SurfaceData::<U>::with_data(surface, |d| d.buffer_transform = transform);
SurfaceData::<U, R>::with_data(surface, |d| d.buffer_transform = transform);
}
}
fn set_buffer_scale(&mut self, _: &mut EventLoopHandle, _: &Client, surface: &wl_surface::WlSurface,
scale: i32) {
trace!(self.log, "Setting surface's buffer scale.");
unsafe {
SurfaceData::<U>::with_data(surface, |d| d.buffer_scale = scale);
SurfaceData::<U, R>::with_data(surface, |d| d.buffer_scale = scale);
}
}
fn damage_buffer(&mut self, _: &mut EventLoopHandle, _: &Client, surface: &wl_surface::WlSurface,
@ -111,7 +119,7 @@ impl<U, H: UserHandler<U>> wl_surface::Handler for CompositorHandler<U, H> {
"Registering damage to surface (buffer coordinates)."
);
unsafe {
SurfaceData::<U>::with_data(surface, |d| {
SurfaceData::<U, R>::with_data(surface, |d| {
d.damage = Damage::Buffer(Rectangle {
x,
y,
@ -123,11 +131,11 @@ impl<U, H: UserHandler<U>> wl_surface::Handler for CompositorHandler<U, H> {
}
}
server_declare_handler!(CompositorHandler<U:[], H: [UserHandler<U>]>, wl_surface::Handler, wl_surface::WlSurface);
server_declare_handler!(CompositorHandler<U:[], R: [], H: [UserHandler<U, R>]>, wl_surface::Handler, wl_surface::WlSurface);
impl<U> Destroy<wl_surface::WlSurface> for CompositorDestructor<U> {
impl<U, R> Destroy<wl_surface::WlSurface> for CompositorDestructor<U, R> {
fn destroy(surface: &wl_surface::WlSurface) {
unsafe { SurfaceData::<U>::cleanup(surface) }
unsafe { SurfaceData::<U, R>::cleanup(surface) }
}
}
@ -135,7 +143,7 @@ impl<U> Destroy<wl_surface::WlSurface> for CompositorDestructor<U> {
* wl_region
*/
impl<U, H> wl_region::Handler for CompositorHandler<U, H> {
impl<U, R, H> wl_region::Handler for CompositorHandler<U, R, H> {
fn add(&mut self, _: &mut EventLoopHandle, _: &Client, region: &wl_region::WlRegion, x: i32, y: i32,
width: i32, height: i32) {
trace!(self.log, "Adding rectangle to a region.");
@ -170,9 +178,9 @@ impl<U, H> wl_region::Handler for CompositorHandler<U, H> {
}
}
server_declare_handler!(CompositorHandler<U: [], H: []>, wl_region::Handler, wl_region::WlRegion);
server_declare_handler!(CompositorHandler<U: [], R: [], H: []>, wl_region::Handler, wl_region::WlRegion);
impl<U> Destroy<wl_region::WlRegion> for CompositorDestructor<U> {
impl<U, R> Destroy<wl_region::WlRegion> for CompositorDestructor<U, R> {
fn destroy(region: &wl_region::WlRegion) {
unsafe { RegionData::cleanup(region) };
}
@ -182,52 +190,63 @@ impl<U> Destroy<wl_region::WlRegion> for CompositorDestructor<U> {
* wl_subcompositor
*/
impl<U, H> wl_subcompositor::Handler for CompositorHandler<U, H>
impl<U, R, H> wl_subcompositor::Handler for CompositorHandler<U, R, H>
where
U: Send + 'static,
R: RoleType
+ Role<SubsurfaceRole>
+ Send
+ 'static,
H: Send + 'static,
{
fn get_subsurface(&mut self, evqh: &mut EventLoopHandle, _: &Client,
resource: &wl_subcompositor::WlSubcompositor, id: wl_subsurface::WlSubsurface,
surface: &wl_surface::WlSurface, parent: &wl_surface::WlSurface) {
trace!(self.log, "Creating new subsurface.");
if let Err(()) = unsafe { SurfaceData::<U>::set_parent(surface, parent) } {
resource.post_error(wl_subcompositor::Error::BadSurface as u32, "Surface already has a role.".into());
return
if let Err(()) = unsafe { SurfaceData::<U, R>::set_parent(surface, parent) } {
resource.post_error(
wl_subcompositor::Error::BadSurface as u32,
"Surface already has a role.".into(),
);
return;
}
id.set_user_data(Box::into_raw(
Box::new(unsafe { surface.clone_unchecked() }),
) as *mut _);
unsafe {
SurfaceData::<U>::with_data(surface, |d| {
d.subsurface_attributes = Some(Default::default())
});
}
evqh.register_with_destructor::<_, CompositorHandler<U, H>, CompositorDestructor<U>>(&id, self.my_id);
evqh.register_with_destructor::<_, CompositorHandler<U, R, H>, CompositorDestructor<U, R>>(
&id,
self.my_id,
);
}
}
server_declare_handler!(CompositorHandler<U: [Send], H: [Send]>, wl_subcompositor::Handler, wl_subcompositor::WlSubcompositor);
server_declare_handler!(CompositorHandler<U: [Send], R: [RoleType, Role<SubsurfaceRole>, Send], H: [Send]>, wl_subcompositor::Handler, wl_subcompositor::WlSubcompositor);
/*
* wl_subsurface
*/
unsafe fn with_subsurface_attributes<U, F>(subsurface: &wl_subsurface::WlSubsurface, f: F)
unsafe fn with_subsurface_attributes<U, R, F>(subsurface: &wl_subsurface::WlSubsurface, f: F)
where
F: FnOnce(&mut SubsurfaceAttributes),
F: FnOnce(&mut SubsurfaceRole),
R: RoleType + Role<SubsurfaceRole>,
{
let ptr = subsurface.get_user_data();
let surface = &*(ptr as *mut wl_surface::WlSurface);
SurfaceData::<U>::with_data(surface, |d| f(d.subsurface_attributes.as_mut().unwrap()));
SurfaceData::<U, R>::with_role_data::<SubsurfaceRole, _, _>(surface, |d| f(d)).expect(
"The surface does not have a subsurface role while it has a wl_subsurface?!",
);
}
impl<U, H> wl_subsurface::Handler for CompositorHandler<U, H> {
impl<U, R, H> wl_subsurface::Handler for CompositorHandler<U, R, H>
where
R: RoleType + Role<SubsurfaceRole>,
{
fn set_position(&mut self, _: &mut EventLoopHandle, _: &Client,
subsurface: &wl_subsurface::WlSubsurface, x: i32, y: i32) {
trace!(self.log, "Setting subsurface position.");
unsafe {
with_subsurface_attributes::<U, _>(subsurface, |attrs| {
with_subsurface_attributes::<U, R, _>(subsurface, |attrs| {
attrs.x = x;
attrs.y = y;
});
@ -239,7 +258,7 @@ impl<U, H> wl_subsurface::Handler for CompositorHandler<U, H> {
unsafe {
let ptr = subsurface.get_user_data();
let surface = &*(ptr as *mut wl_surface::WlSurface);
if let Err(()) = SurfaceData::<U>::reorder(surface, Location::After, sibling) {
if let Err(()) = SurfaceData::<U, R>::reorder(surface, Location::After, sibling) {
subsurface.post_error(wl_subsurface::Error::BadSurface as u32, "Provided surface is not a sibling or parent.".into());
}
}
@ -250,7 +269,7 @@ impl<U, H> wl_subsurface::Handler for CompositorHandler<U, H> {
unsafe {
let ptr = subsurface.get_user_data();
let surface = &*(ptr as *mut wl_surface::WlSurface);
if let Err(()) = SurfaceData::<U>::reorder(surface, Location::Before, sibling) {
if let Err(()) = SurfaceData::<U, R>::reorder(surface, Location::Before, sibling) {
subsurface.post_error(wl_subsurface::Error::BadSurface as u32, "Provided surface is not a sibling or parent.".into());
}
}
@ -258,28 +277,29 @@ impl<U, H> wl_subsurface::Handler for CompositorHandler<U, H> {
fn set_sync(&mut self, _: &mut EventLoopHandle, _: &Client, subsurface: &wl_subsurface::WlSubsurface) {
trace!(self.log, "Setting subsurface sync."; "sync_status" => true);
unsafe {
with_subsurface_attributes::<U, _>(subsurface, |attrs| { attrs.sync = true; });
with_subsurface_attributes::<U, R, _>(subsurface, |attrs| { attrs.sync = true; });
}
}
fn set_desync(&mut self, _: &mut EventLoopHandle, _: &Client, subsurface: &wl_subsurface::WlSubsurface) {
trace!(self.log, "Setting subsurface sync."; "sync_status" => false);
unsafe {
with_subsurface_attributes::<U, _>(subsurface, |attrs| { attrs.sync = false; });
with_subsurface_attributes::<U, R, _>(subsurface, |attrs| { attrs.sync = false; });
}
}
}
server_declare_handler!(CompositorHandler<U: [], H: []>, wl_subsurface::Handler, wl_subsurface::WlSubsurface);
server_declare_handler!(CompositorHandler<U: [], R: [RoleType, Role<SubsurfaceRole>], H: []>, wl_subsurface::Handler, wl_subsurface::WlSubsurface);
impl<U> Destroy<wl_subsurface::WlSubsurface> for CompositorDestructor<U> {
impl<U, R> Destroy<wl_subsurface::WlSubsurface> for CompositorDestructor<U, R>
where R: RoleType + Role<SubsurfaceRole>
{
fn destroy(subsurface: &wl_subsurface::WlSubsurface) {
let ptr = subsurface.get_user_data();
subsurface.set_user_data(::std::ptr::null_mut());
unsafe {
let surface = Box::from_raw(ptr as *mut wl_surface::WlSurface);
if surface.status() == Liveness::Alive {
SurfaceData::<U>::with_data(&*surface, |d| d.subsurface_attributes = None);
SurfaceData::<U>::unset_parent(&surface);
SurfaceData::<U, R>::unset_parent(&surface);
}
}
}

185
src/compositor/mod.rs
View File

@ -28,7 +28,7 @@
//!
//! ```
//! # extern crate wayland_server;
//! # extern crate smithay;
//! # #[macro_use] extern crate smithay;
//! use wayland_server::protocol::wl_compositor::WlCompositor;
//! use wayland_server::protocol::wl_subcompositor::WlSubcompositor;
//! use smithay::compositor;
@ -41,19 +41,22 @@
//! // whatever you need here
//! }
//!
//! // Declare the roles enum
//! define_roles!(MyRoles);
//!
//! // Define a sub-handler to take care of the events the CompositorHandler does not rack for you
//! struct MyHandler {
//! // whatever you need
//! }
//!
//! // Implement the handler trait for this sub-handler
//! impl compositor::Handler<MyData> for MyHandler {
//! impl compositor::Handler<MyData, MyRoles> for MyHandler {
//! // See the trait documentation for its implementation
//! // A default implementation for each method is provided, that does nothing
//! }
//!
//! // A type alias to shorten things:
//! type MyCompositorHandler = compositor::CompositorHandler<MyData,MyHandler>;
//! type MyCompositorHandler = compositor::CompositorHandler<MyData, MyRoles, MyHandler>;
//!
//! # fn main() {
//! # let (_display, mut event_loop) = wayland_server::create_display();
@ -90,15 +93,20 @@
//! state pending from the client as defined by the protocol for wl_surface, as well as your
//! user-defined type holding any data you need to have associated with a struct. See its
//! documentation for details.
//!
//! This `CompositorToken` also provides access to the metadata associated with the role of the
//! surfaces. See the documentation of the `roles` submodule for a detailed explanation.
mod global;
mod handlers;
mod tree;
mod region;
pub mod roles;
use self::region::RegionData;
pub use self::tree::{RoleStatus, TraversalAction};
use self::roles::{Role, RoleType, WrongRole};
use self::tree::SurfaceData;
pub use self::tree::TraversalAction;
use wayland_server::{Client, EventLoopHandle, Init, resource_is_registered};
use wayland_server::protocol::{wl_buffer, wl_callback, wl_output, wl_region, wl_surface};
@ -159,12 +167,6 @@ pub struct SurfaceAttributes<U> {
/// Hint provided by the client to suggest that only this part
/// of the surface was changed and needs to be redrawn
pub damage: Damage,
/// Subsurface-related attribute
///
/// Is `Some` if this surface is a sub-surface
///
/// **Warning:** Changing this field by yourself can cause panics.
pub subsurface_attributes: Option<SubsurfaceAttributes>,
/// User-controlled data
///
/// This is your field to host whatever you need.
@ -180,14 +182,14 @@ impl<U: Default> Default for SurfaceAttributes<U> {
opaque_region: None,
input_region: None,
damage: Damage::Full,
subsurface_attributes: None,
user_data: Default::default(),
}
}
}
/// Attributes defining the behaviour of a sub-surface relative to its parent
pub struct SubsurfaceAttributes {
#[derive(Copy, Clone, Debug)]
pub struct SubsurfaceRole {
/// Horizontal location of the top-left corner of this sub-surface relative to
/// the top-left corner of its parent
pub x: i32,
@ -202,9 +204,9 @@ pub struct SubsurfaceAttributes {
pub sync: bool,
}
impl Default for SubsurfaceAttributes {
fn default() -> SubsurfaceAttributes {
SubsurfaceAttributes {
impl Default for SubsurfaceRole {
fn default() -> SubsurfaceRole {
SubsurfaceRole {
x: 0,
y: 0,
sync: true,
@ -213,7 +215,7 @@ impl Default for SubsurfaceAttributes {
}
/// Kind of a rectangle part of a region
#[derive(Copy, Clone)]
#[derive(Copy, Clone, Debug)]
pub enum RectangleKind {
/// This rectangle should be added to the region
Add,
@ -223,7 +225,7 @@ pub enum RectangleKind {
}
/// A rectangle defined by its top-left corner and dimensions
#[derive(Copy, Clone)]
#[derive(Copy, Clone, Debug)]
pub struct Rectangle {
/// horizontal position of the top-leftcorner of the rectangle, in surface coordinates
pub x: i32,
@ -242,7 +244,7 @@ pub struct Rectangle {
/// This struct contains an ordered Vec containing the rectangles defining
/// a region. They should be added or substracted in this order to compute the
/// actual contents of the region.
#[derive(Clone)]
#[derive(Clone, Debug)]
pub struct RegionAttributes {
/// List of rectangle part of this region
pub rects: Vec<(RectangleKind, Rectangle)>,
@ -259,25 +261,26 @@ impl Default for RegionAttributes {
/// This token can be cloned at will, and is the entry-point to
/// access data associated with the wl_surface and wl_region managed
/// by the `CompositorGlobal` that provided it.
pub struct CompositorToken<U, H> {
pub struct CompositorToken<U, R, H> {
hid: usize,
_data: ::std::marker::PhantomData<*mut U>,
_role: ::std::marker::PhantomData<*mut R>,
_handler: ::std::marker::PhantomData<*mut H>,
}
unsafe impl<U: Send, H: Send> Send for CompositorToken<U, H> {}
unsafe impl<U: Send, H: Send> Sync for CompositorToken<U, H> {}
unsafe impl<U: Send, R: Send, H: Send> Send for CompositorToken<U, R, H> {}
unsafe impl<U: Send, R: Send, H: Send> Sync for CompositorToken<U, R, H> {}
// we implement them manually because #[derive(..)] would require
// U: Clone and H: Clone ...
impl<U, H> Copy for CompositorToken<U, H> {}
impl<U, H> Clone for CompositorToken<U, H> {
fn clone(&self) -> CompositorToken<U, H> {
impl<U, R, H> Copy for CompositorToken<U, R, H> {}
impl<U, R, H> Clone for CompositorToken<U, R, H> {
fn clone(&self) -> CompositorToken<U, R, H> {
*self
}
}
impl<U: Send + 'static, H: Handler<U> + Send + 'static> CompositorToken<U, H> {
impl<U: Send + 'static, R: Send + 'static, H: Handler<U, R> + Send + 'static> CompositorToken<U, R, H> {
/// Access the data of a surface
///
/// The closure will be called with the contents of the data associated with this surface.
@ -289,32 +292,51 @@ impl<U: Send + 'static, H: Handler<U> + Send + 'static> CompositorToken<U, H> {
F: FnOnce(&mut SurfaceAttributes<U>),
{
assert!(
resource_is_registered::<_, CompositorHandler<U, H>>(surface, self.hid),
resource_is_registered::<_, CompositorHandler<U, R, H>>(surface, self.hid),
"Accessing the data of foreign surfaces is not supported."
);
unsafe {
SurfaceData::<U>::with_data(surface, f);
SurfaceData::<U, R>::with_data(surface, f);
}
}
}
impl<U, R, H> CompositorToken<U, R, H>
where
U: Send + 'static,
R: RoleType + Role<SubsurfaceRole> + Send + 'static,
H: Handler<U, R> + Send + 'static,
{
/// Access the data of a surface tree
///
/// The provided closure is called successively on the surface and all its child subsurfaces,
/// in a depth-first order. This matches the order in which the surfaces are supposed to be
/// drawn: top-most last.
///
/// The arguments provided to the closure are, in this order:
///
/// - The surface object itself
/// - a mutable reference to its surface attribute data
/// - a mutable reference to its role data,
/// - a custom value that is passer in a fold-like maneer, but only from the output of a parent
/// to its children. See `TraversalAction` for details.
///
/// If the surface is not managed by the CompositorGlobal that provided this token, this
/// will panic (having more than one compositor is not supported).
pub fn with_surface_tree<F, T>(&self, surface: &wl_surface::WlSurface, initial: T, f: F) -> Result<(), ()>
where
F: FnMut(&wl_surface::WlSurface, &mut SurfaceAttributes<U>, &T) -> TraversalAction<T>,
F: FnMut(&wl_surface::WlSurface,
&mut SurfaceAttributes<U>,
&mut R,
&T)
-> TraversalAction<T>,
{
assert!(
resource_is_registered::<_, CompositorHandler<U, H>>(surface, self.hid),
resource_is_registered::<_, CompositorHandler<U, R, H>>(surface, self.hid),
"Accessing the data of foreign surfaces is not supported."
);
unsafe {
SurfaceData::<U>::map_tree(surface, initial, f);
SurfaceData::<U, R>::map_tree(surface, initial, f);
}
Ok(())
}
@ -327,10 +349,10 @@ impl<U: Send + 'static, H: Handler<U> + Send + 'static> CompositorToken<U, H> {
/// will panic (having more than one compositor is not supported).
pub fn get_parent(&self, surface: &wl_surface::WlSurface) -> Option<wl_surface::WlSurface> {
assert!(
resource_is_registered::<_, CompositorHandler<U, H>>(surface, self.hid),
resource_is_registered::<_, CompositorHandler<U, R, H>>(surface, self.hid),
"Accessing the data of foreign surfaces is not supported."
);
unsafe { SurfaceData::<U>::get_parent(surface) }
unsafe { SurfaceData::<U, R>::get_parent(surface) }
}
/// Retrieve the children of this surface
@ -339,55 +361,95 @@ impl<U: Send + 'static, H: Handler<U> + Send + 'static> CompositorToken<U, H> {
/// will panic (having more than one compositor is not supported).
pub fn get_children(&self, surface: &wl_surface::WlSurface) -> Vec<wl_surface::WlSurface> {
assert!(
resource_is_registered::<_, CompositorHandler<U, H>>(surface, self.hid),
resource_is_registered::<_, CompositorHandler<U, R, H>>(surface, self.hid),
"Accessing the data of foreign surfaces is not supported."
);
unsafe { SurfaceData::<U>::get_children(surface) }
unsafe { SurfaceData::<U, R>::get_children(surface) }
}
}
/// Retrieve the role status this surface
impl<U: Send + 'static, R: Send + RoleType + 'static, H: Handler<U, R> + Send + 'static>
CompositorToken<U, R, H> {
/// Check wether this surface as a role or not
///
/// If the surface is not managed by the CompositorGlobal that provided this token, this
/// will panic (having more than one compositor is not supported).
pub fn role_status(&self, surface: &wl_surface::WlSurface) -> RoleStatus {
pub fn has_a_role(&self, surface: &wl_surface::WlSurface) -> bool {
assert!(
resource_is_registered::<_, CompositorHandler<U, H>>(surface, self.hid),
resource_is_registered::<_, CompositorHandler<U, R, H>>(surface, self.hid),
"Accessing the data of foreign surfaces is not supported."
);
unsafe { SurfaceData::<U>::role_status(surface) }
unsafe { SurfaceData::<U, R>::has_a_role(surface) }
}
/// Register that this surface has a role
/// Check wether this surface as a specific role
///
/// This makes this surface impossible to become a subsurface, as
/// a surface can only have a single role at a time.
/// If the surface is not managed by the CompositorGlobal that provided this token, this
/// will panic (having more than one compositor is not supported).
pub fn has_role<RoleData>(&self, surface: &wl_surface::WlSurface) -> bool
where
R: Role<RoleData>,
{
assert!(
resource_is_registered::<_, CompositorHandler<U, R, H>>(surface, self.hid),
"Accessing the data of foreign surfaces is not supported."
);
unsafe { SurfaceData::<U, R>::has_role::<RoleData>(surface) }
}
/// Register that this surface has given role with default data
///
/// Fails if the surface already has a role.
///
/// If the surface is not managed by the CompositorGlobal that provided this token, this
/// will panic (having more than one compositor is not supported).
pub fn give_role(&self, surface: &wl_surface::WlSurface) -> Result<(), ()> {
pub fn give_role<RoleData>(&self, surface: &wl_surface::WlSurface) -> Result<(), ()>
where
R: Role<RoleData>,
RoleData: Default,
{
assert!(
resource_is_registered::<_, CompositorHandler<U, H>>(surface, self.hid),
resource_is_registered::<_, CompositorHandler<U, R, H>>(surface, self.hid),
"Accessing the data of foreign surfaces is not supported."
);
unsafe { SurfaceData::<U>::give_role(surface) }
unsafe { SurfaceData::<U, R>::give_role::<RoleData>(surface) }
}
/// Register that this surface has no role
/// Register that this surface has given role with given data
///
/// It is a noop if this surface already didn't have one, but fails if
/// the role was "subsurface". This role is automatically managed and as such
/// cannot be removed manually.
/// Fails if the surface already has a role and returns the data.
///
/// If the surface is not managed by the CompositorGlobal that provided this token, this
/// will panic (having more than one compositor is not supported).
pub fn remove_role(&self, surface: &wl_surface::WlSurface) -> Result<(), ()> {
pub fn give_role_with<RoleData>(&self, surface: &wl_surface::WlSurface, data: RoleData)
-> Result<(), RoleData>
where
R: Role<RoleData>,
{
assert!(
resource_is_registered::<_, CompositorHandler<U, H>>(surface, self.hid),
resource_is_registered::<_, CompositorHandler<U, R, H>>(surface, self.hid),
"Accessing the data of foreign surfaces is not supported."
);
unsafe { SurfaceData::<U>::remove_role(surface) }
unsafe { SurfaceData::<U, R>::give_role_with::<RoleData>(surface, data) }
}
/// Register that this surface does not have a role any longer and retrieve the data
///
/// Fails if the surface didn't already have this role.
///
/// If the surface is not managed by the CompositorGlobal that provided this token, this
/// will panic (having more than one compositor is not supported).
pub fn remove_role<RoleData>(&self, surface: &wl_surface::WlSurface) -> Result<RoleData, WrongRole>
where
R: Role<RoleData>,
{
assert!(
resource_is_registered::<_, CompositorHandler<U, R, H>>(surface, self.hid),
"Accessing the data of foreign surfaces is not supported."
);
unsafe { SurfaceData::<U, R>::remove_role::<RoleData>(surface) }
}
/// Retrieve the metadata associated with a wl_region
@ -396,7 +458,7 @@ impl<U: Send + 'static, H: Handler<U> + Send + 'static> CompositorToken<U, H> {
/// will panic (having more than one compositor is not supported).
pub fn get_region_attributes(&self, region: &wl_region::WlRegion) -> RegionAttributes {
assert!(
resource_is_registered::<_, CompositorHandler<U, H>>(region, self.hid),
resource_is_registered::<_, CompositorHandler<U, R, H>>(region, self.hid),
"Accessing the data of foreign regions is not supported."
);
unsafe { RegionData::get_attributes(region) }
@ -411,23 +473,24 @@ impl<U: Send + 'static, H: Handler<U> + Send + 'static> CompositorToken<U, H> {
/// defined in this module.
///
/// See the module-level documentation for instructions and examples of use.
pub struct CompositorHandler<U, H> {
pub struct CompositorHandler<U, R, H> {
my_id: usize,
log: ::slog::Logger,
handler: H,
_role: ::std::marker::PhantomData<R>,
_data: ::std::marker::PhantomData<U>,
}
impl<U, H> Init for CompositorHandler<U, H> {
impl<U, R, H> Init for CompositorHandler<U, R, H> {
fn init(&mut self, _evqh: &mut EventLoopHandle, index: usize) {
self.my_id = index;
debug!(self.log, "Init finished")
}
}
impl<U, H> CompositorHandler<U, H> {
impl<U, R, H> CompositorHandler<U, R, H> {
/// Create a new CompositorHandler
pub fn new<L>(handler: H, logger: L) -> CompositorHandler<U, H>
pub fn new<L>(handler: H, logger: L) -> CompositorHandler<U, R, H>
where
L: Into<Option<::slog::Logger>>,
{
@ -436,12 +499,13 @@ impl<U, H> CompositorHandler<U, H> {
my_id: ::std::usize::MAX,
log: log.new(o!("smithay_module" => "compositor_handler")),
handler: handler,
_role: ::std::marker::PhantomData,
_data: ::std::marker::PhantomData,
}
}
/// Create a token to access the data associated to the objects managed by this handler.
pub fn get_token(&self) -> CompositorToken<U, H> {
pub fn get_token(&self) -> CompositorToken<U, R, H> {
assert!(
self.my_id != ::std::usize::MAX,
"CompositorHandler is not initialized yet."
@ -450,6 +514,7 @@ impl<U, H> CompositorHandler<U, H> {
CompositorToken {
hid: self.my_id,
_data: ::std::marker::PhantomData,
_role: ::std::marker::PhantomData,
_handler: ::std::marker::PhantomData,
}
}
@ -466,7 +531,7 @@ impl<U, H> CompositorHandler<U, H> {
/// are forwarded directly to a handler implementing this trait that you must provide
/// at creation of the `CompositorHandler`.
#[allow(unused_variables)]
pub trait Handler<U>: Sized {
pub trait Handler<U, R>: Sized {
/// The double-buffered state has been validated by the client
///
/// At this point, the pending state that has been accumulated in the `SurfaceAttributes` associated
@ -475,7 +540,7 @@ pub trait Handler<U>: Sized {
/// See [`wayland_server::protocol::wl_surface::Handler::commit`](https://docs.rs/wayland-server/*/wayland_server/protocol/wl_surface/trait.Handler.html#method.commit)
/// for more details
fn commit(&mut self, evlh: &mut EventLoopHandle, client: &Client, surface: &wl_surface::WlSurface,
token: CompositorToken<U, Self>) {
token: CompositorToken<U, R, Self>) {
}
/// The client asks to be notified when would be a good time to update the contents of this surface
///
@ -485,6 +550,6 @@ pub trait Handler<U>: Sized {
/// See [`wayland_server::protocol::wl_surface::Handler::frame`](https://docs.rs/wayland-server/*/wayland_server/protocol/wl_surface/trait.Handler.html#method.frame)
/// for more details
fn frame(&mut self, evlh: &mut EventLoopHandle, client: &Client, surface: &wl_surface::WlSurface,
callback: wl_callback::WlCallback, token: CompositorToken<U, Self>) {
callback: wl_callback::WlCallback, token: CompositorToken<U, R, Self>) {
}
}

239
src/compositor/roles.rs Normal file
View File

@ -0,0 +1,239 @@
//! Tools for handling surface roles
//!
//! In the wayland protocol, surfaces can have several different roles, which
//! define how they are to be used. The core protocol defines 3 of these roles:
//!
//! - `shell_surface`: This surface is to be considered as what is most often
//! called a "window".
//! - `pointer_surface`: This surface represent the contents of a pointer icon
//! and replaces the default pointer.
//! - `subsurface`: This surface is part of a subsurface tree, and as such has
//! a parent surface.
//!
//! A surface can have only one role at any given time. To change he role of a
//! surface, the client must first remove the previous role before assigning the
//! new one. A surface without a role is not displayed at all.
//!
//! This module provides tools to manage roles of a surface in a composable way
//! allowing all handlers of smithay to manage surface roles while being aware
//! of the possible role conflicts.
//!
//! ## General mechanism
//!
//! First, all roles need to have an unique type, holding its metadata and identifying it
//! to the type-system. Even if your role does not hold any metadata, you still need its
//! unique type, using a unit-like struct rather than `()`.
//!
//! You then need a type for managing the roles of a surface. This type holds information
//! about what is the current role of a surface, and what is the metadata associated with
//! it.
//!
//! For convenience, you can use the `define_roles!` macro provided by Smithay to define this
//! type. You can call it like this:
//!
//! ```
//! # #[macro_use]
//! # extern crate smithay;
//! #
//! // Metadata for a first role
//! #[derive(Default)]
//! pub struct MyRoleMetadata {
//! }
//!
//! // Metadata for a second role
//! #[derive(Default)]
//! pub struct MyRoleMetadata2 {
//! }
//!
//! define_roles!(Roles =>
//! // You can put several roles like this
//! // first identifier is the name of the variant for this
//! // role in the generated enum, second is the token type
//! // for this role
//! [MyRoleName, MyRoleMetadata]
//! [MyRoleName2, MyRoleMetadata2]
//! /* ... */
//! );
//!
//! # fn main() {}
//! ```
//!
//! And this will expand to an enum like this:
//!
//! ```ignore
//! pub enum Roles {
//! NoRole,
//! // The subsurface role is always inserted, as it is required
//! // by the CompositorHandler
//! Subsurface(::smithay::compositor::SubsurfaceAttributes),
//! // all your other roles come here
//! MyRoleName(MyRoleMetadata),
//! MyRoleName2(MyRoleMetadata2),
//! /* ... */
//! }
//! ```
//!
//! as well as implement a few trait for it, allowing it to be used by
//! all smithay handlers:
//!
//! - The trait `RoleType`, which defines it as a type handling roles
//! - For each of your roles, the trait `Role<Token>` (where `Token` is your
//! token type), marking its hability to handle this given role.
//!
//! All handlers that handle a specific role will require you to provide
//! them with a `CompositorToken<U, R, H>` where `R: Role<TheToken>`.
//!
//! See the documentation of these traits for their specific definition and
//! capabilities.
/// An error type signifying that the surface does not have expected role
///
/// Generated if you attempt a role operation on a surface that does
/// not have the role you asked for.
#[derive(Debug)]
pub struct WrongRole;
/// A trait representing a type that can manage surface roles
pub trait RoleType {
/// Check if the associated surface has a role
///
/// Only reports if the surface has any role or no role.
/// To check for a role in particular, see `Role::has`.
fn has_role(&self) -> bool;
}
/// A trait representing the capability of a RoleType to handle a given role
///
/// This trait allows to interact with the different roles a RoleType can
/// handle.
///
/// This trait is meant to be used generically, for example, to retrieve the
/// data associated with a given role with token `TheRole`:
///
/// ```ignore
/// let data = <MyRoles as Role<RoleData>>::data(my_roles)
/// .expect("The surface does not have this role.");
/// ```
///
/// The methods of this trait are mirrored on `CompositorToken` for easy
/// access to the role data of the surfaces.
///
/// Note that if a role is automatically handled for you by a Handler provided
/// by smithay, you should not set or unset it manually on a surface. Doing so
/// would likely corrupt the internal state of these handlers, causing spurious
/// protocol errors and unreliable behaviour overall.
pub trait Role<R>: RoleType {
/// Set the role for the associated surface with default associated data
///
/// Fails if the surface already has a role
fn set(&mut self) -> Result<(), ()>
where
R: Default,
{
self.set_with(Default::default()).map_err(|_| ())
}
/// Set the role for the associated surface with given data
///
/// Fails if the surface already has a role and returns the data
fn set_with(&mut self, data: R) -> Result<(), R>;
/// Check if the associated surface has this role
fn has(&self) -> bool;
/// Access the data associated with this role if its the current one
fn data(&self) -> Result<&R, WrongRole>;
/// Mutably access the data associated with this role if its the current one
fn data_mut(&mut self) -> Result<&mut R, WrongRole>;
/// Remove this role from the associated surface
///
/// Fails if the surface does not currently have this role
fn unset(&mut self) -> Result<R, WrongRole>;
}
#[macro_export]
macro_rules! define_roles(
($enum_name: ident) => {
define_roles!($enum_name =>);
};
($enum_name:ident => $([ $role_name: ident, $role_data: ty])*) => {
define_roles!(__impl $enum_name =>
// add in subsurface role
[Subsurface, $crate::compositor::SubsurfaceRole]
$([$role_name, $role_data])*
);
};
(__impl $enum_name:ident => $([ $role_name: ident, $role_data: ty])*) => {
pub enum $enum_name {
NoRole,
$($role_name($role_data)),*
}
impl Default for $enum_name {
fn default() -> $enum_name {
$enum_name::NoRole
}
}
impl $crate::compositor::roles::RoleType for $enum_name {
fn has_role(&self) -> bool {
if let $enum_name::NoRole = *self {
false
} else {
true
}
}
}
$(
impl $crate::compositor::roles::Role<$role_data> for $enum_name {
fn set_with(&mut self, data: $role_data) -> ::std::result::Result<(), $role_data> {
if let $enum_name::NoRole = *self {
*self = $enum_name::$role_name(data);
Ok(())
} else {
Err(data)
}
}
fn has(&self) -> bool {
if let $enum_name::$role_name(_) = *self {
true
} else {
false
}
}
fn data(&self) -> ::std::result::Result<&$role_data, $crate::compositor::roles::WrongRole> {
if let $enum_name::$role_name(ref data) = *self {
Ok(data)
} else {
Err($crate::compositor::roles::WrongRole)
}
}
fn data_mut(&mut self) -> ::std::result::Result<&mut $role_data, $crate::compositor::roles::WrongRole> {
if let $enum_name::$role_name(ref mut data) = *self {
Ok(data)
} else {
Err($crate::compositor::roles::WrongRole)
}
}
fn unset(&mut self) -> ::std::result::Result<$role_data, $crate::compositor::roles::WrongRole> {
// remove self to make borrow checker happy
let temp = ::std::mem::replace(self, $enum_name::NoRole);
if let $enum_name::$role_name(data) = temp {
Ok(data)
} else {
// put it back in place
::std::mem::replace(self, temp);
Err($crate::compositor::roles::WrongRole)
}
}
}
)*
};
);

169
src/compositor/tree.rs
View File

@ -1,4 +1,5 @@
use super::SurfaceAttributes;
use super::{SubsurfaceRole, SurfaceAttributes};
use super::roles::*;
use std::sync::Mutex;
use wayland_server::{Liveness, Resource};
@ -23,26 +24,13 @@ use wayland_server::protocol::wl_surface;
///
/// All the methods here are unsafe, because they assume the provided wl_surface object
/// is correctly initialized regarding its user_data.
pub struct SurfaceData<U> {
pub struct SurfaceData<U, R> {
parent: Option<wl_surface::WlSurface>,
children: Vec<wl_surface::WlSurface>,
has_role: bool,
role: R,
attributes: SurfaceAttributes<U>,
}
/// Status of a surface regarding its role
pub enum RoleStatus {
/// This surface does not have any role
NoRole,
/// This surface is a subsurface
Subsurface,
/// This surface has a role other than subsurface
///
/// It is thus the root of a subsurface tree that will
/// have to be displayed
HasRole,
}
pub enum Location {
Before,
After,
@ -58,12 +46,12 @@ pub enum TraversalAction<T> {
Break,
}
impl<U: Default> SurfaceData<U> {
fn new() -> SurfaceData<U> {
impl<U: Default, R: Default> SurfaceData<U, R> {
fn new() -> SurfaceData<U, R> {
SurfaceData {
parent: None,
children: Vec::new(),
has_role: false,
role: Default::default(),
attributes: Default::default(),
}
}
@ -71,13 +59,13 @@ impl<U: Default> SurfaceData<U> {
/// Initialize the user_data of a surface, must be called right when the surface is created
pub unsafe fn init(surface: &wl_surface::WlSurface) {
surface.set_user_data(Box::into_raw(
Box::new(Mutex::new(SurfaceData::<U>::new())),
Box::new(Mutex::new(SurfaceData::<U, R>::new())),
) as *mut _)
}
}
impl<U> SurfaceData<U> {
unsafe fn get_data(surface: &wl_surface::WlSurface) -> &Mutex<SurfaceData<U>> {
impl<U, R> SurfaceData<U, R> {
unsafe fn get_data(surface: &wl_surface::WlSurface) -> &Mutex<SurfaceData<U, R>> {
let ptr = surface.get_user_data();
&*(ptr as *mut _)
}
@ -86,7 +74,7 @@ impl<U> SurfaceData<U> {
pub unsafe fn cleanup(surface: &wl_surface::WlSurface) {
let ptr = surface.get_user_data();
surface.set_user_data(::std::ptr::null_mut());
let my_data_mutex: Box<Mutex<SurfaceData<U>>> = Box::from_raw(ptr as *mut _);
let my_data_mutex: Box<Mutex<SurfaceData<U, R>>> = Box::from_raw(ptr as *mut _);
let mut my_data = my_data_mutex.into_inner().unwrap();
if let Some(old_parent) = my_data.parent.take() {
if !old_parent.equals(surface) {
@ -107,48 +95,85 @@ impl<U> SurfaceData<U> {
child_guard.parent = None;
}
}
}
/// Retrieve the current role status of this surface
pub unsafe fn role_status(surface: &wl_surface::WlSurface) -> RoleStatus {
impl<U, R: RoleType> SurfaceData<U, R> {
pub unsafe fn has_a_role(surface: &wl_surface::WlSurface) -> bool {
debug_assert!(surface.status() == Liveness::Alive);
let data_mutex = Self::get_data(surface);
let data_guard = data_mutex.lock().unwrap();
match (data_guard.has_role, data_guard.parent.is_some()) {
(true, true) => RoleStatus::Subsurface,
(true, false) => RoleStatus::HasRole,
(false, false) => RoleStatus::NoRole,
(false, true) => unreachable!(),
}
<R as RoleType>::has_role(&data_guard.role)
}
/// Check wether a surface has a given role
pub unsafe fn has_role<RoleData>(surface: &wl_surface::WlSurface) -> bool
where
R: Role<RoleData>,
{
debug_assert!(surface.status() == Liveness::Alive);
let data_mutex = Self::get_data(surface);
let data_guard = data_mutex.lock().unwrap();
<R as Role<RoleData>>::has(&data_guard.role)
}
/// Register that this surface has a role, fails if it already has one
pub unsafe fn give_role(surface: &wl_surface::WlSurface) -> Result<(), ()> {
pub unsafe fn give_role<RoleData>(surface: &wl_surface::WlSurface) -> Result<(), ()>
where
R: Role<RoleData>,
RoleData: Default,
{
debug_assert!(surface.status() == Liveness::Alive);
let data_mutex = Self::get_data(surface);
let mut data_guard = data_mutex.lock().unwrap();
if data_guard.has_role {
return Err(());
}
data_guard.has_role = true;
Ok(())
<R as Role<RoleData>>::set(&mut data_guard.role)
}
/// Register that this surface has no role
/// Register that this surface has a role with given data
///
/// Fails if it already has one and returns the data
pub unsafe fn give_role_with<RoleData>(surface: &wl_surface::WlSurface, data: RoleData)
-> Result<(), RoleData>
where
R: Role<RoleData>,
{
debug_assert!(surface.status() == Liveness::Alive);
let data_mutex = Self::get_data(surface);
let mut data_guard = data_mutex.lock().unwrap();
<R as Role<RoleData>>::set_with(&mut data_guard.role, data)
}
/// Register that this surface has no role and returns the data
///
/// It is a noop if this surface already didn't have one, but fails if
/// the role was "subsurface", it must be removed by the `unset_parent` method.
pub unsafe fn remove_role(surface: &wl_surface::WlSurface) -> Result<(), ()> {
pub unsafe fn remove_role<RoleData>(surface: &wl_surface::WlSurface) -> Result<RoleData, WrongRole>
where
R: Role<RoleData>,
{
debug_assert!(surface.status() == Liveness::Alive);
let data_mutex = Self::get_data(surface);
let mut data_guard = data_mutex.lock().unwrap();
if data_guard.has_role && data_guard.parent.is_some() {
return Err(());
}
data_guard.has_role = false;
Ok(())
<R as Role<RoleData>>::unset(&mut data_guard.role)
}
/// Access to the role data
pub unsafe fn with_role_data<RoleData, F, T>(surface: &wl_surface::WlSurface, f: F)
-> Result<T, WrongRole>
where
R: Role<RoleData>,
F: FnOnce(&mut RoleData) -> T,
{
debug_assert!(surface.status() == Liveness::Alive);
let data_mutex = Self::get_data(surface);
let mut data_guard = data_mutex.lock().unwrap();
let data = <R as Role<RoleData>>::data_mut(&mut data_guard.role)?;
Ok(f(data))
}
}
impl<U, R: RoleType + Role<SubsurfaceRole>> SurfaceData<U, R> {
/// Sets the parent of a surface
///
/// if this surface already has a role, does nothing and fails, otherwise
/// its role is now to be a subsurface
pub unsafe fn set_parent(child: &wl_surface::WlSurface, parent: &wl_surface::WlSurface)
@ -160,13 +185,10 @@ impl<U> SurfaceData<U> {
{
let child_mutex = Self::get_data(child);
let mut child_guard = child_mutex.lock().unwrap();
// if surface already has a role, it cannot be a subsurface
if child_guard.has_role {
return Err(());
}
// if surface already has a role, it cannot become a subsurface
<R as Role<SubsurfaceRole>>::set(&mut child_guard.role)?;
debug_assert!(child_guard.parent.is_none());
child_guard.parent = Some(parent.clone_unchecked());
child_guard.has_role = true;
}
// register child to new parent
// double scoping is to be robust to have a child be its own parent
@ -189,7 +211,8 @@ impl<U> SurfaceData<U> {
let old_parent = child_guard.parent.take();
if old_parent.is_some() {
// We had a parent, so this does not have a role any more
child_guard.has_role = false;
<R as Role<SubsurfaceRole>>::unset(&mut child_guard.role)
.expect("Surface had a parent but not the subsurface role?!");
}
old_parent
};
@ -266,14 +289,16 @@ impl<U> SurfaceData<U> {
parent_guard.children.insert(new_index, me);
Ok(())
}
}
impl<U, R> SurfaceData<U, R> {
/// Access the attributes associated with a surface
///
/// Note that an internal lock is taken during access of this data,
/// so the tree cannot be manipulated at the same time
pub unsafe fn with_data<F>(surface: &wl_surface::WlSurface, f: F)
pub unsafe fn with_data<T, F>(surface: &wl_surface::WlSurface, f: F) -> T
where
F: FnOnce(&mut SurfaceAttributes<U>),
F: FnOnce(&mut SurfaceAttributes<U>) -> T,
{
let data_mutex = Self::get_data(surface);
let mut data_guard = data_mutex.lock().unwrap();
@ -290,28 +315,42 @@ impl<U> SurfaceData<U> {
/// false will cause an early-stopping.
pub unsafe fn map_tree<F, T>(root: &wl_surface::WlSurface, initial: T, mut f: F)
where
F: FnMut(&wl_surface::WlSurface, &mut SurfaceAttributes<U>, &T) -> TraversalAction<T>,
F: FnMut(&wl_surface::WlSurface,
&mut SurfaceAttributes<U>,
&mut R,
&T)
-> TraversalAction<T>,
{
// helper function for recursion
unsafe fn map<U, F, T>(surface: &wl_surface::WlSurface, root: &wl_surface::WlSurface, initial: &T,
f: &mut F)
-> bool
unsafe fn map<U, R, F, T>(surface: &wl_surface::WlSurface, root: &wl_surface::WlSurface, initial: &T,
f: &mut F)
-> bool
where
F: FnMut(&wl_surface::WlSurface, &mut SurfaceAttributes<U>, &T) -> TraversalAction<T>,
F: FnMut(&wl_surface::WlSurface,
&mut SurfaceAttributes<U>,
&mut R,
&T)
-> TraversalAction<T>,
{
// stop if we met the root, so to not deadlock/inifinte loop
if surface.equals(root) {
return true;
}
let data_mutex = SurfaceData::<U>::get_data(surface);
let data_mutex = SurfaceData::<U, R>::get_data(surface);
let mut data_guard = data_mutex.lock().unwrap();
let data_guard = &mut *data_guard;
// call the callback on ourselves
match f(surface, &mut data_guard.attributes, initial) {
match f(
surface,
&mut data_guard.attributes,
&mut data_guard.role,
initial,
) {
TraversalAction::DoChildren(t) => {
// loop over children
for c in &data_guard.children {
if !map(c, root, &t, f) {
if !map::<U, R, _, _>(c, root, &t, f) {
return false;
}
}
@ -324,12 +363,18 @@ impl<U> SurfaceData<U> {
let data_mutex = Self::get_data(root);
let mut data_guard = data_mutex.lock().unwrap();
let data_guard = &mut *data_guard;
// call the callback on ourselves
match f(root, &mut data_guard.attributes, &initial) {
match f(
root,
&mut data_guard.attributes,
&mut data_guard.role,
&initial,
) {
TraversalAction::DoChildren(t) => {
// loop over children
for c in &data_guard.children {
if !map::<U, _, _>(c, root, &t, &mut f) {
if !map::<U, R, _, _>(c, root, &t, &mut f) {
break;
}
}

1
src/lib.rs
View File

@ -33,7 +33,6 @@ extern crate slog;
extern crate slog_stdlog;
pub mod backend;
pub mod compositor;
pub mod shm;
pub mod keyboard;