Implement fill for circles and rectangles

Cargo.toml

@@ -12,7 +12,7 @@ description = "Ratatui widget to draw a plotters chart"
 plotters-backend = "0.3.5"
 ratatui = "0.26.0"
 thiserror = "1.0.50"
-plotters = {version = "0.3.5", optional = true, default-features = false}
+plotters = {version = "0.3.5", optional = true, default-features = true}
 log = "0.4.20"
 
 [features]

README.md

@@ -7,3 +7,11 @@ A ratatui widget for drawing a plotters chart.
 <img src="examples/mandelbrot.png" width=200px />
 <img src="examples/normal-dist.png" width=200px />
 <img src="examples/3d-plot.png" width=200px />
+
+## Tests
+
+When running tests please note the following constraints.
+
+The tests *require* human interaction.  An image is displayed in the upper section of the terminal, with a yes/no question in the lower section.  Inspect the image, and respond to the question with 'y' or 'n' as appropriate.
+
+Because the tests require a `ratatui` display loop, they **MUST** be run single threaded `--test-threads=1`, e.g. `cargo test -- --test-threads=1`.

examples/boilerplate.rs

@@ -52,3 +52,7 @@ pub fn main_boilerplate(
 
     Ok(())
 }
+
+#[warn(dead_code)]
+fn main() {}
+

src/lib.rs

@@ -10,7 +10,7 @@ mod widget;
 #[cfg(feature = "widget")]
 pub use widget::*;
 
-pub const CHAR_PIXEL_SIZE: u32 = 4;
+pub const CHAR_PIXEL_SIZE: (u32, u32) = (2, 4);
 
 pub struct RatatuiBackend<'a, 'b> {
     pub canvas: &'a mut canvas::Context<'b>,
@@ -41,7 +41,7 @@ impl<'a, 'b> DrawingBackend for RatatuiBackend<'a, 'b> {
         mut coord: BackendCoord,
     ) -> Result {
         let width = text.chars().count();
-        coord.0 -= (width as u32 * CHAR_PIXEL_SIZE / 2) as i32;
+        coord.0 -= (width as u32 * CHAR_PIXEL_SIZE.0 / 2) as i32;
 
         let (x, y) = backend_to_canvas_coords(coord, self.size);
         self.canvas.print(x, y, text::Line::styled(text.to_string(), convert_style(style)));
@@ -66,15 +66,27 @@ impl<'a, 'b> DrawingBackend for RatatuiBackend<'a, 'b> {
         coord: BackendCoord,
         radius: u32,
         style: &S,
-        _fill: bool,
+        fill: bool,
     ) -> std::result::Result<(), DrawingErrorKind<Self::ErrorType>> {
         let (x, y) = backend_to_canvas_coords(coord, self.size);
-        self.canvas.draw(&canvas::Circle {
-            x,
-            y,
-            radius: radius.into(),
-            color: convert_color(style.color()),
-        });
+        if fill {
+            let radius = radius as i32;
+            for dy in -radius..=radius {
+                let half_width = ((radius.pow(2) - dy.pow(2)) as f64).sqrt() as i32;
+                self.draw_line(
+                    (coord.0 - half_width, coord.1 + dy),
+                    (coord.0 + half_width, coord.1 + dy),
+                    style,
+                )?;
+            }
+        } else {
+            self.canvas.draw(&canvas::Circle {
+                x,
+                y,
+                radius: radius.into(),
+                color: convert_color(style.color()),
+            });
+        }
         Ok(())
     }
 
@@ -83,18 +95,34 @@ impl<'a, 'b> DrawingBackend for RatatuiBackend<'a, 'b> {
         coord1: BackendCoord,
         coord2: BackendCoord,
         style: &S,
-        _fill: bool,
+        fill: bool,
     ) -> std::result::Result<(), DrawingErrorKind<Self::ErrorType>> {
-        let (x1, y1) = backend_to_canvas_coords(coord1, self.size);
-        let (x2, y2) = backend_to_canvas_coords(coord2, self.size);
-
-        self.canvas.draw(&canvas::Rectangle {
-            x:      x1.min(x2),
-            y:      y1.min(y2),
-            width:  (x2 - x1).abs(),
-            height: (y2 - y1).abs(),
-            color:  convert_color(style.color()),
-        });
+        if fill {
+            let color = convert_color(style.color());
+
+            let (start, stop) = (
+                (coord1.0.min(coord2.0), coord1.1.min(coord2.1)),
+                (coord1.0.max(coord2.0), coord1.1.max(coord2.1)),
+            );
+
+            for x in start.0..=stop.0 {
+                let (x1, y1) = backend_to_canvas_coords((x, start.1), self.size);
+                let (x2, y2) = backend_to_canvas_coords((x, stop.1), self.size);
+
+                self.canvas.draw(&canvas::Line::new(x1, y1, x2, y2, color));
+            }
+        } else {
+            let (x1, y1) = backend_to_canvas_coords(coord1, self.size);
+            let (x2, y2) = backend_to_canvas_coords(coord2, self.size);
+
+            self.canvas.draw(&canvas::Rectangle {
+                x:      x1.min(x2),
+                y:      y1.min(y2),
+                width:  (x2 - x1).abs(),
+                height: (y2 - y1).abs(),
+                color:  convert_color(style.color()),
+            });
+        }
         Ok(())
     }
 
@@ -103,12 +131,12 @@ impl<'a, 'b> DrawingBackend for RatatuiBackend<'a, 'b> {
         text: &str,
         _style: &TStyle,
     ) -> std::result::Result<(u32, u32), DrawingErrorKind<Self::ErrorType>> {
-        Ok((text.chars().count() as u32 * CHAR_PIXEL_SIZE, CHAR_PIXEL_SIZE))
+        Ok((text.chars().count() as u32 * CHAR_PIXEL_SIZE.0, CHAR_PIXEL_SIZE.1))
     }
 }
 
 fn rect_to_size(rect: layout::Rect) -> (u32, u32) {
-    (u32::from(rect.width) * CHAR_PIXEL_SIZE, u32::from(rect.height) * CHAR_PIXEL_SIZE)
+    (u32::from(rect.width) * CHAR_PIXEL_SIZE.0, u32::from(rect.height) * CHAR_PIXEL_SIZE.1)
 }
 
 fn backend_to_canvas_coords((x, y): BackendCoord, rect: layout::Rect) -> (f64, f64) {