tdf#69977: uno::Sequence is expensive

when used as a mutable data-structure. Plain std::vector halves the time
taken to display the chart dialog

Create a class to represent the std::vector we are going to be passing
around, and move some of the utility methods into it to make the code
prettier.
Also create an optimised append(&&) method for the common case of
appending small temporaries.

Change-Id: I7f5b43fb4a8a84e40e6a52fcb7e9f974091b4485

drawinglayer/source/drawinglayeruno/xprimitive2drenderer.cxx

@@ -161,8 +161,8 @@ namespace drawinglayer
                     const primitive2d::Primitive2DReference xEmbedRef(
                         new primitive2d::TransformPrimitive2D(
                             aEmbedding,
-                            Primitive2DSequence));
-                    const primitive2d::Primitive2DSequence xEmbedSeq(&xEmbedRef, 1);
+                            primitive2d::Primitive2DContainer()));
+                    const primitive2d::Primitive2DContainer xEmbedSeq { xEmbedRef };
 
                     BitmapEx aBitmapEx(
                         tools::convertToBitmapEx(

drawinglayer/source/primitive2d/animatedprimitive2d.cxx

@@ -35,7 +35,7 @@ namespace drawinglayer
     {
         AnimatedSwitchPrimitive2D::AnimatedSwitchPrimitive2D(
             const animation::AnimationEntry& rAnimationEntry,
-            const Primitive2DSequence& rChildren,
+            const Primitive2DContainer& rChildren,
             bool bIsTextAnimation)
         :   GroupPrimitive2D(rChildren),
             mpAnimationEntry(nullptr),
@@ -63,12 +63,12 @@ namespace drawinglayer
             return false;
         }
 
-        Primitive2DSequence AnimatedSwitchPrimitive2D::get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
+        Primitive2DContainer AnimatedSwitchPrimitive2D::get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
         {
-            if(getChildren().hasElements())
+            if(!getChildren().empty())
             {
                 const double fState(getAnimationEntry().getStateAtTime(rViewInformation.getViewTime()));
-                const sal_uInt32 nLen(getChildren().getLength());
+                const sal_uInt32 nLen(getChildren().size());
                 sal_uInt32 nIndex(basegfx::fround(fState * (double)nLen));
 
                 if(nIndex >= nLen)
@@ -77,10 +77,10 @@ namespace drawinglayer
                 }
 
                 const Primitive2DReference xRef(getChildren()[nIndex], uno::UNO_QUERY_THROW);
-                return Primitive2DSequence(&xRef, 1L);
+                return Primitive2DContainer { xRef };
             }
 
-            return Primitive2DSequence();
+            return Primitive2DContainer();
         }
 
         // provide unique ID
@@ -97,15 +97,15 @@ namespace drawinglayer
     {
         AnimatedBlinkPrimitive2D::AnimatedBlinkPrimitive2D(
             const animation::AnimationEntry& rAnimationEntry,
-            const Primitive2DSequence& rChildren,
+            const Primitive2DContainer& rChildren,
             bool bIsTextAnimation)
         :   AnimatedSwitchPrimitive2D(rAnimationEntry, rChildren, bIsTextAnimation)
         {
         }
 
-        Primitive2DSequence AnimatedBlinkPrimitive2D::get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
+        Primitive2DContainer AnimatedBlinkPrimitive2D::get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
         {
-            if(getChildren().hasElements())
+            if(!getChildren().empty())
             {
                 const double fState(getAnimationEntry().getStateAtTime(rViewInformation.getViewTime()));
 
@@ -115,7 +115,7 @@ namespace drawinglayer
                 }
             }
 
-            return Primitive2DSequence();
+            return Primitive2DContainer();
         }
 
         // provide unique ID
@@ -133,7 +133,7 @@ namespace drawinglayer
         AnimatedInterpolatePrimitive2D::AnimatedInterpolatePrimitive2D(
             const std::vector< basegfx::B2DHomMatrix >& rmMatrixStack,
             const animation::AnimationEntry& rAnimationEntry,
-            const Primitive2DSequence& rChildren,
+            const Primitive2DContainer& rChildren,
             bool bIsTextAnimation)
         :   AnimatedSwitchPrimitive2D(rAnimationEntry, rChildren, bIsTextAnimation),
             maMatrixStack()
@@ -148,7 +148,7 @@ namespace drawinglayer
             }
         }
 
-        Primitive2DSequence AnimatedInterpolatePrimitive2D::get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
+        Primitive2DContainer AnimatedInterpolatePrimitive2D::get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
         {
             const sal_uInt32 nSize(maMatrixStack.size());
 
@@ -195,7 +195,7 @@ namespace drawinglayer
 
                 // create new transform primitive reference, return new sequence
                 const Primitive2DReference xRef(new TransformPrimitive2D(aTargetTransform, getChildren()));
-                return Primitive2DSequence(&xRef, 1L);
+                return Primitive2DContainer { xRef };
             }
             else
             {

drawinglayer/source/primitive2d/backgroundcolorprimitive2d.cxx

@@ -35,17 +35,17 @@ namespace drawinglayer
 {
     namespace primitive2d
     {
-        Primitive2DSequence BackgroundColorPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
+        Primitive2DContainer BackgroundColorPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
         {
             if(!rViewInformation.getViewport().isEmpty())
             {
                 const basegfx::B2DPolygon aOutline(basegfx::tools::createPolygonFromRect(rViewInformation.getViewport()));
                 const Primitive2DReference xRef(new PolyPolygonColorPrimitive2D(basegfx::B2DPolyPolygon(aOutline), getBColor()));
-                return Primitive2DSequence(&xRef, 1L);
+                return Primitive2DContainer { xRef };
             }
             else
             {
-                return Primitive2DSequence();
+                return Primitive2DContainer();
             }
         }
 
@@ -77,17 +77,17 @@ namespace drawinglayer
             return rViewInformation.getViewport();
         }
 
-        Primitive2DSequence BackgroundColorPrimitive2D::get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
+        Primitive2DContainer BackgroundColorPrimitive2D::get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
         {
             ::osl::MutexGuard aGuard( m_aMutex );
 
-            if(getBuffered2DDecomposition().hasElements() && (maLastViewport != rViewInformation.getViewport()))
+            if(!getBuffered2DDecomposition().empty() && (maLastViewport != rViewInformation.getViewport()))
             {
                 // conditions of last local decomposition have changed, delete
-                const_cast< BackgroundColorPrimitive2D* >(this)->setBuffered2DDecomposition(Primitive2DSequence());
+                const_cast< BackgroundColorPrimitive2D* >(this)->setBuffered2DDecomposition(Primitive2DContainer());
             }
 
-            if(!getBuffered2DDecomposition().hasElements())
+            if(getBuffered2DDecomposition().empty())
             {
                 // remember ViewRange
                 const_cast< BackgroundColorPrimitive2D* >(this)->maLastViewport = rViewInformation.getViewport();

drawinglayer/source/primitive2d/baseprimitive2d.cxx

@@ -21,6 +21,7 @@
 #include <drawinglayer/primitive2d/drawinglayer_primitivetypes2d.hxx>
 #include <drawinglayer/geometry/viewinformation2d.hxx>
 #include <basegfx/tools/canvastools.hxx>
+#include <comphelper/sequence.hxx>
 
 
 
@@ -48,18 +49,18 @@ namespace drawinglayer
 
         basegfx::B2DRange BasePrimitive2D::getB2DRange(const geometry::ViewInformation2D& rViewInformation) const
         {
-            return getB2DRangeFromPrimitive2DSequence(get2DDecomposition(rViewInformation), rViewInformation);
+            return get2DDecomposition(rViewInformation).getB2DRange(rViewInformation);
         }
 
-        Primitive2DSequence BasePrimitive2D::get2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
+        Primitive2DContainer BasePrimitive2D::get2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
         {
-            return Primitive2DSequence();
+            return Primitive2DContainer();
         }
 
         Primitive2DSequence SAL_CALL BasePrimitive2D::getDecomposition( const uno::Sequence< beans::PropertyValue >& rViewParameters ) throw ( uno::RuntimeException, std::exception )
         {
             const geometry::ViewInformation2D aViewInformation(rViewParameters);
-            return get2DDecomposition(aViewInformation);
+            return comphelper::containerToSequence(get2DDecomposition(aViewInformation));
         }
 
         css::geometry::RealRectangle2D SAL_CALL BasePrimitive2D::getRange( const uno::Sequence< beans::PropertyValue >& rViewParameters ) throw ( uno::RuntimeException, std::exception )
@@ -76,9 +77,9 @@ namespace drawinglayer
 {
     namespace primitive2d
     {
-        Primitive2DSequence BufferedDecompositionPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
+        Primitive2DContainer BufferedDecompositionPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
         {
-            return Primitive2DSequence();
+            return Primitive2DContainer();
         }
 
         BufferedDecompositionPrimitive2D::BufferedDecompositionPrimitive2D()
@@ -87,13 +88,13 @@ namespace drawinglayer
         {
         }
 
-        Primitive2DSequence BufferedDecompositionPrimitive2D::get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
+        Primitive2DContainer BufferedDecompositionPrimitive2D::get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
         {
             ::osl::MutexGuard aGuard( m_aMutex );
 
-            if(!getBuffered2DDecomposition().hasElements())
+            if(getBuffered2DDecomposition().empty())
             {
-                const Primitive2DSequence aNewSequence(create2DDecomposition(rViewInformation));
+                const Primitive2DContainer aNewSequence(create2DDecomposition(rViewInformation));
                 const_cast< BufferedDecompositionPrimitive2D* >(this)->setBuffered2DDecomposition(aNewSequence);
             }
 
@@ -110,7 +111,7 @@ namespace drawinglayer
     namespace primitive2d
     {
         // convert helper stl vector of primitives to Primitive2DSequence
-        Primitive2DSequence Primitive2DVectorToPrimitive2DSequence(const Primitive2DVector& rSource, bool bInvert)
+        Primitive2DSequence Primitive2DContainerToPrimitive2DSequence(const Primitive2DContainer& rSource, bool bInvert)
         {
             const sal_uInt32 nSize(rSource.size());
             Primitive2DSequence aRetval;
@@ -125,7 +126,26 @@ namespace drawinglayer
             // all entries taken over to Uno References as owners. To avoid
             // errors with users of this mechanism to delete pointers to BasePrimitive2D
             // itself, clear given vector
-            const_cast< Primitive2DVector& >(rSource).clear();
+            const_cast< Primitive2DContainer& >(rSource).clear();
+
+            return aRetval;
+        }
+        Primitive2DContainer Primitive2DContainer::maybeInvert(bool bInvert) const
+        {
+            const sal_uInt32 nSize(size());
+            Primitive2DContainer aRetval;
+
+            aRetval.resize(nSize);
+
+            for(sal_uInt32 a(0); a < nSize; a++)
+            {
+                aRetval[bInvert ? nSize - 1 - a : a] = (*this)[a];
+            }
+
+            // all entries taken over to Uno References as owners. To avoid
+            // errors with users of this mechanism to delete pointers to BasePrimitive2D
+            // itself, clear given vector
+            const_cast< Primitive2DContainer& >(*this).clear();
 
             return aRetval;
         }
@@ -157,13 +177,29 @@ namespace drawinglayer
         }
 
         // get B2DRange from a given Primitive2DSequence
-        basegfx::B2DRange getB2DRangeFromPrimitive2DSequence(const Primitive2DSequence& rCandidate, const geometry::ViewInformation2D& aViewInformation)
+        basegfx::B2DRange Primitive2DContainer::getB2DRange(const geometry::ViewInformation2D& aViewInformation) const
         {
             basegfx::B2DRange aRetval;
 
-            if(rCandidate.hasElements())
+            if(!empty())
             {
-                const sal_Int32 nCount(rCandidate.getLength());
+                const sal_Int32 nCount(this->size());
+
+                for(sal_Int32 a(0L); a < nCount; a++)
+                {
+                    aRetval.expand(getB2DRangeFromPrimitive2DReference((*this)[a], aViewInformation));
+                }
+            }
+
+            return aRetval;
+        }
+        basegfx::B2DRange getB2DRangeFromPrimitive2DSequence(const Primitive2DContainer& rCandidate, const geometry::ViewInformation2D& aViewInformation)
+        {
+            basegfx::B2DRange aRetval;
+
+            if(!rCandidate.empty())
+            {
+                const sal_Int32 nCount(rCandidate.size());
 
                 for(sal_Int32 a(0L); a < nCount; a++)
                 {
@@ -237,6 +273,38 @@ namespace drawinglayer
             return true;
         }
 
+        bool Primitive2DContainer::operator==(const Primitive2DContainer& rB) const
+        {
+            const bool bAHasElements(!empty());
+
+            if(bAHasElements != !rB.empty())
+            {
+                return false;
+            }
+
+            if(!bAHasElements)
+            {
+                return true;
+            }
+
+            const size_t nCount(size());
+
+            if(nCount != rB.size())
+            {
+                return false;
+            }
+
+            for(size_t a(0L); a < nCount; a++)
+            {
+                if(!arePrimitive2DReferencesEqual((*this)[a], rB[a]))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
         // concatenate sequence
         void appendPrimitive2DSequenceToPrimitive2DSequence(Primitive2DSequence& rDest, const Primitive2DSequence& rSource)
         {
@@ -271,6 +339,30 @@ namespace drawinglayer
             }
         }
 
+        void appendPrimitive2DSequenceToPrimitive2DSequence(Primitive2DSequence& rDest, const Primitive2DContainer& rSource)
+        {
+            appendPrimitive2DSequenceToPrimitive2DSequence(rDest, comphelper::containerToSequence(rSource));
+        }
+
+        void Primitive2DContainer::append(const Primitive2DContainer& rSource)
+        {
+            insert(end(), rSource.begin(), rSource.end());
+        }
+/*
+        void Primitive2DContainer::append(Primitive2DContainer&& rSource)
+        {
+            resize(size() + rSource.size());
+            memcpy(data() + size(),
+                   rSource.data(),
+                   rSource.size() * sizeof(Primitive2DReference));
+            memset(reinterpret_cast<void*>(rSource.data()), 0, rSource.size() * sizeof(Primitive2DReference));
+        }
+*/
+        void Primitive2DContainer::append(const Primitive2DSequence& rSource)
+        {
+            std::copy(rSource.begin(), rSource.end(), std::back_inserter(*this));
+        }
+
         // concatenate single Primitive2D
         void appendPrimitive2DReferenceToPrimitive2DSequence(Primitive2DSequence& rDest, const Primitive2DReference& rSource)
         {

drawinglayer/source/primitive2d/borderlineprimitive2d.cxx

@@ -161,9 +161,9 @@ primitive2d::Primitive2DReference makeSolidLinePrimitive(
             return basegfx::B2DPolyPolygon( clipPolygon );
         }
 
-        Primitive2DSequence BorderLinePrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
+        Primitive2DContainer BorderLinePrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
         {
-            Primitive2DSequence xRetval;
+            Primitive2DContainer xRetval;
 
             if(!getStart().equal(getEnd()) && ( isInsideUsed() || isOutsideUsed() ) )
             {
@@ -181,7 +181,7 @@ primitive2d::Primitive2DReference makeSolidLinePrimitive(
                     const basegfx::B2DPoint aTmpStart(getStart() - (fExt * aVector));
                     const basegfx::B2DPoint aTmpEnd(getEnd() + (fExt * aVector));
 
-                    xRetval.realloc(2);
+                    xRetval.resize(2);
 
                     double fLeftWidth = getLeftWidth();
                     bool bLeftHairline = lcl_UseHairline(fLeftWidth, getStart(), getEnd(), rViewInformation);
@@ -239,7 +239,7 @@ primitive2d::Primitive2DReference makeSolidLinePrimitive(
                         aPolygon.append( getStart() );
                         aPolygon.append( getEnd() );
 
-                        xRetval.realloc(1);
+                        xRetval.resize(1);
                         xRetval[0] = Primitive2DReference(new PolygonHairlinePrimitive2D(
                             aPolygon,
                             aColor));
@@ -276,7 +276,7 @@ primitive2d::Primitive2DReference makeSolidLinePrimitive(
                         }
 
                         sal_uInt32 n = aDashed.count();
-                        xRetval.realloc(n);
+                        xRetval.resize(n);
                         for (sal_uInt32 i = 0; i < n; ++i)
                         {
                             basegfx::B2DPolygon aDash = aDashed.getB2DPolygon(i);

drawinglayer/source/primitive2d/controlprimitive2d.cxx

@@ -237,7 +237,7 @@ namespace drawinglayer
             return xRetval;
         }
 
-        Primitive2DSequence ControlPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
+        Primitive2DContainer ControlPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
         {
             // try to create a bitmap decomposition. If that fails for some reason,
             // at least create a replacement decomposition.
@@ -248,7 +248,7 @@ namespace drawinglayer
                 xReference = createPlaceholderDecomposition(rViewInformation);
             }
 
-            return Primitive2DSequence(&xReference, 1L);
+            return Primitive2DContainer { xReference };
         }
 
         ControlPrimitive2D::ControlPrimitive2D(
@@ -329,23 +329,23 @@ namespace drawinglayer
             return aRetval;
         }
 
-        Primitive2DSequence ControlPrimitive2D::get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
+        Primitive2DContainer ControlPrimitive2D::get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
         {
             // this primitive is view-dependent related to the scaling. If scaling has changed,
             // destroy existing decomposition. To detect change, use size of unit size in view coordinates
             ::osl::MutexGuard aGuard( m_aMutex );
             const basegfx::B2DVector aNewScaling(rViewInformation.getObjectToViewTransformation() * basegfx::B2DVector(1.0, 1.0));
 
-            if(getBuffered2DDecomposition().hasElements())
+            if(!getBuffered2DDecomposition().empty())
             {
                 if(!maLastViewScaling.equal(aNewScaling))
                 {
                     // conditions of last local decomposition have changed, delete
-                    const_cast< ControlPrimitive2D* >(this)->setBuffered2DDecomposition(Primitive2DSequence());
+                    const_cast< ControlPrimitive2D* >(this)->setBuffered2DDecomposition(Primitive2DContainer());
                 }
             }
 
-            if(!getBuffered2DDecomposition().hasElements())
+            if(getBuffered2DDecomposition().empty())
             {
                 // remember ViewTransformation
                 const_cast< ControlPrimitive2D* >(this)->maLastViewScaling = aNewScaling;

drawinglayer/source/primitive2d/cropprimitive2d.cxx

@@ -37,7 +37,7 @@ namespace drawinglayer
     namespace primitive2d
     {
         CropPrimitive2D::CropPrimitive2D(
-            const Primitive2DSequence& rChildren,
+            const Primitive2DContainer& rChildren,
             const basegfx::B2DHomMatrix& rTransformation,
             double fCropLeft,
             double fCropTop,
@@ -68,11 +68,11 @@ namespace drawinglayer
             return false;
         }
 
-        Primitive2DSequence CropPrimitive2D::get2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
+        Primitive2DContainer CropPrimitive2D::get2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
         {
-            Primitive2DSequence xRetval;
+            Primitive2DContainer xRetval;
 
-            if(getChildren().hasElements())
+            if(!getChildren().empty())
             {
                 // get original object scale in unit coordinates (no mirroring)
                 const basegfx::B2DVector aObjectScale(basegfx::absolute(getTransformation() * basegfx::B2DVector(1.0, 1.0)));
@@ -130,7 +130,7 @@ namespace drawinglayer
                         {
                             // the new range is completely inside the old range (unit range),
                             // so no masking is needed
-                            xRetval = Primitive2DSequence(&xTransformPrimitive, 1);
+                            xRetval = Primitive2DContainer { xTransformPrimitive };
                         }
                         else
                         {
@@ -142,9 +142,9 @@ namespace drawinglayer
                             const Primitive2DReference xMask(
                                 new MaskPrimitive2D(
                                     aMaskPolyPolygon,
-                                    Primitive2DSequence(&xTransformPrimitive, 1)));
+                                    Primitive2DContainer { xTransformPrimitive }));
 
-                            xRetval = Primitive2DSequence(&xMask, 1);
+                            xRetval = Primitive2DContainer { xMask };
                         }
                     }
                 }

drawinglayer/source/primitive2d/discretebitmapprimitive2d.cxx

@@ -27,12 +27,12 @@ namespace drawinglayer
 {
     namespace primitive2d
     {
-        Primitive2DSequence DiscreteBitmapPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
+        Primitive2DContainer DiscreteBitmapPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
         {
             // use getViewTransformation() and getObjectTransformation() from
             // ObjectAndViewTransformationDependentPrimitive2D to create a BitmapPrimitive2D
             // with the correct mapping
-            Primitive2DSequence xRetval;
+            Primitive2DContainer xRetval;
 
             if(!getBitmapEx().IsEmpty())
             {
@@ -67,7 +67,7 @@ namespace drawinglayer
 
                 // create BitmapPrimitive2D with now object-local coordinate data
                 const Primitive2DReference xRef(new BitmapPrimitive2D(getBitmapEx(), aObjectTransform));
-                xRetval = Primitive2DSequence(&xRef, 1);
+                xRetval = Primitive2DContainer { xRef };
             }
 
             return xRetval;

drawinglayer/source/primitive2d/discreteshadowprimitive2d.cxx

@@ -163,9 +163,9 @@ namespace drawinglayer
 {
     namespace primitive2d
     {
-        Primitive2DSequence DiscreteShadowPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
+        Primitive2DContainer DiscreteShadowPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
         {
-            Primitive2DSequence xRetval;
+            Primitive2DContainer xRetval;
 
             if(!getDiscreteShadow().getBitmapEx().IsEmpty())
             {
@@ -178,7 +178,7 @@ namespace drawinglayer
                 const double fBigLenX((fBorderX * 2.0) + fSingleX);
                 const double fBigLenY((fBorderY * 2.0) + fSingleY);
 
-                xRetval.realloc(8);
+                xRetval.resize(8);
 
                 // TopLeft
                 xRetval[0] = Primitive2DReference(
@@ -266,7 +266,7 @@ namespace drawinglayer
                         getTransform(),
                         xRetval));
 
-                xRetval = Primitive2DSequence(&xTransformed, 1);
+                xRetval = Primitive2DContainer { xTransformed };
             }
 
             return xRetval;

drawinglayer/source/primitive2d/embedded3dprimitive2d.cxx

@@ -62,10 +62,10 @@ namespace drawinglayer
             }
 
             // return if there are shadow primitives
-            return maShadowPrimitives.hasElements();
+            return !maShadowPrimitives.empty();
         }
 
-        Primitive2DSequence Embedded3DPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
+        Primitive2DContainer Embedded3DPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
         {
             // use info to create a yellow 2d rectangle, similar to empty 3d scenes and/or groups
             const basegfx::B2DRange aLocal2DRange(getB2DRange(rViewInformation));
@@ -73,7 +73,7 @@ namespace drawinglayer
             const basegfx::BColor aYellow(1.0, 1.0, 0.0);
             const Primitive2DReference xRef(new PolygonHairlinePrimitive2D(aOutline, aYellow));
 
-            return Primitive2DSequence(&xRef, 1L);
+            return Primitive2DContainer { xRef };
         }
 
         Embedded3DPrimitive2D::Embedded3DPrimitive2D(
@@ -132,7 +132,7 @@ namespace drawinglayer
                 // taken into account
                 if(impGetShadow3D(rViewInformation))
                 {
-                    const basegfx::B2DRange aShadow2DRange(getB2DRangeFromPrimitive2DSequence(maShadowPrimitives, rViewInformation));
+                    const basegfx::B2DRange aShadow2DRange(maShadowPrimitives.getB2DRange(rViewInformation));
 
                     if(!aShadow2DRange.isEmpty())
                     {

drawinglayer/source/primitive2d/epsprimitive2d.cxx

@@ -25,9 +25,9 @@ namespace drawinglayer
 {
     namespace primitive2d
     {
-        Primitive2DSequence EpsPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
+        Primitive2DContainer EpsPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
         {
-            Primitive2DSequence xRetval;
+            Primitive2DContainer xRetval;
             const GDIMetaFile& rSubstituteContent = getMetaFile();
 
             if( rSubstituteContent.GetActionSize() )
@@ -35,7 +35,7 @@ namespace drawinglayer
                 // the default decomposition will use the Metafile replacement visualisation.
                 // To really use the Eps data, a renderer has to know and interpret this primitive
                 // directly.
-                xRetval.realloc(1);
+                xRetval.resize(1);
 
                 xRetval[0] = Primitive2DReference(
                     new MetafilePrimitive2D(

drawinglayer/source/primitive2d/fillgradientprimitive2d.cxx

@@ -150,13 +150,14 @@ namespace drawinglayer
             }
         }
 
-        Primitive2DSequence FillGradientPrimitive2D::createOverlappingFill(
+        Primitive2DContainer FillGradientPrimitive2D::createOverlappingFill(
             const std::vector< drawinglayer::texture::B2DHomMatrixAndBColor >& rEntries,
             const basegfx::BColor& rOuterColor,
             const basegfx::B2DPolygon& rUnitPolygon) const
         {
             // prepare return value
-            Primitive2DSequence aRetval(rEntries.size() + 1);
+            Primitive2DContainer aRetval;
+            aRetval.resize(rEntries.size() + 1);
 
             // create solid fill with outmost color
             aRetval[0] = Primitive2DReference(
@@ -183,13 +184,14 @@ namespace drawinglayer
             return aRetval;
         }
 
-        Primitive2DSequence FillGradientPrimitive2D::createNonOverlappingFill(
+        Primitive2DContainer FillGradientPrimitive2D::createNonOverlappingFill(
             const std::vector< drawinglayer::texture::B2DHomMatrixAndBColor >& rEntries,
             const basegfx::BColor& rOuterColor,
             const basegfx::B2DPolygon& rUnitPolygon) const
         {
             // prepare return value
-            Primitive2DSequence aRetval(rEntries.size() + 1);
+            Primitive2DContainer aRetval;
+            aRetval.resize(rEntries.size() + 1);
 
             // get outmost visible range from object
             basegfx::B2DRange aOutmostRange(getOutputRange());
@@ -245,7 +247,7 @@ namespace drawinglayer
             return aRetval;
         }
 
-        Primitive2DSequence FillGradientPrimitive2D::createFill(bool bOverlapping) const
+        Primitive2DContainer FillGradientPrimitive2D::createFill(bool bOverlapping) const
         {
             // prepare shape of the Unit Polygon
             basegfx::B2DPolygon aUnitPolygon;
@@ -282,7 +284,7 @@ namespace drawinglayer
             }
         }
 
-        Primitive2DSequence FillGradientPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
+        Primitive2DContainer FillGradientPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
         {
             // default creates overlapping fill which works with AntiAliasing and without.
             // The non-overlapping version does not create single filled polygons, but
@@ -299,7 +301,7 @@ namespace drawinglayer
             }
             else
             {
-                return Primitive2DSequence();
+                return Primitive2DContainer();
             }
         }
 

drawinglayer/source/primitive2d/fillgraphicprimitive2d.cxx

@@ -39,9 +39,9 @@ namespace drawinglayer
 {
     namespace primitive2d
     {
-        Primitive2DSequence FillGraphicPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
+        Primitive2DContainer FillGraphicPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
         {
-            Primitive2DSequence aRetval;
+            Primitive2DContainer aRetval;
             const attribute::FillGraphicAttribute& rAttribute = getFillGraphic();
 
             if(!rAttribute.isDefault())
@@ -66,10 +66,10 @@ namespace drawinglayer
 
                             // get matrices and realloc retval
                             aTiling.appendTransformations(aMatrices);
-                            aRetval.realloc(aMatrices.size());
+                            aRetval.resize(aMatrices.size());
 
                             // prepare content primitive
-                            const Primitive2DSequence xSeq = create2DDecompositionOfGraphic(
+                            const Primitive2DContainer xSeq = create2DDecompositionOfGraphic(
                                 rGraphic,
                                 basegfx::B2DHomMatrix());
 

drawinglayer/source/primitive2d/fillhatchprimitive2d.cxx

@@ -37,9 +37,9 @@ namespace drawinglayer
 {
     namespace primitive2d
     {
-        Primitive2DSequence FillHatchPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
+        Primitive2DContainer FillHatchPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
         {
-            Primitive2DSequence aRetval;
+            Primitive2DContainer aRetval;
 
             if(!getFillHatch().isDefault())
             {
@@ -105,7 +105,7 @@ namespace drawinglayer
 
                 // prepare return value
                 const bool bFillBackground(getFillHatch().isFillBackground());
-                aRetval.realloc(bFillBackground ? aMatrices.size() + 1L : aMatrices.size());
+                aRetval.resize(bFillBackground ? aMatrices.size() + 1L : aMatrices.size());
 
                 // evtl. create filled background
                 if(bFillBackground)
@@ -185,7 +185,7 @@ namespace drawinglayer
             return getOutputRange();
         }
 
-        Primitive2DSequence FillHatchPrimitive2D::get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
+        Primitive2DContainer FillHatchPrimitive2D::get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
         {
             ::osl::MutexGuard aGuard( m_aMutex );
             bool bAdaptDistance(0 != getFillHatch().getMinimalDiscreteDistance());

drawinglayer/source/primitive2d/graphicprimitive2d.cxx

@@ -32,10 +32,10 @@ namespace drawinglayer
 {
     namespace primitive2d
     {
-        Primitive2DSequence GraphicPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D&
+        Primitive2DContainer GraphicPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D&
             ) const
         {
-            Primitive2DSequence aRetval;
+            Primitive2DContainer aRetval;
 
             if(255L == getGraphicAttr().GetTransparency())
             {
@@ -110,7 +110,7 @@ namespace drawinglayer
                 aTransformedGraphic,
                 aTransform);
 
-            if(!aRetval.getLength())
+            if(!aRetval.size())
             {
                 // content is invisible, done
                 return aRetval;
@@ -131,7 +131,7 @@ namespace drawinglayer
                     basegfx::clamp(aSuppressGraphicAttr.GetGamma(), 0.0, 10.0),
                     aSuppressGraphicAttr.IsInvert());
 
-                if(!aRetval.getLength())
+                if(!aRetval.size())
                 {
                     // content is invisible, done
                     return aRetval;
@@ -150,7 +150,7 @@ namespace drawinglayer
                             aRetval,
                             fTransparency));
 
-                    aRetval = Primitive2DSequence(&aUnifiedTransparence, 1);
+                    aRetval = Primitive2DContainer { aUnifiedTransparence };
                 }
             }
 
@@ -179,7 +179,7 @@ namespace drawinglayer
                         getGraphicAttr().GetRightCrop() * aCropScaleFactor.getX(),
                         getGraphicAttr().GetBottomCrop() * aCropScaleFactor.getY()));
 
-                aRetval = Primitive2DSequence(&xPrimitive, 1);
+                aRetval = Primitive2DContainer { xPrimitive };
             }
 
             return aRetval;

drawinglayer/source/primitive2d/graphicprimitivehelper2d.cxx

@@ -193,11 +193,11 @@ namespace drawinglayer
 {
     namespace primitive2d
     {
-        Primitive2DSequence create2DDecompositionOfGraphic(
+        Primitive2DContainer create2DDecompositionOfGraphic(
             const Graphic& rGraphic,
             const basegfx::B2DHomMatrix& rTransform)
         {
-            Primitive2DSequence aRetval;
+            Primitive2DContainer aRetval;
 
             switch(rGraphic.GetType())
             {
@@ -212,7 +212,7 @@ namespace drawinglayer
                         {
                             // create sub-primitives for animated bitmap and the needed animation loop
                             animation::AnimationEntryLoop aAnimationLoop(aData.loopCount() ? aData.loopCount() : 0xffff);
-                            Primitive2DSequence aBitmapPrimitives(aData.count());
+                            Primitive2DContainer aBitmapPrimitives(aData.count());
 
                             for(sal_uInt32 a(0); a < aData.count(); a++)
                             {
@@ -228,7 +228,7 @@ namespace drawinglayer
                             aAnimationList.append(aAnimationLoop);
 
                             // create and add animated switch primitive
-                            aRetval.realloc(1);
+                            aRetval.resize(1);
                             aRetval[0] = new AnimatedSwitchPrimitive2D(
                                 aAnimationList,
                                 aBitmapPrimitives,
@@ -256,7 +256,7 @@ namespace drawinglayer
                             aEmbedSvg = rTransform * aEmbedSvg;
 
                             // add Svg primitives embedded
-                            aRetval.realloc(1);
+                            aRetval.resize(1);
                             aRetval[0] = new TransformPrimitive2D(
                                 aEmbedSvg,
                                 rGraphic.getSvgData()->getPrimitive2DSequence());
@@ -264,7 +264,7 @@ namespace drawinglayer
                     }
                     else
                     {
-                        aRetval.realloc(1);
+                        aRetval.resize(1);
                         aRetval[0] = new BitmapPrimitive2D(
                             rGraphic.GetBitmapEx(),
                             rTransform);
@@ -278,7 +278,7 @@ namespace drawinglayer
                     // create MetafilePrimitive2D
                     const GDIMetaFile& rMetafile = rGraphic.GetGDIMetaFile();
 
-                    aRetval.realloc(1);
+                    aRetval.resize(1);
                     aRetval[0] = new MetafilePrimitive2D(
                         rTransform,
                         rMetafile);
@@ -316,8 +316,8 @@ namespace drawinglayer
             return aRetval;
         }
 
-        Primitive2DSequence create2DColorModifierEmbeddingsAsNeeded(
-            const Primitive2DSequence& rChildren,
+        Primitive2DContainer create2DColorModifierEmbeddingsAsNeeded(
+            const Primitive2DContainer& rChildren,
             GraphicDrawMode aGraphicDrawMode,
             double fLuminance,
             double fContrast,
@@ -327,9 +327,9 @@ namespace drawinglayer
             double fGamma,
             bool bInvert)
         {
-            Primitive2DSequence aRetval;
+            Primitive2DContainer aRetval;
 
-            if(!rChildren.getLength())
+            if(!rChildren.size())
             {
                 // no child content, done
                 return aRetval;
@@ -363,7 +363,7 @@ namespace drawinglayer
                             basegfx::BColorModifierSharedPtr(
                                 new basegfx::BColorModifier_gray())));
 
-                    aRetval = Primitive2DSequence(&aPrimitiveGrey, 1);
+                    aRetval = Primitive2DContainer { aPrimitiveGrey };
                     break;
                 }
                 case GRAPHICDRAWMODE_MONO:
@@ -375,7 +375,7 @@ namespace drawinglayer
                             basegfx::BColorModifierSharedPtr(
                                 new basegfx::BColorModifier_black_and_white(0.5))));
 
-                    aRetval = Primitive2DSequence(&aPrimitiveBlackAndWhite, 1);
+                    aRetval = Primitive2DContainer { aPrimitiveBlackAndWhite };
                     break;
                 }
                 // coverity[dead_error_begin] - intentional dead case
@@ -410,7 +410,7 @@ namespace drawinglayer
                                 fLuminance,
                                 fContrast))));
 
-                aRetval = Primitive2DSequence(&aPrimitiveRGBLuminannceContrast, 1);
+                aRetval = Primitive2DContainer { aPrimitiveRGBLuminannceContrast };
             }
 
             // gamma (boolean)
@@ -423,7 +423,7 @@ namespace drawinglayer
                             new basegfx::BColorModifier_gamma(
                                 fGamma))));
 
-                aRetval = Primitive2DSequence(&aPrimitiveGamma, 1);
+                aRetval = Primitive2DContainer { aPrimitiveGamma };
             }
 
             // invert (boolean)
@@ -435,7 +435,7 @@ namespace drawinglayer
                         basegfx::BColorModifierSharedPtr(
                             new basegfx::BColorModifier_invert())));
 
-                aRetval = Primitive2DSequence(&aPrimitiveInvert, 1);
+                aRetval = Primitive2DContainer { aPrimitiveInvert };
             }
 
             return aRetval;

drawinglayer/source/primitive2d/gridprimitive2d.cxx

@@ -35,9 +35,9 @@ namespace drawinglayer
 {
     namespace primitive2d
     {
-        Primitive2DSequence GridPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
+        Primitive2DContainer GridPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
         {
-            Primitive2DSequence aRetval;
+            Primitive2DContainer aRetval;
 
             if(!rViewInformation.getViewport().isEmpty() && getWidth() > 0.0 && getHeight() > 0.0)
             {
@@ -234,7 +234,7 @@ namespace drawinglayer
                     const sal_uInt32 nRetvalCount((nCountPoint ? 1 : 0) + (nCountCross ? 1 : 0));
                     sal_uInt32 nInsertCounter(0);
 
-                    aRetval.realloc(nRetvalCount);
+                    aRetval.resize(nRetvalCount);
 
                     // add PointArrayPrimitive2D if point markers were added
                     if(nCountPoint)
@@ -319,20 +319,20 @@ namespace drawinglayer
             return aUnitRange;
         }
 
-        Primitive2DSequence GridPrimitive2D::get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
+        Primitive2DContainer GridPrimitive2D::get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
         {
             ::osl::MutexGuard aGuard( m_aMutex );
 
-            if(getBuffered2DDecomposition().hasElements())
+            if(!getBuffered2DDecomposition().empty())
             {
                 if(maLastViewport != rViewInformation.getViewport() || maLastObjectToViewTransformation != rViewInformation.getObjectToViewTransformation())
                 {
                     // conditions of last local decomposition have changed, delete
-                    const_cast< GridPrimitive2D* >(this)->setBuffered2DDecomposition(Primitive2DSequence());
+                    const_cast< GridPrimitive2D* >(this)->setBuffered2DDecomposition(Primitive2DContainer());
                 }
             }
 
-            if(!getBuffered2DDecomposition().hasElements())
+            if(getBuffered2DDecomposition().empty())
             {
                 // remember ViewRange and ViewTransformation
                 const_cast< GridPrimitive2D* >(this)->maLastObjectToViewTransformation = rViewInformation.getObjectToViewTransformation();

drawinglayer/source/primitive2d/groupprimitive2d.cxx

@@ -30,7 +30,7 @@ namespace drawinglayer
 {
     namespace primitive2d
     {
-        GroupPrimitive2D::GroupPrimitive2D( const Primitive2DSequence& rChildren )
+        GroupPrimitive2D::GroupPrimitive2D( const Primitive2DContainer& rChildren )
         :   BasePrimitive2D(),
             maChildren(rChildren)
         {
@@ -46,14 +46,14 @@ namespace drawinglayer
             {
                 const GroupPrimitive2D& rCompare = static_cast< const GroupPrimitive2D& >(rPrimitive);
 
-                return (arePrimitive2DSequencesEqual(getChildren(), rCompare.getChildren()));
+                return getChildren() == rCompare.getChildren();
             }
 
             return false;
         }
 
         /// default: just return children, so all renderers not supporting group will use it's content
-        Primitive2DSequence GroupPrimitive2D::get2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
+        Primitive2DContainer GroupPrimitive2D::get2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
         {
             return getChildren();
         }

drawinglayer/source/primitive2d/helplineprimitive2d.cxx

@@ -35,7 +35,7 @@ namespace drawinglayer
 {
     namespace primitive2d
     {
-        Primitive2DSequence HelplinePrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
+        Primitive2DContainer HelplinePrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
         {
             std::vector< BasePrimitive2D* > aTempPrimitiveTarget;
 
@@ -130,7 +130,7 @@ namespace drawinglayer
             }
 
             // prepare return value
-            Primitive2DSequence aRetval(aTempPrimitiveTarget.size());
+            Primitive2DContainer aRetval(aTempPrimitiveTarget.size());
 
             for(size_t a(0); a < aTempPrimitiveTarget.size(); a++)
             {
@@ -177,20 +177,20 @@ namespace drawinglayer
             return false;
         }
 
-        Primitive2DSequence HelplinePrimitive2D::get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
+        Primitive2DContainer HelplinePrimitive2D::get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
         {
             ::osl::MutexGuard aGuard( m_aMutex );
 
-            if(getBuffered2DDecomposition().hasElements())
+            if(!getBuffered2DDecomposition().empty())
             {
                 if(maLastViewport != rViewInformation.getViewport() || maLastObjectToViewTransformation != rViewInformation.getObjectToViewTransformation())
                 {
                     // conditions of last local decomposition have changed, delete
-                    const_cast< HelplinePrimitive2D* >(this)->setBuffered2DDecomposition(Primitive2DSequence());
+                    const_cast< HelplinePrimitive2D* >(this)->setBuffered2DDecomposition(Primitive2DContainer());
                 }
             }
 
-            if(!getBuffered2DDecomposition().hasElements())
+            if(getBuffered2DDecomposition().empty())
             {
                 // remember ViewRange and ViewTransformation
                 const_cast< HelplinePrimitive2D* >(this)->maLastObjectToViewTransformation = rViewInformation.getObjectToViewTransformation();

drawinglayer/source/primitive2d/hiddengeometryprimitive2d.cxx

@@ -31,19 +31,19 @@ namespace drawinglayer
     namespace primitive2d
     {
         HiddenGeometryPrimitive2D::HiddenGeometryPrimitive2D(
-            const Primitive2DSequence& rChildren)
+            const Primitive2DContainer& rChildren)
         :   GroupPrimitive2D(rChildren)
         {
         }
 
         basegfx::B2DRange HiddenGeometryPrimitive2D::getB2DRange(const geometry::ViewInformation2D& rViewInformation) const
         {
-            return getB2DRangeFromPrimitive2DSequence(getChildren(), rViewInformation);
+            return getChildren().getB2DRange(rViewInformation);
         }
 
-        Primitive2DSequence HiddenGeometryPrimitive2D::get2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
+        Primitive2DContainer HiddenGeometryPrimitive2D::get2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
         {
-            return Primitive2DSequence();
+            return Primitive2DContainer();
         }
 
         // provide unique ID

drawinglayer/source/primitive2d/invertprimitive2d.cxx

@@ -31,7 +31,7 @@ namespace drawinglayer
     namespace primitive2d
     {
         InvertPrimitive2D::InvertPrimitive2D(
-            const Primitive2DSequence& rChildren)
+            const Primitive2DContainer& rChildren)
         :   GroupPrimitive2D(rChildren)
         {
         }

drawinglayer/source/primitive2d/markerarrayprimitive2d.cxx

@@ -36,9 +36,9 @@ namespace drawinglayer
 {
     namespace primitive2d
     {
-        Primitive2DSequence MarkerArrayPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
+        Primitive2DContainer MarkerArrayPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
         {
-            Primitive2DSequence xRetval;
+            Primitive2DContainer xRetval;
             const std::vector< basegfx::B2DPoint >& rPositions = getPositions();
             const sal_uInt32 nMarkerCount(rPositions.size());
 
@@ -57,7 +57,7 @@ namespace drawinglayer
                     aLogicHalfSize *= 0.5;
 
                     // number of primitives is known; realloc accordingly
-                    xRetval.realloc(nMarkerCount);
+                    xRetval.resize(nMarkerCount);
 
                     for(sal_uInt32 a(0); a < nMarkerCount; a++)
                     {

drawinglayer/source/primitive2d/maskprimitive2d.cxx

@@ -32,7 +32,7 @@ namespace drawinglayer
     {
         MaskPrimitive2D::MaskPrimitive2D(
             const basegfx::B2DPolyPolygon& rMask,
-            const Primitive2DSequence& rChildren)
+            const Primitive2DContainer& rChildren)
         :   GroupPrimitive2D(rChildren),
             maMask(rMask)
         {

drawinglayer/source/primitive2d/mediaprimitive2d.cxx

@@ -34,9 +34,10 @@ namespace drawinglayer
 {
     namespace primitive2d
     {
-        Primitive2DSequence MediaPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
+        Primitive2DContainer MediaPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
         {
-            Primitive2DSequence xRetval(1);
+            Primitive2DContainer xRetval;
+            xRetval.resize(1);
 
             // create background object
             basegfx::B2DPolygon aBackgroundPolygon(basegfx::tools::createUnitPolygon());
@@ -51,7 +52,7 @@ namespace drawinglayer
             {
                 const GraphicObject aGraphicObject(maSnapshot);
                 const GraphicAttr aGraphicAttr;
-                xRetval.realloc(2);
+                xRetval.resize(2);
                 xRetval[0] = xRefBackground;
                 xRetval[1] = Primitive2DReference(new GraphicPrimitive2D(getTransform(), aGraphicObject, aGraphicAttr));
             }
@@ -74,7 +75,7 @@ namespace drawinglayer
                     // invisible content for HitTest and BoundRect
                     const Primitive2DReference xHiddenLines(new HiddenGeometryPrimitive2D(xRetval));
 
-                    xRetval = Primitive2DSequence(&xHiddenLines, 1);
+                    xRetval = Primitive2DContainer { xHiddenLines, };
                 }
                 else
                 {
@@ -86,7 +87,7 @@ namespace drawinglayer
 
                     // add transform primitive
                     const Primitive2DReference aScaled(new TransformPrimitive2D(aTransform, xRetval));
-                    xRetval = Primitive2DSequence(&aScaled, 1L);
+                    xRetval = Primitive2DContainer { aScaled };
                 }
             }
 

drawinglayer/source/primitive2d/metafileprimitive2d.cxx

@@ -428,10 +428,10 @@ namespace
             }
         }
 
-        drawinglayer::primitive2d::Primitive2DSequence getPrimitive2DSequence(const PropertyHolder& rPropertyHolder)
+        drawinglayer::primitive2d::Primitive2DContainer getPrimitive2DSequence(const PropertyHolder& rPropertyHolder)
         {
             const sal_uInt32 nCount(aTargets.size());
-            drawinglayer::primitive2d::Primitive2DSequence xRetval(nCount);
+            drawinglayer::primitive2d::Primitive2DContainer xRetval(nCount);
 
             for(sal_uInt32 a(0); a < nCount; a++)
             {
@@ -444,7 +444,7 @@ namespace
             // the buffer to not delete them in the destructor.
             aTargets.clear();
 
-            if(xRetval.hasElements() && rPropertyHolder.getClipPolyPolygonActive())
+            if(!xRetval.empty() && rPropertyHolder.getClipPolyPolygonActive())
             {
                 const basegfx::B2DPolyPolygon& rClipPolyPolygon = rPropertyHolder.getClipPolyPolygon();
 
@@ -455,7 +455,7 @@ namespace
                             rClipPolyPolygon,
                             xRetval));
 
-                    xRetval = drawinglayer::primitive2d::Primitive2DSequence(&xMask, 1);
+                    xRetval = drawinglayer::primitive2d::Primitive2DContainer { xMask };
                 }
             }
 
@@ -538,7 +538,7 @@ namespace drawinglayer
         {
         protected:
             /// local decomposition.
-            virtual Primitive2DSequence create2DDecomposition(
+            virtual Primitive2DContainer create2DDecomposition(
                 const geometry::ViewInformation2D& rViewInformation) const override;
 
         public:
@@ -551,7 +551,7 @@ namespace drawinglayer
             }
         };
 
-        Primitive2DSequence NonOverlappingFillGradientPrimitive2D::create2DDecomposition(
+        Primitive2DContainer NonOverlappingFillGradientPrimitive2D::create2DDecomposition(
             const geometry::ViewInformation2D& /*rViewInformation*/) const
         {
             if(!getFillGradient().isDefault())
@@ -560,7 +560,7 @@ namespace drawinglayer
             }
             else
             {
-                return Primitive2DSequence();
+                return Primitive2DContainer();
             }
         }
     } // end of namespace primitive2d
@@ -990,7 +990,7 @@ namespace
         // MaskPrimitive2D accordingly.
         if(rPropertyHolders.Current().getClipPolyPolygonActive() && rTargetHolders.size() > 1)
         {
-            drawinglayer::primitive2d::Primitive2DSequence aSubContent;
+            drawinglayer::primitive2d::Primitive2DContainer aSubContent;
 
             if(rPropertyHolders.Current().getClipPolyPolygon().count()
                 && rTargetHolders.Current().size())
@@ -1001,7 +1001,7 @@ namespace
 
             rTargetHolders.Pop();
 
-            if(aSubContent.hasElements())
+            if(!aSubContent.empty())
             {
                 rTargetHolders.Current().append(
                     new drawinglayer::primitive2d::GroupPrimitive2D(
@@ -1036,7 +1036,7 @@ namespace
         // check if currently active
         if(rPropertyHolders.Current().isRasterOpActive() && rTargetHolders.size() > 1)
         {
-            drawinglayer::primitive2d::Primitive2DSequence aSubContent;
+            drawinglayer::primitive2d::Primitive2DContainer aSubContent;
 
             if(rTargetHolders.Current().size())
             {
@@ -1045,7 +1045,7 @@ namespace
 
             rTargetHolders.Pop();
 
-            if(aSubContent.hasElements())
+            if(!aSubContent.empty())
             {
                 if(rPropertyHolders.Current().isRasterOpForceBlack())
                 {
@@ -1120,7 +1120,7 @@ namespace
             if(!rPropertyHolder.getTransformation().isIdentity())
             {
                 const drawinglayer::primitive2d::Primitive2DReference xPrim(pRetval);
-                const drawinglayer::primitive2d::Primitive2DSequence xSeq(&xPrim, 1);
+                const drawinglayer::primitive2d::Primitive2DContainer xSeq { xPrim };
 
                 pRetval = new drawinglayer::primitive2d::TransformPrimitive2D(
                     rPropertyHolder.getTransformation(),
@@ -1196,7 +1196,7 @@ namespace
             rTarget.append(
                 new drawinglayer::primitive2d::TransformPrimitive2D(
                     rProperty.getTransformation(),
-                    drawinglayer::primitive2d::Primitive2DSequence(&xPrim, 1)));
+                    drawinglayer::primitive2d::Primitive2DContainer { xPrim }));
         }
     }
 
@@ -1425,7 +1425,7 @@ namespace
                 aTextTransform.translate(rTextStartPosition.X(), rTextStartPosition.Y());
 
                 // prepare Primitive2DSequence, put text in foreground
-                drawinglayer::primitive2d::Primitive2DSequence aSequence(2);
+                drawinglayer::primitive2d::Primitive2DContainer aSequence(2);
                 aSequence[1] = drawinglayer::primitive2d::Primitive2DReference(pResult);
 
                 // prepare filled polygon
@@ -1457,7 +1457,7 @@ namespace
                 rTarget.append(
                     new drawinglayer::primitive2d::TransformPrimitive2D(
                         rProperty.getTransformation(),
-                        drawinglayer::primitive2d::Primitive2DSequence(&aReference, 1)));
+                        drawinglayer::primitive2d::Primitive2DContainer { aReference }));
             }
         }
     }
@@ -1575,7 +1575,7 @@ namespace
                     else
                     {
                         // when a transformation is set, embed to it
-                        drawinglayer::primitive2d::Primitive2DSequence xTargets(aTargetVector.size());
+                        drawinglayer::primitive2d::Primitive2DContainer xTargets(aTargetVector.size());
 
                         for(size_t a(0); a < aTargetVector.size(); a++)
                         {
@@ -2116,7 +2116,7 @@ namespace
                         if(aGDIMetaFile.GetActionSize())
                         {
                             // create sub-content
-                            drawinglayer::primitive2d::Primitive2DSequence xSubContent;
+                            drawinglayer::primitive2d::Primitive2DContainer xSubContent;
                             {
                                 rTargetHolders.Push();
 
@@ -2132,7 +2132,7 @@ namespace
                                 rTargetHolders.Pop();
                             }
 
-                            if(xSubContent.hasElements())
+                            if(!xSubContent.empty())
                             {
                                 // add with transformation
                                 rTargetHolders.Current().append(
@@ -2299,7 +2299,7 @@ namespace
                             {
                                 // really a gradient
                                 aRange.transform(rPropertyHolders.Current().getTransformation());
-                                drawinglayer::primitive2d::Primitive2DSequence xGradient(1);
+                                drawinglayer::primitive2d::Primitive2DContainer xGradient(1);
 
                                 if(rPropertyHolders.Current().isRasterOpInvert())
                                 {
@@ -2356,7 +2356,7 @@ namespace
                         rTargetHolders.Current().append(
                             new drawinglayer::primitive2d::MaskPrimitive2D(
                                 aOutline,
-                                drawinglayer::primitive2d::Primitive2DSequence(&aFillHatch, 1)));
+                                drawinglayer::primitive2d::Primitive2DContainer { aFillHatch }));
                     }
 
                     break;
@@ -2859,13 +2859,13 @@ namespace
 
                             // create primitives there and get them
                             createHairlineAndFillPrimitive(aOutline, rTargetHolders.Current(), rPropertyHolders.Current());
-                            const drawinglayer::primitive2d::Primitive2DSequence aSubContent(
+                            const drawinglayer::primitive2d::Primitive2DContainer aSubContent(
                                 rTargetHolders.Current().getPrimitive2DSequence(rPropertyHolders.Current()));
 
                             // back to old target
                             rTargetHolders.Pop();
 
-                            if(aSubContent.hasElements())
+                            if(!aSubContent.empty())
                             {
                                 rTargetHolders.Current().append(
                                     new drawinglayer::primitive2d::UnifiedTransparencePrimitive2D(
@@ -2967,7 +2967,7 @@ namespace
                         {
                             // create the sub-content with no embedding specific to the
                             // sub-metafile, this seems not to be used.
-                            drawinglayer::primitive2d::Primitive2DSequence xSubContent;
+                            drawinglayer::primitive2d::Primitive2DContainer xSubContent;
                             {
                                 rTargetHolders.Push();
                                 // #i# for sub-Mteafile contents, do start with new, default render state
@@ -2978,7 +2978,7 @@ namespace
                                 rTargetHolders.Pop();
                             }
 
-                            if(xSubContent.hasElements())
+                            if(!xSubContent.empty())
                             {
                                 // prepare sub-content transform
                                 basegfx::B2DHomMatrix aSubTransform;
@@ -3011,7 +3011,7 @@ namespace
                                             aSubTransform,
                                             xSubContent));
 
-                                    xSubContent = drawinglayer::primitive2d::Primitive2DSequence(&aEmbeddedTransform, 1);
+                                    xSubContent = drawinglayer::primitive2d::Primitive2DContainer { aEmbeddedTransform };
                                 }
 
                                 // check if gradient is a real gradient
@@ -3042,7 +3042,7 @@ namespace
                                     rTargetHolders.Current().append(
                                         new drawinglayer::primitive2d::TransparencePrimitive2D(
                                             xSubContent,
-                                            drawinglayer::primitive2d::Primitive2DSequence(&xTransparence, 1)));
+                                            drawinglayer::primitive2d::Primitive2DContainer { xTransparence }));
                                 }
                             }
                         }
@@ -3176,7 +3176,7 @@ namespace drawinglayer
 {
     namespace primitive2d
     {
-        Primitive2DSequence MetafilePrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
+        Primitive2DContainer MetafilePrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
         {
             // prepare target and porperties; each will have one default entry
             TargetHolders aTargetHolders;
@@ -3190,19 +3190,19 @@ namespace drawinglayer
 
             // get the content. There should be only one target, as in the start condition,
             // but iterating will be the right thing to do when some push/pop is not closed
-            Primitive2DSequence xRetval;
+            Primitive2DContainer xRetval;
 
             while(aTargetHolders.size() > 1)
             {
-                appendPrimitive2DSequenceToPrimitive2DSequence(xRetval,
+                xRetval.append(
                     aTargetHolders.Current().getPrimitive2DSequence(aPropertyHolders.Current()));
                 aTargetHolders.Pop();
             }
 
-            appendPrimitive2DSequenceToPrimitive2DSequence(xRetval,
+            xRetval.append(
                 aTargetHolders.Current().getPrimitive2DSequence(aPropertyHolders.Current()));
 
-            if(xRetval.hasElements())
+            if(!xRetval.empty())
             {
                 // get target size
                 const Rectangle aMtfTarget(getMetaFile().GetPrefMapMode().GetOrigin(), getMetaFile().GetPrefSize());
@@ -3222,7 +3222,7 @@ namespace drawinglayer
                         aAdaptedTransform,
                         xRetval));
 
-                xRetval = Primitive2DSequence(&aEmbeddedTransform, 1);
+                xRetval = Primitive2DContainer { aEmbeddedTransform };
             }
 
             return xRetval;

drawinglayer/source/primitive2d/modifiedcolorprimitive2d.cxx

@@ -31,7 +31,7 @@ namespace drawinglayer
     namespace primitive2d
     {
         ModifiedColorPrimitive2D::ModifiedColorPrimitive2D(
-            const Primitive2DSequence& rChildren,
+            const Primitive2DContainer& rChildren,
             const basegfx::BColorModifierSharedPtr& rColorModifier)
         :   GroupPrimitive2D(rChildren),
             maColorModifier(rColorModifier)

drawinglayer/source/primitive2d/objectinfoprimitive2d.cxx

@@ -26,7 +26,7 @@ namespace drawinglayer
     namespace primitive2d
     {
         ObjectInfoPrimitive2D::ObjectInfoPrimitive2D(
-            const Primitive2DSequence& rChildren,
+            const Primitive2DContainer& rChildren,
             const OUString& rName,
             const OUString& rTitle,
             const OUString& rDesc)

drawinglayer/source/primitive2d/pagepreviewprimitive2d.cxx

@@ -35,12 +35,12 @@ namespace drawinglayer
 {
     namespace primitive2d
     {
-        Primitive2DSequence PagePreviewPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
+        Primitive2DContainer PagePreviewPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
         {
-            Primitive2DSequence xRetval;
-            Primitive2DSequence aContent(getPageContent());
+            Primitive2DContainer xRetval;
+            Primitive2DContainer aContent(getPageContent());
 
-            if(aContent.hasElements()
+            if(!aContent.empty()
                 && basegfx::fTools::more(getContentWidth(), 0.0)
                 && basegfx::fTools::more(getContentHeight(), 0.0))
             {
@@ -53,7 +53,7 @@ namespace drawinglayer
                 {
                     // check if content overlaps with target size and needs to be embedded with a
                     // clipping primitive
-                    const basegfx::B2DRange aRealContentRange(getB2DRangeFromPrimitive2DSequence(aContent, rViewInformation));
+                    const basegfx::B2DRange aRealContentRange(aContent.getB2DRange(rViewInformation));
                     const basegfx::B2DRange aAllowedContentRange(0.0, 0.0, getContentWidth(), getContentHeight());
 
                     if(!aAllowedContentRange.isInside(aRealContentRange))
@@ -62,7 +62,7 @@ namespace drawinglayer
                             new MaskPrimitive2D(
                                 basegfx::B2DPolyPolygon(
                                     basegfx::tools::createPolygonFromRect(aAllowedContentRange)), aContent));
-                        aContent = Primitive2DSequence(&xReferenceA, 1);
+                        aContent = Primitive2DContainer { xReferenceA };
                     }
 
                     // create a mapping from content to object.
@@ -112,7 +112,7 @@ namespace drawinglayer
 
                     // embed in necessary transformation to map from SdrPage to SdrPageObject
                     const Primitive2DReference xReferenceB(new TransformPrimitive2D(aPageTrans, aContent));
-                    xRetval = Primitive2DSequence(&xReferenceB, 1);
+                    xRetval = Primitive2DContainer { xReferenceB };
                 }
             }
 
@@ -124,7 +124,7 @@ namespace drawinglayer
             const basegfx::B2DHomMatrix& rTransform,
             double fContentWidth,
             double fContentHeight,
-            const Primitive2DSequence& rPageContent,
+            const Primitive2DContainer& rPageContent,
             bool bKeepAspectRatio)
         :   BufferedDecompositionPrimitive2D(),
             mxDrawPage(rxDrawPage),

drawinglayer/source/primitive2d/patternfillprimitive2d.cxx

@@ -36,11 +36,11 @@ namespace drawinglayer
 {
     namespace primitive2d
     {
-        Primitive2DSequence PatternFillPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
+        Primitive2DContainer PatternFillPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
         {
-            Primitive2DSequence aRetval;
+            Primitive2DContainer aRetval;
 
-            if(getChildren().hasElements())
+            if(!getChildren().empty())
             {
                 if(!getReferenceRange().isEmpty() && getReferenceRange().getWidth() > 0.0 && getReferenceRange().getHeight() > 0.0)
                 {
@@ -56,8 +56,8 @@ namespace drawinglayer
 
                         // check if content needs to be clipped
                         const basegfx::B2DRange aUnitRange(0.0, 0.0, 1.0, 1.0);
-                        const basegfx::B2DRange aContentRange(getB2DRangeFromPrimitive2DSequence(getChildren(), rViewInformation));
-                        Primitive2DSequence aContent(getChildren());
+                        const basegfx::B2DRange aContentRange(getChildren().getB2DRange(rViewInformation));
+                        Primitive2DContainer aContent(getChildren());
 
                         if(!aUnitRange.isInside(aContentRange))
                         {
@@ -66,11 +66,11 @@ namespace drawinglayer
                                     basegfx::B2DPolyPolygon(basegfx::tools::createPolygonFromRect(aUnitRange)),
                                     aContent));
 
-                            aContent = Primitive2DSequence(&xRef, 1);
+                            aContent = Primitive2DContainer { xRef };
                         }
 
                         // resize result
-                        aRetval.realloc(aMatrices.size());
+                        aRetval.resize(aMatrices.size());
 
                         // create one primitive for each matrix
                         for(size_t a(0); a < aMatrices.size(); a++)
@@ -92,7 +92,7 @@ namespace drawinglayer
                                     aMaskTransform,
                                     aRetval));
 
-                            aRetval = Primitive2DSequence(&xRef, 1);
+                            aRetval = Primitive2DContainer { xRef };
                         }
 
                         // embed result in mask
@@ -102,7 +102,7 @@ namespace drawinglayer
                                     getMask(),
                                     aRetval));
 
-                            aRetval = Primitive2DSequence(&xRef, 1);
+                            aRetval = Primitive2DContainer { xRef };
                         }
 
                     }
@@ -114,7 +114,7 @@ namespace drawinglayer
 
         PatternFillPrimitive2D::PatternFillPrimitive2D(
             const basegfx::B2DPolyPolygon& rMask,
-            const Primitive2DSequence& rChildren,
+            const Primitive2DContainer& rChildren,
             const basegfx::B2DRange& rReferenceRange)
         :   BufferedDecompositionPrimitive2D(),
             maMask(rMask),

drawinglayer/source/primitive2d/polygonprimitive2d.cxx

@@ -92,7 +92,7 @@ namespace drawinglayer
 {
     namespace primitive2d
     {
-        Primitive2DSequence PolygonMarkerPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
+        Primitive2DContainer PolygonMarkerPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
         {
             // calculate logic DashLength
             const basegfx::B2DVector aDashVector(rViewInformation.getInverseObjectToViewTransformation() * basegfx::B2DVector(getDiscreteDashLength(), 0.0));
@@ -110,7 +110,7 @@ namespace drawinglayer
                 basegfx::tools::applyLineDashing(getB2DPolygon(), aDash, &aDashedPolyPolyA, &aDashedPolyPolyB, 2.0 * fLogicDashLength);
 
                 // prepare return value
-                Primitive2DSequence aRetval(2);
+                Primitive2DContainer aRetval(2);
 
                 aRetval[0] = Primitive2DReference(new PolyPolygonHairlinePrimitive2D(aDashedPolyPolyA, getRGBColorA()));
                 aRetval[1] = Primitive2DReference(new PolyPolygonHairlinePrimitive2D(aDashedPolyPolyB, getRGBColorB()));
@@ -120,7 +120,7 @@ namespace drawinglayer
             else
             {
                 const Primitive2DReference xRef(new PolygonHairlinePrimitive2D(getB2DPolygon(), getRGBColorA()));
-                return Primitive2DSequence(&xRef, 1L);
+                return Primitive2DContainer { xRef };
             }
         }
 
@@ -175,12 +175,12 @@ namespace drawinglayer
             return aRetval;
         }
 
-        Primitive2DSequence PolygonMarkerPrimitive2D::get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
+        Primitive2DContainer PolygonMarkerPrimitive2D::get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
         {
             ::osl::MutexGuard aGuard( m_aMutex );
             bool bNeedNewDecomposition(false);
 
-            if(getBuffered2DDecomposition().hasElements())
+            if(!getBuffered2DDecomposition().empty())
             {
                 if(rViewInformation.getInverseObjectToViewTransformation() != maLastInverseObjectToViewTransformation)
                 {
@@ -191,10 +191,10 @@ namespace drawinglayer
             if(bNeedNewDecomposition)
             {
                 // conditions of last local decomposition have changed, delete
-                const_cast< PolygonMarkerPrimitive2D* >(this)->setBuffered2DDecomposition(Primitive2DSequence());
+                const_cast< PolygonMarkerPrimitive2D* >(this)->setBuffered2DDecomposition(Primitive2DContainer());
             }
 
-            if(!getBuffered2DDecomposition().hasElements())
+            if(getBuffered2DDecomposition().empty())
             {
                 // remember last used InverseObjectToViewTransformation
                 PolygonMarkerPrimitive2D* pThat = const_cast< PolygonMarkerPrimitive2D* >(this);
@@ -223,7 +223,7 @@ namespace drawinglayer
 
     namespace primitive2d
     {
-        Primitive2DSequence PolygonStrokePrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
+        Primitive2DContainer PolygonStrokePrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
         {
             if(getB2DPolygon().count())
             {
@@ -265,7 +265,7 @@ namespace drawinglayer
                     }
 
                     // prepare return value
-                    Primitive2DSequence aRetval(aAreaPolyPolygon.count());
+                    Primitive2DContainer aRetval(aAreaPolyPolygon.count());
 
                     // create primitive
                     for(sal_uInt32 b(0L); b < aAreaPolyPolygon.count(); b++)
@@ -292,12 +292,12 @@ namespace drawinglayer
                             aHairLinePolyPolygon,
                             getLineAttribute().getColor()));
 
-                    return Primitive2DSequence(&xRef, 1);
+                    return Primitive2DContainer { xRef };
                 }
             }
             else
             {
-                return Primitive2DSequence();
+                return Primitive2DContainer();
             }
         }
 
@@ -408,9 +408,9 @@ namespace drawinglayer
 {
     namespace primitive2d
     {
-        Primitive2DSequence PolygonWavePrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
+        Primitive2DContainer PolygonWavePrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
         {
-            Primitive2DSequence aRetval;
+            Primitive2DContainer aRetval;
 
             if(getB2DPolygon().count())
             {
@@ -422,13 +422,13 @@ namespace drawinglayer
                     // create waveline curve
                     const basegfx::B2DPolygon aWaveline(basegfx::tools::createWaveline(getB2DPolygon(), getWaveWidth(), getWaveHeight()));
                     const Primitive2DReference xRef(new PolygonStrokePrimitive2D(aWaveline, getLineAttribute(), getStrokeAttribute()));
-                    aRetval = Primitive2DSequence(&xRef, 1);
+                    aRetval = Primitive2DContainer { xRef };
                 }
                 else
                 {
                     // flat waveline, decompose to simple line primitive
                     const Primitive2DReference xRef(new PolygonStrokePrimitive2D(getB2DPolygon(), getLineAttribute(), getStrokeAttribute()));
-                    aRetval = Primitive2DSequence(&xRef, 1);
+                    aRetval = Primitive2DContainer { xRef };
                 }
             }
 
@@ -521,7 +521,7 @@ namespace drawinglayer
 {
     namespace primitive2d
     {
-        Primitive2DSequence PolygonStrokeArrowPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
+        Primitive2DContainer PolygonStrokeArrowPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
         {
             // copy local polygon, it may be changed
             basegfx::B2DPolygon aLocalPolygon(getB2DPolygon());
@@ -569,7 +569,7 @@ namespace drawinglayer
             }
 
             // prepare return value
-            Primitive2DSequence aRetval(1L + (aArrowA.count() ? 1L : 0L) + (aArrowB.count() ? 1L : 0L));
+            Primitive2DContainer aRetval(1L + (aArrowA.count() ? 1L : 0L) + (aArrowB.count() ? 1L : 0L));
             sal_uInt32 nInd(0L);
 
             // add shaft

drawinglayer/source/primitive2d/polypolygonprimitive2d.cxx

@@ -42,14 +42,14 @@ namespace drawinglayer
 {
     namespace primitive2d
     {
-        Primitive2DSequence PolyPolygonHairlinePrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
+        Primitive2DContainer PolyPolygonHairlinePrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
         {
             const basegfx::B2DPolyPolygon aPolyPolygon(getB2DPolyPolygon());
             const sal_uInt32 nCount(aPolyPolygon.count());
 
             if(nCount)
             {
-                Primitive2DSequence aRetval(nCount);
+                Primitive2DContainer aRetval(nCount);
 
                 for(sal_uInt32 a(0L); a < nCount; a++)
                 {
@@ -60,7 +60,7 @@ namespace drawinglayer
             }
             else
             {
-                return Primitive2DSequence();
+                return Primitive2DContainer();
             }
         }
 
@@ -102,14 +102,14 @@ namespace drawinglayer
 {
     namespace primitive2d
     {
-        Primitive2DSequence PolyPolygonMarkerPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
+        Primitive2DContainer PolyPolygonMarkerPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
         {
             const basegfx::B2DPolyPolygon aPolyPolygon(getB2DPolyPolygon());
             const sal_uInt32 nCount(aPolyPolygon.count());
 
             if(nCount)
             {
-                Primitive2DSequence aRetval(nCount);
+                Primitive2DContainer aRetval(nCount);
 
                 for(sal_uInt32 a(0L); a < nCount; a++)
                 {
@@ -125,7 +125,7 @@ namespace drawinglayer
             }
             else
             {
-                return Primitive2DSequence();
+                return Primitive2DContainer();
             }
         }
 
@@ -175,14 +175,14 @@ namespace drawinglayer
 {
     namespace primitive2d
     {
-        Primitive2DSequence PolyPolygonStrokePrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
+        Primitive2DContainer PolyPolygonStrokePrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
         {
             const basegfx::B2DPolyPolygon aPolyPolygon(getB2DPolyPolygon());
             const sal_uInt32 nCount(aPolyPolygon.count());
 
             if(nCount)
             {
-                Primitive2DSequence aRetval(nCount);
+                Primitive2DContainer aRetval(nCount);
 
                 for(sal_uInt32 a(0L); a < nCount; a++)
                 {
@@ -195,7 +195,7 @@ namespace drawinglayer
             }
             else
             {
-                return Primitive2DSequence();
+                return Primitive2DContainer();
             }
         }
 
@@ -300,7 +300,7 @@ namespace drawinglayer
 {
     namespace primitive2d
     {
-        Primitive2DSequence PolyPolygonGradientPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
+        Primitive2DContainer PolyPolygonGradientPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
         {
             if(!getFillGradient().isDefault())
             {
@@ -311,17 +311,17 @@ namespace drawinglayer
                     getDefinitionRange(),
                     getFillGradient());
                 const Primitive2DReference xSubRef(pNewGradient);
-                const Primitive2DSequence aSubSequence(&xSubRef, 1L);
+                const Primitive2DContainer aSubSequence { xSubRef };
 
                 // create mask primitive
                 MaskPrimitive2D* pNewMask = new MaskPrimitive2D(getB2DPolyPolygon(), aSubSequence);
                 const Primitive2DReference xRef(pNewMask);
 
-                return Primitive2DSequence(&xRef, 1);
+                return Primitive2DContainer { xRef };
             }
             else
             {
-                return Primitive2DSequence();
+                return Primitive2DContainer();
             }
         }
 
@@ -372,7 +372,7 @@ namespace drawinglayer
 {
     namespace primitive2d
     {
-        Primitive2DSequence PolyPolygonHatchPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
+        Primitive2DContainer PolyPolygonHatchPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
         {
             if(!getFillHatch().isDefault())
             {
@@ -384,17 +384,17 @@ namespace drawinglayer
                     getBackgroundColor(),
                     getFillHatch());
                 const Primitive2DReference xSubRef(pNewHatch);
-                const Primitive2DSequence aSubSequence(&xSubRef, 1L);
+                const Primitive2DContainer aSubSequence { xSubRef };
 
                 // create mask primitive
                 MaskPrimitive2D* pNewMask = new MaskPrimitive2D(getB2DPolyPolygon(), aSubSequence);
                 const Primitive2DReference xRef(pNewMask);
 
-                return Primitive2DSequence(&xRef, 1);
+                return Primitive2DContainer { xRef };
             }
             else
             {
-                return Primitive2DSequence();
+                return Primitive2DContainer();
             }
         }
 
@@ -450,7 +450,7 @@ namespace drawinglayer
 {
     namespace primitive2d
     {
-        Primitive2DSequence PolyPolygonGraphicPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
+        Primitive2DContainer PolyPolygonGraphicPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
         {
             if(!getFillGraphic().isDefault())
             {
@@ -521,14 +521,14 @@ namespace drawinglayer
                         const Primitive2DReference xRef(
                             new MaskPrimitive2D(
                                 getB2DPolyPolygon(),
-                                Primitive2DSequence(&xSubRef, 1)));
+                                Primitive2DContainer { xSubRef }));
 
-                        return Primitive2DSequence(&xRef, 1);
+                        return Primitive2DContainer { xRef };
                     }
                 }
             }
 
-            return Primitive2DSequence();
+            return Primitive2DContainer();
         }
 
         PolyPolygonGraphicPrimitive2D::PolyPolygonGraphicPrimitive2D(
@@ -578,9 +578,9 @@ namespace drawinglayer
 {
     namespace primitive2d
     {
-        Primitive2DSequence PolyPolygonSelectionPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
+        Primitive2DContainer PolyPolygonSelectionPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
         {
-            Primitive2DSequence aRetval;
+            Primitive2DContainer aRetval;
 
             if(getTransparence() < 1.0 && getB2DPolyPolygon().count())
             {
@@ -592,7 +592,7 @@ namespace drawinglayer
                             getB2DPolyPolygon(),
                             getColor()));
 
-                    aRetval = Primitive2DSequence(&aFill, 1);
+                    aRetval = Primitive2DContainer { aFill };
                 }
 
                 if(getDiscreteGrow() > 0.0)
@@ -605,18 +605,18 @@ namespace drawinglayer
                             getB2DPolyPolygon(),
                             aLineAttribute));
 
-                    appendPrimitive2DReferenceToPrimitive2DSequence(aRetval, aFatLine);
+                    aRetval.push_back(aFatLine);
                 }
 
                 // embed filled to transparency (if used)
-                if(aRetval.getLength() && getTransparence() > 0.0)
+                if(!aRetval.empty() && getTransparence() > 0.0)
                 {
                     const Primitive2DReference aTrans(
                         new UnifiedTransparencePrimitive2D(
                             aRetval,
                             getTransparence()));
 
-                    aRetval = Primitive2DSequence(&aTrans, 1);
+                    aRetval = Primitive2DContainer { aTrans };
                 }
             }
 

drawinglayer/source/primitive2d/primitivetools2d.cxx

@@ -27,7 +27,7 @@ namespace drawinglayer
 {
     namespace primitive2d
     {
-        Primitive2DSequence DiscreteMetricDependentPrimitive2D::get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
+        Primitive2DContainer DiscreteMetricDependentPrimitive2D::get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
         {
             ::osl::MutexGuard aGuard( m_aMutex );
 
@@ -35,13 +35,13 @@ namespace drawinglayer
             const basegfx::B2DVector aDiscreteVector(rViewInformation.getInverseObjectToViewTransformation() * basegfx::B2DVector(1.0, 1.0));
             const double fDiscreteUnit(std::min(fabs(aDiscreteVector.getX()), fabs(aDiscreteVector.getY())));
 
-            if(getBuffered2DDecomposition().hasElements() && !basegfx::fTools::equal(fDiscreteUnit, getDiscreteUnit()))
+            if(!getBuffered2DDecomposition().empty() && !basegfx::fTools::equal(fDiscreteUnit, getDiscreteUnit()))
             {
                 // conditions of last local decomposition have changed, delete
-                const_cast< DiscreteMetricDependentPrimitive2D* >(this)->setBuffered2DDecomposition(Primitive2DSequence());
+                const_cast< DiscreteMetricDependentPrimitive2D* >(this)->setBuffered2DDecomposition(Primitive2DContainer());
             }
 
-            if(!getBuffered2DDecomposition().hasElements())
+            if(getBuffered2DDecomposition().empty())
             {
                 // remember new valid DiscreteUnit
                 const_cast< DiscreteMetricDependentPrimitive2D* >(this)->updateDiscreteUnit(fDiscreteUnit);
@@ -59,20 +59,20 @@ namespace drawinglayer
 {
     namespace primitive2d
     {
-        Primitive2DSequence ViewportDependentPrimitive2D::get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
+        Primitive2DContainer ViewportDependentPrimitive2D::get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
         {
             ::osl::MutexGuard aGuard( m_aMutex );
 
             // get the current Viewport
             const basegfx::B2DRange& rViewport = rViewInformation.getViewport();
 
-            if(getBuffered2DDecomposition().hasElements() && !rViewport.equal(getViewport()))
+            if(!getBuffered2DDecomposition().empty() && !rViewport.equal(getViewport()))
             {
                 // conditions of last local decomposition have changed, delete
-                const_cast< ViewportDependentPrimitive2D* >(this)->setBuffered2DDecomposition(Primitive2DSequence());
+                const_cast< ViewportDependentPrimitive2D* >(this)->setBuffered2DDecomposition(Primitive2DContainer());
             }
 
-            if(!getBuffered2DDecomposition().hasElements())
+            if(getBuffered2DDecomposition().empty())
             {
                 // remember new valid DiscreteUnit
                 const_cast< ViewportDependentPrimitive2D* >(this)->maViewport = rViewport;
@@ -90,20 +90,20 @@ namespace drawinglayer
 {
     namespace primitive2d
     {
-        Primitive2DSequence ViewTransformationDependentPrimitive2D::get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
+        Primitive2DContainer ViewTransformationDependentPrimitive2D::get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
         {
             ::osl::MutexGuard aGuard( m_aMutex );
 
             // get the current ViewTransformation
             const basegfx::B2DHomMatrix& rViewTransformation = rViewInformation.getViewTransformation();
 
-            if(getBuffered2DDecomposition().hasElements() && rViewTransformation != getViewTransformation())
+            if(!getBuffered2DDecomposition().empty() && rViewTransformation != getViewTransformation())
             {
                 // conditions of last local decomposition have changed, delete
-                const_cast< ViewTransformationDependentPrimitive2D* >(this)->setBuffered2DDecomposition(Primitive2DSequence());
+                const_cast< ViewTransformationDependentPrimitive2D* >(this)->setBuffered2DDecomposition(Primitive2DContainer());
             }
 
-            if(!getBuffered2DDecomposition().hasElements())
+            if(getBuffered2DDecomposition().empty())
             {
                 // remember new valid ViewTransformation
                 const_cast< ViewTransformationDependentPrimitive2D* >(this)->maViewTransformation = rViewTransformation;
@@ -121,29 +121,29 @@ namespace drawinglayer
 {
     namespace primitive2d
     {
-        Primitive2DSequence ObjectAndViewTransformationDependentPrimitive2D::get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
+        Primitive2DContainer ObjectAndViewTransformationDependentPrimitive2D::get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
         {
             ::osl::MutexGuard aGuard( m_aMutex );
 
             // get the current ViewTransfromation
             const basegfx::B2DHomMatrix& rViewTransformation = rViewInformation.getViewTransformation();
 
-            if(getBuffered2DDecomposition().hasElements() && rViewTransformation != getViewTransformation())
+            if(!getBuffered2DDecomposition().empty() && rViewTransformation != getViewTransformation())
             {
                 // conditions of last local decomposition have changed, delete
-                const_cast< ObjectAndViewTransformationDependentPrimitive2D* >(this)->setBuffered2DDecomposition(Primitive2DSequence());
+                const_cast< ObjectAndViewTransformationDependentPrimitive2D* >(this)->setBuffered2DDecomposition(Primitive2DContainer());
             }
 
             // get the current ObjectTransformation
             const basegfx::B2DHomMatrix& rObjectTransformation = rViewInformation.getObjectTransformation();
 
-            if(getBuffered2DDecomposition().hasElements() && rObjectTransformation != getObjectTransformation())
+            if(!getBuffered2DDecomposition().empty() && rObjectTransformation != getObjectTransformation())
             {
                 // conditions of last local decomposition have changed, delete
-                const_cast< ObjectAndViewTransformationDependentPrimitive2D* >(this)->setBuffered2DDecomposition(Primitive2DSequence());
+                const_cast< ObjectAndViewTransformationDependentPrimitive2D* >(this)->setBuffered2DDecomposition(Primitive2DContainer());
             }
 
-            if(!getBuffered2DDecomposition().hasElements())
+            if(getBuffered2DDecomposition().empty())
             {
                 // remember new valid ViewTransformation, and ObjectTransformation
                 const_cast< ObjectAndViewTransformationDependentPrimitive2D* >(this)->maViewTransformation = rViewTransformation;

drawinglayer/source/primitive2d/sceneprimitive2d.cxx

@@ -78,7 +78,7 @@ namespace drawinglayer
             }
 
             // return if there are shadow primitives
-            return maShadowPrimitives.hasElements();
+            return !maShadowPrimitives.empty();
         }
 
         void ScenePrimitive2D::calculateDiscreteSizes(
@@ -128,17 +128,16 @@ namespace drawinglayer
             }
         }
 
-        Primitive2DSequence ScenePrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
+        Primitive2DContainer ScenePrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
         {
-            Primitive2DSequence aRetval;
+            Primitive2DContainer aRetval;
 
             // create 2D shadows from contained 3D primitives. This creates the shadow primitives on demand and tells if
             // there are some or not. Do this at start, the shadow might still be visible even when the scene is not
             if(impGetShadow3D(rViewInformation))
             {
                 // test visibility
-                const basegfx::B2DRange aShadow2DRange(
-                    getB2DRangeFromPrimitive2DSequence(maShadowPrimitives, rViewInformation));
+                const basegfx::B2DRange aShadow2DRange(maShadowPrimitives.getB2DRange(rViewInformation));
                 const basegfx::B2DRange aViewRange(
                     rViewInformation.getViewport());
 
@@ -298,7 +297,7 @@ namespace drawinglayer
 
                     // create bitmap primitive and add
                     const Primitive2DReference xRef(new BitmapPrimitive2D(maOldRenderedBitmap, aNew2DTransform));
-                    appendPrimitive2DReferenceToPrimitive2DSequence(aRetval, xRef);
+                    aRetval.push_back(xRef);
 
                     // test: Allow to add an outline in the debugger when tests are needed
                     static bool bAddOutlineToCreated3DSceneRepresentation(false);
@@ -308,7 +307,7 @@ namespace drawinglayer
                         basegfx::B2DPolygon aOutline(basegfx::tools::createUnitPolygon());
                         aOutline.transform(aNew2DTransform);
                         const Primitive2DReference xRef2(new PolygonHairlinePrimitive2D(aOutline, basegfx::BColor(1.0, 0.0, 0.0)));
-                        appendPrimitive2DReferenceToPrimitive2DSequence(aRetval, xRef2);
+                        aRetval.push_back(xRef2);
                     }
                 }
             }
@@ -316,9 +315,9 @@ namespace drawinglayer
             return aRetval;
         }
 
-        Primitive2DSequence ScenePrimitive2D::getGeometry2D() const
+        Primitive2DContainer ScenePrimitive2D::getGeometry2D() const
         {
-            Primitive2DSequence aRetval;
+            Primitive2DContainer aRetval;
 
             // create 2D projected geometry from 3D geometry
             if(getChildren3D().hasElements())
@@ -338,9 +337,9 @@ namespace drawinglayer
             return aRetval;
         }
 
-        Primitive2DSequence ScenePrimitive2D::getShadow2D(const geometry::ViewInformation2D& rViewInformation) const
+        Primitive2DContainer ScenePrimitive2D::getShadow2D(const geometry::ViewInformation2D& rViewInformation) const
         {
-            Primitive2DSequence aRetval;
+            Primitive2DContainer aRetval;
 
             // create 2D shadows from contained 3D primitives
             if(impGetShadow3D(rViewInformation))
@@ -446,7 +445,7 @@ namespace drawinglayer
             // expand by evtl. existing shadow primitives
             if(impGetShadow3D(rViewInformation))
             {
-                const basegfx::B2DRange aShadow2DRange(getB2DRangeFromPrimitive2DSequence(maShadowPrimitives, rViewInformation));
+                const basegfx::B2DRange aShadow2DRange(maShadowPrimitives.getB2DRange(rViewInformation));
 
                 if(!aShadow2DRange.isEmpty())
                 {
@@ -457,7 +456,7 @@ namespace drawinglayer
             return aRetval;
         }
 
-        Primitive2DSequence ScenePrimitive2D::get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
+        Primitive2DContainer ScenePrimitive2D::get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
         {
             ::osl::MutexGuard aGuard( m_aMutex );
 
@@ -467,7 +466,7 @@ namespace drawinglayer
             bool bNeedNewDecomposition(false);
             bool bDiscreteSizesAreCalculated(false);
 
-            if(getBuffered2DDecomposition().hasElements())
+            if(!getBuffered2DDecomposition().empty())
             {
                 basegfx::B2DRange aVisibleDiscreteRange;
                 calculateDiscreteSizes(rViewInformation, aDiscreteRange, aVisibleDiscreteRange, aUnitVisibleRange);
@@ -495,10 +494,10 @@ namespace drawinglayer
             if(bNeedNewDecomposition)
             {
                 // conditions of last local decomposition have changed, delete
-                const_cast< ScenePrimitive2D* >(this)->setBuffered2DDecomposition(Primitive2DSequence());
+                const_cast< ScenePrimitive2D* >(this)->setBuffered2DDecomposition(Primitive2DContainer());
             }
 
-            if(!getBuffered2DDecomposition().hasElements())
+            if(getBuffered2DDecomposition().empty())
             {
                 if(!bDiscreteSizesAreCalculated)
                 {

drawinglayer/source/primitive2d/sdrdecompositiontools2d.cxx

@@ -102,7 +102,7 @@ namespace drawinglayer
 
             // create HiddenGeometryPrimitive2D
             return Primitive2DReference(
-                new HiddenGeometryPrimitive2D(Primitive2DSequence(&xReference, 1)));
+                new HiddenGeometryPrimitive2D(Primitive2DContainer { xReference }));
         }
     } // end of namespace primitive2d
 } // end of namespace drawinglayer

drawinglayer/source/primitive2d/shadowprimitive2d.cxx

@@ -39,7 +39,7 @@ namespace drawinglayer
         ShadowPrimitive2D::ShadowPrimitive2D(
             const basegfx::B2DHomMatrix& rShadowTransform,
             const basegfx::BColor& rShadowColor,
-            const Primitive2DSequence& rChildren)
+            const Primitive2DContainer& rChildren)
         :   GroupPrimitive2D(rChildren),
             maShadowTransform(rShadowTransform),
             maShadowColor(rShadowColor)
@@ -61,16 +61,16 @@ namespace drawinglayer
 
         basegfx::B2DRange ShadowPrimitive2D::getB2DRange(const geometry::ViewInformation2D& rViewInformation) const
         {
-            basegfx::B2DRange aRetval(getB2DRangeFromPrimitive2DSequence(getChildren(), rViewInformation));
+            basegfx::B2DRange aRetval(getChildren().getB2DRange(rViewInformation));
             aRetval.transform(getShadowTransform());
             return aRetval;
         }
 
-        Primitive2DSequence ShadowPrimitive2D::get2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
+        Primitive2DContainer ShadowPrimitive2D::get2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
         {
-            Primitive2DSequence aRetval;
+            Primitive2DContainer aRetval;
 
-            if(getChildren().hasElements())
+            if(!getChildren().empty())
             {
                 // create a modifiedColorPrimitive containing the shadow color and the content
                 const basegfx::BColorModifierSharedPtr aBColorModifier(
@@ -80,11 +80,11 @@ namespace drawinglayer
                     new ModifiedColorPrimitive2D(
                         getChildren(),
                         aBColorModifier));
-                const Primitive2DSequence aSequenceB(&xRefA, 1L);
+                const Primitive2DContainer aSequenceB { xRefA };
 
                 // build transformed primitiveVector with shadow offset and add to target
                 const Primitive2DReference xRefB(new TransformPrimitive2D(getShadowTransform(), aSequenceB));
-                aRetval = Primitive2DSequence(&xRefB, 1L);
+                aRetval = Primitive2DContainer { xRefB };
             }
 
             return aRetval;

drawinglayer/source/primitive2d/structuretagprimitive2d.cxx

@@ -32,7 +32,7 @@ namespace drawinglayer
     {
         StructureTagPrimitive2D::StructureTagPrimitive2D(
             const vcl::PDFWriter::StructElement& rStructureElement,
-            const Primitive2DSequence& rChildren)
+            const Primitive2DContainer& rChildren)
         :   GroupPrimitive2D(rChildren),
             maStructureElement(rStructureElement)
         {

drawinglayer/source/primitive2d/svggradientprimitive2d.cxx

@@ -65,11 +65,11 @@ namespace drawinglayer
 {
     namespace primitive2d
     {
-        Primitive2DSequence SvgGradientHelper::createSingleGradientEntryFill() const
+        Primitive2DContainer SvgGradientHelper::createSingleGradientEntryFill() const
         {
             const SvgGradientEntryVector& rEntries = getGradientEntries();
             const sal_uInt32 nCount(rEntries.size());
-            Primitive2DSequence xRetval;
+            Primitive2DContainer xRetval;
 
             if(nCount)
             {
@@ -85,7 +85,7 @@ namespace drawinglayer
 
                     if(fOpacity < 1.0)
                     {
-                        const Primitive2DSequence aContent(&xRef, 1);
+                        const Primitive2DContainer aContent { xRef };
 
                         xRef = Primitive2DReference(
                             new UnifiedTransparencePrimitive2D(
@@ -93,7 +93,7 @@ namespace drawinglayer
                                 1.0 - fOpacity));
                     }
 
-                    xRetval = Primitive2DSequence(&xRef, 1);
+                    xRetval = Primitive2DContainer { xRef };
                 }
             }
             else
@@ -184,8 +184,8 @@ namespace drawinglayer
         }
 
         double SvgGradientHelper::createRun(
-            Primitive2DVector& rTargetColor,
-            Primitive2DVector& rTargetOpacity,
+            Primitive2DContainer& rTargetColor,
+            Primitive2DContainer& rTargetOpacity,
             double fPos,
             double fMax,
             const SvgGradientEntryVector& rEntries,
@@ -238,21 +238,21 @@ namespace drawinglayer
             return fPos;
         }
 
-        Primitive2DSequence SvgGradientHelper::createResult(
-            const Primitive2DVector& rTargetColor,
-            const Primitive2DVector& rTargetOpacity,
+        Primitive2DContainer SvgGradientHelper::createResult(
+            const Primitive2DContainer& rTargetColor,
+            const Primitive2DContainer& rTargetOpacity,
             const basegfx::B2DHomMatrix& rUnitGradientToObject,
             bool bInvert) const
         {
-            Primitive2DSequence xRetval;
-            const Primitive2DSequence aTargetColorEntries(Primitive2DVectorToPrimitive2DSequence(rTargetColor, bInvert));
-            const Primitive2DSequence aTargetOpacityEntries(Primitive2DVectorToPrimitive2DSequence(rTargetOpacity, bInvert));
+            Primitive2DContainer xRetval;
+            const Primitive2DContainer aTargetColorEntries(rTargetColor.maybeInvert(bInvert));
+            const Primitive2DContainer aTargetOpacityEntries(rTargetOpacity.maybeInvert(bInvert));
 
-            if(aTargetColorEntries.hasElements())
+            if(!aTargetColorEntries.empty())
             {
                 Primitive2DReference xRefContent;
 
-                if(aTargetOpacityEntries.hasElements())
+                if(!aTargetOpacityEntries.empty())
                 {
                     const Primitive2DReference xRefOpacity = new TransparencePrimitive2D(
                         aTargetColorEntries,
@@ -260,7 +260,7 @@ namespace drawinglayer
 
                     xRefContent = new TransformPrimitive2D(
                         rUnitGradientToObject,
-                        Primitive2DSequence(&xRefOpacity, 1));
+                        Primitive2DContainer { xRefOpacity });
                 }
                 else
                 {
@@ -271,9 +271,9 @@ namespace drawinglayer
 
                 xRefContent = new MaskPrimitive2D(
                     getPolyPolygon(),
-                    Primitive2DSequence(&xRefContent, 1));
+                    Primitive2DContainer { xRefContent });
 
-                xRetval = Primitive2DSequence(&xRefContent, 1);
+                xRetval = Primitive2DContainer { xRefContent };
             }
 
             return xRetval;
@@ -343,8 +343,8 @@ namespace drawinglayer
         }
 
         void SvgLinearGradientPrimitive2D::createAtom(
-            Primitive2DVector& rTargetColor,
-            Primitive2DVector& rTargetOpacity,
+            Primitive2DContainer& rTargetColor,
+            Primitive2DContainer& rTargetOpacity,
             const SvgGradientEntry& rFrom,
             const SvgGradientEntry& rTo,
             sal_Int32 nOffset) const
@@ -376,9 +376,9 @@ namespace drawinglayer
             }
         }
 
-        Primitive2DSequence SvgLinearGradientPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
+        Primitive2DContainer SvgLinearGradientPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
         {
-            Primitive2DSequence xRetval;
+            Primitive2DContainer xRetval;
 
             if(!getPreconditionsChecked())
             {
@@ -454,8 +454,8 @@ namespace drawinglayer
                 const basegfx::B2DRange aUnitRange(aUnitPoly.getB2DRange());
 
                 // prepare result vectors
-                Primitive2DVector aTargetColor;
-                Primitive2DVector aTargetOpacity;
+                Primitive2DContainer aTargetColor;
+                Primitive2DContainer aTargetOpacity;
 
                 if(basegfx::fTools::more(aUnitRange.getWidth(), 0.0))
                 {
@@ -476,17 +476,17 @@ namespace drawinglayer
                         // else the start and end pads are already created and fPos == aUnitRange.getMaxX().
                         // Its possible to express the repeated linear gradient by adding the
                         // transformed central run. Create it this way
-                        Primitive2DSequence aTargetColorEntries(Primitive2DVectorToPrimitive2DSequence(aTargetColor));
-                        Primitive2DSequence aTargetOpacityEntries(Primitive2DVectorToPrimitive2DSequence(aTargetOpacity));
+                        Primitive2DContainer aTargetColorEntries(aTargetColor.maybeInvert());
+                        Primitive2DContainer aTargetOpacityEntries(aTargetOpacity.maybeInvert());
                         aTargetColor.clear();
                         aTargetOpacity.clear();
 
-                        if(aTargetColorEntries.hasElements())
+                        if(!aTargetColorEntries.empty())
                         {
                             // add original central run as group primitive
                             aTargetColor.push_back(new GroupPrimitive2D(aTargetColorEntries));
 
-                            if(aTargetOpacityEntries.hasElements())
+                            if(!aTargetOpacityEntries.empty())
                             {
                                 aTargetOpacity.push_back(new GroupPrimitive2D(aTargetOpacityEntries));
                             }
@@ -515,7 +515,7 @@ namespace drawinglayer
 
                                 aTargetColor.push_back(new TransformPrimitive2D(aTransform, aTargetColorEntries));
 
-                                if(aTargetOpacityEntries.hasElements())
+                                if(!aTargetOpacityEntries.empty())
                                 {
                                     aTargetOpacity.push_back(new TransformPrimitive2D(aTransform, aTargetOpacityEntries));
                                 }
@@ -542,7 +542,7 @@ namespace drawinglayer
 
                                 aTargetColor.push_back(new TransformPrimitive2D(aTransform, aTargetColorEntries));
 
-                                if(aTargetOpacityEntries.hasElements())
+                                if(!aTargetOpacityEntries.empty())
                                 {
                                     aTargetOpacity.push_back(new TransformPrimitive2D(aTransform, aTargetOpacityEntries));
                                 }
@@ -627,8 +627,8 @@ namespace drawinglayer
         }
 
         void SvgRadialGradientPrimitive2D::createAtom(
-            Primitive2DVector& rTargetColor,
-            Primitive2DVector& rTargetOpacity,
+            Primitive2DContainer& rTargetColor,
+            Primitive2DContainer& rTargetOpacity,
             const SvgGradientEntry& rFrom,
             const SvgGradientEntry& rTo,
             sal_Int32 nOffset) const
@@ -720,9 +720,9 @@ namespace drawinglayer
             }
         }
 
-        Primitive2DSequence SvgRadialGradientPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
+        Primitive2DContainer SvgRadialGradientPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
         {
-            Primitive2DSequence xRetval;
+            Primitive2DContainer xRetval;
 
             if(!getPreconditionsChecked())
             {
@@ -800,8 +800,8 @@ namespace drawinglayer
                 fMax = std::max(fMax, basegfx::B2DVector(aUnitRange.getMaxX(), aUnitRange.getMinY()).getLength());
 
                 // prepare result vectors
-                Primitive2DVector aTargetColor;
-                Primitive2DVector aTargetOpacity;
+                Primitive2DContainer aTargetColor;
+                Primitive2DContainer aTargetOpacity;
 
                 if(0.0 < fMax)
                 {
@@ -924,9 +924,9 @@ namespace drawinglayer
 {
     namespace primitive2d
     {
-        Primitive2DSequence SvgLinearAtomPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
+        Primitive2DContainer SvgLinearAtomPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
         {
-            Primitive2DSequence xRetval;
+            Primitive2DContainer xRetval;
             const double fDelta(getOffsetB() - getOffsetA());
 
             if(!basegfx::fTools::equalZero(fDelta))
@@ -951,7 +951,7 @@ namespace drawinglayer
                 const double fUnitStep(1.0 / nSteps);
 
                 // prepare result set (known size)
-                xRetval.realloc(nSteps);
+                xRetval.resize(nSteps);
 
                 for(sal_uInt32 a(0); a < nSteps; a++, fUnitScale += fUnitStep)
                 {
@@ -1011,9 +1011,9 @@ namespace drawinglayer
 {
     namespace primitive2d
     {
-        Primitive2DSequence SvgRadialAtomPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
+        Primitive2DContainer SvgRadialAtomPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
         {
-            Primitive2DSequence xRetval;
+            Primitive2DContainer xRetval;
             const double fDeltaScale(getScaleB() - getScaleA());
 
             if(!basegfx::fTools::equalZero(fDeltaScale))
@@ -1029,7 +1029,7 @@ namespace drawinglayer
                 const double fUnitStep(1.0 / nSteps);
 
                 // prepare result set (known size)
-                xRetval.realloc(nSteps);
+                xRetval.resize(nSteps);
 
                 for(sal_uInt32 a(0); a < nSteps; a++, fUnitScale += fUnitStep)
                 {

drawinglayer/source/primitive2d/textbreakuphelper.cxx

@@ -57,7 +57,7 @@ namespace drawinglayer
         {
         }
 
-        void TextBreakupHelper::breakupPortion(Primitive2DVector& rTempResult, sal_Int32 nIndex, sal_Int32 nLength, bool bWordLineMode)
+        void TextBreakupHelper::breakupPortion(Primitive2DContainer& rTempResult, sal_Int32 nIndex, sal_Int32 nLength, bool bWordLineMode)
         {
             if(nLength && !(nIndex == mrSource.getTextPosition() && nLength == mrSource.getTextLength()))
             {
@@ -189,7 +189,7 @@ namespace drawinglayer
         {
             if(mrSource.getTextLength())
             {
-                Primitive2DVector aTempResult;
+                Primitive2DContainer aTempResult;
                 static css::uno::Reference< css::i18n::XBreakIterator > xBreakIterator;
 
                 if(!xBreakIterator.is())
@@ -281,13 +281,13 @@ namespace drawinglayer
                     }
                 }
 
-                mxResult = Primitive2DVectorToPrimitive2DSequence(aTempResult);
+                mxResult = aTempResult;
             }
         }
 
-        const Primitive2DSequence& TextBreakupHelper::getResult(BreakupUnit aBreakupUnit) const
+        const Primitive2DContainer& TextBreakupHelper::getResult(BreakupUnit aBreakupUnit) const
         {
-            if(!mxResult.hasElements())
+            if(mxResult.empty())
             {
                 const_cast< TextBreakupHelper* >(this)->breakup(aBreakupUnit);
             }

drawinglayer/source/primitive2d/textdecoratedprimitive2d.cxx

@@ -155,16 +155,16 @@ namespace drawinglayer
             // TODO: Handle Font Emphasis Above/Below
         }
 
-        Primitive2DSequence TextDecoratedPortionPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
+        Primitive2DContainer TextDecoratedPortionPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
         {
             if(getWordLineMode())
             {
                 // support for single word mode; split to single word primitives
                 // using TextBreakupHelper
                 const TextBreakupHelper aTextBreakupHelper(*this);
-                const Primitive2DSequence aBroken(aTextBreakupHelper.getResult(BreakupUnit_word));
+                const Primitive2DContainer aBroken(aTextBreakupHelper.getResult(BreakupUnit_word));
 
-                if(aBroken.hasElements())
+                if(!aBroken.empty())
                 {
                     // was indeed split to several words, use as result
                     return aBroken;
@@ -177,7 +177,7 @@ namespace drawinglayer
             }
             std::vector< Primitive2DReference > aNewPrimitives;
             basegfx::tools::B2DHomMatrixBufferedOnDemandDecompose aDecTrans(getTextTransform());
-            Primitive2DSequence aRetval;
+            Primitive2DContainer aRetval;
 
             // create basic geometry such as SimpleTextPrimitive, Overline, Underline,
             // Strikeout, etc...
@@ -189,7 +189,7 @@ namespace drawinglayer
                 getFontAttribute().getSymbol(),
                 getFontAttribute().getVertical(),
                 getFontAttribute().getItalic(),
-        getFontAttribute().getMonospaced(),
+                getFontAttribute().getMonospaced(),
                 false,             // no outline anymore, handled locally
                 getFontAttribute().getRTL(),
                 getFontAttribute().getBiDiStrong());
@@ -202,7 +202,7 @@ namespace drawinglayer
 
             if(nMemberCount)
             {
-                aRetval.realloc(nMemberCount);
+                aRetval.resize(nMemberCount);
 
                 for(sal_uInt32 a(0); a < nMemberCount; a++)
                 {
@@ -211,7 +211,7 @@ namespace drawinglayer
             }
 
             // Handle Shadow, Outline and TextRelief
-            if(aRetval.hasElements())
+            if(!aRetval.empty())
             {
                 // outline AND shadow depend on NO TextRelief (see dialog)
                 const bool bHasTextRelief(TEXT_RELIEF_NONE != getTextRelief());
@@ -279,7 +279,7 @@ namespace drawinglayer
                             aDecTrans.getTranslate(),
                             aDecTrans.getRotate(),
                             aTextEffectStyle2D));
-                        aRetval = Primitive2DSequence(&aNewTextEffect, 1);
+                        aRetval = Primitive2DContainer { aNewTextEffect };
                     }
                     else if(bHasOutline)
                     {
@@ -290,16 +290,16 @@ namespace drawinglayer
                             aDecTrans.getTranslate(),
                             aDecTrans.getRotate(),
                             TEXTEFFECTSTYLE2D_OUTLINE));
-                        aRetval = Primitive2DSequence(&aNewTextEffect, 1);
+                        aRetval = Primitive2DContainer { aNewTextEffect };
                     }
 
                     if(aShadow.is())
                     {
                         // put shadow in front if there is one to paint timely before
                         // but placed behind content
-                        const Primitive2DSequence aContent(aRetval);
-                        aRetval = Primitive2DSequence(&aShadow, 1);
-                        appendPrimitive2DSequenceToPrimitive2DSequence(aRetval, aContent);
+                        const Primitive2DContainer aContent(aRetval);
+                        aRetval = Primitive2DContainer { aShadow };
+                        aRetval.append(aContent);
                     }
                 }
             }

drawinglayer/source/primitive2d/texteffectprimitive2d.cxx

@@ -32,9 +32,9 @@ namespace drawinglayer
     {
         static double fDiscreteSize(1.1);
 
-        Primitive2DSequence TextEffectPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
+        Primitive2DContainer TextEffectPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
         {
-            Primitive2DSequence aRetval;
+            Primitive2DContainer aRetval;
 
             // get the distance of one discrete units from target display. Use between 1.0 and sqrt(2) to
             // have good results on rotated objects, too
@@ -66,7 +66,7 @@ namespace drawinglayer
                         TEXTEFFECTSTYLE2D_RELIEF_EMBOSSED_DEFAULT == getTextEffectStyle2D()
                         || TEXTEFFECTSTYLE2D_RELIEF_ENGRAVED_DEFAULT == getTextEffectStyle2D());
                     basegfx::B2DHomMatrix aTransform(aBackTransform);
-                    aRetval.realloc(2);
+                    aRetval.resize(2);
 
                     if(bEmbossed)
                     {
@@ -95,7 +95,7 @@ namespace drawinglayer
                         aRetval[0] = Primitive2DReference(
                             new TransformPrimitive2D(
                                 aTransform,
-                                Primitive2DSequence(&xModifiedColor, 1)));
+                                Primitive2DContainer { xModifiedColor }));
 
                         // add original, too
                         const basegfx::BColorModifierSharedPtr aBColorModifierToWhite(
@@ -121,7 +121,7 @@ namespace drawinglayer
                         aRetval[0] = Primitive2DReference(
                             new TransformPrimitive2D(
                                 aTransform,
-                                Primitive2DSequence(&xModifiedColor, 1)));
+                                Primitive2DContainer { xModifiedColor }));
 
                         // add original, too
                         aRetval[1] = Primitive2DReference(new GroupPrimitive2D(getTextContent()));
@@ -133,7 +133,7 @@ namespace drawinglayer
                 {
                     // create transform primitives in all directions
                     basegfx::B2DHomMatrix aTransform;
-                    aRetval.realloc(9);
+                    aRetval.resize(9);
 
                     aTransform.set(0, 2, aDistance.getX());
                     aTransform.set(1, 2, 0.0);
@@ -184,7 +184,7 @@ namespace drawinglayer
         }
 
         TextEffectPrimitive2D::TextEffectPrimitive2D(
-            const Primitive2DSequence& rTextContent,
+            const Primitive2DContainer& rTextContent,
             const basegfx::B2DPoint& rRotationCenter,
             double fDirection,
             TextEffectStyle2D eTextEffectStyle2D)
@@ -218,26 +218,26 @@ namespace drawinglayer
             // then will ask 9 times at nearly the same content. This may even be refined here using the
             // TextEffectStyle information, e.g. for TEXTEFFECTSTYLE2D_RELIEF the grow needs only to
             // be in two directions
-            basegfx::B2DRange aRetval(getB2DRangeFromPrimitive2DSequence(getTextContent(), rViewInformation));
+            basegfx::B2DRange aRetval(getTextContent().getB2DRange(rViewInformation));
             aRetval.grow(fDiscreteSize);
 
             return aRetval;
         }
 
-        Primitive2DSequence TextEffectPrimitive2D::get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
+        Primitive2DContainer TextEffectPrimitive2D::get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
         {
             ::osl::MutexGuard aGuard( m_aMutex );
 
-            if(getBuffered2DDecomposition().hasElements())
+            if(!getBuffered2DDecomposition().empty())
             {
                 if(maLastObjectToViewTransformation != rViewInformation.getObjectToViewTransformation())
                 {
                     // conditions of last local decomposition have changed, delete
-                    const_cast< TextEffectPrimitive2D* >(this)->setBuffered2DDecomposition(Primitive2DSequence());
+                    const_cast< TextEffectPrimitive2D* >(this)->setBuffered2DDecomposition(Primitive2DContainer());
                 }
             }
 
-            if(!getBuffered2DDecomposition().hasElements())
+            if(getBuffered2DDecomposition().empty())
             {
                 // remember ViewRange and ViewTransformation
                 const_cast< TextEffectPrimitive2D* >(this)->maLastObjectToViewTransformation = rViewInformation.getObjectToViewTransformation();

drawinglayer/source/primitive2d/texthierarchyprimitive2d.cxx

@@ -30,7 +30,7 @@ namespace drawinglayer
 {
     namespace primitive2d
     {
-        TextHierarchyLinePrimitive2D::TextHierarchyLinePrimitive2D(const Primitive2DSequence& rChildren)
+        TextHierarchyLinePrimitive2D::TextHierarchyLinePrimitive2D(const Primitive2DContainer& rChildren)
         :   GroupPrimitive2D(rChildren)
         {
         }
@@ -47,7 +47,7 @@ namespace drawinglayer
 {
     namespace primitive2d
     {
-        TextHierarchyParagraphPrimitive2D::TextHierarchyParagraphPrimitive2D(const Primitive2DSequence& rChildren)
+        TextHierarchyParagraphPrimitive2D::TextHierarchyParagraphPrimitive2D(const Primitive2DContainer& rChildren)
         :   GroupPrimitive2D(rChildren)
         {
         }
@@ -64,7 +64,7 @@ namespace drawinglayer
 {
     namespace primitive2d
     {
-        TextHierarchyBulletPrimitive2D::TextHierarchyBulletPrimitive2D(const Primitive2DSequence& rChildren)
+        TextHierarchyBulletPrimitive2D::TextHierarchyBulletPrimitive2D(const Primitive2DContainer& rChildren)
         :   GroupPrimitive2D(rChildren)
         {
         }
@@ -81,7 +81,7 @@ namespace drawinglayer
 {
     namespace primitive2d
     {
-        TextHierarchyBlockPrimitive2D::TextHierarchyBlockPrimitive2D(const Primitive2DSequence& rChildren)
+        TextHierarchyBlockPrimitive2D::TextHierarchyBlockPrimitive2D(const Primitive2DContainer& rChildren)
         :   GroupPrimitive2D(rChildren)
         {
         }
@@ -99,7 +99,7 @@ namespace drawinglayer
     namespace primitive2d
     {
         TextHierarchyFieldPrimitive2D::TextHierarchyFieldPrimitive2D(
-            const Primitive2DSequence& rChildren,
+            const Primitive2DContainer& rChildren,
             const FieldType& rFieldType,
             const OUString& rString)
         :   GroupPrimitive2D(rChildren),
@@ -132,7 +132,7 @@ namespace drawinglayer
 {
     namespace primitive2d
     {
-        TextHierarchyEditPrimitive2D::TextHierarchyEditPrimitive2D(const Primitive2DSequence& rChildren)
+        TextHierarchyEditPrimitive2D::TextHierarchyEditPrimitive2D(const Primitive2DContainer& rChildren)
         :   GroupPrimitive2D(rChildren)
         {
         }

drawinglayer/source/primitive2d/textlineprimitive2d.cxx

@@ -31,9 +31,9 @@ namespace drawinglayer
 {
     namespace primitive2d
     {
-        Primitive2DSequence TextLinePrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
+        Primitive2DContainer TextLinePrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
         {
-            Primitive2DSequence xRetval;
+            Primitive2DContainer xRetval;
 
             if(TEXT_LINE_NONE != getTextLine())
             {
@@ -219,7 +219,7 @@ namespace drawinglayer
                 }
 
                 // add primitive
-                appendPrimitive2DReferenceToPrimitive2DSequence(xRetval, aNewPrimitive);
+                xRetval.push_back(aNewPrimitive);
 
                 if(bDoubleLine)
                 {
@@ -245,9 +245,8 @@ namespace drawinglayer
                     aTransform.translate(aTranslate.getX(), aTranslate.getY());
 
                     // add transform primitive
-                    const Primitive2DSequence aContent(&aNewPrimitive, 1);
-                    appendPrimitive2DReferenceToPrimitive2DSequence(xRetval,
-                        Primitive2DReference(new TransformPrimitive2D(aTransform, aContent)));
+                    const Primitive2DContainer aContent { aNewPrimitive };
+                    xRetval.push_back( Primitive2DReference(new TransformPrimitive2D(aTransform, aContent)));
                 }
             }
 

drawinglayer/source/primitive2d/textprimitive2d.cxx

@@ -167,9 +167,9 @@ namespace drawinglayer
             }
         }
 
-        Primitive2DSequence TextSimplePortionPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
+        Primitive2DContainer TextSimplePortionPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
         {
-            Primitive2DSequence aRetval;
+            Primitive2DContainer aRetval;
 
             if(getTextLength())
             {
@@ -185,7 +185,7 @@ namespace drawinglayer
                 if(nCount)
                 {
                     // alloc space for the primitives
-                    aRetval.realloc(nCount);
+                    aRetval.resize(nCount);
 
                     // color-filled polypolygons
                     for(sal_uInt32 a(0L); a < nCount; a++)
@@ -210,7 +210,7 @@ namespace drawinglayer
                             fRotate,
                             TEXTEFFECTSTYLE2D_OUTLINE));
 
-                        aRetval = Primitive2DSequence(&aNewTextEffect, 1);
+                        aRetval = Primitive2DContainer { aNewTextEffect };
                     }
                 }
             }

drawinglayer/source/primitive2d/textstrikeoutprimitive2d.cxx

@@ -66,7 +66,7 @@ namespace drawinglayer
 {
     namespace primitive2d
     {
-        Primitive2DSequence TextCharacterStrikeoutPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
+        Primitive2DContainer TextCharacterStrikeoutPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
         {
             // strikeout with character
             const OUString aSingleCharString(getStrikeoutChar());
@@ -108,7 +108,7 @@ namespace drawinglayer
                     getLocale(),
                     getFontColor()));
 
-            return Primitive2DSequence(&xReference, 1);
+            return Primitive2DContainer { xReference };
         }
 
         TextCharacterStrikeoutPrimitive2D::TextCharacterStrikeoutPrimitive2D(
@@ -151,7 +151,7 @@ namespace drawinglayer
 {
     namespace primitive2d
     {
-        Primitive2DSequence TextGeometryStrikeoutPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
+        Primitive2DContainer TextGeometryStrikeoutPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
         {
             OSL_ENSURE(TEXT_STRIKEOUT_SLASH != getTextStrikeout() && TEXT_STRIKEOUT_X != getTextStrikeout(),
                 "Wrong TEXT_STRIKEOUT type; a TextCharacterStrikeoutPrimitive2D should be used (!)");
@@ -205,7 +205,7 @@ namespace drawinglayer
 
             // add primitive
             const attribute::LineAttribute aLineAttribute(getFontColor(), fStrikeoutHeight, basegfx::B2DLineJoin::NONE);
-            Primitive2DSequence xRetval(1);
+            Primitive2DContainer xRetval(1);
             xRetval[0] = Primitive2DReference(new PolygonStrokePrimitive2D(aStrikeoutLine, aLineAttribute));
 
             if(bDoubleLine)
@@ -227,7 +227,7 @@ namespace drawinglayer
                 aTransform.translate(aTranslate.getX(), aTranslate.getY());
 
                 // add transform primitive
-                appendPrimitive2DReferenceToPrimitive2DSequence(xRetval,
+                xRetval.push_back(
                     Primitive2DReference(
                         new TransformPrimitive2D(
                             aTransform,

drawinglayer/source/primitive2d/transformprimitive2d.cxx

@@ -33,7 +33,7 @@ namespace drawinglayer
     {
         TransformPrimitive2D::TransformPrimitive2D(
             const basegfx::B2DHomMatrix& rTransformation,
-            const Primitive2DSequence& rChildren)
+            const Primitive2DContainer& rChildren)
         :   GroupPrimitive2D(rChildren),
             maTransformation(rTransformation)
         {
@@ -53,7 +53,7 @@ namespace drawinglayer
 
         basegfx::B2DRange TransformPrimitive2D::getB2DRange(const geometry::ViewInformation2D& rViewInformation) const
         {
-            basegfx::B2DRange aRetval(getB2DRangeFromPrimitive2DSequence(getChildren(), rViewInformation));
+            basegfx::B2DRange aRetval(getChildren().getB2DRange(rViewInformation));
             aRetval.transform(getTransformation());
             return aRetval;
         }

drawinglayer/source/primitive2d/transparenceprimitive2d.cxx

@@ -31,8 +31,8 @@ namespace drawinglayer
     namespace primitive2d
     {
         TransparencePrimitive2D::TransparencePrimitive2D(
-            const Primitive2DSequence& rChildren,
-            const Primitive2DSequence& rTransparence)
+            const Primitive2DContainer& rChildren,
+            const Primitive2DContainer& rTransparence)
         :   GroupPrimitive2D(rChildren),
             maTransparence(rTransparence)
         {

drawinglayer/source/primitive2d/unifiedtransparenceprimitive2d.cxx

@@ -37,7 +37,7 @@ namespace drawinglayer
     namespace primitive2d
     {
         UnifiedTransparencePrimitive2D::UnifiedTransparencePrimitive2D(
-            const Primitive2DSequence& rChildren,
+            const Primitive2DContainer& rChildren,
             double fTransparence)
         :   GroupPrimitive2D(rChildren),
             mfTransparence(fTransparence)
@@ -60,10 +60,10 @@ namespace drawinglayer
         {
             // do not use the fallback to decomposition here since for a correct BoundRect we also
             // need invisible (1.0 == getTransparence()) geometry; these would be deleted in the decomposition
-            return getB2DRangeFromPrimitive2DSequence(getChildren(), rViewInformation);
+            return getChildren().getB2DRange( rViewInformation);
         }
 
-        Primitive2DSequence UnifiedTransparencePrimitive2D::get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
+        Primitive2DContainer UnifiedTransparencePrimitive2D::get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
         {
             if(0.0 == getTransparence())
             {
@@ -88,22 +88,22 @@ namespace drawinglayer
 
                 // I will take the last one here. The small overhead of two primitives will only be
                 // used when UnifiedTransparencePrimitive2D is not handled directly.
-                const basegfx::B2DRange aPolygonRange(getB2DRangeFromPrimitive2DSequence(getChildren(), rViewInformation));
+                const basegfx::B2DRange aPolygonRange(getChildren().getB2DRange(rViewInformation));
                 const basegfx::B2DPolygon aPolygon(basegfx::tools::createPolygonFromRect(aPolygonRange));
                 const basegfx::BColor aGray(getTransparence(), getTransparence(), getTransparence());
-                Primitive2DSequence aTransparenceContent(2);
+                Primitive2DContainer aTransparenceContent(2);
 
                 aTransparenceContent[0] = Primitive2DReference(new PolyPolygonColorPrimitive2D(basegfx::B2DPolyPolygon(aPolygon), aGray));
                 aTransparenceContent[1] = Primitive2DReference(new PolygonHairlinePrimitive2D(aPolygon, aGray));
 
                 // create sub-transparence group with a gray-colored rectangular fill polygon
                 const Primitive2DReference xRefB(new TransparencePrimitive2D(getChildren(), aTransparenceContent));
-                return Primitive2DSequence(&xRefB, 1L);
+                return Primitive2DContainer { xRefB };
             }
             else
             {
                 // completely transparent or invalid definition, add nothing
-                return Primitive2DSequence();
+                return Primitive2DContainer();
             }
         }
 

drawinglayer/source/primitive2d/wallpaperprimitive2d.cxx

@@ -33,9 +33,9 @@ namespace drawinglayer
 {
     namespace primitive2d
     {
-        Primitive2DSequence WallpaperBitmapPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
+        Primitive2DContainer WallpaperBitmapPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
         {
-            Primitive2DSequence aRetval;
+            Primitive2DContainer aRetval;
 
             if(!getLocalObjectRange().isEmpty() && !getBitmapEx().IsEmpty())
             {
@@ -59,7 +59,7 @@ namespace drawinglayer
                                 getBitmapEx(),
                                 aObjectTransform));
 
-                        aRetval = Primitive2DSequence(&xReference, 1);
+                        aRetval = Primitive2DContainer { xReference };
                     }
                     else
                     {
@@ -157,7 +157,7 @@ namespace drawinglayer
                                 new BitmapPrimitive2D(
                                     getBitmapEx(),
                                     aObjectTransform));
-                            aRetval = Primitive2DSequence(&xReference, 1);
+                            aRetval = Primitive2DContainer { xReference };
 
                             // clip when not completely inside object range
                             bNeedsClipping = !getLocalObjectRange().isInside(aTargetRange);
@@ -194,7 +194,7 @@ namespace drawinglayer
                                 new drawinglayer::primitive2d::FillGraphicPrimitive2D(
                                     aObjectTransform,
                                     aFillGraphicAttribute));
-                            aRetval = Primitive2DSequence(&xFillBitmap, 1);
+                            aRetval = Primitive2DContainer { xFillBitmap };
 
                             // always embed tiled fill to clipping
                             bNeedsClipping = true;
@@ -209,7 +209,7 @@ namespace drawinglayer
                                 new drawinglayer::primitive2d::MaskPrimitive2D(
                                     aPolyPolygon,
                                     aRetval));
-                            aRetval = Primitive2DSequence(&xClippedFill, 1);
+                            aRetval = Primitive2DContainer { xClippedFill };
                         }
                     }
                 }

drawinglayer/source/primitive2d/wrongspellprimitive2d.cxx

@@ -29,7 +29,7 @@ namespace drawinglayer
 {
     namespace primitive2d
     {
-        Primitive2DSequence WrongSpellPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
+        Primitive2DContainer WrongSpellPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
         {
             // ATM this decompose is view-independent, what the original VCL-Display is not. To mimic
             // the old behaviour here if wanted it is necessary to add get2DDecomposition and implement
@@ -68,7 +68,7 @@ namespace drawinglayer
 
             // create the waveline primitive
             Primitive2DReference xPrimitive(new PolygonWavePrimitive2D(aPolygon, aLineAttribute, fWaveWidth, 0.5 * fWaveWidth));
-            Primitive2DSequence xRetval(&xPrimitive, 1);
+            Primitive2DContainer xRetval { xPrimitive };
 
             return xRetval;
         }

drawinglayer/source/processor2d/baseprocessor2d.cxx

@@ -18,6 +18,7 @@
  */
 
 #include <drawinglayer/processor2d/baseprocessor2d.hxx>
+#include <comphelper/sequence.hxx>
 
 
 
@@ -42,11 +43,11 @@ namespace drawinglayer
         {
         }
 
-        void BaseProcessor2D::process(const primitive2d::Primitive2DSequence& rSource)
+        void BaseProcessor2D::process(const primitive2d::Primitive2DContainer& rSource)
         {
-            if(rSource.hasElements())
+            if(!rSource.empty())
             {
-                const sal_Int32 nCount(rSource.getLength());
+                const sal_Int32 nCount(rSource.size());
 
                 for(sal_Int32 a(0L); a < nCount; a++)
                 {
@@ -67,7 +68,7 @@ namespace drawinglayer
                         {
                             // unknown implementation, use UNO API call instead and process recursively
                             const uno::Sequence< beans::PropertyValue >& rViewParameters(getViewInformation2D().getViewInformationSequence());
-                            process(xReference->getDecomposition(rViewParameters));
+                            process(comphelper::sequenceToContainer<primitive2d::Primitive2DContainer>(xReference->getDecomposition(rViewParameters)));
                         }
                     }
                 }

drawinglayer/source/processor2d/contourextractor2d.cxx

@@ -149,17 +149,17 @@ namespace drawinglayer
                 {
                     // 2D Scene primitive containing 3D stuff; extract 2D contour in world coordinates
                     const primitive2d::ScenePrimitive2D& rScenePrimitive2DCandidate(static_cast< const primitive2d::ScenePrimitive2D& >(rCandidate));
-                    const primitive2d::Primitive2DSequence xExtracted2DSceneGeometry(rScenePrimitive2DCandidate.getGeometry2D());
-                    const primitive2d::Primitive2DSequence xExtracted2DSceneShadow(rScenePrimitive2DCandidate.getShadow2D(getViewInformation2D()));
+                    const primitive2d::Primitive2DContainer xExtracted2DSceneGeometry(rScenePrimitive2DCandidate.getGeometry2D());
+                    const primitive2d::Primitive2DContainer xExtracted2DSceneShadow(rScenePrimitive2DCandidate.getShadow2D(getViewInformation2D()));
 
                     // process content
-                    if(xExtracted2DSceneGeometry.hasElements())
+                    if(!xExtracted2DSceneGeometry.empty())
                     {
                         process(xExtracted2DSceneGeometry);
                     }
 
                     // process content
-                    if(xExtracted2DSceneShadow.hasElements())
+                    if(!xExtracted2DSceneShadow.empty())
                     {
                         process(xExtracted2DSceneShadow);
                     }

drawinglayer/source/processor2d/hittestprocessor2d.cxx

@@ -506,9 +506,9 @@ namespace drawinglayer
                     // so force this primitive to process its children directly if the switch is set
                     // (which is the default). Else, ignore invisible content
                     const primitive2d::HiddenGeometryPrimitive2D& rHiddenGeometry(static_cast< const primitive2d::HiddenGeometryPrimitive2D& >(rCandidate));
-                       const primitive2d::Primitive2DSequence& rChildren = rHiddenGeometry.getChildren();
+                    const primitive2d::Primitive2DContainer& rChildren = rHiddenGeometry.getChildren();
 
-                    if(rChildren.hasElements())
+                    if(!rChildren.empty())
                     {
                         if(getUseInvisiblePrimitiveContent())
                         {

drawinglayer/source/processor2d/textaspolygonextractor2d.cxx

@@ -161,7 +161,7 @@ namespace drawinglayer
                 {
                     const primitive2d::ModifiedColorPrimitive2D& rModifiedColorCandidate(static_cast< const primitive2d::ModifiedColorPrimitive2D& >(rCandidate));
 
-                    if(rModifiedColorCandidate.getChildren().hasElements())
+                    if(!rModifiedColorCandidate.getChildren().empty())
                     {
                         maBColorModifierStack.push(rModifiedColorCandidate.getColorModifier());
                         process(rModifiedColorCandidate.getChildren());

drawinglayer/source/processor2d/vclmetafileprocessor2d.cxx

@@ -237,13 +237,13 @@ namespace drawinglayer
     namespace processor2d
     {
         Rectangle VclMetafileProcessor2D::impDumpToMetaFile(
-            const primitive2d::Primitive2DSequence& rContent,
+            const primitive2d::Primitive2DContainer& rContent,
             GDIMetaFile& o_rContentMetafile)
         {
             // Prepare VDev, MetaFile and connections
             OutputDevice* pLastOutputDevice = mpOutputDevice;
             GDIMetaFile* pLastMetafile = mpMetaFile;
-            basegfx::B2DRange aPrimitiveRange(primitive2d::getB2DRangeFromPrimitive2DSequence(rContent, getViewInformation2D()));
+            basegfx::B2DRange aPrimitiveRange(rContent.getB2DRange(getViewInformation2D()));
 
             // transform primitive range with current transformation (e.g shadow offset)
             aPrimitiveRange.transform(maCurrentTransformation);
@@ -1006,7 +1006,7 @@ namespace drawinglayer
                     }
 
                     // process recursively
-                    const primitive2d::Primitive2DSequence rContent = rFieldPrimitive.get2DDecomposition(getViewInformation2D());
+                    const primitive2d::Primitive2DContainer rContent = rFieldPrimitive.get2DDecomposition(getViewInformation2D());
                     process(rContent);
 
                     // for the end comment the type is not relevant yet, they are all the same. Just add.
@@ -1015,7 +1015,7 @@ namespace drawinglayer
                     if(mpPDFExtOutDevData && drawinglayer::primitive2d::FIELD_TYPE_URL == rFieldPrimitive.getType())
                     {
                         // emulate data handling from ImpEditEngine::Paint
-                        const basegfx::B2DRange aViewRange(primitive2d::getB2DRangeFromPrimitive2DSequence(rContent, getViewInformation2D()));
+                        const basegfx::B2DRange aViewRange(rContent.getB2DRange(getViewInformation2D()));
                         const Rectangle aRectLogic(
                             (sal_Int32)floor(aViewRange.getMinX()), (sal_Int32)floor(aViewRange.getMinY()),
                             (sal_Int32)ceil(aViewRange.getMaxX()), (sal_Int32)ceil(aViewRange.getMaxY()));
@@ -1476,7 +1476,7 @@ namespace drawinglayer
                                 aLocalPolyPolygon,
                                 rHatchCandidate.getBackgroundColor()));
 
-                        process(primitive2d::Primitive2DSequence(&xBackground, 1));
+                        process(primitive2d::Primitive2DContainer { xBackground });
                     }
 
                     SvtGraphicFill* pSvtGraphicFill = nullptr;
@@ -1752,7 +1752,7 @@ namespace drawinglayer
                     // mask group. Special handling for MetaFiles.
                     const primitive2d::MaskPrimitive2D& rMaskCandidate = static_cast< const primitive2d::MaskPrimitive2D& >(rCandidate);
 
-                    if(rMaskCandidate.getChildren().hasElements())
+                    if(!rMaskCandidate.getChildren().empty())
                     {
                         basegfx::B2DPolyPolygon aMask(rMaskCandidate.getMask());
 
@@ -1820,9 +1820,9 @@ namespace drawinglayer
                     // - uses DrawTransparent for single PolyPoylgons directly. Can be detected by
                     //   checking the content for single PolyPolygonColorPrimitive2D
                     const primitive2d::UnifiedTransparencePrimitive2D& rUniTransparenceCandidate = static_cast< const primitive2d::UnifiedTransparencePrimitive2D& >(rCandidate);
-                    const primitive2d::Primitive2DSequence rContent = rUniTransparenceCandidate.getChildren();
+                    const primitive2d::Primitive2DContainer rContent = rUniTransparenceCandidate.getChildren();
 
-                    if(rContent.hasElements())
+                    if(!rContent.empty())
                     {
                         if(0.0 == rUniTransparenceCandidate.getTransparence())
                         {
@@ -1836,7 +1836,7 @@ namespace drawinglayer
                             const primitive2d::PolyPolygonColorPrimitive2D* pPoPoColor = nullptr;
                             static bool bForceToMetafile(false);
 
-                            if(!bForceToMetafile && 1 == rContent.getLength())
+                            if(!bForceToMetafile && 1 == rContent.size())
                             {
                                 const primitive2d::Primitive2DReference xReference(rContent[0]);
                                 pPoPoColor = dynamic_cast< const primitive2d::PolyPolygonColorPrimitive2D* >(xReference.get());
@@ -1960,17 +1960,17 @@ namespace drawinglayer
                     // If that detection goes wrong, I have to create an transparence-blended bitmap. Eventually
                     // do that in stripes, else RenderTransparencePrimitive2D may just be used
                     const primitive2d::TransparencePrimitive2D& rTransparenceCandidate = static_cast< const primitive2d::TransparencePrimitive2D& >(rCandidate);
-                    const primitive2d::Primitive2DSequence rContent = rTransparenceCandidate.getChildren();
-                    const primitive2d::Primitive2DSequence rTransparence = rTransparenceCandidate.getTransparence();
+                    const primitive2d::Primitive2DContainer& rContent = rTransparenceCandidate.getChildren();
+                    const primitive2d::Primitive2DContainer& rTransparence = rTransparenceCandidate.getTransparence();
 
-                    if(rContent.hasElements() && rTransparence.hasElements())
+                    if(!rContent.empty() && !rTransparence.empty())
                     {
                         // try to identify a single FillGradientPrimitive2D in the
                         // transparence part of the primitive
                         const primitive2d::FillGradientPrimitive2D* pFiGradient = nullptr;
                         static bool bForceToBigTransparentVDev(false);
 
-                        if(!bForceToBigTransparentVDev && 1 == rTransparence.getLength())
+                        if(!bForceToBigTransparentVDev && 1 == rTransparence.size())
                         {
                             const primitive2d::Primitive2DReference xReference(rTransparence[0]);
                             pFiGradient = dynamic_cast< const primitive2d::FillGradientPrimitive2D* >(xReference.get());
@@ -2007,7 +2007,7 @@ namespace drawinglayer
                             // transparence primitives with non-trivial transparence content) i will for now not
                             // refine to tiling here.
 
-                            basegfx::B2DRange aViewRange(primitive2d::getB2DRangeFromPrimitive2DSequence(rContent, getViewInformation2D()));
+                            basegfx::B2DRange aViewRange(rContent.getB2DRange(getViewInformation2D()));
                             aViewRange.transform(maCurrentTransformation);
                             const Rectangle aRectLogic(
                                 (sal_Int32)floor(aViewRange.getMinX()), (sal_Int32)floor(aViewRange.getMinY()),

drawinglayer/source/processor2d/vclmetafileprocessor2d.hxx

@@ -74,7 +74,7 @@ namespace drawinglayer
         private:
             /// local helper(s)
             Rectangle impDumpToMetaFile(
-                const primitive2d::Primitive2DSequence& rContent,
+                const primitive2d::Primitive2DContainer& rContent,
                 GDIMetaFile& o_rContentMetafile);
             void impConvertFillGradientAttributeToVCLGradient(
                 Gradient& o_rVCLGradient,

drawinglayer/source/processor2d/vclpixelprocessor2d.cxx

@@ -867,9 +867,9 @@ namespace drawinglayer
                     // Detect if a single PolyPolygonColorPrimitive2D is contained; in that case,
                     // use the faster OutputDevice::DrawTransparent method
                     const primitive2d::UnifiedTransparencePrimitive2D& rUniTransparenceCandidate = static_cast< const primitive2d::UnifiedTransparencePrimitive2D& >(rCandidate);
-                    const primitive2d::Primitive2DSequence rContent = rUniTransparenceCandidate.getChildren();
+                    const primitive2d::Primitive2DContainer rContent = rUniTransparenceCandidate.getChildren();
 
-                    if(rContent.hasElements())
+                    if(!rContent.empty())
                     {
                         if(0.0 == rUniTransparenceCandidate.getTransparence())
                         {
@@ -884,7 +884,7 @@ namespace drawinglayer
                             // natively), so i am now enabling this shortcut
                             static bool bAllowUsingDrawTransparent(true);
 
-                            if(bAllowUsingDrawTransparent && 1 == rContent.getLength())
+                            if(bAllowUsingDrawTransparent && 1 == rContent.size())
                             {
                                 const primitive2d::Primitive2DReference xReference(rContent[0]);
                                 const primitive2d::BasePrimitive2D* pBasePrimitive = dynamic_cast< const primitive2d::BasePrimitive2D* >(xReference.get());

drawinglayer/source/processor2d/vclprocessor2d.cxx

@@ -864,7 +864,7 @@ namespace drawinglayer
         // mask group. Force output to VDev and create mask from given mask
         void VclProcessor2D::RenderMaskPrimitive2DPixel(const primitive2d::MaskPrimitive2D& rMaskCandidate)
         {
-            if(rMaskCandidate.getChildren().hasElements())
+            if(!rMaskCandidate.getChildren().empty())
             {
                 basegfx::B2DPolyPolygon aMask(rMaskCandidate.getMask());
 
@@ -917,7 +917,7 @@ namespace drawinglayer
         // modified color group. Force output to unified color.
         void VclProcessor2D::RenderModifiedColorPrimitive2D(const primitive2d::ModifiedColorPrimitive2D& rModifiedCandidate)
         {
-            if(rModifiedCandidate.getChildren().hasElements())
+            if(!rModifiedCandidate.getChildren().empty())
             {
                 maBColorModifierStack.push(rModifiedCandidate.getColorModifier());
                 process(rModifiedCandidate.getChildren());
@@ -930,7 +930,7 @@ namespace drawinglayer
         {
             static bool bForceToDecomposition(false);
 
-            if(rTransCandidate.getChildren().hasElements())
+            if(!rTransCandidate.getChildren().empty())
             {
                 if(bForceToDecomposition)
                 {
@@ -947,7 +947,7 @@ namespace drawinglayer
                     else if(rTransCandidate.getTransparence() > 0.0 && rTransCandidate.getTransparence() < 1.0)
                     {
                         // transparence is in visible range
-                        basegfx::B2DRange aRange(primitive2d::getB2DRangeFromPrimitive2DSequence(rTransCandidate.getChildren(), getViewInformation2D()));
+                        basegfx::B2DRange aRange(rTransCandidate.getChildren().getB2DRange(getViewInformation2D()));
                         aRange.transform(maCurrentTransformation);
                         impBufferDevice aBufferDevice(*mpOutputDevice, aRange, true);
 
@@ -974,9 +974,9 @@ namespace drawinglayer
         // sub-transparence group. Draw to VDev first.
         void VclProcessor2D::RenderTransparencePrimitive2D(const primitive2d::TransparencePrimitive2D& rTransCandidate)
         {
-            if(rTransCandidate.getChildren().hasElements())
+            if(!rTransCandidate.getChildren().empty())
             {
-                basegfx::B2DRange aRange(primitive2d::getB2DRangeFromPrimitive2DSequence(rTransCandidate.getChildren(), getViewInformation2D()));
+                basegfx::B2DRange aRange(rTransCandidate.getChildren().getB2DRange(getViewInformation2D()));
                 aRange.transform(maCurrentTransformation);
                 impBufferDevice aBufferDevice(*mpOutputDevice, aRange, true);
 

drawinglayer/source/processor3d/geometry2dextractor.cxx

@@ -94,7 +94,7 @@ namespace drawinglayer
                         a2DHairline.transform(getObjectTransformation());
                         const basegfx::BColor aModifiedColor(maBColorModifierStack.getModifiedColor(rPrimitive.getBColor()));
                         const primitive2d::Primitive2DReference xRef(new primitive2d::PolygonHairlinePrimitive2D(a2DHairline, aModifiedColor));
-                        primitive2d::appendPrimitive2DReferenceToPrimitive2DSequence(maPrimitive2DSequence, xRef);
+                        maPrimitive2DSequence.push_back(xRef);
                     }
                     break;
                 }
@@ -109,7 +109,7 @@ namespace drawinglayer
                         a2DFill.transform(getObjectTransformation());
                         const basegfx::BColor aModifiedColor(maBColorModifierStack.getModifiedColor(rPrimitive.getMaterial().getColor()));
                         const primitive2d::Primitive2DReference xRef(new primitive2d::PolyPolygonColorPrimitive2D(a2DFill, aModifiedColor));
-                        primitive2d::appendPrimitive2DReferenceToPrimitive2DSequence(maPrimitive2DSequence, xRef);
+                        maPrimitive2DSequence.push_back(xRef);
                     }
                     break;
                 }

drawinglayer/source/processor3d/shadow3dextractor.cxx

@@ -53,8 +53,8 @@ namespace drawinglayer
                     const primitive3d::ShadowPrimitive3D& rPrimitive = static_cast< const primitive3d::ShadowPrimitive3D& >(rCandidate);
 
                     // set new target
-                    primitive2d::Primitive2DVector aNewSubList;
-                    primitive2d::Primitive2DVector* pLastTargetSequence = mpPrimitive2DSequence;
+                    primitive2d::Primitive2DContainer aNewSubList;
+                    primitive2d::Primitive2DContainer* pLastTargetSequence = mpPrimitive2DSequence;
                     mpPrimitive2DSequence = &aNewSubList;
 
                     // activate convert
@@ -78,13 +78,13 @@ namespace drawinglayer
                     primitive2d::BasePrimitive2D* pNew = new primitive2d::ShadowPrimitive2D(
                         rPrimitive.getShadowTransform(),
                         rPrimitive.getShadowColor(),
-                        primitive2d::Primitive2DVectorToPrimitive2DSequence(aNewSubList));
+                        aNewSubList);
 
                     if(basegfx::fTools::more(rPrimitive.getShadowTransparence(), 0.0))
                     {
                         // create simpleTransparencePrimitive, add created primitives
                         const primitive2d::Primitive2DReference xRef(pNew);
-                        const primitive2d::Primitive2DSequence aNewTransPrimitiveVector(&xRef, 1);
+                        const primitive2d::Primitive2DContainer aNewTransPrimitiveVector { xRef };
 
                         pNew = new primitive2d::UnifiedTransparencePrimitive2D(
                             aNewTransPrimitiveVector,
@@ -253,10 +253,6 @@ namespace drawinglayer
         {
             OSL_ENSURE(0 == maPrimitive2DSequence.size(),
                 "OOps, someone used Shadow3DExtractingProcessor, but did not fetch the results (!)");
-            for(size_t a(0); a < maPrimitive2DSequence.size(); a++)
-            {
-                delete maPrimitive2DSequence[a];
-            }
         }
 
         basegfx::B2DPolygon Shadow3DExtractingProcessor::impDoShadowProjection(const basegfx::B3DPolygon& rSource)
@@ -300,9 +296,9 @@ namespace drawinglayer
             return aRetval;
         }
 
-        const primitive2d::Primitive2DSequence Shadow3DExtractingProcessor::getPrimitive2DSequence() const
+        const primitive2d::Primitive2DContainer& Shadow3DExtractingProcessor::getPrimitive2DSequence() const
         {
-            return Primitive2DVectorToPrimitive2DSequence(maPrimitive2DSequence);
+            return maPrimitive2DSequence;
         }
 
     } // end of namespace processor3d

drawinglayer/source/tools/converters.cxx

@@ -37,7 +37,7 @@ namespace drawinglayer
     namespace tools
     {
         BitmapEx convertToBitmapEx(
-            const drawinglayer::primitive2d::Primitive2DSequence& rSeq,
+            const drawinglayer::primitive2d::Primitive2DContainer& rSeq,
             const geometry::ViewInformation2D& rViewInformation2D,
             sal_uInt32 nDiscreteWidth,
             sal_uInt32 nDiscreteHeight,
@@ -48,12 +48,12 @@ namespace drawinglayer
             static bool bDoSaveForVisualControl(false);
 #endif
 
-            if(rSeq.hasElements() && nDiscreteWidth && nDiscreteHeight)
+            if(!rSeq.empty() && nDiscreteWidth && nDiscreteHeight)
             {
                 // get destination size in pixels
                 const MapMode aMapModePixel(MAP_PIXEL);
                 const sal_uInt32 nViewVisibleArea(nDiscreteWidth * nDiscreteHeight);
-                drawinglayer::primitive2d::Primitive2DSequence aSequence(rSeq);
+                drawinglayer::primitive2d::Primitive2DContainer aSequence(rSeq);
 
                 if(nViewVisibleArea > nMaxQuadratPixels)
                 {
@@ -67,7 +67,7 @@ namespace drawinglayer
                             basegfx::tools::createScaleB2DHomMatrix(fReduceFactor, fReduceFactor),
                             rSeq));
 
-                    aSequence = drawinglayer::primitive2d::Primitive2DSequence(&aEmbed, 1);
+                    aSequence = drawinglayer::primitive2d::Primitive2DContainer { aEmbed };
                 }
 
                 const Point aEmptyPoint;
@@ -120,7 +120,7 @@ namespace drawinglayer
                             basegfx::BColorModifierSharedPtr(
                                 new basegfx::BColorModifier_replace(
                                     basegfx::BColor(0.0, 0.0, 0.0)))));
-                    const primitive2d::Primitive2DSequence xSeq(&xRef, 1);
+                    const primitive2d::Primitive2DContainer xSeq { xRef };
 
                     // render
                     pContentProcessor->process(xSeq);

include/drawinglayer/primitive2d/animatedprimitive2d.hxx

@@ -71,7 +71,7 @@ namespace drawinglayer
             /// constructor
             AnimatedSwitchPrimitive2D(
                 const animation::AnimationEntry& rAnimationEntry,
-                const Primitive2DSequence& rChildren,
+                const Primitive2DContainer& rChildren,
                 bool bIsTextAnimation);
 
             /// destructor - needed due to mpAnimationEntry
@@ -92,7 +92,7 @@ namespace drawinglayer
                 depends on the point in time, so the default implementation is
                 not useful here, it needs to be handled locally
              */
-            virtual Primitive2DSequence get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
+            virtual Primitive2DContainer get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
         };
     } // end of namespace primitive2d
 } // end of namespace drawinglayer
@@ -116,11 +116,11 @@ namespace drawinglayer
             /// constructor
             AnimatedBlinkPrimitive2D(
                 const animation::AnimationEntry& rAnimationEntry,
-                const Primitive2DSequence& rChildren,
+                const Primitive2DContainer& rChildren,
                 bool bIsTextAnimation);
 
             /// create local decomposition
-            virtual Primitive2DSequence get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
+            virtual Primitive2DContainer get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
 
             /// provide unique ID
             DeclPrimitive2DIDBlock()
@@ -153,11 +153,11 @@ namespace drawinglayer
             AnimatedInterpolatePrimitive2D(
                 const std::vector< basegfx::B2DHomMatrix >& rmMatrixStack,
                 const animation::AnimationEntry& rAnimationEntry,
-                const Primitive2DSequence& rChildren,
+                const Primitive2DContainer& rChildren,
                 bool bIsTextAnimation);
 
             /// create local decomposition
-            virtual Primitive2DSequence get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
+            virtual Primitive2DContainer get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
 
             /// provide unique ID
             DeclPrimitive2DIDBlock()

include/drawinglayer/primitive2d/backgroundcolorprimitive2d.hxx

@@ -55,7 +55,7 @@ namespace drawinglayer
 
         protected:
             /// create local decomposition
-            virtual Primitive2DSequence create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
+            virtual Primitive2DContainer create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
 
         public:
             /// constructor
@@ -77,7 +77,7 @@ namespace drawinglayer
             DeclPrimitive2DIDBlock()
 
             /// Override standard getDecomposition call to be view-dependent here
-            virtual Primitive2DSequence get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
+            virtual Primitive2DContainer get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
         };
     } // end of namespace primitive2d
 } // end of namespace drawinglayer

include/drawinglayer/primitive2d/baseprimitive2d.hxx

@@ -52,6 +52,24 @@ namespace drawinglayer { namespace primitive2d {
     typedef cppu::WeakComponentImplHelper1< css::graphic::XPrimitive2D > BasePrimitive2DImplBase;
     typedef css::uno::Reference< css::graphic::XPrimitive2D > Primitive2DReference;
     typedef css::uno::Sequence< Primitive2DReference > Primitive2DSequence;
+
+
+    class DRAWINGLAYER_DLLPUBLIC SAL_WARN_UNUSED Primitive2DContainer : public std::vector< Primitive2DReference >
+    {
+    public:
+        explicit Primitive2DContainer() {}
+        explicit Primitive2DContainer( size_type count ) : std::vector< Primitive2DReference >(count) {}
+        Primitive2DContainer( const Primitive2DContainer& other ) : std::vector< Primitive2DReference >(other) {}
+        Primitive2DContainer( const std::vector< Primitive2DReference >& other ) : std::vector< Primitive2DReference >(other) {}
+        Primitive2DContainer( std::initializer_list<Primitive2DReference> init ) : std::vector< Primitive2DReference >(init) {}
+
+        void append(const Primitive2DContainer& rSource);
+        void append(const Primitive2DSequence& rSource);
+        bool operator==(const Primitive2DContainer& rB) const;
+        bool operator!=(const Primitive2DContainer& rB) const { return !operator==(rB); }
+        basegfx::B2DRange getB2DRange(const geometry::ViewInformation2D& aViewInformation) const;
+        Primitive2DContainer maybeInvert(bool bInvert = false) const;
+    };
 }}
 
 
@@ -163,7 +181,7 @@ namespace drawinglayer
             virtual sal_uInt32 getPrimitive2DID() const = 0;
 
             /// The default implementation will return an empty sequence
-            virtual Primitive2DSequence get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const;
+            virtual Primitive2DContainer get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const;
 
 
             // Methods from XPrimitive2D
@@ -223,20 +241,20 @@ namespace drawinglayer
         {
         private:
             /// a sequence used for buffering the last create2DDecomposition() result
-            Primitive2DSequence                             maBuffered2DDecomposition;
+            Primitive2DContainer                             maBuffered2DDecomposition;
 
         protected:
             /** access methods to maBuffered2DDecomposition. The usage of this methods may allow
                 later thread-safe stuff to be added if needed. Only to be used by getDecomposition()
                 implementations for buffering the last decomposition.
              */
-            const Primitive2DSequence& getBuffered2DDecomposition() const { return maBuffered2DDecomposition; }
-            void setBuffered2DDecomposition(const Primitive2DSequence& rNew) { maBuffered2DDecomposition = rNew; }
+            const Primitive2DContainer& getBuffered2DDecomposition() const { return maBuffered2DDecomposition; }
+            void setBuffered2DDecomposition(const Primitive2DContainer& rNew) { maBuffered2DDecomposition = rNew; }
 
             /** method which is to be used to implement the local decomposition of a 2D primitive. The default
                 implementation will just return an empty decomposition
              */
-            virtual Primitive2DSequence create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const;
+            virtual Primitive2DContainer create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const;
 
         public:
             // constructor/destructor
@@ -248,7 +266,7 @@ namespace drawinglayer
                 overridden and the ViewInformation2D for the last decomposition need to be remembered, too, and
                 be used in the next call to decide if the buffered decomposition may be reused or not.
              */
-            virtual Primitive2DSequence get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
+            virtual Primitive2DContainer get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
         };
     } // end of namespace primitive2d
 } // end of namespace drawinglayer
@@ -261,8 +279,7 @@ namespace drawinglayer
     namespace primitive2d
     {
         /// support to handle a sequence of primitives as stl vector and convert it during creation
-        typedef ::std::vector< BasePrimitive2D* > Primitive2DVector;
-        Primitive2DSequence DRAWINGLAYER_DLLPUBLIC Primitive2DVectorToPrimitive2DSequence(const Primitive2DVector& rSource, bool bInvert = false);
+        Primitive2DSequence DRAWINGLAYER_DLLPUBLIC Primitive2DVectorToPrimitive2DSequence(const Primitive2DContainer& rSource, bool bInvert = false);
 
         /// get B2DRange from a given Primitive2DReference
         basegfx::B2DRange DRAWINGLAYER_DLLPUBLIC getB2DRangeFromPrimitive2DReference(const Primitive2DReference& rCandidate, const geometry::ViewInformation2D& aViewInformation);
@@ -280,6 +297,7 @@ namespace drawinglayer
 
         /// concatenate sequence
         void DRAWINGLAYER_DLLPUBLIC appendPrimitive2DSequenceToPrimitive2DSequence(Primitive2DSequence& rDest, const Primitive2DSequence& rSource);
+        void DRAWINGLAYER_DLLPUBLIC appendPrimitive2DSequenceToPrimitive2DSequence(Primitive2DSequence& rDest, const Primitive2DContainer& rSource);
 
         /// concatenate single Primitive2D
         void DRAWINGLAYER_DLLPUBLIC appendPrimitive2DReferenceToPrimitive2DSequence(Primitive2DSequence& rDest, const Primitive2DReference& rSource);

include/drawinglayer/primitive2d/borderlineprimitive2d.hxx

@@ -95,7 +95,7 @@ namespace drawinglayer
                     const geometry::ViewInformation2D& rViewInformation) const;
 
             /// create local decomposition
-            virtual Primitive2DSequence create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
+            virtual Primitive2DContainer create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
 
         public:
             /// constructor

include/drawinglayer/primitive2d/controlprimitive2d.hxx

@@ -64,7 +64,7 @@ namespace drawinglayer
 
         protected:
             /// local decomposition
-            virtual Primitive2DSequence create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
+            virtual Primitive2DContainer create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
 
         public:
             /// constructor
@@ -101,7 +101,7 @@ namespace drawinglayer
             DeclPrimitive2DIDBlock()
 
             /// Override standard getDecomposition to be view-dependent here
-            virtual Primitive2DSequence get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
+            virtual Primitive2DContainer get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
         };
     } // end of namespace primitive2d
 } // end of namespace drawinglayer

include/drawinglayer/primitive2d/cropprimitive2d.hxx

@@ -69,7 +69,7 @@ namespace drawinglayer
         public:
             /// constructor
             CropPrimitive2D(
-                const Primitive2DSequence& rChildren,
+                const Primitive2DContainer& rChildren,
                 const basegfx::B2DHomMatrix& rTransformation,
                 double fCropLeft,
                 double fCropTop,
@@ -87,7 +87,7 @@ namespace drawinglayer
             virtual bool operator==(const BasePrimitive2D& rPrimitive) const override;
 
             /// local decomposition
-            virtual Primitive2DSequence get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
+            virtual Primitive2DContainer get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
 
             /// provide unique ID
             DeclPrimitive2DIDBlock()

include/drawinglayer/primitive2d/discretebitmapprimitive2d.hxx

@@ -50,7 +50,7 @@ namespace drawinglayer
 
         protected:
             /// local decomposition.
-            virtual Primitive2DSequence create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
+            virtual Primitive2DContainer create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
 
         public:
             /// constructor

include/drawinglayer/primitive2d/discreteshadowprimitive2d.hxx

@@ -90,7 +90,7 @@ namespace drawinglayer
 
         protected:
             /// create local decomposition
-            virtual Primitive2DSequence create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
+            virtual Primitive2DContainer create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
 
         public:
             /// constructor

include/drawinglayer/primitive2d/embedded3dprimitive2d.hxx

@@ -67,7 +67,7 @@ namespace drawinglayer
             basegfx::B3DRange                                   maScene3DRange;
 
             /// the primitiveSequence for on-demand created shadow primitives (see mbShadow3DChecked)
-            Primitive2DSequence                                 maShadowPrimitives;
+            Primitive2DContainer                                   maShadowPrimitives;
 
             /// #i96669# add simple range buffering for this primitive
             basegfx::B2DRange                                   maB2DRange;
@@ -83,7 +83,7 @@ namespace drawinglayer
 
         protected:
             /// local decomposition.
-            virtual Primitive2DSequence create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
+            virtual Primitive2DContainer create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
 
         public:
             /// constructor

include/drawinglayer/primitive2d/epsprimitive2d.hxx

@@ -46,7 +46,7 @@ namespace drawinglayer
 
         protected:
             /// create local decomposition
-            virtual Primitive2DSequence create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
+            virtual Primitive2DContainer create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
 
         public:
             /// constructor

include/drawinglayer/primitive2d/fillgradientprimitive2d.hxx

@@ -69,21 +69,21 @@ namespace drawinglayer
             void generateMatricesAndColors(
                 std::vector< drawinglayer::texture::B2DHomMatrixAndBColor >& rEntries,
                 basegfx::BColor& rOuterColor) const;
-            Primitive2DSequence createOverlappingFill(
+            Primitive2DContainer createOverlappingFill(
                 const std::vector< drawinglayer::texture::B2DHomMatrixAndBColor >& rEntries,
                 const basegfx::BColor& rOuterColor,
                 const basegfx::B2DPolygon& rUnitPolygon) const;
-            Primitive2DSequence createNonOverlappingFill(
+            Primitive2DContainer createNonOverlappingFill(
                 const std::vector< drawinglayer::texture::B2DHomMatrixAndBColor >& rEntries,
                 const basegfx::BColor& rOuterColor,
                 const basegfx::B2DPolygon& rUnitPolygon) const;
 
         protected:
             /// local helper
-            Primitive2DSequence createFill(bool bOverlapping) const;
+            Primitive2DContainer createFill(bool bOverlapping) const;
 
             /// local decomposition.
-            virtual Primitive2DSequence create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
+            virtual Primitive2DContainer create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
 
         public:
             /// constructors. The one without definition range will use output range as definition range

include/drawinglayer/primitive2d/fillgraphicprimitive2d.hxx

@@ -56,7 +56,7 @@ namespace drawinglayer
 
         protected:
             /// local decomposition.
-            virtual Primitive2DSequence create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
+            virtual Primitive2DContainer create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
 
         public:
             /// constructor

include/drawinglayer/primitive2d/fillhatchprimitive2d.hxx

@@ -66,7 +66,7 @@ namespace drawinglayer
 
         protected:
             /// local decomposition.
-            virtual Primitive2DSequence create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
+            virtual Primitive2DContainer create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
 
         public:
             /// constructors. The one without definition range will use output range as definition range
@@ -93,7 +93,7 @@ namespace drawinglayer
             virtual basegfx::B2DRange getB2DRange(const geometry::ViewInformation2D& rViewInformation) const override;
 
             /// Override standard getDecomposition to be view-dependent here
-            virtual Primitive2DSequence get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
+            virtual Primitive2DContainer get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
 
             /// provide unique ID
             DeclPrimitive2DIDBlock()

include/drawinglayer/primitive2d/graphicprimitive2d.hxx

@@ -61,7 +61,7 @@ namespace drawinglayer
 
         protected:
             /// local decomposition
-            virtual Primitive2DSequence create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
+            virtual Primitive2DContainer create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
 
         public:
             /// constructor(s)

include/drawinglayer/primitive2d/graphicprimitivehelper2d.hxx

@@ -42,7 +42,7 @@ namespace drawinglayer
             Bitmaps (with the sub-categories animated bitmap, and SVG),
             and Metafiles.
          */
-        Primitive2DSequence create2DDecompositionOfGraphic(
+        Primitive2DContainer create2DDecompositionOfGraphic(
             const Graphic& rGraphic,
             const basegfx::B2DHomMatrix& rTransform);
 
@@ -50,8 +50,8 @@ namespace drawinglayer
             of ModifiedColorPrimitive2D's to get all the needed modifications
             applied.
         */
-        Primitive2DSequence create2DColorModifierEmbeddingsAsNeeded(
-            const Primitive2DSequence& rChildren,
+        Primitive2DContainer create2DColorModifierEmbeddingsAsNeeded(
+            const Primitive2DContainer& rChildren,
             GraphicDrawMode aGraphicDrawMode = GRAPHICDRAWMODE_STANDARD,
             double fLuminance = 0.0,        // [-1.0 .. 1.0]
             double fContrast = 0.0,         // [-1.0 .. 1.0]

include/drawinglayer/primitive2d/gridprimitive2d.hxx

@@ -71,7 +71,7 @@ namespace drawinglayer
 
         protected:
             /// create local decomposition
-            virtual Primitive2DSequence create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
+            virtual Primitive2DContainer create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
 
         public:
             /// constructor
@@ -107,7 +107,7 @@ namespace drawinglayer
             DeclPrimitive2DIDBlock()
 
             /// Override standard getDecomposition to be view-dependent here
-            virtual Primitive2DSequence get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
+            virtual Primitive2DContainer get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
         };
     } // end of namespace primitive2d
 } // end of namespace drawinglayer

include/drawinglayer/primitive2d/groupprimitive2d.hxx

@@ -67,20 +67,20 @@ namespace drawinglayer
         {
         private:
             /// the children. Declared private since this shall never be changed at all after construction
-            Primitive2DSequence                             maChildren;
+            Primitive2DContainer                             maChildren;
 
         public:
             /// constructor
-            explicit GroupPrimitive2D(const Primitive2DSequence& rChildren);
+            explicit GroupPrimitive2D(const Primitive2DContainer& rChildren);
 
             /// data read access
-            const Primitive2DSequence& getChildren() const { return maChildren; }
+            const Primitive2DContainer& getChildren() const { return maChildren; }
 
             /// compare operator
             virtual bool operator==( const BasePrimitive2D& rPrimitive ) const override;
 
             /// local decomposition. Implementation will just return children
-            virtual Primitive2DSequence get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
+            virtual Primitive2DContainer get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
 
             /// provide unique ID
             DeclPrimitive2DIDBlock()

include/drawinglayer/primitive2d/helplineprimitive2d.hxx

@@ -75,7 +75,7 @@ namespace drawinglayer
 
         protected:
             /// create local decomposition
-            virtual Primitive2DSequence create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
+            virtual Primitive2DContainer create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
 
         public:
             /// constructor
@@ -102,7 +102,7 @@ namespace drawinglayer
             DeclPrimitive2DIDBlock()
 
             /// Override standard getDecomposition to be view-dependent here
-            virtual Primitive2DSequence get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
+            virtual Primitive2DContainer get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
         };
     } // end of namespace primitive2d
 } // end of namespace drawinglayer

include/drawinglayer/primitive2d/hiddengeometryprimitive2d.hxx

@@ -41,7 +41,7 @@ namespace drawinglayer
         class DRAWINGLAYER_DLLPUBLIC HiddenGeometryPrimitive2D : public GroupPrimitive2D
         {
         public:
-            explicit HiddenGeometryPrimitive2D(const Primitive2DSequence& rChildren);
+            explicit HiddenGeometryPrimitive2D(const Primitive2DContainer& rChildren);
 
             // despite returning an empty decomposition since it's no visualisation data,
             // range calculation is intended to use hidden geometry, so
@@ -49,7 +49,7 @@ namespace drawinglayer
             virtual basegfx::B2DRange getB2DRange(const geometry::ViewInformation2D& rViewInformation) const override;
 
             /// local decomposition. Implementation will return empty Primitive2DSequence
-            virtual Primitive2DSequence get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
+            virtual Primitive2DContainer get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
 
             // provide unique ID
             DeclPrimitive2DIDBlock()

include/drawinglayer/primitive2d/invertprimitive2d.hxx

@@ -44,7 +44,7 @@ namespace drawinglayer
         {
         public:
             /// constructor
-            explicit InvertPrimitive2D(const Primitive2DSequence& rChildren);
+            explicit InvertPrimitive2D(const Primitive2DContainer& rChildren);
 
             /// provide unique ID
             DeclPrimitive2DIDBlock()

include/drawinglayer/primitive2d/markerarrayprimitive2d.hxx

@@ -57,7 +57,7 @@ namespace drawinglayer
 
         protected:
             /// create local decomposition
-            virtual Primitive2DSequence create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
+            virtual Primitive2DContainer create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
 
         public:
             /// constructor

include/drawinglayer/primitive2d/maskprimitive2d.hxx

@@ -55,7 +55,7 @@ namespace drawinglayer
             /// constructor
             MaskPrimitive2D(
                 const basegfx::B2DPolyPolygon& rMask,
-                const Primitive2DSequence& rChildren);
+                const Primitive2DContainer& rChildren);
 
             /// data read access
             const basegfx::B2DPolyPolygon& getMask() const { return maMask; }

include/drawinglayer/primitive2d/mediaprimitive2d.hxx

@@ -61,7 +61,7 @@ namespace drawinglayer
 
         protected:
             /// local decomposition
-            virtual Primitive2DSequence create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
+            virtual Primitive2DContainer create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
 
         public:
             /// constructor

include/drawinglayer/primitive2d/metafileprimitive2d.hxx

@@ -64,7 +64,7 @@ namespace drawinglayer
 
         protected:
             /// local decomposition.
-            virtual Primitive2DSequence create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
+            virtual Primitive2DContainer create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
         public:
             /// constructor
             MetafilePrimitive2D(

include/drawinglayer/primitive2d/modifiedcolorprimitive2d.hxx

@@ -59,7 +59,7 @@ namespace drawinglayer
         public:
             /// constructor
             ModifiedColorPrimitive2D(
-                const Primitive2DSequence& rChildren,
+                const Primitive2DContainer& rChildren,
                 const basegfx::BColorModifierSharedPtr& rColorModifier);
 
             /// data read access

include/drawinglayer/primitive2d/objectinfoprimitive2d.hxx

@@ -45,7 +45,7 @@ namespace drawinglayer
         public:
             /// constructor
             ObjectInfoPrimitive2D(
-                const Primitive2DSequence& rChildren,
+                const Primitive2DContainer& rChildren,
                 const OUString& rName,
                 const OUString& rTitle,
                 const OUString& rDesc);

include/drawinglayer/primitive2d/pagepreviewprimitive2d.hxx

@@ -50,7 +50,7 @@ namespace drawinglayer
             const css::uno::Reference< css::drawing::XDrawPage > mxDrawPage;
 
             /// the PageContent
-            Primitive2DSequence                         maPageContent;
+            Primitive2DContainer                           maPageContent;
 
             /// the own geometry
             basegfx::B2DHomMatrix                       maTransform;
@@ -65,7 +65,7 @@ namespace drawinglayer
 
         protected:
             /// local decomposition. Implementation will just return children
-            virtual Primitive2DSequence create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
+            virtual Primitive2DContainer create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
 
         public:
             /// constructor
@@ -74,12 +74,12 @@ namespace drawinglayer
                 const basegfx::B2DHomMatrix& rTransform,
                 double fContentWidth,
                 double fContentHeight,
-                const Primitive2DSequence& rPageContent,
+                const Primitive2DContainer& rPageContent,
                 bool bKeepAspectRatio);
 
             /// data read access
             const css::uno::Reference< css::drawing::XDrawPage >& getXDrawPage() const { return mxDrawPage; }
-            const Primitive2DSequence& getPageContent() const { return maPageContent; }
+            const Primitive2DContainer& getPageContent() const { return maPageContent; }
             const basegfx::B2DHomMatrix& getTransform() const { return maTransform; }
             double getContentWidth() const { return mfContentWidth; }
             double getContentHeight() const { return mfContentHeight; }

include/drawinglayer/primitive2d/patternfillprimitive2d.hxx

@@ -43,23 +43,23 @@ namespace drawinglayer
         {
         private:
             const basegfx::B2DPolyPolygon       maMask;
-            const Primitive2DSequence           maChildren;
+            const Primitive2DContainer             maChildren;
             const basegfx::B2DRange             maReferenceRange;
 
         protected:
             /// create local decomposition
-            virtual Primitive2DSequence create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
+            virtual Primitive2DContainer create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
 
         public:
             /// constructor
             PatternFillPrimitive2D(
                 const basegfx::B2DPolyPolygon& rMask,
-                const Primitive2DSequence& rChildren,
+                const Primitive2DContainer& rChildren,
                 const basegfx::B2DRange& rReferenceRange);
 
             /// data read access
             const basegfx::B2DPolyPolygon& getMask() const { return maMask; }
-            const Primitive2DSequence& getChildren() const { return maChildren; }
+            const Primitive2DContainer& getChildren() const { return maChildren; }
             const basegfx::B2DRange& getReferenceRange() const { return maReferenceRange; }
 
             /// compare operator

include/drawinglayer/primitive2d/polygonprimitive2d.hxx

@@ -110,7 +110,7 @@ namespace drawinglayer
 
         protected:
             /// local decomposition.
-            virtual Primitive2DSequence create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
+            virtual Primitive2DContainer create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
 
         public:
             /// constructor
@@ -133,7 +133,7 @@ namespace drawinglayer
             virtual basegfx::B2DRange getB2DRange(const geometry::ViewInformation2D& rViewInformation) const override;
 
             /// Override standard getDecomposition to be view-dependent here
-            virtual Primitive2DSequence get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
+            virtual Primitive2DContainer get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
 
             /// provide unique ID
             DeclPrimitive2DIDBlock()
@@ -168,7 +168,7 @@ namespace drawinglayer
 
         protected:
             /// local decomposition.
-            virtual Primitive2DSequence create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
+            virtual Primitive2DContainer create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
 
         public:
             /// constructor
@@ -220,7 +220,7 @@ namespace drawinglayer
 
         protected:
             /// local decomposition.
-            virtual Primitive2DSequence create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
+            virtual Primitive2DContainer create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
 
         public:
             /// constructor
@@ -276,7 +276,7 @@ namespace drawinglayer
 
         protected:
             /// local decomposition.
-            virtual Primitive2DSequence create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
+            virtual Primitive2DContainer create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
 
         public:
             /// constructor

include/drawinglayer/primitive2d/polypolygonprimitive2d.hxx

@@ -57,7 +57,7 @@ namespace drawinglayer
 
         protected:
             /// local decomposition.
-            virtual Primitive2DSequence create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
+            virtual Primitive2DContainer create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
 
         public:
             /// constructor
@@ -107,7 +107,7 @@ namespace drawinglayer
 
         protected:
             /// local decomposition.
-            virtual Primitive2DSequence create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
+            virtual Primitive2DContainer create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
 
         public:
             /// constructor
@@ -162,7 +162,7 @@ namespace drawinglayer
 
         protected:
             /// local decomposition.
-            virtual Primitive2DSequence create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
+            virtual Primitive2DContainer create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
 
         public:
             /// constructor
@@ -263,7 +263,7 @@ namespace drawinglayer
 
         protected:
             /// local decomposition.
-            virtual Primitive2DSequence create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
+            virtual Primitive2DContainer create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
 
         public:
             /// constructors. The one without definition range will use output range as definition range
@@ -319,7 +319,7 @@ namespace drawinglayer
 
         protected:
             /// local decomposition.
-            virtual Primitive2DSequence create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
+            virtual Primitive2DContainer create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
 
         public:
             /// constructors. The one without definition range will use output range as definition range
@@ -375,7 +375,7 @@ namespace drawinglayer
 
         protected:
             /// local decomposition.
-            virtual Primitive2DSequence create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
+            virtual Primitive2DContainer create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
 
         public:
             /// constructors. The one without definition range will use output range as definition range
@@ -435,7 +435,7 @@ namespace drawinglayer
 
         protected:
             /// local decomposition.
-            virtual Primitive2DSequence create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
+            virtual Primitive2DContainer create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
 
         public:
             /// constructor

include/drawinglayer/primitive2d/primitivetools2d.hxx

@@ -66,7 +66,7 @@ namespace drawinglayer
             double getDiscreteUnit() const { return mfDiscreteUnit; }
 
             /// Override standard getDecomposition to be view-dependent here
-            virtual Primitive2DSequence get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
+            virtual Primitive2DContainer get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
         };
     } // end of namespace primitive2d
 } // end of namespace drawinglayer
@@ -105,7 +105,7 @@ namespace drawinglayer
             const basegfx::B2DRange& getViewport() const { return maViewport; }
 
             /// Override standard getDecomposition to be view-dependent here
-            virtual Primitive2DSequence get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
+            virtual Primitive2DContainer get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
         };
     } // end of namespace primitive2d
 } // end of namespace drawinglayer
@@ -144,7 +144,7 @@ namespace drawinglayer
             const basegfx::B2DHomMatrix& getViewTransformation() const { return maViewTransformation; }
 
             /// Override standard getDecomposition to be view-dependent here
-            virtual Primitive2DSequence get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
+            virtual Primitive2DContainer get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
         };
     } // end of namespace primitive2d
 } // end of namespace drawinglayer
@@ -187,7 +187,7 @@ namespace drawinglayer
             const basegfx::B2DHomMatrix& getObjectTransformation() const { return maObjectTransformation; }
 
             /// Override standard getDecomposition to be view-dependent here
-            virtual Primitive2DSequence get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
+            virtual Primitive2DContainer get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
         };
     } // end of namespace primitive2d
 } // end of namespace drawinglayer

include/drawinglayer/primitive2d/sceneprimitive2d.hxx

@@ -72,7 +72,7 @@ namespace drawinglayer
             geometry::ViewInformation3D                         maViewInformation3D;
 
             /// the primitiveSequence for on-demand created shadow primitives (see mbShadow3DChecked)
-            Primitive2DSequence                                 maShadowPrimitives;
+            Primitive2DContainer                                   maShadowPrimitives;
 
             /// bitfield
             /** flag if given 3D geometry is already cheched for shadow definitions and 2d shadows
@@ -100,7 +100,7 @@ namespace drawinglayer
 
         protected:
             /// local decomposition.
-            virtual Primitive2DSequence create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
+            virtual Primitive2DContainer create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
 
         public:
             /// public helpers
@@ -108,8 +108,8 @@ namespace drawinglayer
                 the 3D content is not converted to a bitmap visualisation but to projected 2D geometry. This
                 helper is useful e.g. for Contour extraction or HitTests.
               */
-            Primitive2DSequence getGeometry2D() const;
-            Primitive2DSequence getShadow2D(const geometry::ViewInformation2D& rViewInformation) const;
+            Primitive2DContainer getGeometry2D() const;
+            Primitive2DContainer getShadow2D(const geometry::ViewInformation2D& rViewInformation) const;
 
             /** Fast HitTest which uses the last buffered BitmapEx from the last
                 rendered area if available. The return value describes if the check
@@ -147,7 +147,7 @@ namespace drawinglayer
             DeclPrimitive2DIDBlock()
 
             /// get local decomposition. Override since this decomposition is view-dependent
-            virtual Primitive2DSequence get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
+            virtual Primitive2DContainer get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
         };
     } // end of namespace primitive2d
 } // end of namespace drawinglayer

include/drawinglayer/primitive2d/shadowprimitive2d.hxx

@@ -60,7 +60,7 @@ namespace drawinglayer
             ShadowPrimitive2D(
                 const basegfx::B2DHomMatrix& rShadowTransform,
                 const basegfx::BColor& rShadowColor,
-                const Primitive2DSequence& rChildren);
+                const Primitive2DContainer& rChildren);
 
             /// data read access
             const basegfx::B2DHomMatrix& getShadowTransform() const { return maShadowTransform; }
@@ -73,7 +73,7 @@ namespace drawinglayer
             virtual basegfx::B2DRange getB2DRange(const geometry::ViewInformation2D& rViewInformation) const override;
 
             ///  create decomposition
-            virtual Primitive2DSequence get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
+            virtual Primitive2DContainer get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
 
             /// provide unique ID
             DeclPrimitive2DIDBlock()

include/drawinglayer/primitive2d/structuretagprimitive2d.hxx

@@ -53,7 +53,7 @@ namespace drawinglayer
             /// constructor
             StructureTagPrimitive2D(
                 const vcl::PDFWriter::StructElement& rStructureElement,
-                const Primitive2DSequence& rChildren);
+                const Primitive2DContainer& rChildren);
 
             /// data read access
             const vcl::PDFWriter::StructElement& getStructureElement() const { return maStructureElement; }

include/drawinglayer/primitive2d/svggradientprimitive2d.hxx

@@ -121,24 +121,24 @@ namespace drawinglayer
 
         protected:
             /// local helpers
-            Primitive2DSequence createSingleGradientEntryFill() const;
+            Primitive2DContainer createSingleGradientEntryFill() const;
             virtual void createAtom(
-                Primitive2DVector& rTargetColor,
-                Primitive2DVector& rTargetOpacity,
+                Primitive2DContainer& rTargetColor,
+                Primitive2DContainer& rTargetOpacity,
                 const SvgGradientEntry& rFrom,
                 const SvgGradientEntry& rTo,
                 sal_Int32 nOffset) const = 0;
             double createRun(
-                Primitive2DVector& rTargetColor,
-                Primitive2DVector& rTargetOpacity,
+                Primitive2DContainer& rTargetColor,
+                Primitive2DContainer& rTargetOpacity,
                 double fPos,
                 double fMax,
                 const SvgGradientEntryVector& rEntries,
                 sal_Int32 nOffset) const;
             virtual void checkPreconditions();
-            Primitive2DSequence createResult(
-                const Primitive2DVector& rTargetColor,
-                const Primitive2DVector& rTargetOpacity,
+            Primitive2DContainer createResult(
+                const Primitive2DContainer& rTargetColor,
+                const Primitive2DContainer& rTargetOpacity,
                 const basegfx::B2DHomMatrix& rUnitGradientToObject,
                 bool bInvert = false) const;
             bool getCreatesContent() const { return mbCreatesContent; }
@@ -189,15 +189,15 @@ namespace drawinglayer
         protected:
             /// local helpers
             virtual void createAtom(
-                Primitive2DVector& rTargetColor,
-                Primitive2DVector& rTargetOpacity,
+                Primitive2DContainer& rTargetColor,
+                Primitive2DContainer& rTargetOpacity,
                 const SvgGradientEntry& rFrom,
                 const SvgGradientEntry& rTo,
                 sal_Int32 nOffset) const override;
             virtual void checkPreconditions() override;
 
             /// local decomposition.
-            virtual Primitive2DSequence create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
+            virtual Primitive2DContainer create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
 
         public:
             /// constructor
@@ -258,15 +258,15 @@ namespace drawinglayer
         protected:
             /// local helpers
             virtual void createAtom(
-                Primitive2DVector& rTargetColor,
-                Primitive2DVector& rTargetOpacity,
+                Primitive2DContainer& rTargetColor,
+                Primitive2DContainer& rTargetOpacity,
                 const SvgGradientEntry& rFrom,
                 const SvgGradientEntry& rTo,
                 sal_Int32 nOffset) const override;
             virtual void checkPreconditions() override;
 
             /// local decomposition.
-            virtual Primitive2DSequence create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
+            virtual Primitive2DContainer create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
 
         public:
             /// constructor
@@ -321,7 +321,7 @@ namespace drawinglayer
         protected:
 
             /// local decomposition.
-            virtual Primitive2DSequence create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
+            virtual Primitive2DContainer create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
 
         public:
             /// constructor
@@ -383,7 +383,7 @@ namespace drawinglayer
         protected:
 
             /// local decomposition.
-            virtual Primitive2DSequence create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
+            virtual Primitive2DContainer create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
 
         public:
             /// constructor

include/drawinglayer/primitive2d/textbreakuphelper.hxx

@@ -42,7 +42,7 @@ namespace drawinglayer
         {
         private:
             const TextSimplePortionPrimitive2D&     mrSource;
-            Primitive2DSequence                     mxResult;
+            Primitive2DContainer                       mxResult;
             TextLayouterDevice                      maTextLayouter;
             basegfx::tools::B2DHomMatrixBufferedOnDemandDecompose maDecTrans;
 
@@ -50,7 +50,7 @@ namespace drawinglayer
             bool                                    mbNoDXArray : 1;
 
             /// create a portion from nIndex to nLength and append to rTempResult
-            void breakupPortion(Primitive2DVector& rTempResult, sal_Int32 nIndex, sal_Int32 nLength, bool bWordLineMode);
+            void breakupPortion(Primitive2DContainer& rTempResult, sal_Int32 nIndex, sal_Int32 nLength, bool bWordLineMode);
 
             /// breakup complete primitive
             void breakup(BreakupUnit aBreakupUnit);
@@ -70,7 +70,7 @@ namespace drawinglayer
             virtual ~TextBreakupHelper();
 
             /// get result
-            const Primitive2DSequence& getResult(BreakupUnit aBreakupUnit = BreakupUnit_character) const;
+            const Primitive2DContainer& getResult(BreakupUnit aBreakupUnit = BreakupUnit_character) const;
         };
 
     } // end of namespace primitive2d

include/drawinglayer/primitive2d/textdecoratedprimitive2d.hxx

@@ -75,7 +75,7 @@ namespace drawinglayer
 
         protected:
             /// local decomposition.
-            virtual Primitive2DSequence create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
+            virtual Primitive2DContainer create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
 
         public:
             /// constructor

include/drawinglayer/primitive2d/texteffectprimitive2d.hxx

@@ -51,7 +51,7 @@ namespace drawinglayer
         {
         private:
             /// the text (or other) content
-            Primitive2DSequence                             maTextContent;
+            Primitive2DContainer                               maTextContent;
 
             /// the style to apply, the direction and the rotation center
             const basegfx::B2DPoint                         maRotationCenter;
@@ -65,18 +65,18 @@ namespace drawinglayer
 
         protected:
             /// create local decomposition
-            virtual Primitive2DSequence create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
+            virtual Primitive2DContainer create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
 
         public:
             /// construcor
             TextEffectPrimitive2D(
-                const Primitive2DSequence& rTextContent,
+                const Primitive2DContainer& rTextContent,
                 const basegfx::B2DPoint& rRotationCenter,
                 double fDirection,
                 TextEffectStyle2D eTextEffectStyle2D);
 
             /// data read access
-            const Primitive2DSequence& getTextContent() const { return maTextContent; }
+            const Primitive2DContainer& getTextContent() const { return maTextContent; }
             const basegfx::B2DPoint& getRotationCenter() const { return maRotationCenter; }
             double getDirection() const { return mfDirection; }
             TextEffectStyle2D getTextEffectStyle2D() const { return meTextEffectStyle2D; }
@@ -94,7 +94,7 @@ namespace drawinglayer
             DeclPrimitive2DIDBlock()
 
             /// Override standard getDecomposition to be view-dependent here
-            virtual Primitive2DSequence get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
+            virtual Primitive2DContainer get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
         };
     } // end of namespace primitive2d
 } // end of namespace drawinglayer

include/drawinglayer/primitive2d/texthierarchyprimitive2d.hxx

@@ -45,7 +45,7 @@ namespace drawinglayer
         private:
         public:
             /// constructor
-            explicit TextHierarchyLinePrimitive2D(const Primitive2DSequence& rChildren);
+            explicit TextHierarchyLinePrimitive2D(const Primitive2DContainer& rChildren);
 
             /// provide unique ID
             DeclPrimitive2DIDBlock()
@@ -68,7 +68,7 @@ namespace drawinglayer
         private:
         public:
             /// constructor
-            explicit TextHierarchyBulletPrimitive2D(const Primitive2DSequence& rChildren);
+            explicit TextHierarchyBulletPrimitive2D(const Primitive2DContainer& rChildren);
 
             /// provide unique ID
             DeclPrimitive2DIDBlock()
@@ -91,7 +91,7 @@ namespace drawinglayer
         private:
         public:
             /// constructor
-            explicit TextHierarchyParagraphPrimitive2D(const Primitive2DSequence& rChildren);
+            explicit TextHierarchyParagraphPrimitive2D(const Primitive2DContainer& rChildren);
 
             /// provide unique ID
             DeclPrimitive2DIDBlock()
@@ -114,7 +114,7 @@ namespace drawinglayer
         private:
         public:
             /// constructor
-            explicit TextHierarchyBlockPrimitive2D(const Primitive2DSequence& rChildren);
+            explicit TextHierarchyBlockPrimitive2D(const Primitive2DContainer& rChildren);
 
             /// provide unique ID
             DeclPrimitive2DIDBlock()
@@ -159,7 +159,7 @@ namespace drawinglayer
         public:
             /// constructor
             TextHierarchyFieldPrimitive2D(
-                const Primitive2DSequence& rChildren,
+                const Primitive2DContainer& rChildren,
                 const FieldType& rFieldType,
                 const OUString& rString);
 
@@ -197,7 +197,7 @@ namespace drawinglayer
         private:
         public:
             /// constructor
-            explicit TextHierarchyEditPrimitive2D(const Primitive2DSequence& rChildren);
+            explicit TextHierarchyEditPrimitive2D(const Primitive2DContainer& rChildren);
 
             /// provide unique ID
             DeclPrimitive2DIDBlock()

include/drawinglayer/primitive2d/textlineprimitive2d.hxx

@@ -48,7 +48,7 @@ namespace drawinglayer
 
         protected:
             /// local decomposition.
-            virtual Primitive2DSequence create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
+            virtual Primitive2DContainer create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
 
         public:
             /// constructor