plotters_unstable/drawing/

area.rs

use crate::coord::cartesian::{Cartesian2d, MeshLine};
use crate::coord::ranged1d::{KeyPointHint, Ranged};
use crate::coord::{CoordTranslate, Shift};
use crate::element::{Drawable, PointCollection};
use crate::style::text_anchor::{HPos, Pos, VPos};
use crate::style::{Color, SizeDesc, TextStyle};

/// The abstraction of a drawing area
use plotters_backend::{BackendCoord, DrawingBackend, DrawingErrorKind};

use std::borrow::Borrow;
use std::cell::RefCell;
use std::error::Error;
use std::iter::{once, repeat};
use std::ops::Range;
use std::rc::Rc;

/// The representation of the rectangle in backend canvas
#[derive(Clone, Debug)]
struct Rect {
    x0: i32,
    y0: i32,
    x1: i32,
    y1: i32,
}

impl Rect {
    /// Split the rectangle into a few smaller rectangles
    fn split<'a, BPI: IntoIterator<Item = &'a i32> + 'a>(
        &'a self,
        break_points: BPI,
        vertical: bool,
    ) -> impl Iterator<Item = Rect> + 'a {
        let (mut x0, mut y0) = (self.x0, self.y0);
        let (full_x, full_y) = (self.x1, self.y1);
        break_points
            .into_iter()
            .chain(once(if vertical { &self.y1 } else { &self.x1 }))
            .map(move |&p| {
                let x1 = if vertical { full_x } else { p };
                let y1 = if vertical { p } else { full_y };
                let ret = Rect { x0, y0, x1, y1 };

                if vertical {
                    y0 = y1
                } else {
                    x0 = x1;
                }

                ret
            })
    }

    /// Evenly split the rectangle to a row * col mesh
    fn split_evenly<'a>(&'a self, (row, col): (usize, usize)) -> impl Iterator<Item = Rect> + 'a {
        fn compute_evenly_split(from: i32, to: i32, n: usize, idx: usize) -> i32 {
            let size = (to - from) as usize;
            from + idx as i32 * (size / n) as i32 + idx.min(size % n) as i32
        }
        (0..row)
            .map(move |x| repeat(x).zip(0..col))
            .flatten()
            .map(move |(ri, ci)| Self {
                y0: compute_evenly_split(self.y0, self.y1, row, ri),
                y1: compute_evenly_split(self.y0, self.y1, row, ri + 1),
                x0: compute_evenly_split(self.x0, self.x1, col, ci),
                x1: compute_evenly_split(self.x0, self.x1, col, ci + 1),
            })
    }

    fn split_grid(
        &self,
        x_breaks: impl Iterator<Item = i32>,
        y_breaks: impl Iterator<Item = i32>,
    ) -> impl Iterator<Item = Rect> {
        let mut xs = vec![self.x0, self.x1];
        let mut ys = vec![self.y0, self.y1];
        xs.extend(x_breaks.map(|v| v + self.x0));
        ys.extend(y_breaks.map(|v| v + self.y0));

        xs.sort();
        ys.sort();

        let xsegs: Vec<_> = xs
            .iter()
            .zip(xs.iter().skip(1))
            .map(|(a, b)| (*a, *b))
            .collect();
        let ysegs: Vec<_> = ys
            .iter()
            .zip(ys.iter().skip(1))
            .map(|(a, b)| (*a, *b))
            .collect();

        ysegs
            .into_iter()
            .map(move |(y0, y1)| {
                xsegs
                    .clone()
                    .into_iter()
                    .map(move |(x0, x1)| Self { x0, y0, x1, y1 })
            })
            .flatten()
    }

    /// Make the coordinate in the range of the rectangle
    fn truncate(&self, p: (i32, i32)) -> (i32, i32) {
        (p.0.min(self.x1).max(self.x0), p.1.min(self.y1).max(self.y0))
    }
}

/// The abstraction of a drawing area. Plotters uses drawing area as the fundamental abstraction for the
/// high level drawing API. The major functionality provided by the drawing area is
///     1. Layout specification - Split the parent drawing area into sub-drawing-areas
///     2. Coordinate Translation - Allows guest coordinate system attached and used for drawing.
///     3. Element based drawing - drawing area provides the environment the element can be drawn onto it.
pub struct DrawingArea<DB: DrawingBackend, CT: CoordTranslate> {
    backend: Rc<RefCell<DB>>,
    rect: Rect,
    coord: CT,
}

impl<DB: DrawingBackend, CT: CoordTranslate + Clone> Clone for DrawingArea<DB, CT> {
    fn clone(&self) -> Self {
        Self {
            backend: self.backend.clone(),
            rect: self.rect.clone(),
            coord: self.coord.clone(),
        }
    }
}

/// The error description of any drawing area API
#[derive(Debug)]
pub enum DrawingAreaErrorKind<E: Error + Send + Sync> {
    /// The error is due to drawing backend failure
    BackendError(DrawingErrorKind<E>),
    /// We are not able to get the mutable reference of the backend,
    /// which indicates the drawing backend is current used by other
    /// drawing operation
    SharingError,
    /// The error caused by invalid layout
    LayoutError,
}

impl<E: Error + Send + Sync> std::fmt::Display for DrawingAreaErrorKind<E> {
    fn fmt(&self, fmt: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
        match self {
            DrawingAreaErrorKind::BackendError(e) => write!(fmt, "backend error: {}", e),
            DrawingAreaErrorKind::SharingError => {
                write!(fmt, "Multiple backend operation in progress")
            }
            DrawingAreaErrorKind::LayoutError => write!(fmt, "Bad layout"),
        }
    }
}

impl<E: Error + Send + Sync> Error for DrawingAreaErrorKind<E> {}

#[allow(type_alias_bounds)]
type DrawingAreaError<T: DrawingBackend> = DrawingAreaErrorKind<T::ErrorType>;

impl<DB: DrawingBackend> From<DB> for DrawingArea<DB, Shift> {
    fn from(backend: DB) -> Self {
        Self::with_rc_cell(Rc::new(RefCell::new(backend)))
    }
}

impl<'a, DB: DrawingBackend> From<&'a Rc<RefCell<DB>>> for DrawingArea<DB, Shift> {
    fn from(backend: &'a Rc<RefCell<DB>>) -> Self {
        Self::with_rc_cell(backend.clone())
    }
}

/// A type which can be converted into a root drawing area
pub trait IntoDrawingArea: DrawingBackend + Sized {
    /// Convert the type into a root drawing area
    fn into_drawing_area(self) -> DrawingArea<Self, Shift>;
}

impl<T: DrawingBackend> IntoDrawingArea for T {
    fn into_drawing_area(self) -> DrawingArea<T, Shift> {
        self.into()
    }
}

impl<DB: DrawingBackend, X: Ranged, Y: Ranged> DrawingArea<DB, Cartesian2d<X, Y>> {
    /// Draw the mesh on a area
    pub fn draw_mesh<DrawFunc, YH: KeyPointHint, XH: KeyPointHint>(
        &self,
        mut draw_func: DrawFunc,
        y_count_max: YH,
        x_count_max: XH,
    ) -> Result<(), DrawingAreaErrorKind<DB::ErrorType>>
    where
        DrawFunc: FnMut(&mut DB, MeshLine<X, Y>) -> Result<(), DrawingErrorKind<DB::ErrorType>>,
    {
        self.backend_ops(move |b| {
            self.coord
                .draw_mesh(y_count_max, x_count_max, |line| draw_func(b, line))
        })
    }

    /// Get the range of X of the guest coordinate for current drawing area
    pub fn get_x_range(&self) -> Range<X::ValueType> {
        self.coord.get_x_range()
    }

    /// Get the range of Y of the guest coordinate for current drawing area
    pub fn get_y_range(&self) -> Range<Y::ValueType> {
        self.coord.get_y_range()
    }

    pub fn get_x_axis_pixel_range(&self) -> Range<i32> {
        self.coord.get_x_axis_pixel_range()
    }

    pub fn get_y_axis_pixel_range(&self) -> Range<i32> {
        self.coord.get_y_axis_pixel_range()
    }
}

impl<DB: DrawingBackend, CT: CoordTranslate> DrawingArea<DB, CT> {
    /// Get the left upper conner of this area in the drawing backend
    pub fn get_base_pixel(&self) -> BackendCoord {
        (self.rect.x0, self.rect.y0)
    }

    /// Strip the applied coordinate specification and returns a shift-based drawing area
    pub fn strip_coord_spec(&self) -> DrawingArea<DB, Shift> {
        DrawingArea {
            rect: self.rect.clone(),
            backend: self.backend.clone(),
            coord: Shift((self.rect.x0, self.rect.y0)),
        }
    }

    /// Get the area dimension in pixel
    pub fn dim_in_pixel(&self) -> (u32, u32) {
        (
            (self.rect.x1 - self.rect.x0) as u32,
            (self.rect.y1 - self.rect.y0) as u32,
        )
    }

    /// Compute the relative size based on the drawing area's height
    pub fn relative_to_height(&self, p: f64) -> f64 {
        f64::from((self.rect.y1 - self.rect.y0).max(0)) * (p.min(1.0).max(0.0))
    }

    /// Compute the relative size based on the drawing area's width
    pub fn relative_to_width(&self, p: f64) -> f64 {
        f64::from((self.rect.x1 - self.rect.x0).max(0)) * (p.min(1.0).max(0.0))
    }

    /// Get the pixel range of this area
    pub fn get_pixel_range(&self) -> (Range<i32>, Range<i32>) {
        (self.rect.x0..self.rect.x1, self.rect.y0..self.rect.y1)
    }

    /// Perform operation on the drawing backend
    fn backend_ops<R, O: FnOnce(&mut DB) -> Result<R, DrawingErrorKind<DB::ErrorType>>>(
        &self,
        ops: O,
    ) -> Result<R, DrawingAreaError<DB>> {
        if let Ok(mut db) = self.backend.try_borrow_mut() {
            db.ensure_prepared()
                .map_err(DrawingAreaErrorKind::BackendError)?;
            ops(&mut db).map_err(DrawingAreaErrorKind::BackendError)
        } else {
            Err(DrawingAreaErrorKind::SharingError)
        }
    }

    /// Fill the entire drawing area with a color
    pub fn fill<ColorType: Color>(&self, color: &ColorType) -> Result<(), DrawingAreaError<DB>> {
        self.backend_ops(|backend| {
            backend.draw_rect(
                (self.rect.x0, self.rect.y0),
                (self.rect.x1 - 1, self.rect.y1 - 1),
                color,
                true,
            )
        })
    }

    /// Draw a single pixel
    pub fn draw_pixel<ColorType: Color>(
        &self,
        pos: CT::From,
        color: &ColorType,
    ) -> Result<(), DrawingAreaError<DB>> {
        let pos = self.coord.translate(&pos);
        self.backend_ops(|b| b.draw_pixel(pos, color.color()))
    }

    /// Present all the pending changes to the backend
    pub fn present(&self) -> Result<(), DrawingAreaError<DB>> {
        self.backend_ops(|b| b.present())
    }

    /// Draw an high-level element
    pub fn draw<'a, E>(&self, element: &'a E) -> Result<(), DrawingAreaError<DB>>
    where
        &'a E: PointCollection<'a, CT::From>,
        E: Drawable<DB>,
    {
        let backend_coords = element.point_iter().into_iter().map(|p| {
            let b = p.borrow();
            self.rect.truncate(self.coord.translate(b))
        });
        self.backend_ops(move |b| element.draw(backend_coords, b, self.dim_in_pixel()))
    }

    /// Map coordinate to the backend coordinate
    pub fn map_coordinate(&self, coord: &CT::From) -> BackendCoord {
        self.coord.translate(coord)
    }

    /// Estimate the dimension of the text if drawn on this drawing area.
    /// We can't get this directly from the font, since the drawing backend may or may not
    /// follows the font configuration. In terminal, the font family will be dropped.
    /// So the size of the text is drawing area related.
    ///
    /// - `text`: The text we want to estimate
    /// - `font`: The font spec in which we want to draw the text
    /// - **return**: The size of the text if drawn on this area
    pub fn estimate_text_size(
        &self,
        text: &str,
        style: &TextStyle,
    ) -> Result<(u32, u32), DrawingAreaError<DB>> {
        self.backend_ops(move |b| b.estimate_text_size(text, style))
    }
}

impl<DB: DrawingBackend> DrawingArea<DB, Shift> {
    fn with_rc_cell(backend: Rc<RefCell<DB>>) -> Self {
        let (x1, y1) = RefCell::borrow(backend.borrow()).get_size();
        Self {
            rect: Rect {
                x0: 0,
                y0: 0,
                x1: x1 as i32,
                y1: y1 as i32,
            },
            backend,
            coord: Shift((0, 0)),
        }
    }

    /// Shrink the region, note all the locations are in guest coordinate
    pub fn shrink<A: SizeDesc, B: SizeDesc, C: SizeDesc, D: SizeDesc>(
        mut self,
        left_upper: (A, B),
        dimension: (C, D),
    ) -> DrawingArea<DB, Shift> {
        let left_upper = (left_upper.0.in_pixels(&self), left_upper.1.in_pixels(&self));
        let dimension = (dimension.0.in_pixels(&self), dimension.1.in_pixels(&self));
        self.rect.x0 = self.rect.x1.min(self.rect.x0 + left_upper.0);
        self.rect.y0 = self.rect.y1.min(self.rect.y0 + left_upper.1);

        self.rect.x1 = self.rect.x0.max(self.rect.x0 + dimension.0);
        self.rect.y1 = self.rect.y0.max(self.rect.y0 + dimension.1);

        self.coord = Shift((self.rect.x0, self.rect.y0));

        self
    }

    /// Apply a new coord transformation object and returns a new drawing area
    pub fn apply_coord_spec<CT: CoordTranslate>(&self, coord_spec: CT) -> DrawingArea<DB, CT> {
        DrawingArea {
            rect: self.rect.clone(),
            backend: self.backend.clone(),
            coord: coord_spec,
        }
    }

    /// Create a margin for the given drawing area and returns the new drawing area
    pub fn margin<ST: SizeDesc, SB: SizeDesc, SL: SizeDesc, SR: SizeDesc>(
        &self,
        top: ST,
        bottom: SB,
        left: SL,
        right: SR,
    ) -> DrawingArea<DB, Shift> {
        let left = left.in_pixels(self);
        let right = right.in_pixels(self);
        let top = top.in_pixels(self);
        let bottom = bottom.in_pixels(self);
        DrawingArea {
            rect: Rect {
                x0: self.rect.x0 + left,
                y0: self.rect.y0 + top,
                x1: self.rect.x1 - right,
                y1: self.rect.y1 - bottom,
            },
            backend: self.backend.clone(),
            coord: Shift((self.rect.x0 + left, self.rect.y0 + top)),
        }
    }

    /// Split the drawing area vertically
    pub fn split_vertically<S: SizeDesc>(&self, y: S) -> (Self, Self) {
        let y = y.in_pixels(self);
        let split_point = [y + self.rect.y0];
        let mut ret = self.rect.split(split_point.iter(), true).map(|rect| Self {
            rect: rect.clone(),
            backend: self.backend.clone(),
            coord: Shift((rect.x0, rect.y0)),
        });

        (ret.next().unwrap(), ret.next().unwrap())
    }

    /// Split the drawing area horizontally
    pub fn split_horizontally<S: SizeDesc>(&self, x: S) -> (Self, Self) {
        let x = x.in_pixels(self);
        let split_point = [x + self.rect.x0];
        let mut ret = self.rect.split(split_point.iter(), false).map(|rect| Self {
            rect: rect.clone(),
            backend: self.backend.clone(),
            coord: Shift((rect.x0, rect.y0)),
        });

        (ret.next().unwrap(), ret.next().unwrap())
    }

    /// Split the drawing area evenly
    pub fn split_evenly(&self, (row, col): (usize, usize)) -> Vec<Self> {
        self.rect
            .split_evenly((row, col))
            .map(|rect| Self {
                rect: rect.clone(),
                backend: self.backend.clone(),
                coord: Shift((rect.x0, rect.y0)),
            })
            .collect()
    }

    /// Split the drawing area into a grid with specified breakpoints on both X axis and Y axis
    pub fn split_by_breakpoints<
        XSize: SizeDesc,
        YSize: SizeDesc,
        XS: AsRef<[XSize]>,
        YS: AsRef<[YSize]>,
    >(
        &self,
        xs: XS,
        ys: YS,
    ) -> Vec<Self> {
        self.rect
            .split_grid(
                xs.as_ref().iter().map(|x| x.in_pixels(self)),
                ys.as_ref().iter().map(|x| x.in_pixels(self)),
            )
            .map(|rect| Self {
                rect: rect.clone(),
                backend: self.backend.clone(),
                coord: Shift((rect.x0, rect.y0)),
            })
            .collect()
    }

    /// Draw a title of the drawing area and return the remaining drawing area
    pub fn titled<'a, S: Into<TextStyle<'a>>>(
        &self,
        text: &str,
        style: S,
    ) -> Result<Self, DrawingAreaError<DB>> {
        let style = style.into();

        let x_padding = (self.rect.x1 - self.rect.x0) / 2;

        let (_, text_h) = self.estimate_text_size(text, &style)?;
        let y_padding = (text_h / 2).min(5) as i32;

        let style = &style.pos(Pos::new(HPos::Center, VPos::Top));

        self.backend_ops(|b| {
            b.draw_text(
                text,
                style,
                (self.rect.x0 + x_padding, self.rect.y0 + y_padding),
            )
        })?;

        Ok(Self {
            rect: Rect {
                x0: self.rect.x0,
                y0: self.rect.y0 + y_padding * 2 + text_h as i32,
                x1: self.rect.x1,
                y1: self.rect.y1,
            },
            backend: self.backend.clone(),
            coord: Shift((self.rect.x0, self.rect.y0 + y_padding * 2 + text_h as i32)),
        })
    }

    /// Draw text on the drawing area
    pub fn draw_text(
        &self,
        text: &str,
        style: &TextStyle,
        pos: BackendCoord,
    ) -> Result<(), DrawingAreaError<DB>> {
        self.backend_ops(|b| b.draw_text(text, style, (pos.0 + self.rect.x0, pos.1 + self.rect.y0)))
    }
}

impl<DB: DrawingBackend, CT: CoordTranslate> DrawingArea<DB, CT> {
    pub fn into_coord_spec(self) -> CT {
        self.coord
    }

    pub fn as_coord_spec(&self) -> &CT {
        &self.coord
    }
}

#[cfg(test)]
mod drawing_area_tests {
    use crate::{create_mocked_drawing_area, prelude::*};
    #[test]
    fn test_filling() {
        let drawing_area = create_mocked_drawing_area(1024, 768, |m| {
            m.check_draw_rect(|c, _, f, u, d| {
                assert_eq!(c, WHITE.to_rgba());
                assert_eq!(f, true);
                assert_eq!(u, (0, 0));
                assert_eq!(d, (1023, 767));
            });

            m.drop_check(|b| {
                assert_eq!(b.num_draw_rect_call, 1);
                assert_eq!(b.draw_count, 1);
            });
        });

        drawing_area.fill(&WHITE).expect("Drawing Failure");
    }

    #[test]
    fn test_split_evenly() {
        let colors = vec![
            &RED, &BLUE, &YELLOW, &WHITE, &BLACK, &MAGENTA, &CYAN, &BLUE, &RED,
        ];
        let drawing_area = create_mocked_drawing_area(902, 900, |m| {
            for col in 0..3 {
                for row in 0..3 {
                    let colors = colors.clone();
                    m.check_draw_rect(move |c, _, f, u, d| {
                        assert_eq!(c, colors[col * 3 + row].to_rgba());
                        assert_eq!(f, true);
                        assert_eq!(u, (300 * row as i32 + 2.min(row) as i32, 300 * col as i32));
                        assert_eq!(
                            d,
                            (
                                300 + 300 * row as i32 + 2.min(row + 1) as i32 - 1,
                                300 + 300 * col as i32 - 1
                            )
                        );
                    });
                }
            }
            m.drop_check(|b| {
                assert_eq!(b.num_draw_rect_call, 9);
                assert_eq!(b.draw_count, 9);
            });
        });

        drawing_area
            .split_evenly((3, 3))
            .iter_mut()
            .zip(colors.iter())
            .for_each(|(d, c)| {
                d.fill(*c).expect("Drawing Failure");
            });
    }

    #[test]
    fn test_split_horizontally() {
        let drawing_area = create_mocked_drawing_area(1024, 768, |m| {
            m.check_draw_rect(|c, _, f, u, d| {
                assert_eq!(c, RED.to_rgba());
                assert_eq!(f, true);
                assert_eq!(u, (0, 0));
                assert_eq!(d, (345 - 1, 768 - 1));
            });

            m.check_draw_rect(|c, _, f, u, d| {
                assert_eq!(c, BLUE.to_rgba());
                assert_eq!(f, true);
                assert_eq!(u, (345, 0));
                assert_eq!(d, (1024 - 1, 768 - 1));
            });

            m.drop_check(|b| {
                assert_eq!(b.num_draw_rect_call, 2);
                assert_eq!(b.draw_count, 2);
            });
        });

        let (left, right) = drawing_area.split_horizontally(345);
        left.fill(&RED).expect("Drawing Error");
        right.fill(&BLUE).expect("Drawing Error");
    }

    #[test]
    fn test_split_vertically() {
        let drawing_area = create_mocked_drawing_area(1024, 768, |m| {
            m.check_draw_rect(|c, _, f, u, d| {
                assert_eq!(c, RED.to_rgba());
                assert_eq!(f, true);
                assert_eq!(u, (0, 0));
                assert_eq!(d, (1024 - 1, 345 - 1));
            });

            m.check_draw_rect(|c, _, f, u, d| {
                assert_eq!(c, BLUE.to_rgba());
                assert_eq!(f, true);
                assert_eq!(u, (0, 345));
                assert_eq!(d, (1024 - 1, 768 - 1));
            });

            m.drop_check(|b| {
                assert_eq!(b.num_draw_rect_call, 2);
                assert_eq!(b.draw_count, 2);
            });
        });

        let (left, right) = drawing_area.split_vertically(345);
        left.fill(&RED).expect("Drawing Error");
        right.fill(&BLUE).expect("Drawing Error");
    }

    #[test]
    fn test_split_grid() {
        let colors = vec![
            &RED, &BLUE, &YELLOW, &WHITE, &BLACK, &MAGENTA, &CYAN, &BLUE, &RED,
        ];
        let breaks: [i32; 5] = [100, 200, 300, 400, 500];

        for nxb in 0..=5 {
            for nyb in 0..=5 {
                let drawing_area = create_mocked_drawing_area(1024, 768, |m| {
                    for row in 0..=nyb {
                        for col in 0..=nxb {
                            let get_bp = |full, limit, id| {
                                (if id == 0 {
                                    0
                                } else if id > limit {
                                    full
                                } else {
                                    breaks[id as usize - 1]
                                }) as i32
                            };

                            let expected_u = (get_bp(1024, nxb, col), get_bp(768, nyb, row));
                            let expected_d = (
                                get_bp(1024, nxb, col + 1) - 1,
                                get_bp(768, nyb, row + 1) - 1,
                            );
                            let expected_color =
                                colors[(row * (nxb + 1) + col) as usize % colors.len()];

                            m.check_draw_rect(move |c, _, f, u, d| {
                                assert_eq!(c, expected_color.to_rgba());
                                assert_eq!(f, true);
                                assert_eq!(u, expected_u);
                                assert_eq!(d, expected_d);
                            });
                        }
                    }

                    m.drop_check(move |b| {
                        assert_eq!(b.num_draw_rect_call, ((nxb + 1) * (nyb + 1)) as u32);
                        assert_eq!(b.draw_count, ((nyb + 1) * (nxb + 1)) as u32);
                    });
                });

                let result = drawing_area
                    .split_by_breakpoints(&breaks[0..nxb as usize], &breaks[0..nyb as usize]);
                for i in 0..result.len() {
                    result[i]
                        .fill(colors[i % colors.len()])
                        .expect("Drawing Error");
                }
            }
        }
    }
    #[test]
    fn test_titled() {
        let drawing_area = create_mocked_drawing_area(1024, 768, |m| {
            m.check_draw_text(|c, font, size, _pos, text| {
                assert_eq!(c, BLACK.to_rgba());
                assert_eq!(font, "serif");
                assert_eq!(size, 30.0);
                assert_eq!("This is the title", text);
            });
            m.check_draw_rect(|c, _, f, u, d| {
                assert_eq!(c, WHITE.to_rgba());
                assert_eq!(f, true);
                assert_eq!(u.0, 0);
                assert!(u.1 > 0);
                assert_eq!(d, (1024 - 1, 768 - 1));
            });
            m.drop_check(|b| {
                assert_eq!(b.num_draw_text_call, 1);
                assert_eq!(b.num_draw_rect_call, 1);
                assert_eq!(b.draw_count, 2);
            });
        });

        drawing_area
            .titled("This is the title", ("serif", 30))
            .unwrap()
            .fill(&WHITE)
            .unwrap();
    }

    #[test]
    fn test_margin() {
        let drawing_area = create_mocked_drawing_area(1024, 768, |m| {
            m.check_draw_rect(|c, _, f, u, d| {
                assert_eq!(c, WHITE.to_rgba());
                assert_eq!(f, true);
                assert_eq!(u, (3, 1));
                assert_eq!(d, (1024 - 4 - 1, 768 - 2 - 1));
            });

            m.drop_check(|b| {
                assert_eq!(b.num_draw_rect_call, 1);
                assert_eq!(b.draw_count, 1);
            });
        });

        drawing_area
            .margin(1, 2, 3, 4)
            .fill(&WHITE)
            .expect("Drawing Failure");
    }

    #[test]
    fn test_ranges() {
        let drawing_area = create_mocked_drawing_area(1024, 768, |_m| {})
            .apply_coord_spec(Cartesian2d::<
            crate::coord::types::RangedCoordi32,
            crate::coord::types::RangedCoordu32,
        >::new(-100..100, 0..200, (0..1024, 0..768)));

        let x_range = drawing_area.get_x_range();
        assert_eq!(x_range, -100..100);

        let y_range = drawing_area.get_y_range();
        assert_eq!(y_range, 0..200);
    }

    #[test]
    fn test_relative_size() {
        let drawing_area = create_mocked_drawing_area(1024, 768, |_m| {});

        assert_eq!(102.4, drawing_area.relative_to_width(0.1));
        assert_eq!(384.0, drawing_area.relative_to_height(0.5));

        assert_eq!(1024.0, drawing_area.relative_to_width(1.3));
        assert_eq!(768.0, drawing_area.relative_to_height(1.5));

        assert_eq!(0.0, drawing_area.relative_to_width(-0.2));
        assert_eq!(0.0, drawing_area.relative_to_height(-0.5));
    }

    #[test]
    fn test_relative_split() {
        let drawing_area = create_mocked_drawing_area(1000, 1200, |m| {
            let mut counter = 0;
            m.check_draw_rect(move |c, _, f, u, d| {
                assert_eq!(f, true);

                match counter {
                    0 => {
                        assert_eq!(c, RED.to_rgba());
                        assert_eq!(u, (0, 0));
                        assert_eq!(d, (300 - 1, 600 - 1));
                    }
                    1 => {
                        assert_eq!(c, BLUE.to_rgba());
                        assert_eq!(u, (300, 0));
                        assert_eq!(d, (1000 - 1, 600 - 1));
                    }
                    2 => {
                        assert_eq!(c, GREEN.to_rgba());
                        assert_eq!(u, (0, 600));
                        assert_eq!(d, (300 - 1, 1200 - 1));
                    }
                    3 => {
                        assert_eq!(c, WHITE.to_rgba());
                        assert_eq!(u, (300, 600));
                        assert_eq!(d, (1000 - 1, 1200 - 1));
                    }
                    _ => panic!("Too many draw rect"),
                }

                counter += 1;
            });

            m.drop_check(|b| {
                assert_eq!(b.num_draw_rect_call, 4);
                assert_eq!(b.draw_count, 4);
            });
        });

        let split =
            drawing_area.split_by_breakpoints([(30).percent_width()], [(50).percent_height()]);

        split[0].fill(&RED).unwrap();
        split[1].fill(&BLUE).unwrap();
        split[2].fill(&GREEN).unwrap();
        split[3].fill(&WHITE).unwrap();
    }

    #[test]
    fn test_relative_shrink() {
        let drawing_area = create_mocked_drawing_area(1000, 1200, |m| {
            m.check_draw_rect(move |_, _, _, u, d| {
                assert_eq!((100, 100), u);
                assert_eq!((300 - 1, 700 - 1), d);
            });

            m.drop_check(|b| {
                assert_eq!(b.num_draw_rect_call, 1);
                assert_eq!(b.draw_count, 1);
            });
        })
        .shrink(((10).percent_width(), 100), (200, (50).percent_height()));

        drawing_area.fill(&RED).unwrap();
    }
}