Remove canvas::tools::calcRectToRectTransform

2 files changed, 1 insertions, 83 deletions

diff --git a/canvas/inc/canvas/canvastools.hxx b/canvas/inc/canvas/canvastools.hxx
index a1bee2dc5bb9..1605b6628d68 100644
--- a/canvas/inc/canvas/canvastools.hxx
+++ b/canvas/inc/canvas/canvastools.hxx
@@ -225,60 +225,17 @@ namespace canvas
             @param i_Transformation
             Transformation to apply to the input rectangle
 
-            @see calcRectToRectTransform()
-
             @return a reference to the resulting rectangle
          */
         CANVASTOOLS_DLLPUBLIC ::basegfx::B2DRange& calcTransformedRectBounds( ::basegfx::B2DRange&          o_Rect,
                                                         const ::basegfx::B2DRange&      i_Rect,
                                                         const ::basegfx::B2DHomMatrix&  i_Transformation );
 
-        /** Calc a transform that maps one rectangle on top of
-            another.
-
-            The method is a kissing cousin to
-            calcTransformedRectBounds(). It can be used to modify the
-            given transformation matrix, such that it transforms the
-            given input rectangle to the given output rectangle,
-            changing only translation and scale (if necessary). Thus,
-            if you've calculated an output rectangle via
-            calcTransformedRectBounds(), you can move and scale that
-            rectangle as you like, and have this method calculate the
-            required total transformation for it.
-
-            @param o_transform
-            Output parameter, to receive the resulting transformation
-            matrix.
-
-            @param i_destRect
-            Input parameter, specifies the requested destination
-            rectangle. The resulting transformation will exactly map
-            the source rectangle to the destination rectangle.
-
-            @param i_srcRect
-            Input parameter, specifies the original source
-            rectangle. The resulting transformation will exactly map
-            the source rectangle to the destination rectangle.
-
-            @param i_transformation
-            The original transformation matrix. This is changed with
-            translations and scalings (if necessary), to exactly map
-            the source rectangle to the destination rectangle.
-
-            @return a reference to the resulting transformation matrix
-
-            @see calcTransformedRectBounds()
-        */
-        CANVASTOOLS_DLLPUBLIC ::basegfx::B2DHomMatrix& calcRectToRectTransform( ::basegfx::B2DHomMatrix&            o_transform,
-                                                          const ::basegfx::B2DRange&        i_destRect,
-                                                          const ::basegfx::B2DRange&        i_srcRect,
-                                                          const ::basegfx::B2DHomMatrix&    i_transformation );
-
         /** Calc a transform that maps the upper, left corner of a
              rectangle to the origin.
 
             The method is a specialized version of
-            calcRectToRectTransform(), mapping the input rectangle's
+            calcRectToRectTransform() (Removed now), mapping the input rectangle's
             the upper, left corner to the origin, and leaving the size
             untouched.
 
diff --git a/canvas/source/tools/canvastools.cxx b/canvas/source/tools/canvastools.cxx
index a089f5430b6e..4a55ad55a60b 100644
--- a/canvas/source/tools/canvastools.cxx
+++ b/canvas/source/tools/canvastools.cxx
@@ -688,45 +688,6 @@ namespace canvas
             return outRect;
         }
 
-        ::basegfx::B2DHomMatrix& calcRectToRectTransform( ::basegfx::B2DHomMatrix&          o_transform,
-                                                          const ::basegfx::B2DRange&        destRect,
-                                                          const ::basegfx::B2DRange&        srcRect,
-                                                          const ::basegfx::B2DHomMatrix&    transformation )
-        {
-            if( srcRect.isEmpty() ||
-                destRect.isEmpty() )
-            {
-                return o_transform=transformation;
-            }
-
-            // transform inputRect by transformation
-            ::basegfx::B2DRectangle aTransformedRect;
-            calcTransformedRectBounds( aTransformedRect,
-                                       srcRect,
-                                       transformation );
-
-            // now move resulting left,top point of bounds to (0,0)
-            basegfx::B2DHomMatrix aCorrectedTransform(basegfx::tools::createTranslateB2DHomMatrix(
-                -aTransformedRect.getMinX(), -aTransformedRect.getMinY()));
-
-            // scale to match outRect
-            const double xDenom( aTransformedRect.getWidth() );
-            const double yDenom( aTransformedRect.getHeight() );
-            if( xDenom != 0.0 && yDenom != 0.0 )
-                aCorrectedTransform.scale( destRect.getWidth() / xDenom,
-                                           destRect.getHeight() / yDenom );
-            // TODO(E2): error handling
-
-            // translate to final position
-            aCorrectedTransform.translate( destRect.getMinX(),
-                                           destRect.getMinY() );
-
-            ::basegfx::B2DHomMatrix transform( transformation );
-            o_transform = aCorrectedTransform * transform;
-
-            return o_transform;
-        }
-
         bool isInside( const ::basegfx::B2DRange&       rContainedRect,
                        const ::basegfx::B2DRange&       rTransformRect,
                        const ::basegfx::B2DHomMatrix&   rTransformation )