demos/qtdemo/demoitemanimation.cpp

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
   4 ** All rights reserved.
   5 ** Contact: Nokia Corporation (qt-info@nokia.com)
   6 **
   7 ** This file is part of the demonstration applications of the Qt Toolkit.
   8 **
   9 ** $QT_BEGIN_LICENSE:LGPL$
  10 ** No Commercial Usage
  11 ** This file contains pre-release code and may not be distributed.
  12 ** You may use this file in accordance with the terms and conditions
  13 ** contained in the Technology Preview License Agreement accompanying
  14 ** this package.
  15 **
  16 ** GNU Lesser General Public License Usage
  17 ** Alternatively, this file may be used under the terms of the GNU Lesser
  18 ** General Public License version 2.1 as published by the Free Software
  19 ** Foundation and appearing in the file LICENSE.LGPL included in the
  20 ** packaging of this file.  Please review the following information to
  21 ** ensure the GNU Lesser General Public License version 2.1 requirements
  22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  23 **
  24 ** In addition, as a special exception, Nokia gives you certain additional
  25 ** rights.  These rights are described in the Nokia Qt LGPL Exception
  26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  27 **
  28 ** If you have questions regarding the use of this file, please contact
  29 ** Nokia at qt-info@nokia.com.
  30 **
  31 **
  32 **
  33 **
  34 **
  35 **
  36 **
  37 **
  38 ** $QT_END_LICENSE$
  39 **
  40 ****************************************************************************/
  41
  42 #include "demoitemanimation.h"
  43 #include "demoitem.h"
  44 #include "colors.h"
  45
  46 DemoItemAnimation::DemoItemAnimation(DemoItem *item, INOROUT inOrOut)
  47 {
  48     this->opacityAt0 = 1.0;
  49     this->opacityAt1 = 1.0;
  50     this->startDelay = 0;
  51     this->inOrOut = inOrOut;
  52     this->hideOnFinished = false;
  53     this->forcePlay = false;
  54     this->timeline = new QTimeLine(5000);
  55     this->timeline->setFrameRange(0, 2000);
  56     this->timeline->setUpdateInterval(int(1000.0/Colors::fps));
  57     this->moveOnPlay = false;
  58     setTimeLine(this->timeline);
  59     setItem(item);
  60 }
  61
  62 DemoItemAnimation::~DemoItemAnimation()
  63 {
  64     // Do not delete demoitem. It is not
  65     // owned by an animation
  66     delete this->timeline;
  67 }
  68
  69 void DemoItemAnimation::prepare()
  70 {
  71     this->demoItem()->prepare();
  72 }
  73
  74 void DemoItemAnimation::setStartPos(const QPointF &pos){
  75     this->startPos = pos;
  76 }
  77
  78 void DemoItemAnimation::setDuration(int duration)
  79 {
  80     duration = int(duration * Colors::animSpeed);
  81     this->timeline->setDuration(duration);
  82     this->moveOnPlay = true;
  83 }
  84
  85 void DemoItemAnimation::setCurrentTime(int ms)
  86 {
  87     this->timeline->setCurrentTime(ms);
  88 }
  89
  90 bool DemoItemAnimation::notOwnerOfItem()
  91 {
  92     return this != demoItem()->currentAnimation;
  93 }
  94
  95 void DemoItemAnimation::play(bool fromStart, bool force)
  96 {
  97     this->fromStart = fromStart;
  98     this->forcePlay = force;
  99
 100     QPointF currPos = this->demoItem()->pos();
 101
 102     // If the item that this animation controls in currently under the
 103     // control of another animation, stop that animation first
 104     if (this->demoItem()->currentAnimation)
 105         this->demoItem()->currentAnimation->timeline->stop();
 106     this->demoItem()->currentAnimation = this;
 107     this->timeline->stop();
 108
 109     if (Colors::noAnimations && !this->forcePlay){
 110         this->timeline->setCurrentTime(1);
 111         this->demoItem()->setPos(this->posAt(1));
 112     }
 113     else{
 114         if (this->demoItem()->isVisible())
 115             // If the item is already visible, start the animation from
 116             // the items current position rather than from start.
 117             this->setPosAt(0.0, currPos);
 118         else
 119             this->setPosAt(0.0, this->startPos);
 120
 121         if (this->fromStart){
 122             this->timeline->setCurrentTime(0);
 123             this->demoItem()->setPos(this->posAt(0));
 124         }
 125     }
 126
 127     if (this->inOrOut == ANIM_IN)
 128         this->demoItem()->setRecursiveVisible(true);
 129
 130     if (this->startDelay){
 131         QTimer::singleShot(this->startDelay, this, SLOT(playWithoutDelay()));
 132         return;
 133     }
 134     else
 135         this->playWithoutDelay();
 136 }
 137
 138 void DemoItemAnimation::playWithoutDelay()
 139 {
 140     if (this->moveOnPlay && !(Colors::noAnimations && !this->forcePlay))
 141         this->timeline->start();
 142     this->demoItem()->animationStarted(this->inOrOut);
 143 }
 144
 145 void DemoItemAnimation::stop(bool reset)
 146 {
 147     this->timeline->stop();
 148     if (reset)
 149         this->demoItem()->setPos(this->posAt(0));
 150     if (this->hideOnFinished && !this->moveOnPlay)
 151         this->demoItem()->setRecursiveVisible(false);
 152     this->demoItem()->animationStopped(this->inOrOut);
 153 }
 154
 155 void DemoItemAnimation::setRepeat(int nr)
 156 {
 157     this->timeline->setLoopCount(nr);
 158 }
 159
 160 void DemoItemAnimation::playReverse()
 161 {
 162 }
 163
 164 bool DemoItemAnimation::running()
 165 {
 166     return (this->timeLine()->state() == QTimeLine::Running);
 167 }
 168
 169 bool DemoItemAnimation::runningOrItemLocked()
 170 {
 171     return (this->running() || this->demoItem()->locked);
 172 }
 173
 174 void DemoItemAnimation::lockItem(bool state)
 175 {
 176     this->demoItem()->locked = state;
 177 }
 178
 179 DemoItem *DemoItemAnimation::demoItem()
 180 {
 181     return (DemoItem *) this->item();
 182 }
 183
 184 void DemoItemAnimation::setOpacityAt0(qreal opacity)
 185 {
 186     this->opacityAt0 = opacity;
 187 }
 188
 189 void DemoItemAnimation::setOpacityAt1(qreal opacity)
 190 {
 191     this->opacityAt1 = opacity;
 192 }
 193
 194 void DemoItemAnimation::setOpacity(qreal step)
 195 {
 196     DemoItem *demoItem = (DemoItem *) item();
 197     demoItem->opacity = this->opacityAt0 + step * step * step * (this->opacityAt1 - this->opacityAt0);
 198 }
 199
 200 void DemoItemAnimation::afterAnimationStep(qreal step)
 201 {
 202     if (step == 1.0f){
 203         if (this->timeline->loopCount() > 0){
 204             // animation finished.
 205             if (this->hideOnFinished)
 206                 this->demoItem()->setRecursiveVisible(false);
 207             this->demoItem()->animationStopped(this->inOrOut);
 208         }
 209     } else if (Colors::noAnimations && !this->forcePlay){
 210         // The animation is not at end, but
 211         // the animations should not play, so go to end.
 212         this->setStep(1.0f); // will make this method being called recursive.
 213     }
 214 }
 215
 216
 217
 218
 219