1 /*

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:

    15 *

    16 */

    17 

    18 // System includes

    19 #include <QTimer>

    20 #include <QTimeLine>

    21 #include <HbLabel>

    22 

    23 // User includes

    24 #include "radiocarouselanimator.h"

    25 #include "radiostationcarousel.h"

    26 #include "radiocarouselitem.h"

    27 #include "radiostation.h"

    28 #include "radiostationmodel.h"

    29 #include "radiologger.h"

    30 

    31 // Constants

    32 const int FREQUENCY_SCROLL_DIVIDER = 100000;

    33 const int NUMBER_SCROLL_TIMELINE_DURATION = 1000;

    34 const int FLASH_TIMER_INTERVAL = 400;

    35 const qreal FLASHING_ITEM_DIM_OPACITY = 0.3;

    36 const qreal FLASHING_ITEM_NORMAL_OPACITY = 1.0;

    37 

    38 /*!

    39  *

    40  */

    41 RadioCarouselAnimator::RadioCarouselAnimator( RadioStationCarousel& carousel ) :

    42     mCarousel( carousel ),

    43     mAnimationTimeLine( new QTimeLine( NUMBER_SCROLL_TIMELINE_DURATION, this ) ),

    44     mTimer( new QTimer( this ) ),

    45     mCanceled( false ),

    46     mMode( NoAnimation ),

    47     mStationIsFavorite( false ),

    48     mFlashingToggle( false )

    49 {

    50     mAnimationTimeLine->setCurveShape( QTimeLine::EaseInCurve );

    51     Radio::connect( mAnimationTimeLine, SIGNAL(finished()),

    52                     this,               SLOT(finalizeNumberScroll()) );

    53     Radio::connect( mAnimationTimeLine, SIGNAL(frameChanged(int)),

    54                     this,               SLOT(updateNumberScroll(int)) );

    55 

    56     mTimer->setInterval( FLASH_TIMER_INTERVAL );

    57     mTimer->setSingleShot( false );

    58     Radio::connect( mTimer,     SIGNAL(timeout()),

    59                     this,       SLOT(handleTimeout()) );

    60 }

    61 

    62 /*!

    63  *

    64  */

    65 RadioCarouselAnimator::~RadioCarouselAnimator()

    66 {

    67     stopAll();

    68 }

    69 

    70 /*!

    71  *

    72  */

    73 void RadioCarouselAnimator::startNumberScroll( const uint startFrequency, const uint stopFrequency )

    74 {

    75     addMode( ScrollingNumbers );

    76 

    77     //TODO: Take italy case into account

    78     mAnimationTimeLine->setDuration( NUMBER_SCROLL_TIMELINE_DURATION );

    79     mAnimationTimeLine->setFrameRange( startFrequency / FREQUENCY_SCROLL_DIVIDER,

    80                                        stopFrequency / FREQUENCY_SCROLL_DIVIDER );

    81     mAnimationTimeLine->start();

    82 

    83     mCarousel.scrollContentsTo( QPointF( -mCarousel.mMaxScrollPos, 0 ), mCarousel.mAutoScrollTime );

    84 }

    85 

    86 /*!

    87  *

    88  */

    89 void RadioCarouselAnimator::startFlashingIcon()

    90 {

    91     const uint frequency = mCarousel.mItems[RadioStationCarousel::CenterItem]->frequency();

    92     RadioStation station;

    93     mCarousel.mModel->findFrequency( frequency, station );

    94     mStationIsFavorite = station.isFavorite();

    95 

    96     mCarousel.mItems[RadioStationCarousel::CenterItem]->setIconOpacity( FLASHING_ITEM_DIM_OPACITY );

    97 

    98     addMode( FlashingIcon );

    99 }

   100 

   101 /*!

   102  *

   103  */

   104 void RadioCarouselAnimator::stopFlashingIcon()

   105 {

   106     mCarousel.mItems[RadioStationCarousel::CenterItem]->setIconOpacity( FLASHING_ITEM_NORMAL_OPACITY );

   107     removeMode( FlashingIcon );

   108 }

   109 

   110 /*!

   111  *

   112  */

   113 void RadioCarouselAnimator::startFlashingText()

   114 {

   115     mCarousel.mInfoText->setOpacity( FLASHING_ITEM_DIM_OPACITY );

   116     addMode( FlashingText );

   117 }

   118 

   119 /*!

   120  *

   121  */

   122 void RadioCarouselAnimator::stopFlashingText()

   123 {

   124     mCarousel.mInfoText->setOpacity( FLASHING_ITEM_NORMAL_OPACITY );

   125     removeMode( FlashingText );

   126 }

   127 

   128 /*!

   129  *

   130  */

   131 void RadioCarouselAnimator::stopAll()

   132 {

   133     mCanceled = true;

   134     mAnimationTimeLine->stop();

   135     mTimer->stop();

   136 

   137     stopFlashingText();

   138     stopFlashingIcon();

   139 

   140     mMode = NoAnimation;

   141     deleteLater();

   142 }

   143 

   144 /*!

   145  * Private slot

   146  *

   147  */

   148 void RadioCarouselAnimator::handleTimeout()

   149 {

   150     mFlashingToggle = !mFlashingToggle;

   151     if ( mMode.testFlag( IconItem ) ) {

   152         if ( mFlashingToggle ) {

   153             mCarousel.mItems[RadioStationCarousel::CenterItem]->setIconOpacity( FLASHING_ITEM_NORMAL_OPACITY );

   154         } else {

   155             mCarousel.mItems[RadioStationCarousel::CenterItem]->setIconOpacity( FLASHING_ITEM_DIM_OPACITY );

   156         }

   157     }

   158 

   159     if ( mMode.testFlag( TextItem ) ) {

   160         if ( mFlashingToggle ) {

   161             mCarousel.mInfoText->setOpacity( FLASHING_ITEM_NORMAL_OPACITY );

   162         } else {

   163             mCarousel.mInfoText->setOpacity( FLASHING_ITEM_DIM_OPACITY );

   164         }

   165     }

   166 }

   167 

   168 /*!

   169  * Private slot

   170  *

   171  */

   172 void RadioCarouselAnimator::updateNumberScroll( int value )

   173 {

   174     mCarousel.mItems[RadioStationCarousel::RightItem]->setFrequency( value * FREQUENCY_SCROLL_DIVIDER );

   175 }

   176 

   177 /*!

   178  * Private slot

   179  *

   180  */

   181 void RadioCarouselAnimator::finalizeNumberScroll()

   182 {

   183     if ( !mCanceled ) {

   184         mCarousel.mItems[RadioStationCarousel::CenterItem]->setFrequency(

   185                 mCarousel.mItems[RadioStationCarousel::RightItem]->frequency() );

   186         mCarousel.scrollContentsTo( QPointF( -mCarousel.mMidScrollPos, 0 ), 0 );

   187         emit mCarousel.scanAnimationFinished();

   188     }

   189     removeMode( ScrollingNumbers );

   190 }

   191 

   192 /*!

   193  *

   194  */

   195 void RadioCarouselAnimator::addMode( AnimationMode mode )

   196 {

   197     mMode |= mode;

   198     if ( mMode.testFlag( TimerItem ) && !mTimer->isActive() ) {

   199         mTimer->start();

   200     }

   201 }

   202 

   203 /*!

   204  *

   205  */

   206 void RadioCarouselAnimator::removeMode( AnimationMode mode )

   207 {

   208     mMode &= ~mode;

   209     if ( !mMode.testFlag( TimerItem ) ) {

   210         mTimer->stop();

   211     }

   212 

   213     if ( mMode == NoAnimation ) {

   214         deleteLater();

   215     }

   216 

   217 }