FCL/sf/mw/hb: comparison src/hbcore/image/hbiconanimation.cpp

equal deleted inserted replaced

-:7516d6d86cf5
+:ed14f46c0e55
 void HbIconAnimation::setRenderSize(const QSizeF &size)
 {
 mRenderSize = size;
 }
+void HbIconAnimation::setLoopCount(int loopCount)
+{
+Q_UNUSED(loopCount);
+// Nothing to do here, some subclasses may want to reimplement this in case
+// they want to offer support to the user for manually controlling the loop
+// behavior.
+}
+bool HbIconAnimation::loopCountSet(int *loopCount)
+{
+Q_UNUSED(loopCount);
+return false;
+}
 bool HbIconAnimation::mirrored() const
 {
 return mMirrored;
 }
 return mPlayMode;
 }
 void HbIconAnimation::setPlayMode(HbIconAnimationDefinition::PlayMode playMode)
 {
-this->mPlayMode = playMode;
+mPlayMode = playMode;
 }
 void HbIconAnimation::delayedEmitStarted()
 {
 if (!mStartSignalTimer) {
 HbIconAnimation(animator, iconName),
 mImageRenderer(renderer),
 mIconFileName(iconFileName),
 mType(type),
-mTimerEntry(0)
+mTimerEntry(0),
+mDoNotResetLoopCount(false)
 {
 // This class supports these types
 Q_ASSERT(mType == MNG || mType == GIF);
 // Read the first frame. QImageReader::read() must be called before
 // Store the first frame in the current frame pixmap
 mCurrentFrame = QPixmap::fromImage(img);
 // Set default size based on the first frame
 setDefaultSize(mCurrentFrame.size());
+// Get the loop count. -1 means infinite loop.
+mLoopCount = mImageRenderer->loopCount();
+mCustomLoopCountSet = false;
 // Do not start the timer or initiate any signal emission here.
 // Do it in start() instead, since mFresh is true by default.
 }
 // Recreate the image reader. It's slow but QImageReader::jumpToImage does not work.
 delete mImageRenderer;
 mImageRenderer = 0;
 mImageRenderer = new QImageReader(mIconFileName, mType == MNG ? "MNG" : "GIF");
+if (mDoNotResetLoopCount) {
+mDoNotResetLoopCount = false;
+} else {
+// Reset the loop count.
+if (mCustomLoopCountSet) {
+mLoopCount = mCustomLoopCount;
+} else {
+mLoopCount = mImageRenderer->loopCount();
+}
+}
 // New image reader starts from the first frame. Handle animation update.
 notifyAnimationStarted();
 handleAnimationUpdated();
 }
 }
 // QImageReader::jumpToImage does not work so cannot jump to the last frame if it has not been read yet.
 while (true) {
 QImage img = mImageRenderer->read();
 // Reached last frame?
 if (!mImageRenderer->canRead()) {
+// Must get rid of the old pixmap first, in case of very large frames
+// keeping both the old and new frame in memory would not succeed.
+mCurrentFrame = QPixmap(); // This call is not superfluous.
 mCurrentFrame = QPixmap::fromImage(img);
 mLastFrame = mCurrentFrame;
 break;
 }
 }
 #endif
 return QPixmap();
 }
 }
+void HbIconAnimationImage::setLoopCount(int loopCount)
+{
+// By default we use whatever value QImageReader::loopCount() returned.
+// However we also offer the possibility to override it manually at any
+// time.
+mLoopCount = mCustomLoopCount = loopCount;
+mCustomLoopCountSet = true;
+}
+bool HbIconAnimationImage::loopCountSet(int *loopCount)
+{
+if (loopCount && mCustomLoopCountSet) {
+*loopCount = mCustomLoopCount;
+}
+return mCustomLoopCountSet;
+}
 void HbIconAnimationImage::handleAnimationUpdated()
 {
 bool finished = false;
 // Read the new frame. QImageReader::read() must be called before
 mTimerEntry = HbTimer::instance()->addTimeout(mTimerInterval, this, SLOT(handleAnimationUpdated()));
 }
 // Store the new frame in the current frame pixmap
 if (!img.isNull()) {
+// Must get rid of the old pixmap first, in case of very large frames
+// keeping both the old and new frame in memory would not succeed.
+// (with the OpenVG paint engine QPixmap will create a new QImage if
+// the pixel format is different and it will be different here...)
+mCurrentFrame = QPixmap(); // This call is not superfluous.
 mCurrentFrame = QPixmap::fromImage(img);
 }
 // Reached the last frame. Store it so it can be used by stop().
 else {
 mLastFrame = mCurrentFrame;
 // Inform client
 emit animationUpdated();
 if (finished) {
-notifyAnimationFinished();
+if (mLoopCount == 0) {
+notifyAnimationFinished();
+} else {
+finished = false;
+if (mLoopCount > 0) {
+--mLoopCount;
+}
+mDoNotResetLoopCount = true;
+start();
+}
 }
 }
 HbIconAnimationFrameSet::HbIconAnimationFrameSet(
 HbIconAnimator *animator, const QString &iconName, const QList<FrameData> &frames) :
 HbIconAnimation(animator, iconName),
 mFrames(frames),
 mCurrentFrameIndex(0),
-mTimerEntry(0)
+mTimerEntry(0),
+mManualLoopingSet(false),
+mManualLooping(false)
 {
 // Do not start the timer or initiate any signal emission here.
 // Do it in start() instead, since mFresh is true by default.
 }
 return pm;
 } else {
 return QPixmap();
 }
+}
+void HbIconAnimationFrameSet::setLoopCount(int loopCount)
+{
+// Here we only support manually enabling/disabling infinite looping.
+// (so effectively loop count should be -1 or 0) Positive values are
+// treated as do-not-loop, i.e. zero. This is because explicit loop
+// counts are not supported by axml.
+mManualLoopingSet = true;
+mManualLooping = loopCount < 0; // -1 means loop for ever
+}
+bool HbIconAnimationFrameSet::loopCountSet(int *loopCount)
+{
+if (loopCount && mManualLoopingSet) {
+*loopCount = mManualLooping ? -1 : 0;
+}
+return mManualLoopingSet;
 }
 void HbIconAnimationFrameSet::moveToNextFrame()
 {
 if (mCurrentFrameIndex >= 0 && mCurrentFrameIndex < mFrames.count()) {
 // Go back to the beginning if indexing goes beyond frame count
 // and looping is enabled. Change to the last valid frame and
 // finish if looping is disabled.
 if (mCurrentFrameIndex >= mFrames.count()) {
-if (playMode() == HbIconAnimationDefinition::Loop) {
+bool looping = playMode() == HbIconAnimationDefinition::Loop;
+if (mManualLoopingSet) {
+looping = mManualLooping;
+}
+if (looping) {
 mCurrentFrameIndex = 0;
 } else {
 finished = true;
 mCurrentFrameIndex = mFrames.count() - 1;
 }

changeset 34	ed14f46c0e55
parent 5	627c4a0fd0e7