include/drawinglayer/primitive3d/baseprimitive3d.hxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #pragma once
  21
  22 #include <drawinglayer/drawinglayerdllapi.h>
  23
  24 #include <comphelper/compbase.hxx>
  25 #include <com/sun/star/graphic/XPrimitive3D.hpp>
  26 #include <basegfx/range/b3drange.hxx>
  27 #include <deque>
  28
  29
  30 /** defines for DeclPrimitive3DIDBlock and ImplPrimitive3DIDBlock
  31     Added to be able to simply change identification stuff later, e.g. add
  32     an identification string and/or ID to the interface and to the implementation
  33     ATM used to declare implement getPrimitive3DID()
  34  */
  35
  36 #define DeclPrimitive3DIDBlock() \
  37     virtual sal_uInt32 getPrimitive3DID() const override;
  38
  39 #define ImplPrimitive3DIDBlock(TheClass, TheID) \
  40     sal_uInt32 TheClass::getPrimitive3DID() const { return TheID; }
  41
  42
  43 // predefines
  44
  45 namespace drawinglayer::geometry {
  46     class ViewInformation3D;
  47 }
  48
  49 namespace drawinglayer::primitive3d {
  50     /// typedefs for basePrimitive3DImplBase, Primitive3DContainer and Primitive3DReference
  51     typedef comphelper::WeakComponentImplHelper< css::graphic::XPrimitive3D > BasePrimitive3DImplBase;
  52     typedef css::uno::Reference< css::graphic::XPrimitive3D > Primitive3DReference;
  53
  54     class SAL_WARN_UNUSED DRAWINGLAYER_DLLPUBLIC Primitive3DContainer : public std::deque< Primitive3DReference >
  55     {
  56     public:
  57         explicit Primitive3DContainer() {}
  58         explicit Primitive3DContainer( size_type count ) : deque(count) {}
  59         Primitive3DContainer( const Primitive3DContainer& other ) : deque(other) {}
  60         Primitive3DContainer( Primitive3DContainer&& other ) noexcept : deque(std::move(other)) {}
  61         Primitive3DContainer( std::initializer_list<Primitive3DReference> init ) : deque(init) {}
  62         template <class Iter>
  63         Primitive3DContainer(Iter first, Iter last) : deque(first, last) {}
  64
  65         void append(const Primitive3DContainer& rSource);
  66         Primitive3DContainer& operator=(const Primitive3DContainer& r) { deque::operator=(r); return *this; }
  67         Primitive3DContainer& operator=(Primitive3DContainer&& r) noexcept { deque::operator=(std::move(r)); return *this; }
  68         bool operator==(const Primitive3DContainer& rB) const;
  69         bool operator!=(const Primitive3DContainer& rB) const { return !operator==(rB); }
  70         basegfx::B3DRange getB3DRange(const geometry::ViewInformation3D& aViewInformation) const;
  71     };
  72 }
  73
  74
  75 // basePrimitive3D class
  76
  77 namespace drawinglayer::primitive3d
  78     {
  79         /** BasePrimitive3D class
  80
  81             Baseclass for all C++ implementations of css::graphic::XPrimitive2D
  82
  83             The description/functionality is identical with the 2D case in baseprimitive2d.hxx,
  84             please see there for detailed information.
  85
  86             Current Basic 3D Primitives are:
  87
  88             - PolygonHairlinePrimitive3D (for 3D hairlines)
  89             - PolyPolygonMaterialPrimitive3D (for 3D filled plane polygons)
  90
  91             That's all for 3D!
  92          */
  93         class DRAWINGLAYER_DLLPUBLIC BasePrimitive3D
  94         :   public BasePrimitive3DImplBase
  95         {
  96             BasePrimitive3D(const BasePrimitive3D&) = delete;
  97             BasePrimitive3D& operator=( const BasePrimitive3D& ) = delete;
  98         public:
  99             // constructor/destructor
 100             BasePrimitive3D();
 101             virtual ~BasePrimitive3D() override;
 102
 103             /** the ==operator is mainly needed to allow testing newly-created high level primitives against their last
 104                 incarnation which buffers/holds the decompositions. The default implementation
 105                 uses getPrimitive3DID()-calls to test if it's the same ID at last.
 106                 Overridden implementation are then based on this implementation.
 107              */
 108             virtual bool operator==( const BasePrimitive3D& rPrimitive ) const;
 109             bool operator!=( const BasePrimitive3D& rPrimitive ) const { return !operator==(rPrimitive); }
 110
 111             /** This method is for places where using the C++ implementation directly is possible. The subprocessing
 112                 and range merging is more efficient when working directly on basegfx::B3DRange. The default implementation
 113                 will use getDecomposition results to create the range
 114              */
 115             virtual basegfx::B3DRange getB3DRange(const geometry::ViewInformation3D& rViewInformation) const;
 116
 117             /** provide unique ID for fast identifying of known primitive implementations in renderers. These use
 118                 the defines from primitivetypes3d.hxx to define unique IDs.
 119              */
 120             virtual sal_uInt32 getPrimitive3DID() const = 0;
 121
 122             /// The default implementation returns an empty sequence
 123             virtual Primitive3DContainer get3DDecomposition(const geometry::ViewInformation3D& rViewInformation) const;
 124
 125
 126             // Methods from XPrimitive3D
 127
 128
 129             /** The getDecomposition implementation for UNO API will use getDecomposition from this implementation. It
 130                 will get the ViewInformation from the ViewParameters for that purpose
 131              */
 132             virtual css::uno::Sequence< ::css::uno::Reference< ::css::graphic::XPrimitive3D > > SAL_CALL getDecomposition( const css::uno::Sequence< css::beans::PropertyValue >& rViewParameters ) override final;
 133
 134             /** the getRange default implementation will use getDecomposition to create the range information from merging
 135                 getRange results from the single local decomposition primitives.
 136              */
 137             virtual css::geometry::RealRectangle3D SAL_CALL getRange( const css::uno::Sequence< css::beans::PropertyValue >& rViewParameters ) override final;
 138         };
 139
 140 } // end of namespace drawinglayer::primitive2d
 141
 142
 143 // BufferedDecompositionPrimitive3D class
 144
 145 namespace drawinglayer::primitive3d
 146     {
 147         /** BufferedDecompositionPrimitive3D class
 148
 149             Baseclass for all C++ implementations of css::graphic::XPrimitive2D
 150
 151             The description/functionality is identical with the 2D case in baseprimitive2d.hxx,
 152             please see there for detailed information
 153          */
 154         class DRAWINGLAYER_DLLPUBLIC BufferedDecompositionPrimitive3D
 155         :   public BasePrimitive3D
 156         {
 157         private:
 158             /// a sequence used for buffering the last create3DDecomposition() result
 159             Primitive3DContainer                             maBuffered3DDecomposition;
 160
 161         protected:
 162             /** access methods to maBuffered3DDecomposition. The usage of this methods may allow
 163                 later thread-safe stuff to be added if needed. Only to be used by getDecomposition()
 164                 implementations for buffering the last decomposition.
 165              */
 166             const Primitive3DContainer& getBuffered3DDecomposition() const { return maBuffered3DDecomposition; }
 167             void setBuffered3DDecomposition(const Primitive3DContainer& rNew) { maBuffered3DDecomposition = rNew; }
 168
 169             /** method which is to be used to implement the local decomposition of a 2D primitive. The default
 170                 implementation will just return an empty decomposition
 171              */
 172             virtual Primitive3DContainer create3DDecomposition(const geometry::ViewInformation3D& rViewInformation) const;
 173
 174         public:
 175             // constructor
 176             BufferedDecompositionPrimitive3D();
 177
 178             /** The getDecomposition default implementation will on demand use create3DDecomposition() if
 179                 maBuffered3DDecomposition is empty. It will set maBuffered3DDecomposition to this obtained decomposition
 180                 to buffer it. If the decomposition is also ViewInformation-dependent, this method needs to be
 181                 overridden and the ViewInformation for the last decomposition needs to be remembered, too, and
 182                 be used in the next call to decide if the buffered decomposition may be reused or not.
 183              */
 184             virtual Primitive3DContainer get3DDecomposition(const geometry::ViewInformation3D& rViewInformation) const override;
 185         };
 186
 187 } // end of namespace drawinglayer::primitive3d
 188
 189
 190 // tooling
 191
 192 namespace drawinglayer::primitive3d
 193     {
 194         /// get B3DRange from a given Primitive3DReference
 195         basegfx::B3DRange DRAWINGLAYER_DLLPUBLIC getB3DRangeFromPrimitive3DReference(const Primitive3DReference& rCandidate, const geometry::ViewInformation3D& aViewInformation);
 196
 197         /** compare two Primitive2DReferences for equality, including trying to get implementations (BasePrimitive2D)
 198             and using compare operator
 199          */
 200         bool DRAWINGLAYER_DLLPUBLIC arePrimitive3DReferencesEqual(const Primitive3DReference& rA, const Primitive3DReference& rB);
 201
 202 } // end of namespace drawinglayer::primitive3d
 203
 204 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */