loplugin:reftotemp in canvas

Change-Id: I0a038cf32e05dab59b1cedcf06ecd38b48d76feb
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/176257
Tested-by: Jenkins
Reviewed-by: Noel Grandin <noel.grandin@collabora.co.uk>

20 files changed, 151 insertions, 151 deletions

diff --git a/canvas/source/cairo/cairo_canvas.cxx b/canvas/source/cairo/cairo_canvas.cxx
index b170c4f7e4d8..4078e95deb63 100644
--- a/canvas/source/cairo/cairo_canvas.cxx
+++ b/canvas/source/cairo/cairo_canvas.cxx
@@ -151,9 +151,9 @@ namespace cairocanvas
 
         BitmapSystemData aData;
         if( rBitmap.GetSystemData( aData ) ) {
-            const Size& rSize = rBitmap.GetSizePixel();
+            const Size aSize = rBitmap.GetSizePixel();
 
-            pSurface = maDeviceHelper.createSurface( aData, rSize );
+            pSurface = maDeviceHelper.createSurface( aData, aSize );
         }
 
         return pSurface;
diff --git a/canvas/source/cairo/cairo_canvashelper.cxx b/canvas/source/cairo/cairo_canvashelper.cxx
index 99b56d719ae1..75c69a5847ab 100644
--- a/canvas/source/cairo/cairo_canvashelper.cxx
+++ b/canvas/source/cairo/cairo_canvashelper.cxx
@@ -811,7 +811,7 @@ constexpr OUStringLiteral PARAMETRICPOLYPOLYGON_IMPLEMENTATION_NAME = u"Canvas::
                         bool bNoLineJoin,
                         const uno::Sequence< rendering::Texture >* pTextures ) const
     {
-        const ::basegfx::B2DPolyPolygon& rPolyPoly(
+        const ::basegfx::B2DPolyPolygon aPolyPoly(
             ::basegfx::unotools::b2DPolyPolygonFromXPolyPolygon2D(xPolyPolygon) );
 
         cairo_t* pCairo = mpCairo.get();
@@ -819,9 +819,9 @@ constexpr OUStringLiteral PARAMETRICPOLYPOLYGON_IMPLEMENTATION_NAME = u"Canvas::
         if(bNoLineJoin && aOperation == Stroke)
         {
             // emulate rendering::PathJoinType::NONE by painting single edges
-            for(sal_uInt32 a(0); a < rPolyPoly.count(); a++)
+            for(sal_uInt32 a(0); a < aPolyPoly.count(); a++)
             {
-                const basegfx::B2DPolygon& aCandidate(rPolyPoly.getB2DPolygon(a));
+                const basegfx::B2DPolygon& aCandidate(aPolyPoly.getB2DPolygon(a));
                 const sal_uInt32 nPointCount(aCandidate.count());
 
                 if(nPointCount)
@@ -852,7 +852,7 @@ constexpr OUStringLiteral PARAMETRICPOLYPOLYGON_IMPLEMENTATION_NAME = u"Canvas::
         }
         else
         {
-            doPolyPolygonImplementation( rPolyPoly, aOperation,
+            doPolyPolygonImplementation( aPolyPoly, aOperation,
                                          pCairo, pTextures,
                                          mpSurfaceProvider,
                                          xPolyPolygon->getFillRule() );
diff --git a/canvas/source/cairo/cairo_spritecanvas.cxx b/canvas/source/cairo/cairo_spritecanvas.cxx
index fcbaa4186138..bb97ae4bfb35 100644
--- a/canvas/source/cairo/cairo_spritecanvas.cxx
+++ b/canvas/source/cairo/cairo_spritecanvas.cxx
@@ -165,9 +165,9 @@ namespace cairocanvas
     {
         BitmapSystemData aData;
         if( rBitmap.GetSystemData( aData ) ) {
-            const Size& rSize = rBitmap.GetSizePixel();
+            const Size aSize = rBitmap.GetSizePixel();
 
-            return maDeviceHelper.createSurface( aData, rSize );
+            return maDeviceHelper.createSurface( aData, aSize );
         }
 
         return SurfaceSharedPtr();
diff --git a/canvas/source/cairo/cairo_spritecanvashelper.cxx b/canvas/source/cairo/cairo_spritecanvashelper.cxx
index 3fcfd734ab2f..45a594545663 100644
--- a/canvas/source/cairo/cairo_spritecanvashelper.cxx
+++ b/canvas/source/cairo/cairo_spritecanvashelper.cxx
@@ -260,9 +260,9 @@ namespace cairocanvas
         // the sprite.
         ::basegfx::B2IRange aSourceRect(
             ::canvas::tools::spritePixelAreaFromB2DRange( rMoveStart ) );
-        const ::basegfx::B2IRange& rDestRect(
+        const ::basegfx::B2IRange aDestRect(
             ::canvas::tools::spritePixelAreaFromB2DRange( rMoveEnd ) );
-        ::basegfx::B2IPoint aDestPos( rDestRect.getMinimum() );
+        ::basegfx::B2IPoint aDestPos( aDestRect.getMinimum() );
 
         std::vector< ::basegfx::B2IRange > aUnscrollableAreas;
 
@@ -296,10 +296,10 @@ namespace cairocanvas
             const ::basegfx::B2IVector aSourceUpperLeftPos( aSourceRect.getMinimum() );
 
             // clip dest area (which must be inside rDestBounds)
-            ::basegfx::B2IRange aDestRect( rDestRect );
-            aDestRect.intersect( aOutputBounds );
+            ::basegfx::B2IRange aClipDestRect( aDestRect );
+            aClipDestRect.intersect( aOutputBounds );
 
-            ::basegfx::B2ISize aScrollSize( aDestRect.getWidth(), aDestRect.getHeight() );
+            ::basegfx::B2ISize aScrollSize( aClipDestRect.getWidth(), aClipDestRect.getHeight() );
             SurfaceSharedPtr pScrollSurface( getTemporarySurface() );
             CairoSharedPtr pScrollCairo( pScrollSurface->getCairo() );
 
@@ -354,7 +354,7 @@ namespace cairocanvas
         std::vector< ::basegfx::B2DRange > aUncoveredAreas;
         ::basegfx::computeSetDifference( aUncoveredAreas,
                                          rUpdateArea.maTotalBounds,
-                                         ::basegfx::B2DRange( rDestRect ) );
+                                         ::basegfx::B2DRange( aDestRect ) );
         for( const auto& rArea : aUncoveredAreas )
             repaintBackground( pCompositingCairo,
                                mpOwningSpriteCanvas->getBufferSurface(), rArea );
diff --git a/canvas/source/cairo/cairo_textlayout.cxx b/canvas/source/cairo/cairo_textlayout.cxx
index 8dd2587dc11e..e6b81999ef8f 100644
--- a/canvas/source/cairo/cairo_textlayout.cxx
+++ b/canvas/source/cairo/cairo_textlayout.cxx
@@ -164,7 +164,7 @@ namespace cairocanvas
 
         // need metrics for Y offset, the XCanvas always renders
         // relative to baseline
-        const ::FontMetric& aMetric( pVDev->GetFontMetric() );
+        const ::FontMetric aMetric( pVDev->GetFontMetric() );
 
         setupLayoutMode( *pVDev, mnTextDirection );
 
diff --git a/canvas/source/opengl/ogl_canvashelper.cxx b/canvas/source/opengl/ogl_canvashelper.cxx
index a4ab0738e65d..114f98be1903 100644
--- a/canvas/source/opengl/ogl_canvashelper.cxx
+++ b/canvas/source/opengl/ogl_canvashelper.cxx
@@ -559,12 +559,12 @@ namespace oglcanvas
                 {
                     // copy state from Gradient polypoly locally
                     // (given object might change!)
-                    const ::canvas::ParametricPolyPolygon::Values& rValues(
+                    const ::canvas::ParametricPolyPolygon::Values aValues(
                         pGradient->getValues() );
 
                     rAct.maFunction = std::bind(&lcl_fillGradientPolyPolygon,
                                                     std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4,
-                                                    rValues,
+                                                    aValues,
                                                     textures[0],
                                                     std::placeholders::_6);
                 }
@@ -681,22 +681,22 @@ namespace oglcanvas
 
             auto pLayoutFont = xLayoutetText->getFont();
             CanvasFont* pFont=dynamic_cast<CanvasFont*>(pLayoutFont.get());
-            const rendering::StringContext& rTxt=xLayoutetText->getText();
-            if( pFont && rTxt.Length )
+            const rendering::StringContext aTxt=xLayoutetText->getText();
+            if( pFont && aTxt.Length )
             {
                 // create the font
-                const rendering::FontRequest& rFontRequest = pFont->getFontRequest();
+                const rendering::FontRequest  aFontRequest = pFont->getFontRequest();
                 const geometry::Matrix2D&     rFontMatrix = pFont->getFontMatrix();
                 vcl::Font aFont(
-                    rFontRequest.FontDescription.FamilyName,
-                    rFontRequest.FontDescription.StyleName,
-                    Size( 0, ::basegfx::fround<tools::Long>(rFontRequest.CellSize)));
+                    aFontRequest.FontDescription.FamilyName,
+                    aFontRequest.FontDescription.StyleName,
+                    Size( 0, ::basegfx::fround<tools::Long>(aFontRequest.CellSize)));
 
                 aFont.SetAlignment( ALIGN_BASELINE );
-                aFont.SetCharSet( (rFontRequest.FontDescription.IsSymbolFont==util::TriState_YES) ? RTL_TEXTENCODING_SYMBOL : RTL_TEXTENCODING_UNICODE );
-                aFont.SetVertical( rFontRequest.FontDescription.IsVertical==util::TriState_YES );
-                aFont.SetWeight( static_cast<FontWeight>(rFontRequest.FontDescription.FontDescription.Weight) );
-                aFont.SetItalic( (rFontRequest.FontDescription.FontDescription.Letterform<=8) ? ITALIC_NONE : ITALIC_NORMAL );
+                aFont.SetCharSet( (aFontRequest.FontDescription.IsSymbolFont==util::TriState_YES) ? RTL_TEXTENCODING_SYMBOL : RTL_TEXTENCODING_UNICODE );
+                aFont.SetVertical( aFontRequest.FontDescription.IsVertical==util::TriState_YES );
+                aFont.SetWeight( static_cast<FontWeight>(aFontRequest.FontDescription.FontDescription.Weight) );
+                aFont.SetItalic( (aFontRequest.FontDescription.FontDescription.Letterform<=8) ? ITALIC_NONE : ITALIC_NORMAL );
 
                 if (pFont->getEmphasisMark())
                     aFont.SetEmphasisMark(FontEmphasisMark(pFont->getEmphasisMark()));
@@ -735,10 +735,10 @@ namespace oglcanvas
 
                     // get the glyphs
                     pVDev->GetTextOutlines(rAct.maPolyPolys,
-                                          rTxt.Text,
+                                          aTxt.Text,
                                           0,
-                                          rTxt.StartPosition,
-                                          rTxt.Length,
+                                          aTxt.StartPosition,
+                                          aTxt.Length,
                                           0,
                                           aDXArray,
                                           aKashidaArray);
@@ -747,10 +747,10 @@ namespace oglcanvas
                 {
                     // get the glyphs
                     pVDev->GetTextOutlines(rAct.maPolyPolys,
-                                          rTxt.Text,
+                                          aTxt.Text,
                                           0,
-                                          rTxt.StartPosition,
-                                          rTxt.Length );
+                                          aTxt.StartPosition,
+                                          aTxt.Length );
                 }
 
                 // own copy, for thread safety
diff --git a/canvas/source/opengl/ogl_canvastools.cxx b/canvas/source/opengl/ogl_canvastools.cxx
index 97e7377c0a60..57aa686072b0 100644
--- a/canvas/source/opengl/ogl_canvastools.cxx
+++ b/canvas/source/opengl/ogl_canvastools.cxx
@@ -29,9 +29,9 @@ namespace oglcanvas
         ::basegfx::B2DPolyPolygon aPolyPoly(rPolyPoly);
         if( aPolyPoly.areControlPointsUsed() )
             aPolyPoly = rPolyPoly.getDefaultAdaptiveSubdivision();
-        const ::basegfx::B2DRange& rBounds(aPolyPoly.getB2DRange());
-        const double nWidth=rBounds.getWidth();
-        const double nHeight=rBounds.getHeight();
+        const ::basegfx::B2DRange aBounds(aPolyPoly.getB2DRange());
+        const double nWidth=aBounds.getWidth();
+        const double nHeight=aBounds.getHeight();
         const ::basegfx::triangulator::B2DTriangleVector rTriangulatedPolygon(
             ::basegfx::triangulator::triangulate(aPolyPoly));
 
diff --git a/canvas/source/opengl/ogl_spritedevicehelper.cxx b/canvas/source/opengl/ogl_spritedevicehelper.cxx
index 7c0088e5b992..571764986fca 100644
--- a/canvas/source/opengl/ogl_spritedevicehelper.cxx
+++ b/canvas/source/opengl/ogl_spritedevicehelper.cxx
@@ -270,8 +270,8 @@ namespace oglcanvas
         mxContext->makeCurrent();
 
         SystemChildWindow* pChildWindow = mxContext->getChildWindow();
-        const ::Size& rOutputSize = pChildWindow->GetSizePixel();
-        initTransformation(rOutputSize);
+        const ::Size aOutputSize = pChildWindow->GetSizePixel();
+        initTransformation(aOutputSize);
 
         // render the actual spritecanvas content
         mpSpriteCanvas->renderRecordedActions();
@@ -291,8 +291,8 @@ namespace oglcanvas
         glMatrixMode(GL_MODELVIEW);
         glLoadIdentity();
         glTranslated(-1.0, 1.0, 0.0);
-        glScaled( 2.0  / rOutputSize.Width(),
-                  -2.0 / rOutputSize.Height(),
+        glScaled( 2.0  / aOutputSize.Width(),
+                  -2.0 / aOutputSize.Height(),
                   1.0 );
 
         const double denominator( maLastUpdate.getElapsedTime() );
diff --git a/canvas/source/opengl/ogl_textlayout.cxx b/canvas/source/opengl/ogl_textlayout.cxx
index 5baf7eb794cb..1bcf1a9fbaf7 100644
--- a/canvas/source/opengl/ogl_textlayout.cxx
+++ b/canvas/source/opengl/ogl_textlayout.cxx
@@ -102,9 +102,9 @@ namespace oglcanvas
 
         // fake text bounds by either taking the advancement values,
         // or assuming square glyph boxes (width similar to height)
-        const rendering::FontRequest& rFontRequest( mpFont->getFontRequest() );
-        const double nFontSize( std::max( rFontRequest.CellSize,
-                                            rFontRequest.ReferenceAdvancement ) );
+        const rendering::FontRequest aFontRequest( mpFont->getFontRequest() );
+        const double nFontSize( std::max( aFontRequest.CellSize,
+                                            aFontRequest.ReferenceAdvancement ) );
         if( maLogicalAdvancements.hasElements() )
         {
             return geometry::RealRectangle2D( 0, -nFontSize/2,
diff --git a/canvas/source/tools/canvascustomspritehelper.cxx b/canvas/source/tools/canvascustomspritehelper.cxx
index 975d62325d49..2517e05be947 100644
--- a/canvas/source/tools/canvascustomspritehelper.cxx
+++ b/canvas/source/tools/canvascustomspritehelper.cxx
@@ -61,7 +61,7 @@ namespace canvas
 
             // clip which is about to be set, expressed as a
             // b2drectangle
-            const ::basegfx::B2DRectangle& rClipBounds(
+            const ::basegfx::B2DRectangle aClipBounds(
                 ::basegfx::utils::getRange( aClipPath ) );
 
             const ::basegfx::B2DRectangle aBounds( 0.0, 0.0,
@@ -77,7 +77,7 @@ namespace canvas
 
             // aClipBoundsA = new clip bound rect, intersected
             // with sprite area
-            ::basegfx::B2DRectangle aClipBoundsA(rClipBounds);
+            ::basegfx::B2DRectangle aClipBoundsA(aClipBounds);
             aClipBoundsA.intersect( aSpriteRectPixel );
 
             if( nNumClipPolygons != 1 )
@@ -191,7 +191,7 @@ namespace canvas
         if( xBitmap->hasAlpha() )
             return;
 
-        const geometry::IntegerSize2D& rInputSize(xBitmap->getSize());
+        const geometry::IntegerSize2D aInputSize(xBitmap->getSize());
         basegfx::B2DSize rOurSize(rSprite->getSizePixel().getX(), rSprite->getSizePixel().getY());
 
         ::basegfx::B2DHomMatrix aTransform;
@@ -200,8 +200,8 @@ namespace canvas
                                          rOurSize.getWidth(),
                                          rOurSize.getHeight() ),
                 ::basegfx::B2DRectangle( 0.0,0.0,
-                                         rInputSize.Width,
-                                         rInputSize.Height ),
+                                         aInputSize.Width,
+                                         aInputSize.Height ),
                 ::canvas::tools::mergeViewAndRenderTransform(aTransform,
                                                              viewState,
                                                              renderState) ) )
@@ -252,7 +252,7 @@ namespace canvas
         if( aPoint == maPosition )
             return;
 
-        const ::basegfx::B2DRectangle&  rBounds
+        const ::basegfx::B2DRectangle aBounds
             = getUpdateArea( ::basegfx::B2DRectangle( 0.0, 0.0,
                                                       maSize.getX(),
                                                       maSize.getY() ) );
@@ -260,9 +260,9 @@ namespace canvas
         if( mbActive )
         {
             mpSpriteCanvas->moveSprite( rSprite,
-                                        rBounds.getMinimum(),
-                                        rBounds.getMinimum() - maPosition + aPoint,
-                                        rBounds.getRange() );
+                                        aBounds.getMinimum(),
+                                        aBounds.getMinimum() - maPosition + aPoint,
+                                        aBounds.getRange() );
         }
 
         maPosition = aPoint;
@@ -279,7 +279,7 @@ namespace canvas
             return;
 
         // retrieve bounds before and after transformation change.
-        const ::basegfx::B2DRectangle& rPrevBounds( getUpdateArea() );
+        const ::basegfx::B2DRectangle aPrevBounds( getUpdateArea() );
 
         maTransform = aMatrix;
 
@@ -288,7 +288,7 @@ namespace canvas
         {
             mpSpriteCanvas->updateSprite( rSprite,
                                           maPosition,
-                                          rPrevBounds );
+                                          aPrevBounds );
             mpSpriteCanvas->updateSprite( rSprite,
                                           maPosition,
                                           getUpdateArea() );
@@ -303,7 +303,7 @@ namespace canvas
         // NULL xClip explicitly allowed here (to clear clipping)
 
         // retrieve bounds before and after clip change.
-        const ::basegfx::B2DRectangle& rPrevBounds( getUpdateArea() );
+        const ::basegfx::B2DRectangle aPrevBounds( getUpdateArea() );
 
         mxClipPoly = xClip;
 
@@ -312,7 +312,7 @@ namespace canvas
         {
             mpSpriteCanvas->updateSprite( rSprite,
                                           maPosition,
-                                          rPrevBounds );
+                                          aPrevBounds );
             mpSpriteCanvas->updateSprite( rSprite,
                                           maPosition,
                                           getUpdateArea() );
diff --git a/canvas/source/tools/canvastools.cxx b/canvas/source/tools/canvastools.cxx
index 4326847570d8..b77524351b96 100644
--- a/canvas/source/tools/canvastools.cxx
+++ b/canvas/source/tools/canvastools.cxx
@@ -958,13 +958,13 @@ namespace canvas::tools
 
             // compute full destination area (to determine uninitialized
             // areas below)
-            const ::basegfx::B2I64Tuple& rRange( io_rSourceArea.getRange() );
+            const ::basegfx::B2I64Tuple aRange( io_rSourceArea.getRange() );
             ::basegfx::B2IRange aInputDestArea( io_rDestPoint.getX(),
                                                 io_rDestPoint.getY(),
                                                 (io_rDestPoint.getX()
-                                                 + static_cast<sal_Int32>(rRange.getX())),
+                                                 + static_cast<sal_Int32>(aRange.getX())),
                                                 (io_rDestPoint.getY()
-                                                 + static_cast<sal_Int32>(rRange.getY())) );
+                                                 + static_cast<sal_Int32>(aRange.getY())) );
             // limit to output area (no point updating outside of it)
             aInputDestArea.intersect( rBounds );
 
diff --git a/canvas/source/tools/spriteredrawmanager.cxx b/canvas/source/tools/spriteredrawmanager.cxx
index 06eb6d1de594..26a1d67f8836 100644
--- a/canvas/source/tools/spriteredrawmanager.cxx
+++ b/canvas/source/tools/spriteredrawmanager.cxx
@@ -286,11 +286,11 @@ namespace canvas
         // marked as "don't need update"
         for( const auto& pUnchangedSprite : aUnchangedSprites )
         {
-            const ::basegfx::B2DRange& rUpdateArea( pUnchangedSprite->getUpdateArea() );
+            const ::basegfx::B2DRange aUpdateArea( pUnchangedSprite->getUpdateArea() );
             rUpdateAreas.addRange(
-                ::basegfx::unotools::b2DSurroundingIntegerRangeFromB2DRange( rUpdateArea ),
+                ::basegfx::unotools::b2DSurroundingIntegerRangeFromB2DRange( aUpdateArea ),
                 SpriteInfo( pUnchangedSprite,
-                            rUpdateArea,
+                            aUpdateArea,
                             false ) );
         }
     }
diff --git a/canvas/source/tools/surface.cxx b/canvas/source/tools/surface.cxx
index ff5dce985048..c197f6d251a5 100644
--- a/canvas/source/tools/surface.cxx
+++ b/canvas/source/tools/surface.cxx
@@ -100,12 +100,12 @@ namespace canvas
         prepareRendering();
 
         // convert size to normalized device coordinates
-        const ::basegfx::B2DRectangle& rUV( getUVCoords() );
+        const ::basegfx::B2DRectangle aUV( getUVCoords() );
 
-        const double u1(rUV.getMinX());
-        const double v1(rUV.getMinY());
-        const double u2(rUV.getMaxX());
-        const double v2(rUV.getMaxY());
+        const double u1(aUV.getMinX());
+        const double v1(aUV.getMinY());
+        const double u2(aUV.getMaxX());
+        const double v2(aUV.getMaxY());
 
         // concat transforms
         // 1) offset of surface subarea
@@ -144,10 +144,10 @@ namespace canvas
             ######################################
         */
 
-        const ::basegfx::B2DPoint& p0(aTransform * ::basegfx::B2DPoint(maSize.getWidth(),maSize.getHeight()));
-        const ::basegfx::B2DPoint& p1(aTransform * ::basegfx::B2DPoint(0.0,maSize.getHeight()));
-        const ::basegfx::B2DPoint& p2(aTransform * ::basegfx::B2DPoint(0.0,0.0));
-        const ::basegfx::B2DPoint& p3(aTransform * ::basegfx::B2DPoint(maSize.getWidth(),0.0));
+        const ::basegfx::B2DPoint p0(aTransform * ::basegfx::B2DPoint(maSize.getWidth(),maSize.getHeight()));
+        const ::basegfx::B2DPoint p1(aTransform * ::basegfx::B2DPoint(0.0,maSize.getHeight()));
+        const ::basegfx::B2DPoint p2(aTransform * ::basegfx::B2DPoint(0.0,0.0));
+        const ::basegfx::B2DPoint p3(aTransform * ::basegfx::B2DPoint(maSize.getWidth(),0.0));
 
         canvas::Vertex vertex;
         vertex.r = 1.0f;
@@ -222,13 +222,13 @@ namespace canvas
             aDestOffset = mpFragment->getPos();
 
         // convert size to normalized device coordinates
-        const ::basegfx::B2DRectangle& rUV(
+        const ::basegfx::B2DRectangle aUV(
             getUVCoords(aPos1 - maSourceOffset + aDestOffset,
                         basegfx::B2ISize(aSize.getX(), aSize.getY())) );
-        const double u1(rUV.getMinX());
-        const double v1(rUV.getMinY());
-        const double u2(rUV.getMaxX());
-        const double v2(rUV.getMaxY());
+        const double u1(aUV.getMinX());
+        const double v1(aUV.getMinY());
+        const double u2(aUV.getMaxX());
+        const double v2(aUV.getMaxY());
 
         // concatenate transforms
         // 1) offset of surface subarea
@@ -264,10 +264,10 @@ namespace canvas
             ######################################
         */
 
-        const ::basegfx::B2DPoint& p0(aTransform * ::basegfx::B2DPoint(aSize.getX(),aSize.getY()));
-        const ::basegfx::B2DPoint& p1(aTransform * ::basegfx::B2DPoint(0.0,         aSize.getY()));
-        const ::basegfx::B2DPoint& p2(aTransform * ::basegfx::B2DPoint(0.0,         0.0));
-        const ::basegfx::B2DPoint& p3(aTransform * ::basegfx::B2DPoint(aSize.getX(),0.0));
+        const ::basegfx::B2DPoint p0(aTransform * ::basegfx::B2DPoint(aSize.getX(),aSize.getY()));
+        const ::basegfx::B2DPoint p1(aTransform * ::basegfx::B2DPoint(0.0,         aSize.getY()));
+        const ::basegfx::B2DPoint p2(aTransform * ::basegfx::B2DPoint(0.0,         0.0));
+        const ::basegfx::B2DPoint p3(aTransform * ::basegfx::B2DPoint(aSize.getX(),0.0));
 
         canvas::Vertex vertex;
         vertex.r = 1.0f;
@@ -360,7 +360,7 @@ namespace canvas
 
         // uv coordinates that map the surface rectangle
         // to the destination rectangle.
-        const ::basegfx::B2DRectangle& rUV( getUVCoords() );
+        const ::basegfx::B2DRectangle aUV( getUVCoords() );
 
         basegfx::B2DPolygon rTriangleList(basegfx::utils::clipTriangleListOnRange(rClipPoly,
                                                                                   aSurfaceClipRect));
@@ -385,8 +385,8 @@ namespace canvas
             {
                 const basegfx::B2DPoint &aPoint = rTriangleList.getB2DPoint(nIndex);
                 basegfx::B2DPoint aTransformedPoint(aTransform * aPoint);
-                const double tu(((aPoint.getX()-aSurfaceClipRect.getMinX())*rUV.getWidth()/w)+rUV.getMinX());
-                const double tv(((aPoint.getY()-aSurfaceClipRect.getMinY())*rUV.getHeight()/h)+rUV.getMinY());
+                const double tu(((aPoint.getX()-aSurfaceClipRect.getMinX())*aUV.getWidth()/w)+aUV.getMinX());
+                const double tv(((aPoint.getY()-aSurfaceClipRect.getMinY())*aUV.getHeight()/h)+aUV.getMinY());
                 vertex.u=static_cast<float>(tu);
                 vertex.v=static_cast<float>(tv);
                 vertex.x=static_cast<float>(aTransformedPoint.getX());
diff --git a/canvas/source/tools/surfaceproxy.cxx b/canvas/source/tools/surfaceproxy.cxx
index af76b8b3c30a..b5cd289d9f62 100644
--- a/canvas/source/tools/surfaceproxy.cxx
+++ b/canvas/source/tools/surfaceproxy.cxx
@@ -111,16 +111,16 @@ namespace canvas
                              const ::basegfx::B2DPolyPolygon& rClipPoly,
                              const ::basegfx::B2DHomMatrix&   rTransform )
     {
-        const ::basegfx::triangulator::B2DTriangleVector& rTriangulatedVector(
+        const ::basegfx::triangulator::B2DTriangleVector aTriangulatedVector(
             ::basegfx::triangulator::triangulate(rClipPoly));
 
         // we have now an explicit ::B2DTriangle and ::B2DTriangleVector,
         // but I do not know enough about 'drawWithClip' or 'clipTriangleListOnRange'
         // to adapt to that. Convert back to old three-point-in-polygon convention
         ::basegfx::B2DPolygon aTriangulatedPolygon;
-        aTriangulatedPolygon.reserve(rTriangulatedVector.size() * 3);
+        aTriangulatedPolygon.reserve(aTriangulatedVector.size() * 3);
 
-        for(const auto& rCandidate : rTriangulatedVector)
+        for(const auto& rCandidate : aTriangulatedVector)
         {
             aTriangulatedPolygon.append(rCandidate.getA());
             aTriangulatedPolygon.append(rCandidate.getB());
diff --git a/canvas/source/vcl/canvasfont.cxx b/canvas/source/vcl/canvasfont.cxx
index 235f72fbb514..9ee7c1cec53b 100644
--- a/canvas/source/vcl/canvasfont.cxx
+++ b/canvas/source/vcl/canvasfont.cxx
@@ -111,7 +111,7 @@ namespace vclcanvas
         OutputDevice& rOutDev = mpOutDevProvider->getOutDev();
         ScopedVclPtrInstance< VirtualDevice > pVDev( rOutDev );
         pVDev->SetFont(getVCLFont());
-        const ::FontMetric& aMetric( pVDev->GetFontMetric() );
+        const ::FontMetric aMetric( pVDev->GetFontMetric() );
 
         return rendering::FontMetrics(
             aMetric.GetAscent(),
diff --git a/canvas/source/vcl/canvashelper.cxx b/canvas/source/vcl/canvashelper.cxx
index db19111f349c..f398f6734f1a 100644
--- a/canvas/source/vcl/canvashelper.cxx
+++ b/canvas/source/vcl/canvashelper.cxx
@@ -219,26 +219,26 @@ namespace vclcanvas
         tools::OutDevStateKeeper aStateKeeper( mpProtectedOutDevProvider );
         setupOutDevState( viewState, renderState, LINE_COLOR );
 
-        const Point& rStartPoint( tools::mapRealPoint2D( geometry::RealPoint2D(aBezierSegment.Px,
+        const Point aStartPoint( tools::mapRealPoint2D( geometry::RealPoint2D(aBezierSegment.Px,
                                                                                aBezierSegment.Py),
                                                         viewState, renderState ) );
-        const Point& rCtrlPoint1( tools::mapRealPoint2D( geometry::RealPoint2D(aBezierSegment.C1x,
+        const Point aCtrlPoint1( tools::mapRealPoint2D( geometry::RealPoint2D(aBezierSegment.C1x,
                                                                                aBezierSegment.C1y),
                                                         viewState, renderState ) );
-        const Point& rCtrlPoint2( tools::mapRealPoint2D( geometry::RealPoint2D(aBezierSegment.C2x,
+        const Point aCtrlPoint2( tools::mapRealPoint2D( geometry::RealPoint2D(aBezierSegment.C2x,
                                                                                aBezierSegment.C2y),
                                                          viewState, renderState ) );
-        const Point& rEndPoint( tools::mapRealPoint2D( _aEndPoint,
+        const Point aEndPoint( tools::mapRealPoint2D( _aEndPoint,
                                                        viewState, renderState ) );
 
         ::tools::Polygon aPoly(4);
-        aPoly.SetPoint( rStartPoint, 0 );
+        aPoly.SetPoint( aStartPoint, 0 );
         aPoly.SetFlags( 0, PolyFlags::Normal );
-        aPoly.SetPoint( rCtrlPoint1, 1 );
+        aPoly.SetPoint( aCtrlPoint1, 1 );
         aPoly.SetFlags( 1, PolyFlags::Control );
-        aPoly.SetPoint( rCtrlPoint2, 2 );
+        aPoly.SetPoint( aCtrlPoint2, 2 );
         aPoly.SetFlags( 2, PolyFlags::Control );
-        aPoly.SetPoint( rEndPoint, 3 );
+        aPoly.SetPoint( aEndPoint, 3 );
         aPoly.SetFlags( 3, PolyFlags::Normal );
 
         // TODO(F2): alpha
@@ -260,11 +260,11 @@ namespace vclcanvas
             tools::OutDevStateKeeper aStateKeeper( mpProtectedOutDevProvider );
             setupOutDevState( viewState, renderState, LINE_COLOR );
 
-            const ::basegfx::B2DPolyPolygon& rPolyPoly(
+            const ::basegfx::B2DPolyPolygon aBasegfxPolyPoly(
                 ::basegfx::unotools::b2DPolyPolygonFromXPolyPolygon2D(xPolyPolygon) );
-            const ::tools::PolyPolygon aPolyPoly( tools::mapPolyPolygon( rPolyPoly, viewState, renderState ) );
+            const ::tools::PolyPolygon aPolyPoly( tools::mapPolyPolygon( aBasegfxPolyPoly, viewState, renderState ) );
 
-            if( rPolyPoly.isClosed() )
+            if( aBasegfxPolyPoly.isClosed() )
             {
                 mpOutDevProvider->getOutDev().DrawPolyPolygon( aPolyPoly );
 
@@ -318,7 +318,7 @@ namespace vclcanvas
             // apply dashing, if any
             if( strokeAttributes.DashArray.hasElements() )
             {
-                const std::vector<double>& aDashArray(
+                const std::vector<double> aDashArray(
                     ::comphelper::sequenceToContainer< std::vector<double> >(strokeAttributes.DashArray) );
 
                 ::basegfx::B2DPolyPolygon aDashedPolyPoly;
diff --git a/canvas/source/vcl/canvashelper_texturefill.cxx b/canvas/source/vcl/canvashelper_texturefill.cxx
index 6972066b47a5..f9501cf8d426 100644
--- a/canvas/source/vcl/canvashelper_texturefill.cxx
+++ b/canvas/source/vcl/canvashelper_texturefill.cxx
@@ -210,13 +210,13 @@ namespace vclcanvas
             // the 'left'. Since we postpone actual rendering into the
             // loop below, we set the _right_ edge here, which will be
             // readily copied into the left edge in the loop below
-            const ::basegfx::B2DPoint& rPoint1( aLeftTop - 2.0*nDiagonalLength*aDirection );
-            aTempPoly[1] = ::Point( ::basegfx::fround<::tools::Long>( rPoint1.getX() ),
-                                    ::basegfx::fround<::tools::Long>( rPoint1.getY() ) );
+            const ::basegfx::B2DPoint aPoint1( aLeftTop - 2.0*nDiagonalLength*aDirection );
+            aTempPoly[1] = ::Point( ::basegfx::fround<::tools::Long>( aPoint1.getX() ),
+                                    ::basegfx::fround<::tools::Long>( aPoint1.getY() ) );
 
-            const ::basegfx::B2DPoint& rPoint2( aLeftBottom - 2.0*nDiagonalLength*aDirection );
-            aTempPoly[2] = ::Point( ::basegfx::fround<::tools::Long>( rPoint2.getX() ),
-                                    ::basegfx::fround<::tools::Long>( rPoint2.getY() ) );
+            const ::basegfx::B2DPoint aPoint2( aLeftBottom - 2.0*nDiagonalLength*aDirection );
+            aTempPoly[2] = ::Point( ::basegfx::fround<::tools::Long>( aPoint2.getX() ),
+                                    ::basegfx::fround<::tools::Long>( aPoint2.getY() ) );
 
 
             // iteratively render all other strips
@@ -255,17 +255,17 @@ namespace vclcanvas
                 // increased by one, to account for the fact that we
                 // calculate the right border here (whereas the fill
                 // color is governed by the left edge)
-                const ::basegfx::B2DPoint& rPoint3(
+                const ::basegfx::B2DPoint aPoint3(
                     (nStepCount - i-1)/double(nStepCount)*aLeftTop +
                     (i+1)/double(nStepCount)*aRightTop );
-                aTempPoly[1] = ::Point( ::basegfx::fround<::tools::Long>( rPoint3.getX() ),
-                                        ::basegfx::fround<::tools::Long>( rPoint3.getY() ) );
+                aTempPoly[1] = ::Point( ::basegfx::fround<::tools::Long>( aPoint3.getX() ),
+                                        ::basegfx::fround<::tools::Long>( aPoint3.getY() ) );
 
-                const ::basegfx::B2DPoint& rPoint4(
+                const ::basegfx::B2DPoint aPoint4(
                     (nStepCount - i-1)/double(nStepCount)*aLeftBottom +
                     (i+1)/double(nStepCount)*aRightBottom );
-                aTempPoly[2] = ::Point( ::basegfx::fround<::tools::Long>( rPoint4.getX() ),
-                                        ::basegfx::fround<::tools::Long>( rPoint4.getY() ) );
+                aTempPoly[2] = ::Point( ::basegfx::fround<::tools::Long>( aPoint4.getX() ),
+                                        ::basegfx::fround<::tools::Long>( aPoint4.getY() ) );
 
                 rOutDev.DrawPolygon( aTempPoly );
             }
@@ -282,13 +282,13 @@ namespace vclcanvas
             // calculate new right edge, by moving right edge of the
             // gradient rect two times the bound rect's diagonal to
             // the 'right'.
-            const ::basegfx::B2DPoint& rPoint3( aRightTop + 2.0*nDiagonalLength*aDirection );
-            aTempPoly[0] = aTempPoly[4] = ::Point( ::basegfx::fround<::tools::Long>( rPoint3.getX() ),
-                                                   ::basegfx::fround<::tools::Long>( rPoint3.getY() ) );
+            const ::basegfx::B2DPoint aPoint3( aRightTop + 2.0*nDiagonalLength*aDirection );
+            aTempPoly[0] = aTempPoly[4] = ::Point( ::basegfx::fround<::tools::Long>( aPoint3.getX() ),
+                                                   ::basegfx::fround<::tools::Long>( aPoint3.getY() ) );
 
-            const ::basegfx::B2DPoint& rPoint4( aRightBottom + 2.0*nDiagonalLength*aDirection );
-            aTempPoly[3] = ::Point( ::basegfx::fround<::tools::Long>( rPoint4.getX() ),
-                                    ::basegfx::fround<::tools::Long>( rPoint4.getY() ) );
+            const ::basegfx::B2DPoint aPoint4( aRightBottom + 2.0*nDiagonalLength*aDirection );
+            aTempPoly[3] = ::Point( ::basegfx::fround<::tools::Long>( aPoint4.getX() ),
+                                    ::basegfx::fround<::tools::Long>( aPoint4.getY() ) );
 
             rOutDev.SetFillColor( rColors.back() );
 
@@ -629,20 +629,20 @@ namespace vclcanvas
                 {
                     // copy state from Gradient polypoly locally
                     // (given object might change!)
-                    const ::canvas::ParametricPolyPolygon::Values& rValues(
+                    const ::canvas::ParametricPolyPolygon::Values aValues(
                         pGradient->getValues() );
 
-                    if( rValues.maColors.getLength() < 2 )
+                    if( aValues.maColors.getLength() < 2 )
                     {
                         rendering::RenderState aTempState=renderState;
-                        aTempState.DeviceColor = rValues.maColors[0];
+                        aTempState.DeviceColor = aValues.maColors[0];
                         fillPolyPolygon(pCanvas, xPolyPolygon, viewState, aTempState);
                     }
                     else
                     {
-                        std::vector< ::Color > aColors(rValues.maColors.getLength());
-                        std::transform(&rValues.maColors[0],
-                                       &rValues.maColors[0]+rValues.maColors.getLength(),
+                        std::vector< ::Color > aColors(aValues.maColors.getLength());
+                        std::transform(&aValues.maColors[0],
+                                       &aValues.maColors[0]+aValues.maColors.getLength(),
                                        aColors.begin(),
                                        [](const uno::Sequence< double >& aColor) {
                                            return vcl::unotools::stdColorSpaceSequenceToColor( aColor );
@@ -652,7 +652,7 @@ namespace vclcanvas
                         // TODO(F1): FillRule
                         gradientFill( mpOutDevProvider->getOutDev(),
                                       mp2ndOutDevProvider ? &mp2ndOutDevProvider->getOutDev() : nullptr,
-                                      rValues,
+                                      aValues,
                                       aColors,
                                       aPolyPoly,
                                       viewState,
diff --git a/canvas/source/vcl/spritecanvashelper.cxx b/canvas/source/vcl/spritecanvashelper.cxx
index 37f70a364267..c8bef05d721f 100644
--- a/canvas/source/vcl/spritecanvashelper.cxx
+++ b/canvas/source/vcl/spritecanvashelper.cxx
@@ -60,27 +60,27 @@ namespace vclcanvas
 
         double calcNumPixel( const ::canvas::Sprite::Reference& rSprite )
         {
-            const ::basegfx::B2DVector& rSize(
+            const ::basegfx::B2DVector aSize(
                 ::boost::polymorphic_downcast< Sprite* >(rSprite.get())->getSizePixel() );
 
-            return rSize.getX() * rSize.getY();
+            return aSize.getX() * aSize.getY();
         }
 
         void repaintBackground( OutputDevice&               rOutDev,
                                 OutputDevice const &        rBackBuffer,
                                 const ::basegfx::B2DRange&  rArea )
         {
-            const ::Point& rPos( vcl::unotools::pointFromB2DPoint( rArea.getMinimum()) );
-            const ::Size& rSize( vcl::unotools::sizeFromB2DSize( rArea.getRange()) );
+            const ::Point aPos( vcl::unotools::pointFromB2DPoint( rArea.getMinimum()) );
+            const ::Size aSize( vcl::unotools::sizeFromB2DSize( rArea.getRange()) );
 
-            rOutDev.DrawOutDev( rPos, rSize, rPos, rSize, rBackBuffer );
+            rOutDev.DrawOutDev( aPos, aSize, aPos, aSize, rBackBuffer );
         }
 
         void opaqueUpdateSpriteArea( const ::canvas::Sprite::Reference& rSprite,
                                      OutputDevice&                      rOutDev,
                                      const ::basegfx::B2IRange&         rArea )
         {
-            const ::tools::Rectangle& rRequestedArea(
+            const ::tools::Rectangle aRequestedArea(
                 vcl::unotools::rectangleFromB2IRectangle( rArea ) );
 
             // clip output to actual update region (otherwise a)
@@ -88,7 +88,7 @@ namespace vclcanvas
             // scrolled sprite content outside this area)
             rOutDev.EnableMapMode( false );
             rOutDev.SetAntialiasing( AntialiasingFlags::Enable );
-            rOutDev.SetClipRegion(vcl::Region(rRequestedArea));
+            rOutDev.SetClipRegion(vcl::Region(aRequestedArea));
 
             // repaint affected sprite directly to output device (at
             // the actual screen output position)
@@ -341,10 +341,10 @@ namespace vclcanvas
         BackBufferSharedPtr pBackBuffer( mpOwningSpriteCanvas->getBackBuffer() );
         OutputDevice&       rBackOutDev( pBackBuffer->getOutDev() );
 
-        const Size&                rTargetSizePixel( rOutDev.GetOutputSizePixel() );
+        const Size                 aTargetSizePixel( rOutDev.GetOutputSizePixel() );
         const ::basegfx::B2IRange  aOutputBounds( 0,0,
-                                                  rTargetSizePixel.Width(),
-                                                  rTargetSizePixel.Height() );
+                                                  aTargetSizePixel.Width(),
+                                                  aTargetSizePixel.Height() );
 
         // round rectangles to integer pixel. Note: have to be
         // extremely careful here, to avoid off-by-one errors for
@@ -353,9 +353,9 @@ namespace vclcanvas
         // the sprite.
         ::basegfx::B2IRange aSourceRect(
             ::canvas::tools::spritePixelAreaFromB2DRange( rMoveStart ) );
-        const ::basegfx::B2IRange& rDestRect(
+        const ::basegfx::B2IRange aDestRect(
             ::canvas::tools::spritePixelAreaFromB2DRange( rMoveEnd ) );
-        ::basegfx::B2IPoint aDestPos( rDestRect.getMinimum() );
+        ::basegfx::B2IPoint aDestPos( aDestRect.getMinimum() );
 
         std::vector< ::basegfx::B2IRange > aUnscrollableAreas;
 
@@ -421,7 +421,7 @@ namespace vclcanvas
         std::vector< ::basegfx::B2DRange > aUncoveredAreas;
         ::basegfx::computeSetDifference( aUncoveredAreas,
                                          rUpdateArea.maTotalBounds,
-                                         ::basegfx::B2DRange( rDestRect ) );
+                                         ::basegfx::B2DRange( aDestRect ) );
 
         for( const auto& rArea : aUncoveredAreas )
             repaintBackground( rOutDev, rBackOutDev, rArea );
@@ -467,7 +467,7 @@ namespace vclcanvas
         OutputDevice&       rBackOutDev( pBackBuffer->getOutDev() );
 
         // limit size of update VDev to target outdev's size
-        const Size& rTargetSizePixel( rOutDev.GetOutputSizePixel() );
+        const Size aTargetSizePixel( rOutDev.GetOutputSizePixel() );
 
         // round output position towards zero. Don't want to truncate
         // a fraction of a sprite pixel...  Clip position at origin,
@@ -484,10 +484,10 @@ namespace vclcanvas
         // cover _only_ the visible parts).
         const ::Size aOutputSize(
             std::max( sal_Int32( 0 ),
-                        std::min( static_cast< sal_Int32 >(rTargetSizePixel.Width() - aOutputPosition.X()),
+                        std::min( static_cast< sal_Int32 >(aTargetSizePixel.Width() - aOutputPosition.X()),
                                     ::canvas::tools::roundUp( rRequestedArea.getMaxX() - aOutputPosition.X() ))),
             std::max( sal_Int32( 0 ),
-                        std::min( static_cast< sal_Int32 >(rTargetSizePixel.Height() - aOutputPosition.Y()),
+                        std::min( static_cast< sal_Int32 >(aTargetSizePixel.Height() - aOutputPosition.Y()),
                                     ::canvas::tools::roundUp( rRequestedArea.getMaxY() - aOutputPosition.Y() ))));
 
         // early exit for empty output area.
@@ -531,12 +531,12 @@ namespace vclcanvas
 
                 // calc relative sprite position in rUpdateArea (which
                 // need not be the whole screen!)
-                const ::basegfx::B2DPoint& rSpriteScreenPos( pSprite->getPosPixel() );
-                const ::basegfx::B2DPoint& rSpriteRenderPos(
-                        rSpriteScreenPos - vcl::unotools::b2DPointFromPoint(aOutputPosition)
+                const ::basegfx::B2DPoint aSpriteScreenPos( pSprite->getPosPixel() );
+                const ::basegfx::B2DPoint aSpriteRenderPos(
+                        aSpriteScreenPos - vcl::unotools::b2DPointFromPoint(aOutputPosition)
                         );
 
-                pSprite->redraw( *maVDev, rSpriteRenderPos, true );
+                pSprite->redraw( *maVDev, aSpriteRenderPos, true );
             }
         }
 
@@ -635,12 +635,12 @@ namespace vclcanvas
         static const int NUM_VIRDEV(2);
         static const int BYTES_PER_PIXEL(3);
 
-        const Size& rVDevSize( maVDev->GetOutputSizePixel() );
-        const Size& rBackBufferSize( pBackBuffer->getOutDev().GetOutputSizePixel() );
+        const Size aVDevSize( maVDev->GetOutputSizePixel() );
+        const Size aBackBufferSize( pBackBuffer->getOutDev().GetOutputSizePixel() );
 
         const double nMemUsage( nPixel * NUM_VIRDEV * BYTES_PER_PIXEL +
-                                rVDevSize.Width()*rVDevSize.Height() * BYTES_PER_PIXEL +
-                                rBackBufferSize.Width()*rBackBufferSize.Height() * BYTES_PER_PIXEL );
+                                aVDevSize.Width()*aVDevSize.Height() * BYTES_PER_PIXEL +
+                                aBackBufferSize.Width()*aBackBufferSize.Height() * BYTES_PER_PIXEL );
 
         OUString text( ::rtl::math::doubleToUString( nMemUsage / 1048576.0,
                                                             rtl_math_StringFormat_F,
diff --git a/canvas/source/vcl/textlayout.cxx b/canvas/source/vcl/textlayout.cxx
index b08288c70127..024edd1f8e67 100644
--- a/canvas/source/vcl/textlayout.cxx
+++ b/canvas/source/vcl/textlayout.cxx
@@ -247,7 +247,7 @@ namespace vclcanvas
 
         // need metrics for Y offset, the XCanvas always renders
         // relative to baseline
-        const ::FontMetric& aMetric( pVDev->GetFontMetric() );
+        const ::FontMetric aMetric( pVDev->GetFontMetric() );
 
         setupLayoutMode( *pVDev, mnTextDirection );
 
diff --git a/canvas/workben/canvasdemo.cxx b/canvas/workben/canvasdemo.cxx
index e910353dd5f4..65e8ba775c76 100644
--- a/canvas/workben/canvasdemo.cxx
+++ b/canvas/workben/canvasdemo.cxx
@@ -294,14 +294,14 @@ class DemoRenderer
                                              maBox.Height()*.5 );
             const basegfx::B2DPoint aRadii( maBox.Width()*.3,
                                             maBox.Height()*.3 );
-            const basegfx::B2DPolygon& rEllipse(
+            const basegfx::B2DPolygon aEllipse(
                 basegfx::utils::createPolygonFromEllipse( aCenter,
                                                           aRadii.getX(),
                                                           aRadii.getY() ));
 
             uno::Reference< rendering::XPolyPolygon2D > xPoly(
                 basegfx::unotools::xPolyPolygonFromB2DPolygon(mxDevice,
-                                                              rEllipse) );
+                                                              aEllipse) );
 
             rendering::StrokeAttributes aStrokeAttrs;
             aStrokeAttrs.StrokeWidth = 4.0;