Merging upstream version 1.71.1+dfsg1.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

4 files changed, 1191 insertions, 0 deletions

diff --git a/vendor/plotters/src/drawing/area.rs b/vendor/plotters/src/drawing/area.rs
new file mode 100644
index 000000000..2e5c3fe39
--- /dev/null
+++ b/vendor/plotters/src/drawing/area.rs
@@ -0,0 +1,861 @@
+use crate::coord::cartesian::{Cartesian2d, MeshLine};
+use crate::coord::ranged1d::{KeyPointHint, Ranged};
+use crate::coord::{CoordTranslate, Shift};
+use crate::element::{CoordMapper, 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)]
+pub 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(&self, (row, col): (usize, usize)) -> impl Iterator<Item = Rect> + '_ {
+        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)
+            .flat_map(move |x| repeat(x).zip(0..col))
+            .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),
+            })
+    }
+
+    /// Evenly the rectangle into a grid with arbitrary breaks; return a rect iterator.
+    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_unstable();
+        ys.sort_unstable();
+
+        let xsegs: Vec<_> = xs
+            .iter()
+            .zip(xs.iter().skip(1))
+            .map(|(a, b)| (*a, *b))
+            .collect();
+
+        // Justify: this is actually needed. Because we need to return a iterator that have 
+        // static life time, thus we need to copy the value to a buffer and then turn the buffer
+        // into a iterator.
+        #[allow(clippy::needless_collect)]
+        let ysegs: Vec<_> = ys
+            .iter()
+            .zip(ys.iter().skip(1))
+            .map(|(a, b)| (*a, *b))
+            .collect();
+
+        ysegs
+            .into_iter()
+            .flat_map(move |(y0, y1)| {
+                xsegs
+                    .clone()
+                    .into_iter()
+                    .map(move |(x0, x1)| Self { x0, y0, x1, y1 })
+            })
+    }
+
+    /// Make the coordinate in the range of the rectangle
+    pub 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()
+    }
+
+    /// Get the range of X of the backend coordinate for current drawing area
+    pub fn get_x_axis_pixel_range(&self) -> Range<i32> {
+        self.coord.get_x_axis_pixel_range()
+    }
+
+    /// Get the range of Y of the backend coordinate for current drawing area
+    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)),
+        }
+    }
+
+    /// Strip the applied coordinate specification and returns a drawing area
+    pub fn use_screen_coord(&self) -> DrawingArea<DB, Shift> {
+        DrawingArea {
+            rect: self.rect.clone(),
+            backend: self.backend.clone(),
+            coord: Shift((0, 0)),
+        }
+    }
+
+    /// 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, self.rect.y1),
+                &color.to_backend_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.to_backend_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, B>(&self, element: &'a E) -> Result<(), DrawingAreaError<DB>>
+    where
+        B: CoordMapper,
+        &'a E: PointCollection<'a, CT::From, B>,
+        E: Drawable<DB, B>,
+    {
+        let backend_coords = element.point_iter().into_iter().map(|p| {
+            let b = p.borrow();
+            B::map(&self.coord, b, &self.rect)
+        });
+        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> {
+    /// Returns the coordinates by value
+    pub fn into_coord_spec(self) -> CT {
+        self.coord
+    }
+
+    /// Returns the coordinates by reference
+    pub fn as_coord_spec(&self) -> &CT {
+        &self.coord
+    }
+
+    /// Returns the coordinates by mutable reference
+    pub fn as_coord_spec_mut(&mut self) -> &mut CT {
+        &mut 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, (1024, 768));
+            });
+
+            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,
+                                300 + 300 * col as i32
+                            )
+                        );
+                    });
+                }
+            }
+            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, 768));
+            });
+
+            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, 768));
+            });
+
+            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, 345));
+            });
+
+            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, 768));
+            });
+
+            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), get_bp(768, nyb, row + 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, 768));
+            });
+            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, 768 - 2));
+            });
+
+            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, 600));
+                    }
+                    1 => {
+                        assert_eq!(c, BLUE.to_rgba());
+                        assert_eq!(u, (300, 0));
+                        assert_eq!(d, (1000, 600));
+                    }
+                    2 => {
+                        assert_eq!(c, GREEN.to_rgba());
+                        assert_eq!(u, (0, 600));
+                        assert_eq!(d, (300, 1200));
+                    }
+                    3 => {
+                        assert_eq!(c, WHITE.to_rgba());
+                        assert_eq!(u, (300, 600));
+                        assert_eq!(d, (1000, 1200));
+                    }
+                    _ => 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, 700), 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();
+    }
+}
diff --git a/vendor/plotters/src/drawing/backend_impl/mocked.rs b/vendor/plotters/src/drawing/backend_impl/mocked.rs
new file mode 100644
index 000000000..7569e7322
--- /dev/null
+++ b/vendor/plotters/src/drawing/backend_impl/mocked.rs
@@ -0,0 +1,296 @@
+use crate::coord::Shift;
+use crate::drawing::area::IntoDrawingArea;
+use crate::drawing::DrawingArea;
+use crate::style::RGBAColor;
+use plotters_backend::{
+    BackendColor, BackendCoord, BackendStyle, BackendTextStyle, DrawingBackend, DrawingErrorKind,
+};
+
+use std::collections::VecDeque;
+
+pub fn check_color(left: BackendColor, right: RGBAColor) {
+    assert_eq!(
+        RGBAColor(left.rgb.0, left.rgb.1, left.rgb.2, left.alpha),
+        right
+    );
+}
+
+pub struct MockedBackend {
+    height: u32,
+    width: u32,
+    init_count: u32,
+    pub draw_count: u32,
+    pub num_draw_pixel_call: u32,
+    pub num_draw_line_call: u32,
+    pub num_draw_rect_call: u32,
+    pub num_draw_circle_call: u32,
+    pub num_draw_text_call: u32,
+    pub num_draw_path_call: u32,
+    pub num_fill_polygon_call: u32,
+    check_draw_pixel: VecDeque<Box<dyn FnMut(RGBAColor, BackendCoord)>>,
+    check_draw_line: VecDeque<Box<dyn FnMut(RGBAColor, u32, BackendCoord, BackendCoord)>>,
+    check_draw_rect: VecDeque<Box<dyn FnMut(RGBAColor, u32, bool, BackendCoord, BackendCoord)>>,
+    check_draw_path: VecDeque<Box<dyn FnMut(RGBAColor, u32, Vec<BackendCoord>)>>,
+    check_draw_circle: VecDeque<Box<dyn FnMut(RGBAColor, u32, bool, BackendCoord, u32)>>,
+    check_draw_text: VecDeque<Box<dyn FnMut(RGBAColor, &str, f64, BackendCoord, &str)>>,
+    check_fill_polygon: VecDeque<Box<dyn FnMut(RGBAColor, Vec<BackendCoord>)>>,
+    drop_check: Option<Box<dyn FnMut(&Self)>>,
+}
+
+macro_rules! def_set_checker_func {
+    (drop_check, $($param:ty),*) => {
+        pub fn drop_check<T: FnMut($($param,)*) + 'static>(&mut self, check:T) -> &mut Self {
+            self.drop_check = Some(Box::new(check));
+            self
+        }
+    };
+    ($name:ident, $($param:ty),*) => {
+        pub fn $name<T: FnMut($($param,)*) + 'static>(&mut self, check:T) -> &mut Self {
+            self.$name.push_back(Box::new(check));
+            self
+        }
+    }
+}
+
+impl MockedBackend {
+    pub fn new(width: u32, height: u32) -> Self {
+        MockedBackend {
+            height,
+            width,
+            init_count: 0,
+            draw_count: 0,
+            num_draw_pixel_call: 0,
+            num_draw_line_call: 0,
+            num_draw_rect_call: 0,
+            num_draw_circle_call: 0,
+            num_draw_text_call: 0,
+            num_draw_path_call: 0,
+            num_fill_polygon_call: 0,
+            check_draw_pixel: vec![].into(),
+            check_draw_line: vec![].into(),
+            check_draw_rect: vec![].into(),
+            check_draw_path: vec![].into(),
+            check_draw_circle: vec![].into(),
+            check_draw_text: vec![].into(),
+            check_fill_polygon: vec![].into(),
+            drop_check: None,
+        }
+    }
+
+    def_set_checker_func!(check_draw_pixel, RGBAColor, BackendCoord);
+    def_set_checker_func!(check_draw_line, RGBAColor, u32, BackendCoord, BackendCoord);
+    def_set_checker_func!(
+        check_draw_rect,
+        RGBAColor,
+        u32,
+        bool,
+        BackendCoord,
+        BackendCoord
+    );
+    def_set_checker_func!(check_draw_path, RGBAColor, u32, Vec<BackendCoord>);
+    def_set_checker_func!(check_draw_circle, RGBAColor, u32, bool, BackendCoord, u32);
+    def_set_checker_func!(check_draw_text, RGBAColor, &str, f64, BackendCoord, &str);
+    def_set_checker_func!(drop_check, &Self);
+    def_set_checker_func!(check_fill_polygon, RGBAColor, Vec<BackendCoord>);
+
+    fn check_before_draw(&mut self) {
+        self.draw_count += 1;
+        //assert_eq!(self.init_count, self.draw_count);
+    }
+}
+
+#[derive(Debug)]
+pub struct MockedError;
+
+impl std::fmt::Display for MockedError {
+    fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(fmt, "MockedError")
+    }
+}
+
+impl std::error::Error for MockedError {}
+
+impl DrawingBackend for MockedBackend {
+    type ErrorType = MockedError;
+
+    fn get_size(&self) -> (u32, u32) {
+        (self.width, self.height)
+    }
+
+    fn ensure_prepared(&mut self) -> Result<(), DrawingErrorKind<MockedError>> {
+        self.init_count += 1;
+        Ok(())
+    }
+
+    fn present(&mut self) -> Result<(), DrawingErrorKind<MockedError>> {
+        self.init_count = 0;
+        self.draw_count = 0;
+        Ok(())
+    }
+
+    fn draw_pixel(
+        &mut self,
+        point: BackendCoord,
+        color: BackendColor,
+    ) -> Result<(), DrawingErrorKind<Self::ErrorType>> {
+        self.check_before_draw();
+        self.num_draw_pixel_call += 1;
+        let color = RGBAColor(color.rgb.0, color.rgb.1, color.rgb.2, color.alpha);
+        if let Some(mut checker) = self.check_draw_pixel.pop_front() {
+            checker(color, point);
+
+            if self.check_draw_pixel.is_empty() {
+                self.check_draw_pixel.push_back(checker);
+            }
+        }
+        Ok(())
+    }
+
+    fn draw_line<S: BackendStyle>(
+        &mut self,
+        from: BackendCoord,
+        to: BackendCoord,
+        style: &S,
+    ) -> Result<(), DrawingErrorKind<Self::ErrorType>> {
+        self.check_before_draw();
+        self.num_draw_line_call += 1;
+        let color = style.color();
+        let color = RGBAColor(color.rgb.0, color.rgb.1, color.rgb.2, color.alpha);
+        if let Some(mut checker) = self.check_draw_line.pop_front() {
+            checker(color, style.stroke_width(), from, to);
+
+            if self.check_draw_line.is_empty() {
+                self.check_draw_line.push_back(checker);
+            }
+        }
+        Ok(())
+    }
+
+    fn draw_rect<S: BackendStyle>(
+        &mut self,
+        upper_left: BackendCoord,
+        bottom_right: BackendCoord,
+        style: &S,
+        fill: bool,
+    ) -> Result<(), DrawingErrorKind<Self::ErrorType>> {
+        self.check_before_draw();
+        self.num_draw_rect_call += 1;
+        let color = style.color();
+        let color = RGBAColor(color.rgb.0, color.rgb.1, color.rgb.2, color.alpha);
+        if let Some(mut checker) = self.check_draw_rect.pop_front() {
+            checker(color, style.stroke_width(), fill, upper_left, bottom_right);
+
+            if self.check_draw_rect.is_empty() {
+                self.check_draw_rect.push_back(checker);
+            }
+        }
+        Ok(())
+    }
+
+    fn draw_path<S: BackendStyle, I: IntoIterator<Item = BackendCoord>>(
+        &mut self,
+        path: I,
+        style: &S,
+    ) -> Result<(), DrawingErrorKind<Self::ErrorType>> {
+        self.check_before_draw();
+        self.num_draw_path_call += 1;
+        let color = style.color();
+        let color = RGBAColor(color.rgb.0, color.rgb.1, color.rgb.2, color.alpha);
+        if let Some(mut checker) = self.check_draw_path.pop_front() {
+            checker(color, style.stroke_width(), path.into_iter().collect());
+
+            if self.check_draw_path.is_empty() {
+                self.check_draw_path.push_back(checker);
+            }
+        }
+        Ok(())
+    }
+
+    fn draw_circle<S: BackendStyle>(
+        &mut self,
+        center: BackendCoord,
+        radius: u32,
+        style: &S,
+        fill: bool,
+    ) -> Result<(), DrawingErrorKind<Self::ErrorType>> {
+        self.check_before_draw();
+        self.num_draw_circle_call += 1;
+        let color = style.color();
+        let color = RGBAColor(color.rgb.0, color.rgb.1, color.rgb.2, color.alpha);
+        if let Some(mut checker) = self.check_draw_circle.pop_front() {
+            checker(color, style.stroke_width(), fill, center, radius);
+
+            if self.check_draw_circle.is_empty() {
+                self.check_draw_circle.push_back(checker);
+            }
+        }
+        Ok(())
+    }
+
+    fn fill_polygon<S: BackendStyle, I: IntoIterator<Item = BackendCoord>>(
+        &mut self,
+        path: I,
+        style: &S,
+    ) -> Result<(), DrawingErrorKind<Self::ErrorType>> {
+        self.check_before_draw();
+        self.num_fill_polygon_call += 1;
+        let color = style.color();
+        let color = RGBAColor(color.rgb.0, color.rgb.1, color.rgb.2, color.alpha);
+        if let Some(mut checker) = self.check_fill_polygon.pop_front() {
+            checker(color, path.into_iter().collect());
+
+            if self.check_fill_polygon.is_empty() {
+                self.check_fill_polygon.push_back(checker);
+            }
+        }
+        Ok(())
+    }
+
+    fn draw_text<S: BackendTextStyle>(
+        &mut self,
+        text: &str,
+        style: &S,
+        pos: BackendCoord,
+    ) -> Result<(), DrawingErrorKind<Self::ErrorType>> {
+        let color = style.color();
+        let color = RGBAColor(color.rgb.0, color.rgb.1, color.rgb.2, color.alpha);
+        self.check_before_draw();
+        self.num_draw_text_call += 1;
+        if let Some(mut checker) = self.check_draw_text.pop_front() {
+            checker(color, style.family().as_str(), style.size(), pos, text);
+
+            if self.check_draw_text.is_empty() {
+                self.check_draw_text.push_back(checker);
+            }
+        }
+        Ok(())
+    }
+}
+
+impl Drop for MockedBackend {
+    fn drop(&mut self) {
+        // `self.drop_check` is typically a testing function; it can panic.
+        // The current `drop` call may be a part of stack unwinding caused
+        // by another panic. If so, we should never call it.
+        if std::thread::panicking() {
+            return;
+        }
+
+        let mut temp = None;
+        std::mem::swap(&mut temp, &mut self.drop_check);
+
+        if let Some(mut checker) = temp {
+            checker(self);
+        }
+    }
+}
+
+pub fn create_mocked_drawing_area<F: FnOnce(&mut MockedBackend)>(
+    width: u32,
+    height: u32,
+    setup: F,
+) -> DrawingArea<MockedBackend, Shift> {
+    let mut backend = MockedBackend::new(width, height);
+    setup(&mut backend);
+    backend.into_drawing_area()
+}
diff --git a/vendor/plotters/src/drawing/backend_impl/mod.rs b/vendor/plotters/src/drawing/backend_impl/mod.rs
new file mode 100644
index 000000000..59daa8d6c
--- /dev/null
+++ b/vendor/plotters/src/drawing/backend_impl/mod.rs
@@ -0,0 +1,16 @@
+#[cfg(test)]
+mod mocked;
+#[cfg(test)]
+pub use mocked::{check_color, create_mocked_drawing_area, MockedBackend};
+
+/// This is the dummy backend placeholder for the backend that never fails
+#[derive(Debug)]
+pub struct DummyBackendError;
+
+impl std::fmt::Display for DummyBackendError {
+    fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(fmt, "{:?}", self)
+    }
+}
+
+impl std::error::Error for DummyBackendError {}
diff --git a/vendor/plotters/src/drawing/mod.rs b/vendor/plotters/src/drawing/mod.rs
new file mode 100644
index 000000000..9e32d9132
--- /dev/null
+++ b/vendor/plotters/src/drawing/mod.rs
@@ -0,0 +1,18 @@
+/*!
+The drawing utils for Plotters. In Plotters, we have two set of drawing APIs: low-level API and
+high-level API.
+
+The low-level drawing abstraction, the module defines the `DrawingBackend` trait from the `plotters-backend` create.
+It exposes a set of functions which allows basic shape, such as pixels, lines, rectangles, circles, to be drawn on the screen.
+The low-level API uses the pixel based coordinate.
+
+The high-level API is built on the top of high-level API. The `DrawingArea` type exposes the high-level drawing API to the remianing part
+of Plotters. The basic drawing blocks are composable elements, which can be defined in logic coordinate. To learn more details
+about the [coordinate abstraction](../coord/index.html) and [element system](../element/index.html).
+*/
+mod area;
+mod backend_impl;
+
+pub use area::{DrawingArea, DrawingAreaErrorKind, IntoDrawingArea, Rect};
+
+pub use backend_impl::*;