tdf#82214 optimize PatternFillPrimitive and SVG

Use buffering in the drawinglayer, and don't do slow stuff in the
windows gdi renderer.

Conflicts:
	svgio/source/svgreader/svgstyleattributes.cxx

Change-Id: Id955ee6a3b03e568c2678f02d77af35d2e5ba1d4

1 files changed, 60 insertions, 39 deletions

diff --git a/svgio/source/svgreader/svgstyleattributes.cxx b/svgio/source/svgreader/svgstyleattributes.cxx
index dcde298b72be..993521c39922 100644
--- a/svgio/source/svgreader/svgstyleattributes.cxx
+++ b/svgio/source/svgreader/svgstyleattributes.cxx
@@ -664,54 +664,75 @@ namespace svgio
 
                     if(basegfx::fTools::more(fStrokeWidth, 0.0))
                     {
-                        // get LineJoin, LineCap and stroke array
-                        const basegfx::B2DLineJoin aB2DLineJoin(StrokeLinejoinToB2DLineJoin(getStrokeLinejoin()));
-                        const css::drawing::LineCap aLineCap(StrokeLinecapToDrawingLineCap(getStrokeLinecap()));
-                        ::std::vector< double > aDashArray;
+                        drawinglayer::primitive2d::Primitive2DReference aNewLinePrimitive;
 
-                        if(!getStrokeDasharray().empty())
+                        // if we have a line with two identical points it is not really a line,
+                        // but used by SVG sometimes to paint a single dot.In that case, create
+                        // the geometry for a single dot
+                        if(1 == rPath.count())
                         {
-                            aDashArray = solveSvgNumberVector(getStrokeDasharray(), mrOwner);
-                        }
+                            const basegfx::B2DPolygon aSingle(rPath.getB2DPolygon(0));
 
-                        // todo: Handle getStrokeDashOffset()
-
-                        // convert svg:stroke-miterlimit to LineAttrute:mfMiterMinimumAngle
-                        // The default needs to be set explicitly, because svg default <> Draw default
-                        double fMiterMinimumAngle;
-                        if (getStrokeMiterLimit().isSet())
-                        {
-                            fMiterMinimumAngle = 2.0 * asin(1.0/getStrokeMiterLimit().getNumber());
+                            if(2 == aSingle.count() && aSingle.getB2DPoint(0).equal(aSingle.getB2DPoint(1)))
+                            {
+                                aNewLinePrimitive = new drawinglayer::primitive2d::PolyPolygonColorPrimitive2D(
+                                    basegfx::B2DPolyPolygon(
+                                        basegfx::tools::createPolygonFromCircle(
+                                            aSingle.getB2DPoint(0),
+                                            fStrokeWidth * (1.44 * 0.5))),
+                                    pStroke ? *pStroke : basegfx::BColor(0.0, 0.0, 0.0));
+                            }
                         }
-                        else
+
+                        if(!aNewLinePrimitive.is())
                         {
-                            fMiterMinimumAngle = 2.0 * asin(0.25); // 1.0/default 4.0
-                        }
+                            // get LineJoin, LineCap and stroke array
+                            const basegfx::B2DLineJoin aB2DLineJoin(StrokeLinejoinToB2DLineJoin(getStrokeLinejoin()));
+                            const css::drawing::LineCap aLineCap(StrokeLinecapToDrawingLineCap(getStrokeLinecap()));
+                            ::std::vector< double > aDashArray;
 
-                        // prepare line attribute
-                        drawinglayer::primitive2d::Primitive2DReference aNewLinePrimitive;
+                            if(!getStrokeDasharray().empty())
+                            {
+                                aDashArray = solveSvgNumberVector(getStrokeDasharray(), mrOwner);
+                            }
+
+                            // convert svg:stroke-miterlimit to LineAttrute:mfMiterMinimumAngle
+                            // The default needs to be set explicitely, because svg default <> Draw default
+                            double fMiterMinimumAngle;
+                            if (getStrokeMiterLimit().isSet())
+                            {
+                                fMiterMinimumAngle = 2.0 * asin(1.0/getStrokeMiterLimit().getNumber());
+                            }
+                            else
+                            {
+                                fMiterMinimumAngle = 2.0 * asin(0.25); // 1.0/default 4.0
+                            }
 
-                        const drawinglayer::attribute::LineAttribute aLineAttribute(
-                            pStroke ? *pStroke : basegfx::BColor(0.0, 0.0, 0.0),
-                            fStrokeWidth,
-                            aB2DLineJoin,
-                            aLineCap,
-                            fMiterMinimumAngle);
+                            // todo: Handle getStrokeDashOffset()
 
-                        if(aDashArray.empty())
-                        {
-                            aNewLinePrimitive = new drawinglayer::primitive2d::PolyPolygonStrokePrimitive2D(
-                                rPath,
-                                aLineAttribute);
-                        }
-                        else
-                        {
-                            const drawinglayer::attribute::StrokeAttribute aStrokeAttribute(aDashArray);
+                            // prepare line attribute
+                            const drawinglayer::attribute::LineAttribute aLineAttribute(
+                                pStroke ? *pStroke : basegfx::BColor(0.0, 0.0, 0.0),
+                                fStrokeWidth,
+                                aB2DLineJoin,
+                                aLineCap,
+                                fMiterMinimumAngle);
 
-                            aNewLinePrimitive = new drawinglayer::primitive2d::PolyPolygonStrokePrimitive2D(
-                                rPath,
-                                aLineAttribute,
-                                aStrokeAttribute);
+                            if(aDashArray.empty())
+                            {
+                                aNewLinePrimitive = new drawinglayer::primitive2d::PolyPolygonStrokePrimitive2D(
+                                    rPath,
+                                    aLineAttribute);
+                            }
+                            else
+                            {
+                                const drawinglayer::attribute::StrokeAttribute aStrokeAttribute(aDashArray);
+
+                                aNewLinePrimitive = new drawinglayer::primitive2d::PolyPolygonStrokePrimitive2D(
+                                    rPath,
+                                    aLineAttribute,
+                                    aStrokeAttribute);
+                            }
                         }
 
                         if(pStrokeGradient || pStrokePattern)