split up polypolygonprimitive2d.cxx into separate files

Change-Id: I39d1682f9d3781272590015f59ccafb33c0fd617
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/91788
Tested-by: Jenkins
Reviewed-by: Tomaž Vajngerl <quikee@gmail.com>

10 files changed, 793 insertions, 573 deletions

diff --git a/drawinglayer/Library_drawinglayer.mk b/drawinglayer/Library_drawinglayer.mk
index 0f93f8407b98..2a0f1030a789 100644
--- a/drawinglayer/Library_drawinglayer.mk
+++ b/drawinglayer/Library_drawinglayer.mk
@@ -102,7 +102,14 @@ $(eval $(call gb_Library_add_exception_objects,drawinglayer,\
     drawinglayer/source/primitive2d/patternfillprimitive2d \
     drawinglayer/source/primitive2d/pointarrayprimitive2d \
     drawinglayer/source/primitive2d/polygonprimitive2d \
-    drawinglayer/source/primitive2d/polypolygonprimitive2d \
+    drawinglayer/source/primitive2d/PolyPolygonHairlinePrimitive2D \
+    drawinglayer/source/primitive2d/PolyPolygonMarkerPrimitive2D \
+    drawinglayer/source/primitive2d/PolyPolygonStrokePrimitive2D \
+    drawinglayer/source/primitive2d/PolyPolygonColorPrimitive2D \
+    drawinglayer/source/primitive2d/PolyPolygonGradientPrimitive2D \
+    drawinglayer/source/primitive2d/PolyPolygonHatchPrimitive2D \
+    drawinglayer/source/primitive2d/PolyPolygonGraphicPrimitive2D \
+    drawinglayer/source/primitive2d/PolyPolygonSelectionPrimitive2D \
     drawinglayer/source/primitive2d/primitivetools2d \
     drawinglayer/source/primitive2d/Primitive2DContainer \
     drawinglayer/source/primitive2d/sceneprimitive2d \
diff --git a/drawinglayer/source/primitive2d/PolyPolygonColorPrimitive2D.cxx b/drawinglayer/source/primitive2d/PolyPolygonColorPrimitive2D.cxx
new file mode 100644
index 000000000000..aa48a965e692
--- /dev/null
+++ b/drawinglayer/source/primitive2d/PolyPolygonColorPrimitive2D.cxx
@@ -0,0 +1,66 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <drawinglayer/primitive2d/PolyPolygonColorPrimitive2D.hxx>
+
+#include <basegfx/polygon/b2dpolypolygontools.hxx>
+#include <drawinglayer/primitive2d/drawinglayer_primitivetypes2d.hxx>
+
+using namespace com::sun::star;
+
+namespace drawinglayer::primitive2d
+{
+PolyPolygonColorPrimitive2D::PolyPolygonColorPrimitive2D(
+    const basegfx::B2DPolyPolygon& rPolyPolygon, const basegfx::BColor& rBColor)
+    : BasePrimitive2D()
+    , maPolyPolygon(rPolyPolygon)
+    , maBColor(rBColor)
+{
+}
+
+bool PolyPolygonColorPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
+{
+    if (BasePrimitive2D::operator==(rPrimitive))
+    {
+        const PolyPolygonColorPrimitive2D& rCompare
+            = static_cast<const PolyPolygonColorPrimitive2D&>(rPrimitive);
+
+        return (getB2DPolyPolygon() == rCompare.getB2DPolyPolygon()
+                && getBColor() == rCompare.getBColor());
+    }
+
+    return false;
+}
+
+basegfx::B2DRange PolyPolygonColorPrimitive2D::getB2DRange(
+    const geometry::ViewInformation2D& /*rViewInformation*/) const
+{
+    // return range
+    return basegfx::utils::getRange(getB2DPolyPolygon());
+}
+
+// provide unique ID
+sal_uInt32 PolyPolygonColorPrimitive2D::getPrimitive2DID() const
+{
+    return PRIMITIVE2D_ID_POLYPOLYGONCOLORPRIMITIVE2D;
+}
+
+} // end drawinglayer::primitive2d namespace
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/drawinglayer/source/primitive2d/PolyPolygonGradientPrimitive2D.cxx b/drawinglayer/source/primitive2d/PolyPolygonGradientPrimitive2D.cxx
new file mode 100644
index 000000000000..076436b40655
--- /dev/null
+++ b/drawinglayer/source/primitive2d/PolyPolygonGradientPrimitive2D.cxx
@@ -0,0 +1,90 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <drawinglayer/primitive2d/PolyPolygonGradientPrimitive2D.hxx>
+
+#include <drawinglayer/primitive2d/drawinglayer_primitivetypes2d.hxx>
+#include <drawinglayer/primitive2d/fillgradientprimitive2d.hxx>
+#include <drawinglayer/primitive2d/maskprimitive2d.hxx>
+
+using namespace com::sun::star;
+
+namespace drawinglayer::primitive2d
+{
+void PolyPolygonGradientPrimitive2D::create2DDecomposition(
+    Primitive2DContainer& rContainer, const geometry::ViewInformation2D& /*rViewInformation*/) const
+{
+    if (!getFillGradient().isDefault())
+    {
+        // create SubSequence with FillGradientPrimitive2D
+        const basegfx::B2DRange aPolyPolygonRange(getB2DPolyPolygon().getB2DRange());
+        FillGradientPrimitive2D* pNewGradient = new FillGradientPrimitive2D(
+            aPolyPolygonRange, getDefinitionRange(), getFillGradient());
+        const Primitive2DReference xSubRef(pNewGradient);
+        const Primitive2DContainer aSubSequence{ xSubRef };
+
+        // create mask primitive
+        rContainer.push_back(new MaskPrimitive2D(getB2DPolyPolygon(), aSubSequence));
+    }
+}
+
+PolyPolygonGradientPrimitive2D::PolyPolygonGradientPrimitive2D(
+    const basegfx::B2DPolyPolygon& rPolyPolygon,
+    const attribute::FillGradientAttribute& rFillGradient)
+    : BufferedDecompositionPrimitive2D()
+    , maPolyPolygon(rPolyPolygon)
+    , maDefinitionRange(rPolyPolygon.getB2DRange())
+    , maFillGradient(rFillGradient)
+{
+}
+
+PolyPolygonGradientPrimitive2D::PolyPolygonGradientPrimitive2D(
+    const basegfx::B2DPolyPolygon& rPolyPolygon, const basegfx::B2DRange& rDefinitionRange,
+    const attribute::FillGradientAttribute& rFillGradient)
+    : BufferedDecompositionPrimitive2D()
+    , maPolyPolygon(rPolyPolygon)
+    , maDefinitionRange(rDefinitionRange)
+    , maFillGradient(rFillGradient)
+{
+}
+
+bool PolyPolygonGradientPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
+{
+    if (BufferedDecompositionPrimitive2D::operator==(rPrimitive))
+    {
+        const PolyPolygonGradientPrimitive2D& rCompare
+            = static_cast<const PolyPolygonGradientPrimitive2D&>(rPrimitive);
+
+        return (getB2DPolyPolygon() == rCompare.getB2DPolyPolygon()
+                && getDefinitionRange() == rCompare.getDefinitionRange()
+                && getFillGradient() == rCompare.getFillGradient());
+    }
+
+    return false;
+}
+
+// provide unique ID
+sal_uInt32 PolyPolygonGradientPrimitive2D::getPrimitive2DID() const
+{
+    return PRIMITIVE2D_ID_POLYPOLYGONGRADIENTPRIMITIVE2D;
+}
+
+} // end drawinglayer::primitive2d namespace
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/drawinglayer/source/primitive2d/PolyPolygonGraphicPrimitive2D.cxx b/drawinglayer/source/primitive2d/PolyPolygonGraphicPrimitive2D.cxx
new file mode 100644
index 000000000000..00bea0ab10ea
--- /dev/null
+++ b/drawinglayer/source/primitive2d/PolyPolygonGraphicPrimitive2D.cxx
@@ -0,0 +1,135 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <drawinglayer/primitive2d/PolyPolygonGraphicPrimitive2D.hxx>
+
+#include <basegfx/matrix/b2dhommatrix.hxx>
+#include <basegfx/matrix/b2dhommatrixtools.hxx>
+#include <drawinglayer/primitive2d/drawinglayer_primitivetypes2d.hxx>
+#include <drawinglayer/primitive2d/fillgraphicprimitive2d.hxx>
+#include <drawinglayer/primitive2d/maskprimitive2d.hxx>
+#include <vcl/graph.hxx>
+
+using namespace com::sun::star;
+
+namespace drawinglayer::primitive2d
+{
+void PolyPolygonGraphicPrimitive2D::create2DDecomposition(
+    Primitive2DContainer& rContainer, const geometry::ViewInformation2D& /*rViewInformation*/) const
+{
+    if (!getFillGraphic().isDefault())
+    {
+        const Graphic& rGraphic = getFillGraphic().getGraphic();
+        const GraphicType aType(rGraphic.GetType());
+
+        // is there a bitmap or a metafile (do we have content)?
+        if (GraphicType::Bitmap == aType || GraphicType::GdiMetafile == aType)
+        {
+            const Size aPrefSize(rGraphic.GetPrefSize());
+
+            // does content have a size?
+            if (aPrefSize.Width() && aPrefSize.Height())
+            {
+                // create SubSequence with FillGraphicPrimitive2D based on polygon range
+                const basegfx::B2DRange aOutRange(getB2DPolyPolygon().getB2DRange());
+                const basegfx::B2DHomMatrix aNewObjectTransform(
+                    basegfx::utils::createScaleTranslateB2DHomMatrix(aOutRange.getRange(),
+                                                                     aOutRange.getMinimum()));
+                Primitive2DReference xSubRef;
+
+                if (aOutRange != getDefinitionRange())
+                {
+                    // we want to paint (tiled) content which is defined relative to DefinitionRange
+                    // with the same tiling and offset(s) in the target range of the geometry (the
+                    // polygon). The range given in the local FillGraphicAttribute defines the position
+                    // of the graphic in unit coordinates relative to the DefinitionRange. Transform
+                    // this using DefinitionRange to get to the global definition and then with the
+                    // inverse transformation from the target range to go to unit coordinates relative
+                    // to that target coordinate system.
+                    basegfx::B2DRange aAdaptedRange(getFillGraphic().getGraphicRange());
+
+                    const basegfx::B2DHomMatrix aFromDefinitionRangeToGlobal(
+                        basegfx::utils::createScaleTranslateB2DHomMatrix(
+                            getDefinitionRange().getRange(), getDefinitionRange().getMinimum()));
+
+                    aAdaptedRange.transform(aFromDefinitionRangeToGlobal);
+
+                    basegfx::B2DHomMatrix aFromGlobalToOutRange(
+                        basegfx::utils::createScaleTranslateB2DHomMatrix(aOutRange.getRange(),
+                                                                         aOutRange.getMinimum()));
+                    aFromGlobalToOutRange.invert();
+
+                    aAdaptedRange.transform(aFromGlobalToOutRange);
+
+                    const drawinglayer::attribute::FillGraphicAttribute
+                        aAdaptedFillGraphicAttribute(getFillGraphic().getGraphic(), aAdaptedRange,
+                                                     getFillGraphic().getTiling(),
+                                                     getFillGraphic().getOffsetX(),
+                                                     getFillGraphic().getOffsetY());
+
+                    xSubRef = new FillGraphicPrimitive2D(aNewObjectTransform,
+                                                         aAdaptedFillGraphicAttribute);
+                }
+                else
+                {
+                    xSubRef = new FillGraphicPrimitive2D(aNewObjectTransform, getFillGraphic());
+                }
+
+                // embed to mask primitive
+                rContainer.push_back(
+                    new MaskPrimitive2D(getB2DPolyPolygon(), Primitive2DContainer{ xSubRef }));
+            }
+        }
+    }
+}
+
+PolyPolygonGraphicPrimitive2D::PolyPolygonGraphicPrimitive2D(
+    const basegfx::B2DPolyPolygon& rPolyPolygon, const basegfx::B2DRange& rDefinitionRange,
+    const attribute::FillGraphicAttribute& rFillGraphic)
+    : BufferedDecompositionPrimitive2D()
+    , maPolyPolygon(rPolyPolygon)
+    , maDefinitionRange(rDefinitionRange)
+    , maFillGraphic(rFillGraphic)
+{
+}
+
+bool PolyPolygonGraphicPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
+{
+    if (BufferedDecompositionPrimitive2D::operator==(rPrimitive))
+    {
+        const PolyPolygonGraphicPrimitive2D& rCompare
+            = static_cast<const PolyPolygonGraphicPrimitive2D&>(rPrimitive);
+
+        return (getB2DPolyPolygon() == rCompare.getB2DPolyPolygon()
+                && getDefinitionRange() == rCompare.getDefinitionRange()
+                && getFillGraphic() == rCompare.getFillGraphic());
+    }
+
+    return false;
+}
+
+// provide unique ID
+sal_uInt32 PolyPolygonGraphicPrimitive2D::getPrimitive2DID() const
+{
+    return PRIMITIVE2D_ID_POLYPOLYGONGRAPHICPRIMITIVE2D;
+}
+
+} // end drawinglayer::primitive2d namespace
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/drawinglayer/source/primitive2d/PolyPolygonHairlinePrimitive2D.cxx b/drawinglayer/source/primitive2d/PolyPolygonHairlinePrimitive2D.cxx
new file mode 100644
index 000000000000..e4c73f9191a5
--- /dev/null
+++ b/drawinglayer/source/primitive2d/PolyPolygonHairlinePrimitive2D.cxx
@@ -0,0 +1,83 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <drawinglayer/primitive2d/PolyPolygonHairlinePrimitive2D.hxx>
+
+#include <basegfx/polygon/b2dpolypolygontools.hxx>
+#include <drawinglayer/primitive2d/drawinglayer_primitivetypes2d.hxx>
+#include <drawinglayer/primitive2d/polygonprimitive2d.hxx>
+
+using namespace com::sun::star;
+
+namespace drawinglayer::primitive2d
+{
+void PolyPolygonHairlinePrimitive2D::create2DDecomposition(
+    Primitive2DContainer& rContainer, const geometry::ViewInformation2D& /*rViewInformation*/) const
+{
+    const basegfx::B2DPolyPolygon aPolyPolygon(getB2DPolyPolygon());
+    const sal_uInt32 nCount(aPolyPolygon.count());
+
+    if (nCount)
+    {
+        for (sal_uInt32 a(0); a < nCount; a++)
+        {
+            rContainer.push_back(
+                new PolygonHairlinePrimitive2D(aPolyPolygon.getB2DPolygon(a), getBColor()));
+        }
+    }
+}
+
+PolyPolygonHairlinePrimitive2D::PolyPolygonHairlinePrimitive2D(
+    const basegfx::B2DPolyPolygon& rPolyPolygon, const basegfx::BColor& rBColor)
+    : BufferedDecompositionPrimitive2D()
+    , maPolyPolygon(rPolyPolygon)
+    , maBColor(rBColor)
+{
+}
+
+bool PolyPolygonHairlinePrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
+{
+    if (BufferedDecompositionPrimitive2D::operator==(rPrimitive))
+    {
+        const PolyPolygonHairlinePrimitive2D& rCompare
+            = static_cast<const PolyPolygonHairlinePrimitive2D&>(rPrimitive);
+
+        return (getB2DPolyPolygon() == rCompare.getB2DPolyPolygon()
+                && getBColor() == rCompare.getBColor());
+    }
+
+    return false;
+}
+
+basegfx::B2DRange PolyPolygonHairlinePrimitive2D::getB2DRange(
+    const geometry::ViewInformation2D& /*rViewInformation*/) const
+{
+    // return range
+    return basegfx::utils::getRange(getB2DPolyPolygon());
+}
+
+// provide unique ID
+sal_uInt32 PolyPolygonHairlinePrimitive2D::getPrimitive2DID() const
+{
+    return PRIMITIVE2D_ID_POLYPOLYGONHAIRLINEPRIMITIVE2D;
+}
+
+} // end drawinglayer::primitive2d namespace
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/drawinglayer/source/primitive2d/PolyPolygonHatchPrimitive2D.cxx b/drawinglayer/source/primitive2d/PolyPolygonHatchPrimitive2D.cxx
new file mode 100644
index 000000000000..17140a549436
--- /dev/null
+++ b/drawinglayer/source/primitive2d/PolyPolygonHatchPrimitive2D.cxx
@@ -0,0 +1,93 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <drawinglayer/primitive2d/PolyPolygonHatchPrimitive2D.hxx>
+
+#include <drawinglayer/primitive2d/drawinglayer_primitivetypes2d.hxx>
+#include <drawinglayer/primitive2d/maskprimitive2d.hxx>
+#include <primitive2d/fillhatchprimitive2d.hxx>
+
+using namespace com::sun::star;
+
+namespace drawinglayer::primitive2d
+{
+void PolyPolygonHatchPrimitive2D::create2DDecomposition(
+    Primitive2DContainer& rContainer, const geometry::ViewInformation2D& /*rViewInformation*/) const
+{
+    if (!getFillHatch().isDefault())
+    {
+        // create SubSequence with FillHatchPrimitive2D
+        const basegfx::B2DRange aPolyPolygonRange(getB2DPolyPolygon().getB2DRange());
+        FillHatchPrimitive2D* pNewHatch = new FillHatchPrimitive2D(
+            aPolyPolygonRange, getDefinitionRange(), getBackgroundColor(), getFillHatch());
+        const Primitive2DReference xSubRef(pNewHatch);
+        const Primitive2DContainer aSubSequence{ xSubRef };
+
+        // create mask primitive
+        rContainer.push_back(new MaskPrimitive2D(getB2DPolyPolygon(), aSubSequence));
+    }
+}
+
+PolyPolygonHatchPrimitive2D::PolyPolygonHatchPrimitive2D(
+    const basegfx::B2DPolyPolygon& rPolyPolygon, const basegfx::BColor& rBackgroundColor,
+    const attribute::FillHatchAttribute& rFillHatch)
+    : BufferedDecompositionPrimitive2D()
+    , maPolyPolygon(rPolyPolygon)
+    , maDefinitionRange(rPolyPolygon.getB2DRange())
+    , maBackgroundColor(rBackgroundColor)
+    , maFillHatch(rFillHatch)
+{
+}
+
+PolyPolygonHatchPrimitive2D::PolyPolygonHatchPrimitive2D(
+    const basegfx::B2DPolyPolygon& rPolyPolygon, const basegfx::B2DRange& rDefinitionRange,
+    const basegfx::BColor& rBackgroundColor, const attribute::FillHatchAttribute& rFillHatch)
+    : BufferedDecompositionPrimitive2D()
+    , maPolyPolygon(rPolyPolygon)
+    , maDefinitionRange(rDefinitionRange)
+    , maBackgroundColor(rBackgroundColor)
+    , maFillHatch(rFillHatch)
+{
+}
+
+bool PolyPolygonHatchPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
+{
+    if (BufferedDecompositionPrimitive2D::operator==(rPrimitive))
+    {
+        const PolyPolygonHatchPrimitive2D& rCompare
+            = static_cast<const PolyPolygonHatchPrimitive2D&>(rPrimitive);
+
+        return (getB2DPolyPolygon() == rCompare.getB2DPolyPolygon()
+                && getDefinitionRange() == rCompare.getDefinitionRange()
+                && getBackgroundColor() == rCompare.getBackgroundColor()
+                && getFillHatch() == rCompare.getFillHatch());
+    }
+
+    return false;
+}
+
+// provide unique ID
+sal_uInt32 PolyPolygonHatchPrimitive2D::getPrimitive2DID() const
+{
+    return PRIMITIVE2D_ID_POLYPOLYGONHATCHPRIMITIVE2D;
+}
+
+} // end drawinglayer::primitive2d namespace
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/drawinglayer/source/primitive2d/PolyPolygonMarkerPrimitive2D.cxx b/drawinglayer/source/primitive2d/PolyPolygonMarkerPrimitive2D.cxx
new file mode 100644
index 000000000000..b545ec9465fa
--- /dev/null
+++ b/drawinglayer/source/primitive2d/PolyPolygonMarkerPrimitive2D.cxx
@@ -0,0 +1,89 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <drawinglayer/primitive2d/PolyPolygonMarkerPrimitive2D.hxx>
+
+#include <basegfx/polygon/b2dpolypolygontools.hxx>
+#include <drawinglayer/primitive2d/drawinglayer_primitivetypes2d.hxx>
+#include <drawinglayer/primitive2d/polygonprimitive2d.hxx>
+
+using namespace com::sun::star;
+
+namespace drawinglayer::primitive2d
+{
+void PolyPolygonMarkerPrimitive2D::create2DDecomposition(
+    Primitive2DContainer& rContainer, const geometry::ViewInformation2D& /*rViewInformation*/) const
+{
+    const basegfx::B2DPolyPolygon aPolyPolygon(getB2DPolyPolygon());
+    const sal_uInt32 nCount(aPolyPolygon.count());
+
+    if (nCount)
+    {
+        for (sal_uInt32 a(0); a < nCount; a++)
+        {
+            rContainer.push_back(new PolygonMarkerPrimitive2D(aPolyPolygon.getB2DPolygon(a),
+                                                              getRGBColorA(), getRGBColorB(),
+                                                              getDiscreteDashLength()));
+        }
+    }
+}
+
+PolyPolygonMarkerPrimitive2D::PolyPolygonMarkerPrimitive2D(
+    const basegfx::B2DPolyPolygon& rPolyPolygon, const basegfx::BColor& rRGBColorA,
+    const basegfx::BColor& rRGBColorB, double fDiscreteDashLength)
+    : BufferedDecompositionPrimitive2D()
+    , maPolyPolygon(rPolyPolygon)
+    , maRGBColorA(rRGBColorA)
+    , maRGBColorB(rRGBColorB)
+    , mfDiscreteDashLength(fDiscreteDashLength)
+{
+}
+
+bool PolyPolygonMarkerPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
+{
+    if (BufferedDecompositionPrimitive2D::operator==(rPrimitive))
+    {
+        const PolyPolygonMarkerPrimitive2D& rCompare
+            = static_cast<const PolyPolygonMarkerPrimitive2D&>(rPrimitive);
+
+        return (getB2DPolyPolygon() == rCompare.getB2DPolyPolygon()
+                && getRGBColorA() == rCompare.getRGBColorA()
+                && getRGBColorB() == rCompare.getRGBColorB()
+                && getDiscreteDashLength() == rCompare.getDiscreteDashLength());
+    }
+
+    return false;
+}
+
+basegfx::B2DRange PolyPolygonMarkerPrimitive2D::getB2DRange(
+    const geometry::ViewInformation2D& /*rViewInformation*/) const
+{
+    // return range
+    return basegfx::utils::getRange(getB2DPolyPolygon());
+}
+
+// provide unique ID
+sal_uInt32 PolyPolygonMarkerPrimitive2D::getPrimitive2DID() const
+{
+    return PRIMITIVE2D_ID_POLYPOLYGONMARKERPRIMITIVE2D;
+}
+
+} // end drawinglayer::primitive2d namespace
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/drawinglayer/source/primitive2d/PolyPolygonSelectionPrimitive2D.cxx b/drawinglayer/source/primitive2d/PolyPolygonSelectionPrimitive2D.cxx
new file mode 100644
index 000000000000..7be684c2f71e
--- /dev/null
+++ b/drawinglayer/source/primitive2d/PolyPolygonSelectionPrimitive2D.cxx
@@ -0,0 +1,126 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <drawinglayer/primitive2d/PolyPolygonSelectionPrimitive2D.hxx>
+
+#include <basegfx/polygon/b2dpolypolygontools.hxx>
+#include <drawinglayer/primitive2d/drawinglayer_primitivetypes2d.hxx>
+#include <drawinglayer/geometry/viewinformation2d.hxx>
+#include <drawinglayer/primitive2d/PolyPolygonColorPrimitive2D.hxx>
+#include <drawinglayer/primitive2d/PolyPolygonStrokePrimitive2D.hxx>
+#include <drawinglayer/primitive2d/unifiedtransparenceprimitive2d.hxx>
+
+using namespace com::sun::star;
+
+namespace drawinglayer::primitive2d
+{
+void PolyPolygonSelectionPrimitive2D::create2DDecomposition(
+    Primitive2DContainer& rContainer, const geometry::ViewInformation2D& /*rViewInformation*/) const
+{
+    if (getTransparence() >= 1.0 || !getB2DPolyPolygon().count())
+        return;
+
+    Primitive2DContainer aRetval;
+
+    if (getFill() && getB2DPolyPolygon().isClosed())
+    {
+        // create fill primitive
+        const Primitive2DReference aFill(
+            new PolyPolygonColorPrimitive2D(getB2DPolyPolygon(), getColor()));
+
+        aRetval = Primitive2DContainer{ aFill };
+    }
+
+    if (getDiscreteGrow() > 0.0)
+    {
+        const attribute::LineAttribute aLineAttribute(getColor(),
+                                                      getDiscreteGrow() * getDiscreteUnit() * 2.0);
+        const Primitive2DReference aFatLine(
+            new PolyPolygonStrokePrimitive2D(getB2DPolyPolygon(), aLineAttribute));
+
+        aRetval.push_back(aFatLine);
+    }
+
+    // embed filled to transparency (if used)
+    if (!aRetval.empty() && getTransparence() > 0.0)
+    {
+        const Primitive2DReference aTrans(
+            new UnifiedTransparencePrimitive2D(aRetval, getTransparence()));
+
+        aRetval = Primitive2DContainer{ aTrans };
+    }
+
+    rContainer.insert(rContainer.end(), aRetval.begin(), aRetval.end());
+}
+
+PolyPolygonSelectionPrimitive2D::PolyPolygonSelectionPrimitive2D(
+    const basegfx::B2DPolyPolygon& rPolyPolygon, const basegfx::BColor& rColor,
+    double fTransparence, double fDiscreteGrow, bool bFill)
+    : DiscreteMetricDependentPrimitive2D()
+    , maPolyPolygon(rPolyPolygon)
+    , maColor(rColor)
+    , mfTransparence(fTransparence)
+    , mfDiscreteGrow(fabs(fDiscreteGrow))
+    , mbFill(bFill)
+{
+}
+
+bool PolyPolygonSelectionPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
+{
+    if (DiscreteMetricDependentPrimitive2D::operator==(rPrimitive))
+    {
+        const PolyPolygonSelectionPrimitive2D& rCompare
+            = static_cast<const PolyPolygonSelectionPrimitive2D&>(rPrimitive);
+
+        return (
+            getB2DPolyPolygon() == rCompare.getB2DPolyPolygon() && getColor() == rCompare.getColor()
+            && getTransparence() == rCompare.getTransparence()
+            && getDiscreteGrow() == rCompare.getDiscreteGrow() && getFill() == rCompare.getFill());
+    }
+
+    return false;
+}
+
+basegfx::B2DRange PolyPolygonSelectionPrimitive2D::getB2DRange(
+    const geometry::ViewInformation2D& rViewInformation) const
+{
+    basegfx::B2DRange aRetval(basegfx::utils::getRange(getB2DPolyPolygon()));
+
+    if (getDiscreteGrow() > 0.0)
+    {
+        // get the current DiscreteUnit (not sure if getDiscreteUnit() is updated here, better go safe way)
+        const double fDiscreteUnit(
+            (rViewInformation.getInverseObjectToViewTransformation() * basegfx::B2DVector(1.0, 0.0))
+                .getLength());
+
+        aRetval.grow(fDiscreteUnit * getDiscreteGrow());
+    }
+
+    return aRetval;
+}
+
+// provide unique ID
+sal_uInt32 PolyPolygonSelectionPrimitive2D::getPrimitive2DID() const
+{
+    return PRIMITIVE2D_ID_POLYPOLYGONSELECTIONPRIMITIVE2D;
+}
+
+} // end drawinglayer::primitive2d namespace
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/drawinglayer/source/primitive2d/PolyPolygonStrokePrimitive2D.cxx b/drawinglayer/source/primitive2d/PolyPolygonStrokePrimitive2D.cxx
new file mode 100644
index 000000000000..53abec1138c3
--- /dev/null
+++ b/drawinglayer/source/primitive2d/PolyPolygonStrokePrimitive2D.cxx
@@ -0,0 +1,103 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <drawinglayer/primitive2d/PolyPolygonStrokePrimitive2D.hxx>
+
+#include <basegfx/polygon/b2dpolypolygontools.hxx>
+#include <drawinglayer/primitive2d/drawinglayer_primitivetypes2d.hxx>
+#include <drawinglayer/primitive2d/polygonprimitive2d.hxx>
+
+using namespace com::sun::star;
+
+namespace drawinglayer::primitive2d
+{
+void PolyPolygonStrokePrimitive2D::create2DDecomposition(
+    Primitive2DContainer& rContainer, const geometry::ViewInformation2D& /*rViewInformation*/) const
+{
+    const basegfx::B2DPolyPolygon aPolyPolygon(getB2DPolyPolygon());
+    const sal_uInt32 nCount(aPolyPolygon.count());
+
+    if (nCount)
+    {
+        for (sal_uInt32 a(0); a < nCount; a++)
+        {
+            rContainer.push_back(new PolygonStrokePrimitive2D(
+                aPolyPolygon.getB2DPolygon(a), getLineAttribute(), getStrokeAttribute()));
+        }
+    }
+}
+
+PolyPolygonStrokePrimitive2D::PolyPolygonStrokePrimitive2D(
+    const basegfx::B2DPolyPolygon& rPolyPolygon, const attribute::LineAttribute& rLineAttribute,
+    const attribute::StrokeAttribute& rStrokeAttribute)
+    : BufferedDecompositionPrimitive2D()
+    , maPolyPolygon(rPolyPolygon)
+    , maLineAttribute(rLineAttribute)
+    , maStrokeAttribute(rStrokeAttribute)
+{
+}
+
+PolyPolygonStrokePrimitive2D::PolyPolygonStrokePrimitive2D(
+    const basegfx::B2DPolyPolygon& rPolyPolygon, const attribute::LineAttribute& rLineAttribute)
+    : BufferedDecompositionPrimitive2D()
+    , maPolyPolygon(rPolyPolygon)
+    , maLineAttribute(rLineAttribute)
+    , maStrokeAttribute()
+{
+}
+
+bool PolyPolygonStrokePrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
+{
+    if (BufferedDecompositionPrimitive2D::operator==(rPrimitive))
+    {
+        const PolyPolygonStrokePrimitive2D& rCompare
+            = static_cast<const PolyPolygonStrokePrimitive2D&>(rPrimitive);
+
+        return (getB2DPolyPolygon() == rCompare.getB2DPolyPolygon()
+                && getLineAttribute() == rCompare.getLineAttribute()
+                && getStrokeAttribute() == rCompare.getStrokeAttribute());
+    }
+
+    return false;
+}
+
+basegfx::B2DRange PolyPolygonStrokePrimitive2D::getB2DRange(
+    const geometry::ViewInformation2D& /*rViewInformation*/) const
+{
+    // get range of it (subdivided)
+    basegfx::B2DRange aRetval(basegfx::utils::getRange(getB2DPolyPolygon()));
+
+    // if width, grow by line width
+    if (getLineAttribute().getWidth())
+    {
+        aRetval.grow(getLineAttribute().getWidth() / 2.0);
+    }
+
+    return aRetval;
+}
+
+// provide unique ID
+sal_uInt32 PolyPolygonStrokePrimitive2D::getPrimitive2DID() const
+{
+    return PRIMITIVE2D_ID_POLYPOLYGONSTROKEPRIMITIVE2D;
+}
+
+} // end drawinglayer::primitive2d namespace
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/drawinglayer/source/primitive2d/polypolygonprimitive2d.cxx b/drawinglayer/source/primitive2d/polypolygonprimitive2d.cxx
deleted file mode 100644
index 02e3d5705f95..000000000000
--- a/drawinglayer/source/primitive2d/polypolygonprimitive2d.cxx
+++ /dev/null
@@ -1,572 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/*
- * This file is part of the LibreOffice project.
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- *
- * This file incorporates work covered by the following license notice:
- *
- *   Licensed to the Apache Software Foundation (ASF) under one or more
- *   contributor license agreements. See the NOTICE file distributed
- *   with this work for additional information regarding copyright
- *   ownership. The ASF licenses this file to you under the Apache
- *   License, Version 2.0 (the "License"); you may not use this file
- *   except in compliance with the License. You may obtain a copy of
- *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
- */
-
-#include <drawinglayer/primitive2d/PolyPolygonHairlinePrimitive2D.hxx>
-#include <drawinglayer/primitive2d/PolyPolygonMarkerPrimitive2D.hxx>
-#include <drawinglayer/primitive2d/PolyPolygonStrokePrimitive2D.hxx>
-#include <drawinglayer/primitive2d/PolyPolygonColorPrimitive2D.hxx>
-#include <drawinglayer/primitive2d/PolyPolygonGradientPrimitive2D.hxx>
-#include <drawinglayer/primitive2d/PolyPolygonHatchPrimitive2D.hxx>
-#include <drawinglayer/primitive2d/PolyPolygonGraphicPrimitive2D.hxx>
-#include <drawinglayer/primitive2d/PolyPolygonSelectionPrimitive2D.hxx>
-
-#include <basegfx/polygon/b2dpolypolygontools.hxx>
-#include <drawinglayer/primitive2d/fillgradientprimitive2d.hxx>
-#include <drawinglayer/primitive2d/maskprimitive2d.hxx>
-#include <primitive2d/fillhatchprimitive2d.hxx>
-#include <basegfx/matrix/b2dhommatrix.hxx>
-#include <drawinglayer/primitive2d/fillgraphicprimitive2d.hxx>
-#include <drawinglayer/primitive2d/polygonprimitive2d.hxx>
-#include <drawinglayer/primitive2d/drawinglayer_primitivetypes2d.hxx>
-#include <basegfx/matrix/b2dhommatrixtools.hxx>
-#include <drawinglayer/primitive2d/unifiedtransparenceprimitive2d.hxx>
-#include <drawinglayer/geometry/viewinformation2d.hxx>
-#include <vcl/graph.hxx>
-
-using namespace com::sun::star;
-
-namespace drawinglayer::primitive2d
-{
-void PolyPolygonHairlinePrimitive2D::create2DDecomposition(
-    Primitive2DContainer& rContainer, const geometry::ViewInformation2D& /*rViewInformation*/) const
-{
-    const basegfx::B2DPolyPolygon aPolyPolygon(getB2DPolyPolygon());
-    const sal_uInt32 nCount(aPolyPolygon.count());
-
-    if (nCount)
-    {
-        for (sal_uInt32 a(0); a < nCount; a++)
-        {
-            rContainer.push_back(
-                new PolygonHairlinePrimitive2D(aPolyPolygon.getB2DPolygon(a), getBColor()));
-        }
-    }
-}
-
-PolyPolygonHairlinePrimitive2D::PolyPolygonHairlinePrimitive2D(
-    const basegfx::B2DPolyPolygon& rPolyPolygon, const basegfx::BColor& rBColor)
-    : BufferedDecompositionPrimitive2D()
-    , maPolyPolygon(rPolyPolygon)
-    , maBColor(rBColor)
-{
-}
-
-bool PolyPolygonHairlinePrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
-{
-    if (BufferedDecompositionPrimitive2D::operator==(rPrimitive))
-    {
-        const PolyPolygonHairlinePrimitive2D& rCompare
-            = static_cast<const PolyPolygonHairlinePrimitive2D&>(rPrimitive);
-
-        return (getB2DPolyPolygon() == rCompare.getB2DPolyPolygon()
-                && getBColor() == rCompare.getBColor());
-    }
-
-    return false;
-}
-
-basegfx::B2DRange PolyPolygonHairlinePrimitive2D::getB2DRange(
-    const geometry::ViewInformation2D& /*rViewInformation*/) const
-{
-    // return range
-    return basegfx::utils::getRange(getB2DPolyPolygon());
-}
-
-// provide unique ID
-sal_uInt32 PolyPolygonHairlinePrimitive2D::getPrimitive2DID() const
-{
-    return PRIMITIVE2D_ID_POLYPOLYGONHAIRLINEPRIMITIVE2D;
-}
-
-void PolyPolygonMarkerPrimitive2D::create2DDecomposition(
-    Primitive2DContainer& rContainer, const geometry::ViewInformation2D& /*rViewInformation*/) const
-{
-    const basegfx::B2DPolyPolygon aPolyPolygon(getB2DPolyPolygon());
-    const sal_uInt32 nCount(aPolyPolygon.count());
-
-    if (nCount)
-    {
-        for (sal_uInt32 a(0); a < nCount; a++)
-        {
-            rContainer.push_back(new PolygonMarkerPrimitive2D(aPolyPolygon.getB2DPolygon(a),
-                                                              getRGBColorA(), getRGBColorB(),
-                                                              getDiscreteDashLength()));
-        }
-    }
-}
-
-PolyPolygonMarkerPrimitive2D::PolyPolygonMarkerPrimitive2D(
-    const basegfx::B2DPolyPolygon& rPolyPolygon, const basegfx::BColor& rRGBColorA,
-    const basegfx::BColor& rRGBColorB, double fDiscreteDashLength)
-    : BufferedDecompositionPrimitive2D()
-    , maPolyPolygon(rPolyPolygon)
-    , maRGBColorA(rRGBColorA)
-    , maRGBColorB(rRGBColorB)
-    , mfDiscreteDashLength(fDiscreteDashLength)
-{
-}
-
-bool PolyPolygonMarkerPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
-{
-    if (BufferedDecompositionPrimitive2D::operator==(rPrimitive))
-    {
-        const PolyPolygonMarkerPrimitive2D& rCompare
-            = static_cast<const PolyPolygonMarkerPrimitive2D&>(rPrimitive);
-
-        return (getB2DPolyPolygon() == rCompare.getB2DPolyPolygon()
-                && getRGBColorA() == rCompare.getRGBColorA()
-                && getRGBColorB() == rCompare.getRGBColorB()
-                && getDiscreteDashLength() == rCompare.getDiscreteDashLength());
-    }
-
-    return false;
-}
-
-basegfx::B2DRange PolyPolygonMarkerPrimitive2D::getB2DRange(
-    const geometry::ViewInformation2D& /*rViewInformation*/) const
-{
-    // return range
-    return basegfx::utils::getRange(getB2DPolyPolygon());
-}
-
-// provide unique ID
-sal_uInt32 PolyPolygonMarkerPrimitive2D::getPrimitive2DID() const
-{
-    return PRIMITIVE2D_ID_POLYPOLYGONMARKERPRIMITIVE2D;
-}
-
-void PolyPolygonStrokePrimitive2D::create2DDecomposition(
-    Primitive2DContainer& rContainer, const geometry::ViewInformation2D& /*rViewInformation*/) const
-{
-    const basegfx::B2DPolyPolygon aPolyPolygon(getB2DPolyPolygon());
-    const sal_uInt32 nCount(aPolyPolygon.count());
-
-    if (nCount)
-    {
-        for (sal_uInt32 a(0); a < nCount; a++)
-        {
-            rContainer.push_back(new PolygonStrokePrimitive2D(
-                aPolyPolygon.getB2DPolygon(a), getLineAttribute(), getStrokeAttribute()));
-        }
-    }
-}
-
-PolyPolygonStrokePrimitive2D::PolyPolygonStrokePrimitive2D(
-    const basegfx::B2DPolyPolygon& rPolyPolygon, const attribute::LineAttribute& rLineAttribute,
-    const attribute::StrokeAttribute& rStrokeAttribute)
-    : BufferedDecompositionPrimitive2D()
-    , maPolyPolygon(rPolyPolygon)
-    , maLineAttribute(rLineAttribute)
-    , maStrokeAttribute(rStrokeAttribute)
-{
-}
-
-PolyPolygonStrokePrimitive2D::PolyPolygonStrokePrimitive2D(
-    const basegfx::B2DPolyPolygon& rPolyPolygon, const attribute::LineAttribute& rLineAttribute)
-    : BufferedDecompositionPrimitive2D()
-    , maPolyPolygon(rPolyPolygon)
-    , maLineAttribute(rLineAttribute)
-    , maStrokeAttribute()
-{
-}
-
-bool PolyPolygonStrokePrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
-{
-    if (BufferedDecompositionPrimitive2D::operator==(rPrimitive))
-    {
-        const PolyPolygonStrokePrimitive2D& rCompare
-            = static_cast<const PolyPolygonStrokePrimitive2D&>(rPrimitive);
-
-        return (getB2DPolyPolygon() == rCompare.getB2DPolyPolygon()
-                && getLineAttribute() == rCompare.getLineAttribute()
-                && getStrokeAttribute() == rCompare.getStrokeAttribute());
-    }
-
-    return false;
-}
-
-basegfx::B2DRange PolyPolygonStrokePrimitive2D::getB2DRange(
-    const geometry::ViewInformation2D& /*rViewInformation*/) const
-{
-    // get range of it (subdivided)
-    basegfx::B2DRange aRetval(basegfx::utils::getRange(getB2DPolyPolygon()));
-
-    // if width, grow by line width
-    if (getLineAttribute().getWidth())
-    {
-        aRetval.grow(getLineAttribute().getWidth() / 2.0);
-    }
-
-    return aRetval;
-}
-
-// provide unique ID
-sal_uInt32 PolyPolygonStrokePrimitive2D::getPrimitive2DID() const
-{
-    return PRIMITIVE2D_ID_POLYPOLYGONSTROKEPRIMITIVE2D;
-}
-
-PolyPolygonColorPrimitive2D::PolyPolygonColorPrimitive2D(
-    const basegfx::B2DPolyPolygon& rPolyPolygon, const basegfx::BColor& rBColor)
-    : BasePrimitive2D()
-    , maPolyPolygon(rPolyPolygon)
-    , maBColor(rBColor)
-{
-}
-
-bool PolyPolygonColorPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
-{
-    if (BasePrimitive2D::operator==(rPrimitive))
-    {
-        const PolyPolygonColorPrimitive2D& rCompare
-            = static_cast<const PolyPolygonColorPrimitive2D&>(rPrimitive);
-
-        return (getB2DPolyPolygon() == rCompare.getB2DPolyPolygon()
-                && getBColor() == rCompare.getBColor());
-    }
-
-    return false;
-}
-
-basegfx::B2DRange PolyPolygonColorPrimitive2D::getB2DRange(
-    const geometry::ViewInformation2D& /*rViewInformation*/) const
-{
-    // return range
-    return basegfx::utils::getRange(getB2DPolyPolygon());
-}
-
-// provide unique ID
-sal_uInt32 PolyPolygonColorPrimitive2D::getPrimitive2DID() const
-{
-    return PRIMITIVE2D_ID_POLYPOLYGONCOLORPRIMITIVE2D;
-}
-
-void PolyPolygonGradientPrimitive2D::create2DDecomposition(
-    Primitive2DContainer& rContainer, const geometry::ViewInformation2D& /*rViewInformation*/) const
-{
-    if (!getFillGradient().isDefault())
-    {
-        // create SubSequence with FillGradientPrimitive2D
-        const basegfx::B2DRange aPolyPolygonRange(getB2DPolyPolygon().getB2DRange());
-        FillGradientPrimitive2D* pNewGradient = new FillGradientPrimitive2D(
-            aPolyPolygonRange, getDefinitionRange(), getFillGradient());
-        const Primitive2DReference xSubRef(pNewGradient);
-        const Primitive2DContainer aSubSequence{ xSubRef };
-
-        // create mask primitive
-        rContainer.push_back(new MaskPrimitive2D(getB2DPolyPolygon(), aSubSequence));
-    }
-}
-
-PolyPolygonGradientPrimitive2D::PolyPolygonGradientPrimitive2D(
-    const basegfx::B2DPolyPolygon& rPolyPolygon,
-    const attribute::FillGradientAttribute& rFillGradient)
-    : BufferedDecompositionPrimitive2D()
-    , maPolyPolygon(rPolyPolygon)
-    , maDefinitionRange(rPolyPolygon.getB2DRange())
-    , maFillGradient(rFillGradient)
-{
-}
-
-PolyPolygonGradientPrimitive2D::PolyPolygonGradientPrimitive2D(
-    const basegfx::B2DPolyPolygon& rPolyPolygon, const basegfx::B2DRange& rDefinitionRange,
-    const attribute::FillGradientAttribute& rFillGradient)
-    : BufferedDecompositionPrimitive2D()
-    , maPolyPolygon(rPolyPolygon)
-    , maDefinitionRange(rDefinitionRange)
-    , maFillGradient(rFillGradient)
-{
-}
-
-bool PolyPolygonGradientPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
-{
-    if (BufferedDecompositionPrimitive2D::operator==(rPrimitive))
-    {
-        const PolyPolygonGradientPrimitive2D& rCompare
-            = static_cast<const PolyPolygonGradientPrimitive2D&>(rPrimitive);
-
-        return (getB2DPolyPolygon() == rCompare.getB2DPolyPolygon()
-                && getDefinitionRange() == rCompare.getDefinitionRange()
-                && getFillGradient() == rCompare.getFillGradient());
-    }
-
-    return false;
-}
-
-// provide unique ID
-sal_uInt32 PolyPolygonGradientPrimitive2D::getPrimitive2DID() const
-{
-    return PRIMITIVE2D_ID_POLYPOLYGONGRADIENTPRIMITIVE2D;
-}
-
-void PolyPolygonHatchPrimitive2D::create2DDecomposition(
-    Primitive2DContainer& rContainer, const geometry::ViewInformation2D& /*rViewInformation*/) const
-{
-    if (!getFillHatch().isDefault())
-    {
-        // create SubSequence with FillHatchPrimitive2D
-        const basegfx::B2DRange aPolyPolygonRange(getB2DPolyPolygon().getB2DRange());
-        FillHatchPrimitive2D* pNewHatch = new FillHatchPrimitive2D(
-            aPolyPolygonRange, getDefinitionRange(), getBackgroundColor(), getFillHatch());
-        const Primitive2DReference xSubRef(pNewHatch);
-        const Primitive2DContainer aSubSequence{ xSubRef };
-
-        // create mask primitive
-        rContainer.push_back(new MaskPrimitive2D(getB2DPolyPolygon(), aSubSequence));
-    }
-}
-
-PolyPolygonHatchPrimitive2D::PolyPolygonHatchPrimitive2D(
-    const basegfx::B2DPolyPolygon& rPolyPolygon, const basegfx::BColor& rBackgroundColor,
-    const attribute::FillHatchAttribute& rFillHatch)
-    : BufferedDecompositionPrimitive2D()
-    , maPolyPolygon(rPolyPolygon)
-    , maDefinitionRange(rPolyPolygon.getB2DRange())
-    , maBackgroundColor(rBackgroundColor)
-    , maFillHatch(rFillHatch)
-{
-}
-
-PolyPolygonHatchPrimitive2D::PolyPolygonHatchPrimitive2D(
-    const basegfx::B2DPolyPolygon& rPolyPolygon, const basegfx::B2DRange& rDefinitionRange,
-    const basegfx::BColor& rBackgroundColor, const attribute::FillHatchAttribute& rFillHatch)
-    : BufferedDecompositionPrimitive2D()
-    , maPolyPolygon(rPolyPolygon)
-    , maDefinitionRange(rDefinitionRange)
-    , maBackgroundColor(rBackgroundColor)
-    , maFillHatch(rFillHatch)
-{
-}
-
-bool PolyPolygonHatchPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
-{
-    if (BufferedDecompositionPrimitive2D::operator==(rPrimitive))
-    {
-        const PolyPolygonHatchPrimitive2D& rCompare
-            = static_cast<const PolyPolygonHatchPrimitive2D&>(rPrimitive);
-
-        return (getB2DPolyPolygon() == rCompare.getB2DPolyPolygon()
-                && getDefinitionRange() == rCompare.getDefinitionRange()
-                && getBackgroundColor() == rCompare.getBackgroundColor()
-                && getFillHatch() == rCompare.getFillHatch());
-    }
-
-    return false;
-}
-
-// provide unique ID
-sal_uInt32 PolyPolygonHatchPrimitive2D::getPrimitive2DID() const
-{
-    return PRIMITIVE2D_ID_POLYPOLYGONHATCHPRIMITIVE2D;
-}
-
-void PolyPolygonGraphicPrimitive2D::create2DDecomposition(
-    Primitive2DContainer& rContainer, const geometry::ViewInformation2D& /*rViewInformation*/) const
-{
-    if (!getFillGraphic().isDefault())
-    {
-        const Graphic& rGraphic = getFillGraphic().getGraphic();
-        const GraphicType aType(rGraphic.GetType());
-
-        // is there a bitmap or a metafile (do we have content)?
-        if (GraphicType::Bitmap == aType || GraphicType::GdiMetafile == aType)
-        {
-            const Size aPrefSize(rGraphic.GetPrefSize());
-
-            // does content have a size?
-            if (aPrefSize.Width() && aPrefSize.Height())
-            {
-                // create SubSequence with FillGraphicPrimitive2D based on polygon range
-                const basegfx::B2DRange aOutRange(getB2DPolyPolygon().getB2DRange());
-                const basegfx::B2DHomMatrix aNewObjectTransform(
-                    basegfx::utils::createScaleTranslateB2DHomMatrix(aOutRange.getRange(),
-                                                                     aOutRange.getMinimum()));
-                Primitive2DReference xSubRef;
-
-                if (aOutRange != getDefinitionRange())
-                {
-                    // we want to paint (tiled) content which is defined relative to DefinitionRange
-                    // with the same tiling and offset(s) in the target range of the geometry (the
-                    // polygon). The range given in the local FillGraphicAttribute defines the position
-                    // of the graphic in unit coordinates relative to the DefinitionRange. Transform
-                    // this using DefinitionRange to get to the global definition and then with the
-                    // inverse transformation from the target range to go to unit coordinates relative
-                    // to that target coordinate system.
-                    basegfx::B2DRange aAdaptedRange(getFillGraphic().getGraphicRange());
-
-                    const basegfx::B2DHomMatrix aFromDefinitionRangeToGlobal(
-                        basegfx::utils::createScaleTranslateB2DHomMatrix(
-                            getDefinitionRange().getRange(), getDefinitionRange().getMinimum()));
-
-                    aAdaptedRange.transform(aFromDefinitionRangeToGlobal);
-
-                    basegfx::B2DHomMatrix aFromGlobalToOutRange(
-                        basegfx::utils::createScaleTranslateB2DHomMatrix(aOutRange.getRange(),
-                                                                         aOutRange.getMinimum()));
-                    aFromGlobalToOutRange.invert();
-
-                    aAdaptedRange.transform(aFromGlobalToOutRange);
-
-                    const drawinglayer::attribute::FillGraphicAttribute
-                        aAdaptedFillGraphicAttribute(getFillGraphic().getGraphic(), aAdaptedRange,
-                                                     getFillGraphic().getTiling(),
-                                                     getFillGraphic().getOffsetX(),
-                                                     getFillGraphic().getOffsetY());
-
-                    xSubRef = new FillGraphicPrimitive2D(aNewObjectTransform,
-                                                         aAdaptedFillGraphicAttribute);
-                }
-                else
-                {
-                    xSubRef = new FillGraphicPrimitive2D(aNewObjectTransform, getFillGraphic());
-                }
-
-                // embed to mask primitive
-                rContainer.push_back(
-                    new MaskPrimitive2D(getB2DPolyPolygon(), Primitive2DContainer{ xSubRef }));
-            }
-        }
-    }
-}
-
-PolyPolygonGraphicPrimitive2D::PolyPolygonGraphicPrimitive2D(
-    const basegfx::B2DPolyPolygon& rPolyPolygon, const basegfx::B2DRange& rDefinitionRange,
-    const attribute::FillGraphicAttribute& rFillGraphic)
-    : BufferedDecompositionPrimitive2D()
-    , maPolyPolygon(rPolyPolygon)
-    , maDefinitionRange(rDefinitionRange)
-    , maFillGraphic(rFillGraphic)
-{
-}
-
-bool PolyPolygonGraphicPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
-{
-    if (BufferedDecompositionPrimitive2D::operator==(rPrimitive))
-    {
-        const PolyPolygonGraphicPrimitive2D& rCompare
-            = static_cast<const PolyPolygonGraphicPrimitive2D&>(rPrimitive);
-
-        return (getB2DPolyPolygon() == rCompare.getB2DPolyPolygon()
-                && getDefinitionRange() == rCompare.getDefinitionRange()
-                && getFillGraphic() == rCompare.getFillGraphic());
-    }
-
-    return false;
-}
-
-// provide unique ID
-sal_uInt32 PolyPolygonGraphicPrimitive2D::getPrimitive2DID() const
-{
-    return PRIMITIVE2D_ID_POLYPOLYGONGRAPHICPRIMITIVE2D;
-}
-
-void PolyPolygonSelectionPrimitive2D::create2DDecomposition(
-    Primitive2DContainer& rContainer, const geometry::ViewInformation2D& /*rViewInformation*/) const
-{
-    if (getTransparence() >= 1.0 || !getB2DPolyPolygon().count())
-        return;
-
-    Primitive2DContainer aRetval;
-
-    if (getFill() && getB2DPolyPolygon().isClosed())
-    {
-        // create fill primitive
-        const Primitive2DReference aFill(
-            new PolyPolygonColorPrimitive2D(getB2DPolyPolygon(), getColor()));
-
-        aRetval = Primitive2DContainer{ aFill };
-    }
-
-    if (getDiscreteGrow() > 0.0)
-    {
-        const attribute::LineAttribute aLineAttribute(getColor(),
-                                                      getDiscreteGrow() * getDiscreteUnit() * 2.0);
-        const Primitive2DReference aFatLine(
-            new PolyPolygonStrokePrimitive2D(getB2DPolyPolygon(), aLineAttribute));
-
-        aRetval.push_back(aFatLine);
-    }
-
-    // embed filled to transparency (if used)
-    if (!aRetval.empty() && getTransparence() > 0.0)
-    {
-        const Primitive2DReference aTrans(
-            new UnifiedTransparencePrimitive2D(aRetval, getTransparence()));
-
-        aRetval = Primitive2DContainer{ aTrans };
-    }
-
-    rContainer.insert(rContainer.end(), aRetval.begin(), aRetval.end());
-}
-
-PolyPolygonSelectionPrimitive2D::PolyPolygonSelectionPrimitive2D(
-    const basegfx::B2DPolyPolygon& rPolyPolygon, const basegfx::BColor& rColor,
-    double fTransparence, double fDiscreteGrow, bool bFill)
-    : DiscreteMetricDependentPrimitive2D()
-    , maPolyPolygon(rPolyPolygon)
-    , maColor(rColor)
-    , mfTransparence(fTransparence)
-    , mfDiscreteGrow(fabs(fDiscreteGrow))
-    , mbFill(bFill)
-{
-}
-
-bool PolyPolygonSelectionPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
-{
-    if (DiscreteMetricDependentPrimitive2D::operator==(rPrimitive))
-    {
-        const PolyPolygonSelectionPrimitive2D& rCompare
-            = static_cast<const PolyPolygonSelectionPrimitive2D&>(rPrimitive);
-
-        return (
-            getB2DPolyPolygon() == rCompare.getB2DPolyPolygon() && getColor() == rCompare.getColor()
-            && getTransparence() == rCompare.getTransparence()
-            && getDiscreteGrow() == rCompare.getDiscreteGrow() && getFill() == rCompare.getFill());
-    }
-
-    return false;
-}
-
-basegfx::B2DRange PolyPolygonSelectionPrimitive2D::getB2DRange(
-    const geometry::ViewInformation2D& rViewInformation) const
-{
-    basegfx::B2DRange aRetval(basegfx::utils::getRange(getB2DPolyPolygon()));
-
-    if (getDiscreteGrow() > 0.0)
-    {
-        // get the current DiscreteUnit (not sure if getDiscreteUnit() is updated here, better go safe way)
-        const double fDiscreteUnit(
-            (rViewInformation.getInverseObjectToViewTransformation() * basegfx::B2DVector(1.0, 0.0))
-                .getLength());
-
-        aRetval.grow(fDiscreteUnit * getDiscreteGrow());
-    }
-
-    return aRetval;
-}
-
-// provide unique ID
-sal_uInt32 PolyPolygonSelectionPrimitive2D::getPrimitive2DID() const
-{
-    return PRIMITIVE2D_ID_POLYPOLYGONSELECTIONPRIMITIVE2D;
-}
-
-} // end drawinglayer::primitive2d namespace
-
-/* vim:set shiftwidth=4 softtabstop=4 expandtab: */