[librsvg/wip/euclid] Move method on transform

[Paolo Borelli <pborelli src gnome org>]

commit ef685ba2634914d27e1368fa0529d2430dba6f80
Author: Paolo Borelli <pborelli gnome org>
Date:   Wed Nov 27 15:00:16 2019 +0100

    Move method on transform
    
    This is the same API used in euclid

 rsvg_internals/src/bbox.rs      |  8 +++---
 rsvg_internals/src/rect.rs      | 62 ---------------------------------------
 rsvg_internals/src/transform.rs | 64 +++++++++++++++++++++++++++++++++++++++++
 3 files changed, 68 insertions(+), 66 deletions(-)
---
diff --git a/rsvg_internals/src/bbox.rs b/rsvg_internals/src/bbox.rs
index f82802a7..d3f2c9fa 100644
--- a/rsvg_internals/src/bbox.rs
+++ b/rsvg_internals/src/bbox.rs
@@ -74,11 +74,11 @@ fn combine_rects(
 ) -> Option<cairo::Rectangle> {
     match (r1, r2, clip) {
         (r1, None, _) => r1,
-        (None, Some(r2), _) => Some(r2.transform(&affine)),
-        (Some(r1), Some(r2), true) => r2
-            .transform(&affine)
+        (None, Some(r2), _) => Some(affine.transform_rect(&r2)),
+        (Some(r1), Some(r2), true) => affine
+            .transform_rect(&r2)
             .intersection(&r1)
             .or_else(|| Some(cairo::Rectangle::new(0.0, 0.0, 0.0, 0.0))),
-        (Some(r1), Some(r2), false) => Some(r2.transform(&affine).union(&r1)),
+        (Some(r1), Some(r2), false) => Some(affine.transform_rect(&r2).union(&r1)),
     }
 }
diff --git a/rsvg_internals/src/rect.rs b/rsvg_internals/src/rect.rs
index 8fa400c9..f4091063 100644
--- a/rsvg_internals/src/rect.rs
+++ b/rsvg_internals/src/rect.rs
@@ -9,7 +9,6 @@ pub trait RectangleExt {
     fn is_empty(&self) -> bool;
     fn intersection(&self, rect: &cairo::Rectangle) -> Option<cairo::Rectangle>;
     fn union(&self, rect: &cairo::Rectangle) -> cairo::Rectangle;
-    fn transform(&self, affine: &cairo::Matrix) -> cairo::Rectangle;
     fn translate(&self, by: (f64, f64)) -> cairo::Rectangle;
     fn outer(&self) -> cairo::Rectangle;
 }
@@ -73,46 +72,6 @@ impl RectangleExt for cairo::Rectangle {
         }
     }
 
-    fn transform(&self, affine: &cairo::Matrix) -> cairo::Rectangle {
-        let points = vec![
-            affine.transform_point(self.x, self.y),
-            affine.transform_point(self.x + self.width, self.y),
-            affine.transform_point(self.x, self.y + self.height),
-            affine.transform_point(self.x + self.width, self.y + self.height),
-        ];
-
-        let (mut xmin, mut ymin, mut xmax, mut ymax) = {
-            let (x, y) = points[0];
-
-            (x, y, x, y)
-        };
-
-        for &(x, y) in points.iter().take(4).skip(1) {
-            if x < xmin {
-                xmin = x;
-            }
-
-            if x > xmax {
-                xmax = x;
-            }
-
-            if y < ymin {
-                ymin = y;
-            }
-
-            if y > ymax {
-                ymax = y;
-            }
-        }
-
-        cairo::Rectangle {
-            x: xmin,
-            y: ymin,
-            width: xmax - xmin,
-            height: ymax - ymin,
-        }
-    }
-
     fn translate(&self, by: (f64, f64)) -> cairo::Rectangle {
         cairo::Rectangle {
             x: self.x + by.0,
@@ -332,27 +291,6 @@ mod tests {
         assert_approx_eq_cairo!(4.34_f64, r.height);
     }
 
-    #[test]
-    fn transform_rect() {
-        let r = cairo::Rectangle {
-            x: 0.42,
-            y: 0.42,
-            width: 3.14,
-            height: 3.14,
-        };
-
-        let m = cairo::Matrix::identity();
-        let tr = r.transform(&m);
-        assert_eq!(tr, r);
-
-        let m = cairo::Matrix::new(2.0, 0.0, 0.0, 2.0, 1.5, 1.5);
-        let tr = r.transform(&m);
-        assert_approx_eq_cairo!(2.34_f64, tr.x);
-        assert_approx_eq_cairo!(2.34_f64, tr.y);
-        assert_approx_eq_cairo!(6.28_f64, tr.width);
-        assert_approx_eq_cairo!(6.28_f64, tr.height);
-    }
-
     #[test]
     fn outer_rect() {
         let r = cairo::Rectangle {
diff --git a/rsvg_internals/src/transform.rs b/rsvg_internals/src/transform.rs
index e830a6b3..f3401a5a 100644
--- a/rsvg_internals/src/transform.rs
+++ b/rsvg_internals/src/transform.rs
@@ -18,6 +18,8 @@ where Self: std::marker::Sized
     fn inverse(&self) -> Option<Self>;
 
     fn pre_transform(&self, mat: &Self) -> Self;
+
+    fn transform_rect(&self, rect: &cairo::Rectangle) -> cairo::Rectangle;
 }
 
 impl TransformExt for Transform {
@@ -32,6 +34,46 @@ impl TransformExt for Transform {
     fn pre_transform(&self, mat: &Self) -> Self {
         cairo::Matrix::multiply(mat, self)
     }
+
+    fn transform_rect(&self, rect: &cairo::Rectangle) -> cairo::Rectangle {
+        let points = vec![
+            self.transform_point(rect.x, rect.y),
+            self.transform_point(rect.x + rect.width, rect.y),
+            self.transform_point(rect.x, rect.y + rect.height),
+            self.transform_point(rect.x + rect.width, rect.y + rect.height),
+        ];
+
+        let (mut xmin, mut ymin, mut xmax, mut ymax) = {
+            let (x, y) = points[0];
+
+            (x, y, x, y)
+        };
+
+        for &(x, y) in points.iter().take(4).skip(1) {
+            if x < xmin {
+                xmin = x;
+            }
+
+            if x > xmax {
+                xmax = x;
+            }
+
+            if y < ymin {
+                ymin = y;
+            }
+
+            if y > ymax {
+                ymax = y;
+            }
+        }
+
+        cairo::Rectangle {
+            x: xmin,
+            y: ymin,
+            width: xmax - xmin,
+            height: ymax - ymin,
+        }
+    }
 }
 
 impl Parse for Transform {
@@ -272,9 +314,31 @@ fn make_rotation_matrix(angle_degrees: f64, tx: f64, ty: f64) -> Transform {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::float_eq_cairo::ApproxEqCairo;
     use float_cmp::ApproxEq;
     use std::f64;
 
+    #[test]
+    fn transform_rect() {
+        let r = cairo::Rectangle {
+            x: 0.42,
+            y: 0.42,
+            width: 3.14,
+            height: 3.14,
+        };
+
+        let t = cairo::Matrix::identity();
+        let tr = t.transform_rect(&r);
+        assert_eq!(tr, r);
+
+        let t = cairo::Matrix::new(2.0, 0.0, 0.0, 2.0, 1.5, 1.5);
+        let tr = t.transform_rect(&r);
+        assert_approx_eq_cairo!(2.34_f64, tr.x);
+        assert_approx_eq_cairo!(2.34_f64, tr.y);
+        assert_approx_eq_cairo!(6.28_f64, tr.width);
+        assert_approx_eq_cairo!(6.28_f64, tr.height);
+    }
+
     fn parse_transform(s: &str) -> Result<Transform, ValueErrorKind> {
         Transform::parse_str(s)
     }