adding a simple layout renderer

Author: Innes Anderson-Morrison

crates/penrose_ui/examples/layout-render.rs

@@ -0,0 +1,32 @@
+use penrose::{
+    builtin::layout::{CenteredMain, Grid, MainAndStack},
+    extensions::layout::{Fibonacci, Tatami},
+    pure::geometry::Rect,
+    stack,
+};
+use penrose_ui::layout_viewer::LayoutViewer;
+
+const BLACK: u32 = 0x252535ff; // #252535
+const WHITE: u32 = 0xdcd7baff; // #dcd7ba
+const BLUE: u32 = 0x658594ff; //  #658594
+const R: Rect = Rect::new(0, 0, 640, 480);
+const FRAME_MS: u64 = 400;
+const GPX: u32 = 5;
+
+fn main() -> anyhow::Result<()> {
+    let layouts = vec![
+        MainAndStack::boxed_default(),
+        MainAndStack::boxed_default_rotated(),
+        CenteredMain::boxed_default(),
+        CenteredMain::boxed_default_rotated(),
+        Fibonacci::boxed_default(),
+        Tatami::boxed_default(),
+        Grid::boxed(),
+    ];
+
+    let mut v = LayoutViewer::new(R, BLACK, BLUE, WHITE)?;
+    let s = stack!(1, 2, 3, 4, 5, 6).map(Into::into);
+    v.showcase_layouts(s, layouts, GPX, FRAME_MS)?;
+
+    Ok(())
+}

crates/penrose_ui/src/layout_viewer.rs

@@ -0,0 +1,101 @@
+//! A simple UI for view the results of a given Layout implementation
+use crate::{Draw, Result};
+use penrose::{
+    builtin::layout::transformers::Gaps,
+    core::layout::Layout,
+    pure::{geometry::Rect, Stack},
+    x::{Atom, WinType, XConn},
+    x11rb::RustConn,
+    Color, Xid,
+};
+use std::{thread::sleep, time::Duration};
+
+const FONT: &str = "mono";
+
+/// A simple way to view the output of specific [Layout] implementations outside of a running
+/// window manager.
+#[derive(Debug)]
+pub struct LayoutViewer {
+    drw: Draw,
+    win: Xid,
+    r: Rect,
+    focused: Color,
+    unfocused: Color,
+}
+
+impl LayoutViewer {
+    /// Construct a new [LayoutViewer] with a specified color scheme and window size.
+    pub fn new(
+        r: Rect,
+        bg: impl Into<Color>,
+        focused: impl Into<Color>,
+        unfocused: impl Into<Color>,
+    ) -> Result<Self> {
+        let conn = RustConn::new()?;
+        let screen_rects = conn.screen_details()?;
+        let r_screen = screen_rects.last().unwrap();
+
+        let mut drw = Draw::new(FONT, 14, bg)?;
+        let win = drw.new_window(
+            WinType::InputOutput(Atom::NetWindowTypeDock),
+            r.centered_in(r_screen).unwrap_or(r_screen.shrink_in(30)),
+            false,
+        )?;
+
+        Ok(Self {
+            drw,
+            win,
+            r,
+            focused: focused.into(),
+            unfocused: unfocused.into(),
+        })
+    }
+
+    /// Run a [Layout] for a given client stack and display the result for specified number of
+    /// milliseconds.
+    pub fn render_layout_with_stack(
+        &mut self,
+        layout: &mut Box<dyn Layout>,
+        stack: &Stack<Xid>,
+        display_ms: u64,
+    ) -> Result<()> {
+        let focus = *stack.focused();
+        let (_, positions) = layout.layout(stack, self.r);
+
+        let mut ctx = self.drw.context_for(self.win)?;
+        ctx.fill_bg(self.r)?;
+
+        for (id, r_w) in positions {
+            let color = if id == focus {
+                self.focused
+            } else {
+                self.unfocused
+            };
+            ctx.fill_rect(r_w, color)?;
+        }
+
+        ctx.flush();
+        sleep(Duration::from_millis(display_ms));
+
+        Ok(())
+    }
+
+    /// Show the layout result for a set of [Layout]s using a given stack while rotating focus
+    /// between the clients.
+    pub fn showcase_layouts(
+        &mut self,
+        mut s: Stack<Xid>,
+        layouts: Vec<Box<dyn Layout>>,
+        gap_px: u32,
+        display_ms: u64,
+    ) -> Result<()> {
+        for mut l in layouts.into_iter().map(|l| Gaps::wrap(l, gap_px, gap_px)) {
+            for _ in 0..s.len() {
+                self.render_layout_with_stack(&mut l, &s, display_ms)?;
+                s.focus_down();
+            }
+        }
+
+        Ok(())
+    }
+}

crates/penrose_ui/src/lib.rs

@@ -39,6 +39,7 @@ use std::ffi::NulError;
 
 pub mod bar;
 pub mod core;
+pub mod layout_viewer;
 
 pub use crate::core::{Context, Draw, TextStyle};
 pub use bar::{Position, StatusBar};

src/builtin/layout/mod.rs

@@ -82,6 +82,15 @@ impl MainAndStack {
         Box::<Self>::default()
     }
 
+    /// Create a new rotated default [MainAndStack] [Layout] as a trait object ready to be added to
+    /// your [LayoutStack][crate::core::layout::LayoutStack].
+    pub fn boxed_default_rotated() -> Box<dyn Layout> {
+        let mut l = Self::default();
+        l.rotate();
+
+        Box::new(l)
+    }
+
     /// Create a new [MainAndStack] [Layout] with the main area on the left and remaining windows
     /// stacked to the right.
     pub fn side(max_main: u32, ratio: f32, ratio_step: f32) -> Box<dyn Layout> {
@@ -130,6 +139,11 @@ impl MainAndStack {
         }
     }
 
+    /// Rotate the main axis of this layout
+    pub fn rotate(&mut self) {
+        self.pos = self.pos.rotate();
+    }
+
     fn ratio(&self) -> f32 {
         if self.mirrored {
             1.0 - self.ratio
@@ -237,7 +251,7 @@ impl Layout for MainAndStack {
         } else if let Some(&Mirror) = m.downcast_ref() {
             self.mirrored = !self.mirrored;
         } else if let Some(&Rotate) = m.downcast_ref() {
-            self.pos = self.pos.rotate();
+            self.rotate();
         }
 
         None
@@ -297,6 +311,15 @@ impl CenteredMain {
         Box::<Self>::default()
     }
 
+    /// Create a new rotated default [CenteredMain] [Layout] as a trait object ready to be added to
+    /// your [LayoutStack][crate::core::layout::LayoutStack].
+    pub fn boxed_default_rotated() -> Box<dyn Layout> {
+        let mut l = Self::default();
+        l.rotate();
+
+        Box::new(l)
+    }
+
     /// Create a new [CenteredMain] [Layout] with a vertical main area and remaining windows
     /// tiled to the left and right.
     pub fn vertical(max_main: u32, ratio: f32, ratio_step: f32) -> Box<dyn Layout> {
@@ -331,6 +354,11 @@ impl CenteredMain {
         }
     }
 
+    /// Rotate the main axis of this layout
+    pub fn rotate(&mut self) {
+        self.pos = self.pos.rotate();
+    }
+
     fn single_stack(&self, n: u32) -> bool {
         n <= self.max_main || self.ratio == 1.0 || self.ratio == 0.0
     }
@@ -455,7 +483,7 @@ impl Layout for CenteredMain {
                 self.max_main += n as u32;
             }
         } else if let Some(&Rotate) = m.downcast_ref() {
-            self.pos = self.pos.rotate();
+            self.rotate();
         }
 
         None

src/extensions/layout/mod.rs

@@ -193,6 +193,12 @@ impl Tatami {
     pub fn boxed(ratio: f32, ratio_step: f32) -> Box<dyn Layout> {
         Box::new(Tatami { ratio, ratio_step })
     }
+
+    /// Create a new default [Tatami] layout returned as a trait object ready to be added to your
+    /// layout stack.
+    pub fn boxed_default() -> Box<dyn Layout> {
+        Box::<Tatami>::default()
+    }
 }
 
 impl Default for Tatami {