drawinglayer/source/animation/animationtiming.cxx

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