drawinglayer/source/animation/animationtiming.cxx

   1 /*************************************************************************
   2  *
   3  *  OpenOffice.org - a multi-platform office productivity suite
   4  *
   5  *  $RCSfile: animationtiming.cxx,v $
   6  *
   7  *  $Revision: 1.6 $
   8  *
   9  *  last change: $Author: aw $ $Date: 2008-05-27 14:11:19 $
  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/animation/animationtiming.hxx>
  40 #include <basegfx/numeric/ftools.hxx>
  41
  42 //////////////////////////////////////////////////////////////////////////////
  43
  44 namespace drawinglayer
  45 {
  46     namespace animation
  47     {
  48         //////////////////////////////////////////////////////////////////////////////
  49
  50         AnimationEntry::AnimationEntry()
  51         {
  52         }
  53
  54         AnimationEntry::~AnimationEntry()
  55         {
  56         }
  57
  58         //////////////////////////////////////////////////////////////////////////////
  59
  60         AnimationEntryFixed::AnimationEntryFixed(double fDuration, double fState)
  61         :       mfDuration(fDuration),
  62             mfState(fState)
  63         {
  64         }
  65
  66         AnimationEntryFixed::~AnimationEntryFixed()
  67         {
  68         }
  69
  70         AnimationEntry* AnimationEntryFixed::clone() const
  71         {
  72             return new AnimationEntryFixed(mfDuration, mfState);
  73         }
  74
  75         bool AnimationEntryFixed::operator==(const AnimationEntry& rCandidate) const
  76         {
  77             const AnimationEntryFixed* pCompare = dynamic_cast< const AnimationEntryFixed* >(&rCandidate);
  78
  79             return (pCompare
  80                 && basegfx::fTools::equal(mfDuration, pCompare->mfDuration)
  81                 && basegfx::fTools::equal(mfState, pCompare->mfState));
  82         }
  83
  84         double AnimationEntryFixed::getDuration() const
  85         {
  86             return mfDuration;
  87         }
  88
  89         double AnimationEntryFixed::getStateAtTime(double /*fTime*/) const
  90         {
  91             return mfState;
  92         }
  93
  94         double AnimationEntryFixed::getNextEventTime(double fTime) const
  95         {
  96             if(basegfx::fTools::less(fTime, mfDuration))
  97             {
  98                 return mfDuration;
  99             }
 100             else
 101             {
 102                 return 0.0;
 103             }
 104         }
 105
 106         //////////////////////////////////////////////////////////////////////////////
 107
 108         AnimationEntryLinear::AnimationEntryLinear(double fDuration, double fFrequency, double fStart, double fStop)
 109         :       mfDuration(fDuration),
 110             mfFrequency(fFrequency),
 111             mfStart(fStart),
 112             mfStop(fStop)
 113         {
 114         }
 115
 116         AnimationEntryLinear::~AnimationEntryLinear()
 117         {
 118         }
 119
 120         AnimationEntry* AnimationEntryLinear::clone() const
 121         {
 122             return new AnimationEntryLinear(mfDuration, mfFrequency, mfStart, mfStop);
 123         }
 124
 125         bool AnimationEntryLinear::operator==(const AnimationEntry& rCandidate) const
 126         {
 127             const AnimationEntryLinear* pCompare = dynamic_cast< const AnimationEntryLinear* >(&rCandidate);
 128
 129             return (pCompare
 130                 && basegfx::fTools::equal(mfDuration, pCompare->mfDuration)
 131                 && basegfx::fTools::equal(mfStart, pCompare->mfStart)
 132                 && basegfx::fTools::equal(mfStop, pCompare->mfStop));
 133         }
 134
 135         double AnimationEntryLinear::getDuration() const
 136         {
 137             return mfDuration;
 138         }
 139
 140         double AnimationEntryLinear::getStateAtTime(double fTime) const
 141         {
 142             if(basegfx::fTools::more(mfDuration, 0.0))
 143             {
 144                 const double fFactor(fTime / mfDuration);
 145
 146                 if(fFactor > 1.0)
 147                 {
 148                     return mfStop;
 149                 }
 150                 else
 151                 {
 152                     return mfStart + ((mfStop - mfStart) * fFactor);
 153                 }
 154             }
 155             else
 156             {
 157                 return mfStart;
 158             }
 159         }
 160
 161         double AnimationEntryLinear::getNextEventTime(double fTime) const
 162         {
 163             if(basegfx::fTools::less(fTime, mfDuration))
 164             {
 165                 // use the simple solution: just add the frequency. More correct (but also more
 166                 // complicated) would be to calculate the slice of time we are in and when this
 167                 // slice will end. For the animations, this makes no quality difference.
 168                 fTime += mfFrequency;
 169
 170                 if(basegfx::fTools::more(fTime, mfDuration))
 171                 {
 172                     fTime = mfDuration;
 173                 }
 174
 175                 return fTime;
 176             }
 177             else
 178             {
 179                 return 0.0;
 180             }
 181         }
 182
 183         //////////////////////////////////////////////////////////////////////////////
 184
 185         sal_uInt32 AnimationEntryList::impGetIndexAtTime(double fTime, double &rfAddedTime) const
 186         {
 187             sal_uInt32 nIndex(0L);
 188
 189             while(nIndex < maEntries.size() && basegfx::fTools::lessOrEqual(rfAddedTime + maEntries[nIndex]->getDuration(), fTime))
 190             {
 191                 rfAddedTime += maEntries[nIndex++]->getDuration();
 192             }
 193
 194             return nIndex;
 195         }
 196
 197         AnimationEntryList::AnimationEntryList()
 198         :       mfDuration(0.0)
 199         {
 200         }
 201
 202         AnimationEntryList::~AnimationEntryList()
 203         {
 204             for(sal_uInt32 a(0L); a < maEntries.size(); a++)
 205             {
 206                 delete maEntries[a];
 207             }
 208         }
 209
 210         AnimationEntry* AnimationEntryList::clone() const
 211         {
 212             AnimationEntryList* pNew = new AnimationEntryList();
 213
 214             for(sal_uInt32 a(0L); a < maEntries.size(); a++)
 215             {
 216                 pNew->append(*maEntries[a]);
 217             }
 218
 219             return pNew;
 220         }
 221
 222         bool AnimationEntryList::operator==(const AnimationEntry& rCandidate) const
 223         {
 224             const AnimationEntryList* pCompare = dynamic_cast< const AnimationEntryList* >(&rCandidate);
 225
 226             if(pCompare && mfDuration == pCompare->mfDuration)
 227             {
 228                 for(sal_uInt32 a(0L); a < maEntries.size(); a++)
 229                 {
 230                     if(!(*maEntries[a] == *pCompare->maEntries[a]))
 231                     {
 232                         return false;
 233                     }
 234                 }
 235
 236                 return true;
 237             }
 238
 239             return false;
 240         }
 241
 242         void AnimationEntryList::append(const AnimationEntry& rCandidate)
 243         {
 244             const double fDuration(rCandidate.getDuration());
 245
 246             if(!basegfx::fTools::equalZero(fDuration))
 247             {
 248                 maEntries.push_back(rCandidate.clone());
 249                 mfDuration += fDuration;
 250             }
 251         }
 252
 253         double AnimationEntryList::getDuration() const
 254         {
 255             return mfDuration;
 256         }
 257
 258         double AnimationEntryList::getStateAtTime(double fTime) const
 259         {
 260             if(!basegfx::fTools::equalZero(mfDuration))
 261             {
 262                 double fAddedTime(0.0);
 263                 const sal_uInt32 nIndex(impGetIndexAtTime(fTime, fAddedTime));
 264
 265                 if(nIndex < maEntries.size())
 266                 {
 267                     return maEntries[nIndex]->getStateAtTime(fTime - fAddedTime);
 268                 }
 269             }
 270
 271             return 0.0;
 272         }
 273
 274         double AnimationEntryList::getNextEventTime(double fTime) const
 275         {
 276             double fNewTime(0.0);
 277
 278             if(!basegfx::fTools::equalZero(mfDuration))
 279             {
 280                 double fAddedTime(0.0);
 281                 const sal_uInt32 nIndex(impGetIndexAtTime(fTime, fAddedTime));
 282
 283                 if(nIndex < maEntries.size())
 284                 {
 285                     fNewTime = maEntries[nIndex]->getNextEventTime(fTime - fAddedTime) + fAddedTime;
 286                 }
 287             }
 288
 289             return fNewTime;
 290         }
 291
 292         //////////////////////////////////////////////////////////////////////////////
 293
 294         AnimationEntryLoop::AnimationEntryLoop(sal_uInt32 nRepeat)
 295         :       AnimationEntryList(),
 296             mnRepeat(nRepeat)
 297         {
 298         }
 299
 300         AnimationEntryLoop::~AnimationEntryLoop()
 301         {
 302         }
 303
 304         AnimationEntry* AnimationEntryLoop::clone() const
 305         {
 306             AnimationEntryLoop* pNew = new AnimationEntryLoop(mnRepeat);
 307
 308             for(sal_uInt32 a(0L); a < maEntries.size(); a++)
 309             {
 310                 pNew->append(*maEntries[a]);
 311             }
 312
 313             return pNew;
 314         }
 315
 316         bool AnimationEntryLoop::operator==(const AnimationEntry& rCandidate) const
 317         {
 318             const AnimationEntryLoop* pCompare = dynamic_cast< const AnimationEntryLoop* >(&rCandidate);
 319
 320             return (pCompare
 321                 && mnRepeat == pCompare->mnRepeat
 322                 && AnimationEntryList::operator==(rCandidate));
 323         }
 324
 325         double AnimationEntryLoop::getDuration() const
 326         {
 327             return (mfDuration * (double)mnRepeat);
 328         }
 329
 330         double AnimationEntryLoop::getStateAtTime(double fTime) const
 331         {
 332             if(mnRepeat && !basegfx::fTools::equalZero(mfDuration))
 333             {
 334                 const sal_uInt32 nCurrentLoop((sal_uInt32)(fTime / mfDuration));
 335
 336                 if(nCurrentLoop > mnRepeat)
 337                 {
 338                     return 1.0;
 339                 }
 340                 else
 341                 {
 342                     const double fTimeAtLoopStart((double)nCurrentLoop * mfDuration);
 343                     const double fRelativeTime(fTime - fTimeAtLoopStart);
 344                     return AnimationEntryList::getStateAtTime(fRelativeTime);
 345                 }
 346             }
 347
 348             return 0.0;
 349         }
 350
 351         double AnimationEntryLoop::getNextEventTime(double fTime) const
 352         {
 353             double fNewTime(0.0);
 354
 355             if(mnRepeat && !basegfx::fTools::equalZero(mfDuration))
 356             {
 357                 const sal_uInt32 nCurrentLoop((sal_uInt32)(fTime / mfDuration));
 358
 359                 if(nCurrentLoop <= mnRepeat)
 360                 {
 361                     const double fTimeAtLoopStart((double)nCurrentLoop * mfDuration);
 362                     const double fRelativeTime(fTime - fTimeAtLoopStart);
 363                     const double fNextEventAtLoop(AnimationEntryList::getNextEventTime(fRelativeTime));
 364
 365                     if(!basegfx::fTools::equalZero(fNextEventAtLoop))
 366                     {
 367                         fNewTime = fNextEventAtLoop + fTimeAtLoopStart;
 368                     }
 369                 }
 370             }
 371
 372             return fNewTime;
 373         }
 374     } // end of namespace animation
 375 } // end of namespace drawinglayer
 376
 377 //////////////////////////////////////////////////////////////////////////////
 378 // eof