drawinglayer/source/primitive2d/animatedprimitive2d.cxx

   1 /*************************************************************************
   2  *
   3  *  OpenOffice.org - a multi-platform office productivity suite
   4  *
   5  *  $RCSfile: animatedprimitive2d.cxx,v $
   6  *
   7  *  $Revision: 1.5 $
   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/animatedprimitive2d.hxx>
  40 #include <drawinglayer/animation/animationtiming.hxx>
  41 #include <drawinglayer/primitive2d/transformprimitive2d.hxx>
  42 #include <drawinglayer/geometry/viewinformation2d.hxx>
  43 #include <drawinglayer/primitive2d/drawinglayer_primitivetypes2d.hxx>
  44
  45 //////////////////////////////////////////////////////////////////////////////
  46
  47 using namespace com::sun::star;
  48
  49 //////////////////////////////////////////////////////////////////////////////
  50
  51 namespace drawinglayer
  52 {
  53     namespace primitive2d
  54     {
  55         Primitive2DSequence AnimatedSwitchPrimitive2D::createLocalDecomposition(const geometry::ViewInformation2D& rViewInformation) const
  56         {
  57             if(getChildren().hasElements())
  58             {
  59                 const double fState(getAnimationEntry().getStateAtTime(rViewInformation.getViewTime()));
  60                 const sal_uInt32 nLen(getChildren().getLength());
  61                 sal_uInt32 nIndex(basegfx::fround(fState * (double)nLen));
  62
  63                 if(nIndex >= nLen)
  64                 {
  65                     nIndex = nLen - 1L;
  66                 }
  67
  68                 const Primitive2DReference xRef(getChildren()[nIndex], uno::UNO_QUERY_THROW);
  69                 return Primitive2DSequence(&xRef, 1L);
  70             }
  71
  72             return Primitive2DSequence();
  73         }
  74
  75         AnimatedSwitchPrimitive2D::AnimatedSwitchPrimitive2D(
  76             const animation::AnimationEntry& rAnimationEntry,
  77             const Primitive2DSequence& rChildren,
  78             bool bIsTextAnimation)
  79         :       GroupPrimitive2D(rChildren),
  80             mpAnimationEntry(0),
  81             mfDecomposeViewTime(0.0),
  82             mbIsTextAnimation(bIsTextAnimation)
  83         {
  84             // clone given animation description
  85             mpAnimationEntry = rAnimationEntry.clone();
  86         }
  87
  88         AnimatedSwitchPrimitive2D::~AnimatedSwitchPrimitive2D()
  89         {
  90             // delete cloned animation description
  91             delete mpAnimationEntry;
  92         }
  93
  94         bool AnimatedSwitchPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
  95         {
  96             if(GroupPrimitive2D::operator==(rPrimitive))
  97             {
  98                 const AnimatedSwitchPrimitive2D& rCompare = static_cast< const AnimatedSwitchPrimitive2D& >(rPrimitive);
  99
 100                 return (getAnimationEntry() == rCompare.getAnimationEntry());
 101             }
 102
 103             return false;
 104         }
 105
 106         Primitive2DSequence AnimatedSwitchPrimitive2D::get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
 107         {
 108             ::osl::MutexGuard aGuard( m_aMutex );
 109
 110             if(getLocalDecomposition().hasElements() && mfDecomposeViewTime != rViewInformation.getViewTime())
 111             {
 112                 // conditions of last local decomposition have changed, delete
 113                 const_cast< AnimatedSwitchPrimitive2D* >(this)->setLocalDecomposition(Primitive2DSequence());
 114             }
 115
 116             if(!getLocalDecomposition().hasElements())
 117             {
 118                 // remember time
 119                 const_cast< AnimatedSwitchPrimitive2D* >(this)->mfDecomposeViewTime = rViewInformation.getViewTime();
 120             }
 121
 122             // use parent implementation
 123             return GroupPrimitive2D::get2DDecomposition(rViewInformation);
 124         }
 125
 126         basegfx::B2DRange AnimatedSwitchPrimitive2D::getB2DRange(const geometry::ViewInformation2D& rViewInformation) const
 127         {
 128             // to get range from decomposition and not from group content, call implementation from
 129             // BasePrimitive2D here
 130             return BasePrimitive2D::getB2DRange(rViewInformation);
 131         }
 132
 133         // provide unique ID
 134         ImplPrimitrive2DIDBlock(AnimatedSwitchPrimitive2D, PRIMITIVE2D_ID_ANIMATEDSWITCHPRIMITIVE2D)
 135
 136     } // end of namespace primitive2d
 137 } // end of namespace drawinglayer
 138
 139 //////////////////////////////////////////////////////////////////////////////
 140
 141 namespace drawinglayer
 142 {
 143     namespace primitive2d
 144     {
 145         Primitive2DSequence AnimatedBlinkPrimitive2D::createLocalDecomposition(const geometry::ViewInformation2D& rViewInformation) const
 146         {
 147             if(getChildren().hasElements())
 148             {
 149                 const double fState(getAnimationEntry().getStateAtTime(rViewInformation.getViewTime()));
 150
 151                 if(fState < 0.5)
 152                 {
 153                     return getChildren();
 154                 }
 155             }
 156
 157             return Primitive2DSequence();
 158         }
 159
 160         AnimatedBlinkPrimitive2D::AnimatedBlinkPrimitive2D(
 161             const animation::AnimationEntry& rAnimationEntry,
 162             const Primitive2DSequence& rChildren,
 163             bool bIsTextAnimation)
 164         :       AnimatedSwitchPrimitive2D(rAnimationEntry, rChildren, bIsTextAnimation)
 165         {
 166         }
 167
 168         // provide unique ID
 169         ImplPrimitrive2DIDBlock(AnimatedBlinkPrimitive2D, PRIMITIVE2D_ID_ANIMATEDBLINKPRIMITIVE2D)
 170
 171     } // end of namespace primitive2d
 172 } // end of namespace drawinglayer
 173
 174 //////////////////////////////////////////////////////////////////////////////
 175 // helper class for AnimatedInterpolatePrimitive2D
 176
 177 namespace drawinglayer
 178 {
 179     namespace primitive2d
 180     {
 181         BufferedMatrixDecompose::BufferedMatrixDecompose(const basegfx::B2DHomMatrix& rMatrix)
 182         :       maB2DHomMatrix(rMatrix),
 183             maScale(0.0, 0.0),
 184             maTranslate(0.0, 0.0),
 185             mfRotate(0.0),
 186             mfShearX(0.0),
 187             mbDecomposed(false)
 188         {
 189         }
 190
 191         void BufferedMatrixDecompose::ensureDecompose() const
 192         {
 193             if(!mbDecomposed)
 194             {
 195                 BufferedMatrixDecompose* pThis = const_cast< BufferedMatrixDecompose* >(this);
 196                 maB2DHomMatrix.decompose(pThis->maScale, pThis->maTranslate, pThis->mfRotate, pThis->mfShearX);
 197                 pThis->mbDecomposed = true;
 198             }
 199         }
 200     } // end of anonymous namespace
 201 } // end of namespace drawinglayer
 202
 203 //////////////////////////////////////////////////////////////////////////////
 204
 205 namespace drawinglayer
 206 {
 207     namespace primitive2d
 208     {
 209         Primitive2DSequence AnimatedInterpolatePrimitive2D::createLocalDecomposition(const geometry::ViewInformation2D& rViewInformation) const
 210         {
 211             const sal_uInt32 nSize(maMatrixStack.size());
 212
 213             if(nSize)
 214             {
 215                 double fState(getAnimationEntry().getStateAtTime(rViewInformation.getViewTime()));
 216
 217                 if(fState < 0.0)
 218                 {
 219                     fState = 0.0;
 220                 }
 221                 else if(fState > 1.0)
 222                 {
 223                     fState = 1.0;
 224                 }
 225
 226                 const double fIndex(fState * (double)(nSize - 1L));
 227                 const sal_uInt32 nIndA(sal_uInt32(floor(fIndex)));
 228                 const double fOffset(fIndex - (double)nIndA);
 229                 basegfx::B2DHomMatrix aTargetTransform;
 230
 231                 if(basegfx::fTools::equalZero(fOffset))
 232                 {
 233                     // use matrix from nIndA directly
 234                     aTargetTransform = maMatrixStack[nIndA].getB2DHomMatrix();
 235                 }
 236                 else
 237                 {
 238                     // interpolate. Get involved matrices and ensure they are decomposed
 239                     const sal_uInt32 nIndB((nIndA + 1L) % nSize);
 240                     std::vector< BufferedMatrixDecompose >::const_iterator aMatA(maMatrixStack.begin() + nIndA);
 241                     std::vector< BufferedMatrixDecompose >::const_iterator aMatB(maMatrixStack.begin() + nIndB);
 242
 243                     aMatA->ensureDecompose();
 244                     aMatB->ensureDecompose();
 245
 246                     // interpolate for fOffset [0.0 .. 1.0[
 247                     const basegfx::B2DVector aScale(basegfx::interpolate(aMatA->getScale(), aMatB->getScale(), fOffset));
 248                     const basegfx::B2DVector aTranslate(basegfx::interpolate(aMatA->getTranslate(), aMatB->getTranslate(), fOffset));
 249                     const double fRotate(((aMatB->getRotate() - aMatA->getRotate()) * fOffset) + aMatA->getRotate());
 250                     const double fShearX(((aMatB->getShearX() - aMatA->getShearX()) * fOffset) + aMatA->getShearX());
 251
 252                     // build matrix for state
 253                     aTargetTransform.scale(aScale.getX(), aScale.getY());
 254                     aTargetTransform.shearX(fShearX);
 255                     aTargetTransform.rotate(fRotate);
 256                     aTargetTransform.translate(aTranslate.getX(), aTranslate.getY());
 257                 }
 258
 259                 // create new transform primitive reference, return new sequence
 260                 const Primitive2DReference xRef(new TransformPrimitive2D(aTargetTransform, getChildren()));
 261                 return Primitive2DSequence(&xRef, 1L);
 262             }
 263             else
 264             {
 265                 return getChildren();
 266             }
 267         }
 268
 269         AnimatedInterpolatePrimitive2D::AnimatedInterpolatePrimitive2D(
 270             const std::vector< basegfx::B2DHomMatrix >& rmMatrixStack,
 271             const animation::AnimationEntry& rAnimationEntry,
 272             const Primitive2DSequence& rChildren,
 273             bool bIsTextAnimation)
 274         :       AnimatedSwitchPrimitive2D(rAnimationEntry, rChildren, bIsTextAnimation),
 275             maMatrixStack()
 276         {
 277             // copy matrices
 278             const sal_uInt32 nCount(rmMatrixStack.size());
 279
 280             for(sal_uInt32 a(0L); a < nCount; a++)
 281             {
 282                 maMatrixStack.push_back(BufferedMatrixDecompose(rmMatrixStack[a]));
 283             }
 284         }
 285
 286         // provide unique ID
 287         ImplPrimitrive2DIDBlock(AnimatedInterpolatePrimitive2D, PRIMITIVE2D_ID_ANIMATEDINTERPOLATEPRIMITIVE2D)
 288
 289     } // end of namespace primitive2d
 290 } // end of namespace drawinglayer
 291
 292 //////////////////////////////////////////////////////////////////////////////
 293 // eof