Implemented Size checking of widgets

Added border widget to start off widget implementations

Author: EmeraldPandaTurtle

Cargo.toml

@@ -8,6 +8,8 @@ repository = "https://github.com/TheEmeraldBee/ascii-forge"
 license = "MIT OR Apache-2.0"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+[lib]
+doctest = false
 
 [dependencies]
 compact_str = "0.8.0"

Makefile

@@ -1,5 +1,9 @@
+test:
+	cargo test
+
+
 VERSION_FILE := Cargo.toml
 
 publish:
 	sed -i -r "s/version=\"0\.0\.0\"/version=\"${VERSION}\"/g" $(VERSION_FILE) \
-	  && cargo publish --allow-dirty \
+	  && cargo publish --allow-dirty

src/lib.rs

@@ -4,6 +4,8 @@ pub mod window;
 
 pub mod math;
 
+pub mod widgets;
+
 pub mod prelude;
 
 // Export required crates

src/renderer/render.rs

@@ -9,7 +9,7 @@ use crate::prelude::*;
 /// This render will return the location of which the last element finished rendering.
 /**
 `Example`
-```rust, no_run
+```rust
 use crate::prelude::*;
 
 // Create a window
@@ -18,8 +18,8 @@ let window = Window::init()?;
 // Render This works! and Another Element! To the window's buffer
 render!(
     window,
-        vec2(16, 16) => [ "This works!" ]
-        vec2(0, 0) => [ "Another Element!" ]
+        (16, 16) => [ "This works!" ]
+        (0, 0) => [ "Another Element!" ]
 );
 ```
 */
@@ -29,8 +29,9 @@ macro_rules! render {
         #[allow(unused_mut)]
         let mut loc;
         $(
-            loc = $loc;
-            $(loc = $render.render(loc, $buffer.as_mut());)*
+            loc = Vec2::from($loc);
+            $(loc = $render.render(loc, $buffer.as_mut()));*;
+            let _ = loc;
         )*
         loc
     }};
@@ -40,6 +41,12 @@ macro_rules! render {
 /// Render's return type is the location the render ended at.
 pub trait Render {
     fn render(&self, loc: Vec2, buffer: &mut Buffer) -> Vec2;
+    fn size(&self) -> Vec2 {
+        let mut buf = Buffer::new((u16::MAX, u16::MAX));
+        render!(buf, vec2(0, 0) => [ self ]);
+        buf.shrink();
+        buf.size()
+    }
 }
 
 /* --------------- Implementations --------------- */
@@ -48,12 +55,18 @@ impl Render for char {
         buffer.set(loc, *self);
         loc
     }
+    fn size(&self) -> Vec2 {
+        vec2(1, 1)
+    }
 }
 
 impl Render for &str {
     fn render(&self, loc: Vec2, buffer: &mut Buffer) -> Vec2 {
         render!(buffer, loc => [ StyledContent::new(ContentStyle::default(), self) ])
     }
+    fn size(&self) -> Vec2 {
+        StyledContent::new(ContentStyle::default(), self).size()
+    }
 }
 
 impl<R: Render + 'static> From<R> for Box<dyn Render> {
@@ -114,4 +127,13 @@ impl<D: Display> Render for StyledContent<D> {
         loc.y -= 1;
         loc
     }
+    fn size(&self) -> Vec2 {
+        let mut width = 0;
+        let mut height = 0;
+        for line in format!("{}", self.content()).split('\n') {
+            width = line.chars().count().max(width);
+            height += 1;
+        }
+        vec2(width as u16, height)
+    }
 }

src/widgets/border.rs

@@ -0,0 +1,66 @@
+use crate::prelude::*;
+
+/// A basic border type.
+/// Rendering this will put the next content inside of the function
+pub struct Border {
+    width: u16,
+    height: u16,
+    horizontal: &'static str,
+    vertical: &'static str,
+    top_left: &'static str,
+    top_right: &'static str,
+    bottom_left: &'static str,
+    bottom_right: &'static str,
+}
+
+impl Border {
+    pub const fn square(width: u16, height: u16) -> Border {
+        Border {
+            width,
+            height,
+            horizontal: "─",
+            vertical: "│",
+            top_right: "┐",
+            top_left: "┌",
+            bottom_left: "└",
+            bottom_right: "┘",
+        }
+    }
+}
+impl Render for Border {
+    fn render(&self, loc: Vec2, buffer: &mut Buffer) -> Vec2 {
+        for y in (loc.y + 1)..(loc.y + self.height - 1) {
+            buffer.set(vec2(loc.x, y), self.vertical);
+            buffer.set(vec2(loc.x + self.width - 1, y), self.vertical);
+        }
+
+        let _ = render!(buffer,
+            loc => [self.top_left, self.horizontal.repeat(self.width as usize - 2), self.top_right],
+            vec2(loc.x, loc.y + self.height - 1) => [self.bottom_left, self.horizontal.repeat(self.width as usize - 2), self.bottom_right]
+        );
+
+        vec2(loc.x + 1, loc.y + 1)
+    }
+    fn size(&self) -> Vec2 {
+        vec2(self.width, self.height)
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::{
+        math::Vec2,
+        render,
+        widgets::border::Border,
+        window::{Buffer, Render},
+    };
+
+    #[test]
+    fn check_size() {
+        let border = Border::square(16, 16);
+        let mut buf = Buffer::new((80, 80));
+        render!(buf, (0, 0) => [ border ]);
+        buf.shrink();
+        assert_eq!(buf.size(), border.size())
+    }
+}

src/widgets/mod.rs

@@ -0,0 +1 @@
+pub mod border;

src/window.rs

@@ -31,7 +31,7 @@ impl AsMut<Buffer> for Window {
 /// Represents the terminal window, allowing it to be used similar to a buffer,
 /// but has extra event handling.
 /**
-```rust, no_run
+```rust,
 use ascii_forge::prelude::*;
 
 let mut window = Window::init()?;