Merge pull request #19 from vberger/compositor
First draft of the compositor/subcompositor global handler
This commit is contained in:
Victor Berger
GitHub
commit
ce70cda374
|
|
@ -1,2 +1,3 @@
|
|||
target
|
||||
Cargo.lock
|
||||
*.bk
|
||||
|
|
|
|||
|
|
@ -6,6 +6,5 @@ reorder_imports = true
|
|||
reorder_imported_names = true
|
||||
report_todo = "Never"
|
||||
report_fixme = "Never"
|
||||
normalize_comments = true
|
||||
use_try_shorthand = true
|
||||
max_width = 110
|
||||
|
|
|
|||
|
|
@ -14,7 +14,7 @@ slog-stdlog = "2.0.0-0.2"
|
|||
libloading = "0.4.0"
|
||||
wayland-client = { version = "~0.8.6", optional = true }
|
||||
winit = { git = "https://github.com/tomaka/winit.git", optional = true }
|
||||
glium = { version = "~0.16.0", optional = true }
|
||||
glium = { version = "~0.16.0", optional = true, default-features = false }
|
||||
input = { version = "~0.2.0", optional = true }
|
||||
clippy = { version = "*", optional = true }
|
||||
rental = "0.4.11"
|
||||
|
|
@ -23,7 +23,8 @@ rental = "0.4.11"
|
|||
gl_generator = "0.5"
|
||||
|
||||
[dev-dependencies]
|
||||
slog-term = "~1.5"
|
||||
slog-term = "2.0"
|
||||
slog-async = "2.0"
|
||||
|
||||
[features]
|
||||
default = ["backend_winit", "backend_libinput", "renderer_glium"]
|
||||
|
|
|
|||
|
|
@ -0,0 +1,127 @@
|
|||
use glium;
|
||||
use glium::Surface;
|
||||
use glium::index::PrimitiveType;
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
struct Vertex {
|
||||
position: [f32; 2],
|
||||
tex_coords: [f32; 2],
|
||||
}
|
||||
|
||||
implement_vertex!(Vertex, position, tex_coords);
|
||||
|
||||
pub struct GliumDrawer<'a, F: 'a> {
|
||||
display: &'a F,
|
||||
vertex_buffer: glium::VertexBuffer<Vertex>,
|
||||
index_buffer: glium::IndexBuffer<u16>,
|
||||
program: glium::Program,
|
||||
}
|
||||
|
||||
impl<'a, F: glium::backend::Facade + 'a> GliumDrawer<'a, F> {
|
||||
pub fn new(display: &'a F) -> GliumDrawer<'a, F> {
|
||||
|
||||
// building the vertex buffer, which contains all the vertices that we will draw
|
||||
let vertex_buffer = glium::VertexBuffer::new(
|
||||
display,
|
||||
&[
|
||||
Vertex {
|
||||
position: [0.0, 0.0],
|
||||
tex_coords: [0.0, 0.0],
|
||||
},
|
||||
Vertex {
|
||||
position: [0.0, 1.0],
|
||||
tex_coords: [0.0, 1.0],
|
||||
},
|
||||
Vertex {
|
||||
position: [1.0, 1.0],
|
||||
tex_coords: [1.0, 1.0],
|
||||
},
|
||||
Vertex {
|
||||
position: [1.0, 0.0],
|
||||
tex_coords: [1.0, 0.0],
|
||||
},
|
||||
],
|
||||
).unwrap();
|
||||
|
||||
// building the index buffer
|
||||
let index_buffer =
|
||||
glium::IndexBuffer::new(display, PrimitiveType::TriangleStrip, &[1 as u16, 2, 0, 3]).unwrap();
|
||||
|
||||
// compiling shaders and linking them together
|
||||
let program = program!(display,
|
||||
100 => {
|
||||
vertex: "
|
||||
#version 100
|
||||
uniform lowp mat4 matrix;
|
||||
attribute lowp vec2 position;
|
||||
attribute lowp vec2 tex_coords;
|
||||
varying lowp vec2 v_tex_coords;
|
||||
void main() {
|
||||
gl_Position = matrix * vec4(position, 0.0, 1.0);
|
||||
v_tex_coords = tex_coords;
|
||||
}
|
||||
",
|
||||
|
||||
fragment: "
|
||||
#version 100
|
||||
uniform lowp sampler2D tex;
|
||||
varying lowp vec2 v_tex_coords;
|
||||
void main() {
|
||||
lowp vec4 color = texture2D(tex, v_tex_coords);
|
||||
gl_FragColor.r = color.z;
|
||||
gl_FragColor.g = color.y;
|
||||
gl_FragColor.b = color.x;
|
||||
gl_FragColor.a = color.w;
|
||||
}
|
||||
",
|
||||
},
|
||||
).unwrap();
|
||||
|
||||
GliumDrawer {
|
||||
display,
|
||||
vertex_buffer,
|
||||
index_buffer,
|
||||
program,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn draw(&self, target: &mut glium::Frame, contents: &[u8], surface_dimensions: (u32, u32),
|
||||
surface_location: (i32, i32), screen_size: (u32, u32)) {
|
||||
|
||||
let image = glium::texture::RawImage2d {
|
||||
data: contents.into(),
|
||||
width: surface_dimensions.0,
|
||||
height: surface_dimensions.1,
|
||||
format: glium::texture::ClientFormat::U8U8U8U8,
|
||||
};
|
||||
let opengl_texture = glium::texture::Texture2d::new(self.display, image).unwrap();
|
||||
|
||||
let xscale = 2.0 * (surface_dimensions.0 as f32) / (screen_size.0 as f32);
|
||||
let yscale = -2.0 * (surface_dimensions.1 as f32) / (screen_size.1 as f32);
|
||||
|
||||
let x = 2.0 * (surface_location.0 as f32) / (screen_size.0 as f32) - 1.0;
|
||||
let y = 1.0 - 2.0 * (surface_location.1 as f32) / (screen_size.1 as f32);
|
||||
|
||||
let uniforms =
|
||||
uniform! {
|
||||
matrix: [
|
||||
[xscale, 0.0 , 0.0, 0.0],
|
||||
[ 0.0 , yscale , 0.0, 0.0],
|
||||
[ 0.0 , 0.0 , 1.0, 0.0],
|
||||
[ x , y , 0.0, 1.0]
|
||||
],
|
||||
tex: &opengl_texture
|
||||
};
|
||||
|
||||
target
|
||||
.draw(
|
||||
&self.vertex_buffer,
|
||||
&self.index_buffer,
|
||||
&self.program,
|
||||
&uniforms,
|
||||
&Default::default(),
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,5 @@
|
|||
mod shell;
|
||||
mod glium;
|
||||
|
||||
pub use self::glium::GliumDrawer;
|
||||
pub use self::shell::WlShellStubHandler;
|
||||
|
|
@ -0,0 +1,84 @@
|
|||
|
||||
|
||||
use smithay::compositor::{CompositorToken, Handler as CompositorHandler};
|
||||
use wayland_server::{Client, EventLoopHandle, GlobalHandler, Init, Resource};
|
||||
use wayland_server::protocol::{wl_shell, wl_shell_surface, wl_surface};
|
||||
|
||||
/// A very basic handler for wl_shell
|
||||
///
|
||||
/// All it does is track which wl_shell_surface exist and which do not,
|
||||
/// as well as the roles associated to them.
|
||||
///
|
||||
/// That's it.
|
||||
pub struct WlShellStubHandler<U, H> {
|
||||
my_id: Option<usize>,
|
||||
token: CompositorToken<U, 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> {
|
||||
WlShellStubHandler {
|
||||
my_id: None,
|
||||
token: compositor_token,
|
||||
surfaces: Vec::new(),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn surfaces(&self) -> &[(wl_shell_surface::WlShellSurface, wl_surface::WlSurface)] {
|
||||
&self.surfaces
|
||||
}
|
||||
}
|
||||
|
||||
impl<U, H> Init for WlShellStubHandler<U, 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
|
||||
{
|
||||
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."));
|
||||
}
|
||||
}
|
||||
|
||||
impl<U, H> wl_shell::Handler for WlShellStubHandler<U, H>
|
||||
where
|
||||
U: Send + 'static,
|
||||
H: CompositorHandler<U> + Send + 'static,
|
||||
{
|
||||
fn get_shell_surface(&mut self, evqh: &mut EventLoopHandle, client: &Client,
|
||||
resource: &wl_shell::WlShell, id: wl_shell_surface::WlShellSurface,
|
||||
surface: &wl_surface::WlSurface) {
|
||||
let surface = surface.clone().expect(
|
||||
"WlShellStubHandler can only manage surfaces managed by Smithay's CompositorHandler.",
|
||||
);
|
||||
if self.token.give_role(&surface).is_err() {
|
||||
// This surface already has a role, and thus cannot be given one!
|
||||
resource.post_error(
|
||||
wl_shell::Error::Role as u32,
|
||||
"Surface already has a role.".into(),
|
||||
);
|
||||
return;
|
||||
}
|
||||
evqh.register::<_, Self>(&id, self.my_id.unwrap());
|
||||
self.surfaces.push((id, surface))
|
||||
}
|
||||
}
|
||||
|
||||
server_declare_handler!(WlShellStubHandler<U: [Send], H: [CompositorHandler<U>, Send]>, wl_shell::Handler, wl_shell::WlShell);
|
||||
|
||||
impl<U, H> wl_shell_surface::Handler for WlShellStubHandler<U, H>
|
||||
where
|
||||
U: Send + 'static,
|
||||
H: CompositorHandler<U> + Send + 'static,
|
||||
{
|
||||
}
|
||||
|
||||
server_declare_handler!(WlShellStubHandler<U: [Send], H: [CompositorHandler<U>, Send]>, wl_shell_surface::Handler, wl_shell_surface::WlShellSurface);
|
||||
|
|
@ -1,47 +1,185 @@
|
|||
#[macro_use(server_declare_handler)]
|
||||
extern crate wayland_server;
|
||||
extern crate smithay;
|
||||
#[macro_use]
|
||||
extern crate glium;
|
||||
|
||||
#[macro_use]
|
||||
extern crate slog;
|
||||
extern crate slog_async;
|
||||
extern crate slog_term;
|
||||
|
||||
mod helpers;
|
||||
|
||||
use glium::Surface;
|
||||
|
||||
use helpers::{GliumDrawer, WlShellStubHandler};
|
||||
use slog::*;
|
||||
|
||||
use smithay::backend::graphics::glium::IntoGlium;
|
||||
use smithay::backend::input::InputBackend;
|
||||
use smithay::backend::winit;
|
||||
use smithay::shm::ShmGlobal;
|
||||
use wayland_server::protocol::wl_shm;
|
||||
use smithay::compositor::{self, CompositorHandler, CompositorToken, TraversalAction};
|
||||
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};
|
||||
|
||||
struct SurfaceHandler {
|
||||
shm_token: ShmToken,
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
struct SurfaceData {
|
||||
buffer: Option<(Vec<u8>, (u32, u32))>,
|
||||
}
|
||||
|
||||
impl compositor::Handler<SurfaceData> for SurfaceHandler {
|
||||
fn commit(&mut self, evlh: &mut EventLoopHandle, client: &Client, surface: &wl_surface::WlSurface,
|
||||
token: CompositorToken<SurfaceData, SurfaceHandler>) {
|
||||
// we retrieve the contents of the associated buffer and copy it
|
||||
token.with_surface_data(surface, |attributes| {
|
||||
match attributes.buffer.take() {
|
||||
Some(Some((buffer, (x, y)))) => {
|
||||
self.shm_token.with_buffer_contents(&buffer, |slice, data| {
|
||||
let offset = data.offset as usize;
|
||||
let stride = data.stride as usize;
|
||||
let width = data.width as usize;
|
||||
let height = data.height as usize;
|
||||
let mut new_vec = Vec::with_capacity(width * height * 4);
|
||||
for i in 0..height {
|
||||
new_vec.extend(
|
||||
&slice[(offset + i * stride)..(offset + i * stride + width * 4)],
|
||||
);
|
||||
}
|
||||
attributes.user_data.buffer =
|
||||
Some((new_vec, (data.width as u32, data.height as u32)));
|
||||
});
|
||||
|
||||
}
|
||||
Some(None) => {
|
||||
// erase the contents
|
||||
attributes.user_data.buffer = None;
|
||||
}
|
||||
None => {}
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
fn main() {
|
||||
// A logger facility, here we use the terminal for this example
|
||||
let log = Logger::root(
|
||||
slog_async::Async::default(slog_term::term_full().fuse()).fuse(),
|
||||
o!(),
|
||||
);
|
||||
|
||||
// Initialize a simple backend for testing
|
||||
let (renderer, mut input) = winit::init().unwrap();
|
||||
let (renderer, mut input) = winit::init(log.clone()).unwrap();
|
||||
|
||||
let (_display, mut event_loop) = wayland_server::create_display();
|
||||
let (mut display, mut event_loop) = wayland_server::create_display();
|
||||
|
||||
/*
|
||||
* Initialize wl_shm global
|
||||
*/
|
||||
// Insert the ShmGlobal as a handler to your event loop
|
||||
// Here, we specify tha the standard Argb8888 and Xrgb8888 is the only supported.
|
||||
let handler_id = event_loop.add_handler_with_init(ShmGlobal::new(
|
||||
vec![],
|
||||
None, /* we don't provide a logger here */
|
||||
));
|
||||
|
||||
let shm_handler_id = event_loop.add_handler_with_init(ShmGlobal::new(vec![], log.clone()));
|
||||
// Register this handler to advertise a wl_shm global of version 1
|
||||
let shm_global = event_loop.register_global::<wl_shm::WlShm, ShmGlobal>(handler_id, 1);
|
||||
|
||||
// Retrieve the shm token for later use to access the buffers
|
||||
event_loop.register_global::<wl_shm::WlShm, ShmGlobal>(shm_handler_id, 1);
|
||||
// retreive the token
|
||||
let shm_token = {
|
||||
let state = event_loop.state();
|
||||
state.get_handler::<ShmGlobal>(handler_id).get_token()
|
||||
state.get_handler::<ShmGlobal>(shm_handler_id).get_token()
|
||||
};
|
||||
|
||||
// Init glium
|
||||
|
||||
/*
|
||||
* Initialize the compositor global
|
||||
*/
|
||||
let compositor_handler_id = event_loop.add_handler_with_init(CompositorHandler::<SurfaceData, _>::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, CompositorHandler<SurfaceData, SurfaceHandler>>(
|
||||
compositor_handler_id,
|
||||
4,
|
||||
);
|
||||
event_loop.register_global::<wl_subcompositor::WlSubcompositor, CompositorHandler<SurfaceData,SurfaceHandler>>(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_token()
|
||||
};
|
||||
|
||||
/*
|
||||
* Initialize the shell stub global
|
||||
*/
|
||||
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>>(
|
||||
shell_handler_id,
|
||||
1,
|
||||
);
|
||||
|
||||
/*
|
||||
* Initialize glium
|
||||
*/
|
||||
let context = renderer.into_glium();
|
||||
|
||||
let drawer = GliumDrawer::new(&context);
|
||||
|
||||
/*
|
||||
* Add a listening socket:
|
||||
*/
|
||||
let name = display.add_socket_auto().unwrap().into_string().unwrap();
|
||||
println!("Listening on socket: {}", name);
|
||||
|
||||
loop {
|
||||
input.dispatch_new_events().unwrap();
|
||||
|
||||
let mut frame = context.draw();
|
||||
frame.clear(None, Some((0.0, 0.0, 0.0, 1.0)), false, None, None);
|
||||
frame.clear(None, Some((0.8, 0.8, 0.9, 1.0)), false, None, None);
|
||||
// redraw the frame, in a simple but inneficient way
|
||||
{
|
||||
let screen_dimensions = context.get_framebuffer_dimensions();
|
||||
let state = event_loop.state();
|
||||
for &(_, ref surface) in
|
||||
state
|
||||
.get_handler::<WlShellStubHandler<SurfaceData, 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
|
||||
}
|
||||
},
|
||||
);
|
||||
}
|
||||
}
|
||||
frame.finish().unwrap();
|
||||
|
||||
event_loop.dispatch(Some(16)).unwrap();
|
||||
display.flush_clients();
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -3,7 +3,7 @@
|
|||
use backend::graphics::egl::{EGLGraphicsBackend, SwapBuffersError};
|
||||
use glium::Frame;
|
||||
use glium::SwapBuffersError as GliumSwapBuffersError;
|
||||
use glium::backend::{Backend, Context};
|
||||
use glium::backend::{Backend, Context, Facade};
|
||||
use glium::debug::DebugCallbackBehavior;
|
||||
use std::ops::Deref;
|
||||
use std::os::raw::c_void;
|
||||
|
|
@ -63,6 +63,12 @@ impl<T: EGLGraphicsBackend> Deref for GliumGraphicsBackend<T> {
|
|||
}
|
||||
}
|
||||
|
||||
impl<T: EGLGraphicsBackend> Facade for GliumGraphicsBackend<T> {
|
||||
fn get_context(&self) -> &Rc<Context> {
|
||||
&self.context
|
||||
}
|
||||
}
|
||||
|
||||
/// Converter trait to expose `glium` compatibility for all `EGLGraphicsBackend`s
|
||||
pub trait IntoGlium: EGLGraphicsBackend + Sized {
|
||||
/// Wrap the given `EGLGraphicsBackend` to a `GliumGraphicBackend`
|
||||
|
|
|
|||
|
|
@ -763,6 +763,7 @@ impl InputBackend for WinitInputBackend {
|
|||
*time_counter += 1;
|
||||
}
|
||||
Event::DeviceEvent { .. } => {}
|
||||
_ => {}
|
||||
});
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,25 @@
|
|||
use super::{CompositorHandler, Handler as UserHandler};
|
||||
|
||||
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
|
||||
{
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
impl<U, H> GlobalHandler<wl_subcompositor::WlSubcompositor> for CompositorHandler<U, H>
|
||||
where
|
||||
U: 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);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,286 @@
|
|||
use super::{CompositorHandler, Damage, Handler as UserHandler, Rectangle, RectangleKind,
|
||||
SubsurfaceAttributes};
|
||||
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> {
|
||||
_t: ::std::marker::PhantomData<U>,
|
||||
}
|
||||
|
||||
/*
|
||||
* wl_compositor
|
||||
*/
|
||||
|
||||
impl<U, H> wl_compositor::Handler for CompositorHandler<U, H>
|
||||
where
|
||||
U: Default + Send + 'static,
|
||||
H: UserHandler<U> + 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);
|
||||
}
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
server_declare_handler!(CompositorHandler<U: [Default, Send], H: [UserHandler<U>, Send]>, wl_compositor::Handler, wl_compositor::WlCompositor);
|
||||
|
||||
/*
|
||||
* wl_surface
|
||||
*/
|
||||
|
||||
impl<U, H: UserHandler<U>> wl_surface::Handler for CompositorHandler<U, 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| {
|
||||
d.buffer = Some(buffer.map(|b| (b.clone_unchecked(), (x, y))))
|
||||
});
|
||||
}
|
||||
}
|
||||
fn damage(&mut self, _: &mut EventLoopHandle, _: &Client, surface: &wl_surface::WlSurface, x: i32,
|
||||
y: i32, width: i32, height: i32) {
|
||||
trace!(self.log, "Registering damage to surface.");
|
||||
unsafe {
|
||||
SurfaceData::<U>::with_data(surface, |d| {
|
||||
d.damage = Damage::Surface(Rectangle {
|
||||
x,
|
||||
y,
|
||||
width,
|
||||
height,
|
||||
})
|
||||
});
|
||||
}
|
||||
}
|
||||
fn frame(&mut self, evlh: &mut EventLoopHandle, client: &Client, surface: &wl_surface::WlSurface,
|
||||
callback: wl_callback::WlCallback) {
|
||||
trace!(self.log, "Frame surface callback.");
|
||||
let token = self.get_token();
|
||||
UserHandler::frame(&mut self.handler, evlh, client, surface, callback, token);
|
||||
}
|
||||
fn set_opaque_region(&mut self, _: &mut EventLoopHandle, _: &Client, surface: &wl_surface::WlSurface,
|
||||
region: Option<&wl_region::WlRegion>) {
|
||||
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);
|
||||
}
|
||||
}
|
||||
fn set_input_region(&mut self, _: &mut EventLoopHandle, _: &Client, surface: &wl_surface::WlSurface,
|
||||
region: Option<&wl_region::WlRegion>) {
|
||||
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);
|
||||
}
|
||||
}
|
||||
fn commit(&mut self, evlh: &mut EventLoopHandle, client: &Client, surface: &wl_surface::WlSurface) {
|
||||
trace!(self.log, "Commit surface callback.");
|
||||
let token = self.get_token();
|
||||
UserHandler::commit(&mut self.handler, evlh, client, surface, token);
|
||||
}
|
||||
fn set_buffer_transform(&mut self, _: &mut EventLoopHandle, _: &Client,
|
||||
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);
|
||||
}
|
||||
}
|
||||
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);
|
||||
}
|
||||
}
|
||||
fn damage_buffer(&mut self, _: &mut EventLoopHandle, _: &Client, surface: &wl_surface::WlSurface,
|
||||
x: i32, y: i32, width: i32, height: i32) {
|
||||
trace!(
|
||||
self.log,
|
||||
"Registering damage to surface (buffer coordinates)."
|
||||
);
|
||||
unsafe {
|
||||
SurfaceData::<U>::with_data(surface, |d| {
|
||||
d.damage = Damage::Buffer(Rectangle {
|
||||
x,
|
||||
y,
|
||||
width,
|
||||
height,
|
||||
})
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
server_declare_handler!(CompositorHandler<U:[], H: [UserHandler<U>]>, wl_surface::Handler, wl_surface::WlSurface);
|
||||
|
||||
impl<U> Destroy<wl_surface::WlSurface> for CompositorDestructor<U> {
|
||||
fn destroy(surface: &wl_surface::WlSurface) {
|
||||
unsafe { SurfaceData::<U>::cleanup(surface) }
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* wl_region
|
||||
*/
|
||||
|
||||
impl<U, H> wl_region::Handler for CompositorHandler<U, 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.");
|
||||
unsafe {
|
||||
RegionData::add_rectangle(
|
||||
region,
|
||||
RectangleKind::Add,
|
||||
Rectangle {
|
||||
x,
|
||||
y,
|
||||
width,
|
||||
height,
|
||||
},
|
||||
)
|
||||
};
|
||||
}
|
||||
fn subtract(&mut self, _: &mut EventLoopHandle, _: &Client, region: &wl_region::WlRegion, x: i32,
|
||||
y: i32, width: i32, height: i32) {
|
||||
trace!(self.log, "Subtracting rectangle to a region.");
|
||||
unsafe {
|
||||
RegionData::add_rectangle(
|
||||
region,
|
||||
RectangleKind::Subtract,
|
||||
Rectangle {
|
||||
x,
|
||||
y,
|
||||
width,
|
||||
height,
|
||||
},
|
||||
)
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
server_declare_handler!(CompositorHandler<U: [], H: []>, wl_region::Handler, wl_region::WlRegion);
|
||||
|
||||
impl<U> Destroy<wl_region::WlRegion> for CompositorDestructor<U> {
|
||||
fn destroy(region: &wl_region::WlRegion) {
|
||||
unsafe { RegionData::cleanup(region) };
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* wl_subcompositor
|
||||
*/
|
||||
|
||||
impl<U, H> wl_subcompositor::Handler for CompositorHandler<U, H>
|
||||
where
|
||||
U: 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
|
||||
}
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
server_declare_handler!(CompositorHandler<U: [Send], H: [Send]>, wl_subcompositor::Handler, wl_subcompositor::WlSubcompositor);
|
||||
|
||||
/*
|
||||
* wl_subsurface
|
||||
*/
|
||||
|
||||
unsafe fn with_subsurface_attributes<U, F>(subsurface: &wl_subsurface::WlSubsurface, f: F)
|
||||
where
|
||||
F: FnOnce(&mut SubsurfaceAttributes),
|
||||
{
|
||||
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()));
|
||||
}
|
||||
|
||||
impl<U, H> wl_subsurface::Handler for CompositorHandler<U, H> {
|
||||
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| {
|
||||
attrs.x = x;
|
||||
attrs.y = y;
|
||||
});
|
||||
}
|
||||
}
|
||||
fn place_above(&mut self, _: &mut EventLoopHandle, _: &Client,
|
||||
subsurface: &wl_subsurface::WlSubsurface, sibling: &wl_surface::WlSurface) {
|
||||
trace!(self.log, "Setting subsurface above an other.");
|
||||
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) {
|
||||
subsurface.post_error(wl_subsurface::Error::BadSurface as u32, "Provided surface is not a sibling or parent.".into());
|
||||
}
|
||||
}
|
||||
}
|
||||
fn place_below(&mut self, _: &mut EventLoopHandle, _: &Client,
|
||||
subsurface: &wl_subsurface::WlSubsurface, sibling: &wl_surface::WlSurface) {
|
||||
trace!(self.log, "Setting subsurface below an other.");
|
||||
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) {
|
||||
subsurface.post_error(wl_subsurface::Error::BadSurface as u32, "Provided surface is not a sibling or parent.".into());
|
||||
}
|
||||
}
|
||||
}
|
||||
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; });
|
||||
}
|
||||
}
|
||||
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; });
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
server_declare_handler!(CompositorHandler<U: [], H: []>, wl_subsurface::Handler, wl_subsurface::WlSubsurface);
|
||||
|
||||
impl<U> Destroy<wl_subsurface::WlSubsurface> for CompositorDestructor<U> {
|
||||
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);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,490 @@
|
|||
//! Utilities for handling surfaces, subsurfaces and regions
|
||||
//!
|
||||
//! This module provides the `CompositorHandler<U,H>` type, with implements
|
||||
//! automatic handling of sufaces, subsurfaces and region wayland objects,
|
||||
//! by being registered as a global handler for `wl_compositor` and
|
||||
//! `wl_subcompositor`.
|
||||
//!
|
||||
//! ## Why use this handler
|
||||
//!
|
||||
//! This handler does a simple job: it stores in a coherent way the state of
|
||||
//! surface trees with subsurfaces, to provide you a direct access to the tree
|
||||
//! structure and all surface metadata.
|
||||
//!
|
||||
//! As such, you can, given a root surface with a role requiring it to be displayed,
|
||||
//! you can iterate over the whole tree of subsurfaces to recover all the metadata you
|
||||
//! need to display the subsurface tree.
|
||||
//!
|
||||
//! This handler will not do anything more than present you the metadata specified by the
|
||||
//! client in a coherent and practical way. All the logic regarding to drawing itself, and
|
||||
//! the positionning of windows (surface trees) one relative to another is out of its scope.
|
||||
//!
|
||||
//! ## How to use it
|
||||
//!
|
||||
//! ### Initialization
|
||||
//!
|
||||
//! To initialize this handler, simply instanciate it and register it to the event loop
|
||||
//! as a global handler for wl_compositor and wl_subcompositor:
|
||||
//!
|
||||
//! ```
|
||||
//! # extern crate wayland_server;
|
||||
//! # extern crate smithay;
|
||||
//! use wayland_server::protocol::wl_compositor::WlCompositor;
|
||||
//! use wayland_server::protocol::wl_subcompositor::WlSubcompositor;
|
||||
//! use smithay::compositor;
|
||||
//!
|
||||
//! // Define some user data to be associated with the surfaces.
|
||||
//! // It must implement the Default trait, which will represent the state of a surface which
|
||||
//! // has just been created.
|
||||
//! #[derive(Default)]
|
||||
//! struct MyData {
|
||||
//! // whatever you need here
|
||||
//! }
|
||||
//!
|
||||
//! // 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 {
|
||||
//! // 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>;
|
||||
//!
|
||||
//! # fn main() {
|
||||
//! # let (_display, mut event_loop) = wayland_server::create_display();
|
||||
//!
|
||||
//! // Instanciate the CompositorHandler and give it to the event loop
|
||||
//! let compositor_hid = event_loop.add_handler_with_init(
|
||||
//! MyCompositorHandler::new(MyHandler{ /* ... */ }, None /* put a logger here */)
|
||||
//! );
|
||||
//!
|
||||
//! // Register it as a handler for wl_compositor
|
||||
//! event_loop.register_global::<WlCompositor, MyCompositorHandler>(compositor_hid, 4);
|
||||
//!
|
||||
//! // Register it as a handler for wl_subcompositor
|
||||
//! event_loop.register_global::<WlSubcompositor, MyCompositorHandler>(compositor_hid, 1);
|
||||
//!
|
||||
//! // retrieve the token needed to access the surfaces' metadata
|
||||
//! let compositor_token = {
|
||||
//! let state = event_loop.state();
|
||||
//! state.get_handler::<MyCompositorHandler>(compositor_hid).get_token()
|
||||
//! };
|
||||
//!
|
||||
//! // You're now ready to go!
|
||||
//! # }
|
||||
//! ```
|
||||
//!
|
||||
//! ### Use the surface metadata
|
||||
//!
|
||||
//! As you can see in the previous example, in the end we are retrieving a token from
|
||||
//! the `CompositorHandler`. This token is necessary to retrieve the metadata associated with
|
||||
//! a surface. It can be cloned, and is sendable accross threads. See `CompositorToken` for
|
||||
//! the details of what it enables you.
|
||||
//!
|
||||
//! The surface metadata is held in the `SurfaceAttributes` struct. In contains double-buffered
|
||||
//! 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.
|
||||
|
||||
mod global;
|
||||
mod handlers;
|
||||
mod tree;
|
||||
mod region;
|
||||
|
||||
use self::region::RegionData;
|
||||
pub use self::tree::{RoleStatus, TraversalAction};
|
||||
use self::tree::SurfaceData;
|
||||
use wayland_server::{Client, EventLoopHandle, Init, resource_is_registered};
|
||||
|
||||
use wayland_server::protocol::{wl_buffer, wl_callback, wl_output, wl_region, wl_surface};
|
||||
|
||||
/// Description of which part of a surface
|
||||
/// should be considered damaged and needs to be redrawn
|
||||
pub enum Damage {
|
||||
/// The whole surface must be considered damaged (this is the default)
|
||||
Full,
|
||||
/// A rectangle containing the damaged zone, in surface coordinates
|
||||
Surface(Rectangle),
|
||||
/// A rectangle containing the damaged zone, in buffer coordinates
|
||||
///
|
||||
/// Note: Buffer scaling must be taken into consideration
|
||||
Buffer(Rectangle),
|
||||
}
|
||||
|
||||
/// Data associated with a surface, aggreged by the handlers
|
||||
///
|
||||
/// Most of the fields of this struct represent a double-buffered state, which
|
||||
/// should only be applied once a `commit` request is received from the surface.
|
||||
///
|
||||
/// You are responsible for setting those values as you see fit to avoid
|
||||
/// processing them two times.
|
||||
pub struct SurfaceAttributes<U> {
|
||||
/// Buffer defining the contents of the surface
|
||||
///
|
||||
/// The tuple represent the coordinates of this buffer
|
||||
/// relative to the location of the current buffer.
|
||||
///
|
||||
/// If set to `Some(None)`, it means the user specifically asked for the
|
||||
/// surface to be unmapped.
|
||||
///
|
||||
/// You are free to set this field to `None` to avoid processing it several
|
||||
/// times. It'll be set to `Some(...)` if the user attaches a buffer (or NULL) to
|
||||
/// the surface.
|
||||
pub buffer: Option<Option<(wl_buffer::WlBuffer, (i32, i32))>>,
|
||||
/// Scale of the contents of the buffer, for higher-resolution contents.
|
||||
///
|
||||
/// If it matches the one of the output displaying this surface, no change
|
||||
/// is necessary.
|
||||
pub buffer_scale: i32,
|
||||
/// Transform under which interpret the contents of the buffer
|
||||
///
|
||||
/// If it matches the one of the output displaying this surface, no change
|
||||
/// is necessary.
|
||||
pub buffer_transform: wl_output::Transform,
|
||||
/// Region of the surface that is guaranteed to be opaque
|
||||
///
|
||||
/// By default the whole surface is potentially transparent
|
||||
pub opaque_region: Option<RegionAttributes>,
|
||||
/// Region of the surface that is sensitive to user input
|
||||
///
|
||||
/// By default the whole surface should be sensitive
|
||||
pub input_region: Option<RegionAttributes>,
|
||||
/// Damage rectangle
|
||||
///
|
||||
/// 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.
|
||||
pub user_data: U,
|
||||
}
|
||||
|
||||
impl<U: Default> Default for SurfaceAttributes<U> {
|
||||
fn default() -> SurfaceAttributes<U> {
|
||||
SurfaceAttributes {
|
||||
buffer: None,
|
||||
buffer_scale: 1,
|
||||
buffer_transform: wl_output::Transform::Normal,
|
||||
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 {
|
||||
/// Horizontal location of the top-left corner of this sub-surface relative to
|
||||
/// the top-left corner of its parent
|
||||
pub x: i32,
|
||||
/// Vertical location of the top-left corner of this sub-surface relative to
|
||||
/// the top-left corner of its parent
|
||||
pub y: i32,
|
||||
/// Sync status of this sub-surface
|
||||
///
|
||||
/// If `true`, this surface should be repainted synchronously with its parent
|
||||
/// if `false`, it should be considered independant of its parent regarding
|
||||
/// repaint timings.
|
||||
pub sync: bool,
|
||||
}
|
||||
|
||||
impl Default for SubsurfaceAttributes {
|
||||
fn default() -> SubsurfaceAttributes {
|
||||
SubsurfaceAttributes {
|
||||
x: 0,
|
||||
y: 0,
|
||||
sync: true,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Kind of a rectangle part of a region
|
||||
#[derive(Copy, Clone)]
|
||||
pub enum RectangleKind {
|
||||
/// This rectangle should be added to the region
|
||||
Add,
|
||||
/// The intersection of this rectangle with the region should
|
||||
/// be removed from the region
|
||||
Subtract,
|
||||
}
|
||||
|
||||
/// A rectangle defined by its top-left corner and dimensions
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct Rectangle {
|
||||
/// horizontal position of the top-leftcorner of the rectangle, in surface coordinates
|
||||
pub x: i32,
|
||||
/// vertical position of the top-leftcorner of the rectangle, in surface coordinates
|
||||
pub y: i32,
|
||||
/// width of the rectangle
|
||||
pub width: i32,
|
||||
/// height of the rectangle
|
||||
pub height: i32,
|
||||
}
|
||||
|
||||
/// Description of the contents of a region
|
||||
///
|
||||
/// A region is defined as an union and difference of 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)]
|
||||
pub struct RegionAttributes {
|
||||
/// List of rectangle part of this region
|
||||
pub rects: Vec<(RectangleKind, Rectangle)>,
|
||||
}
|
||||
|
||||
impl Default for RegionAttributes {
|
||||
fn default() -> RegionAttributes {
|
||||
RegionAttributes { rects: Vec::new() }
|
||||
}
|
||||
}
|
||||
|
||||
/// A Compositor global token
|
||||
///
|
||||
/// 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> {
|
||||
hid: usize,
|
||||
_data: ::std::marker::PhantomData<*mut U>,
|
||||
_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> {}
|
||||
|
||||
// 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> {
|
||||
*self
|
||||
}
|
||||
}
|
||||
|
||||
impl<U: Send + 'static, H: Handler<U> + Send + 'static> CompositorToken<U, H> {
|
||||
/// Access the data of a surface
|
||||
///
|
||||
/// The closure will be called with the contents of the data associated with this surface.
|
||||
///
|
||||
/// 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_data<F>(&self, surface: &wl_surface::WlSurface, f: F)
|
||||
where
|
||||
F: FnOnce(&mut SurfaceAttributes<U>),
|
||||
{
|
||||
assert!(
|
||||
resource_is_registered::<_, CompositorHandler<U, H>>(surface, self.hid),
|
||||
"Accessing the data of foreign surfaces is not supported."
|
||||
);
|
||||
unsafe {
|
||||
SurfaceData::<U>::with_data(surface, f);
|
||||
}
|
||||
}
|
||||
|
||||
/// 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.
|
||||
///
|
||||
/// 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>,
|
||||
{
|
||||
assert!(
|
||||
resource_is_registered::<_, CompositorHandler<U, H>>(surface, self.hid),
|
||||
"Accessing the data of foreign surfaces is not supported."
|
||||
);
|
||||
unsafe {
|
||||
SurfaceData::<U>::map_tree(surface, initial, f);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Retrieve the parent of this surface
|
||||
///
|
||||
/// Returns `None` is this surface is a root surface
|
||||
///
|
||||
/// 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 get_parent(&self, surface: &wl_surface::WlSurface) -> Option<wl_surface::WlSurface> {
|
||||
assert!(
|
||||
resource_is_registered::<_, CompositorHandler<U, H>>(surface, self.hid),
|
||||
"Accessing the data of foreign surfaces is not supported."
|
||||
);
|
||||
unsafe { SurfaceData::<U>::get_parent(surface) }
|
||||
}
|
||||
|
||||
/// Retrieve the children of this surface
|
||||
///
|
||||
/// 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 get_children(&self, surface: &wl_surface::WlSurface) -> Vec<wl_surface::WlSurface> {
|
||||
assert!(
|
||||
resource_is_registered::<_, CompositorHandler<U, H>>(surface, self.hid),
|
||||
"Accessing the data of foreign surfaces is not supported."
|
||||
);
|
||||
unsafe { SurfaceData::<U>::get_children(surface) }
|
||||
}
|
||||
|
||||
/// Retrieve the role status this surface
|
||||
///
|
||||
/// 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 {
|
||||
assert!(
|
||||
resource_is_registered::<_, CompositorHandler<U, H>>(surface, self.hid),
|
||||
"Accessing the data of foreign surfaces is not supported."
|
||||
);
|
||||
unsafe { SurfaceData::<U>::role_status(surface) }
|
||||
}
|
||||
|
||||
/// Register that this surface has a role
|
||||
///
|
||||
/// This makes this surface impossible to become a subsurface, as
|
||||
/// a surface can only have a single role at a time.
|
||||
///
|
||||
/// 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<(), ()> {
|
||||
assert!(
|
||||
resource_is_registered::<_, CompositorHandler<U, H>>(surface, self.hid),
|
||||
"Accessing the data of foreign surfaces is not supported."
|
||||
);
|
||||
unsafe { SurfaceData::<U>::give_role(surface) }
|
||||
}
|
||||
|
||||
/// Register that this surface has no role
|
||||
///
|
||||
/// 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.
|
||||
///
|
||||
/// 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<(), ()> {
|
||||
assert!(
|
||||
resource_is_registered::<_, CompositorHandler<U, H>>(surface, self.hid),
|
||||
"Accessing the data of foreign surfaces is not supported."
|
||||
);
|
||||
unsafe { SurfaceData::<U>::remove_role(surface) }
|
||||
}
|
||||
|
||||
/// Retrieve the metadata associated with a wl_region
|
||||
///
|
||||
/// If the region is not managed by the CompositorGlobal that provided this token, this
|
||||
/// 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),
|
||||
"Accessing the data of foreign regions is not supported."
|
||||
);
|
||||
unsafe { RegionData::get_attributes(region) }
|
||||
}
|
||||
}
|
||||
|
||||
/// A struct handling the `wl_compositor` and `wl_subcompositor` globals
|
||||
///
|
||||
/// It allows you to choose a custom `U` type to store data you want
|
||||
/// associated with the surfaces in their metadata, as well a providing
|
||||
/// a sub-handler to handle the events defined by the `Handler` trait
|
||||
/// defined in this module.
|
||||
///
|
||||
/// See the module-level documentation for instructions and examples of use.
|
||||
pub struct CompositorHandler<U, H> {
|
||||
my_id: usize,
|
||||
log: ::slog::Logger,
|
||||
handler: H,
|
||||
_data: ::std::marker::PhantomData<U>,
|
||||
}
|
||||
|
||||
impl<U, H> Init for CompositorHandler<U, 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> {
|
||||
/// Create a new CompositorHandler
|
||||
pub fn new<L>(handler: H, logger: L) -> CompositorHandler<U, H>
|
||||
where
|
||||
L: Into<Option<::slog::Logger>>,
|
||||
{
|
||||
let log = ::slog_or_stdlog(logger);
|
||||
CompositorHandler {
|
||||
my_id: ::std::usize::MAX,
|
||||
log: log.new(o!("smithay_module" => "compositor_handler")),
|
||||
handler: handler,
|
||||
_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> {
|
||||
assert!(
|
||||
self.my_id != ::std::usize::MAX,
|
||||
"CompositorHandler is not initialized yet."
|
||||
);
|
||||
trace!(self.log, "Creating a compositor token.");
|
||||
CompositorToken {
|
||||
hid: self.my_id,
|
||||
_data: ::std::marker::PhantomData,
|
||||
_handler: ::std::marker::PhantomData,
|
||||
}
|
||||
}
|
||||
|
||||
/// Access the underlying sub-handler
|
||||
pub fn get_handler(&mut self) -> &mut H {
|
||||
&mut self.handler
|
||||
}
|
||||
}
|
||||
|
||||
/// Sub-handler trait for surface event handling
|
||||
///
|
||||
/// The global provided by Smithay cannot process these events for you, so they
|
||||
/// 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 {
|
||||
/// The double-buffered state has been validated by the client
|
||||
///
|
||||
/// At this point, the pending state that has been accumulated in the `SurfaceAttributes` associated
|
||||
/// to this surface should be integrated into the current state of the surface.
|
||||
///
|
||||
/// 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>) {
|
||||
}
|
||||
/// The client asks to be notified when would be a good time to update the contents of this surface
|
||||
///
|
||||
/// You must keep the provided `WlCallback` and trigger it at the appropriate time by calling
|
||||
/// its `done()` method.
|
||||
///
|
||||
/// 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>) {
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,44 @@
|
|||
use super::{Rectangle, RectangleKind, RegionAttributes};
|
||||
|
||||
use std::sync::Mutex;
|
||||
use wayland_server::Resource;
|
||||
|
||||
use wayland_server::protocol::wl_region;
|
||||
|
||||
#[derive(Default)]
|
||||
pub struct RegionData {
|
||||
attributes: RegionAttributes,
|
||||
}
|
||||
|
||||
impl RegionData {
|
||||
/// Initialize the user_data of a region, must be called right when the surface is created
|
||||
pub unsafe fn init(region: &wl_region::WlRegion) {
|
||||
region.set_user_data(Box::into_raw(
|
||||
Box::new(Mutex::new(RegionData::default())),
|
||||
) as *mut _)
|
||||
}
|
||||
|
||||
/// Cleans the user_data of that surface, must be called when it is destroyed
|
||||
pub unsafe fn cleanup(region: &wl_region::WlRegion) {
|
||||
let ptr = region.get_user_data();
|
||||
region.set_user_data(::std::ptr::null_mut());
|
||||
let _my_data_mutex: Box<Mutex<RegionData>> = Box::from_raw(ptr as *mut _);
|
||||
}
|
||||
|
||||
unsafe fn get_data(region: &wl_region::WlRegion) -> &Mutex<RegionData> {
|
||||
let ptr = region.get_user_data();
|
||||
&*(ptr as *mut _)
|
||||
}
|
||||
|
||||
pub unsafe fn get_attributes(region: &wl_region::WlRegion) -> RegionAttributes {
|
||||
let data_mutex = Self::get_data(region);
|
||||
let data_guard = data_mutex.lock().unwrap();
|
||||
data_guard.attributes.clone()
|
||||
}
|
||||
|
||||
pub unsafe fn add_rectangle(region: &wl_region::WlRegion, kind: RectangleKind, rect: Rectangle) {
|
||||
let data_mutex = Self::get_data(region);
|
||||
let mut data_guard = data_mutex.lock().unwrap();
|
||||
data_guard.attributes.rects.push((kind, rect));
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,340 @@
|
|||
use super::SurfaceAttributes;
|
||||
use std::sync::Mutex;
|
||||
|
||||
use wayland_server::{Liveness, Resource};
|
||||
use wayland_server::protocol::wl_surface;
|
||||
|
||||
/// Node of a subsurface tree, holding some user specified data type U
|
||||
/// at each node
|
||||
///
|
||||
/// This type is internal to Smithay, and should not appear in the
|
||||
/// public API
|
||||
///
|
||||
/// It is a bidirectionnal tree, meaning we can move along it in both
|
||||
/// direction (top-bottom or bottom-up). We are taking advantage of the
|
||||
/// fact that lifetime of objects are decided by wayland-server to ensure
|
||||
/// the cleanup will be done properly, and we won't leak anything.
|
||||
///
|
||||
/// This implementation is not strictly a tree, but rather a directed graph
|
||||
/// with the constraint that node can have at most one incoming edge. Aka like
|
||||
/// a tree, but with loops allowed. This is because the wayland protocol does not
|
||||
/// have a failure case to forbid this. Note that if any node in such a graph does not
|
||||
/// have a parent, then the graph is a tree and this node is its root.
|
||||
///
|
||||
/// 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> {
|
||||
parent: Option<wl_surface::WlSurface>,
|
||||
children: Vec<wl_surface::WlSurface>,
|
||||
has_role: bool,
|
||||
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,
|
||||
}
|
||||
|
||||
/// Possible actions to do after handling a node diring tree traversal
|
||||
pub enum TraversalAction<T> {
|
||||
/// Traverse its children as well, providing them the data T
|
||||
DoChildren(T),
|
||||
/// Skip its children
|
||||
SkipChildren,
|
||||
/// Stop traversal completely
|
||||
Break,
|
||||
}
|
||||
|
||||
impl<U: Default> SurfaceData<U> {
|
||||
fn new() -> SurfaceData<U> {
|
||||
SurfaceData {
|
||||
parent: None,
|
||||
children: Vec::new(),
|
||||
has_role: false,
|
||||
attributes: Default::default(),
|
||||
}
|
||||
}
|
||||
|
||||
/// 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())),
|
||||
) as *mut _)
|
||||
}
|
||||
}
|
||||
|
||||
impl<U> SurfaceData<U> {
|
||||
unsafe fn get_data(surface: &wl_surface::WlSurface) -> &Mutex<SurfaceData<U>> {
|
||||
let ptr = surface.get_user_data();
|
||||
&*(ptr as *mut _)
|
||||
}
|
||||
|
||||
/// Cleans the user_data of that surface, must be called when it is destroyed
|
||||
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 mut my_data = my_data_mutex.into_inner().unwrap();
|
||||
if let Some(old_parent) = my_data.parent.take() {
|
||||
if !old_parent.equals(surface) {
|
||||
// We had a parent that is not ourselves, lets unregister ourselves from it
|
||||
let old_parent_mutex = Self::get_data(&old_parent);
|
||||
let mut old_parent_guard = old_parent_mutex.lock().unwrap();
|
||||
old_parent_guard.children.retain(|c| !c.equals(surface));
|
||||
}
|
||||
}
|
||||
// orphan all our children
|
||||
for child in &my_data.children {
|
||||
// don't do anything if this child is ourselves
|
||||
if child.equals(surface) {
|
||||
continue;
|
||||
}
|
||||
let child_mutex = Self::get_data(child);
|
||||
let mut child_guard = child_mutex.lock().unwrap();
|
||||
child_guard.parent = None;
|
||||
}
|
||||
}
|
||||
|
||||
/// Retrieve the current role status of this surface
|
||||
pub unsafe fn role_status(surface: &wl_surface::WlSurface) -> RoleStatus {
|
||||
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!(),
|
||||
}
|
||||
}
|
||||
|
||||
/// Register that this surface has a role, fails if it already has one
|
||||
pub unsafe fn give_role(surface: &wl_surface::WlSurface) -> Result<(), ()> {
|
||||
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(())
|
||||
}
|
||||
|
||||
/// Register that this surface has no role
|
||||
///
|
||||
/// 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<(), ()> {
|
||||
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(())
|
||||
}
|
||||
|
||||
/// 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)
|
||||
-> Result<(), ()> {
|
||||
debug_assert!(child.status() == Liveness::Alive);
|
||||
debug_assert!(parent.status() == Liveness::Alive);
|
||||
|
||||
// change child's parent
|
||||
{
|
||||
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(());
|
||||
}
|
||||
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
|
||||
{
|
||||
let parent_mutex = Self::get_data(parent);
|
||||
let mut parent_guard = parent_mutex.lock().unwrap();
|
||||
parent_guard.children.push(child.clone_unchecked())
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Remove a pre-existing parent of this child
|
||||
///
|
||||
/// Does nothing if it has no parent
|
||||
pub unsafe fn unset_parent(child: &wl_surface::WlSurface) {
|
||||
debug_assert!(child.status() == Liveness::Alive);
|
||||
let old_parent = {
|
||||
let child_mutex = Self::get_data(child);
|
||||
let mut child_guard = child_mutex.lock().unwrap();
|
||||
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;
|
||||
}
|
||||
old_parent
|
||||
};
|
||||
// unregister from our parent
|
||||
if let Some(old_parent) = old_parent {
|
||||
let parent_mutex = Self::get_data(&old_parent);
|
||||
let mut parent_guard = parent_mutex.lock().unwrap();
|
||||
parent_guard.children.retain(|c| !c.equals(child));
|
||||
}
|
||||
}
|
||||
|
||||
/// Retrieve the parent surface (if any) of this surface
|
||||
pub unsafe fn get_parent(child: &wl_surface::WlSurface) -> Option<wl_surface::WlSurface> {
|
||||
let child_mutex = Self::get_data(child);
|
||||
let child_guard = child_mutex.lock().unwrap();
|
||||
child_guard.parent.as_ref().map(|p| p.clone_unchecked())
|
||||
}
|
||||
|
||||
/// Retrieve the parent surface (if any) of this surface
|
||||
pub unsafe fn get_children(child: &wl_surface::WlSurface) -> Vec<wl_surface::WlSurface> {
|
||||
let child_mutex = Self::get_data(child);
|
||||
let child_guard = child_mutex.lock().unwrap();
|
||||
child_guard
|
||||
.children
|
||||
.iter()
|
||||
.map(|p| p.clone_unchecked())
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// Reorders a surface relative to one of its sibling
|
||||
///
|
||||
/// Fails if `relative_to` is not a sibling or parent of `surface`.
|
||||
pub unsafe fn reorder(surface: &wl_surface::WlSurface, to: Location,
|
||||
relative_to: &wl_surface::WlSurface)
|
||||
-> Result<(), ()> {
|
||||
let parent = {
|
||||
let data_mutex = Self::get_data(surface);
|
||||
let data_guard = data_mutex.lock().unwrap();
|
||||
data_guard
|
||||
.parent
|
||||
.as_ref()
|
||||
.map(|p| p.clone_unchecked())
|
||||
.unwrap()
|
||||
};
|
||||
if parent.equals(relative_to) {
|
||||
// TODO: handle positioning relative to parent
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
fn index_of(surface: &wl_surface::WlSurface, slice: &[wl_surface::WlSurface]) -> Option<usize> {
|
||||
for (i, s) in slice.iter().enumerate() {
|
||||
if s.equals(surface) {
|
||||
return Some(i);
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
let parent_mutex = Self::get_data(&parent);
|
||||
let mut parent_guard = parent_mutex.lock().unwrap();
|
||||
let my_index = index_of(surface, &parent_guard.children).unwrap();
|
||||
let mut other_index = match index_of(surface, &parent_guard.children) {
|
||||
Some(idx) => idx,
|
||||
None => return Err(()),
|
||||
};
|
||||
let me = parent_guard.children.remove(my_index);
|
||||
if my_index < other_index {
|
||||
other_index -= 1;
|
||||
}
|
||||
let new_index = match to {
|
||||
Location::Before => other_index,
|
||||
Location::After => other_index + 1,
|
||||
};
|
||||
parent_guard.children.insert(new_index, me);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// 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)
|
||||
where
|
||||
F: FnOnce(&mut SurfaceAttributes<U>),
|
||||
{
|
||||
let data_mutex = Self::get_data(surface);
|
||||
let mut data_guard = data_mutex.lock().unwrap();
|
||||
f(&mut data_guard.attributes)
|
||||
}
|
||||
|
||||
/// Access sequentially the attributes associated with a surface tree,
|
||||
/// in a depth-first order
|
||||
///
|
||||
/// Note that an internal lock is taken during access of this data,
|
||||
/// so the tree cannot be manipulated at the same time.
|
||||
///
|
||||
/// The callback returns wether the traversal should continue or not. Returning
|
||||
/// 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>,
|
||||
{
|
||||
// helper function for recursion
|
||||
unsafe fn map<U, 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>,
|
||||
{
|
||||
// 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 mut data_guard = data_mutex.lock().unwrap();
|
||||
// call the callback on ourselves
|
||||
match f(surface, &mut data_guard.attributes, initial) {
|
||||
TraversalAction::DoChildren(t) => {
|
||||
// loop over children
|
||||
for c in &data_guard.children {
|
||||
if !map(c, root, &t, f) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
true
|
||||
}
|
||||
TraversalAction::SkipChildren => true,
|
||||
TraversalAction::Break => false,
|
||||
}
|
||||
}
|
||||
|
||||
let data_mutex = Self::get_data(root);
|
||||
let mut data_guard = data_mutex.lock().unwrap();
|
||||
// call the callback on ourselves
|
||||
match f(root, &mut data_guard.attributes, &initial) {
|
||||
TraversalAction::DoChildren(t) => {
|
||||
// loop over children
|
||||
for c in &data_guard.children {
|
||||
if !map::<U, _, _>(c, root, &t, &mut f) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -32,8 +32,10 @@ extern crate glium;
|
|||
extern crate slog;
|
||||
extern crate slog_stdlog;
|
||||
|
||||
pub mod shm;
|
||||
pub mod backend;
|
||||
|
||||
pub mod compositor;
|
||||
pub mod shm;
|
||||
pub mod keyboard;
|
||||
|
||||
fn slog_or_stdlog<L>(logger: L) -> ::slog::Logger
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@
|
|||
//!
|
||||
//! To use it, first add a `ShmGlobal` to your event loop, specifying the formats
|
||||
//! you want to support (ARGB8888 and XRGB8888 are always considered as supported,
|
||||
//! as specified by the wayland protocol) and obtain its `ShmGlobalToken`.
|
||||
//! as specified by the wayland protocol) and obtain its `ShmToken`.
|
||||
//!
|
||||
//! ```
|
||||
//! extern crate wayland_server;
|
||||
|
|
@ -110,8 +110,8 @@ impl ShmGlobal {
|
|||
/// and has been initialized. If it is not the case, this method will panic.
|
||||
///
|
||||
/// This is needed to retrieve the contents of the shm pools and buffers.
|
||||
pub fn get_token(&self) -> ShmGlobalToken {
|
||||
ShmGlobalToken { hid: self.handler_id.expect("ShmGlobal was not initialized.") }
|
||||
pub fn get_token(&self) -> ShmToken {
|
||||
ShmToken { hid: self.handler_id.expect("ShmGlobal was not initialized.") }
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -119,7 +119,8 @@ impl ShmGlobal {
|
|||
///
|
||||
/// It is needed to access the contents of the buffers & pools managed by the
|
||||
/// associated `ShmGlobal`.
|
||||
pub struct ShmGlobalToken {
|
||||
#[derive(Clone)]
|
||||
pub struct ShmToken {
|
||||
hid: usize,
|
||||
}
|
||||
|
||||
|
|
@ -136,7 +137,7 @@ pub enum BufferAccessError {
|
|||
BadMap,
|
||||
}
|
||||
|
||||
impl ShmGlobalToken {
|
||||
impl ShmToken {
|
||||
/// Call given closure with the contents of the given buffer
|
||||
///
|
||||
/// If the buffer is managed by the associated ShmGlobal, its contents are
|
||||
|
|
|
|||
Loading…
Reference in New Issue