| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_drawinglayer.hxx" |
| |
| #include <drawinglayer/animation/animationtiming.hxx> |
| #include <basegfx/numeric/ftools.hxx> |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| |
| namespace drawinglayer |
| { |
| namespace animation |
| { |
| ////////////////////////////////////////////////////////////////////////////// |
| |
| AnimationEntry::AnimationEntry() |
| { |
| } |
| |
| AnimationEntry::~AnimationEntry() |
| { |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| |
| AnimationEntryFixed::AnimationEntryFixed(double fDuration, double fState) |
| : mfDuration(fDuration), |
| mfState(fState) |
| { |
| } |
| |
| AnimationEntryFixed::~AnimationEntryFixed() |
| { |
| } |
| |
| AnimationEntry* AnimationEntryFixed::clone() const |
| { |
| return new AnimationEntryFixed(mfDuration, mfState); |
| } |
| |
| bool AnimationEntryFixed::operator==(const AnimationEntry& rCandidate) const |
| { |
| const AnimationEntryFixed* pCompare = dynamic_cast< const AnimationEntryFixed* >(&rCandidate); |
| |
| return (pCompare |
| && basegfx::fTools::equal(mfDuration, pCompare->mfDuration) |
| && basegfx::fTools::equal(mfState, pCompare->mfState)); |
| } |
| |
| double AnimationEntryFixed::getDuration() const |
| { |
| return mfDuration; |
| } |
| |
| double AnimationEntryFixed::getStateAtTime(double /*fTime*/) const |
| { |
| return mfState; |
| } |
| |
| double AnimationEntryFixed::getNextEventTime(double fTime) const |
| { |
| if(basegfx::fTools::less(fTime, mfDuration)) |
| { |
| return mfDuration; |
| } |
| else |
| { |
| return 0.0; |
| } |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| |
| AnimationEntryLinear::AnimationEntryLinear(double fDuration, double fFrequency, double fStart, double fStop) |
| : mfDuration(fDuration), |
| mfFrequency(fFrequency), |
| mfStart(fStart), |
| mfStop(fStop) |
| { |
| } |
| |
| AnimationEntryLinear::~AnimationEntryLinear() |
| { |
| } |
| |
| AnimationEntry* AnimationEntryLinear::clone() const |
| { |
| return new AnimationEntryLinear(mfDuration, mfFrequency, mfStart, mfStop); |
| } |
| |
| bool AnimationEntryLinear::operator==(const AnimationEntry& rCandidate) const |
| { |
| const AnimationEntryLinear* pCompare = dynamic_cast< const AnimationEntryLinear* >(&rCandidate); |
| |
| return (pCompare |
| && basegfx::fTools::equal(mfDuration, pCompare->mfDuration) |
| && basegfx::fTools::equal(mfStart, pCompare->mfStart) |
| && basegfx::fTools::equal(mfStop, pCompare->mfStop)); |
| } |
| |
| double AnimationEntryLinear::getDuration() const |
| { |
| return mfDuration; |
| } |
| |
| double AnimationEntryLinear::getStateAtTime(double fTime) const |
| { |
| if(basegfx::fTools::more(mfDuration, 0.0)) |
| { |
| const double fFactor(fTime / mfDuration); |
| |
| if(fFactor > 1.0) |
| { |
| return mfStop; |
| } |
| else |
| { |
| return mfStart + ((mfStop - mfStart) * fFactor); |
| } |
| } |
| else |
| { |
| return mfStart; |
| } |
| } |
| |
| double AnimationEntryLinear::getNextEventTime(double fTime) const |
| { |
| if(basegfx::fTools::less(fTime, mfDuration)) |
| { |
| // use the simple solution: just add the frequency. More correct (but also more |
| // complicated) would be to calculate the slice of time we are in and when this |
| // slice will end. For the animations, this makes no quality difference. |
| fTime += mfFrequency; |
| |
| if(basegfx::fTools::more(fTime, mfDuration)) |
| { |
| fTime = mfDuration; |
| } |
| |
| return fTime; |
| } |
| else |
| { |
| return 0.0; |
| } |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| |
| sal_uInt32 AnimationEntryList::impGetIndexAtTime(double fTime, double &rfAddedTime) const |
| { |
| sal_uInt32 nIndex(0L); |
| |
| while(nIndex < maEntries.size() && basegfx::fTools::lessOrEqual(rfAddedTime + maEntries[nIndex]->getDuration(), fTime)) |
| { |
| rfAddedTime += maEntries[nIndex++]->getDuration(); |
| } |
| |
| return nIndex; |
| } |
| |
| AnimationEntryList::AnimationEntryList() |
| : mfDuration(0.0) |
| { |
| } |
| |
| AnimationEntryList::~AnimationEntryList() |
| { |
| for(sal_uInt32 a(0L); a < maEntries.size(); a++) |
| { |
| delete maEntries[a]; |
| } |
| } |
| |
| AnimationEntry* AnimationEntryList::clone() const |
| { |
| AnimationEntryList* pNew = new AnimationEntryList(); |
| |
| for(sal_uInt32 a(0L); a < maEntries.size(); a++) |
| { |
| pNew->append(*maEntries[a]); |
| } |
| |
| return pNew; |
| } |
| |
| bool AnimationEntryList::operator==(const AnimationEntry& rCandidate) const |
| { |
| const AnimationEntryList* pCompare = dynamic_cast< const AnimationEntryList* >(&rCandidate); |
| |
| if(pCompare && mfDuration == pCompare->mfDuration) |
| { |
| for(sal_uInt32 a(0L); a < maEntries.size(); a++) |
| { |
| if(!(*maEntries[a] == *pCompare->maEntries[a])) |
| { |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| |
| return false; |
| } |
| |
| void AnimationEntryList::append(const AnimationEntry& rCandidate) |
| { |
| const double fDuration(rCandidate.getDuration()); |
| |
| if(!basegfx::fTools::equalZero(fDuration)) |
| { |
| maEntries.push_back(rCandidate.clone()); |
| mfDuration += fDuration; |
| } |
| } |
| |
| double AnimationEntryList::getDuration() const |
| { |
| return mfDuration; |
| } |
| |
| double AnimationEntryList::getStateAtTime(double fTime) const |
| { |
| if(!basegfx::fTools::equalZero(mfDuration)) |
| { |
| double fAddedTime(0.0); |
| const sal_uInt32 nIndex(impGetIndexAtTime(fTime, fAddedTime)); |
| |
| if(nIndex < maEntries.size()) |
| { |
| return maEntries[nIndex]->getStateAtTime(fTime - fAddedTime); |
| } |
| } |
| |
| return 0.0; |
| } |
| |
| double AnimationEntryList::getNextEventTime(double fTime) const |
| { |
| double fNewTime(0.0); |
| |
| if(!basegfx::fTools::equalZero(mfDuration)) |
| { |
| double fAddedTime(0.0); |
| const sal_uInt32 nIndex(impGetIndexAtTime(fTime, fAddedTime)); |
| |
| if(nIndex < maEntries.size()) |
| { |
| fNewTime = maEntries[nIndex]->getNextEventTime(fTime - fAddedTime) + fAddedTime; |
| } |
| } |
| |
| return fNewTime; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| |
| AnimationEntryLoop::AnimationEntryLoop(sal_uInt32 nRepeat) |
| : AnimationEntryList(), |
| mnRepeat(nRepeat) |
| { |
| } |
| |
| AnimationEntryLoop::~AnimationEntryLoop() |
| { |
| } |
| |
| AnimationEntry* AnimationEntryLoop::clone() const |
| { |
| AnimationEntryLoop* pNew = new AnimationEntryLoop(mnRepeat); |
| |
| for(sal_uInt32 a(0L); a < maEntries.size(); a++) |
| { |
| pNew->append(*maEntries[a]); |
| } |
| |
| return pNew; |
| } |
| |
| bool AnimationEntryLoop::operator==(const AnimationEntry& rCandidate) const |
| { |
| const AnimationEntryLoop* pCompare = dynamic_cast< const AnimationEntryLoop* >(&rCandidate); |
| |
| return (pCompare |
| && mnRepeat == pCompare->mnRepeat |
| && AnimationEntryList::operator==(rCandidate)); |
| } |
| |
| double AnimationEntryLoop::getDuration() const |
| { |
| return (mfDuration * (double)mnRepeat); |
| } |
| |
| double AnimationEntryLoop::getStateAtTime(double fTime) const |
| { |
| if(mnRepeat && !basegfx::fTools::equalZero(mfDuration)) |
| { |
| const sal_uInt32 nCurrentLoop((sal_uInt32)(fTime / mfDuration)); |
| |
| if(nCurrentLoop > mnRepeat) |
| { |
| return 1.0; |
| } |
| else |
| { |
| const double fTimeAtLoopStart((double)nCurrentLoop * mfDuration); |
| const double fRelativeTime(fTime - fTimeAtLoopStart); |
| return AnimationEntryList::getStateAtTime(fRelativeTime); |
| } |
| } |
| |
| return 0.0; |
| } |
| |
| double AnimationEntryLoop::getNextEventTime(double fTime) const |
| { |
| double fNewTime(0.0); |
| |
| if(mnRepeat && !basegfx::fTools::equalZero(mfDuration)) |
| { |
| const sal_uInt32 nCurrentLoop((sal_uInt32)(fTime / mfDuration)); |
| |
| if(nCurrentLoop <= mnRepeat) |
| { |
| const double fTimeAtLoopStart((double)nCurrentLoop * mfDuration); |
| const double fRelativeTime(fTime - fTimeAtLoopStart); |
| const double fNextEventAtLoop(AnimationEntryList::getNextEventTime(fRelativeTime)); |
| |
| if(!basegfx::fTools::equalZero(fNextEventAtLoop)) |
| { |
| fNewTime = fNextEventAtLoop + fTimeAtLoopStart; |
| } |
| } |
| } |
| |
| return fNewTime; |
| } |
| } // end of namespace animation |
| } // end of namespace drawinglayer |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| // eof |
