drawinglayer/source/primitive3d/baseprimitive3d.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*************************************************************************
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * Copyright 2000, 2010 Oracle and/or its affiliates.
   7  *
   8  * OpenOffice.org - a multi-platform office productivity suite
   9  *
  10  * This file is part of OpenOffice.org.
  11  *
  12  * OpenOffice.org is free software: you can redistribute it and/or modify
  13  * it under the terms of the GNU Lesser General Public License version 3
  14  * only, as published by the Free Software Foundation.
  15  *
  16  * OpenOffice.org is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU Lesser General Public License version 3 for more details
  20  * (a copy is included in the LICENSE file that accompanied this code).
  21  *
  22  * You should have received a copy of the GNU Lesser General Public License
  23  * version 3 along with OpenOffice.org.  If not, see
  24  * <http://www.openoffice.org/license.html>
  25  * for a copy of the LGPLv3 License.
  26  *
  27  ************************************************************************/
  28
  29 #include <drawinglayer/primitive3d/baseprimitive3d.hxx>
  30 #include <drawinglayer/geometry/viewinformation3d.hxx>
  31 #include <basegfx/tools/canvastools.hxx>
  32
  33 //////////////////////////////////////////////////////////////////////////////
  34
  35 using namespace com::sun::star;
  36
  37 //////////////////////////////////////////////////////////////////////////////
  38
  39 namespace drawinglayer
  40 {
  41     namespace primitive3d
  42     {
  43         BasePrimitive3D::BasePrimitive3D()
  44         :   BasePrimitive3DImplBase(m_aMutex)
  45         {
  46         }
  47
  48         BasePrimitive3D::~BasePrimitive3D()
  49         {
  50         }
  51
  52         bool BasePrimitive3D::operator==( const BasePrimitive3D& rPrimitive ) const
  53         {
  54             return (getPrimitive3DID() == rPrimitive.getPrimitive3DID());
  55         }
  56
  57         basegfx::B3DRange BasePrimitive3D::getB3DRange(const geometry::ViewInformation3D& rViewInformation) const
  58         {
  59             return getB3DRangeFromPrimitive3DSequence(get3DDecomposition(rViewInformation), rViewInformation);
  60         }
  61
  62         Primitive3DSequence BasePrimitive3D::get3DDecomposition(const geometry::ViewInformation3D& /*rViewInformation*/) const
  63         {
  64             return Primitive3DSequence();
  65         }
  66
  67         Primitive3DSequence SAL_CALL BasePrimitive3D::getDecomposition( const uno::Sequence< beans::PropertyValue >& rViewParameters ) throw ( uno::RuntimeException )
  68         {
  69             const geometry::ViewInformation3D aViewInformation(rViewParameters);
  70             return get3DDecomposition(rViewParameters);
  71         }
  72
  73         com::sun::star::geometry::RealRectangle3D SAL_CALL BasePrimitive3D::getRange( const uno::Sequence< beans::PropertyValue >& rViewParameters ) throw ( uno::RuntimeException )
  74         {
  75             const geometry::ViewInformation3D aViewInformation(rViewParameters);
  76             return basegfx::unotools::rectangle3DFromB3DRectangle(getB3DRange(aViewInformation));
  77         }
  78     } // end of namespace primitive3d
  79 } // end of namespace drawinglayer
  80
  81 //////////////////////////////////////////////////////////////////////////////
  82
  83 namespace drawinglayer
  84 {
  85     namespace primitive3d
  86     {
  87         Primitive3DSequence BufferedDecompositionPrimitive3D::create3DDecomposition(const geometry::ViewInformation3D& /*rViewInformation*/) const
  88         {
  89             return Primitive3DSequence();
  90         }
  91
  92         BufferedDecompositionPrimitive3D::BufferedDecompositionPrimitive3D()
  93         :   BasePrimitive3D(),
  94             maBuffered3DDecomposition()
  95         {
  96         }
  97
  98         Primitive3DSequence BufferedDecompositionPrimitive3D::get3DDecomposition(const geometry::ViewInformation3D& rViewInformation) const
  99         {
 100             ::osl::MutexGuard aGuard( m_aMutex );
 101
 102             if(!getBuffered3DDecomposition().hasElements())
 103             {
 104                 const Primitive3DSequence aNewSequence(create3DDecomposition(rViewInformation));
 105                 const_cast< BufferedDecompositionPrimitive3D* >(this)->setBuffered3DDecomposition(aNewSequence);
 106             }
 107
 108             return getBuffered3DDecomposition();
 109         }
 110     } // end of namespace primitive3d
 111 } // end of namespace drawinglayer
 112
 113 //////////////////////////////////////////////////////////////////////////////
 114 // tooling
 115
 116 namespace drawinglayer
 117 {
 118     namespace primitive3d
 119     {
 120         // get range3D from a given Primitive3DReference
 121         basegfx::B3DRange getB3DRangeFromPrimitive3DReference(const Primitive3DReference& rCandidate, const geometry::ViewInformation3D& aViewInformation)
 122         {
 123             basegfx::B3DRange aRetval;
 124
 125             if(rCandidate.is())
 126             {
 127                 // try to get C++ implementation base
 128                 const BasePrimitive3D* pCandidate(dynamic_cast< BasePrimitive3D* >(rCandidate.get()));
 129
 130                 if(pCandidate)
 131                 {
 132                     // use it if possible
 133                     aRetval.expand(pCandidate->getB3DRange(aViewInformation));
 134                 }
 135                 else
 136                 {
 137                     // use UNO API call instead
 138                     const uno::Sequence< beans::PropertyValue >& rViewParameters(aViewInformation.getViewInformationSequence());
 139                     aRetval.expand(basegfx::unotools::b3DRectangleFromRealRectangle3D(rCandidate->getRange(rViewParameters)));
 140                 }
 141             }
 142
 143             return aRetval;
 144         }
 145
 146         // get range3D from a given Primitive3DSequence
 147         basegfx::B3DRange getB3DRangeFromPrimitive3DSequence(const Primitive3DSequence& rCandidate, const geometry::ViewInformation3D& aViewInformation)
 148         {
 149             basegfx::B3DRange aRetval;
 150
 151             if(rCandidate.hasElements())
 152             {
 153                 const sal_Int32 nCount(rCandidate.getLength());
 154
 155                 for(sal_Int32 a(0L); a < nCount; a++)
 156                 {
 157                     aRetval.expand(getB3DRangeFromPrimitive3DReference(rCandidate[a], aViewInformation));
 158                 }
 159             }
 160
 161             return aRetval;
 162         }
 163
 164         bool arePrimitive3DReferencesEqual(const Primitive3DReference& rxA, const Primitive3DReference& rxB)
 165         {
 166             const sal_Bool bAIs(rxA.is());
 167
 168             if(bAIs != rxB.is())
 169             {
 170                 return false;
 171             }
 172
 173             if(!bAIs)
 174             {
 175                 return true;
 176             }
 177
 178             const BasePrimitive3D* pA(dynamic_cast< const BasePrimitive3D* >(rxA.get()));
 179             const BasePrimitive3D* pB(dynamic_cast< const BasePrimitive3D* >(rxB.get()));
 180             const bool bAEqualZero(pA == 0L);
 181
 182             if(bAEqualZero != (pB == 0L))
 183             {
 184                 return false;
 185             }
 186
 187             if(bAEqualZero)
 188             {
 189                 return false;
 190             }
 191
 192             return (pA->operator==(*pB));
 193         }
 194
 195         bool arePrimitive3DSequencesEqual(const Primitive3DSequence& rA, const Primitive3DSequence& rB)
 196         {
 197             const sal_Bool bAHasElements(rA.hasElements());
 198
 199             if(bAHasElements != rB.hasElements())
 200             {
 201                 return false;
 202             }
 203
 204             if(!bAHasElements)
 205             {
 206                 return true;
 207             }
 208
 209             const sal_Int32 nCount(rA.getLength());
 210
 211             if(nCount != rB.getLength())
 212             {
 213                 return false;
 214             }
 215
 216             for(sal_Int32 a(0L); a < nCount; a++)
 217             {
 218                 if(!arePrimitive3DReferencesEqual(rA[a], rB[a]))
 219                 {
 220                     return false;
 221                 }
 222             }
 223
 224             return true;
 225         }
 226
 227         // concatenate sequence
 228         void appendPrimitive3DSequenceToPrimitive3DSequence(Primitive3DSequence& rDest, const Primitive3DSequence& rSource)
 229         {
 230             if(rSource.hasElements())
 231             {
 232                 if(rDest.hasElements())
 233                 {
 234                     const sal_Int32 nSourceCount(rSource.getLength());
 235                     const sal_Int32 nDestCount(rDest.getLength());
 236                     const sal_Int32 nTargetCount(nSourceCount + nDestCount);
 237                     sal_Int32 nInsertPos(nDestCount);
 238
 239                     rDest.realloc(nTargetCount);
 240
 241                     for(sal_Int32 a(0L); a < nSourceCount; a++)
 242                     {
 243                         if(rSource[a].is())
 244                         {
 245                             rDest[nInsertPos++] = rSource[a];
 246                         }
 247                     }
 248
 249                     if(nInsertPos != nTargetCount)
 250                     {
 251                         rDest.realloc(nInsertPos);
 252                     }
 253                 }
 254                 else
 255                 {
 256                     rDest = rSource;
 257                 }
 258             }
 259         }
 260
 261         // concatenate single Primitive3D
 262         void appendPrimitive3DReferenceToPrimitive3DSequence(Primitive3DSequence& rDest, const Primitive3DReference& rSource)
 263         {
 264             if(rSource.is())
 265             {
 266                 const sal_Int32 nDestCount(rDest.getLength());
 267                 rDest.realloc(nDestCount + 1L);
 268                 rDest[nDestCount] = rSource;
 269             }
 270         }
 271
 272     } // end of namespace primitive3d
 273 } // end of namespace drawinglayer
 274
 275 //////////////////////////////////////////////////////////////////////////////
 276 // eof
 277
 278 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */