From dce901676a3cf539f3f7f6f9b86c991375293764 Mon Sep 17 00:00:00 2001
From: Kirill Chibisov <contact@kchibisov.com>
Date: Tue, 7 Mar 2023 10:04:12 +0300
Subject: [PATCH] Update to wayland-rs 0.30

This should update the sctk-adwaita to the latest smithay-client-toolkit
and wayland-rs.
---
 CHANGELOG.md       |   3 +
 Cargo.toml         |   6 +-
 examples/simple.rs | 117 ------
 examples/window.rs | 554 +++++++++++++++++++++++++
 src/buttons.rs     | 507 ++++++++++-------------
 src/lib.rs         | 997 +++++++++++++++++++--------------------------
 src/parts.rs       | 281 +++++++------
 src/pointer.rs     | 333 +++++----------
 src/surface.rs     | 154 -------
 src/theme.rs       | 126 +++---
 src/title.rs       |   2 +-
 11 files changed, 1500 insertions(+), 1580 deletions(-)
 delete mode 100644 examples/simple.rs
 create mode 100644 examples/window.rs
 delete mode 100644 src/surface.rs

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9139167..dad3b20 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,6 @@
+## Unreleased
+- Update the `smithay-client-toolkit` to `0.17.0`
+
 ## 0.5.4
 - Timeout dbus call to settings portal (100ms)
 
diff --git a/Cargo.toml b/Cargo.toml
index e281b56..81b0c69 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -10,10 +10,10 @@ documentation = "https://docs.rs/sctk-adwaita"
 description = "Adwaita-like SCTK Frame"
 
 [dependencies]
-smithay-client-toolkit = "0.16"
+smithay-client-toolkit = { version = "0.17.0", default_features = false }
 tiny-skia = { version = "0.8", features = ["std", "simd"] }
 log = "0.4"
-memmap2 = "0.5.8"
+memmap2 = { version = "0.5.8", optional = true }
 
 # Draw title text using crossfont `--features crossfont`
 crossfont = { version = "0.5.0", features = ["force_system_fontconfig"], optional = true }
@@ -22,3 +22,5 @@ ab_glyph = { version = "0.2.17", optional = true }
 
 [features]
 default = ["ab_glyph"]
+crossfont = ["dep:crossfont"]
+ab_glyph = ["dep:ab_glyph", "memmap2"]
diff --git a/examples/simple.rs b/examples/simple.rs
deleted file mode 100644
index f1353d9..0000000
--- a/examples/simple.rs
+++ /dev/null
@@ -1,117 +0,0 @@
-extern crate smithay_client_toolkit as sctk;
-
-use sctk::reexports::calloop;
-use sctk::reexports::client::protocol::{wl_shm, wl_surface};
-use sctk::shm::AutoMemPool;
-use sctk::window::Event as WEvent;
-
-sctk::default_environment!(KbdInputExample, desktop);
-
-fn main() {
-    let (env, display, queue) = sctk::new_default_environment!(KbdInputExample, desktop)
-        .expect("Unable to connect to a Wayland compositor");
-
-    let mut event_loop = calloop::EventLoop::<Option<WEvent>>::try_new().unwrap();
-
-    let mut dimensions = (380u32, 240u32);
-
-    let surface = env.create_surface().detach();
-
-    let mut window = env
-        .create_window::<sctk_adwaita::AdwaitaFrame, _>(
-            surface,
-            None,
-            dimensions,
-            move |evt, mut dispatch_data| {
-                let next_action = dispatch_data.get::<Option<WEvent>>().unwrap();
-                // Keep last event in priority order : Close > Configure > Refresh
-                let replace = matches!(
-                    (&evt, &*next_action),
-                    (_, &None)
-                        | (_, &Some(WEvent::Refresh))
-                        | (&WEvent::Configure { .. }, &Some(WEvent::Configure { .. }))
-                        | (&WEvent::Close, _)
-                );
-                if replace {
-                    *next_action = Some(evt);
-                }
-            },
-        )
-        .expect("Failed to create a window !");
-
-    window.set_title("/usr/lib/xorg/modules/input".to_string());
-
-    // // uncomment to override automatic theme selection
-    // window.set_frame_config(sctk_adwaita::FrameConfig::light());
-
-    let mut pool = env
-        .create_auto_pool()
-        .expect("Failed to create a memory pool !");
-
-    if !env.get_shell().unwrap().needs_configure() {
-        // initial draw to bootstrap on wl_shell
-        redraw(&mut pool, window.surface(), dimensions).expect("Failed to draw");
-        window.refresh();
-    }
-
-    println!("XDG_WINDOW: {:?}", window.surface());
-
-    let mut next_action = None;
-
-    sctk::WaylandSource::new(queue)
-        .quick_insert(event_loop.handle())
-        .unwrap();
-
-    loop {
-        match next_action.take() {
-            Some(WEvent::Close) => break,
-            Some(WEvent::Refresh) => {
-                window.refresh();
-                window.surface().commit();
-            }
-            Some(WEvent::Configure { new_size, .. }) => {
-                if let Some((w, h)) = new_size {
-                    window.resize(w, h);
-                    dimensions = (w, h)
-                }
-                window.refresh();
-                redraw(&mut pool, window.surface(), dimensions).expect("Failed to draw");
-            }
-            None => {}
-        }
-
-        // always flush the connection before going to sleep waiting for events
-        display.flush().unwrap();
-
-        event_loop.dispatch(None, &mut next_action).unwrap();
-    }
-}
-
-fn redraw(
-    pool: &mut AutoMemPool,
-    surface: &wl_surface::WlSurface,
-    (buf_x, buf_y): (u32, u32),
-) -> Result<(), ::std::io::Error> {
-    let (canvas, new_buffer) = pool.buffer(
-        buf_x as i32,
-        buf_y as i32,
-        4 * buf_x as i32,
-        wl_shm::Format::Argb8888,
-    )?;
-
-    for pixel in canvas.chunks_exact_mut(4) {
-        pixel[0] = 255;
-        pixel[1] = 255;
-        pixel[2] = 255;
-        pixel[3] = 255;
-    }
-
-    surface.attach(Some(&new_buffer), 0, 0);
-    if surface.as_ref().version() >= 4 {
-        surface.damage_buffer(0, 0, buf_x as i32, buf_y as i32);
-    } else {
-        surface.damage(0, 0, buf_x as i32, buf_y as i32);
-    }
-    surface.commit();
-    Ok(())
-}
diff --git a/examples/window.rs b/examples/window.rs
new file mode 100644
index 0000000..d2977ce
--- /dev/null
+++ b/examples/window.rs
@@ -0,0 +1,554 @@
+// Based on https://github.com/Smithay/client-toolkit/blob/master/examples/themed_window.rs.
+
+use std::sync::Arc;
+use std::{convert::TryInto, num::NonZeroU32};
+
+use smithay_client_toolkit::reexports::client::{
+    globals::registry_queue_init,
+    protocol::{wl_output, wl_pointer, wl_seat, wl_shm, wl_surface},
+    Connection, Proxy, QueueHandle,
+};
+use smithay_client_toolkit::{
+    compositor::{CompositorHandler, CompositorState},
+    delegate_compositor, delegate_output, delegate_pointer, delegate_registry, delegate_seat,
+    delegate_shm, delegate_subcompositor, delegate_xdg_shell, delegate_xdg_window,
+    output::{OutputHandler, OutputState},
+    registry::{ProvidesRegistryState, RegistryState},
+    registry_handlers,
+    seat::{
+        pointer::{
+            PointerData, PointerEvent, PointerEventKind, PointerHandler, ThemeSpec, ThemedPointer,
+        },
+        Capability, SeatHandler, SeatState,
+    },
+    shell::{
+        xdg::{
+            frame::{DecorationsFrame, FrameAction, FrameClick},
+            window::{DecorationMode, Window, WindowConfigure, WindowDecorations, WindowHandler},
+            XdgShell, XdgSurface,
+        },
+        WaylandSurface,
+    },
+    shm::{
+        slot::{Buffer, SlotPool},
+        Shm, ShmHandler,
+    },
+    subcompositor::SubcompositorState,
+};
+
+use sctk_adwaita::{AdwaitaFrame, FrameConfig};
+
+fn main() {
+    let conn = Connection::connect_to_env().unwrap();
+
+    let (globals, mut event_queue) = registry_queue_init(&conn).unwrap();
+    let qh = event_queue.handle();
+    let registry_state = RegistryState::new(&globals);
+    let seat_state = SeatState::new(&globals, &qh);
+    let output_state = OutputState::new(&globals, &qh);
+    let compositor_state =
+        CompositorState::bind(&globals, &qh).expect("wl_compositor not available");
+    let subcompositor_state =
+        SubcompositorState::bind(compositor_state.wl_compositor().clone(), &globals, &qh)
+            .expect("wl_subcompositor not available");
+    let shm_state = Shm::bind(&globals, &qh).expect("wl_shm not available");
+    let xdg_shell_state = XdgShell::bind(&globals, &qh).expect("xdg shell not available");
+
+    let width = 256;
+    let height = 256;
+    let pool = SlotPool::new(width as usize * height as usize * 4, &shm_state)
+        .expect("Failed to create pool");
+
+    let window_surface = compositor_state.create_surface(&qh);
+    let pointer_surface = compositor_state.create_surface(&qh);
+
+    let window =
+        xdg_shell_state.create_window(window_surface, WindowDecorations::ServerDefault, &qh);
+    window.set_title("A wayland window");
+    // GitHub does not let projects use the `org.github` domain but the `io.github` domain is fine.
+    window.set_app_id("simple-window");
+    window.set_min_size(Some((2, 1)));
+
+    // In order for the window to be mapped, we need to perform an initial commit with no attached buffer.
+    // For more info, see WaylandSurface::commit
+    //
+    // The compositor will respond with an initial configure that we can then use to present to the window with
+    // the correct options.
+    window.commit();
+
+    let mut simple_window = SimpleWindow {
+        title: String::from("/usr/lib/xorg/modules/input"),
+        registry_state,
+        seat_state,
+        output_state,
+        _compositor_state: compositor_state,
+        subcompositor_state: Arc::new(subcompositor_state),
+        shm_state,
+        _xdg_shell_state: xdg_shell_state,
+
+        exit: false,
+        first_configure: true,
+        pool,
+        width: NonZeroU32::new(width).unwrap(),
+        height: NonZeroU32::new(height).unwrap(),
+        shift: None,
+        buffer: None,
+        window,
+        window_frame: None,
+        pointer_surface,
+        themed_pointer: None,
+        set_cursor: false,
+        cursor_icon: String::from("diamond_cross"),
+    };
+
+    // We don't draw immediately, the configure will notify us when to first draw.
+
+    loop {
+        event_queue.blocking_dispatch(&mut simple_window).unwrap();
+
+        if simple_window.exit {
+            println!("exiting example");
+            break;
+        }
+    }
+}
+
+struct SimpleWindow {
+    title: String,
+    registry_state: RegistryState,
+    seat_state: SeatState,
+    output_state: OutputState,
+    _compositor_state: CompositorState,
+    subcompositor_state: Arc<SubcompositorState>,
+    shm_state: Shm,
+    _xdg_shell_state: XdgShell,
+
+    exit: bool,
+    first_configure: bool,
+    pool: SlotPool,
+    width: NonZeroU32,
+    height: NonZeroU32,
+    shift: Option<u32>,
+    buffer: Option<Buffer>,
+    window: Window,
+    window_frame: Option<AdwaitaFrame<Self>>,
+    pointer_surface: wl_surface::WlSurface,
+    themed_pointer: Option<ThemedPointer>,
+    set_cursor: bool,
+    cursor_icon: String,
+}
+
+impl CompositorHandler for SimpleWindow {
+    fn scale_factor_changed(
+        &mut self,
+        _conn: &Connection,
+        _qh: &QueueHandle<Self>,
+        _surface: &wl_surface::WlSurface,
+        _new_factor: i32,
+    ) {
+        // Not needed for this example.
+    }
+
+    fn frame(
+        &mut self,
+        conn: &Connection,
+        qh: &QueueHandle<Self>,
+        _surface: &wl_surface::WlSurface,
+        _time: u32,
+    ) {
+        self.draw(conn, qh);
+    }
+}
+
+impl OutputHandler for SimpleWindow {
+    fn output_state(&mut self) -> &mut OutputState {
+        &mut self.output_state
+    }
+
+    fn new_output(
+        &mut self,
+        _conn: &Connection,
+        _qh: &QueueHandle<Self>,
+        _output: wl_output::WlOutput,
+    ) {
+    }
+
+    fn update_output(
+        &mut self,
+        _conn: &Connection,
+        _qh: &QueueHandle<Self>,
+        _output: wl_output::WlOutput,
+    ) {
+    }
+
+    fn output_destroyed(
+        &mut self,
+        _conn: &Connection,
+        _qh: &QueueHandle<Self>,
+        _output: wl_output::WlOutput,
+    ) {
+    }
+}
+
+impl WindowHandler for SimpleWindow {
+    fn request_close(&mut self, _: &Connection, _: &QueueHandle<Self>, _: &Window) {
+        self.exit = true;
+    }
+
+    fn configure(
+        &mut self,
+        conn: &Connection,
+        qh: &QueueHandle<Self>,
+        window: &Window,
+        configure: WindowConfigure,
+        _serial: u32,
+    ) {
+        self.buffer = None;
+
+        println!(
+            "Configure size {:?}, decorations: {:?}",
+            configure.new_size, configure.decoration_mode
+        );
+
+        let (width, height) = if configure.decoration_mode == DecorationMode::Client {
+            let window_frame = self.window_frame.get_or_insert_with(|| {
+                let mut frame = AdwaitaFrame::new(
+                    &self.window,
+                    &self.shm_state,
+                    self.subcompositor_state.clone(),
+                    qh.clone(),
+                    FrameConfig::auto(),
+                )
+                .expect("failed to create client side decorations frame.");
+                frame.set_title(self.title.clone());
+                frame
+            });
+
+            // Un-hide the frame.
+            window_frame.set_hidden(false);
+
+            // Configure state before touching any resizing.
+            window_frame.update_state(configure.state);
+
+            // Configure the button state.
+            window_frame.update_wm_capabilities(configure.capabilities);
+
+            let (width, height) = match configure.new_size {
+                (Some(width), Some(height)) => {
+                    // The size could be 0.
+                    window_frame.subtract_borders(width, height)
+                }
+                _ => {
+                    // You might want to consider checking for configure bounds.
+                    (Some(self.width), Some(self.height))
+                }
+            };
+
+            // Clamp the size to at least one pixel.
+            let width = width.unwrap_or(NonZeroU32::new(1).unwrap());
+            let height = height.unwrap_or(NonZeroU32::new(1).unwrap());
+
+            window_frame.resize(width, height);
+
+            let (x, y) = window_frame.location();
+            let outer_size = window_frame.add_borders(width.get(), height.get());
+            window.xdg_surface().set_window_geometry(
+                x,
+                y,
+                outer_size.0 as i32,
+                outer_size.1 as i32,
+            );
+
+            (width, height)
+        } else {
+            // Hide the frame, if any.
+            if let Some(frame) = self.window_frame.as_mut() {
+                frame.set_hidden(true)
+            }
+            let width = configure.new_size.0.unwrap_or(self.width);
+            let height = configure.new_size.1.unwrap_or(self.height);
+            self.window.xdg_surface().set_window_geometry(
+                0,
+                0,
+                width.get() as i32,
+                height.get() as i32,
+            );
+            (width, height)
+        };
+
+        // Update new width and height;
+        self.width = width;
+        self.height = height;
+
+        // Initiate the first draw.
+        if self.first_configure {
+            self.first_configure = false;
+            self.draw(conn, qh);
+        }
+    }
+}
+
+impl SeatHandler for SimpleWindow {
+    fn seat_state(&mut self) -> &mut SeatState {
+        &mut self.seat_state
+    }
+
+    fn new_seat(&mut self, _: &Connection, _: &QueueHandle<Self>, _: wl_seat::WlSeat) {}
+
+    fn new_capability(
+        &mut self,
+        _conn: &Connection,
+        qh: &QueueHandle<Self>,
+        seat: wl_seat::WlSeat,
+        capability: Capability,
+    ) {
+        if capability == Capability::Pointer && self.themed_pointer.is_none() {
+            println!("Set pointer capability");
+            println!("Creating pointer theme");
+            let themed_pointer = self
+                .seat_state
+                .get_pointer_with_theme(qh, &seat, ThemeSpec::default())
+                .expect("Failed to create pointer");
+            self.themed_pointer.replace(themed_pointer);
+        }
+    }
+
+    fn remove_capability(
+        &mut self,
+        _conn: &Connection,
+        _: &QueueHandle<Self>,
+        _: wl_seat::WlSeat,
+        capability: Capability,
+    ) {
+        if capability == Capability::Pointer && self.themed_pointer.is_some() {
+            println!("Unset pointer capability");
+            self.themed_pointer.take().unwrap().pointer().release();
+        }
+    }
+
+    fn remove_seat(&mut self, _: &Connection, _: &QueueHandle<Self>, _: wl_seat::WlSeat) {}
+}
+
+impl PointerHandler for SimpleWindow {
+    fn pointer_frame(
+        &mut self,
+        _conn: &Connection,
+        _qh: &QueueHandle<Self>,
+        pointer: &wl_pointer::WlPointer,
+        events: &[PointerEvent],
+    ) {
+        use PointerEventKind::*;
+        for event in events {
+            let (x, y) = event.position;
+            match event.kind {
+                Enter { .. } => {
+                    self.set_cursor = true;
+                    self.cursor_icon = self
+                        .window_frame
+                        .as_mut()
+                        .and_then(|frame| frame.click_point_moved(&event.surface, x, y))
+                        .unwrap_or("diamond_cross")
+                        .to_owned();
+
+                    if &event.surface == self.window.wl_surface() {
+                        println!("Pointer entered @{:?}", event.position);
+                    }
+                }
+                Leave { .. } => {
+                    if &event.surface != self.window.wl_surface() {
+                        if let Some(window_frame) = self.window_frame.as_mut() {
+                            window_frame.click_point_left();
+                        }
+                    }
+                    println!("Pointer left");
+                }
+                Motion { .. } => {
+                    if let Some(new_cursor) = self
+                        .window_frame
+                        .as_mut()
+                        .and_then(|frame| frame.click_point_moved(&event.surface, x, y))
+                    {
+                        self.set_cursor = true;
+                        self.cursor_icon = new_cursor.to_owned();
+                    }
+                }
+                Press { button, serial, .. } | Release { button, serial, .. } => {
+                    let pressed = if matches!(event.kind, Press { .. }) {
+                        true
+                    } else {
+                        false
+                    };
+                    if &event.surface != self.window.wl_surface() {
+                        let click = match button {
+                            0x110 => FrameClick::Normal,
+                            0x111 => FrameClick::Alternate,
+                            _ => continue,
+                        };
+
+                        if let Some(action) = self
+                            .window_frame
+                            .as_mut()
+                            .and_then(|frame| frame.on_click(click, pressed))
+                        {
+                            self.frame_action(pointer, serial, action);
+                        }
+                    } else if pressed {
+                        println!("Press {:x} @ {:?}", button, event.position);
+                        self.shift = self.shift.xor(Some(0));
+                    }
+                }
+                Axis {
+                    horizontal,
+                    vertical,
+                    ..
+                } => {
+                    if &event.surface == self.window.wl_surface() {
+                        println!("Scroll H:{horizontal:?}, V:{vertical:?}");
+                    }
+                }
+            }
+        }
+    }
+}
+impl SimpleWindow {
+    fn frame_action(&mut self, pointer: &wl_pointer::WlPointer, serial: u32, action: FrameAction) {
+        let pointer_data = pointer.data::<PointerData>().unwrap();
+        let seat = pointer_data.seat();
+        match action {
+            FrameAction::Close => self.exit = true,
+            FrameAction::Minimize => self.window.set_minimized(),
+            FrameAction::Maximize => self.window.set_maximized(),
+            FrameAction::UnMaximize => self.window.unset_maximized(),
+            FrameAction::ShowMenu(x, y) => self.window.show_window_menu(seat, serial, (x, y)),
+            FrameAction::Resize(edge) => self.window.resize(seat, serial, edge),
+            FrameAction::Move => self.window.move_(seat, serial),
+        }
+    }
+}
+
+impl ShmHandler for SimpleWindow {
+    fn shm_state(&mut self) -> &mut Shm {
+        &mut self.shm_state
+    }
+}
+
+impl SimpleWindow {
+    pub fn draw(&mut self, conn: &Connection, qh: &QueueHandle<Self>) {
+        if self.set_cursor {
+            let _ = self.themed_pointer.as_mut().unwrap().set_cursor(
+                conn,
+                &self.cursor_icon,
+                self.shm_state.wl_shm(),
+                &self.pointer_surface,
+                1,
+            );
+            self.set_cursor = false;
+        }
+
+        let width = self.width.get();
+        let height = self.height.get();
+        let stride = width as i32 * 4;
+
+        let buffer = self.buffer.get_or_insert_with(|| {
+            self.pool
+                .create_buffer(
+                    width as i32,
+                    height as i32,
+                    stride,
+                    wl_shm::Format::Argb8888,
+                )
+                .expect("create buffer")
+                .0
+        });
+
+        let canvas = match self.pool.canvas(buffer) {
+            Some(canvas) => canvas,
+            None => {
+                // This should be rare, but if the compositor has not released the previous
+                // buffer, we need double-buffering.
+                let (second_buffer, canvas) = self
+                    .pool
+                    .create_buffer(
+                        width as i32,
+                        height as i32,
+                        stride,
+                        wl_shm::Format::Argb8888,
+                    )
+                    .expect("create buffer");
+                *buffer = second_buffer;
+                canvas
+            }
+        };
+
+        // Draw to the window:
+        {
+            let shift = self.shift.unwrap_or(0);
+            canvas
+                .chunks_exact_mut(4)
+                .enumerate()
+                .for_each(|(index, chunk)| {
+                    let x = ((index + shift as usize) % width as usize) as u32;
+                    let y = (index / width as usize) as u32;
+
+                    let a = 0xFF;
+                    let r = u32::min(((width - x) * 0xFF) / width, ((height - y) * 0xFF) / height);
+                    let g = u32::min((x * 0xFF) / width, ((height - y) * 0xFF) / height);
+                    let b = u32::min(((width - x) * 0xFF) / width, (y * 0xFF) / height);
+                    let color = (a << 24) + (r << 16) + (g << 8) + b;
+
+                    let array: &mut [u8; 4] = chunk.try_into().unwrap();
+                    *array = color.to_le_bytes();
+                });
+
+            if let Some(shift) = &mut self.shift {
+                *shift = (*shift + 1) % width;
+            }
+        }
+
+        // Draw the decorations frame.
+        self.window_frame.as_mut().map(|frame| {
+            if frame.is_dirty() && !frame.is_hidden() {
+                frame.draw();
+            }
+        });
+
+        // Damage the entire window
+        self.window.wl_surface().damage_buffer(
+            0,
+            0,
+            self.width.get() as i32,
+            self.height.get() as i32,
+        );
+
+        // Request our next frame
+        self.window
+            .wl_surface()
+            .frame(qh, self.window.wl_surface().clone());
+
+        // Attach and commit to present.
+        buffer
+            .attach_to(self.window.wl_surface())
+            .expect("buffer attach");
+        self.window.wl_surface().commit();
+    }
+}
+
+delegate_compositor!(SimpleWindow);
+delegate_subcompositor!(SimpleWindow);
+delegate_output!(SimpleWindow);
+delegate_shm!(SimpleWindow);
+
+delegate_seat!(SimpleWindow);
+delegate_pointer!(SimpleWindow);
+
+delegate_xdg_shell!(SimpleWindow);
+delegate_xdg_window!(SimpleWindow);
+
+delegate_registry!(SimpleWindow);
+
+impl ProvidesRegistryState for SimpleWindow {
+    fn registry(&mut self) -> &mut RegistryState {
+        &mut self.registry_state
+    }
+    registry_handlers![OutputState, SeatState,];
+}
diff --git a/src/buttons.rs b/src/buttons.rs
index 67daf1b..6f03605 100644
--- a/src/buttons.rs
+++ b/src/buttons.rs
@@ -1,345 +1,268 @@
-use smithay_client_toolkit::window::ButtonState;
 use tiny_skia::{FillRule, PathBuilder, PixmapMut, Rect, Stroke, Transform};
 
-use crate::{
-    theme::{ColorMap, BORDER_SIZE},
-    Location, SkiaResult,
-};
+use smithay_client_toolkit::shell::xdg::window::{WindowManagerCapabilities, WindowState};
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub enum ButtonKind {
-    Close,
-    Maximize,
-    Minimize,
-}
-
-#[derive(Default, Debug)]
-pub(crate) struct Button {
-    x: f32,
-    y: f32,
-    size: f32,
-}
-
-impl Button {
-    pub fn radius(&self) -> f32 {
-        self.size / 2.0
-    }
+use crate::{theme::ColorMap, Location, SkiaResult};
 
-    pub fn x(&self) -> f32 {
-        self.x
-    }
+/// The size of the button on the header bar in logical points.
+const BUTTON_SIZE: f32 = 24.;
+const BUTTON_MARGIN: f32 = 5.;
+const BUTTON_SPACING: f32 = 13.;
 
-    pub fn center_x(&self) -> f32 {
-        self.x + self.radius()
-    }
-
-    pub fn center_y(&self) -> f32 {
-        self.y + self.radius()
-    }
+#[derive(Debug)]
+pub(crate) struct Buttons {
+    pub close: Button,
+    pub maximize: Option<Button>,
+    pub minimize: Option<Button>,
+}
 
-    fn contains(&self, x: f32, y: f32) -> bool {
-        x > self.x && x < self.x + self.size && y > self.y && y < self.y + self.size
+impl Default for Buttons {
+    fn default() -> Self {
+        Self {
+            close: Button::new(ButtonKind::Close),
+            maximize: Some(Button::new(ButtonKind::Maximize)),
+            minimize: Some(Button::new(ButtonKind::Minimize)),
+        }
     }
 }
 
-impl Button {
-    pub fn draw_minimize(
-        &self,
-        scale: f32,
-        colors: &ColorMap,
-        mouses: &[Location],
-        pixmap: &mut PixmapMut,
-    ) -> SkiaResult {
-        let btn_state = if mouses.contains(&Location::Button(ButtonKind::Minimize)) {
-            ButtonState::Hovered
-        } else {
-            ButtonState::Idle
-        };
-
-        let radius = self.radius();
+impl Buttons {
+    /// Rearrange the buttons with the new width.
+    pub fn arrange(&mut self, width: u32) {
+        let mut x = width as f32 - BUTTON_MARGIN;
+
+        for button in [
+            Some(&mut self.close),
+            self.maximize.as_mut(),
+            self.minimize.as_mut(),
+        ]
+        .into_iter()
+        .flatten()
+        {
+            // Subtract the button size.
+            x -= BUTTON_SIZE;
 
-        let x = self.center_x();
-        let y = self.center_y();
+            // Update it's
+            button.offset = x;
 
-        let circle = PathBuilder::from_circle(x, y, radius)?;
+            // Subtract spacing for the next button.
+            x -= BUTTON_SPACING;
+        }
+    }
 
-        let button_bg = if btn_state == ButtonState::Hovered {
-            colors.button_hover_paint()
+    /// Find the coordinate of the button.
+    pub fn find_button(&self, x: f64, y: f64) -> Location {
+        let x = x as f32;
+        let y = y as f32;
+        if self.close.contains(x, y) {
+            Location::Button(ButtonKind::Close)
+        } else if self.maximize.as_ref().map(|b| b.contains(x, y)) == Some(true) {
+            Location::Button(ButtonKind::Maximize)
+        } else if self.minimize.as_ref().map(|b| b.contains(x, y)) == Some(true) {
+            Location::Button(ButtonKind::Minimize)
         } else {
-            colors.button_idle_paint()
-        };
-
-        pixmap.fill_path(
-            &circle,
-            &button_bg,
-            FillRule::Winding,
-            Transform::identity(),
-            None,
-        );
-
-        let mut button_icon_paint = colors.button_icon_paint();
-        button_icon_paint.anti_alias = false;
-
-        let len = 8.0 * scale;
-        let hlen = len / 2.0;
-        pixmap.fill_rect(
-            Rect::from_xywh(x - hlen, y + hlen, len, 1.0 * scale)?,
-            &button_icon_paint,
-            Transform::identity(),
-            None,
-        );
+            Location::Head
+        }
+    }
 
-        Some(())
+    pub fn update(&mut self, wm_capabilites: WindowManagerCapabilities) {
+        self.maximize = wm_capabilites
+            .contains(WindowManagerCapabilities::MAXIMIZE)
+            .then_some(Button::new(ButtonKind::Maximize));
+        self.minimize = wm_capabilites
+            .contains(WindowManagerCapabilities::MINIMIZE)
+            .then_some(Button::new(ButtonKind::Minimize));
     }
 
-    pub fn draw_maximize(
-        &self,
-        scale: f32,
-        colors: &ColorMap,
-        mouses: &[Location],
-        maximizable: bool,
-        is_maximized: bool,
-        pixmap: &mut PixmapMut,
-    ) -> SkiaResult {
-        let btn_state = if !maximizable {
-            ButtonState::Disabled
-        } else if mouses
-            .iter()
-            .any(|&l| l == Location::Button(ButtonKind::Maximize))
-        {
-            ButtonState::Hovered
+    pub fn left_most(&self) -> &Button {
+        if let Some(minimize) = self.minimize.as_ref() {
+            minimize
+        } else if let Some(maximize) = self.maximize.as_ref() {
+            maximize
         } else {
-            ButtonState::Idle
-        };
-
-        let radius = self.radius();
+            &self.close
+        }
+    }
 
-        let x = self.center_x();
-        let y = self.center_y();
+    pub fn iter(&self) -> std::array::IntoIter<Option<Button>, 3> {
+        [
+            Some(self.close.clone()),
+            self.maximize.clone(),
+            self.minimize.clone(),
+        ]
+        .into_iter()
+    }
+}
 
-        let path1 = {
-            let mut pb = PathBuilder::new();
-            pb.push_circle(x, y, radius);
-            pb.finish()?
-        };
+#[derive(Debug, Clone)]
+pub(crate) struct Button {
+    /// The button offset into the header bar canvas.
+    offset: f32,
+    /// The kind of the button.
+    kind: ButtonKind,
+}
 
-        let button_bg = if btn_state == ButtonState::Hovered {
-            colors.button_hover_paint()
-        } else {
-            colors.button_idle_paint()
-        };
+impl Button {
+    pub fn new(kind: ButtonKind) -> Self {
+        Self { offset: 0., kind }
+    }
 
-        pixmap.fill_path(
-            &path1,
-            &button_bg,
-            FillRule::Winding,
-            Transform::identity(),
-            None,
-        );
+    pub fn radius(&self) -> f32 {
+        BUTTON_SIZE / 2.0
+    }
 
-        let path2 = {
-            let size = 8.0 * scale;
-            let hsize = size / 2.0;
-            let mut pb = PathBuilder::new();
-
-            let x = x - hsize;
-            let y = y - hsize;
-            pb.push_rect(x, y, size, size);
-
-            if is_maximized {
-                if let Some(rect) = Rect::from_xywh(x + 2.0, y - 2.0, size, size) {
-                    pb.move_to(rect.left(), rect.top());
-                    pb.line_to(rect.right(), rect.top());
-                    pb.line_to(rect.right(), rect.bottom());
-                }
-            }
+    pub fn x(&self) -> f32 {
+        self.offset
+    }
 
-            pb.finish()?
-        };
+    pub fn center_x(&self) -> f32 {
+        self.offset + self.radius()
+    }
 
-        let mut button_icon_paint = colors.button_icon_paint();
-        button_icon_paint.anti_alias = false;
-        pixmap.stroke_path(
-            &path2,
-            &button_icon_paint,
-            &Stroke {
-                width: 1.0 * scale,
-                ..Default::default()
-            },
-            Transform::identity(),
-            None,
-        );
+    pub fn center_y(&self) -> f32 {
+        BUTTON_MARGIN + self.radius()
+    }
 
-        Some(())
+    fn contains(&self, x: f32, y: f32) -> bool {
+        x > self.offset
+            && x < self.offset + BUTTON_SIZE
+            && y > BUTTON_MARGIN
+            && y < BUTTON_MARGIN + BUTTON_SIZE
     }
 
-    pub fn draw_close(
+    pub fn draw(
         &self,
         scale: f32,
         colors: &ColorMap,
-        mouses: &[Location],
+        mouse_location: Location,
         pixmap: &mut PixmapMut,
+        resizable: bool,
+        state: &WindowState,
     ) -> SkiaResult {
-        // Draw the close button
-        let btn_state = if mouses
-            .iter()
-            .any(|&l| l == Location::Button(ButtonKind::Close))
+        println!("Draw button: {:?}", self);
+        let button_bg = if mouse_location == Location::Button(self.kind)
+            && (resizable || self.kind != ButtonKind::Maximize)
         {
-            ButtonState::Hovered
-        } else {
-            ButtonState::Idle
-        };
-
-        let radius = self.radius();
-
-        let x = self.center_x();
-        let y = self.center_y();
-
-        let path1 = {
-            let mut pb = PathBuilder::new();
-            pb.push_circle(x, y, radius);
-            pb.finish()?
-        };
-
-        let button_bg = if btn_state == ButtonState::Hovered {
             colors.button_hover_paint()
         } else {
             colors.button_idle_paint()
         };
 
+        // Convert to pixels.
+        let x = self.center_x() * scale;
+        let y = self.center_y() * scale;
+        let radius = self.radius() * scale;
+
+        // Draw the button background.
+        let circle = PathBuilder::from_circle(x, y, radius)?;
         pixmap.fill_path(
-            &path1,
+            &circle,
             &button_bg,
             FillRule::Winding,
             Transform::identity(),
             None,
         );
 
-        let x_icon = {
-            let size = 3.5 * scale;
-            let mut pb = PathBuilder::new();
-
-            {
-                let sx = x - size;
-                let sy = y - size;
-                let ex = x + size;
-                let ey = y + size;
-
-                pb.move_to(sx, sy);
-                pb.line_to(ex, ey);
-                pb.close();
+        let mut button_icon_paint = colors.button_icon_paint();
+        // Do AA only for diagonal lines.
+        button_icon_paint.anti_alias = self.kind == ButtonKind::Close;
+
+        // Draw the icon.
+        match self.kind {
+            ButtonKind::Close => {
+                let x_icon = {
+                    let size = 3.5 * scale;
+                    let mut pb = PathBuilder::new();
+
+                    {
+                        let sx = x - size;
+                        let sy = y - size;
+                        let ex = x + size;
+                        let ey = y + size;
+
+                        pb.move_to(sx, sy);
+                        pb.line_to(ex, ey);
+                        pb.close();
+                    }
+
+                    {
+                        let sx = x - size;
+                        let sy = y + size;
+                        let ex = x + size;
+                        let ey = y - size;
+
+                        pb.move_to(sx, sy);
+                        pb.line_to(ex, ey);
+                        pb.close();
+                    }
+
+                    pb.finish()?
+                };
+
+                pixmap.stroke_path(
+                    &x_icon,
+                    &button_icon_paint,
+                    &Stroke {
+                        width: 1.1 * scale,
+                        ..Default::default()
+                    },
+                    Transform::identity(),
+                    None,
+                );
             }
-
-            {
-                let sx = x - size;
-                let sy = y + size;
-                let ex = x + size;
-                let ey = y - size;
-
-                pb.move_to(sx, sy);
-                pb.line_to(ex, ey);
-                pb.close();
+            ButtonKind::Maximize => {
+                let path2 = {
+                    let size = 8.0 * scale;
+                    let hsize = size / 2.0;
+                    let mut pb = PathBuilder::new();
+
+                    let x = x - hsize;
+                    let y = y - hsize;
+                    pb.push_rect(x, y, size, size);
+
+                    if state.contains(WindowState::MAXIMIZED) {
+                        if let Some(rect) =
+                            Rect::from_xywh(x + 2.0 * scale, y - 2.0 * scale, size, size)
+                        {
+                            pb.move_to(rect.left(), rect.top());
+                            pb.line_to(rect.right(), rect.top());
+                            pb.line_to(rect.right(), rect.bottom());
+                        }
+                    }
+
+                    pb.finish()?
+                };
+
+                pixmap.stroke_path(
+                    &path2,
+                    &button_icon_paint,
+                    &Stroke {
+                        width: 1.0 * scale,
+                        ..Default::default()
+                    },
+                    Transform::identity(),
+                    None,
+                );
             }
-
-            pb.finish()?
-        };
-
-        let mut button_icon_paint = colors.button_icon_paint();
-        button_icon_paint.anti_alias = true;
-        pixmap.stroke_path(
-            &x_icon,
-            &button_icon_paint,
-            &Stroke {
-                width: 1.1 * scale,
-                ..Default::default()
-            },
-            Transform::identity(),
-            None,
-        );
+            ButtonKind::Minimize => {
+                let len = 8.0 * scale;
+                let hlen = len / 2.0;
+                pixmap.fill_rect(
+                    Rect::from_xywh(x - hlen, y + hlen, len, scale)?,
+                    &button_icon_paint,
+                    Transform::identity(),
+                    None,
+                );
+            }
+        }
 
         Some(())
     }
 }
 
-#[derive(Debug)]
-pub(crate) struct Buttons {
-    pub close: Button,
-    pub maximize: Button,
-    pub minimize: Button,
-
-    w: u32,
-    h: u32,
-
-    scale: u32,
-}
-
-impl Default for Buttons {
-    fn default() -> Self {
-        Self {
-            close: Default::default(),
-            maximize: Default::default(),
-            minimize: Default::default(),
-            scale: 1,
-
-            w: 0,
-            h: super::theme::HEADER_SIZE,
-        }
-    }
-}
-
-impl Buttons {
-    pub fn arrange(&mut self, w: u32) {
-        self.w = w;
-
-        let scale = self.scale as f32;
-        let margin_top = BORDER_SIZE as f32 * scale;
-        let margin = 5.0 * scale;
-        let spacing = 13.0 * scale;
-        let size = 12.0 * 2.0 * scale;
-
-        let mut x = w as f32 * scale - margin - BORDER_SIZE as f32 * scale;
-        let y = margin + margin_top;
-
-        x -= size;
-        self.close.x = x;
-        self.close.y = y;
-        self.close.size = size;
-
-        x -= size;
-        x -= spacing;
-        self.maximize.x = x;
-        self.maximize.y = y;
-        self.maximize.size = size;
-
-        x -= size;
-        x -= spacing;
-        self.minimize.x = x;
-        self.minimize.y = y;
-        self.minimize.size = size;
-    }
-
-    pub fn update_scale(&mut self, scale: u32) {
-        if self.scale != scale {
-            self.scale = scale;
-            self.arrange(self.w);
-        }
-    }
-
-    pub fn find_button(&self, x: f64, y: f64) -> Location {
-        let x = x as f32 * self.scale as f32;
-        let y = y as f32 * self.scale as f32;
-        if self.close.contains(x, y) {
-            Location::Button(ButtonKind::Close)
-        } else if self.maximize.contains(x, y) {
-            Location::Button(ButtonKind::Maximize)
-        } else if self.minimize.contains(x, y) {
-            Location::Button(ButtonKind::Minimize)
-        } else {
-            Location::Head
-        }
-    }
-
-    pub fn scaled_size(&self) -> (u32, u32) {
-        (self.w * self.scale, self.h * self.scale)
-    }
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum ButtonKind {
+    Close,
+    Maximize,
+    Minimize,
 }
diff --git a/src/lib.rs b/src/lib.rs
index f11f798..267e576 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,686 +1,530 @@
+use std::error::Error;
+use std::num::NonZeroU32;
+use std::sync::Arc;
+
+use tiny_skia::{
+    ClipMask, Color, FillRule, Path, PathBuilder, Pixmap, PixmapMut, PixmapPaint, Point, Rect,
+    Transform,
+};
+
+use smithay_client_toolkit::reexports::client::protocol::wl_shm;
+use smithay_client_toolkit::reexports::client::protocol::wl_subsurface::WlSubsurface;
+use smithay_client_toolkit::reexports::client::protocol::wl_surface::WlSurface;
+use smithay_client_toolkit::reexports::client::{Dispatch, Proxy, QueueHandle};
+
+use smithay_client_toolkit::compositor::SurfaceData;
+use smithay_client_toolkit::shell::xdg::frame::{DecorationsFrame, FrameAction, FrameClick};
+use smithay_client_toolkit::shell::xdg::window::{WindowManagerCapabilities, WindowState};
+use smithay_client_toolkit::shell::WaylandSurface;
+use smithay_client_toolkit::shm::{slot::SlotPool, Shm};
+use smithay_client_toolkit::subcompositor::SubcompositorState;
+use smithay_client_toolkit::subcompositor::SubsurfaceData;
+
 mod buttons;
 mod config;
 mod parts;
 mod pointer;
-mod surface;
 pub mod theme;
 mod title;
 
-use crate::theme::ColorMap;
-use buttons::{ButtonKind, Buttons};
-use client::{
-    protocol::{wl_compositor, wl_seat, wl_shm, wl_subcompositor, wl_surface},
-    Attached, DispatchData,
-};
-use parts::Parts;
-use pointer::PointerUserData;
-use smithay_client_toolkit::{
-    reexports::client,
-    seat::pointer::{ThemeManager, ThemeSpec, ThemedPointer},
-    shm::AutoMemPool,
-    window::{Frame, FrameRequest, State, WindowState},
-};
-use std::{cell::RefCell, fmt, rc::Rc};
-use theme::{ColorTheme, BORDER_SIZE, HEADER_SIZE};
-use tiny_skia::{
-    ClipMask, Color, FillRule, Paint, Path, PathBuilder, Pixmap, PixmapMut, PixmapPaint, Point,
-    Rect, Transform,
+use crate::theme::{
+    ColorMap, ColorTheme, BORDER_SIZE, CORNER_RADIUS, HEADER_SIZE, VISIBLE_BORDER_SIZE,
 };
+
+use buttons::Buttons;
+use parts::DecorationParts;
+use pointer::{Location, MouseState};
 use title::TitleText;
 
+/// XXX this is not result, so `must_use` when needed.
 type SkiaResult = Option<()>;
 
-/*
- * Utilities
- */
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-enum Location {
-    None,
-    Head,
-    Top,
-    TopRight,
-    Right,
-    BottomRight,
-    Bottom,
-    BottomLeft,
-    Left,
-    TopLeft,
-    Button(ButtonKind),
-}
+/// A simple set of decorations
+#[derive(Debug)]
+pub struct AdwaitaFrame<State> {
+    /// The base surface used to create the window.
+    base_surface: WlSurface,
 
-/*
- * The core frame
- */
+    /// Subcompositor to create/drop subsurfaces ondemand.
+    subcompositor: Arc<SubcompositorState>,
 
-struct Inner {
-    parts: Parts,
-    size: (u32, u32),
+    /// Queue handle to perform object creation.
+    queue_handle: QueueHandle<State>,
+
+    /// The drawable decorations, `None` when hidden.
+    decorations: Option<DecorationParts>,
+
+    /// Memory pool to allocate the buffers for the decorations.
+    pool: SlotPool,
+
+    /// Whether the frame should be redrawn.
+    dirty: bool,
+
+    /// Wether the frame is resizable.
     resizable: bool,
-    theme_over_surface: bool,
-    implem: Box<dyn FnMut(FrameRequest, u32, DispatchData)>,
-    maximized: bool,
-    fullscreened: bool,
-    tiled: bool,
+
+    buttons: Buttons,
+    state: WindowState,
+    wm_capabilities: WindowManagerCapabilities,
+    mouse: MouseState,
+    theme: ColorTheme,
+    title: Option<String>,
+    title_text: Option<TitleText>,
 }
 
-impl fmt::Debug for Inner {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("Inner")
-            .field("parts", &self.parts)
-            .field("size", &self.size)
-            .field("resizable", &self.resizable)
-            .field("theme_over_surface", &self.theme_over_surface)
-            .field(
-                "implem",
-                &"FnMut(FrameRequest, u32, DispatchData) -> { ... }",
-            )
-            .field("maximized", &self.maximized)
-            .field("fullscreened", &self.fullscreened)
-            .finish()
+impl<State> AdwaitaFrame<State>
+where
+    State: Dispatch<WlSurface, SurfaceData> + Dispatch<WlSubsurface, SubsurfaceData> + 'static,
+{
+    pub fn new(
+        base_surface: &impl WaylandSurface,
+        shm: &Shm,
+        subcompositor: Arc<SubcompositorState>,
+        queue_handle: QueueHandle<State>,
+        frame_config: FrameConfig,
+    ) -> Result<Self, Box<dyn Error>> {
+        let base_surface = base_surface.wl_surface().clone();
+        let pool = SlotPool::new(1, shm)?;
+
+        let decorations = Some(DecorationParts::new(
+            &base_surface,
+            &subcompositor,
+            &queue_handle,
+        ));
+
+        let theme = frame_config.theme;
+
+        Ok(AdwaitaFrame {
+            base_surface,
+            decorations,
+            pool,
+            subcompositor,
+            queue_handle,
+            dirty: true,
+            title: None,
+            title_text: TitleText::new(theme.active.font_color),
+            theme,
+            buttons: Default::default(),
+            mouse: Default::default(),
+            state: WindowState::empty(),
+            wm_capabilities: WindowManagerCapabilities::all(),
+            resizable: true,
+        })
     }
-}
 
-fn precise_location(buttons: &Buttons, old: Location, width: u32, x: f64, y: f64) -> Location {
-    match old {
-        Location::Head
-        | Location::Button(_)
-        | Location::Top
-        | Location::TopLeft
-        | Location::TopRight => match buttons.find_button(x, y) {
-            Location::Head => {
-                if y <= f64::from(BORDER_SIZE) {
-                    if x <= f64::from(BORDER_SIZE) {
-                        Location::TopLeft
-                    } else if x >= f64::from(width + BORDER_SIZE) {
-                        Location::TopRight
-                    } else {
-                        Location::Top
-                    }
-                } else if x < f64::from(BORDER_SIZE) {
+    /// Update the current frame config.
+    pub fn set_config(&mut self, config: FrameConfig) {
+        self.theme = config.theme;
+        self.dirty = true;
+    }
+
+    fn precise_location(&self, location: Location, header_width: u32, x: f64, y: f64) -> Location {
+        match location {
+            Location::Head | Location::Button(_) => self.buttons.find_button(x, y),
+            Location::Top | Location::TopLeft | Location::TopRight => {
+                if x <= f64::from(BORDER_SIZE) {
                     Location::TopLeft
-                } else if x > f64::from(width) {
+                } else if x >= f64::from(header_width + BORDER_SIZE) {
                     Location::TopRight
                 } else {
-                    Location::Head
+                    Location::Top
                 }
             }
-            other => other,
-        },
-
-        Location::Bottom | Location::BottomLeft | Location::BottomRight => {
-            if x <= f64::from(BORDER_SIZE) {
-                Location::BottomLeft
-            } else if x >= f64::from(width + BORDER_SIZE) {
-                Location::BottomRight
-            } else {
-                Location::Bottom
+            Location::Bottom | Location::BottomLeft | Location::BottomRight => {
+                if x <= f64::from(BORDER_SIZE) {
+                    Location::BottomLeft
+                } else if x >= f64::from(header_width + BORDER_SIZE) {
+                    Location::BottomRight
+                } else {
+                    Location::Bottom
+                }
             }
+            other => other,
         }
-
-        other => other,
     }
-}
-
-#[derive(Debug, Clone)]
-pub struct FrameConfig {
-    pub theme: ColorTheme,
-}
 
-impl FrameConfig {
-    pub fn auto() -> Self {
-        Self {
-            theme: ColorTheme::auto(),
-        }
-    }
+    fn redraw_inner(&mut self) -> SkiaResult {
+        let decorations = self.decorations.as_mut()?;
 
-    pub fn light() -> Self {
-        Self {
-            theme: ColorTheme::light(),
-        }
-    }
+        // Reset the dirty bit.
+        self.dirty = false;
 
-    pub fn dark() -> Self {
-        Self {
-            theme: ColorTheme::dark(),
+        // Don't draw borders if the frame explicitly hidden or fullscreened.
+        if self.state.contains(WindowState::FULLSCREEN) {
+            decorations.hide();
+            return Some(());
         }
-    }
-}
 
-/// A simple set of decorations
-#[derive(Debug)]
-pub struct AdwaitaFrame {
-    base_surface: wl_surface::WlSurface,
-    compositor: Attached<wl_compositor::WlCompositor>,
-    subcompositor: Attached<wl_subcompositor::WlSubcompositor>,
-    inner: Rc<RefCell<Inner>>,
-    pool: AutoMemPool,
-    active: WindowState,
-    hidden: bool,
-    pointers: Vec<ThemedPointer>,
-    themer: ThemeManager,
-    surface_version: u32,
-
-    buttons: Rc<RefCell<Buttons>>,
-    colors: ColorTheme,
-    title: Option<String>,
-    title_text: Option<TitleText>,
-}
+        let colors = if self.state.contains(WindowState::ACTIVATED) {
+            &self.theme.active
+        } else {
+            &self.theme.inactive
+        };
 
-impl Frame for AdwaitaFrame {
-    type Error = ::std::io::Error;
-    type Config = FrameConfig;
-    fn init(
-        base_surface: &wl_surface::WlSurface,
-        compositor: &Attached<wl_compositor::WlCompositor>,
-        subcompositor: &Attached<wl_subcompositor::WlSubcompositor>,
-        shm: &Attached<wl_shm::WlShm>,
-        theme_manager: Option<ThemeManager>,
-        implementation: Box<dyn FnMut(FrameRequest, u32, DispatchData)>,
-    ) -> Result<AdwaitaFrame, ::std::io::Error> {
-        let (themer, theme_over_surface) = if let Some(theme_manager) = theme_manager {
-            (theme_manager, false)
+        let draw_borders = if self.state.contains(WindowState::MAXIMIZED) {
+            // Don't draw the borders.
+            decorations.hide_borders();
+            false
         } else {
-            (
-                ThemeManager::init(ThemeSpec::System, compositor.clone(), shm.clone()),
-                true,
-            )
+            true
         };
+        let border_paint = colors.border_paint();
 
-        let inner = Rc::new(RefCell::new(Inner {
-            parts: Parts::default(),
-            size: (1, 1),
-            resizable: true,
-            implem: implementation,
-            theme_over_surface,
-            maximized: false,
-            fullscreened: false,
-            tiled: false,
-        }));
+        // Draw the borders.
+        for (idx, part) in decorations
+            .parts()
+            .filter(|(idx, _)| *idx == DecorationParts::HEADER || draw_borders)
+        {
+            let scale = part.scale();
+
+            // XXX to perfectly align the visible borders we draw them with
+            // the header, otherwise rounded corners won't look 'smooth' at the
+            // start. To achieve that, we enlargen the width of the header by
+            // 2 * `VISIBLE_BORDER_SIZE`, and move `x` by `VISIBLE_BORDER_SIZE`
+            // to the left.
+            let (width, height, pos) = if idx == DecorationParts::HEADER && draw_borders {
+                (
+                    (part.width + 2 * VISIBLE_BORDER_SIZE) * scale,
+                    part.height * scale,
+                    (part.pos.0 - VISIBLE_BORDER_SIZE as i32, part.pos.1),
+                )
+            } else {
+                (part.width * scale, part.height * scale, part.pos)
+            };
+
+            let (buffer, canvas) = match self.pool.create_buffer(
+                width as i32,
+                height as i32,
+                width as i32 * 4,
+                wl_shm::Format::Argb8888,
+            ) {
+                Ok((buffer, canvas)) => (buffer, canvas),
+                Err(_) => continue,
+            };
+
+            // Create the pixmap and fill with transparent color.
+            let mut pixmap = PixmapMut::from_bytes(canvas, width, height)?;
+
+            // Fill everything with transparent background, since we draw rounded corners and
+            // do invisible borders to enlarge the input zone.
+            pixmap.fill(Color::TRANSPARENT);
+
+            match idx {
+                DecorationParts::HEADER => {
+                    if let Some(title_text) = self.title_text.as_mut() {
+                        title_text.update_scale(scale);
+                        title_text.update_color(colors.font_color);
+                    }
 
-        let pool = AutoMemPool::new(shm.clone())?;
+                    draw_headerbar(
+                        &mut pixmap,
+                        self.title_text.as_ref().map(|t| t.pixmap()).unwrap_or(None),
+                        scale as f32,
+                        self.resizable,
+                        &self.state,
+                        &self.theme,
+                        &self.buttons,
+                        self.mouse.location,
+                    );
+                }
+                border => {
+                    // The visible border is one pt.
+                    let visible_border_size = VISIBLE_BORDER_SIZE * scale;
+
+                    // XXX we do all the match using integral types and then convert to f32 in the
+                    // end to ensure that result is finite.
+                    let rect = match border {
+                        DecorationParts::LEFT => {
+                            let x = (pos.0.unsigned_abs() * scale) - visible_border_size;
+                            let y = pos.1.unsigned_abs() * scale;
+                            Rect::from_xywh(
+                                x as f32,
+                                y as f32,
+                                visible_border_size as f32,
+                                (height - y) as f32,
+                            )
+                        }
+                        DecorationParts::RIGHT => {
+                            let y = pos.1.unsigned_abs() * scale;
+                            Rect::from_xywh(
+                                0.,
+                                y as f32,
+                                visible_border_size as f32,
+                                (height - y) as f32,
+                            )
+                        }
+                        // We draw small visible border only bellow the window surface, no need to
+                        // handle `TOP`.
+                        DecorationParts::BOTTOM => {
+                            let x = (pos.0.unsigned_abs() * scale) - visible_border_size;
+                            Rect::from_xywh(
+                                x as f32,
+                                0.,
+                                (width - 2 * x) as f32,
+                                visible_border_size as f32,
+                            )
+                        }
+                        _ => None,
+                    };
+
+                    // Fill the visible border, if present.
+                    if let Some(rect) = rect {
+                        pixmap.fill_rect(rect, &border_paint, Transform::identity(), None);
+                    }
+                }
+            };
 
-        let colors = ColorTheme::auto();
+            part.surface.set_buffer_scale(scale as i32);
 
-        Ok(AdwaitaFrame {
-            base_surface: base_surface.clone(),
-            compositor: compositor.clone(),
-            subcompositor: subcompositor.clone(),
-            inner,
-            pool,
-            active: WindowState::Inactive,
-            hidden: true,
-            pointers: Vec::new(),
-            themer,
-            surface_version: compositor.as_ref().version(),
-            buttons: Default::default(),
-            title: None,
-            title_text: TitleText::new(colors.active.font_color),
-            colors,
-        })
-    }
+            part.subsurface.set_position(pos.0, pos.1);
+            buffer.attach_to(&part.surface).ok()?;
 
-    fn new_seat(&mut self, seat: &Attached<wl_seat::WlSeat>) {
-        let inner = self.inner.clone();
-
-        let buttons = self.buttons.clone();
-        let pointer = self.themer.theme_pointer_with_impl(
-            seat,
-            move |event, pointer: ThemedPointer, ddata: DispatchData| {
-                if let Some(data) = pointer
-                    .as_ref()
-                    .user_data()
-                    .get::<RefCell<PointerUserData>>()
-                {
-                    let mut data = data.borrow_mut();
-                    let mut inner = inner.borrow_mut();
-                    data.event(event, &mut inner, &buttons.borrow(), &pointer, ddata);
-                }
-            },
-        );
-        pointer
-            .as_ref()
-            .user_data()
-            .set(|| RefCell::new(PointerUserData::new(seat.detach())));
-        self.pointers.push(pointer);
-    }
+            if part.surface.version() >= 4 {
+                part.surface.damage_buffer(0, 0, i32::MAX, i32::MAX);
+            } else {
+                part.surface.damage(0, 0, i32::MAX, i32::MAX);
+            }
 
-    fn remove_seat(&mut self, seat: &wl_seat::WlSeat) {
-        self.pointers.retain(|pointer| {
-            pointer
-                .as_ref()
-                .user_data()
-                .get::<RefCell<PointerUserData>>()
-                .map(|user_data| {
-                    let guard = user_data.borrow_mut();
-                    if &guard.seat == seat {
-                        pointer.release();
-                        false
-                    } else {
-                        true
-                    }
-                })
-                .unwrap_or(false)
-        });
+            part.surface.commit();
+        }
+
+        Some(())
     }
+}
 
-    fn set_states(&mut self, states: &[State]) -> bool {
-        let mut inner = self.inner.borrow_mut();
-        let mut need_redraw = false;
+impl<State> DecorationsFrame for AdwaitaFrame<State>
+where
+    State: Dispatch<WlSurface, SurfaceData> + Dispatch<WlSubsurface, SubsurfaceData> + 'static,
+{
+    fn update_state(&mut self, state: WindowState) {
+        let difference = self.state.symmetric_difference(state);
+        self.state = state;
+        self.dirty |= difference.intersects(
+            WindowState::ACTIVATED
+                | WindowState::FULLSCREEN
+                | WindowState::MAXIMIZED
+                | WindowState::TILED,
+        );
+    }
 
-        // Process active.
-        let new_active = if states.contains(&State::Activated) {
-            WindowState::Active
-        } else {
-            WindowState::Inactive
-        };
-        need_redraw |= new_active != self.active;
-        self.active = new_active;
-
-        // Process maximized.
-        let new_maximized = states.contains(&State::Maximized);
-        need_redraw |= new_maximized != inner.maximized;
-        inner.maximized = new_maximized;
-
-        // Process fullscreened.
-        let new_fullscreened = states.contains(&State::Fullscreen);
-        need_redraw |= new_fullscreened != inner.fullscreened;
-        inner.fullscreened = new_fullscreened;
-
-        let new_tiled = states.contains(&State::TiledLeft)
-            || states.contains(&State::TiledRight)
-            || states.contains(&State::TiledTop)
-            || states.contains(&State::TiledBottom);
-        need_redraw |= new_tiled != inner.tiled;
-        inner.tiled = new_tiled;
-
-        need_redraw
+    fn update_wm_capabilities(&mut self, wm_capabilities: WindowManagerCapabilities) {
+        self.dirty |= self.wm_capabilities != wm_capabilities;
+        self.wm_capabilities = wm_capabilities;
+        self.buttons.update(wm_capabilities);
     }
 
     fn set_hidden(&mut self, hidden: bool) {
-        self.hidden = hidden;
-        let mut inner = self.inner.borrow_mut();
-        if !self.hidden {
-            inner.parts.add_decorations(
+        if hidden {
+            self.dirty = false;
+            let _ = self.pool.resize(1);
+            self.decorations = None;
+        } else if self.decorations.is_none() {
+            self.decorations = Some(DecorationParts::new(
                 &self.base_surface,
-                &self.compositor,
                 &self.subcompositor,
-                self.inner.clone(),
-            );
-        } else {
-            inner.parts.remove_decorations();
+                &self.queue_handle,
+            ));
+            self.dirty = true;
         }
     }
 
     fn set_resizable(&mut self, resizable: bool) {
-        self.inner.borrow_mut().resizable = resizable;
+        self.dirty |= self.resizable != resizable;
+        self.resizable = resizable;
     }
 
-    fn resize(&mut self, newsize: (u32, u32)) {
-        self.inner.borrow_mut().size = newsize;
-        self.buttons
-            .borrow_mut()
-            .arrange(newsize.0 + BORDER_SIZE * 2);
+    fn resize(&mut self, width: NonZeroU32, height: NonZeroU32) {
+        let decorations = self
+            .decorations
+            .as_mut()
+            .expect("trying to resize the hidden frame.");
+
+        decorations.resize(width.get(), height.get());
+        self.buttons.arrange(width.get());
+        self.dirty = true;
     }
 
-    fn redraw(&mut self) {
+    fn draw(&mut self) {
         self.redraw_inner();
     }
 
-    fn subtract_borders(&self, width: i32, height: i32) -> (i32, i32) {
-        if self.hidden || self.inner.borrow().fullscreened {
-            (width, height)
+    fn subtract_borders(
+        &self,
+        width: NonZeroU32,
+        height: NonZeroU32,
+    ) -> (Option<NonZeroU32>, Option<NonZeroU32>) {
+        if self.decorations.is_none() || self.state.contains(WindowState::FULLSCREEN) {
+            (Some(width), Some(height))
         } else {
-            (width, height - HEADER_SIZE as i32)
+            (
+                Some(width),
+                NonZeroU32::new(height.get().saturating_sub(HEADER_SIZE)),
+            )
         }
     }
 
-    fn add_borders(&self, width: i32, height: i32) -> (i32, i32) {
-        if self.hidden || self.inner.borrow().fullscreened {
+    fn add_borders(&self, width: u32, height: u32) -> (u32, u32) {
+        if self.decorations.is_none() || self.state.contains(WindowState::FULLSCREEN) {
             (width, height)
         } else {
-            (width, height + HEADER_SIZE as i32)
+            (width, height + HEADER_SIZE)
         }
     }
 
     fn location(&self) -> (i32, i32) {
-        if self.hidden || self.inner.borrow().fullscreened {
+        if self.decorations.is_none() || self.state.contains(WindowState::FULLSCREEN) {
             (0, 0)
         } else {
             (0, -(HEADER_SIZE as i32))
         }
     }
 
-    fn set_config(&mut self, config: FrameConfig) {
-        self.colors = config.theme;
-    }
-
-    fn set_title(&mut self, title: String) {
+    fn set_title(&mut self, title: impl Into<String>) {
+        let new_title = title.into();
         if let Some(title_text) = self.title_text.as_mut() {
-            title_text.update_title(&title);
+            title_text.update_title(new_title.clone());
         }
 
-        self.title = Some(title);
+        self.title = Some(new_title);
+        self.dirty = true;
     }
-}
-
-impl AdwaitaFrame {
-    fn redraw_inner(&mut self) -> SkiaResult {
-        let inner = self.inner.borrow_mut();
 
-        // Don't draw borders if the frame explicitly hidden or fullscreened.
-        if self.hidden || inner.fullscreened {
-            inner.parts.hide_decorations();
-            return Some(());
+    fn on_click(&mut self, click: FrameClick, pressed: bool) -> Option<FrameAction> {
+        match click {
+            FrameClick::Normal => {
+                self.mouse
+                    .click(pressed, self.resizable, &self.state, &self.wm_capabilities)
+            }
+            FrameClick::Alternate => self.mouse.alternate_click(pressed, &self.wm_capabilities),
         }
+    }
 
-        // `parts` can't be empty here, since the initial state for `self.hidden` is true, and
-        // they will be created once `self.hidden` will become `false`.
-        let parts = &inner.parts;
-
-        let (width, height) = inner.size;
-
-        if let Some(decoration) = parts.decoration() {
-            // Use header scale for all the thing.
-            let header_scale = decoration.header.scale();
-            self.buttons.borrow_mut().update_scale(header_scale);
-
-            let left_scale = decoration.left.scale();
-            let right_scale = decoration.right.scale();
-            let bottom_scale = decoration.bottom.scale();
-
-            let (header_width, header_height) = self.buttons.borrow().scaled_size();
-            let header_height = header_height + BORDER_SIZE * header_scale;
-
-            {
-                // Create the buffers and draw
-
-                let colors = if self.active == WindowState::Active {
-                    &self.colors.active
-                } else {
-                    &self.colors.inactive
-                };
-
-                if let Some(title_text) = self.title_text.as_mut() {
-                    title_text.update_color(colors.font_color);
-                }
-
-                let border_paint = colors.border_paint();
-
-                // -> head-subsurface
-                if let Ok((canvas, buffer)) = self.pool.buffer(
-                    header_width as i32,
-                    header_height as i32,
-                    4 * header_width as i32,
-                    wl_shm::Format::Argb8888,
-                ) {
-                    let mut pixmap = PixmapMut::from_bytes(canvas, header_width, header_height)?;
-                    pixmap.fill(Color::TRANSPARENT);
+    fn click_point_moved(&mut self, surface: &WlSurface, x: f64, y: f64) -> Option<&str> {
+        let decorations = self.decorations.as_ref()?;
+        let location = decorations.find_surface(surface);
+        if location == Location::None {
+            return None;
+        }
 
-                    if let Some(title_text) = self.title_text.as_mut() {
-                        title_text.update_scale(header_scale);
-                    }
+        let header_width = decorations.header().width;
+        let old_location = self.mouse.location;
 
-                    draw_headerbar(
-                        &mut pixmap,
-                        self.title_text.as_ref().map(|t| t.pixmap()).unwrap_or(None),
-                        header_scale as f32,
-                        inner.resizable,
-                        inner.maximized,
-                        inner.tiled,
-                        self.active,
-                        &self.colors,
-                        &self.buttons.borrow(),
-                        &self
-                            .pointers
-                            .iter()
-                            .flat_map(|p| {
-                                if p.as_ref().is_alive() {
-                                    let data: &RefCell<PointerUserData> =
-                                        p.as_ref().user_data().get()?;
-                                    Some(data.borrow().location)
-                                } else {
-                                    None
-                                }
-                            })
-                            .collect::<Vec<Location>>(),
-                    );
+        let location = self.precise_location(location, header_width, x, y);
+        let new_cursor = self.mouse.moved(location, x, y, self.resizable);
 
-                    decoration.header.subsurface.set_position(
-                        -(BORDER_SIZE as i32),
-                        -(HEADER_SIZE as i32 + BORDER_SIZE as i32),
-                    );
-                    decoration.header.surface.attach(Some(&buffer), 0, 0);
-                    if self.surface_version >= 4 {
-                        decoration.header.surface.damage_buffer(
-                            0,
-                            0,
-                            header_width as i32,
-                            header_height as i32,
-                        );
-                    } else {
-                        // surface is old and does not support damage_buffer, so we damage
-                        // in surface coordinates and hope it is not rescaled
-                        decoration
-                            .header
-                            .surface
-                            .damage(0, 0, width as i32, HEADER_SIZE as i32);
-                    }
-                    decoration.header.surface.commit();
-                }
+        // Set dirty if we moved the cursor between the buttons.
+        self.dirty |= (matches!(old_location, Location::Button(_))
+            || matches!(self.mouse.location, Location::Button(_)))
+            && old_location != self.mouse.location;
 
-                if inner.maximized {
-                    // Don't draw the borders.
-                    decoration.hide_borders();
-                    return Some(());
-                }
+        Some(new_cursor)
+    }
 
-                let w = ((width + 2 * BORDER_SIZE) * bottom_scale) as i32;
-                let h = (BORDER_SIZE * bottom_scale) as i32;
-                // -> bottom-subsurface
-                if let Ok((canvas, buffer)) = self.pool.buffer(
-                    w,
-                    h,
-                    (4 * bottom_scale * (width + 2 * BORDER_SIZE)) as i32,
-                    wl_shm::Format::Argb8888,
-                ) {
-                    let mut pixmap = PixmapMut::from_bytes(canvas, w as u32, h as u32)?;
-                    pixmap.fill(Color::TRANSPARENT);
-
-                    let size = 1.0;
-                    let x = BORDER_SIZE as f32 * bottom_scale as f32 - 1.0;
-                    pixmap.fill_rect(
-                        Rect::from_xywh(
-                            x,
-                            0.0,
-                            w as f32 - BORDER_SIZE as f32 * 2.0 * bottom_scale as f32 + 2.0,
-                            size,
-                        )?,
-                        &border_paint,
-                        Transform::identity(),
-                        None,
-                    );
+    fn click_point_left(&mut self) {
+        self.mouse.left()
+    }
 
-                    decoration
-                        .bottom
-                        .subsurface
-                        .set_position(-(BORDER_SIZE as i32), height as i32);
-                    decoration.bottom.surface.attach(Some(&buffer), 0, 0);
-                    if self.surface_version >= 4 {
-                        decoration.bottom.surface.damage_buffer(
-                            0,
-                            0,
-                            ((width + 2 * BORDER_SIZE) * bottom_scale) as i32,
-                            (BORDER_SIZE * bottom_scale) as i32,
-                        );
-                    } else {
-                        // surface is old and does not support damage_buffer, so we damage
-                        // in surface coordinates and hope it is not rescaled
-                        decoration.bottom.surface.damage(
-                            0,
-                            0,
-                            (width + 2 * BORDER_SIZE) as i32,
-                            BORDER_SIZE as i32,
-                        );
-                    }
-                    decoration.bottom.surface.commit();
-                }
+    fn is_dirty(&self) -> bool {
+        self.dirty
+    }
 
-                let w = (BORDER_SIZE * left_scale) as i32;
-                let h = (height * left_scale) as i32;
-                // -> left-subsurface
-                if let Ok((canvas, buffer)) = self.pool.buffer(
-                    w,
-                    h,
-                    4 * (BORDER_SIZE * left_scale) as i32,
-                    wl_shm::Format::Argb8888,
-                ) {
-                    let mut bg = Paint::default();
-                    bg.set_color_rgba8(255, 0, 0, 255);
-
-                    let mut pixmap = PixmapMut::from_bytes(canvas, w as u32, h as u32)?;
-                    pixmap.fill(Color::TRANSPARENT);
-
-                    let size = 1.0;
-                    pixmap.fill_rect(
-                        Rect::from_xywh(w as f32 - size, 0.0, w as f32, h as f32)?,
-                        &border_paint,
-                        Transform::identity(),
-                        None,
-                    );
+    fn is_hidden(&self) -> bool {
+        self.decorations.is_none()
+    }
+}
 
-                    decoration
-                        .left
-                        .subsurface
-                        .set_position(-(BORDER_SIZE as i32), 0);
-                    decoration.left.surface.attach(Some(&buffer), 0, 0);
-                    if self.surface_version >= 4 {
-                        decoration.left.surface.damage_buffer(0, 0, w, h);
-                    } else {
-                        // surface is old and does not support damage_buffer, so we damage
-                        // in surface coordinates and hope it is not rescaled
-                        decoration.left.surface.damage(
-                            0,
-                            0,
-                            BORDER_SIZE as i32,
-                            (height + HEADER_SIZE) as i32,
-                        );
-                    }
-                    decoration.left.surface.commit();
-                }
+/// The configuration for the [`AdwaitaFrame`] frame.
+#[derive(Debug, Clone)]
+pub struct FrameConfig {
+    pub theme: ColorTheme,
+}
 
-                let w = (BORDER_SIZE * right_scale) as i32;
-                let h = (height * right_scale) as i32;
-                // -> right-subsurface
-                if let Ok((canvas, buffer)) = self.pool.buffer(
-                    w,
-                    h,
-                    4 * (BORDER_SIZE * right_scale) as i32,
-                    wl_shm::Format::Argb8888,
-                ) {
-                    let mut bg = Paint::default();
-                    bg.set_color_rgba8(255, 0, 0, 255);
-
-                    let mut pixmap = PixmapMut::from_bytes(canvas, w as u32, h as u32)?;
-                    pixmap.fill(Color::TRANSPARENT);
-
-                    let size = 1.0;
-                    pixmap.fill_rect(
-                        Rect::from_xywh(0.0, 0.0, size, h as f32)?,
-                        &border_paint,
-                        Transform::identity(),
-                        None,
-                    );
+impl FrameConfig {
+    /// Create the new configuration with the given `theme`.
+    pub fn new(theme: ColorTheme) -> Self {
+        Self { theme }
+    }
 
-                    decoration.right.subsurface.set_position(width as i32, 0);
-                    decoration.right.surface.attach(Some(&buffer), 0, 0);
-                    if self.surface_version >= 4 {
-                        decoration.right.surface.damage_buffer(0, 0, w, h);
-                    } else {
-                        // surface is old and does not support damage_buffer, so we damage
-                        // in surface coordinates and hope it is not rescaled
-                        decoration
-                            .right
-                            .surface
-                            .damage(0, 0, BORDER_SIZE as i32, height as i32);
-                    }
-                    decoration.right.surface.commit();
-                }
-            }
+    /// This is equivalent of calling `FrameConfig::new(ColorTheme::auto())`.
+    ///
+    /// For details see [`ColorTheme::auto`].
+    pub fn auto() -> Self {
+        Self {
+            theme: ColorTheme::auto(),
         }
+    }
 
-        Some(())
+    /// This is equivalent of calling `FrameConfig::new(ColorTheme::light())`.
+    ///
+    /// For details see [`ColorTheme::light`].
+    pub fn light() -> Self {
+        Self {
+            theme: ColorTheme::light(),
+        }
     }
-}
 
-impl Drop for AdwaitaFrame {
-    fn drop(&mut self) {
-        for ptr in self.pointers.drain(..) {
-            if ptr.as_ref().version() >= 3 {
-                ptr.release();
-            }
+    /// This is equivalent of calling `FrameConfig::new(ColorTheme::dark())`.
+    ///
+    /// For details see [`ColorTheme::dark`].
+    pub fn dark() -> Self {
+        Self {
+            theme: ColorTheme::dark(),
         }
     }
 }
 
+#[allow(clippy::too_many_arguments)]
 fn draw_headerbar(
     pixmap: &mut PixmapMut,
     text_pixmap: Option<&Pixmap>,
     scale: f32,
-    maximizable: bool,
-    is_maximized: bool,
-    tiled: bool,
-    state: WindowState,
-    colors: &ColorTheme,
+    resizable: bool,
+    state: &WindowState,
+    theme: &ColorTheme,
     buttons: &Buttons,
-    mouses: &[Location],
+    mouse: Location,
 ) {
-    let border_size = BORDER_SIZE as f32 * scale;
-
-    let margin_h = border_size;
-    let margin_v = border_size;
+    let colors = theme.for_state(state.contains(WindowState::ACTIVATED));
 
-    let colors = colors.for_state(state);
+    let _ = draw_headerbar_bg(pixmap, scale, colors, state);
 
-    draw_headerbar_bg(
-        pixmap,
-        scale,
-        margin_h,
-        margin_v,
-        colors,
-        is_maximized,
-        tiled,
-    );
+    // Horizontal margin.
+    let margin_h = if state.intersects(WindowState::MAXIMIZED | WindowState::TILED) {
+        0.
+    } else {
+        VISIBLE_BORDER_SIZE as f32 * scale
+    };
 
     if let Some(text_pixmap) = text_pixmap {
+        const TEXT_OFFSET: f32 = 10.;
+
+        let closest_button_x = buttons.left_most().x() * scale;
+        let offset_x = TEXT_OFFSET * scale;
+
         let canvas_w = pixmap.width() as f32;
         let canvas_h = pixmap.height() as f32;
 
         let header_w = canvas_w - margin_h * 2.0;
-        let header_h = canvas_h - margin_v;
+        let header_h = canvas_h;
 
         let text_w = text_pixmap.width() as f32;
         let text_h = text_pixmap.height() as f32;
 
-        let x = header_w / 2.0 - text_w / 2.0;
-        let y = header_h / 2.0 - text_h / 2.0;
-
-        let x = margin_h + x;
-        let y = margin_v + y;
+        let x = margin_h + header_w / 2. - text_w / 2.;
+        let y = header_h / 2. - text_h / 2.;
 
-        let (x, y) = if x + text_w < buttons.minimize.x() - 10.0 {
+        let (x, y) = if x + text_w < closest_button_x - offset_x {
             (x, y)
         } else {
-            let y = header_h / 2.0 - text_h / 2.0;
-
-            let x = buttons.minimize.x() - text_w - 10.0;
-            let y = margin_v + y;
+            let x = closest_button_x - text_w - offset_x;
+            let y = header_h / 2. - text_h / 2.;
             (x, y)
         };
 
-        let x = x.max(margin_h + 5.0);
+        // Ensure that text start within the bounds.
+        let x = x.max(margin_h + offset_x);
 
-        if let Some(clip) = Rect::from_xywh(0.0, 0.0, buttons.minimize.x() - 10.0, canvas_h) {
+        if let Some(clip) = Rect::from_xywh(0., 0., closest_button_x - offset_x, canvas_h) {
             let mut mask = ClipMask::new();
             mask.set_path(
                 canvas_w as u32,
@@ -700,45 +544,32 @@ fn draw_headerbar(
         }
     }
 
-    if buttons.close.x() > margin_h {
-        buttons.close.draw_close(scale, colors, mouses, pixmap);
-    }
-
-    if buttons.maximize.x() > margin_h {
-        buttons
-            .maximize
-            .draw_maximize(scale, colors, mouses, maximizable, is_maximized, pixmap);
-    }
-
-    if buttons.minimize.x() > margin_h {
-        buttons
-            .minimize
-            .draw_minimize(scale, colors, mouses, pixmap);
+    // Draw the buttons.
+    for button in buttons.iter().flatten() {
+        // Ensure that it'll be visible.
+        if button.x() > margin_h {
+            button.draw(scale, colors, mouse, pixmap, resizable, state);
+        }
     }
 }
 
+#[must_use]
 fn draw_headerbar_bg(
     pixmap: &mut PixmapMut,
     scale: f32,
-    margin_h: f32,
-    margin_v: f32,
     colors: &ColorMap,
-    is_maximized: bool,
-    tiled: bool,
+    state: &WindowState,
 ) -> SkiaResult {
     let w = pixmap.width() as f32;
     let h = pixmap.height() as f32;
 
-    let radius = if is_maximized || tiled {
-        0.0
+    let radius = if state.intersects(WindowState::MAXIMIZED | WindowState::TILED) {
+        0.
     } else {
-        10.0 * scale
+        CORNER_RADIUS as f32 * scale
     };
 
-    let margin_h = margin_h - 1.0;
-    let w = w - margin_h * 2.0;
-
-    let bg = rounded_headerbar_shape(margin_h, margin_v, w, h, radius)?;
+    let bg = rounded_headerbar_shape(0., 0., w, h, radius)?;
 
     pixmap.fill_path(
         &bg,
@@ -749,7 +580,7 @@ fn draw_headerbar_bg(
     );
 
     pixmap.fill_rect(
-        Rect::from_xywh(margin_h, h - 1.0, w, h)?,
+        Rect::from_xywh(0., h - 1., w, h)?,
         &colors.border_paint(),
         Transform::identity(),
         None,
diff --git a/src/parts.rs b/src/parts.rs
index 921b6c2..6f8e385 100644
--- a/src/parts.rs
+++ b/src/parts.rs
@@ -1,144 +1,142 @@
-use std::{cell::RefCell, rc::Rc};
+use smithay_client_toolkit::reexports::client::{
+    protocol::{wl_subsurface::WlSubsurface, wl_surface::WlSurface},
+    Dispatch, Proxy, QueueHandle,
+};
 
 use smithay_client_toolkit::{
-    reexports::client::{
-        protocol::{
-            wl_compositor::WlCompositor, wl_subcompositor::WlSubcompositor,
-            wl_subsurface::WlSubsurface, wl_surface::WlSurface,
-        },
-        Attached, DispatchData,
-    },
-    window::FrameRequest,
+    compositor::SurfaceData,
+    subcompositor::{SubcompositorState, SubsurfaceData},
 };
 
-use crate::{surface, Inner, Location};
-
-pub enum DecorationPartKind {
-    Header,
-    Top,
-    Left,
-    Right,
-    Bottom,
-    None,
-}
+use crate::pointer::Location;
+use crate::theme::{BORDER_SIZE, HEADER_SIZE};
 
+/// The decoration's 'parts'.
 #[derive(Debug)]
-pub struct Decoration {
-    pub header: Part,
-
-    pub top: Part,
-    pub left: Part,
-    pub right: Part,
-    pub bottom: Part,
+pub struct DecorationParts {
+    parts: [Part; 5],
 }
 
-impl Decoration {
-    pub fn iter(&self) -> [&Part; 5] {
-        [
-            &self.header,
-            &self.top,
-            &self.left,
-            &self.right,
-            &self.bottom,
-        ]
+impl DecorationParts {
+    // XXX keep in sync with `Self;:new`.
+    pub const HEADER: usize = 0;
+    pub const TOP: usize = 1;
+    pub const LEFT: usize = 2;
+    pub const RIGHT: usize = 3;
+    pub const BOTTOM: usize = 4;
+
+    pub fn new<State>(
+        base_surface: &WlSurface,
+        subcompositor: &SubcompositorState,
+        queue_handle: &QueueHandle<State>,
+    ) -> Self
+    where
+        State: Dispatch<WlSurface, SurfaceData> + Dispatch<WlSubsurface, SubsurfaceData> + 'static,
+    {
+        // XXX the order must be in sync with associated constants.
+        let parts = [
+            // Header.
+            Part::new(
+                base_surface,
+                subcompositor,
+                queue_handle,
+                0,
+                HEADER_SIZE,
+                (0, -(HEADER_SIZE as i32)),
+            ),
+            // Top.
+            Part::new(
+                base_surface,
+                subcompositor,
+                queue_handle,
+                0,
+                BORDER_SIZE,
+                (
+                    -(BORDER_SIZE as i32),
+                    -(HEADER_SIZE as i32 + BORDER_SIZE as i32),
+                ),
+            ),
+            // Left.
+            Part::new(
+                base_surface,
+                subcompositor,
+                queue_handle,
+                BORDER_SIZE,
+                0,
+                (-(BORDER_SIZE as i32), -(HEADER_SIZE as i32)),
+            ),
+            // Right.
+            Part::new(
+                base_surface,
+                subcompositor,
+                queue_handle,
+                BORDER_SIZE,
+                0,
+                (-(BORDER_SIZE as i32), -(HEADER_SIZE as i32)),
+            ),
+            // Bottom.
+            Part::new(
+                base_surface,
+                subcompositor,
+                queue_handle,
+                0,
+                BORDER_SIZE,
+                (-(BORDER_SIZE as i32), 0),
+            ),
+        ];
+
+        Self { parts }
+    }
+
+    pub fn parts(&self) -> std::iter::Enumerate<std::slice::Iter<Part>> {
+        self.parts.iter().enumerate()
     }
 
-    pub fn hide_decoration(&self) {
-        for p in self.iter() {
-            p.surface.attach(None, 0, 0);
-            p.surface.commit();
+    pub fn hide(&self) {
+        for part in self.parts.iter() {
+            part.surface.attach(None, 0, 0);
+            part.surface.commit();
         }
     }
 
     pub fn hide_borders(&self) {
-        for p in self.iter().iter().skip(1) {
-            p.surface.attach(None, 0, 0);
-            p.surface.commit();
+        for (_, part) in self.parts().filter(|(idx, _)| *idx != Self::HEADER) {
+            part.surface.attach(None, 0, 0);
+            part.surface.commit();
         }
     }
-}
 
-#[derive(Default, Debug)]
-pub(crate) struct Parts {
-    decoration: Option<Decoration>,
-}
+    pub fn resize(&mut self, width: u32, height: u32) {
+        self.parts[Self::HEADER].width = width;
 
-impl Parts {
-    pub fn add_decorations(
-        &mut self,
-        parent: &WlSurface,
-        compositor: &Attached<WlCompositor>,
-        subcompositor: &Attached<WlSubcompositor>,
-        inner: Rc<RefCell<Inner>>,
-    ) {
-        if self.decoration.is_none() {
-            let header = Part::new(parent, compositor, subcompositor, Some(inner));
-            let top = Part::new(parent, compositor, subcompositor, None);
-            let left = Part::new(parent, compositor, subcompositor, None);
-            let right = Part::new(parent, compositor, subcompositor, None);
-            let bottom = Part::new(parent, compositor, subcompositor, None);
-
-            self.decoration = Some(Decoration {
-                header,
-                top,
-                left,
-                right,
-                bottom,
-            });
-        }
-    }
+        self.parts[Self::BOTTOM].width = width + 2 * BORDER_SIZE;
+        self.parts[Self::BOTTOM].pos.1 = height as i32;
 
-    pub fn remove_decorations(&mut self) {
-        self.decoration = None;
-    }
+        self.parts[Self::TOP].width = self.parts[Self::BOTTOM].width;
 
-    pub fn hide_decorations(&self) {
-        if let Some(decor) = self.decoration.as_ref() {
-            decor.hide_decoration();
-        }
-    }
+        self.parts[Self::LEFT].height = height + HEADER_SIZE;
 
-    pub fn decoration(&self) -> Option<&Decoration> {
-        self.decoration.as_ref()
+        self.parts[Self::RIGHT].height = self.parts[Self::LEFT].height;
+        self.parts[Self::RIGHT].pos.0 = width as i32;
     }
 
-    pub fn find_decoration_part(&self, surface: &WlSurface) -> DecorationPartKind {
-        if let Some(decor) = self.decoration() {
-            if surface.as_ref().equals(decor.header.surface.as_ref()) {
-                DecorationPartKind::Header
-            } else if surface.as_ref().equals(decor.top.surface.as_ref()) {
-                DecorationPartKind::Top
-            } else if surface.as_ref().equals(decor.bottom.surface.as_ref()) {
-                DecorationPartKind::Bottom
-            } else if surface.as_ref().equals(decor.left.surface.as_ref()) {
-                DecorationPartKind::Left
-            } else if surface.as_ref().equals(decor.right.surface.as_ref()) {
-                DecorationPartKind::Right
-            } else {
-                DecorationPartKind::None
-            }
-        } else {
-            DecorationPartKind::None
-        }
+    pub fn header(&self) -> &Part {
+        &self.parts[Self::HEADER]
     }
 
     pub fn find_surface(&self, surface: &WlSurface) -> Location {
-        if let Some(decor) = self.decoration() {
-            if surface.as_ref().equals(decor.header.surface.as_ref()) {
-                Location::Head
-            } else if surface.as_ref().equals(decor.top.surface.as_ref()) {
-                Location::Top
-            } else if surface.as_ref().equals(decor.bottom.surface.as_ref()) {
-                Location::Bottom
-            } else if surface.as_ref().equals(decor.left.surface.as_ref()) {
-                Location::Left
-            } else if surface.as_ref().equals(decor.right.surface.as_ref()) {
-                Location::Right
-            } else {
-                Location::None
-            }
-        } else {
-            Location::None
+        let pos = match self.parts.iter().position(|part| &part.surface == surface) {
+            Some(pos) => pos,
+            None => return Location::None,
+        };
+
+        match pos {
+            Self::HEADER => Location::Head,
+            Self::TOP => Location::Top,
+            Self::BOTTOM => Location::Bottom,
+            Self::LEFT => Location::Left,
+            Self::RIGHT => Location::Right,
+            _ => unreachable!(),
         }
     }
 }
@@ -147,46 +145,41 @@ impl Parts {
 pub struct Part {
     pub surface: WlSurface,
     pub subsurface: WlSubsurface,
+
+    pub width: u32,
+    pub height: u32,
+
+    pub pos: (i32, i32),
 }
 
 impl Part {
-    fn new(
+    fn new<State>(
         parent: &WlSurface,
-        compositor: &Attached<WlCompositor>,
-        subcompositor: &Attached<WlSubcompositor>,
-        inner: Option<Rc<RefCell<Inner>>>,
-    ) -> Part {
-        let surface = if let Some(inner) = inner {
-            surface::setup_surface(
-                compositor.create_surface(),
-                Some(move |dpi, surface: WlSurface, ddata: DispatchData| {
-                    surface.set_buffer_scale(dpi);
-                    surface.commit();
-                    (inner.borrow_mut().implem)(FrameRequest::Refresh, 0, ddata);
-                }),
-            )
-        } else {
-            surface::setup_surface(
-                compositor.create_surface(),
-                Some(move |dpi, surface: WlSurface, _ddata: DispatchData| {
-                    surface.set_buffer_scale(dpi);
-                    surface.commit();
-                }),
-            )
-        };
-
-        let surface = surface.detach();
-
-        let subsurface = subcompositor.get_subsurface(&surface, parent);
+        subcompositor: &SubcompositorState,
+        queue_handle: &QueueHandle<State>,
+        width: u32,
+        height: u32,
+        pos: (i32, i32),
+    ) -> Part
+    where
+        State: Dispatch<WlSurface, SurfaceData> + Dispatch<WlSubsurface, SubsurfaceData> + 'static,
+    {
+        let (subsurface, surface) = subcompositor.create_subsurface(parent.clone(), queue_handle);
+
+        // Sync with the parent surface.
+        subsurface.set_sync();
 
         Part {
             surface,
-            subsurface: subsurface.detach(),
+            subsurface,
+            width,
+            height,
+            pos,
         }
     }
 
     pub fn scale(&self) -> u32 {
-        surface::get_surface_scale_factor(&self.surface) as u32
+        self.surface.data::<SurfaceData>().unwrap().scale_factor() as u32
     }
 }
 
diff --git a/src/pointer.rs b/src/pointer.rs
index 332159c..6b79618 100644
--- a/src/pointer.rs
+++ b/src/pointer.rs
@@ -1,260 +1,143 @@
-use log::error;
+use std::time::{Duration, Instant};
+
 use smithay_client_toolkit::{
-    reexports::{
-        client::{
-            protocol::{wl_pointer, wl_seat::WlSeat},
-            DispatchData,
-        },
-        protocols::xdg_shell::client::xdg_toplevel::ResizeEdge,
+    reexports::protocols::xdg::shell::client::xdg_toplevel::ResizeEdge,
+    shell::xdg::{
+        frame::FrameAction,
+        window::{WindowManagerCapabilities, WindowState},
     },
-    seat::pointer::ThemedPointer,
-    window::FrameRequest,
 };
 
 use crate::{
-    buttons::{ButtonKind, Buttons},
-    parts::DecorationPartKind,
-    precise_location,
+    buttons::ButtonKind,
     theme::{BORDER_SIZE, HEADER_SIZE},
-    Inner, Location,
 };
 
-pub(crate) struct PointerUserData {
+/// Time to register the next click as a double click.
+const DOUBLE_CLICK_DURATION: Duration = Duration::from_millis(300);
+
+/// The state of the mouse input inside the decorations frame.
+#[derive(Debug, Default)]
+pub(crate) struct MouseState {
     pub location: Location,
-    current_surface: DecorationPartKind,
 
+    /// The surface local location inside the surface.
     position: (f64, f64),
-    pub seat: WlSeat,
-    last_click: Option<std::time::Instant>,
 
-    lpm_grab: Option<ButtonKind>,
+    /// The instant of the last click.
+    last_normal_click: Option<Instant>,
 }
 
-impl PointerUserData {
-    pub fn new(seat: WlSeat) -> Self {
-        Self {
-            location: Location::None,
-            current_surface: DecorationPartKind::None,
-            position: (0.0, 0.0),
-            seat,
-            last_click: None,
-            lpm_grab: None,
-        }
-    }
-
-    pub fn event(
+impl MouseState {
+    /// The normal click on decorations frame was made.
+    pub fn click(
         &mut self,
-        event: wl_pointer::Event,
-        inner: &mut Inner,
-        buttons: &Buttons,
-        pointer: &ThemedPointer,
-        ddata: DispatchData<'_>,
-    ) {
-        use wl_pointer::Event;
-        match event {
-            Event::Enter {
-                serial,
-                surface,
-                surface_x,
-                surface_y,
-            } => {
-                self.location = precise_location(
-                    buttons,
-                    inner.parts.find_surface(&surface),
-                    inner.size.0,
-                    surface_x,
-                    surface_y,
-                );
-                self.current_surface = inner.parts.find_decoration_part(&surface);
-                self.position = (surface_x, surface_y);
-                change_pointer(pointer, inner, self.location, Some(serial))
+        pressed: bool,
+        resizable: bool,
+        state: &WindowState,
+        wm_capabilities: &WindowManagerCapabilities,
+    ) -> Option<FrameAction> {
+        let maximized = state.contains(WindowState::MAXIMIZED);
+        let action = match self.location {
+            Location::Top if resizable => FrameAction::Resize(ResizeEdge::Top),
+            Location::TopLeft if resizable => FrameAction::Resize(ResizeEdge::TopLeft),
+            Location::Left if resizable => FrameAction::Resize(ResizeEdge::Left),
+            Location::BottomLeft if resizable => FrameAction::Resize(ResizeEdge::BottomLeft),
+            Location::Bottom if resizable => FrameAction::Resize(ResizeEdge::Bottom),
+            Location::BottomRight if resizable => FrameAction::Resize(ResizeEdge::BottomRight),
+            Location::Right if resizable => FrameAction::Resize(ResizeEdge::Right),
+            Location::TopRight if resizable => FrameAction::Resize(ResizeEdge::TopRight),
+            Location::Button(ButtonKind::Close) if !pressed => FrameAction::Close,
+            Location::Button(ButtonKind::Maximize) if !pressed && !maximized => {
+                FrameAction::Maximize
             }
-            Event::Leave { serial, .. } => {
-                self.current_surface = DecorationPartKind::None;
-
-                self.location = Location::None;
-                change_pointer(pointer, inner, self.location, Some(serial));
-                (inner.implem)(FrameRequest::Refresh, 0, ddata);
+            Location::Button(ButtonKind::Maximize) if !pressed && maximized => {
+                FrameAction::UnMaximize
             }
-            Event::Motion {
-                surface_x,
-                surface_y,
-                ..
-            } => {
-                self.position = (surface_x, surface_y);
-                let newpos =
-                    precise_location(buttons, self.location, inner.size.0, surface_x, surface_y);
-                if newpos != self.location {
-                    match (newpos, self.location) {
-                        (Location::Button(_), _) | (_, Location::Button(_)) => {
-                            // pointer movement involves a button, request refresh
-                            (inner.implem)(FrameRequest::Refresh, 0, ddata);
+            Location::Button(ButtonKind::Minimize) if !pressed => FrameAction::Minimize,
+            Location::Head
+                if pressed && wm_capabilities.contains(WindowManagerCapabilities::MAXIMIZE) =>
+            {
+                match self.last_normal_click.replace(std::time::Instant::now()) {
+                    Some(now) if now.elapsed() < DOUBLE_CLICK_DURATION => {
+                        if maximized {
+                            FrameAction::UnMaximize
+                        } else {
+                            FrameAction::Maximize
                         }
-                        _ => (),
                     }
-                    // we changed of part of the decoration, pointer image
-                    // may need to be changed
-                    self.location = newpos;
-                    change_pointer(pointer, inner, self.location, None)
+                    _ => FrameAction::Move,
                 }
             }
-            Event::Button {
-                serial,
-                button,
-                state,
-                ..
-            } => {
-                let request = if state == wl_pointer::ButtonState::Pressed {
-                    match button {
-                        // Left mouse button.
-                        0x110 => lmb_press(self, inner.maximized, inner.resizable),
-                        // Right mouse button.
-                        0x111 => rmb_press(self),
-                        _ => None,
-                    }
-                } else {
-                    // Left mouse button.
-                    if button == 0x110 {
-                        lmb_release(self, inner.maximized)
-                    } else {
-                        None
-                    }
-                };
+            Location::Head if pressed => FrameAction::Move,
+            _ => return None,
+        };
 
-                if let Some(request) = request {
-                    (inner.implem)(request, serial, ddata);
-                }
-            }
-            _ => {}
-        }
+        Some(action)
     }
-}
-
-fn lmb_press(
-    pointer_data: &mut PointerUserData,
-    maximized: bool,
-    resizable: bool,
-) -> Option<FrameRequest> {
-    match pointer_data.location {
-        Location::Top if resizable => Some(FrameRequest::Resize(
-            pointer_data.seat.clone(),
-            ResizeEdge::Top,
-        )),
-        Location::TopLeft if resizable => Some(FrameRequest::Resize(
-            pointer_data.seat.clone(),
-            ResizeEdge::TopLeft,
-        )),
-        Location::Left if resizable => Some(FrameRequest::Resize(
-            pointer_data.seat.clone(),
-            ResizeEdge::Left,
-        )),
-        Location::BottomLeft if resizable => Some(FrameRequest::Resize(
-            pointer_data.seat.clone(),
-            ResizeEdge::BottomLeft,
-        )),
-        Location::Bottom if resizable => Some(FrameRequest::Resize(
-            pointer_data.seat.clone(),
-            ResizeEdge::Bottom,
-        )),
-        Location::BottomRight if resizable => Some(FrameRequest::Resize(
-            pointer_data.seat.clone(),
-            ResizeEdge::BottomRight,
-        )),
-        Location::Right if resizable => Some(FrameRequest::Resize(
-            pointer_data.seat.clone(),
-            ResizeEdge::Right,
-        )),
-        Location::TopRight if resizable => Some(FrameRequest::Resize(
-            pointer_data.seat.clone(),
-            ResizeEdge::TopRight,
-        )),
-        Location::Head => {
-            let last_click = pointer_data.last_click.replace(std::time::Instant::now());
 
-            if let Some(last) = last_click {
-                if last.elapsed() < std::time::Duration::from_millis(400) {
-                    pointer_data.last_click = None;
-
-                    if maximized {
-                        Some(FrameRequest::UnMaximize)
-                    } else {
-                        Some(FrameRequest::Maximize)
-                    }
-                } else {
-                    Some(FrameRequest::Move(pointer_data.seat.clone()))
-                }
-            } else {
-                Some(FrameRequest::Move(pointer_data.seat.clone()))
+    /// Alternative click on decorations frame was made.
+    pub fn alternate_click(
+        &mut self,
+        pressed: bool,
+        wm_capabilities: &WindowManagerCapabilities,
+    ) -> Option<FrameAction> {
+        // Invalidate the normal click.
+        self.last_normal_click = None;
+
+        match self.location {
+            Location::Head | Location::Button(_)
+                if pressed && wm_capabilities.contains(WindowManagerCapabilities::WINDOW_MENU) =>
+            {
+                Some(FrameAction::ShowMenu(
+                    // XXX this could be one 1pt off when the frame is not maximized, but it's not
+                    // like it really matters in the end.
+                    self.position.0 as i32 - BORDER_SIZE as i32,
+                    // We must offset it by header size for precise position.
+                    self.position.1 as i32 - HEADER_SIZE as i32,
+                ))
             }
+            _ => None,
         }
-        Location::Button(btn) => {
-            pointer_data.lpm_grab = Some(btn);
-            None
-        }
-        _ => None,
     }
-}
-
-fn lmb_release(pointer_data: &mut PointerUserData, maximized: bool) -> Option<FrameRequest> {
-    let lpm_grab = pointer_data.lpm_grab.take();
-
-    match pointer_data.location {
-        Location::Button(btn) => {
-            if lpm_grab == Some(btn) {
-                let req = match btn {
-                    ButtonKind::Close => FrameRequest::Close,
-                    ButtonKind::Maximize => {
-                        if maximized {
-                            FrameRequest::UnMaximize
-                        } else {
-                            FrameRequest::Maximize
-                        }
-                    }
-                    ButtonKind::Minimize => FrameRequest::Minimize,
-                };
 
-                Some(req)
-            } else {
-                None
-            }
+    /// The mouse moved inside the decorations frame.
+    pub fn moved(&mut self, location: Location, x: f64, y: f64, resizable: bool) -> &'static str {
+        self.location = location;
+        self.position = (x, y);
+        match self.location {
+            _ if !resizable => "left_ptr",
+            Location::Top => "top_side",
+            Location::TopRight => "top_right_corner",
+            Location::Right => "right_side",
+            Location::BottomRight => "bottom_right_corner",
+            Location::Bottom => "bottom_side",
+            Location::BottomLeft => "bottom_left_corner",
+            Location::Left => "left_side",
+            Location::TopLeft => "top_left_corner",
+            _ => "left_ptr",
         }
-        _ => None,
     }
-}
 
-fn rmb_press(pointer_data: &PointerUserData) -> Option<FrameRequest> {
-    match pointer_data.location {
-        Location::Head | Location::Button(_) => Some(FrameRequest::ShowMenu(
-            pointer_data.seat.clone(),
-            pointer_data.position.0 as i32 - BORDER_SIZE as i32,
-            // We must offset it by header size for precise position.
-            pointer_data.position.1 as i32 - (HEADER_SIZE as i32 + BORDER_SIZE as i32),
-        )),
-        _ => None,
+    /// The mouse left the decorations frame.
+    pub fn left(&mut self) {
+        // Reset only the location.
+        self.location = Location::None;
     }
 }
 
-fn change_pointer(pointer: &ThemedPointer, inner: &Inner, location: Location, serial: Option<u32>) {
-    // Prevent theming of the surface if it was requested.
-    if !inner.theme_over_surface && location == Location::None {
-        return;
-    }
-
-    let name = match location {
-        // If we can't resize a frame we shouldn't show resize cursors.
-        _ if !inner.resizable => "left_ptr",
-        Location::Top => "top_side",
-        Location::TopRight => "top_right_corner",
-        Location::Right => "right_side",
-        Location::BottomRight => "bottom_right_corner",
-        Location::Bottom => "bottom_side",
-        Location::BottomLeft => "bottom_left_corner",
-        Location::Left => "left_side",
-        Location::TopLeft => "top_left_corner",
-        _ => "left_ptr",
-    };
-
-    if pointer.set_cursor(name, serial).is_err() {
-        error!("Failed to set cursor");
-    }
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Default)]
+pub enum Location {
+    #[default]
+    None,
+    Head,
+    Top,
+    TopRight,
+    Right,
+    BottomRight,
+    Bottom,
+    BottomLeft,
+    Left,
+    TopLeft,
+    Button(ButtonKind),
 }
diff --git a/src/surface.rs b/src/surface.rs
deleted file mode 100644
index de88f50..0000000
--- a/src/surface.rs
+++ /dev/null
@@ -1,154 +0,0 @@
-use std::{cell::RefCell, rc::Rc, sync::Mutex};
-
-use super::client;
-use smithay_client_toolkit as sctk;
-
-use client::{
-    protocol::{wl_output, wl_surface},
-    Attached, DispatchData, Main,
-};
-use sctk::output::{add_output_listener, with_output_info, OutputListener};
-
-pub(crate) struct SurfaceUserData {
-    scale_factor: i32,
-    outputs: Vec<(wl_output::WlOutput, i32, OutputListener)>,
-}
-
-impl SurfaceUserData {
-    fn new() -> Self {
-        SurfaceUserData {
-            scale_factor: 1,
-            outputs: Vec::new(),
-        }
-    }
-
-    pub(crate) fn enter<F>(
-        &mut self,
-        output: wl_output::WlOutput,
-        surface: wl_surface::WlSurface,
-        callback: &Option<Rc<RefCell<F>>>,
-    ) where
-        F: FnMut(i32, wl_surface::WlSurface, DispatchData) + 'static,
-    {
-        let output_scale = with_output_info(&output, |info| info.scale_factor).unwrap_or(1);
-        let my_surface = surface.clone();
-        // Use a UserData to safely share the callback with the other thread
-        let my_callback = client::UserData::new();
-        if let Some(ref cb) = callback {
-            my_callback.set(|| cb.clone());
-        }
-        let listener = add_output_listener(&output, move |output, info, ddata| {
-            let mut user_data = my_surface
-                .as_ref()
-                .user_data()
-                .get::<Mutex<SurfaceUserData>>()
-                .unwrap()
-                .lock()
-                .unwrap();
-            // update the scale factor of the relevant output
-            for (ref o, ref mut factor, _) in user_data.outputs.iter_mut() {
-                if o.as_ref().equals(output.as_ref()) {
-                    if info.obsolete {
-                        // an output that no longer exists is marked by a scale factor of -1
-                        *factor = -1;
-                    } else {
-                        *factor = info.scale_factor;
-                    }
-                    break;
-                }
-            }
-            // recompute the scale factor with the new info
-            let callback = my_callback.get::<Rc<RefCell<F>>>().cloned();
-            let old_scale_factor = user_data.scale_factor;
-            let new_scale_factor = user_data.recompute_scale_factor();
-            drop(user_data);
-            if let Some(ref cb) = callback {
-                if old_scale_factor != new_scale_factor {
-                    (*cb.borrow_mut())(new_scale_factor, surface.clone(), ddata);
-                }
-            }
-        });
-        self.outputs.push((output, output_scale, listener));
-    }
-
-    pub(crate) fn leave(&mut self, output: &wl_output::WlOutput) {
-        self.outputs
-            .retain(|(ref output2, _, _)| !output.as_ref().equals(output2.as_ref()));
-    }
-
-    fn recompute_scale_factor(&mut self) -> i32 {
-        let mut new_scale_factor = 1;
-        self.outputs.retain(|&(_, output_scale, _)| {
-            if output_scale > 0 {
-                new_scale_factor = ::std::cmp::max(new_scale_factor, output_scale);
-                true
-            } else {
-                // cleanup obsolete output
-                false
-            }
-        });
-        if self.outputs.is_empty() {
-            // don't update the scale factor if we are not displayed on any output
-            return self.scale_factor;
-        }
-        self.scale_factor = new_scale_factor;
-        new_scale_factor
-    }
-}
-
-pub fn setup_surface<F>(
-    surface: Main<wl_surface::WlSurface>,
-    callback: Option<F>,
-) -> Attached<wl_surface::WlSurface>
-where
-    F: FnMut(i32, wl_surface::WlSurface, DispatchData) + 'static,
-{
-    let callback = callback.map(|c| Rc::new(RefCell::new(c)));
-    surface.quick_assign(move |surface, event, ddata| {
-        let mut user_data = surface
-            .as_ref()
-            .user_data()
-            .get::<Mutex<SurfaceUserData>>()
-            .unwrap()
-            .lock()
-            .unwrap();
-        match event {
-            wl_surface::Event::Enter { output } => {
-                // Passing the callback to be added to output listener
-                user_data.enter(output, surface.detach(), &callback);
-            }
-            wl_surface::Event::Leave { output } => {
-                user_data.leave(&output);
-            }
-            _ => unreachable!(),
-        };
-        let old_scale_factor = user_data.scale_factor;
-        let new_scale_factor = user_data.recompute_scale_factor();
-        drop(user_data);
-        if let Some(ref cb) = callback {
-            if old_scale_factor != new_scale_factor {
-                (*cb.borrow_mut())(new_scale_factor, surface.detach(), ddata);
-            }
-        }
-    });
-    surface
-        .as_ref()
-        .user_data()
-        .set_threadsafe(|| Mutex::new(SurfaceUserData::new()));
-    surface.into()
-}
-
-/// Returns the current suggested scale factor of a surface.
-///
-/// Panics if the surface was not created using `Environment::create_surface` or
-/// `Environment::create_surface_with_dpi_callback`.
-pub fn get_surface_scale_factor(surface: &wl_surface::WlSurface) -> i32 {
-    surface
-        .as_ref()
-        .user_data()
-        .get::<Mutex<SurfaceUserData>>()
-        .expect("SCTK: Surface was not created by SCTK.")
-        .lock()
-        .unwrap()
-        .scale_factor
-}
diff --git a/src/theme.rs b/src/theme.rs
index 69b3652..1923855 100644
--- a/src/theme.rs
+++ b/src/theme.rs
@@ -1,73 +1,18 @@
-use smithay_client_toolkit::window::WindowState;
-
 pub use tiny_skia::Color;
 use tiny_skia::{Paint, Shader};
 
 pub(crate) const BORDER_SIZE: u32 = 10;
 pub(crate) const HEADER_SIZE: u32 = 35;
+pub(crate) const CORNER_RADIUS: u32 = 10;
+pub(crate) const VISIBLE_BORDER_SIZE: u32 = 1;
 
-#[derive(Debug, Clone)]
-pub struct ColorMap {
-    pub headerbar: Color,
-    pub button_idle: Color,
-    pub button_hover: Color,
-    pub button_icon: Color,
-    pub border_color: Color,
-    pub font_color: Color,
-}
-
-impl ColorMap {
-    pub(crate) fn headerbar_paint(&self) -> Paint {
-        Paint {
-            shader: Shader::SolidColor(self.headerbar),
-            anti_alias: true,
-            ..Default::default()
-        }
-    }
-
-    pub(crate) fn button_idle_paint(&self) -> Paint {
-        Paint {
-            shader: Shader::SolidColor(self.button_idle),
-            anti_alias: true,
-            ..Default::default()
-        }
-    }
-
-    pub(crate) fn button_hover_paint(&self) -> Paint {
-        Paint {
-            shader: Shader::SolidColor(self.button_hover),
-            anti_alias: true,
-            ..Default::default()
-        }
-    }
-
-    pub(crate) fn button_icon_paint(&self) -> Paint {
-        Paint {
-            shader: Shader::SolidColor(self.button_icon),
-            ..Default::default()
-        }
-    }
-
-    pub(crate) fn border_paint(&self) -> Paint {
-        Paint {
-            shader: Shader::SolidColor(self.border_color),
-            ..Default::default()
-        }
-    }
-}
-
+/// The color theme to use with the decorations frame.
 #[derive(Debug, Clone)]
 pub struct ColorTheme {
     pub active: ColorMap,
     pub inactive: ColorMap,
 }
 
-impl Default for ColorTheme {
-    fn default() -> Self {
-        Self::light()
-    }
-}
-
 impl ColorTheme {
     /// Automatically choose between light & dark themes based on:
     /// * dbus org.freedesktop.portal.Settings
@@ -79,6 +24,7 @@ impl ColorTheme {
         }
     }
 
+    /// Predefined light variant, which aims to replecate Adwaita theme.
     pub fn light() -> Self {
         Self {
             active: ColorMap {
@@ -100,6 +46,7 @@ impl ColorTheme {
         }
     }
 
+    /// Predefined dark variant, which aims to replecate Adwaita-dark theme.
     pub fn dark() -> Self {
         Self {
             active: ColorMap {
@@ -120,14 +67,69 @@ impl ColorTheme {
             },
         }
     }
-}
 
-impl ColorTheme {
-    pub(crate) fn for_state(&self, state: WindowState) -> &ColorMap {
-        if state == WindowState::Active {
+    pub(crate) fn for_state(&self, active: bool) -> &ColorMap {
+        if active {
             &self.active
         } else {
             &self.inactive
         }
     }
 }
+
+impl Default for ColorTheme {
+    fn default() -> Self {
+        Self::auto()
+    }
+}
+
+/// The color map for various decorcation parts.
+#[derive(Debug, Clone)]
+pub struct ColorMap {
+    pub headerbar: Color,
+    pub button_idle: Color,
+    pub button_hover: Color,
+    pub button_icon: Color,
+    pub border_color: Color,
+    pub font_color: Color,
+}
+
+impl ColorMap {
+    pub(crate) fn headerbar_paint(&self) -> Paint {
+        Paint {
+            shader: Shader::SolidColor(self.headerbar),
+            anti_alias: true,
+            ..Default::default()
+        }
+    }
+
+    pub(crate) fn button_idle_paint(&self) -> Paint {
+        Paint {
+            shader: Shader::SolidColor(self.button_idle),
+            anti_alias: true,
+            ..Default::default()
+        }
+    }
+
+    pub(crate) fn button_hover_paint(&self) -> Paint {
+        Paint {
+            shader: Shader::SolidColor(self.button_hover),
+            anti_alias: true,
+            ..Default::default()
+        }
+    }
+
+    pub(crate) fn button_icon_paint(&self) -> Paint {
+        Paint {
+            shader: Shader::SolidColor(self.button_icon),
+            ..Default::default()
+        }
+    }
+
+    pub(crate) fn border_paint(&self) -> Paint {
+        Paint {
+            shader: Shader::SolidColor(self.border_color),
+            ..Default::default()
+        }
+    }
+}
diff --git a/src/title.rs b/src/title.rs
index d4a6153..1067f65 100644
--- a/src/title.rs
+++ b/src/title.rs
@@ -47,7 +47,7 @@ impl TitleText {
         self.imp.update_scale(scale)
     }
 
-    pub fn update_title<S: Into<String>>(&mut self, title: S) {
+    pub fn update_title(&mut self, title: impl Into<String>) {
         self.imp.update_title(title)
     }