demos/qtdemo/itemcircleanimation.cpp

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 2009 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 "itemcircleanimation.h"
  43 #include "demoitemanimation.h"
  44 #include "colors.h"
  45 #include "menumanager.h"
  46 #include "mainwindow.h"
  47 #include "menumanager.h"
  48
  49 static QGraphicsScene *sscene;
  50
  51 //////////////////// POST EFFECT STUFF ////////////////////////////////////////
  52
  53 class TickerPostEffect
  54 {
  55 public:
  56     virtual ~TickerPostEffect(){};
  57     virtual void tick(float){};
  58     virtual void transform(DemoItem *, QPointF &){};
  59 };
  60
  61 class PostRotateXY : public TickerPostEffect
  62 {
  63 public:
  64     float currRotX, currRotY;
  65     float speedx, speedy, curvx, curvy;
  66
  67     PostRotateXY(float speedx, float speedy, float curvx, float curvy)
  68         : currRotX(0), currRotY(0),
  69         speedx(speedx), speedy(speedy),
  70         curvx(curvx), curvy(curvy){};
  71
  72     void tick(float adjust)
  73     {
  74         currRotX += speedx * adjust;
  75         currRotY += speedy * adjust;
  76     }
  77
  78     void transform(DemoItem *item, QPointF &pos)
  79     {
  80         DemoItem *parent = (DemoItem *) item->parentItem();
  81         QPointF center = parent->boundingRect().center();
  82         pos.setX(center.x() + (pos.x() - center.x()) * cos(currRotX + pos.x() * curvx));
  83         pos.setY(center.y() + (pos.y() - center.y()) * cos(currRotY + pos.y() * curvy));
  84     }
  85 };
  86
  87 class PostRotateXYTwist : public TickerPostEffect
  88 {
  89 public:
  90     float currRotX, currRotY;
  91     float speedx, speedy, curvx, curvy;
  92
  93     PostRotateXYTwist(float speedx, float speedy, float curvx, float curvy)
  94         : currRotX(0), currRotY(0),
  95         speedx(speedx), speedy(speedy),
  96         curvx(curvx), curvy(curvy){};
  97
  98     void tick(float adjust)
  99     {
 100         currRotX += speedx * adjust;
 101         currRotY += speedy * adjust;
 102     }
 103
 104     void transform(DemoItem *item, QPointF &pos)
 105     {
 106         DemoItem *parent = (DemoItem *) item->parentItem();
 107         QPointF center = parent->boundingRect().center();
 108         pos.setX(center.x() + (pos.x() - center.x()) * cos(currRotX + pos.y() * curvx));
 109         pos.setY(center.y() + (pos.y() - center.y()) * cos(currRotY + pos.x() * curvy));
 110     }
 111 };
 112
 113 //////////////////// TICKER EFFECT STUFF //////////////////////////////////////
 114
 115 class TickerEffect
 116 {
 117     TickerPostEffect *postEffect;
 118 public:
 119     enum EffectStatus{Normal, Intro, Outro} status;
 120     LetterList *letters;
 121     float morphSpeed, moveSpeed;
 122     float normalMorphSpeed, normalMoveSpeed;
 123     bool useSheepDog, morphBetweenModels;
 124
 125     TickerEffect(LetterList *letters)
 126         : postEffect(new TickerPostEffect()), status(Intro), letters(letters),
 127         morphSpeed(Colors::tickerMorphSpeed), moveSpeed(Colors::tickerMoveSpeed),
 128         normalMorphSpeed(Colors::tickerMorphSpeed), normalMoveSpeed(Colors::tickerMoveSpeed),
 129         useSheepDog(true), morphBetweenModels(!Colors::noTickerMorph){}
 130
 131     void setPostEffect(TickerPostEffect *effect)
 132     {
 133         delete postEffect;
 134         postEffect = effect;
 135     }
 136
 137     virtual ~TickerEffect()
 138     {
 139         delete postEffect;
 140     }
 141
 142     void slowDownAfterIntro(float adjust)
 143     {
 144         if (morphBetweenModels){
 145             if (status == Intro){
 146                 float dec = 0.1 * adjust;
 147                 moveSpeed -= dec;
 148                 if (moveSpeed < Colors::tickerMoveSpeed){
 149                     moveSpeed = normalMoveSpeed;
 150                     morphSpeed = normalMorphSpeed;
 151                     status = Normal;
 152                 }
 153             }
 154         }
 155     }
 156
 157     void moveLetters(float adjust)
 158     {
 159         float adaptedMoveSpeed = this->moveSpeed * adjust;
 160         float adaptedMorphSpeed = this->morphSpeed * adjust;
 161         postEffect->tick(adjust);
 162
 163         for (int i=0; i<letters->size(); i++){
 164             LetterItem *letter = letters->at(i);
 165             letter->guideAdvance(this->morphBetweenModels ? adaptedMoveSpeed : Colors::tickerMoveSpeed);
 166             letter->guideMove(this->morphBetweenModels ? adaptedMorphSpeed : -1);
 167
 168             QPointF pos = letter->getGuidedPos();
 169             postEffect->transform(letter, pos);
 170
 171             if (useSheepDog)
 172                 letter->setPosUsingSheepDog(pos, QRectF(0, 0, 800, 600));
 173             else
 174                 letter->setPos(pos);
 175         }
 176     }
 177
 178     virtual void tick(float adjust)
 179     {
 180         slowDownAfterIntro(adjust);
 181         moveLetters(adjust);
 182     }
 183
 184 };
 185
 186 class EffectWhirlWind : public TickerEffect
 187 {
 188 public:
 189     EffectWhirlWind(LetterList *letters) : TickerEffect(letters)
 190     {
 191         moveSpeed = 50;
 192         for (int i=0; i<this->letters->size(); i++){
 193             LetterItem *letter = this->letters->at(i);
 194             letter->setGuidedPos(QPointF(0, 100));
 195         }
 196     }
 197 };
 198
 199 class EffectSnake : public TickerEffect
 200 {
 201 public:
 202     EffectSnake(LetterList *letters) : TickerEffect(letters)
 203     {
 204         moveSpeed = 40;
 205         for (int i=0; i<this->letters->size(); i++){
 206             LetterItem *letter = this->letters->at(i);
 207             letter->setGuidedPos(QPointF(0, -250 - (i * 5)));
 208         }
 209     }
 210 };
 211
 212 class EffectScan : public TickerEffect
 213 {
 214 public:
 215     EffectScan(LetterList *letters) : TickerEffect(letters)
 216     {
 217         for (int i=0; i<this->letters->size(); i++){
 218             LetterItem *letter = this->letters->at(i);
 219             letter->setGuidedPos(QPointF(100, -300));
 220         }
 221     }
 222 };
 223
 224 class EffectRaindrops : public TickerEffect
 225 {
 226 public:
 227     EffectRaindrops(LetterList *letters) : TickerEffect(letters)
 228     {
 229         for (int i=0; i<this->letters->size(); i++){
 230             LetterItem *letter = this->letters->at(i);
 231             letter->setGuidedPos(QPointF(-100 + rand() % 200, - 200.0f - rand() % 1300));
 232         }
 233     }
 234 };
 235
 236 class EffectLine : public TickerEffect
 237 {
 238 public:
 239     EffectLine(LetterList *letters) : TickerEffect(letters)
 240     {
 241         for (int i=0; i<this->letters->size(); i++){
 242             LetterItem *letter = this->letters->at(i);
 243             letter->setGuidedPos(QPointF(100, 500.0f + i * 20));
 244         }
 245     }
 246 };
 247
 248 //////////////////// TICKER STUFF /////////////////////////////////////////////
 249
 250 ItemCircleAnimation::ItemCircleAnimation(QGraphicsScene *scene, QGraphicsItem *parent)
 251     : DemoItem(scene, parent)
 252 {
 253     sscene = scene;
 254     this->letterCount = Colors::tickerLetterCount;
 255     this->scale = 1;
 256     this->showCount = -1;
 257     this->tickOnPaint = false;
 258     this->paused = false;
 259     this->doIntroTransitions = true;
 260     this->setAcceptsHoverEvents(true);
 261     this->setCursor(Qt::OpenHandCursor);
 262     this->setupGuides();
 263     this->setupLetters();
 264     this->useGuideQt();
 265     this->effect = 0;//new TickerEffect(this->letterList);
 266 }
 267
 268 ItemCircleAnimation::~ItemCircleAnimation()
 269 {
 270     delete this->letterList;
 271     delete this->qtGuide1;
 272     delete this->qtGuide2;
 273     delete this->qtGuide3;
 274     delete this->effect;
 275 }
 276
 277 void ItemCircleAnimation::createLetter(char c)
 278 {
 279     LetterItem *letter = new LetterItem(c, sscene, this);
 280     this->letterList->append(letter);
 281 }
 282
 283 void ItemCircleAnimation::setupLetters()
 284 {
 285     this->letterList = new LetterList();
 286
 287     QString s = Colors::tickerText;
 288     int len = s.length();
 289     int i = 0;
 290     for (; i < this->letterCount - len; i += len)
 291         for (int l=0; l<len; l++)
 292             createLetter(s[l].toLatin1());
 293
 294     // Fill inn with blanks:
 295     for (; i < this->letterCount; ++i)
 296         createLetter(' ');
 297 }
 298
 299 void ItemCircleAnimation::setupGuides()
 300 {
 301     int x = 0;
 302     int y = 20;
 303
 304     this->qtGuide1 = new GuideCircle(QRectF(x, y, 260, 260), -36, 342);
 305     new GuideLine(QPointF(x + 240, y + 268), this->qtGuide1);
 306     new GuideLine(QPointF(x + 265, y + 246), this->qtGuide1);
 307     new GuideLine(QPointF(x + 158, y + 134), this->qtGuide1);
 308     new GuideLine(QPointF(x + 184, y + 109), this->qtGuide1);
 309     new GuideLine(QPointF(x + 160, y +  82), this->qtGuide1);
 310     new GuideLine(QPointF(x +  77, y + 163), this->qtGuide1); // T-top
 311     new GuideLine(QPointF(x + 100, y + 190), this->qtGuide1);
 312     new GuideLine(QPointF(x + 132, y + 159), this->qtGuide1);
 313     new GuideLine(QPointF(x + 188, y + 211), this->qtGuide1);
 314     new GuideCircle(QRectF(x + 30, y + 30, 200, 200), -30, 336, GuideCircle::CW, this->qtGuide1);
 315     new GuideLine(QPointF(x + 238, y + 201), this->qtGuide1);
 316
 317     y = 30;
 318     this->qtGuide2 = new GuideCircle(QRectF(x + 30, y + 30, 200, 200), 135, 270, GuideCircle::CCW);
 319     new GuideLine(QPointF(x + 222, y + 38), this->qtGuide2);
 320     new GuideCircle(QRectF(x, y, 260, 260), 135, 270, GuideCircle::CW, this->qtGuide2);
 321     new GuideLine(QPointF(x + 59, y + 59), this->qtGuide2);
 322
 323     x = 115;
 324     y = 10;
 325     this->qtGuide3 = new GuideLine(QLineF(x, y, x + 30, y));
 326     new GuideLine(QPointF(x + 30, y + 170), this->qtGuide3);
 327     new GuideLine(QPointF(x, y + 170), this->qtGuide3);
 328     new GuideLine(QPointF(x, y), this->qtGuide3);
 329
 330     this->qtGuide1->setFence(QRectF(0, 0, 800, 600));
 331     this->qtGuide2->setFence(QRectF(0, 0, 800, 600));
 332     this->qtGuide3->setFence(QRectF(0, 0, 800, 600));
 333 }
 334
 335 void ItemCircleAnimation::useGuide(Guide *guide, int firstLetter, int lastLetter)
 336 {
 337     float padding = guide->lengthAll() / float(lastLetter - firstLetter);
 338     for (int i=firstLetter; i<lastLetter; i++){
 339         LetterItem *letter = this->letterList->at(i);
 340         letter->useGuide(guide, (i - firstLetter) * padding);
 341     }
 342 }
 343
 344 void ItemCircleAnimation::useGuideQt()
 345 {
 346     if (this->currGuide != this->qtGuide1){
 347         this->useGuide(qtGuide1, 0, this->letterCount);
 348         this->currGuide = qtGuide1;
 349     }
 350 }
 351
 352 void ItemCircleAnimation::useGuideTt()
 353 {
 354     if (this->currGuide != this->qtGuide2){
 355         int split = int(this->letterCount * 5.0 / 7.0);
 356         this->useGuide(qtGuide2, 0, split);
 357         this->useGuide(qtGuide3, split, this->letterCount);
 358         this->currGuide = qtGuide2;
 359     }
 360 }
 361
 362 QRectF ItemCircleAnimation::boundingRect() const
 363 {
 364     return QRectF(0, 0, 300, 320);
 365 }
 366
 367 void ItemCircleAnimation::prepare()
 368 {
 369 }
 370
 371 void ItemCircleAnimation::switchToNextEffect()
 372 {
 373     ++this->showCount;
 374     delete this->effect;
 375
 376     switch (this->showCount){
 377     case 1:
 378         this->effect = new EffectSnake(this->letterList);
 379         break;
 380     case 2:
 381         this->effect = new EffectLine(this->letterList);
 382         this->effect->setPostEffect(new PostRotateXYTwist(0.01f, 0.0f, 0.003f, 0.0f));
 383         break;
 384     case 3:
 385         this->effect = new EffectRaindrops(this->letterList);
 386         this->effect->setPostEffect(new PostRotateXYTwist(0.01f, 0.005f, 0.003f, 0.003f));
 387         break;
 388     case 4:
 389         this->effect = new EffectScan(this->letterList);
 390         this->effect->normalMoveSpeed = 0;
 391         this->effect->setPostEffect(new PostRotateXY(0.008f, 0.0f, 0.005f, 0.0f));
 392         break;
 393     default:
 394         this->showCount = 0;
 395         this->effect = new EffectWhirlWind(this->letterList);
 396     }
 397 }
 398
 399 void ItemCircleAnimation::animationStarted(int id)
 400 {
 401     if (id == DemoItemAnimation::ANIM_IN){
 402         if (this->doIntroTransitions){
 403             // Make all letters dissapear
 404             for (int i=0; i<this->letterList->size(); i++){
 405                 LetterItem *letter = this->letterList->at(i);
 406                 letter->setPos(1000, 0);
 407             }
 408             this->switchToNextEffect();
 409             this->useGuideQt();
 410             this->scale = 1;
 411             // The first time we run, we have a rather large
 412             // delay to perform benchmark before the ticker shows.
 413             // But now, since we are showing, use a more appropriate value:
 414             this->currentAnimation->startDelay = 1500;
 415         }
 416     }
 417     else if (this->effect)
 418         this->effect->useSheepDog = false;
 419
 420     this->tickTimer = QTime::currentTime();
 421 }
 422
 423 void ItemCircleAnimation::animationStopped(int)
 424 {
 425     // Nothing to do.
 426 }
 427
 428 void ItemCircleAnimation::swapModel(){
 429     if (this->currGuide == this->qtGuide2)
 430         this->useGuideQt();
 431     else
 432         this->useGuideTt();
 433 }
 434
 435 void ItemCircleAnimation::hoverEnterEvent(QGraphicsSceneHoverEvent *)
 436 {
 437 //  Skip swap here to enhance ticker dragging
 438 //    this->swapModel();
 439 }
 440
 441 void ItemCircleAnimation::hoverLeaveEvent(QGraphicsSceneHoverEvent *)
 442 {
 443     this->swapModel();
 444 }
 445
 446 void ItemCircleAnimation::setTickerScale(float s)
 447 {
 448     this->scale = s;
 449     qtGuide1->setScale(this->scale, this->scale);
 450     qtGuide2->setScale(this->scale, this->scale);
 451     qtGuide3->setScale(this->scale, this->scale);
 452 }
 453
 454 void ItemCircleAnimation::mousePressEvent(QGraphicsSceneMouseEvent *event)
 455 {
 456     this->mouseMoveLastPosition = event->scenePos();
 457     if (event->button() == Qt::LeftButton)
 458         this->setCursor(Qt::ClosedHandCursor);
 459     else
 460         this->switchToNextEffect();
 461 }
 462
 463 void ItemCircleAnimation::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
 464 {
 465     if (event->button() == Qt::LeftButton)
 466         this->setCursor(Qt::OpenHandCursor);
 467 }
 468
 469 void ItemCircleAnimation::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
 470 {
 471     QPointF newPosition = event->scenePos();
 472     this->setPosUsingSheepDog(this->pos() + newPosition - this->mouseMoveLastPosition, QRectF(-260, -280, 1350, 1160));
 473     this->mouseMoveLastPosition = newPosition;
 474 }
 475
 476 void ItemCircleAnimation::wheelEvent(QGraphicsSceneWheelEvent *event)
 477 {
 478     this->effect->moveSpeed = this->effect->moveSpeed + (event->delta() > 0 ? -0.20 : 0.20);
 479     if (this->effect->moveSpeed < 0)
 480         this->effect->moveSpeed = 0;
 481 }
 482
 483 void ItemCircleAnimation::pause(bool on)
 484 {
 485     this->paused = on;
 486     this->tickTimer = QTime::currentTime();
 487 }
 488
 489 void ItemCircleAnimation::tick()
 490 {
 491     if (this->paused || !this->effect)
 492         return;
 493
 494     float t = this->tickTimer.msecsTo(QTime::currentTime());
 495     this->tickTimer = QTime::currentTime();
 496     this->effect->tick(t/10.0f);
 497 }
 498
 499 void ItemCircleAnimation::paint(QPainter *, const QStyleOptionGraphicsItem *, QWidget *)
 500 {
 501     if (this->tickOnPaint)
 502         tick();
 503 }
 504
 505
 506
 507