[Libreoffice-commits] core.git: drawinglayer/source include/drawinglayer solenv/clang-format
Tomaž Vajngerl (via logerrit)
logerrit at kemper.freedesktop.org
Wed Jan 1 19:59:30 UTC 2020
drawinglayer/source/primitive2d/baseprimitive2d.cxx | 666 ++++++++++---------
include/drawinglayer/primitive2d/baseprimitive2d.hxx | 540 ++++++++-------
solenv/clang-format/blacklist | 2
3 files changed, 664 insertions(+), 544 deletions(-)
New commits:
commit a3569c7b89a7ddee06149ece91ce608b1252fa82
Author: Tomaž Vajngerl <tomaz.vajngerl at collabora.co.uk>
AuthorDate: Tue Dec 31 13:39:33 2019 +0100
Commit: Tomaž Vajngerl <quikee at gmail.com>
CommitDate: Wed Jan 1 20:58:56 2020 +0100
drawinglayer: clang-format BasePrimitive2D + remove from blacklist
No functional change was made, only formatting of the code.
The code was formatted with clang-format and moves the files
baseprimitve2d.{cxx,hxx} out of blacklist so it will be auto
formatted with every change from now on.
Change-Id: If49ec94f91e58825f7aa94dc54cff8374467aa30
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/86078
Tested-by: Jenkins
Reviewed-by: Tomaž Vajngerl <quikee at gmail.com>
Tested-by: Tomaž Vajngerl <quikee at gmail.com>
diff --git a/drawinglayer/source/primitive2d/baseprimitive2d.cxx b/drawinglayer/source/primitive2d/baseprimitive2d.cxx
index 4db80991dd93..72b0f33734ee 100644
--- a/drawinglayer/source/primitive2d/baseprimitive2d.cxx
+++ b/drawinglayer/source/primitive2d/baseprimitive2d.cxx
@@ -28,349 +28,433 @@
#include <basegfx/utils/canvastools.hxx>
#include <comphelper/sequence.hxx>
-
using namespace com::sun::star;
-
namespace drawinglayer
{
- namespace primitive2d
- {
- Primitive2DDecompositionVisitor::~Primitive2DDecompositionVisitor() {}
-
- BasePrimitive2D::BasePrimitive2D()
- : BasePrimitive2DImplBase(m_aMutex)
- {
- }
-
- BasePrimitive2D::~BasePrimitive2D()
- {
- }
-
- bool BasePrimitive2D::operator==( const BasePrimitive2D& rPrimitive ) const
- {
- return (getPrimitive2DID() == rPrimitive.getPrimitive2DID());
- }
+namespace primitive2d
+{
+Primitive2DDecompositionVisitor::~Primitive2DDecompositionVisitor() {}
- namespace {
-
- // Visitor class to get the B2D range from a tree of Primitive2DReference's
- //
- class B2DRangeVisitor : public Primitive2DDecompositionVisitor {
- public:
- const geometry::ViewInformation2D& mrViewInformation;
- basegfx::B2DRange maRetval;
- B2DRangeVisitor(const geometry::ViewInformation2D& rViewInformation) : mrViewInformation(rViewInformation) {}
- virtual void append(const Primitive2DReference& r) override {
- maRetval.expand(getB2DRangeFromPrimitive2DReference(r, mrViewInformation));
- }
- virtual void append(const Primitive2DContainer& r) override {
- maRetval.expand(r.getB2DRange(mrViewInformation));
- }
- virtual void append(Primitive2DContainer&& r) override {
- maRetval.expand(r.getB2DRange(mrViewInformation));
- }
- };
+BasePrimitive2D::BasePrimitive2D()
+ : BasePrimitive2DImplBase(m_aMutex)
+{
+}
- }
+BasePrimitive2D::~BasePrimitive2D() {}
- basegfx::B2DRange BasePrimitive2D::getB2DRange(const geometry::ViewInformation2D& rViewInformation) const
- {
- B2DRangeVisitor aVisitor(rViewInformation);
- get2DDecomposition(aVisitor, rViewInformation);
- return aVisitor.maRetval;
- }
+bool BasePrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
+{
+ return (getPrimitive2DID() == rPrimitive.getPrimitive2DID());
+}
- void BasePrimitive2D::get2DDecomposition(Primitive2DDecompositionVisitor& /*rVisitor*/, const geometry::ViewInformation2D& /*rViewInformation*/) const
- {
- }
+namespace
+{
+// Visitor class to get the B2D range from a tree of Primitive2DReference's
+//
+class B2DRangeVisitor : public Primitive2DDecompositionVisitor
+{
+public:
+ const geometry::ViewInformation2D& mrViewInformation;
+ basegfx::B2DRange maRetval;
+ B2DRangeVisitor(const geometry::ViewInformation2D& rViewInformation)
+ : mrViewInformation(rViewInformation)
+ {
+ }
+ virtual void append(const Primitive2DReference& r) override
+ {
+ maRetval.expand(getB2DRangeFromPrimitive2DReference(r, mrViewInformation));
+ }
+ virtual void append(const Primitive2DContainer& r) override
+ {
+ maRetval.expand(r.getB2DRange(mrViewInformation));
+ }
+ virtual void append(Primitive2DContainer&& r) override
+ {
+ maRetval.expand(r.getB2DRange(mrViewInformation));
+ }
+};
+}
- css::uno::Sequence< ::css::uno::Reference< ::css::graphic::XPrimitive2D > > SAL_CALL BasePrimitive2D::getDecomposition( const uno::Sequence< beans::PropertyValue >& rViewParameters )
- {
- const geometry::ViewInformation2D aViewInformation(rViewParameters);
- Primitive2DContainer aContainer;
- get2DDecomposition(aContainer, aViewInformation);
- return comphelper::containerToSequence(aContainer);
- }
+basegfx::B2DRange
+BasePrimitive2D::getB2DRange(const geometry::ViewInformation2D& rViewInformation) const
+{
+ B2DRangeVisitor aVisitor(rViewInformation);
+ get2DDecomposition(aVisitor, rViewInformation);
+ return aVisitor.maRetval;
+}
+
+void BasePrimitive2D::get2DDecomposition(
+ Primitive2DDecompositionVisitor& /*rVisitor*/,
+ const geometry::ViewInformation2D& /*rViewInformation*/) const
+{
+}
- css::geometry::RealRectangle2D SAL_CALL BasePrimitive2D::getRange( const uno::Sequence< beans::PropertyValue >& rViewParameters )
- {
- const geometry::ViewInformation2D aViewInformation(rViewParameters);
- return basegfx::unotools::rectangle2DFromB2DRectangle(getB2DRange(aViewInformation));
- }
+css::uno::Sequence<::css::uno::Reference<::css::graphic::XPrimitive2D>> SAL_CALL
+BasePrimitive2D::getDecomposition(const uno::Sequence<beans::PropertyValue>& rViewParameters)
+{
+ const geometry::ViewInformation2D aViewInformation(rViewParameters);
+ Primitive2DContainer aContainer;
+ get2DDecomposition(aContainer, aViewInformation);
+ return comphelper::containerToSequence(aContainer);
+}
+
+css::geometry::RealRectangle2D SAL_CALL
+BasePrimitive2D::getRange(const uno::Sequence<beans::PropertyValue>& rViewParameters)
+{
+ const geometry::ViewInformation2D aViewInformation(rViewParameters);
+ return basegfx::unotools::rectangle2DFromB2DRectangle(getB2DRange(aViewInformation));
+}
- sal_Int64 SAL_CALL BasePrimitive2D::estimateUsage()
- {
- return 0; // for now ignore the objects themselves
- }
- } // end of namespace primitive2d
+sal_Int64 SAL_CALL BasePrimitive2D::estimateUsage()
+{
+ return 0; // for now ignore the objects themselves
+}
+} // end of namespace primitive2d
} // end of namespace drawinglayer
-
namespace drawinglayer
{
- namespace primitive2d
- {
- void BufferedDecompositionPrimitive2D::create2DDecomposition(Primitive2DContainer& /*rContainer*/, const geometry::ViewInformation2D& /*rViewInformation*/) const
- {
- }
-
- BufferedDecompositionPrimitive2D::BufferedDecompositionPrimitive2D()
- : BasePrimitive2D(),
- maBuffered2DDecomposition()
- {
- }
+namespace primitive2d
+{
+void BufferedDecompositionPrimitive2D::create2DDecomposition(
+ Primitive2DContainer& /*rContainer*/,
+ const geometry::ViewInformation2D& /*rViewInformation*/) const
+{
+}
- void BufferedDecompositionPrimitive2D::get2DDecomposition(Primitive2DDecompositionVisitor& rVisitor, const geometry::ViewInformation2D& rViewInformation) const
- {
- ::osl::MutexGuard aGuard( m_aMutex );
+BufferedDecompositionPrimitive2D::BufferedDecompositionPrimitive2D()
+ : BasePrimitive2D()
+ , maBuffered2DDecomposition()
+{
+}
- if(getBuffered2DDecomposition().empty())
- {
- Primitive2DContainer aNewSequence;
- create2DDecomposition(aNewSequence, rViewInformation);
- const_cast< BufferedDecompositionPrimitive2D* >(this)->setBuffered2DDecomposition(aNewSequence);
- }
+void BufferedDecompositionPrimitive2D::get2DDecomposition(
+ Primitive2DDecompositionVisitor& rVisitor,
+ const geometry::ViewInformation2D& rViewInformation) const
+{
+ ::osl::MutexGuard aGuard(m_aMutex);
- rVisitor.append(getBuffered2DDecomposition());
- }
- } // end of namespace primitive2d
+ if (getBuffered2DDecomposition().empty())
+ {
+ Primitive2DContainer aNewSequence;
+ create2DDecomposition(aNewSequence, rViewInformation);
+ const_cast<BufferedDecompositionPrimitive2D*>(this)->setBuffered2DDecomposition(
+ aNewSequence);
+ }
+
+ rVisitor.append(getBuffered2DDecomposition());
+}
+} // end of namespace primitive2d
} // end of namespace drawinglayer
-
// tooling
namespace drawinglayer
{
- namespace primitive2d
+namespace primitive2d
+{
+Primitive2DContainer Primitive2DContainer::maybeInvert(bool bInvert) const
+{
+ const sal_uInt32 nSize(size());
+ Primitive2DContainer aRetval;
+
+ aRetval.resize(nSize);
+
+ for (sal_uInt32 a(0); a < nSize; a++)
{
- Primitive2DContainer Primitive2DContainer::maybeInvert(bool bInvert) const
- {
- const sal_uInt32 nSize(size());
- Primitive2DContainer aRetval;
+ aRetval[bInvert ? nSize - 1 - a : a] = (*this)[a];
+ }
- aRetval.resize(nSize);
+ // 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();
- for(sal_uInt32 a(0); a < nSize; a++)
- {
- aRetval[bInvert ? nSize - 1 - a : a] = (*this)[a];
- }
+ return aRetval;
+}
- // 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();
+// get B2DRange from a given Primitive2DReference
+basegfx::B2DRange
+getB2DRangeFromPrimitive2DReference(const Primitive2DReference& rCandidate,
+ const geometry::ViewInformation2D& aViewInformation)
+{
+ basegfx::B2DRange aRetval;
- return aRetval;
- }
+ if (rCandidate.is())
+ {
+ // try to get C++ implementation base
+ const BasePrimitive2D* pCandidate(dynamic_cast<BasePrimitive2D*>(rCandidate.get()));
- // get B2DRange from a given Primitive2DReference
- basegfx::B2DRange getB2DRangeFromPrimitive2DReference(const Primitive2DReference& rCandidate, const geometry::ViewInformation2D& aViewInformation)
+ if (pCandidate)
{
- basegfx::B2DRange aRetval;
-
- if(rCandidate.is())
- {
- // try to get C++ implementation base
- const BasePrimitive2D* pCandidate(dynamic_cast< BasePrimitive2D* >(rCandidate.get()));
-
- if(pCandidate)
- {
- // use it if possible
- aRetval.expand(pCandidate->getB2DRange(aViewInformation));
- }
- else
- {
- // use UNO API call instead
- const uno::Sequence< beans::PropertyValue >& rViewParameters(aViewInformation.getViewInformationSequence());
- aRetval.expand(basegfx::unotools::b2DRectangleFromRealRectangle2D(rCandidate->getRange(rViewParameters)));
- }
- }
-
- return aRetval;
+ // use it if possible
+ aRetval.expand(pCandidate->getB2DRange(aViewInformation));
}
-
- // get B2DRange from a given Primitive2DSequence
- basegfx::B2DRange Primitive2DContainer::getB2DRange(const geometry::ViewInformation2D& aViewInformation) const
+ else
{
- basegfx::B2DRange aRetval;
+ // use UNO API call instead
+ const uno::Sequence<beans::PropertyValue>& rViewParameters(
+ aViewInformation.getViewInformationSequence());
+ aRetval.expand(basegfx::unotools::b2DRectangleFromRealRectangle2D(
+ rCandidate->getRange(rViewParameters)));
+ }
+ }
- if(!empty())
- {
- const sal_Int32 nCount(size());
+ return aRetval;
+}
- for(sal_Int32 a(0); a < nCount; a++)
- {
- aRetval.expand(getB2DRangeFromPrimitive2DReference((*this)[a], aViewInformation));
- }
- }
+// get B2DRange from a given Primitive2DSequence
+basegfx::B2DRange
+Primitive2DContainer::getB2DRange(const geometry::ViewInformation2D& aViewInformation) const
+{
+ basegfx::B2DRange aRetval;
- return aRetval;
- }
+ if (!empty())
+ {
+ const sal_Int32 nCount(size());
- bool arePrimitive2DReferencesEqual(const Primitive2DReference& rxA, const Primitive2DReference& rxB)
+ for (sal_Int32 a(0); a < nCount; a++)
{
- const bool bAIs(rxA.is());
+ aRetval.expand(getB2DRangeFromPrimitive2DReference((*this)[a], aViewInformation));
+ }
+ }
- if(bAIs != rxB.is())
- {
- return false;
- }
+ return aRetval;
+}
- if(!bAIs)
- {
- return true;
- }
+bool arePrimitive2DReferencesEqual(const Primitive2DReference& rxA, const Primitive2DReference& rxB)
+{
+ const bool bAIs(rxA.is());
- const BasePrimitive2D* pA(dynamic_cast< const BasePrimitive2D* >(rxA.get()));
- const BasePrimitive2D* pB(dynamic_cast< const BasePrimitive2D* >(rxB.get()));
+ if (bAIs != rxB.is())
+ {
+ return false;
+ }
- if (!pA || !pB)
- {
- return false;
- }
+ if (!bAIs)
+ {
+ return true;
+ }
- return pA->operator==(*pB);
- }
+ const BasePrimitive2D* pA(dynamic_cast<const BasePrimitive2D*>(rxA.get()));
+ const BasePrimitive2D* pB(dynamic_cast<const BasePrimitive2D*>(rxB.get()));
- 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(0); a < nCount; a++)
- {
- if(!arePrimitive2DReferencesEqual((*this)[a], rB[a]))
- {
- return false;
- }
- }
-
- return true;
- }
+ if (!pA || !pB)
+ {
+ return false;
+ }
- Primitive2DContainer::~Primitive2DContainer() {}
+ return pA->operator==(*pB);
+}
- void Primitive2DContainer::append(const Primitive2DReference& rSource)
- {
- push_back(rSource);
- }
+bool Primitive2DContainer::operator==(const Primitive2DContainer& rB) const
+{
+ const bool bAHasElements(!empty());
- void Primitive2DContainer::append(const Primitive2DContainer& rSource)
- {
- insert(end(), rSource.begin(), rSource.end());
- }
+ if (bAHasElements != !rB.empty())
+ {
+ return false;
+ }
- void Primitive2DContainer::append(Primitive2DContainer&& rSource)
- {
- size_t n = size();
- resize(n + rSource.size());
- for (size_t i = 0; i<rSource.size(); ++i)
- {
- (*this)[n + i] = std::move( rSource[i] );
- }
- }
+ if (!bAHasElements)
+ {
+ return true;
+ }
- void Primitive2DContainer::append(const Primitive2DSequence& rSource)
- {
- std::copy(rSource.begin(), rSource.end(), std::back_inserter(*this));
- }
+ const size_t nCount(size());
+
+ if (nCount != rB.size())
+ {
+ return false;
+ }
- OUString idToString(sal_uInt32 nId)
+ for (size_t a(0); a < nCount; a++)
+ {
+ if (!arePrimitive2DReferencesEqual((*this)[a], rB[a]))
{
- switch( nId )
- {
- case PRIMITIVE2D_ID_TRANSPARENCEPRIMITIVE2D: return "TRANSPARENCE";
- case PRIMITIVE2D_ID_ANIMATEDSWITCHPRIMITIVE2D: return "ANIMATEDSWITCH";
- case PRIMITIVE2D_ID_ANIMATEDBLINKPRIMITIVE2D: return "ANIMATEDBLINK";
- case PRIMITIVE2D_ID_ANIMATEDINTERPOLATEPRIMITIVE2D: return "ANIMATEDINTERPOLATE";
- case PRIMITIVE2D_ID_BACKGROUNDCOLORPRIMITIVE2D: return "BACKGROUNDCOLOR";
- case PRIMITIVE2D_ID_BITMAPPRIMITIVE2D: return "BITMAP";
- case PRIMITIVE2D_ID_CONTROLPRIMITIVE2D: return "CONTROL";
- case PRIMITIVE2D_ID_EMBEDDED3DPRIMITIVE2D: return "EMBEDDED3D";
- case PRIMITIVE2D_ID_FILLGRAPHICPRIMITIVE2D: return "FILLGRAPHIC";
- case PRIMITIVE2D_ID_FILLGRADIENTPRIMITIVE2D: return "FILLGRADIENT";
- case PRIMITIVE2D_ID_FILLHATCHPRIMITIVE2D: return "FILLHATCH";
- case PRIMITIVE2D_ID_GRAPHICPRIMITIVE2D: return "GRAPHIC";
- case PRIMITIVE2D_ID_GRIDPRIMITIVE2D: return "GRID";
- case PRIMITIVE2D_ID_GROUPPRIMITIVE2D: return "GROUP";
- case PRIMITIVE2D_ID_HELPLINEPRIMITIVE2D: return "HELPLINE";
- case PRIMITIVE2D_ID_MARKERARRAYPRIMITIVE2D: return "MARKERARRAY";
- case PRIMITIVE2D_ID_MASKPRIMITIVE2D: return "MASK";
- case PRIMITIVE2D_ID_MEDIAPRIMITIVE2D: return "MEDIA";
- case PRIMITIVE2D_ID_METAFILEPRIMITIVE2D: return "METAFILE";
- case PRIMITIVE2D_ID_MODIFIEDCOLORPRIMITIVE2D: return "MODIFIEDCOLOR";
- case PRIMITIVE2D_ID_POLYGONHAIRLINEPRIMITIVE2D: return "POLYGONHAIRLINE";
- case PRIMITIVE2D_ID_POLYGONMARKERPRIMITIVE2D: return "POLYGONMARKER";
- case PRIMITIVE2D_ID_POLYGONSTROKEPRIMITIVE2D: return "POLYGONSTROKE";
- case PRIMITIVE2D_ID_POLYGONSTROKEARROWPRIMITIVE2D: return "POLYGONSTROKEARROW";
- case PRIMITIVE2D_ID_POLYPOLYGONSTROKEPRIMITIVE2D: return "POLYPOLYGONSTROKE";
- case PRIMITIVE2D_ID_POLYPOLYGONSTROKEARROWPRIMITIVE2D: return "POLYPOLYGONSTROKEARROW";
- case PRIMITIVE2D_ID_POLYPOLYGONCOLORPRIMITIVE2D: return "POLYPOLYGONCOLOR";
- case PRIMITIVE2D_ID_POLYPOLYGONGRADIENTPRIMITIVE2D: return "POLYPOLYGONGRADIENT";
- case PRIMITIVE2D_ID_POLYPOLYGONHATCHPRIMITIVE2D: return "POLYPOLYGONHATCH";
- case PRIMITIVE2D_ID_POLYPOLYGONGRAPHICPRIMITIVE2D: return "POLYPOLYGONGRAPHIC";
- case PRIMITIVE2D_ID_SCENEPRIMITIVE2D: return "SCENE";
- case PRIMITIVE2D_ID_SHADOWPRIMITIVE2D: return "SHADOW";
- case PRIMITIVE2D_ID_TEXTSIMPLEPORTIONPRIMITIVE2D: return "TEXTSIMPLEPORTION";
- case PRIMITIVE2D_ID_TEXTDECORATEDPORTIONPRIMITIVE2D: return "TEXTDECORATEDPORTION";
- case PRIMITIVE2D_ID_TRANSFORMPRIMITIVE2D: return "TRANSFORM";
- case PRIMITIVE2D_ID_UNIFIEDTRANSPARENCEPRIMITIVE2D: return "UNIFIEDTRANSPARENCE";
- case PRIMITIVE2D_ID_POINTARRAYPRIMITIVE2D: return "POINTARRAY";
- case PRIMITIVE2D_ID_TEXTHIERARCHYFIELDPRIMITIVE2D: return "TEXTHIERARCHYFIELD";
- case PRIMITIVE2D_ID_TEXTHIERARCHYLINEPRIMITIVE2D: return "TEXTHIERARCHYLINE";
- case PRIMITIVE2D_ID_TEXTHIERARCHYPARAGRAPHPRIMITIVE2D: return "TEXTHIERARCHYPARAGRAPH";
- case PRIMITIVE2D_ID_TEXTHIERARCHYBLOCKPRIMITIVE2D: return "TEXTHIERARCHYBLOCK";
- case PRIMITIVE2D_ID_TEXTHIERARCHYEDITPRIMITIVE2D: return "TEXTHIERARCHYEDIT";
- case PRIMITIVE2D_ID_POLYGONWAVEPRIMITIVE2D: return "POLYGONWAVE";
- case PRIMITIVE2D_ID_WRONGSPELLPRIMITIVE2D: return "WRONGSPELL";
- case PRIMITIVE2D_ID_TEXTEFFECTPRIMITIVE2D: return "TEXTEFFECT";
- case PRIMITIVE2D_ID_TEXTHIERARCHYBULLETPRIMITIVE2D: return "TEXTHIERARCHYBULLET";
- case PRIMITIVE2D_ID_POLYPOLYGONHAIRLINEPRIMITIVE2D: return "POLYPOLYGONHAIRLINE";
- case PRIMITIVE2D_ID_EXECUTEPRIMITIVE2D: return "EXECUTE";
- case PRIMITIVE2D_ID_PAGEPREVIEWPRIMITIVE2D: return "PAGEPREVIEW";
- case PRIMITIVE2D_ID_STRUCTURETAGPRIMITIVE2D: return "STRUCTURETAG";
- case PRIMITIVE2D_ID_BORDERLINEPRIMITIVE2D: return "BORDERLINE";
- case PRIMITIVE2D_ID_POLYPOLYGONMARKERPRIMITIVE2D: return "POLYPOLYGONMARKER";
- case PRIMITIVE2D_ID_HITTESTPRIMITIVE2D: return "HITTEST";
- case PRIMITIVE2D_ID_INVERTPRIMITIVE2D: return "INVERT";
- case PRIMITIVE2D_ID_DISCRETEBITMAPPRIMITIVE2D: return "DISCRETEBITMAP";
- case PRIMITIVE2D_ID_WALLPAPERBITMAPPRIMITIVE2D: return "WALLPAPERBITMAP";
- case PRIMITIVE2D_ID_TEXTLINEPRIMITIVE2D: return "TEXTLINE";
- case PRIMITIVE2D_ID_TEXTCHARACTERSTRIKEOUTPRIMITIVE2D: return "TEXTCHARACTERSTRIKEOUT";
- case PRIMITIVE2D_ID_TEXTGEOMETRYSTRIKEOUTPRIMITIVE2D: return "TEXTGEOMETRYSTRIKEOUT";
- case PRIMITIVE2D_ID_EPSPRIMITIVE2D: return "EPS";
- case PRIMITIVE2D_ID_DISCRETESHADOWPRIMITIVE2D: return "DISCRETESHADOW";
- case PRIMITIVE2D_ID_HIDDENGEOMETRYPRIMITIVE2D: return "HIDDENGEOMETRY";
- case PRIMITIVE2D_ID_SVGLINEARGRADIENTPRIMITIVE2D: return "SVGLINEARGRADIENT";
- case PRIMITIVE2D_ID_SVGRADIALGRADIENTPRIMITIVE2D: return "SVGRADIALGRADIENT";
- case PRIMITIVE2D_ID_SVGLINEARATOMPRIMITIVE2D: return "SVGLINEARATOM";
- case PRIMITIVE2D_ID_SVGRADIALATOMPRIMITIVE2D: return "SVGRADIALATOM";
- case PRIMITIVE2D_ID_CROPPRIMITIVE2D: return "CROP";
- case PRIMITIVE2D_ID_PATTERNFILLPRIMITIVE2D: return "PATTERNFILL";
- case PRIMITIVE2D_ID_OBJECTINFOPRIMITIVE2D: return "OBJECTINFO";
- case PRIMITIVE2D_ID_POLYPOLYGONSELECTIONPRIMITIVE2D: return "POLYPOLYGONSELECTION";
- case PRIMITIVE2D_ID_PAGEHIERARCHYPRIMITIVE2D: return "PAGEHIERARCHY";
- default: return OUString::number((nId >> 16) & 0xFF) + "|" + OUString::number(nId & 0xFF);
- }
+ return false;
}
- } // end of namespace primitive2d
+ }
+
+ return true;
+}
+
+Primitive2DContainer::~Primitive2DContainer() {}
+
+void Primitive2DContainer::append(const Primitive2DReference& rSource) { push_back(rSource); }
+
+void Primitive2DContainer::append(const Primitive2DContainer& rSource)
+{
+ insert(end(), rSource.begin(), rSource.end());
+}
+
+void Primitive2DContainer::append(Primitive2DContainer&& rSource)
+{
+ size_t n = size();
+ resize(n + rSource.size());
+ for (size_t i = 0; i < rSource.size(); ++i)
+ {
+ (*this)[n + i] = std::move(rSource[i]);
+ }
+}
+
+void Primitive2DContainer::append(const Primitive2DSequence& rSource)
+{
+ std::copy(rSource.begin(), rSource.end(), std::back_inserter(*this));
+}
+
+OUString idToString(sal_uInt32 nId)
+{
+ switch (nId)
+ {
+ case PRIMITIVE2D_ID_TRANSPARENCEPRIMITIVE2D:
+ return "TRANSPARENCE";
+ case PRIMITIVE2D_ID_ANIMATEDSWITCHPRIMITIVE2D:
+ return "ANIMATEDSWITCH";
+ case PRIMITIVE2D_ID_ANIMATEDBLINKPRIMITIVE2D:
+ return "ANIMATEDBLINK";
+ case PRIMITIVE2D_ID_ANIMATEDINTERPOLATEPRIMITIVE2D:
+ return "ANIMATEDINTERPOLATE";
+ case PRIMITIVE2D_ID_BACKGROUNDCOLORPRIMITIVE2D:
+ return "BACKGROUNDCOLOR";
+ case PRIMITIVE2D_ID_BITMAPPRIMITIVE2D:
+ return "BITMAP";
+ case PRIMITIVE2D_ID_CONTROLPRIMITIVE2D:
+ return "CONTROL";
+ case PRIMITIVE2D_ID_EMBEDDED3DPRIMITIVE2D:
+ return "EMBEDDED3D";
+ case PRIMITIVE2D_ID_FILLGRAPHICPRIMITIVE2D:
+ return "FILLGRAPHIC";
+ case PRIMITIVE2D_ID_FILLGRADIENTPRIMITIVE2D:
+ return "FILLGRADIENT";
+ case PRIMITIVE2D_ID_FILLHATCHPRIMITIVE2D:
+ return "FILLHATCH";
+ case PRIMITIVE2D_ID_GRAPHICPRIMITIVE2D:
+ return "GRAPHIC";
+ case PRIMITIVE2D_ID_GRIDPRIMITIVE2D:
+ return "GRID";
+ case PRIMITIVE2D_ID_GROUPPRIMITIVE2D:
+ return "GROUP";
+ case PRIMITIVE2D_ID_HELPLINEPRIMITIVE2D:
+ return "HELPLINE";
+ case PRIMITIVE2D_ID_MARKERARRAYPRIMITIVE2D:
+ return "MARKERARRAY";
+ case PRIMITIVE2D_ID_MASKPRIMITIVE2D:
+ return "MASK";
+ case PRIMITIVE2D_ID_MEDIAPRIMITIVE2D:
+ return "MEDIA";
+ case PRIMITIVE2D_ID_METAFILEPRIMITIVE2D:
+ return "METAFILE";
+ case PRIMITIVE2D_ID_MODIFIEDCOLORPRIMITIVE2D:
+ return "MODIFIEDCOLOR";
+ case PRIMITIVE2D_ID_POLYGONHAIRLINEPRIMITIVE2D:
+ return "POLYGONHAIRLINE";
+ case PRIMITIVE2D_ID_POLYGONMARKERPRIMITIVE2D:
+ return "POLYGONMARKER";
+ case PRIMITIVE2D_ID_POLYGONSTROKEPRIMITIVE2D:
+ return "POLYGONSTROKE";
+ case PRIMITIVE2D_ID_POLYGONSTROKEARROWPRIMITIVE2D:
+ return "POLYGONSTROKEARROW";
+ case PRIMITIVE2D_ID_POLYPOLYGONSTROKEPRIMITIVE2D:
+ return "POLYPOLYGONSTROKE";
+ case PRIMITIVE2D_ID_POLYPOLYGONSTROKEARROWPRIMITIVE2D:
+ return "POLYPOLYGONSTROKEARROW";
+ case PRIMITIVE2D_ID_POLYPOLYGONCOLORPRIMITIVE2D:
+ return "POLYPOLYGONCOLOR";
+ case PRIMITIVE2D_ID_POLYPOLYGONGRADIENTPRIMITIVE2D:
+ return "POLYPOLYGONGRADIENT";
+ case PRIMITIVE2D_ID_POLYPOLYGONHATCHPRIMITIVE2D:
+ return "POLYPOLYGONHATCH";
+ case PRIMITIVE2D_ID_POLYPOLYGONGRAPHICPRIMITIVE2D:
+ return "POLYPOLYGONGRAPHIC";
+ case PRIMITIVE2D_ID_SCENEPRIMITIVE2D:
+ return "SCENE";
+ case PRIMITIVE2D_ID_SHADOWPRIMITIVE2D:
+ return "SHADOW";
+ case PRIMITIVE2D_ID_TEXTSIMPLEPORTIONPRIMITIVE2D:
+ return "TEXTSIMPLEPORTION";
+ case PRIMITIVE2D_ID_TEXTDECORATEDPORTIONPRIMITIVE2D:
+ return "TEXTDECORATEDPORTION";
+ case PRIMITIVE2D_ID_TRANSFORMPRIMITIVE2D:
+ return "TRANSFORM";
+ case PRIMITIVE2D_ID_UNIFIEDTRANSPARENCEPRIMITIVE2D:
+ return "UNIFIEDTRANSPARENCE";
+ case PRIMITIVE2D_ID_POINTARRAYPRIMITIVE2D:
+ return "POINTARRAY";
+ case PRIMITIVE2D_ID_TEXTHIERARCHYFIELDPRIMITIVE2D:
+ return "TEXTHIERARCHYFIELD";
+ case PRIMITIVE2D_ID_TEXTHIERARCHYLINEPRIMITIVE2D:
+ return "TEXTHIERARCHYLINE";
+ case PRIMITIVE2D_ID_TEXTHIERARCHYPARAGRAPHPRIMITIVE2D:
+ return "TEXTHIERARCHYPARAGRAPH";
+ case PRIMITIVE2D_ID_TEXTHIERARCHYBLOCKPRIMITIVE2D:
+ return "TEXTHIERARCHYBLOCK";
+ case PRIMITIVE2D_ID_TEXTHIERARCHYEDITPRIMITIVE2D:
+ return "TEXTHIERARCHYEDIT";
+ case PRIMITIVE2D_ID_POLYGONWAVEPRIMITIVE2D:
+ return "POLYGONWAVE";
+ case PRIMITIVE2D_ID_WRONGSPELLPRIMITIVE2D:
+ return "WRONGSPELL";
+ case PRIMITIVE2D_ID_TEXTEFFECTPRIMITIVE2D:
+ return "TEXTEFFECT";
+ case PRIMITIVE2D_ID_TEXTHIERARCHYBULLETPRIMITIVE2D:
+ return "TEXTHIERARCHYBULLET";
+ case PRIMITIVE2D_ID_POLYPOLYGONHAIRLINEPRIMITIVE2D:
+ return "POLYPOLYGONHAIRLINE";
+ case PRIMITIVE2D_ID_EXECUTEPRIMITIVE2D:
+ return "EXECUTE";
+ case PRIMITIVE2D_ID_PAGEPREVIEWPRIMITIVE2D:
+ return "PAGEPREVIEW";
+ case PRIMITIVE2D_ID_STRUCTURETAGPRIMITIVE2D:
+ return "STRUCTURETAG";
+ case PRIMITIVE2D_ID_BORDERLINEPRIMITIVE2D:
+ return "BORDERLINE";
+ case PRIMITIVE2D_ID_POLYPOLYGONMARKERPRIMITIVE2D:
+ return "POLYPOLYGONMARKER";
+ case PRIMITIVE2D_ID_HITTESTPRIMITIVE2D:
+ return "HITTEST";
+ case PRIMITIVE2D_ID_INVERTPRIMITIVE2D:
+ return "INVERT";
+ case PRIMITIVE2D_ID_DISCRETEBITMAPPRIMITIVE2D:
+ return "DISCRETEBITMAP";
+ case PRIMITIVE2D_ID_WALLPAPERBITMAPPRIMITIVE2D:
+ return "WALLPAPERBITMAP";
+ case PRIMITIVE2D_ID_TEXTLINEPRIMITIVE2D:
+ return "TEXTLINE";
+ case PRIMITIVE2D_ID_TEXTCHARACTERSTRIKEOUTPRIMITIVE2D:
+ return "TEXTCHARACTERSTRIKEOUT";
+ case PRIMITIVE2D_ID_TEXTGEOMETRYSTRIKEOUTPRIMITIVE2D:
+ return "TEXTGEOMETRYSTRIKEOUT";
+ case PRIMITIVE2D_ID_EPSPRIMITIVE2D:
+ return "EPS";
+ case PRIMITIVE2D_ID_DISCRETESHADOWPRIMITIVE2D:
+ return "DISCRETESHADOW";
+ case PRIMITIVE2D_ID_HIDDENGEOMETRYPRIMITIVE2D:
+ return "HIDDENGEOMETRY";
+ case PRIMITIVE2D_ID_SVGLINEARGRADIENTPRIMITIVE2D:
+ return "SVGLINEARGRADIENT";
+ case PRIMITIVE2D_ID_SVGRADIALGRADIENTPRIMITIVE2D:
+ return "SVGRADIALGRADIENT";
+ case PRIMITIVE2D_ID_SVGLINEARATOMPRIMITIVE2D:
+ return "SVGLINEARATOM";
+ case PRIMITIVE2D_ID_SVGRADIALATOMPRIMITIVE2D:
+ return "SVGRADIALATOM";
+ case PRIMITIVE2D_ID_CROPPRIMITIVE2D:
+ return "CROP";
+ case PRIMITIVE2D_ID_PATTERNFILLPRIMITIVE2D:
+ return "PATTERNFILL";
+ case PRIMITIVE2D_ID_OBJECTINFOPRIMITIVE2D:
+ return "OBJECTINFO";
+ case PRIMITIVE2D_ID_POLYPOLYGONSELECTIONPRIMITIVE2D:
+ return "POLYPOLYGONSELECTION";
+ case PRIMITIVE2D_ID_PAGEHIERARCHYPRIMITIVE2D:
+ return "PAGEHIERARCHY";
+ default:
+ return OUString::number((nId >> 16) & 0xFF) + "|" + OUString::number(nId & 0xFF);
+ }
+}
+} // end of namespace primitive2d
} // end of namespace drawinglayer
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/include/drawinglayer/primitive2d/baseprimitive2d.hxx b/include/drawinglayer/primitive2d/baseprimitive2d.hxx
index 0d0921850588..17b5d2f03a36 100644
--- a/include/drawinglayer/primitive2d/baseprimitive2d.hxx
+++ b/include/drawinglayer/primitive2d/baseprimitive2d.hxx
@@ -29,296 +29,334 @@
#include <basegfx/range/b2drange.hxx>
#include <deque>
-
/** defines for DeclPrimitive2DIDBlock and ImplPrimitive2DIDBlock
Added to be able to simply change identification stuff later, e.g. add
an identification string and/or ID to the interface and to the implementation
ATM used to delclare implement getPrimitive2DID()
*/
-#define DeclPrimitive2DIDBlock() \
- virtual sal_uInt32 getPrimitive2DID() const override;
+#define DeclPrimitive2DIDBlock() virtual sal_uInt32 getPrimitive2DID() const override;
-#define ImplPrimitive2DIDBlock(TheClass, TheID) \
+#define ImplPrimitive2DIDBlock(TheClass, TheID) \
sal_uInt32 TheClass::getPrimitive2DID() const { return TheID; }
-
// predefines
-namespace drawinglayer { namespace geometry {
- class ViewInformation2D;
-}}
-
-namespace drawinglayer { namespace primitive2d {
- /// typedefs for basePrimitive2DImplBase, Primitive2DSequence and Primitive2DReference
- typedef cppu::WeakComponentImplHelper<
- css::graphic::XPrimitive2D,
- css::util::XAccounting
- > BasePrimitive2DImplBase;
- typedef css::uno::Reference< css::graphic::XPrimitive2D > Primitive2DReference;
- typedef css::uno::Sequence< Primitive2DReference > Primitive2DSequence;
-
- class Primitive2DContainer;
- // Visitor class for walking a tree of Primitive2DReference in BasePrimitive2D::get2DDecomposition
- class DRAWINGLAYER_DLLPUBLIC Primitive2DDecompositionVisitor {
- public:
- virtual void append(const Primitive2DReference&) = 0;
- virtual void append(const Primitive2DContainer&) = 0;
- virtual void append(Primitive2DContainer&&) = 0;
- virtual ~Primitive2DDecompositionVisitor();
- };
-
- class SAL_WARN_UNUSED DRAWINGLAYER_DLLPUBLIC Primitive2DContainer : public std::deque< Primitive2DReference >,
- public Primitive2DDecompositionVisitor
- {
- public:
- explicit Primitive2DContainer() {}
- explicit Primitive2DContainer( size_type count ) : deque(count) {}
- virtual ~Primitive2DContainer() override;
- Primitive2DContainer( const Primitive2DContainer& other ) : deque(other) {}
- Primitive2DContainer( Primitive2DContainer&& other ) noexcept : deque(std::move(other)) {}
- Primitive2DContainer( const std::deque< Primitive2DReference >& other ) : deque(other) {}
- Primitive2DContainer( std::initializer_list<Primitive2DReference> init ) : deque(init) {}
- template <class Iter>
- Primitive2DContainer(Iter first, Iter last) : deque(first, last) {}
-
- virtual void append(const Primitive2DReference&) override;
- virtual void append(const Primitive2DContainer& rSource) override;
- virtual void append(Primitive2DContainer&& rSource) override;
- void append(const Primitive2DSequence& rSource);
- Primitive2DContainer& operator=(const Primitive2DContainer& r) { deque::operator=(r); return *this; }
- Primitive2DContainer& operator=(Primitive2DContainer&& r) noexcept { deque::operator=(std::move(r)); return *this; }
- 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;
- };
-}}
-
-
-// basePrimitive2D class
+namespace drawinglayer
+{
+namespace geometry
+{
+class ViewInformation2D;
+}
+}
namespace drawinglayer
{
- namespace primitive2d
+namespace primitive2d
+{
+/// typedefs for basePrimitive2DImplBase, Primitive2DSequence and Primitive2DReference
+typedef cppu::WeakComponentImplHelper<css::graphic::XPrimitive2D, css::util::XAccounting>
+ BasePrimitive2DImplBase;
+typedef css::uno::Reference<css::graphic::XPrimitive2D> Primitive2DReference;
+typedef css::uno::Sequence<Primitive2DReference> Primitive2DSequence;
+
+class Primitive2DContainer;
+// Visitor class for walking a tree of Primitive2DReference in BasePrimitive2D::get2DDecomposition
+class DRAWINGLAYER_DLLPUBLIC Primitive2DDecompositionVisitor
+{
+public:
+ virtual void append(const Primitive2DReference&) = 0;
+ virtual void append(const Primitive2DContainer&) = 0;
+ virtual void append(Primitive2DContainer&&) = 0;
+ virtual ~Primitive2DDecompositionVisitor();
+};
+
+class SAL_WARN_UNUSED DRAWINGLAYER_DLLPUBLIC Primitive2DContainer
+ : public std::deque<Primitive2DReference>,
+ public Primitive2DDecompositionVisitor
+{
+public:
+ explicit Primitive2DContainer() {}
+ explicit Primitive2DContainer(size_type count)
+ : deque(count)
{
- /** BasePrimitive2D class
-
- Baseclass for all C++ implementations of css::graphic::XPrimitive2D
-
- This class is strongly virtual due to the lack of getPrimitiveID() implementation.
- This is by purpose, this base class shall not be incarnated and be used directly as
- a XPrimitive2D.
-
- It is noncopyable to make clear that a primitive is a read-only
- instance and copying or changing values is not intended. The idea is to hold all data
- needed for visualisation of this primitive in unchangeable form.
-
- It is derived from cppu::BaseMutex to have a Mutex at hand; in a base
- implementation this may not be needed, but e.g. when buffering at last decomposition
- in a local member, multiple threads may try to decompose at the same time, so locking
- is needed to avoid race conditions seen from the UNO object implementation.
-
- A method to get a simplified representation is provided by get2DDecomposition. The
- default implementation returns an empty sequence. The idea is that processors
- using this primitive and do not know it, may get the decomposition and process
- these instead. An example is e.g. a fat line, who's decomposition may contain
- the geometric representation of that line using filled polygon primitives. When
- the renderer knows how to handle fat lines, he may process this primitive directly;
- if not he can use the decomposition. With this functionality, renderers may operate by
- knowing only a small set of primitives.
-
- When a primitive does not implement get2DDecomposition, it is called a 'Basic Primitive' and
- belongs to the set of primitives which a processor should be able to handle. Practice
- will define this minimal sets of primitives. When defined and the concept is proved,
- unique UNO APIs may be defined/implemented for these set to allow more intense work
- with primitives using UNO.
-
- Current Basic 2D Primitives are:
-
- - BitmapPrimitive2D (bitmap data, evtl. with transparence)
- - PointArrayPrimitive2D (single points)
- - PolygonHairlinePrimitive2D (hairline curves/polygons)
- - PolyPolygonColorPrimitive2D (colored polygons)
-
- UPDATE: MetafilePrimitive2D (VCL Metafile) is taken off this list since
- it is implemented with the integration of CWS aw078 into DV300m69.
-
- All other implemented primitives have a defined decomposition and can thus be
- decomposed down to this small set.
-
- A renderer implementing support for this minimal set of primitives can completely
- render primitive-based visualisations. Of course, he also has to take states into account
- which are represented by GroupPrimitive2D derivations, see groupprimitive2d.hxx
-
- To support getting the geometric BoundRect, getB2DRange is used. The default
- implementation will use the get2DDecomposition result and merge a range from the
- entries. Thus, an implementation is only necessary for the Basic Primitives, but
- of course speedups are possible (and are used) by implementing the method at higher-level
- primitives.
-
- For primitive identification, getPrimitiveID is used currently in this implementations
- to allow a fast switch/case processing. This needs a unique identifier mechanism which
- currently uses defines (see drawinglayer_primitivetypes2d.hxx). For UNO primitive API
- it will be needed to add a unique descriptor (Name?) later to the API.
-
- This base implementation provides mappings from the methods from XPrimitive2D
- (getDecomposition/getRange) to the appropriate methods in the C++ implementations
- (get2DDecomposition/getB2DRange). The PropertyValue ViewParameters is converted to
- the appropriate C++ implementation class ViewInformation2D.
-
- This base class does not implement any buffering; e.g. buffering the decomposition
- and/or the range. These may be buffered anytime since the definition is that the primitive
- is read-only and thus unchangeable. This implies that the decomposition and/or getting
- the range will lead to the same result as last time, under the precondition that
- the parameter ViewInformation2D is the same as the last one. This is usually the case
- for view-independent primitives which are defined by not using ViewInformation2D
- in their get2DDecomposition/getB2DRange implementations.
- */
- class DRAWINGLAYER_DLLPUBLIC BasePrimitive2D
- : protected cppu::BaseMutex,
- public BasePrimitive2DImplBase
- {
- BasePrimitive2D(const BasePrimitive2D&) = delete;
- BasePrimitive2D& operator=( const BasePrimitive2D& ) = delete;
- public:
- // constructor/destructor
- BasePrimitive2D();
- virtual ~BasePrimitive2D() override;
-
- /** the ==operator is mainly needed to allow testing newly-created primitives against their last
- incarnation which buffers/holds the made decompositions. The default implementation
- uses getPrimitive2DID()-calls to test if it's the same ID at last.
- Overridden implementations are then based on this implementation
- */
- virtual bool operator==( const BasePrimitive2D& rPrimitive ) const;
- bool operator!=( const BasePrimitive2D& rPrimitive ) const { return !operator==(rPrimitive); }
-
- /// The default implementation will use getDecomposition results to create the range
- virtual basegfx::B2DRange getB2DRange(const geometry::ViewInformation2D& rViewInformation) const;
-
- /** provide unique ID for fast identifying of known primitive implementations in renderers. These use
- the defines from drawinglayer_primitivetypes2d.hxx to define unique IDs.
- This method is normally defined using DeclPrimitive2DIDBlock()
- */
- virtual sal_uInt32 getPrimitive2DID() const = 0;
-
- /// The default implementation will return an empty sequence
- virtual void get2DDecomposition(Primitive2DDecompositionVisitor& rVisitor, const geometry::ViewInformation2D& rViewInformation) const;
-
-
- // Methods from XPrimitive2D
-
-
- /** The getDecomposition implementation for UNO API will use getDecomposition from this implementation. It
- will construct a ViewInformation2D from the ViewParameters for that purpose
- */
- virtual css::uno::Sequence< ::css::uno::Reference< ::css::graphic::XPrimitive2D > > SAL_CALL getDecomposition( const css::uno::Sequence< css::beans::PropertyValue >& rViewParameters ) override;
+ }
+ virtual ~Primitive2DContainer() override;
+ Primitive2DContainer(const Primitive2DContainer& other)
+ : deque(other)
+ {
+ }
+ Primitive2DContainer(Primitive2DContainer&& other) noexcept
+ : deque(std::move(other))
+ {
+ }
+ Primitive2DContainer(const std::deque<Primitive2DReference>& other)
+ : deque(other)
+ {
+ }
+ Primitive2DContainer(std::initializer_list<Primitive2DReference> init)
+ : deque(init)
+ {
+ }
+ template <class Iter>
+ Primitive2DContainer(Iter first, Iter last)
+ : deque(first, last)
+ {
+ }
- /** The getRange implementation for UNO API will use getRange from this implementation. It
- will construct a ViewInformation2D from the ViewParameters for that purpose
- */
- virtual css::geometry::RealRectangle2D SAL_CALL getRange( const css::uno::Sequence< css::beans::PropertyValue >& rViewParameters ) override;
+ virtual void append(const Primitive2DReference&) override;
+ virtual void append(const Primitive2DContainer& rSource) override;
+ virtual void append(Primitive2DContainer&& rSource) override;
+ void append(const Primitive2DSequence& rSource);
+ Primitive2DContainer& operator=(const Primitive2DContainer& r)
+ {
+ deque::operator=(r);
+ return *this;
+ }
+ Primitive2DContainer& operator=(Primitive2DContainer&& r) noexcept
+ {
+ deque::operator=(std::move(r));
+ return *this;
+ }
+ 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;
+};
+}
+}
- // XAccounting
- virtual sal_Int64 SAL_CALL estimateUsage() override;
+// basePrimitive2D class
- };
- } // end of namespace primitive2d
+namespace drawinglayer
+{
+namespace primitive2d
+{
+/** BasePrimitive2D class
+
+ Baseclass for all C++ implementations of css::graphic::XPrimitive2D
+
+ This class is strongly virtual due to the lack of getPrimitiveID() implementation.
+ This is by purpose, this base class shall not be incarnated and be used directly as
+ a XPrimitive2D.
+
+ It is noncopyable to make clear that a primitive is a read-only
+ instance and copying or changing values is not intended. The idea is to hold all data
+ needed for visualisation of this primitive in unchangeable form.
+
+ It is derived from cppu::BaseMutex to have a Mutex at hand; in a base
+ implementation this may not be needed, but e.g. when buffering at last decomposition
+ in a local member, multiple threads may try to decompose at the same time, so locking
+ is needed to avoid race conditions seen from the UNO object implementation.
+
+ A method to get a simplified representation is provided by get2DDecomposition. The
+ default implementation returns an empty sequence. The idea is that processors
+ using this primitive and do not know it, may get the decomposition and process
+ these instead. An example is e.g. a fat line, who's decomposition may contain
+ the geometric representation of that line using filled polygon primitives. When
+ the renderer knows how to handle fat lines, he may process this primitive directly;
+ if not he can use the decomposition. With this functionality, renderers may operate by
+ knowing only a small set of primitives.
+
+ When a primitive does not implement get2DDecomposition, it is called a 'Basic Primitive' and
+ belongs to the set of primitives which a processor should be able to handle. Practice
+ will define this minimal sets of primitives. When defined and the concept is proved,
+ unique UNO APIs may be defined/implemented for these set to allow more intense work
+ with primitives using UNO.
+
+ Current Basic 2D Primitives are:
+
+ - BitmapPrimitive2D (bitmap data, evtl. with transparence)
+ - PointArrayPrimitive2D (single points)
+ - PolygonHairlinePrimitive2D (hairline curves/polygons)
+ - PolyPolygonColorPrimitive2D (colored polygons)
+
+ UPDATE: MetafilePrimitive2D (VCL Metafile) is taken off this list since
+ it is implemented with the integration of CWS aw078 into DV300m69.
+
+ All other implemented primitives have a defined decomposition and can thus be
+ decomposed down to this small set.
+
+ A renderer implementing support for this minimal set of primitives can completely
+ render primitive-based visualisations. Of course, he also has to take states into account
+ which are represented by GroupPrimitive2D derivations, see groupprimitive2d.hxx
+
+ To support getting the geometric BoundRect, getB2DRange is used. The default
+ implementation will use the get2DDecomposition result and merge a range from the
+ entries. Thus, an implementation is only necessary for the Basic Primitives, but
+ of course speedups are possible (and are used) by implementing the method at higher-level
+ primitives.
+
+ For primitive identification, getPrimitiveID is used currently in this implementations
+ to allow a fast switch/case processing. This needs a unique identifier mechanism which
+ currently uses defines (see drawinglayer_primitivetypes2d.hxx). For UNO primitive API
+ it will be needed to add a unique descriptor (Name?) later to the API.
+
+ This base implementation provides mappings from the methods from XPrimitive2D
+ (getDecomposition/getRange) to the appropriate methods in the C++ implementations
+ (get2DDecomposition/getB2DRange). The PropertyValue ViewParameters is converted to
+ the appropriate C++ implementation class ViewInformation2D.
+
+ This base class does not implement any buffering; e.g. buffering the decomposition
+ and/or the range. These may be buffered anytime since the definition is that the primitive
+ is read-only and thus unchangeable. This implies that the decomposition and/or getting
+ the range will lead to the same result as last time, under the precondition that
+ the parameter ViewInformation2D is the same as the last one. This is usually the case
+ for view-independent primitives which are defined by not using ViewInformation2D
+ in their get2DDecomposition/getB2DRange implementations.
+ */
+class DRAWINGLAYER_DLLPUBLIC BasePrimitive2D : protected cppu::BaseMutex,
+ public BasePrimitive2DImplBase
+{
+ BasePrimitive2D(const BasePrimitive2D&) = delete;
+ BasePrimitive2D& operator=(const BasePrimitive2D&) = delete;
+
+public:
+ // constructor/destructor
+ BasePrimitive2D();
+ virtual ~BasePrimitive2D() override;
+
+ /** the ==operator is mainly needed to allow testing newly-created primitives against their last
+ incarnation which buffers/holds the made decompositions. The default implementation
+ uses getPrimitive2DID()-calls to test if it's the same ID at last.
+ Overridden implementations are then based on this implementation
+ */
+ virtual bool operator==(const BasePrimitive2D& rPrimitive) const;
+ bool operator!=(const BasePrimitive2D& rPrimitive) const { return !operator==(rPrimitive); }
+
+ /// The default implementation will use getDecomposition results to create the range
+ virtual basegfx::B2DRange
+ getB2DRange(const geometry::ViewInformation2D& rViewInformation) const;
+
+ /** provide unique ID for fast identifying of known primitive implementations in renderers. These use
+ the defines from drawinglayer_primitivetypes2d.hxx to define unique IDs.
+ This method is normally defined using DeclPrimitive2DIDBlock()
+ */
+ virtual sal_uInt32 getPrimitive2DID() const = 0;
+
+ /// The default implementation will return an empty sequence
+ virtual void get2DDecomposition(Primitive2DDecompositionVisitor& rVisitor,
+ const geometry::ViewInformation2D& rViewInformation) const;
+
+ // Methods from XPrimitive2D
+
+ /** The getDecomposition implementation for UNO API will use getDecomposition from this implementation. It
+ will construct a ViewInformation2D from the ViewParameters for that purpose
+ */
+ virtual css::uno::Sequence<::css::uno::Reference<::css::graphic::XPrimitive2D>> SAL_CALL
+ getDecomposition(const css::uno::Sequence<css::beans::PropertyValue>& rViewParameters) override;
+
+ /** The getRange implementation for UNO API will use getRange from this implementation. It
+ will construct a ViewInformation2D from the ViewParameters for that purpose
+ */
+ virtual css::geometry::RealRectangle2D SAL_CALL
+ getRange(const css::uno::Sequence<css::beans::PropertyValue>& rViewParameters) override;
+
+ // XAccounting
+ virtual sal_Int64 SAL_CALL estimateUsage() override;
+};
+} // end of namespace primitive2d
} // end of namespace drawinglayer
-
// BufferedDecompositionPrimitive2D class
namespace drawinglayer
{
- namespace primitive2d
+namespace primitive2d
+{
+/** BufferedDecompositionPrimitive2D class
+
+ Baseclass for all C++ implementations of css::graphic::XPrimitive2D
+ which want to buffer the decomposition result
+
+ Buffering the decomposition is the most-used buffering and is thus used my most
+ primitive implementations which support a decomposition as base class.
+
+ The buffering is done by holding the last decomposition in the local parameter
+ maBuffered2DDecomposition. The default implementation of get2DDecomposition checks
+ if maBuffered2DDecomposition is empty. If yes, it uses create2DDecomposition
+ to create the content. In all cases, maBuffered2DDecomposition is returned.
+
+ For view-dependent primitives derived from Primitive2DBufferDecomposition more needs
+ to be done when the decomposition depends on parts of the parameter ViewInformation2D.
+ This defines a standard method for processing these:
+
+ Implement a view-dependent get2DDecomposition doing the following steps:
+ (a) Locally extract needed parameters from ViewInformation2D to new, local parameters
+ (this may be a complete local copy of ViewInformation2D)
+ (b) If a buffered decomposition exists, ckeck if one of the new local parameters
+ differs from the corresponding locally remembered (as member) ones. If yes,
+ clear maBuffered2DDecomposition
+ (d) call baseclass::get2DDecomposition which will use create2DDecomposition
+ to fill maBuffered2DDecomposition if it's empty
+ (e) copy the new local parameters to the corresponding locally remembered ones
+ to identify if a new decomposition is needed at the next call
+ (f) return maBuffered2DDecomposition
+ */
+class DRAWINGLAYER_DLLPUBLIC BufferedDecompositionPrimitive2D : public BasePrimitive2D
+{
+private:
+ /// a sequence used for buffering the last create2DDecomposition() result
+ 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 Primitive2DContainer& getBuffered2DDecomposition() const
{
- /** BufferedDecompositionPrimitive2D class
-
- Baseclass for all C++ implementations of css::graphic::XPrimitive2D
- which want to buffer the decomposition result
-
- Buffering the decomposition is the most-used buffering and is thus used my most
- primitive implementations which support a decomposition as base class.
-
- The buffering is done by holding the last decomposition in the local parameter
- maBuffered2DDecomposition. The default implementation of get2DDecomposition checks
- if maBuffered2DDecomposition is empty. If yes, it uses create2DDecomposition
- to create the content. In all cases, maBuffered2DDecomposition is returned.
-
- For view-dependent primitives derived from Primitive2DBufferDecomposition more needs
- to be done when the decomposition depends on parts of the parameter ViewInformation2D.
- This defines a standard method for processing these:
-
- Implement a view-dependent get2DDecomposition doing the following steps:
- (a) Locally extract needed parameters from ViewInformation2D to new, local parameters
- (this may be a complete local copy of ViewInformation2D)
- (b) If a buffered decomposition exists, ckeck if one of the new local parameters
- differs from the corresponding locally remembered (as member) ones. If yes,
- clear maBuffered2DDecomposition
- (d) call baseclass::get2DDecomposition which will use create2DDecomposition
- to fill maBuffered2DDecomposition if it's empty
- (e) copy the new local parameters to the corresponding locally remembered ones
- to identify if a new decomposition is needed at the next call
- (f) return maBuffered2DDecomposition
- */
- class DRAWINGLAYER_DLLPUBLIC BufferedDecompositionPrimitive2D
- : public BasePrimitive2D
- {
- private:
- /// a sequence used for buffering the last create2DDecomposition() result
- 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 Primitive2DContainer& getBuffered2DDecomposition() const { return maBuffered2DDecomposition; }
- void setBuffered2DDecomposition(const Primitive2DContainer& rNew) { maBuffered2DDecomposition = rNew; }
+ 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
+ /** 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 void create2DDecomposition(Primitive2DContainer& rContainer, const geometry::ViewInformation2D& rViewInformation) const;
-
- public:
- // constructor/destructor
- BufferedDecompositionPrimitive2D();
-
- /** The getDecomposition default implementation will on demand use create2DDecomposition() if
- maBuffered2DDecomposition is empty. It will set maBuffered2DDecomposition to this obtained decomposition
- to buffer it. If the decomposition is also ViewInformation2D-dependent, this method needs to be
- 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 void get2DDecomposition(Primitive2DDecompositionVisitor& rVisitor, const geometry::ViewInformation2D& rViewInformation) const override;
- };
- } // end of namespace primitive2d
+ virtual void create2DDecomposition(Primitive2DContainer& rContainer,
+ const geometry::ViewInformation2D& rViewInformation) const;
+
+public:
+ // constructor/destructor
+ BufferedDecompositionPrimitive2D();
+
+ /** The getDecomposition default implementation will on demand use create2DDecomposition() if
+ maBuffered2DDecomposition is empty. It will set maBuffered2DDecomposition to this obtained decomposition
+ to buffer it. If the decomposition is also ViewInformation2D-dependent, this method needs to be
+ 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 void
+ get2DDecomposition(Primitive2DDecompositionVisitor& rVisitor,
+ const geometry::ViewInformation2D& rViewInformation) const override;
+};
+} // end of namespace primitive2d
} // end of namespace drawinglayer
-
// tooling
namespace drawinglayer
{
- namespace primitive2d
- {
- /// get B2DRange from a given Primitive2DReference
- basegfx::B2DRange DRAWINGLAYER_DLLPUBLIC getB2DRangeFromPrimitive2DReference(const Primitive2DReference& rCandidate, const geometry::ViewInformation2D& aViewInformation);
+namespace primitive2d
+{
+/// get B2DRange from a given Primitive2DReference
+basegfx::B2DRange DRAWINGLAYER_DLLPUBLIC getB2DRangeFromPrimitive2DReference(
+ const Primitive2DReference& rCandidate, const geometry::ViewInformation2D& aViewInformation);
- /** compare two Primitive2DReferences for equality, including trying to get implementations (BasePrimitive2D)
- and using compare operator
- */
- bool DRAWINGLAYER_DLLPUBLIC arePrimitive2DReferencesEqual(const Primitive2DReference& rA, const Primitive2DReference& rB);
+/** compare two Primitive2DReferences for equality, including trying to get implementations (BasePrimitive2D)
+ and using compare operator
+ */
+bool DRAWINGLAYER_DLLPUBLIC arePrimitive2DReferencesEqual(const Primitive2DReference& rA,
+ const Primitive2DReference& rB);
- OUString DRAWINGLAYER_DLLPUBLIC idToString(sal_uInt32 nId);
+OUString DRAWINGLAYER_DLLPUBLIC idToString(sal_uInt32 nId);
- } // end of namespace primitive2d
+} // end of namespace primitive2d
} // end of namespace drawinglayer
-
#endif //INCLUDED_DRAWINGLAYER_PRIMITIVE2D_BASEPRIMITIVE2D_HXX
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/solenv/clang-format/blacklist b/solenv/clang-format/blacklist
index f3334412c16d..84500af7c2ef 100644
--- a/solenv/clang-format/blacklist
+++ b/solenv/clang-format/blacklist
@@ -3758,7 +3758,6 @@ drawinglayer/source/geometry/viewinformation2d.cxx
drawinglayer/source/geometry/viewinformation3d.cxx
drawinglayer/source/primitive2d/animatedprimitive2d.cxx
drawinglayer/source/primitive2d/backgroundcolorprimitive2d.cxx
-drawinglayer/source/primitive2d/baseprimitive2d.cxx
drawinglayer/source/primitive2d/bitmapprimitive2d.cxx
drawinglayer/source/primitive2d/borderlineprimitive2d.cxx
drawinglayer/source/primitive2d/controlprimitive2d.cxx
@@ -6067,7 +6066,6 @@ include/drawinglayer/geometry/viewinformation2d.hxx
include/drawinglayer/geometry/viewinformation3d.hxx
include/drawinglayer/primitive2d/animatedprimitive2d.hxx
include/drawinglayer/primitive2d/backgroundcolorprimitive2d.hxx
-include/drawinglayer/primitive2d/baseprimitive2d.hxx
include/drawinglayer/primitive2d/bitmapprimitive2d.hxx
include/drawinglayer/primitive2d/borderlineprimitive2d.hxx
include/drawinglayer/primitive2d/controlprimitive2d.hxx
More information about the Libreoffice-commits
mailing list