LCOV - code coverage report
Current view: top level - include/drawinglayer/primitive2d - baseprimitive2d.hxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 3 3 100.0 %
Date: 2014-11-03 Functions: 3 4 75.0 %
Legend: Lines: hit not hit

          Line data    Source code
       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             : #ifndef INCLUDED_DRAWINGLAYER_PRIMITIVE2D_BASEPRIMITIVE2D_HXX
      21             : #define INCLUDED_DRAWINGLAYER_PRIMITIVE2D_BASEPRIMITIVE2D_HXX
      22             : 
      23             : #include <drawinglayer/drawinglayerdllapi.h>
      24             : 
      25             : #include <cppuhelper/compbase1.hxx>
      26             : #include <boost/utility.hpp>
      27             : #include <com/sun/star/graphic/XPrimitive2D.hpp>
      28             : #include <comphelper/broadcasthelper.hxx>
      29             : #include <basegfx/range/b2drange.hxx>
      30             : 
      31             : 
      32             : /** defines for DeclPrimitive2DIDBlock and ImplPrimitive2DIDBlock
      33             :     Added to be able to simply change identification stuff later, e.g. add
      34             :     a identification string and/or ID to the interface and to the implementation
      35             :     ATM used to delclare implement getPrimitive2DID()
      36             : */
      37             : 
      38             : #define DeclPrimitive2DIDBlock() \
      39             :     virtual sal_uInt32 getPrimitive2DID() const SAL_OVERRIDE;
      40             : 
      41             : #define ImplPrimitive2DIDBlock(TheClass, TheID) \
      42             :     sal_uInt32 TheClass::getPrimitive2DID() const { return TheID; }
      43             : 
      44             : 
      45             : // predefines
      46             : 
      47             : namespace drawinglayer { namespace geometry {
      48             :     class ViewInformation2D;
      49             : }}
      50             : 
      51             : namespace drawinglayer { namespace primitive2d {
      52             :     /// typedefs for basePrimitive2DImplBase, Primitive2DSequence and Primitive2DReference
      53             :     typedef cppu::WeakComponentImplHelper1< ::com::sun::star::graphic::XPrimitive2D > BasePrimitive2DImplBase;
      54             :     typedef ::com::sun::star::uno::Reference< ::com::sun::star::graphic::XPrimitive2D > Primitive2DReference;
      55             :     typedef ::com::sun::star::uno::Sequence< Primitive2DReference > Primitive2DSequence;
      56             : }}
      57             : 
      58             : 
      59             : // basePrimitive2D class
      60             : 
      61             : namespace drawinglayer
      62             : {
      63             :     namespace primitive2d
      64             :     {
      65             :         /** BasePrimitive2D class
      66             : 
      67             :             Baseclass for all C++ implementations of com::sun::star::graphic::XPrimitive2D
      68             : 
      69             :             This class is strongly virtual due to the lack of getPrimitiveID() implementation.
      70             :             This is by purpose, this base class shall not be incarnated and be used directly as
      71             :             a XPrimitive2D.
      72             : 
      73             :             Is is derived from boost::noncopyable to make clear that a primitive is a read-only
      74             :             instance and copying or changing values is not intended. The idea is to hold all data
      75             :             needed for visualisation of this primitive in unchangeable form.
      76             : 
      77             :             It is derived from comphelper::OBaseMutex to have a Mutex at hand; in a base
      78             :             implementation this may not be needed, but e.g. when buffering at last decomposition
      79             :             in a local member, multiple threads may try to decompose at the same time, so locking
      80             :             is needed to avoid race conditions seen from the UNO object implementation.
      81             : 
      82             :             A method to get a simplified representation is provided by get2DDecomposition. The
      83             :             default implementation returns an empty sequence. The idea is that processors
      84             :             using this primitive and do not know it, may get the decomposition and process
      85             :             these instead. An example is e.g. a fat line, who's decomposition may contain
      86             :             the geometric representation of that line using filled polygon prmimitives. When
      87             :             the renderer knows how to handle fat lines, he may process this primitive directly;
      88             :             if not he can use the decomposition. With this functionality, renderers may operate by
      89             :             knowing only a small set of primitives.
      90             : 
      91             :             When a primitive does not implement get2DDecomposition, it is called a 'Basic Primitive' and
      92             :             belongs to the set of primitives which a processor should be able to handle. Practice
      93             :             will define this minimal sets of primitives. When defined and the concept is proved,
      94             :             unique UNO APIs may be defined/implemented for these set to allow more intense work
      95             :             with primitives using UNO.
      96             : 
      97             :             Current Basic 2D Primitives are:
      98             : 
      99             :             - BitmapPrimitive2D (bitmap data, evtl. with transparence)
     100             :             - PointArrayPrimitive2D (single points)
     101             :             - PolygonHairlinePrimitive2D (hairline curves/polygons)
     102             :             - PolyPolygonColorPrimitive2D (colored polygons)
     103             : 
     104             :             UPDATE: MetafilePrimitive2D (VCL Metafile) is taken off this list since
     105             :             it is implemented with the integration of CWS aw078 into DV300m69.
     106             : 
     107             :             All other implemented primitives have a defined decomposition and can thus be
     108             :             decomposed down to this small set.
     109             : 
     110             :             A renderer implementing support for this minimal set of primitives can completely
     111             :             render primitive-based visualisations. Of course, he also has to take states into account
     112             :             which are representated by GroupPrimitive2D derivations, see groupprimitive2d.hxx
     113             : 
     114             :             To support getting the geometric BoundRect, getB2DRange is used. The default
     115             :             implementation will use the get2DDecomposition result and merge a range from the
     116             :             entries. Thus, an implementation is only necessary for the Basic Primitives, but
     117             :             of course speedups are possible (and are used) by implementing the method at higher-level
     118             :             primitives.
     119             : 
     120             :             For primitive identification, getPrimitiveID is used currently in this implementations
     121             :             to allow a fast switch/case processing. This needs a unique identifier mechanism which
     122             :             currently uses defines (see drawinglayer_primitivetypes2d.hxx). For UNO prmitive API
     123             :             it will be needed to add a unique descriptor (Name?) later to the API.
     124             : 
     125             :             This base implementation provides mappings from the methods from XPrimitive2D
     126             :             (getDecomposition/getRange) to the appropriate methods in the C++ implementations
     127             :             (get2DDecomposition/getB2DRange). The PropertyValue ViewParameters is converted to
     128             :             the appropriate C++ implementation class ViewInformation2D.
     129             : 
     130             :             This base class does not implement any buffering; e.g. buffering the decompositon
     131             :             and/or the range. These may be buffered anytime since the definition is that the primitive
     132             :             is read-only and thus unchangeable. This implies that the decomposition and/or getting
     133             :             the range will lead to the same result as last time, under the precondition that
     134             :             the parameter ViewInformation2D is the same as the last one. This is usually the case
     135             :             for view-independent primitives which are defined by not using ViewInformation2D
     136             :             in their get2DDecomposition/getB2DRange implementations.
     137             :          */
     138             :         class DRAWINGLAYER_DLLPUBLIC BasePrimitive2D
     139             :         :   private boost::noncopyable,
     140             :             protected comphelper::OBaseMutex,
     141             :             public BasePrimitive2DImplBase
     142             :         {
     143             :         private:
     144             :         protected:
     145             :         public:
     146             :             // constructor/destructor
     147             :             BasePrimitive2D();
     148             :             virtual ~BasePrimitive2D();
     149             : 
     150             :             /** the ==operator is mainly needed to allow testing newly-created primitives against their last
     151             :                 incarnation which buffers/holds the made decompositions. The default implementation
     152             :                 uses getPrimitive2DID()-calls to test if it's the same ID at last. Overloaded implementation are then
     153             :                 based on this implementation
     154             :              */
     155             :             virtual bool operator==( const BasePrimitive2D& rPrimitive ) const;
     156             :             bool operator!=( const BasePrimitive2D& rPrimitive ) const { return !operator==(rPrimitive); }
     157             : 
     158             :             /// The default implementation will use getDecomposition results to create the range
     159             :             virtual basegfx::B2DRange getB2DRange(const geometry::ViewInformation2D& rViewInformation) const;
     160             : 
     161             :             /** provide unique ID for fast identifying of known primitive implementations in renderers. These use
     162             :                 the defines from drawinglayer_primitivetypes2d.hxx to define unique IDs.
     163             :                 This method is normally defined using DeclPrimitive2DIDBlock()
     164             :              */
     165             :             virtual sal_uInt32 getPrimitive2DID() const = 0;
     166             : 
     167             :             /// The default implementation will return an empty sequence
     168             :             virtual Primitive2DSequence get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const;
     169             : 
     170             : 
     171             :             // Methods from XPrimitive2D
     172             : 
     173             : 
     174             :             /** The getDecomposition implementation for UNO API will use getDecomposition from this implementation. It
     175             :                 will construct a ViewInformation2D from the ViewParameters for that purpose
     176             :              */
     177             :             virtual Primitive2DSequence SAL_CALL getDecomposition( const ::com::sun::star::uno::Sequence< ::com::sun::star::beans::PropertyValue >& rViewParameters ) throw ( ::com::sun::star::uno::RuntimeException, std::exception ) SAL_OVERRIDE;
     178             : 
     179             :             /** The getRange implementation for UNO API will use getRange from this implementation. It
     180             :                 will construct a ViewInformation2D from the ViewParameters for that purpose
     181             :              */
     182             :             virtual ::com::sun::star::geometry::RealRectangle2D SAL_CALL getRange( const ::com::sun::star::uno::Sequence< ::com::sun::star::beans::PropertyValue >& rViewParameters ) throw ( ::com::sun::star::uno::RuntimeException, std::exception ) SAL_OVERRIDE;
     183             :         };
     184             :     } // end of namespace primitive2d
     185             : } // end of namespace drawinglayer
     186             : 
     187             : 
     188             : // BufferedDecompositionPrimitive2D class
     189             : 
     190             : namespace drawinglayer
     191             : {
     192             :     namespace primitive2d
     193             :     {
     194             :         /** BufferedDecompositionPrimitive2D class
     195             : 
     196             :             Baseclass for all C++ implementations of com::sun::star::graphic::XPrimitive2D
     197             :             which want to buffer the decomoposition result
     198             : 
     199             :             Buffering the decomposition is the most-used buffering and is thus used my most
     200             :             primitive implementations which support a decomposition as base class.
     201             : 
     202             :             The buffering is done by holding the last decomposition in the local parameter
     203             :             maBuffered2DDecomposition. The default implementation of get2DDecomposition checks
     204             :             if maBuffered2DDecomposition is empty. If yes, it uses create2DDecomposition
     205             :             to create the content. In all cases, maBuffered2DDecomposition is returned.
     206             : 
     207             :             For view-dependent primitives derived from Primitive2DBufferDecomposition more needs
     208             :             to be done when the decomposition depends on parts of the parameter ViewInformation2D.
     209             :             This defines a standard method for processing these:
     210             : 
     211             :             Implement a view-dependent get2DDecomposition doing te following steps:
     212             :             (a) Locally extract needed parameters from ViewInformation2D to new, local parameters
     213             :                 (this may be a complete local copy of ViewInformation2D)
     214             :             (b) If a buffered decomposition exists, ckeck if one of the new local parameters
     215             :                 differs from the corresponding locally remembered (as member) ones. If yes,
     216             :                 clear maBuffered2DDecomposition
     217             :             (d) call baseclass::get2DDecomposition which will use create2DDecomposition
     218             :                 to fill maBuffered2DDecomposition if it's empty
     219             :             (e) copy the new local parameters to the corresponding locally remembered ones
     220             :                 to identify if a new decomposition is needed at the next call
     221             :             (f) return maBuffered2DDecomposition
     222             :          */
     223      238562 :         class DRAWINGLAYER_DLLPUBLIC BufferedDecompositionPrimitive2D
     224             :         :   public BasePrimitive2D
     225             :         {
     226             :         private:
     227             :             /// a sequence used for buffering the last create2DDecomposition() result
     228             :             Primitive2DSequence                             maBuffered2DDecomposition;
     229             : 
     230             :         protected:
     231             :             /** access methods to maBuffered2DDecomposition. The usage of this methods may allow
     232             :                 later thread-safe stuff to be added if needed. Only to be used by getDecomposition()
     233             :                 implementations for buffering the last decomposition.
     234             :              */
     235      841298 :             const Primitive2DSequence& getBuffered2DDecomposition() const { return maBuffered2DDecomposition; }
     236      100714 :             void setBuffered2DDecomposition(const Primitive2DSequence& rNew) { maBuffered2DDecomposition = rNew; }
     237             : 
     238             :             /** method which is to be used to implement the local decomposition of a 2D primitive. The default
     239             :                 implementation will just return an empty decomposition
     240             :              */
     241             :             virtual Primitive2DSequence create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const;
     242             : 
     243             :         public:
     244             :             // constructor/destructor
     245             :             BufferedDecompositionPrimitive2D();
     246             : 
     247             :             /** The getDecomposition default implementation will on demand use create2DDecomposition() if
     248             :                 maBuffered2DDecomposition is empty. It will set maBuffered2DDecomposition to this obtained decomposition
     249             :                 to buffer it. If the decomposition is also ViewInformation2D-dependent, this method needs to be
     250             :                 overloaded and the ViewInformation2D for the last decomposition need to be remembered, too, and
     251             :                 be used in the next call to decide if the buffered decomposition may be reused or not.
     252             :              */
     253             :             virtual Primitive2DSequence get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const SAL_OVERRIDE;
     254             :         };
     255             :     } // end of namespace primitive2d
     256             : } // end of namespace drawinglayer
     257             : 
     258             : 
     259             : // tooling
     260             : 
     261             : namespace drawinglayer
     262             : {
     263             :     namespace primitive2d
     264             :     {
     265             :         /// support to handle a sequence of primitives as stl vector and convert it during creation
     266             :         typedef ::std::vector< BasePrimitive2D* > Primitive2DVector;
     267             :         Primitive2DSequence DRAWINGLAYER_DLLPUBLIC Primitive2DVectorToPrimitive2DSequence(const Primitive2DVector& rSource, bool bInvert = false);
     268             : 
     269             :         /// get B2DRange from a given Primitive2DReference
     270             :         basegfx::B2DRange DRAWINGLAYER_DLLPUBLIC getB2DRangeFromPrimitive2DReference(const Primitive2DReference& rCandidate, const geometry::ViewInformation2D& aViewInformation);
     271             : 
     272             :         /// get B2DRange from a given Primitive2DSequence
     273             :         basegfx::B2DRange DRAWINGLAYER_DLLPUBLIC getB2DRangeFromPrimitive2DSequence(const Primitive2DSequence& rCandidate, const geometry::ViewInformation2D& aViewInformation);
     274             : 
     275             :         /** compare two Primitive2DReferences for equality, including trying to get implementations (BasePrimitive2D)
     276             :             and using compare operator
     277             :          */
     278             :         bool DRAWINGLAYER_DLLPUBLIC arePrimitive2DReferencesEqual(const Primitive2DReference& rA, const Primitive2DReference& rB);
     279             : 
     280             :         /// compare two Primitive2DReferences for equality, uses arePrimitive2DReferencesEqual internally
     281             :         bool DRAWINGLAYER_DLLPUBLIC arePrimitive2DSequencesEqual(const Primitive2DSequence& rA, const Primitive2DSequence& rB);
     282             : 
     283             :         /// concatenate sequence
     284             :         void DRAWINGLAYER_DLLPUBLIC appendPrimitive2DSequenceToPrimitive2DSequence(Primitive2DSequence& rDest, const Primitive2DSequence& rSource);
     285             : 
     286             :         /// concatenate single Primitive2D
     287             :         void DRAWINGLAYER_DLLPUBLIC appendPrimitive2DReferenceToPrimitive2DSequence(Primitive2DSequence& rDest, const Primitive2DReference& rSource);
     288             : 
     289             :         OUString DRAWINGLAYER_DLLPUBLIC idToString(sal_uInt32 nId);
     290             : 
     291             :     } // end of namespace primitive2d
     292             : } // end of namespace drawinglayer
     293             : 
     294             : 
     295             : 
     296             : #endif //INCLUDED_DRAWINGLAYER_PRIMITIVE2D_BASEPRIMITIVE2D_HXX
     297             : 
     298             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10