desktop: Add new desktop abstractions module

Adds a new `Window` and `Space` abstraction to make it easier
to handle windows of various shells and their positions in a
compositor space.

Cargo.toml

@@ -29,6 +29,7 @@ drm = { version = "0.5.0", optional = true }
 drm-ffi = { version = "0.2.0", optional = true }
 gbm = { version = "0.7.0", optional = true, default-features = false, features = ["drm-support"] }
 input = { version = "0.7", default-features = false, features=["libinput_1_14"], optional = true }
+indexmap = { version = "1.7", optional = true }
 lazy_static = "1"
 libc = "0.2.103"
 libseat= { version = "0.1.1", optional = true }
@@ -59,7 +60,7 @@ gl_generator = { version = "0.14", optional = true }
 pkg-config = { version = "0.3.17", optional = true }
 
 [features]
-default = ["backend_drm", "backend_gbm", "backend_libinput", "backend_udev", "backend_session_logind", "backend_winit", "renderer_gl", "xwayland", "wayland_frontend", "slog-stdlog", "backend_x11"]
+default = ["backend_drm", "backend_gbm", "backend_libinput", "backend_udev", "backend_session_logind", "backend_winit", "desktop", "renderer_gl", "xwayland", "wayland_frontend", "slog-stdlog", "backend_x11"]
 backend_winit = ["winit", "wayland-server/dlopen", "backend_egl", "wayland-egl", "renderer_gl"]
 backend_x11 = ["x11rb", "x11rb/dri3", "x11rb/xfixes", "x11rb/present", "x11rb_event_source", "backend_gbm", "backend_drm", "backend_egl"]
 backend_drm = ["drm", "drm-ffi"]
@@ -71,6 +72,7 @@ backend_udev = ["udev", "input/udev"]
 backend_session_logind = ["dbus", "backend_session", "pkg-config"]
 backend_session_elogind = ["backend_session_logind"]
 backend_session_libseat = ["backend_session", "libseat"]
+desktop = ["indexmap", "wayland_frontend"]
 renderer_gl = ["gl_generator", "backend_egl"]
 use_system_lib = ["wayland_frontend", "wayland-sys", "wayland-server/use_system_lib"]
 wayland_frontend = ["wayland-server", "wayland-commons", "wayland-protocols", "tempfile"]

src/desktop/mod.rs

@@ -0,0 +1,7 @@
+// TODO: Remove - but for now, this makes sure these files are not completely highlighted with warnings
+#![allow(missing_docs, clippy::all)]
+mod space;
+mod window;
+
+pub use self::space::*;
+pub use self::window::*;

src/desktop/space.rs

@@ -0,0 +1,419 @@
+use super::{draw_window, Window};
+use crate::{
+    backend::renderer::{Frame, ImportAll, Renderer, Transform},
+    utils::{Logical, Point, Rectangle},
+    wayland::output::Output,
+};
+use indexmap::{IndexMap, IndexSet};
+use std::{
+    cell::{RefCell, RefMut},
+    collections::{HashMap, HashSet, VecDeque},
+    sync::{
+        atomic::{AtomicUsize, Ordering},
+        Mutex,
+    },
+};
+use wayland_server::protocol::wl_surface;
+
+static SPACE_ID: AtomicUsize = AtomicUsize::new(0);
+lazy_static::lazy_static! {
+    static ref SPACE_IDS: Mutex<HashSet<usize>> = Mutex::new(HashSet::new());
+}
+fn next_space_id() -> usize {
+    let mut ids = SPACE_IDS.lock().unwrap();
+    if ids.len() == usize::MAX {
+        // Theoretically the code below wraps around correctly,
+        // but that is hard to detect and might deadlock.
+        // Maybe make this a debug_assert instead?
+        panic!("Out of space ids");
+    }
+
+    let mut id = SPACE_ID.fetch_add(1, Ordering::SeqCst);
+    while ids.iter().any(|k| *k == id) {
+        id = SPACE_ID.fetch_add(1, Ordering::SeqCst);
+    }
+
+    ids.insert(id);
+    id
+}
+
+#[derive(Default)]
+struct WindowState {
+    location: Point<i32, Logical>,
+    drawn: bool,
+}
+
+type WindowUserdata = RefCell<HashMap<usize, WindowState>>;
+fn window_state(space: usize, w: &Window) -> RefMut<'_, WindowState> {
+    let userdata = w.user_data();
+    userdata.insert_if_missing(WindowUserdata::default);
+    RefMut::map(userdata.get::<WindowUserdata>().unwrap().borrow_mut(), |m| {
+        m.entry(space).or_default()
+    })
+}
+
+#[derive(Clone, Default)]
+struct OutputState {
+    location: Point<i32, Logical>,
+    render_scale: f64,
+    // damage and last_state in space coordinate space
+    old_damage: VecDeque<Vec<Rectangle<i32, Logical>>>,
+    last_state: IndexMap<usize, Rectangle<i32, Logical>>,
+}
+
+type OutputUserdata = RefCell<HashMap<usize, OutputState>>;
+fn output_state(space: usize, o: &Output) -> RefMut<'_, OutputState> {
+    let userdata = o.user_data();
+    userdata.insert_if_missing(OutputUserdata::default);
+    RefMut::map(userdata.get::<OutputUserdata>().unwrap().borrow_mut(), |m| {
+        m.entry(space).or_default()
+    })
+}
+
+// TODO: Maybe replace UnmanagedResource if nothing else comes up?
+#[derive(Debug, thiserror::Error)]
+pub enum SpaceError {
+    #[error("Window is not mapped to this space")]
+    UnknownWindow,
+}
+
+#[derive(Debug)]
+pub struct Space {
+    id: usize,
+    // in z-order, back to front
+    windows: IndexSet<Window>,
+    outputs: Vec<Output>,
+    // TODO:
+    //layers: Vec<Layer>,
+    logger: ::slog::Logger,
+}
+
+impl Drop for Space {
+    fn drop(&mut self) {
+        SPACE_IDS.lock().unwrap().remove(&self.id);
+    }
+}
+
+impl Space {
+    pub fn new<L>(log: L) -> Space
+    where
+        L: Into<slog::Logger>,
+    {
+        Space {
+            id: next_space_id(),
+            windows: IndexSet::new(),
+            outputs: Vec::new(),
+            logger: log.into(),
+        }
+    }
+
+    /// Map window and moves it to top of the stack
+    ///
+    /// This can safely be called on an already mapped window
+    pub fn map_window(&mut self, window: &Window, location: Point<i32, Logical>) -> Result<(), SpaceError> {
+        window_state(self.id, window).location = location;
+        self.windows.shift_remove(window);
+        self.windows.insert(window.clone());
+        Ok(())
+    }
+
+    pub fn raise_window(&mut self, window: &Window) {
+        let loc = window_state(self.id, window).location;
+        let _ = self.map_window(window, loc);
+
+        // TODO: should this be handled by us?
+        window.set_activated(true);
+        for w in self.windows.iter() {
+            if w != window {
+                w.set_activated(false);
+            }
+        }
+    }
+
+    /// Unmap a window from this space by its id
+    pub fn unmap_window(&mut self, window: &Window) {
+        if let Some(map) = window.user_data().get::<WindowUserdata>() {
+            map.borrow_mut().remove(&self.id);
+        }
+        self.windows.shift_remove(window);
+    }
+
+    /// Iterate window in z-order back to front
+    pub fn windows(&self) -> impl Iterator<Item = &Window> {
+        self.windows.iter()
+    }
+
+    /// Get a reference to the window under a given point, if any
+    pub fn window_under(&self, point: Point<f64, Logical>) -> Option<&Window> {
+        self.windows.iter().find(|w| {
+            let loc = window_state(self.id, w).location;
+            let mut bbox = w.bbox();
+            bbox.loc += loc;
+            bbox.to_f64().contains(point)
+        })
+    }
+
+    pub fn window_for_surface(&self, surface: &wl_surface::WlSurface) -> Option<&Window> {
+        if !surface.as_ref().is_alive() {
+            return None;
+        }
+
+        self.windows
+            .iter()
+            .find(|w| w.toplevel().get_surface().map(|x| x == surface).unwrap_or(false))
+    }
+
+    pub fn window_geometry(&self, w: &Window) -> Option<Rectangle<i32, Logical>> {
+        if !self.windows.contains(w) {
+            return None;
+        }
+
+        Some(window_rect(w, &self.id))
+    }
+
+    pub fn map_output(&mut self, output: &Output, scale: f64, location: Point<i32, Logical>) {
+        let mut state = output_state(self.id, output);
+        *state = OutputState {
+            location,
+            render_scale: scale,
+            ..Default::default()
+        };
+        if !self.outputs.contains(output) {
+            self.outputs.push(output.clone());
+        }
+    }
+
+    pub fn outputs(&self) -> impl Iterator<Item = &Output> {
+        self.outputs.iter()
+    }
+
+    pub fn unmap_output(&mut self, output: &Output) {
+        if let Some(map) = output.user_data().get::<OutputUserdata>() {
+            map.borrow_mut().remove(&self.id);
+        }
+        self.outputs.retain(|o| o != output);
+    }
+
+    pub fn output_geometry(&self, o: &Output) -> Option<Rectangle<i32, Logical>> {
+        if !self.outputs.contains(o) {
+            return None;
+        }
+
+        let state = output_state(self.id, o);
+        o.current_mode().map(|mode| {
+            Rectangle::from_loc_and_size(
+                state.location,
+                mode.size.to_f64().to_logical(state.render_scale).to_i32_round(),
+            )
+        })
+    }
+
+    pub fn output_scale(&self, o: &Output) -> Option<f64> {
+        if !self.outputs.contains(o) {
+            return None;
+        }
+
+        let state = output_state(self.id, o);
+        Some(state.render_scale)
+    }
+
+    pub fn output_for_window(&self, w: &Window) -> Option<Output> {
+        if !self.windows.contains(w) {
+            return None;
+        }
+
+        let w_geo = self.window_geometry(w).unwrap();
+        for o in &self.outputs {
+            let o_geo = self.output_geometry(o).unwrap();
+            if w_geo.overlaps(o_geo) {
+                return Some(o.clone());
+            }
+        }
+
+        // TODO primary output
+        self.outputs.get(0).cloned()
+    }
+
+    pub fn cleanup(&mut self) {
+        self.windows.retain(|w| w.toplevel().alive());
+    }
+
+    pub fn render_output<R>(
+        &mut self,
+        renderer: &mut R,
+        output: &Output,
+        age: usize,
+        clear_color: [f32; 4],
+    ) -> Result<bool, RenderError<R>>
+    where
+        R: Renderer + ImportAll,
+        R::TextureId: 'static,
+    {
+        let mut state = output_state(self.id, output);
+        let output_size = output
+            .current_mode()
+            .ok_or(RenderError::OutputNoMode)?
+            .size
+            .to_f64()
+            .to_logical(state.render_scale)
+            .to_i32_round();
+        let output_geo = Rectangle::from_loc_and_size(state.location, output_size);
+
+        // This will hold all the damage we need for this rendering step
+        let mut damage = Vec::<Rectangle<i32, Logical>>::new();
+        // First add damage for windows gone
+        for old_window in state
+            .last_state
+            .iter()
+            .filter_map(|(id, w)| {
+                if !self.windows.iter().any(|w| w.0.id == *id) {
+                    Some(*w)
+                } else {
+                    None
+                }
+            })
+            .collect::<Vec<Rectangle<i32, Logical>>>()
+        {
+            slog::debug!(self.logger, "Removing window at: {:?}", old_window);
+            damage.push(old_window);
+        }
+
+        // lets iterate front to back and figure out, what new windows or unmoved windows we have
+        for window in self.windows.iter().rev() {
+            let geo = window_rect(window, &self.id);
+            let old_geo = state.last_state.get(&window.0.id).cloned();
+
+            // window was moved or resized
+            if old_geo.map(|old_geo| old_geo != geo).unwrap_or(false) {
+                // Add damage for the old position of the window
+                damage.push(old_geo.unwrap());
+            } /* else {
+                  // window stayed at its place
+                  // TODO: Only push surface damage
+                  //       But this would need to take subsurfaces into account and accumulate damage at least.
+                  //       Even better would be if damage would be ignored that is hidden by subsurfaces...
+              }*/
+            // Add damage for the new position (see TODO above for a better approach)
+            damage.push(geo);
+        }
+
+        // That is all completely new damage, which we need to store for subsequent renders
+        let new_damage = damage.clone();
+        // We now add old damage states, if we have an age value
+        if age > 0 && state.old_damage.len() >= age {
+            // We do not need older states anymore
+            state.old_damage.truncate(age);
+            damage.extend(state.old_damage.iter().flatten().copied());
+        } else {
+            // just damage everything, if we have no damage
+            damage = vec![output_geo];
+        }
+
+        // Optimize the damage for rendering
+        damage.retain(|rect| rect.overlaps(output_geo));
+        damage.retain(|rect| rect.size.h > 0 && rect.size.w > 0);
+        for rect in damage.clone().iter() {
+            // if this rect was already removed, because it was smaller as another one,
+            // there is no reason to evaluate this.
+            if damage.contains(rect) {
+                // remove every rectangle that is contained in this rectangle
+                damage.retain(|other| !rect.contains_rect(*other));
+            }
+        }
+
+        let output_transform: Transform = output.current_transform().into();
+        if let Err(err) = renderer.render(
+            output_transform
+                .transform_size(output_size)
+                .to_f64()
+                .to_physical(state.render_scale)
+                .to_i32_round(),
+            output_transform,
+            |renderer, frame| {
+                // First clear all damaged regions
+                for geo in &damage {
+                    slog::debug!(self.logger, "Clearing at {:?}", geo);
+                    frame.clear(
+                        clear_color,
+                        Some(geo.to_f64().to_physical(state.render_scale).to_i32_ceil()),
+                    )?;
+                }
+
+                // Then re-draw all window overlapping with a damage rect.
+                for window in self.windows.iter() {
+                    let wgeo = window_rect(window, &self.id);
+                    let mut loc = window_loc(window, &self.id);
+                    if damage.iter().any(|geo| wgeo.overlaps(*geo)) {
+                        loc -= output_geo.loc;
+                        slog::debug!(self.logger, "Rendering window at {:?}", wgeo);
+                        draw_window(renderer, frame, window, state.render_scale, loc, &self.logger)?;
+                        window_state(self.id, window).drawn = true;
+                    }
+                }
+
+                Result::<(), R::Error>::Ok(())
+            },
+        ) {
+            // if the rendering errors on us, we need to be prepared, that this whole buffer was partially updated and thus now unusable.
+            // thus clean our old states before returning
+            state.old_damage = VecDeque::new();
+            state.last_state = IndexMap::new();
+            return Err(RenderError::Rendering(err));
+        }
+
+        // If rendering was successful capture the state and add the damage
+        state.last_state = self
+            .windows
+            .iter()
+            .map(|window| {
+                let wgeo = window_rect(window, &self.id);
+                (window.0.id, wgeo)
+            })
+            .collect();
+        state.old_damage.push_front(new_damage);
+
+        // Return if we actually rendered something
+        Ok(!damage.is_empty())
+    }
+
+    pub fn send_frames(&self, all: bool, time: u32) {
+        for window in self.windows.iter().filter(|w| {
+            all || {
+                let mut state = window_state(self.id, w);
+                std::mem::replace(&mut state.drawn, false)
+            }
+        }) {
+            window.send_frame(time);
+        }
+    }
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum RenderError<R: Renderer> {
+    #[error(transparent)]
+    Rendering(R::Error),
+    #[error("Output has no active mode")]
+    OutputNoMode,
+}
+
+fn window_rect(window: &Window, space_id: &usize) -> Rectangle<i32, Logical> {
+    let loc = window_loc(window, space_id);
+    window_bbox_with_pos(window, loc)
+}
+
+fn window_loc(window: &Window, space_id: &usize) -> Point<i32, Logical> {
+    window
+        .user_data()
+        .get::<RefCell<HashMap<usize, WindowState>>>()
+        .unwrap()
+        .borrow()
+        .get(space_id)
+        .unwrap()
+        .location
+}
+
+fn window_bbox_with_pos(window: &Window, pos: Point<i32, Logical>) -> Rectangle<i32, Logical> {
+    let mut wgeo = window.bbox();
+    wgeo.loc += pos;
+    wgeo
+}

src/desktop/window.rs

@@ -0,0 +1,510 @@
+use crate::{
+    backend::renderer::{buffer_dimensions, Frame, ImportAll, Renderer, Texture},
+    utils::{Logical, Physical, Point, Rectangle, Size},
+    wayland::{
+        compositor::{
+            add_commit_hook, is_sync_subsurface, with_states, with_surface_tree_downward,
+            with_surface_tree_upward, BufferAssignment, Damage, SubsurfaceCachedState, SurfaceAttributes,
+            TraversalAction,
+        },
+        shell::xdg::{SurfaceCachedState, ToplevelSurface},
+    },
+};
+use std::{
+    cell::RefCell,
+    collections::HashSet,
+    hash::{Hash, Hasher},
+    rc::Rc,
+    sync::{
+        atomic::{AtomicUsize, Ordering},
+        Mutex,
+    },
+};
+use wayland_commons::user_data::UserDataMap;
+use wayland_protocols::xdg_shell::server::xdg_toplevel;
+use wayland_server::protocol::{wl_buffer, wl_surface};
+
+static WINDOW_ID: AtomicUsize = AtomicUsize::new(0);
+lazy_static::lazy_static! {
+    static ref WINDOW_IDS: Mutex<HashSet<usize>> = Mutex::new(HashSet::new());
+}
+
+fn next_window_id() -> usize {
+    let mut ids = WINDOW_IDS.lock().unwrap();
+    if ids.len() == usize::MAX {
+        // Theoretically the code below wraps around correctly,
+        // but that is hard to detect and might deadlock.
+        // Maybe make this a debug_assert instead?
+        panic!("Out of window ids");
+    }
+
+    let mut id = WINDOW_ID.fetch_add(1, Ordering::SeqCst);
+    while ids.iter().any(|k| *k == id) {
+        id = WINDOW_ID.fetch_add(1, Ordering::SeqCst);
+    }
+
+    ids.insert(id);
+    id
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum Kind {
+    Xdg(ToplevelSurface),
+    #[cfg(feature = "xwayland")]
+    X11(X11Surface),
+}
+
+// Big TODO
+#[derive(Debug, Clone)]
+pub struct X11Surface {
+    surface: wl_surface::WlSurface,
+}
+
+impl std::cmp::PartialEq for X11Surface {
+    fn eq(&self, other: &Self) -> bool {
+        self.alive() && other.alive() && self.surface == other.surface
+    }
+}
+
+impl X11Surface {
+    pub fn alive(&self) -> bool {
+        self.surface.as_ref().is_alive()
+    }
+
+    pub fn get_surface(&self) -> Option<&wl_surface::WlSurface> {
+        if self.alive() {
+            Some(&self.surface)
+        } else {
+            None
+        }
+    }
+}
+
+impl Kind {
+    pub fn alive(&self) -> bool {
+        match *self {
+            Kind::Xdg(ref t) => t.alive(),
+            #[cfg(feature = "xwayland")]
+            Kind::X11(ref t) => t.alive(),
+        }
+    }
+
+    pub fn get_surface(&self) -> Option<&wl_surface::WlSurface> {
+        match *self {
+            Kind::Xdg(ref t) => t.get_surface(),
+            #[cfg(feature = "xwayland")]
+            Kind::X11(ref t) => t.get_surface(),
+        }
+    }
+}
+
+#[derive(Default)]
+struct SurfaceState {
+    buffer_dimensions: Option<Size<i32, Physical>>,
+    buffer_scale: i32,
+    buffer: Option<wl_buffer::WlBuffer>,
+    texture: Option<Box<dyn std::any::Any + 'static>>,
+}
+
+fn surface_commit(surface: &wl_surface::WlSurface) {
+    if !is_sync_subsurface(surface) {
+        with_surface_tree_upward(
+            surface,
+            (),
+            |_, _, _| TraversalAction::DoChildren(()),
+            |_surf, states, _| {
+                states
+                    .data_map
+                    .insert_if_missing(|| RefCell::new(SurfaceState::default()));
+                let mut data = states
+                    .data_map
+                    .get::<RefCell<SurfaceState>>()
+                    .unwrap()
+                    .borrow_mut();
+                data.update_buffer(&mut *states.cached_state.current::<SurfaceAttributes>());
+            },
+            |_, _, _| true,
+        );
+    }
+}
+
+impl SurfaceState {
+    pub fn update_buffer(&mut self, attrs: &mut SurfaceAttributes) {
+        match attrs.buffer.take() {
+            Some(BufferAssignment::NewBuffer { buffer, .. }) => {
+                // new contents
+                self.buffer_dimensions = buffer_dimensions(&buffer);
+                self.buffer_scale = attrs.buffer_scale;
+                if let Some(old_buffer) = std::mem::replace(&mut self.buffer, Some(buffer)) {
+                    if &old_buffer != self.buffer.as_ref().unwrap() {
+                        old_buffer.release();
+                    }
+                }
+                self.texture = None;
+            }
+            Some(BufferAssignment::Removed) => {
+                // remove the contents
+                self.buffer_dimensions = None;
+                if let Some(buffer) = self.buffer.take() {
+                    buffer.release();
+                };
+                self.texture = None;
+            }
+            None => {}
+        }
+    }
+
+    /// Returns the size of the surface.
+    pub fn size(&self) -> Option<Size<i32, Logical>> {
+        self.buffer_dimensions
+            .map(|dims| dims.to_logical(self.buffer_scale))
+    }
+
+    fn contains_point(&self, attrs: &SurfaceAttributes, point: Point<f64, Logical>) -> bool {
+        let size = match self.size() {
+            None => return false, // If the surface has no size, it can't have an input region.
+            Some(size) => size,
+        };
+
+        let rect = Rectangle {
+            loc: (0, 0).into(),
+            size,
+        }
+        .to_f64();
+
+        // The input region is always within the surface itself, so if the surface itself doesn't contain the
+        // point we can return false.
+        if !rect.contains(point) {
+            return false;
+        }
+
+        // If there's no input region, we're done.
+        if attrs.input_region.is_none() {
+            return true;
+        }
+
+        attrs
+            .input_region
+            .as_ref()
+            .unwrap()
+            .contains(point.to_i32_floor())
+    }
+}
+
+#[derive(Debug)]
+pub(super) struct WindowInner {
+    pub(super) id: usize,
+    toplevel: Kind,
+    user_data: UserDataMap,
+}
+
+impl Drop for WindowInner {
+    fn drop(&mut self) {
+        WINDOW_IDS.lock().unwrap().remove(&self.id);
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct Window(pub(super) Rc<WindowInner>);
+
+impl PartialEq for Window {
+    fn eq(&self, other: &Self) -> bool {
+        self.0.id == other.0.id
+    }
+}
+
+impl Eq for Window {}
+
+impl Hash for Window {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.0.id.hash(state);
+    }
+}
+
+impl Window {
+    pub fn new(toplevel: Kind) -> Window {
+        let id = next_window_id();
+
+        // TODO: Do we want this? For new lets add Window::commit
+        //add_commit_hook(toplevel.get_surface().unwrap(), surface_commit);
+
+        Window(Rc::new(WindowInner {
+            id,
+            toplevel,
+            user_data: UserDataMap::new(),
+        }))
+    }
+
+    /// Returns the geometry of this window.
+    pub fn geometry(&self) -> Rectangle<i32, Logical> {
+        // It's the set geometry with the full bounding box as the fallback.
+        with_states(self.0.toplevel.get_surface().unwrap(), |states| {
+            states.cached_state.current::<SurfaceCachedState>().geometry
+        })
+        .unwrap()
+        .unwrap_or_else(|| self.bbox())
+    }
+
+    /// A bounding box over this window and its children.
+    // TODO: Cache and document when to trigger updates. If possible let space do it
+    pub fn bbox(&self) -> Rectangle<i32, Logical> {
+        let mut bounding_box = Rectangle::from_loc_and_size((0, 0), (0, 0));
+        if let Some(wl_surface) = self.0.toplevel.get_surface() {
+            with_surface_tree_downward(
+                wl_surface,
+                (0, 0).into(),
+                |_, states, loc: &Point<i32, Logical>| {
+                    let mut loc = *loc;
+                    let data = states.data_map.get::<RefCell<SurfaceState>>();
+
+                    if let Some(size) = data.and_then(|d| d.borrow().size()) {
+                        if states.role == Some("subsurface") {
+                            let current = states.cached_state.current::<SubsurfaceCachedState>();
+                            loc += current.location;
+                        }
+
+                        // Update the bounding box.
+                        bounding_box = bounding_box.merge(Rectangle::from_loc_and_size(loc, size));
+
+                        TraversalAction::DoChildren(loc)
+                    } else {
+                        // If the parent surface is unmapped, then the child surfaces are hidden as
+                        // well, no need to consider them here.
+                        TraversalAction::SkipChildren
+                    }
+                },
+                |_, _, _| {},
+                |_, _, _| true,
+            );
+        }
+        bounding_box
+    }
+
+    /// Activate/Deactivate this window
+    // TODO: Add more helpers for Maximize? Minimize? Fullscreen? I dunno
+    pub fn set_activated(&self, active: bool) -> bool {
+        match self.0.toplevel {
+            Kind::Xdg(ref t) => t
+                .with_pending_state(|state| {
+                    if active {
+                        state.states.set(xdg_toplevel::State::Activated)
+                    } else {
+                        state.states.unset(xdg_toplevel::State::Activated)
+                    }
+                })
+                .unwrap_or(false),
+            #[cfg(feature = "xwayland")]
+            Kind::X11(ref t) => unimplemented!(),
+        }
+    }
+
+    /// Commit any changes to this window
+    pub fn configure(&self) {
+        match self.0.toplevel {
+            Kind::Xdg(ref t) => t.send_configure(),
+            #[cfg(feature = "xwayland")]
+            Kind::X11(ref t) => unimplemented!(),
+        }
+    }
+
+    /// Sends the frame callback to all the subsurfaces in this
+    /// window that requested it
+    pub fn send_frame(&self, time: u32) {
+        if let Some(wl_surface) = self.0.toplevel.get_surface() {
+            with_surface_tree_downward(
+                wl_surface,
+                (),
+                |_, _, &()| TraversalAction::DoChildren(()),
+                |_surf, states, &()| {
+                    // the surface may not have any user_data if it is a subsurface and has not
+                    // yet been commited
+                    for callback in states
+                        .cached_state
+                        .current::<SurfaceAttributes>()
+                        .frame_callbacks
+                        .drain(..)
+                    {
+                        callback.done(time);
+                    }
+                },
+                |_, _, &()| true,
+            );
+        }
+    }
+
+    /// Finds the topmost surface under this point if any and returns it together with the location of this
+    /// surface.
+    pub fn surface_under(
+        &self,
+        point: Point<f64, Logical>,
+    ) -> Option<(wl_surface::WlSurface, Point<i32, Logical>)> {
+        let found = RefCell::new(None);
+        if let Some(wl_surface) = self.0.toplevel.get_surface() {
+            with_surface_tree_downward(
+                wl_surface,
+                (0, 0).into(),
+                |wl_surface, states, location: &Point<i32, Logical>| {
+                    let mut location = *location;
+                    let data = states.data_map.get::<RefCell<SurfaceState>>();
+
+                    if states.role == Some("subsurface") {
+                        let current = states.cached_state.current::<SubsurfaceCachedState>();
+                        location += current.location;
+                    }
+
+                    let contains_the_point = data
+                        .map(|data| {
+                            data.borrow()
+                                .contains_point(&*states.cached_state.current(), point - location.to_f64())
+                        })
+                        .unwrap_or(false);
+                    if contains_the_point {
+                        *found.borrow_mut() = Some((wl_surface.clone(), location));
+                    }
+
+                    TraversalAction::DoChildren(location)
+                },
+                |_, _, _| {},
+                |_, _, _| {
+                    // only continue if the point is not found
+                    found.borrow().is_none()
+                },
+            );
+        }
+        found.into_inner()
+    }
+
+    pub fn toplevel(&self) -> &Kind {
+        &self.0.toplevel
+    }
+
+    pub fn user_data(&self) -> &UserDataMap {
+        &self.0.user_data
+    }
+
+    /// Has to be called on commit - Window handles the buffer for you
+    pub fn commit(surface: &wl_surface::WlSurface) {
+        surface_commit(surface)
+    }
+}
+
+// TODO: This is basically `draw_surface_tree` from anvil.
+// Can we move this somewhere, where it is also usable for other things then windows?
+// Maybe add this as a helper function for surfaces to `backend::renderer`?
+// How do we handle SurfaceState in that case? Like we need a closure to
+// store and retrieve textures for arbitrary surface trees? Or leave this to the
+// compositor, but that feels like a lot of unnecessary code dublication.
+
+// TODO: This does not handle ImportAll errors properly and uses only one texture slot.
+// This means it is *not* compatible with MultiGPU setups at all.
+// Current plan is to make sure it does not crash at least in that case and later add
+// A `MultiGpuManager` that opens gpus automatically, creates renderers for them,
+// implements `Renderer` and `ImportAll` itself and dispatches everything accordingly,
+// even copying buffers if necessary. This abstraction will likely also handle dmabuf-
+// protocol(s) (and maybe explicit sync?). Then this function will be fine and all the
+// gore of handling multiple gpus will be hidden away for most if not all cases.
+
+// TODO: This function does not crop or scale windows to fit into a space.
+// How do we want to handle this? Add an additional size property to a window?
+// Let the user specify the max size and the method to handle it?
+
+pub fn draw_window<R, E, F, T>(
+    renderer: &mut R,
+    frame: &mut F,
+    window: &Window,
+    scale: f64,
+    location: Point<i32, Logical>,
+    log: &slog::Logger,
+) -> Result<(), R::Error>
+where
+    R: Renderer<Error = E, TextureId = T, Frame = F> + ImportAll,
+    F: Frame<Error = E, TextureId = T>,
+    E: std::error::Error,
+    T: Texture + 'static,
+{
+    let mut result = Ok(());
+    if let Some(surface) = window.0.toplevel.get_surface() {
+        with_surface_tree_upward(
+            surface,
+            location,
+            |_surface, states, location| {
+                let mut location = *location;
+                if let Some(data) = states.data_map.get::<RefCell<SurfaceState>>() {
+                    let mut data = data.borrow_mut();
+                    let attributes = states.cached_state.current::<SurfaceAttributes>();
+                    // Import a new buffer if necessary
+                    if data.texture.is_none() {
+                        if let Some(buffer) = data.buffer.as_ref() {
+                            let damage = attributes
+                                .damage
+                                .iter()
+                                .map(|dmg| match dmg {
+                                    Damage::Buffer(rect) => *rect,
+                                    // TODO also apply transformations
+                                    Damage::Surface(rect) => rect.to_buffer(attributes.buffer_scale),
+                                })
+                                .collect::<Vec<_>>();
+
+                            match renderer.import_buffer(buffer, Some(states), &damage) {
+                                Some(Ok(m)) => {
+                                    data.texture = Some(Box::new(m));
+                                }
+                                Some(Err(err)) => {
+                                    slog::warn!(log, "Error loading buffer: {}", err);
+                                }
+                                None => {
+                                    slog::error!(log, "Unknown buffer format for: {:?}", buffer);
+                                }
+                            }
+                        }
+                    }
+                    // Now, should we be drawn ?
+                    if data.texture.is_some() {
+                        // if yes, also process the children
+                        if states.role == Some("subsurface") {
+                            let current = states.cached_state.current::<SubsurfaceCachedState>();
+                            location += current.location;
+                        }
+                        TraversalAction::DoChildren(location)
+                    } else {
+                        // we are not displayed, so our children are neither
+                        TraversalAction::SkipChildren
+                    }
+                } else {
+                    // we are not displayed, so our children are neither
+                    TraversalAction::SkipChildren
+                }
+            },
+            |_surface, states, location| {
+                let mut location = *location;
+                if let Some(data) = states.data_map.get::<RefCell<SurfaceState>>() {
+                    let mut data = data.borrow_mut();
+                    let buffer_scale = data.buffer_scale;
+                    let attributes = states.cached_state.current::<SurfaceAttributes>();
+                    if let Some(texture) = data.texture.as_mut().and_then(|x| x.downcast_mut::<T>()) {
+                        // we need to re-extract the subsurface offset, as the previous closure
+                        // only passes it to our children
+                        if states.role == Some("subsurface") {
+                            let current = states.cached_state.current::<SubsurfaceCachedState>();
+                            location += current.location;
+                        }
+                        // TODO: Take wp_viewporter into account
+                        if let Err(err) = frame.render_texture_at(
+                            texture,
+                            location.to_f64().to_physical(scale).to_i32_round(),
+                            buffer_scale,
+                            scale,
+                            attributes.buffer_transform.into(),
+                            1.0,
+                        ) {
+                            result = Err(err);
+                        }
+                    }
+                }
+            },
+            |_, _, _| true,
+        );
+    }
+
+    result
+}

src/lib.rs

@@ -51,6 +51,8 @@
 pub extern crate nix;
 
 pub mod backend;
+#[cfg(feature = "desktop")]
+pub mod desktop;
 pub mod utils;
 #[cfg(feature = "wayland_frontend")]
 pub mod wayland;