drawinglayer/source/primitive2d/baseprimitive2d.cxx

   1 /*************************************************************************
   2  *
   3  *  OpenOffice.org - a multi-platform office productivity suite
   4  *
   5  *  $RCSfile: baseprimitive2d.cxx,v $
   6  *
   7  *  $Revision: 1.6 $
   8  *
   9  *  last change: $Author: aw $ $Date: 2008-05-27 14:11:20 $
  10  *
  11  *  The Contents of this file are made available subject to
  12  *  the terms of GNU Lesser General Public License Version 2.1.
  13  *
  14  *
  15  *    GNU Lesser General Public License Version 2.1
  16  *    =============================================
  17  *    Copyright 2005 by Sun Microsystems, Inc.
  18  *    901 San Antonio Road, Palo Alto, CA 94303, USA
  19  *
  20  *    This library is free software; you can redistribute it and/or
  21  *    modify it under the terms of the GNU Lesser General Public
  22  *    License version 2.1, as published by the Free Software Foundation.
  23  *
  24  *    This library is distributed in the hope that it will be useful,
  25  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  26  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  27  *    Lesser General Public License for more details.
  28  *
  29  *    You should have received a copy of the GNU Lesser General Public
  30  *    License along with this library; if not, write to the Free Software
  31  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  32  *    MA  02111-1307  USA
  33  *
  34  ************************************************************************/
  35
  36 // MARKER(update_precomp.py): autogen include statement, do not remove
  37 #include "precompiled_drawinglayer.hxx"
  38
  39 #include <drawinglayer/primitive2d/baseprimitive2d.hxx>
  40 #include <drawinglayer/geometry/viewinformation2d.hxx>
  41 #include <basegfx/tools/canvastools.hxx>
  42
  43 //////////////////////////////////////////////////////////////////////////////
  44
  45 using namespace com::sun::star;
  46
  47 //////////////////////////////////////////////////////////////////////////////
  48
  49 namespace drawinglayer
  50 {
  51     namespace primitive2d
  52     {
  53         Primitive2DSequence BasePrimitive2D::createLocalDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
  54         {
  55             return Primitive2DSequence();
  56         }
  57
  58         BasePrimitive2D::BasePrimitive2D()
  59         :       BasePrimitive2DImplBase(m_aMutex),
  60             maLocalDecomposition()
  61         {
  62         }
  63
  64         bool BasePrimitive2D::operator==( const BasePrimitive2D& rPrimitive ) const
  65         {
  66             return (getPrimitiveID() == rPrimitive.getPrimitiveID());
  67         }
  68
  69         basegfx::B2DRange BasePrimitive2D::getB2DRange(const geometry::ViewInformation2D& rViewInformation) const
  70         {
  71             return getB2DRangeFromPrimitive2DSequence(get2DDecomposition(rViewInformation), rViewInformation);
  72         }
  73
  74         Primitive2DSequence BasePrimitive2D::get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
  75         {
  76             ::osl::MutexGuard aGuard( m_aMutex );
  77
  78             if(!getLocalDecomposition().hasElements())
  79             {
  80                 const Primitive2DSequence aNewSequence(createLocalDecomposition(rViewInformation));
  81                 const_cast< BasePrimitive2D* >(this)->setLocalDecomposition(aNewSequence);
  82             }
  83
  84             return getLocalDecomposition();
  85         }
  86
  87         Primitive2DSequence SAL_CALL BasePrimitive2D::getDecomposition( const uno::Sequence< beans::PropertyValue >& rViewParameters ) throw ( uno::RuntimeException )
  88         {
  89             const geometry::ViewInformation2D aViewInformation(rViewParameters);
  90             return get2DDecomposition(aViewInformation);
  91         }
  92
  93         com::sun::star::geometry::RealRectangle2D SAL_CALL BasePrimitive2D::getRange( const uno::Sequence< beans::PropertyValue >& rViewParameters ) throw ( uno::RuntimeException )
  94         {
  95             const geometry::ViewInformation2D aViewInformation(rViewParameters);
  96             return basegfx::unotools::rectangle2DFromB2DRectangle(getB2DRange(aViewInformation));
  97         }
  98     } // end of namespace primitive2d
  99 } // end of namespace drawinglayer
 100
 101 //////////////////////////////////////////////////////////////////////////////
 102 // tooling
 103
 104 namespace drawinglayer
 105 {
 106     namespace primitive2d
 107     {
 108         // get B2DRange from a given Primitive2DReference
 109         basegfx::B2DRange getB2DRangeFromPrimitive2DReference(const Primitive2DReference& rCandidate, const geometry::ViewInformation2D& aViewInformation)
 110         {
 111             basegfx::B2DRange aRetval;
 112
 113             if(rCandidate.is())
 114             {
 115                 // try to get C++ implementation base
 116                 const BasePrimitive2D* pCandidate(dynamic_cast< BasePrimitive2D* >(rCandidate.get()));
 117
 118                 if(pCandidate)
 119                 {
 120                     // use it if possible
 121                     aRetval.expand(pCandidate->getB2DRange(aViewInformation));
 122                 }
 123                 else
 124                 {
 125                     // use UNO API call instead
 126                     const uno::Sequence< beans::PropertyValue >& rViewParameters(aViewInformation.getViewInformationSequence());
 127                     aRetval.expand(basegfx::unotools::b2DRectangleFromRealRectangle2D(rCandidate->getRange(rViewParameters)));
 128                 }
 129             }
 130
 131             return aRetval;
 132         }
 133
 134         // get B2DRange from a given Primitive2DSequence
 135         basegfx::B2DRange getB2DRangeFromPrimitive2DSequence(const Primitive2DSequence& rCandidate, const geometry::ViewInformation2D& aViewInformation)
 136         {
 137             basegfx::B2DRange aRetval;
 138
 139             if(rCandidate.hasElements())
 140             {
 141                 const sal_Int32 nCount(rCandidate.getLength());
 142
 143                 for(sal_Int32 a(0L); a < nCount; a++)
 144                 {
 145                     aRetval.expand(getB2DRangeFromPrimitive2DReference(rCandidate[a], aViewInformation));
 146                 }
 147             }
 148
 149             return aRetval;
 150         }
 151
 152         bool arePrimitive2DReferencesEqual(const Primitive2DReference& rxA, const Primitive2DReference& rxB)
 153         {
 154             const sal_Bool bAIs(rxA.is());
 155
 156             if(bAIs != rxB.is())
 157             {
 158                 return false;
 159             }
 160
 161             if(!bAIs)
 162             {
 163                 return true;
 164             }
 165
 166             const BasePrimitive2D* pA(dynamic_cast< const BasePrimitive2D* >(rxA.get()));
 167             const BasePrimitive2D* pB(dynamic_cast< const BasePrimitive2D* >(rxB.get()));
 168             const bool bAEqualZero(pA == 0L);
 169
 170             if(bAEqualZero != (pB == 0L))
 171             {
 172                 return false;
 173             }
 174
 175             if(bAEqualZero)
 176             {
 177                 return false;
 178             }
 179
 180             return (pA->operator==(*pB));
 181         }
 182
 183         bool arePrimitive2DSequencesEqual(const Primitive2DSequence& rA, const Primitive2DSequence& rB)
 184         {
 185             const sal_Bool bAHasElements(rA.hasElements());
 186
 187             if(bAHasElements != rB.hasElements())
 188             {
 189                 return false;
 190             }
 191
 192             if(!bAHasElements)
 193             {
 194                 return true;
 195             }
 196
 197             const sal_Int32 nCount(rA.getLength());
 198
 199             if(nCount != rB.getLength())
 200             {
 201                 return false;
 202             }
 203
 204             for(sal_Int32 a(0L); a < nCount; a++)
 205             {
 206                 if(!arePrimitive2DReferencesEqual(rA[a], rB[a]))
 207                 {
 208                     return false;
 209                 }
 210             }
 211
 212             return true;
 213         }
 214
 215         // concatenate sequence
 216         void appendPrimitive2DSequenceToPrimitive2DSequence(Primitive2DSequence& rDest, const Primitive2DSequence& rSource)
 217         {
 218             if(rSource.hasElements())
 219             {
 220                 if(rDest.hasElements())
 221                 {
 222                     const sal_Int32 nSourceCount(rSource.getLength());
 223                     const sal_Int32 nDestCount(rDest.getLength());
 224                     const sal_Int32 nTargetCount(nSourceCount + nDestCount);
 225                     sal_Int32 nInsertPos(nDestCount);
 226
 227                     rDest.realloc(nTargetCount);
 228
 229                     for(sal_Int32 a(0L); a < nSourceCount; a++)
 230                     {
 231                         if(rSource[a].is())
 232                         {
 233                             rDest[nInsertPos++] = rSource[a];
 234                         }
 235                     }
 236
 237                     if(nInsertPos != nTargetCount)
 238                     {
 239                         rDest.realloc(nInsertPos);
 240                     }
 241                 }
 242                 else
 243                 {
 244                     rDest = rSource;
 245                 }
 246             }
 247         }
 248
 249         // concatenate single Primitive2D
 250         void appendPrimitive2DReferenceToPrimitive2DSequence(Primitive2DSequence& rDest, const Primitive2DReference& rSource)
 251         {
 252             if(rSource.is())
 253             {
 254                 const sal_Int32 nDestCount(rDest.getLength());
 255                 rDest.realloc(nDestCount + 1L);
 256                 rDest[nDestCount] = rSource;
 257             }
 258         }
 259
 260     } // end of namespace primitive2d
 261 } // end of namespace drawinglayer
 262
 263 //////////////////////////////////////////////////////////////////////////////
 264 // eof