radioapp/radiowidgets/src/radiofrequencystripbase.cpp
changeset 39 ac7857bd5fdb
child 44 0a3ad94fc71c
equal deleted inserted replaced
38:f8c3d4e6102c 39:ac7857bd5fdb
       
     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 <HbDocumentLoader>
       
    20 #include <HbEffect>
       
    21 #include <QPainter>
       
    22 #include <QStringListModel>
       
    23 #include <QGraphicsSceneResizeEvent>
       
    24 #include <QPen>
       
    25 #include <HbPushButton>
       
    26 #include <QTimer>
       
    27 #include <HbColorScheme>
       
    28 #include <HbEvent>
       
    29 #include <HbSwipeGesture>
       
    30 #include <HbDeviceProfile>
       
    31 #include <QDebug>
       
    32 
       
    33 // User includes
       
    34 #include "radiofrequencystripbase.h"
       
    35 #include "radiofrequencystripdef.h"
       
    36 #include "radiofrequencyitem.h"
       
    37 
       
    38 /*!
       
    39  * Convenience function to check signal-slot connections
       
    40  */
       
    41 //#define CHECK_SIGNAL_CONNECTIONS
       
    42 static bool connectAndCheck( const QObject* sender, const char* signal,
       
    43                              const QObject* receiver, const char* member,
       
    44                              Qt::ConnectionType type = Qt::AutoConnection )
       
    45 {
       
    46     bool connected = QObject::connect( sender, signal, receiver, member, type );
       
    47 
       
    48     #ifdef CHECK_SIGNAL_CONNECTIONS
       
    49 
       
    50     if ( !connected ) {
       
    51         qDebug() << "Failed to make a signal-slot connection!";
       
    52         qDebug() << "sender: " << sender->metaObject()->className();
       
    53         qDebug() << "signal: " << signal;
       
    54         qDebug() << "receiver: " << receiver->metaObject()->className();
       
    55         qDebug() << "slot/signal: " << signal;
       
    56 
       
    57         Q_ASSERT( false );
       
    58 
       
    59         // ----------------------------------------------------------------
       
    60         // SIGNAL-SLOT CONNECT FAILED!
       
    61         // ----------------------------------------------------------------
       
    62     }
       
    63 
       
    64     #endif // CHECK_SIGNAL_CONNECTIONS
       
    65 
       
    66     return connected;
       
    67 }
       
    68 
       
    69 /*!
       
    70  *
       
    71  */
       
    72 RadioFrequencyStripBase::RadioFrequencyStripBase( QGraphicsItem* parent ) :
       
    73     RadioStripBase( parent ),
       
    74     mItemHeight( 8 ),
       
    75     mMinFrequency( 87500000 ),
       
    76     mMaxFrequency( 108000000 ),
       
    77     mFrequencyStepSize( 100000 ),
       
    78     mFrequency( 87500000 ),
       
    79     mSelectorImage( new QGraphicsPixmapItem( this ) ),
       
    80     mSeparatorPos( 0.0 ),
       
    81     mMaxWidth( 0 ),
       
    82     mSelectorPos( 0.0 ),
       
    83     mLeftButton( 0 ),
       
    84     mRightButton( 0 ),
       
    85     mManualSeekTimer( NULL ),
       
    86     mManualSeekMode( false ),
       
    87     mLastReportedFrequency( 0 ),
       
    88     mManualSeekTimerId( 0 ),
       
    89     mForegroundColor( Qt::white )//HbColorScheme::color( FrequencyStrip::TEXT_COLOR_ATTRIBUTE ) )
       
    90 {
       
    91     setScrollingStyle( HbScrollArea::PanWithFollowOn );
       
    92     setItemSize( QSizeF( FrequencyStrip::ITEM_WIDTH + FrequencyStrip::PIXMAP_OVERLAP / 2, mItemHeight ) );
       
    93     setOverlap( FrequencyStrip::PIXMAP_OVERLAP / 2 );
       
    94 }
       
    95 
       
    96 /*!
       
    97  * Property
       
    98  */
       
    99 void RadioFrequencyStripBase::setItemHeight( int itemHeight )
       
   100 {
       
   101     mItemHeight = itemHeight;
       
   102 }
       
   103 
       
   104 /*!
       
   105  * Property
       
   106  */
       
   107 int RadioFrequencyStripBase::itemHeight() const
       
   108 {
       
   109     return mItemHeight;
       
   110 }
       
   111 
       
   112 /*!
       
   113  *
       
   114  */
       
   115 void RadioFrequencyStripBase::initbase( uint minFrequency, uint maxFrequency, uint stepSize, uint frequency )
       
   116 {
       
   117     mMinFrequency       = minFrequency;
       
   118     mMaxFrequency       = maxFrequency;
       
   119     mFrequencyStepSize  = stepSize;
       
   120     mFrequency          = frequency;
       
   121 
       
   122     initModel();
       
   123     initEmptyItems();
       
   124     initPositions();
       
   125 
       
   126     HbDeviceProfile deviceProfile;
       
   127     mItemHeight = static_cast<int>( mItemHeight * deviceProfile.unitValue() );
       
   128 
       
   129     mManualSeekTimer = new QTimer( this );
       
   130     mManualSeekTimer->setInterval( FrequencyStrip::MANUALSEEK_START_TIMEOUT );
       
   131     mManualSeekTimer->setSingleShot( true );
       
   132     connectAndCheck( mManualSeekTimer,   SIGNAL(timeout()),
       
   133                      this,               SLOT(toggleManualSeek()) );
       
   134 
       
   135     connectAndCheck( this,           SIGNAL(scrollingEnded()),
       
   136                      this,           SLOT(handleScrollingEnd()) );
       
   137 
       
   138     grabGesture( Qt::SwipeGesture );
       
   139 
       
   140     //TODO: Remove. Stepsize temporarily hardcoded to 100 Khz in europe region
       
   141     if ( mFrequencyStepSize < FrequencyStrip::ONE_HUNDRED_KHZ ) {
       
   142         mFrequencyStepSize = FrequencyStrip::ONE_HUNDRED_KHZ;
       
   143     }
       
   144 
       
   145     updateAllItems();
       
   146 
       
   147     showButtons();
       
   148 }
       
   149 
       
   150 /*!
       
   151  *
       
   152  */
       
   153 void RadioFrequencyStripBase::createButtonsFromDocml( HbDocumentLoader& uiLoader, const QString& leftButtonName, const QString& rightButtonName )
       
   154 {
       
   155     Q_ASSERT( !mLeftButton && !mRightButton );
       
   156     mLeftButton = qobject_cast<HbPushButton*>( uiLoader.findWidget( leftButtonName ) );
       
   157     mRightButton = qobject_cast<HbPushButton*>( uiLoader.findWidget( rightButtonName ) );
       
   158 
       
   159     initButtons();
       
   160 }
       
   161 
       
   162 /*!
       
   163  *
       
   164  */
       
   165 void RadioFrequencyStripBase::createButtons()
       
   166 {
       
   167     Q_ASSERT( !mLeftButton && !mRightButton );
       
   168     mLeftButton = new HbPushButton( this );
       
   169     mRightButton = new HbPushButton( this );
       
   170 
       
   171     mLeftButton->setIcon( HbIcon( "qtg_mono_previous" ) );
       
   172     mRightButton->setIcon( HbIcon( "qtg_mono_next" ) );
       
   173 
       
   174     initButtons();
       
   175 }
       
   176 
       
   177 /*!
       
   178  *
       
   179  */
       
   180 void RadioFrequencyStripBase::setFrequency( const uint frequency, int reason, Scroll::Direction direction )
       
   181 {
       
   182     if ( mFrequencies.contains( frequency ) ) {
       
   183         scrollToFrequency( frequency, direction, mAutoScrollTime );
       
   184     }
       
   185 }
       
   186 
       
   187 /*!
       
   188  *
       
   189  */
       
   190 uint RadioFrequencyStripBase::frequency() const
       
   191 {
       
   192     return mFrequency;
       
   193 }
       
   194 
       
   195 /*!
       
   196  *
       
   197  */
       
   198 bool RadioFrequencyStripBase::isInManualSeekMode() const
       
   199 {
       
   200     return mManualSeekMode;
       
   201 }
       
   202 
       
   203 /*!
       
   204  *
       
   205  */
       
   206 void RadioFrequencyStripBase::cancelManualSeek()
       
   207 {
       
   208     mManualSeekTimer->stop();
       
   209     if ( mManualSeekMode ) {
       
   210         toggleManualSeek();
       
   211     }
       
   212 }
       
   213 
       
   214 /*!
       
   215  *
       
   216  */
       
   217 void RadioFrequencyStripBase::addScannedStation( uint frequency )
       
   218 {
       
   219     FrequencyPos pos = mFrequencies.value( frequency );
       
   220     updateItem( pos.mItem, frequency );
       
   221 }
       
   222 
       
   223 /*!
       
   224  *
       
   225  */
       
   226 void RadioFrequencyStripBase::updateFavorite( uint frequency )
       
   227 {
       
   228     FrequencyPos pos = mFrequencies.value( frequency );
       
   229     updateItem( pos.mItem );
       
   230 }
       
   231 
       
   232 /*!
       
   233  * Public slot
       
   234  *
       
   235  */
       
   236 void RadioFrequencyStripBase::setScanningMode( bool isScanning )
       
   237 {
       
   238     mManualSeekTimer->stop();
       
   239     if ( isScanning ) {
       
   240         initEmptyItems();
       
   241         hideButtons();
       
   242         scrollToFrequency( mMinFrequency, Scroll::Shortest, mAutoScrollTime );
       
   243     } else {
       
   244         showButtons();
       
   245     }
       
   246     setEnabled( !isScanning );
       
   247 }
       
   248 
       
   249 /*!
       
   250  * Private slot
       
   251  *
       
   252  */
       
   253 void RadioFrequencyStripBase::initEmptyItems()
       
   254 {
       
   255     //TODO: Remove the weird hack of checking the sender
       
   256     if ( !sender() || !isScanning() ) {
       
   257         QList<FrequencyStrip::StationMarker> emptyList;
       
   258         foreach ( RadioFrequencyItem* item, mFrequencyItems ) {
       
   259             QPixmap pixmap = drawPixmap( item->frequency(), emptyList, item );
       
   260             item->setPixmap( pixmap );
       
   261         }
       
   262     }
       
   263 }
       
   264 
       
   265 /*!
       
   266  * Private slot
       
   267  *
       
   268  */
       
   269 void RadioFrequencyStripBase::removeStation( const QModelIndex& parent, int first, int last )
       
   270 {
       
   271     Q_UNUSED( parent );
       
   272     updateStationsInRange( first, last, true );
       
   273 }
       
   274 
       
   275 /*!
       
   276  * Private slot
       
   277  *
       
   278  */
       
   279 void RadioFrequencyStripBase::updateStation( const QModelIndex& parent, int first, int last )
       
   280 {
       
   281     Q_UNUSED( parent );
       
   282     updateStationsInRange( first, last );
       
   283 }
       
   284 
       
   285 /*!
       
   286  * Private slot
       
   287  */
       
   288 void RadioFrequencyStripBase::handleLeftButton()
       
   289 {
       
   290     skipToPreviousFavorite();
       
   291 }
       
   292 
       
   293 /*!
       
   294  * Private slot
       
   295  */
       
   296 void RadioFrequencyStripBase::handleRightButton()
       
   297 {
       
   298     skipToNextFavorite();
       
   299 }
       
   300 
       
   301 /*!
       
   302  * Private slot
       
   303  */
       
   304 void RadioFrequencyStripBase::handleLongLeftButton()
       
   305 {
       
   306     seekDown();
       
   307 }
       
   308 
       
   309 /*!
       
   310  * Private slot
       
   311  */
       
   312 void RadioFrequencyStripBase::handleLongRightButton()
       
   313 {
       
   314     seekUp();
       
   315 }
       
   316 
       
   317 /*!
       
   318  * Private slot
       
   319  *
       
   320  */
       
   321 void RadioFrequencyStripBase::toggleManualSeek()
       
   322 {
       
   323     mManualSeekMode = !mManualSeekMode;
       
   324     emit manualSeekChanged( mManualSeekMode );
       
   325 
       
   326     if ( mManualSeekMode ) {
       
   327         grabMouse();
       
   328         hideButtons();
       
   329         mManualSeekTimerId = startTimer( FrequencyStrip::MANUALSEEK_SIGNAL_DELAY );
       
   330     } else {
       
   331         ungrabMouse();
       
   332         showButtons();
       
   333         killTimer( mManualSeekTimerId );
       
   334         mManualSeekTimerId = 0;
       
   335     }
       
   336 }
       
   337 
       
   338 /*!
       
   339  * Private slot
       
   340  */
       
   341 void RadioFrequencyStripBase::handleScrollingEnd()
       
   342 {
       
   343     // Check if the selector is in the invalid area where the strip loops around
       
   344     const int selectorPosition = selectorPos();
       
   345     if ( mManualSeekMode ) {
       
   346         if ( !mPositions.contains( selectorPosition ) ) {
       
   347             if ( selectorPosition < mMaxWidth - FrequencyStrip::ITEM_WIDTH + mSeparatorPos ) {
       
   348                 scrollToFrequency( mMaxFrequency, Scroll::Shortest, 500 );
       
   349                 emitFrequencyChanged( mMaxFrequency, FrequencyStrip::ManualSeekUpdate, Scroll::Shortest );
       
   350             } else {
       
   351                 scrollToFrequency( mMinFrequency, Scroll::Shortest, 500 );
       
   352                 emitFrequencyChanged( mMinFrequency, FrequencyStrip::ManualSeekUpdate, Scroll::Shortest );
       
   353             }
       
   354         }
       
   355 
       
   356         mManualSeekTimer->start( FrequencyStrip::MANUALSEEK_END_TIMEOUT );
       
   357     }
       
   358 }
       
   359 
       
   360 /*!
       
   361  * \reimp
       
   362  */
       
   363 void RadioFrequencyStripBase::updateItemPrimitive( QGraphicsItem* itemToUpdate, int itemIndex )
       
   364 {
       
   365     QGraphicsPixmapItem* item = static_cast<QGraphicsPixmapItem*>( itemToUpdate );
       
   366     if ( itemIndex < mFrequencyItems.count() ) {
       
   367         item->setPixmap( mFrequencyItems.at( itemIndex )->updatePrimitive( item ) );
       
   368     }
       
   369 }
       
   370 
       
   371 /*!
       
   372  * \reimp
       
   373  */
       
   374 QGraphicsItem* RadioFrequencyStripBase::createItemPrimitive( QGraphicsItem* parent )
       
   375 {
       
   376     return new QGraphicsPixmapItem( parent );
       
   377 }
       
   378 
       
   379 /*!
       
   380  * \reimp
       
   381  */
       
   382 void RadioFrequencyStripBase::scrollPosChanged()
       
   383 {
       
   384     if ( mManualSeekMode ) {
       
   385         const int pos = selectorPos();
       
   386         const uint frequency = mPositions.value( pos );
       
   387         if ( frequency > 0 ) {
       
   388             mFrequency = mPositions.value( pos );
       
   389             emitFrequencyChanged( mFrequency, FrequencyStrip::ManualSeekUpdate, Scroll::Shortest );
       
   390         }
       
   391     }
       
   392 }
       
   393 
       
   394 /*!
       
   395  * \reimp
       
   396  */
       
   397 void RadioFrequencyStripBase::resizeEvent ( QGraphicsSceneResizeEvent* event )
       
   398 {
       
   399     RadioStripBase::resizeEvent( event );
       
   400 
       
   401     initSelector();
       
   402 
       
   403     const qreal height = event->newSize().height();
       
   404     const qreal width = event->newSize().width();
       
   405 
       
   406     mSelectorPos = width / 2;
       
   407     mSelectorImage->setOffset( mSelectorPos - ( FrequencyStrip::INDICATOR_WIDTH / 2 ), 0.0 );
       
   408 
       
   409     if ( mLeftButton && mRightButton ) {
       
   410         mLeftButton->resize( height, height );
       
   411         mRightButton->resize( height, height );
       
   412         mRightButton->setPos( QPointF( width - height, 0 ) );
       
   413     }
       
   414 
       
   415     scrollToFrequency( mFrequency );
       
   416 }
       
   417 
       
   418 /*!
       
   419  * \reimp
       
   420  */
       
   421 void RadioFrequencyStripBase::changeEvent( QEvent* event )
       
   422 {
       
   423     if ( event->type() == HbEvent::ThemeChanged ) {
       
   424         // Update the foreground color and redraw each item
       
   425         mForegroundColor = Qt::white;// HbColorScheme::color( FrequencyStrip::TEXT_COLOR_ATTRIBUTE );
       
   426         updateAllItems();
       
   427     }
       
   428 
       
   429     return RadioStripBase::changeEvent(event);
       
   430 }
       
   431 
       
   432 /*!
       
   433  * \reimp
       
   434  */
       
   435 void RadioFrequencyStripBase::mousePressEvent( QGraphicsSceneMouseEvent* event )
       
   436 {
       
   437     RadioStripBase::mousePressEvent( event );
       
   438 
       
   439     mManualSeekTimer->stop();
       
   440     if ( mManualSeekMode ) {
       
   441         const bool insideStrip = rect().contains( event->pos() );
       
   442         if ( !insideStrip ) {
       
   443             toggleManualSeek();
       
   444         }
       
   445     } else {
       
   446         mManualSeekTimer->start( FrequencyStrip::MANUALSEEK_START_TIMEOUT );
       
   447     }
       
   448 }
       
   449 
       
   450 /*!
       
   451  * \reimp
       
   452  */
       
   453 void RadioFrequencyStripBase::mouseReleaseEvent( QGraphicsSceneMouseEvent* event )
       
   454 {
       
   455     RadioStripBase::mouseReleaseEvent( event );
       
   456 
       
   457     mManualSeekTimer->stop();
       
   458     if ( mManualSeekMode && !isScrolling() ) {
       
   459         mManualSeekTimer->start( FrequencyStrip::MANUALSEEK_END_TIMEOUT );
       
   460     }
       
   461 }
       
   462 
       
   463 /*!
       
   464  * \reimp
       
   465  */
       
   466 void RadioFrequencyStripBase::gestureEvent( QGestureEvent* event )
       
   467 {
       
   468     HbSwipeGesture* swipeGesture = static_cast<HbSwipeGesture*>( event->gesture( Qt::SwipeGesture ) );
       
   469     if ( swipeGesture && !mManualSeekMode ) {
       
   470         if ( swipeGesture->state() == Qt::GestureFinished ) {
       
   471             if ( swipeGesture->horizontalDirection() == QSwipeGesture::Left ) {
       
   472                 skipToNext();
       
   473             } else if ( swipeGesture->horizontalDirection() == QSwipeGesture::Right ) {
       
   474                 skipToPrevious();
       
   475             }
       
   476         }
       
   477     } else if ( mManualSeekMode ) {
       
   478         RadioStripBase::gestureEvent( event );
       
   479     }
       
   480 }
       
   481 
       
   482 /*!
       
   483  * \reimp
       
   484  */
       
   485 void RadioFrequencyStripBase::timerEvent( QTimerEvent* event )
       
   486 {
       
   487     Q_UNUSED( event );
       
   488     if ( mLastReportedFrequency != mFrequency ) {
       
   489         mLastReportedFrequency = mFrequency;
       
   490         emitFrequencyChanged( mFrequency, FrequencyStrip::ManualSeekTune, Scroll::Shortest );
       
   491     }
       
   492 }
       
   493 
       
   494 /*!
       
   495  *
       
   496  */
       
   497 void RadioFrequencyStripBase::initModel()
       
   498 {
       
   499     const uint minFreq = uint( qreal(mMinFrequency) / FrequencyStrip::ONE_HERTZ + FrequencyStrip::ROUNDER );
       
   500     const uint maxFreq = uint( qreal(mMaxFrequency) / FrequencyStrip::ONE_HERTZ + 0.9 ); // always round up
       
   501 
       
   502     QStringList list;
       
   503     QString freqText;
       
   504     for ( uint i = minFreq; i <= maxFreq; ++i ) {
       
   505         freqText = QString::number( i );
       
   506         list.append( freqText );
       
   507         mFrequencyItems.append( new RadioFrequencyItem( freqText ) );
       
   508     }
       
   509     mFrequencyItems.append( new RadioFrequencyItem( "" ) );
       
   510     list.append( "" );
       
   511 
       
   512     mMaxWidth = list.count() * FrequencyStrip::ITEM_WIDTH;
       
   513 
       
   514     mSeparatorPos = qreal(FrequencyStrip::ITEM_WIDTH) / 2;
       
   515     const uint minDrawableFreq = minFreq * FrequencyStrip::ONE_HERTZ - FrequencyStrip::HALF_HERTZ;;
       
   516     const uint maxDrawableFreq = maxFreq * FrequencyStrip::ONE_HERTZ + FrequencyStrip::HALF_HERTZ;
       
   517     mSeparatorPos += qreal( ( mMinFrequency  - minDrawableFreq ) / 2 ) / FrequencyStrip::PIXEL_IN_HZ;
       
   518     mSeparatorPos -= qreal( ( maxDrawableFreq - mMaxFrequency ) / 2 ) / FrequencyStrip::PIXEL_IN_HZ;
       
   519 
       
   520     setModel( new QStringListModel( list, this ) );
       
   521 }
       
   522 
       
   523 /*!
       
   524  *
       
   525  */
       
   526 void RadioFrequencyStripBase::initSelector()
       
   527 {
       
   528     QPixmap selectorPixmap = QPixmap( QSize( FrequencyStrip::SELECTOR_WIDTH, (int)size().height() ) );
       
   529     selectorPixmap.fill( Qt::red );
       
   530     mSelectorImage->setPixmap( selectorPixmap );
       
   531     mSelectorImage->setZValue( FrequencyStrip::SELECTOR_Z_POS );
       
   532 }
       
   533 
       
   534 /*!
       
   535  *
       
   536  */
       
   537 void RadioFrequencyStripBase::initPositions()
       
   538 {
       
   539     int prevPos = 0;
       
   540     int nextPos = 0;
       
   541     const int lastPos = mFrequencies.value( mMaxFrequency ).mPosition;
       
   542     for ( int i = mFrequencies.value( mMinFrequency ).mPosition; i < lastPos; ++i ) {
       
   543         if ( mPositions.contains( i ) ) {
       
   544             prevPos = i;
       
   545             const uint freq = mPositions.value( prevPos ) + mFrequencyStepSize;
       
   546             if ( mFrequencies.contains( freq ) ) {
       
   547                 nextPos = mFrequencies.value( freq ).mPosition;
       
   548             } else {
       
   549                 nextPos = prevPos;
       
   550             }
       
   551         } else {
       
   552             const int nearestHit = ( i - prevPos ) < ( nextPos - i ) ? prevPos : nextPos;
       
   553             mPositions.insert( i, mPositions.value( nearestHit ) );
       
   554         }
       
   555     }
       
   556 }
       
   557 
       
   558 /*!
       
   559  *
       
   560  */
       
   561 void RadioFrequencyStripBase::initButtons()
       
   562 {
       
   563     Q_ASSERT( mLeftButton && mRightButton );
       
   564     connectAndCheck( mLeftButton,    SIGNAL(clicked()),
       
   565                      this,           SLOT(handleLeftButton()) );
       
   566     connectAndCheck( mRightButton,   SIGNAL(clicked()),
       
   567                      this,           SLOT(handleRightButton()) );
       
   568     connectAndCheck( mLeftButton,    SIGNAL(longPress(QPointF)),
       
   569                      this,           SLOT(handleLongLeftButton()) );
       
   570     connectAndCheck( mRightButton,   SIGNAL(longPress(QPointF)),
       
   571                      this,           SLOT(handleLongRightButton()) );
       
   572 
       
   573     mLeftButton->setZValue( FrequencyStrip::SELECTOR_Z_POS );
       
   574     mLeftButton->setObjectName( FrequencyStrip::LEFT_BUTTON );
       
   575     mRightButton->setZValue( FrequencyStrip::SELECTOR_Z_POS );
       
   576     mRightButton->setObjectName( FrequencyStrip::RIGHT_BUTTON );
       
   577 
       
   578     const qreal height = size().height();
       
   579     const qreal width = size().width();
       
   580     mLeftButton->resize( height, height );
       
   581     mRightButton->resize( height, height );
       
   582     mRightButton->setPos( QPointF( width - height, 0 ) );
       
   583 
       
   584     // Add left button effects
       
   585     QStringList pathList;
       
   586     pathList << ":/effects/slide_to_left.fxml" << ":/effects/slide_from_left.fxml";
       
   587     QStringList eventList;
       
   588     eventList << FrequencyStrip::SLIDE_TO_LEFT << FrequencyStrip::SLIDE_FROM_LEFT;
       
   589     HbEffect::add( mLeftButton, pathList, eventList );
       
   590 
       
   591     // Add right button effects
       
   592     pathList.clear();
       
   593     pathList << ":/effects/slide_to_right.fxml" << ":/effects/slide_from_right.fxml";
       
   594     eventList.clear();
       
   595     eventList << FrequencyStrip::SLIDE_TO_RIGHT << FrequencyStrip::SLIDE_FROM_RIGHT;
       
   596     HbEffect::add( mRightButton, pathList, eventList );
       
   597 }
       
   598 
       
   599 /*!
       
   600  *
       
   601  */
       
   602 void RadioFrequencyStripBase::addFrequencyPos( int pos, uint frequency, RadioFrequencyItem* item )
       
   603 {
       
   604     mFrequencies.insert( frequency, FrequencyPos( pos, item ) );
       
   605     mPositions.insert( pos, frequency );
       
   606 }
       
   607 
       
   608 /*!
       
   609  *
       
   610  */
       
   611 void RadioFrequencyStripBase::updateStationsInRange( int first, int last, bool stationRemoved )
       
   612 {
       
   613     if ( !isScanning() ) {
       
   614         uint frequency = 0;
       
   615         for ( int i = first; i <= last; ++i ) {
       
   616             frequency = frequencyAtIndex( i );
       
   617             if ( mFrequencies.contains( frequency ) ) {
       
   618                 FrequencyPos pos = mFrequencies.value( frequency );
       
   619                 updateItem( pos.mItem, 0, stationRemoved ? frequency : 0 );
       
   620             }
       
   621         }
       
   622     }
       
   623 }
       
   624 
       
   625 /*!
       
   626  *
       
   627  */
       
   628 void RadioFrequencyStripBase::updateItem( RadioFrequencyItem* item, uint upperRange, uint ignoredFrequency )
       
   629 {
       
   630     if ( item ) {
       
   631         uint frequency = item->frequency();
       
   632         QList<FrequencyStrip::StationMarker> markers;
       
   633 
       
   634         if ( upperRange == 0 ) {
       
   635             upperRange = frequency + FrequencyStrip::HALF_HERTZ;
       
   636         }
       
   637 
       
   638         if ( isInitialized() ) {
       
   639             markers = stationsInRange( frequency - FrequencyStrip::HALF_HERTZ, upperRange );
       
   640             for ( int i = markers.count() - 1; ignoredFrequency > 0 && i >= 0; --i ) {
       
   641                 if ( markers[i].mFrequency == ignoredFrequency ) {
       
   642                     markers.removeAt( i );
       
   643                     break;
       
   644                 }
       
   645             }
       
   646         }
       
   647 
       
   648         QPixmap pixmap = drawPixmap( frequency, markers, item );
       
   649         item->setPixmap( pixmap );
       
   650 
       
   651         foreach ( const FrequencyStrip::StationMarker& marker, markers ) {
       
   652             FrequencyPos pos = mFrequencies.value( marker.mFrequency );
       
   653             mFrequencies.insert( marker.mFrequency, pos );
       
   654         }
       
   655     }
       
   656 }
       
   657 
       
   658 /*!
       
   659  *
       
   660  */
       
   661 void RadioFrequencyStripBase::updateAllItems()
       
   662 {
       
   663     foreach ( RadioFrequencyItem* item, mFrequencyItems ) {
       
   664         updateItem( item );
       
   665     }
       
   666 }
       
   667 
       
   668 /*!
       
   669  *
       
   670  */
       
   671 QPixmap RadioFrequencyStripBase::drawPixmap( uint frequency, QList<FrequencyStrip::StationMarker> stations, RadioFrequencyItem* item )
       
   672 {
       
   673     QPixmap pixmap( FrequencyStrip::PIXMAP_WIDTH, mItemHeight );
       
   674     pixmap.fill( Qt::transparent );
       
   675     QPainter painter( &pixmap );
       
   676     QPen normalPen = painter.pen();
       
   677     QPen favoritePen = normalPen;
       
   678     normalPen.setColor( mForegroundColor );
       
   679     painter.setPen( normalPen );
       
   680 
       
   681     if ( frequency == 0 ) {
       
   682         painter.drawLine( makeTab( mSeparatorPos - 1 + FrequencyStrip::ROUNDER, mItemHeight ) );
       
   683         painter.drawLine( makeTab( mSeparatorPos + FrequencyStrip::ROUNDER, mItemHeight ) );
       
   684         return pixmap;
       
   685     }
       
   686 
       
   687     const QString itemText = QString::number( frequency / FrequencyStrip::ONE_HERTZ );
       
   688     const uint startFrequency = frequency - FrequencyStrip::HALF_HERTZ;
       
   689     const uint endFrequency = startFrequency + FrequencyStrip::ONE_HERTZ;
       
   690     const uint  roundedMin = int( qreal(mMinFrequency) / FrequencyStrip::ONE_HERTZ + FrequencyStrip::ROUNDER );
       
   691     const uint freq = frequency / FrequencyStrip::ONE_HERTZ;
       
   692     const int diff = freq - roundedMin;
       
   693     const qreal startPixel = diff * FrequencyStrip::ITEM_WIDTH;
       
   694     qreal pixels = 0.0;
       
   695     const qreal leftOverlap = FrequencyStrip::PIXMAP_OVERLAP / 2;
       
   696 
       
   697     for ( uint frequency = startFrequency; frequency <= endFrequency; frequency += mFrequencyStepSize ) {
       
   698 
       
   699         if ( frequency < mMinFrequency || frequency > mMaxFrequency ) {
       
   700             continue;
       
   701         }
       
   702 
       
   703         pixels = qreal( frequency - startFrequency ) / FrequencyStrip::PIXEL_IN_HZ;
       
   704         if ( frequency % FrequencyStrip::ONE_HERTZ == 0 ) {
       
   705 
       
   706             // Draw the high frequency tab and the frequency text for the even number
       
   707             normalPen.setWidth( 3 );
       
   708             painter.setPen( normalPen );
       
   709             painter.drawLine( makeTab( pixels + leftOverlap - 1, FrequencyStrip::TAB_HEIGHT_BIG ) );
       
   710             normalPen.setWidth( 1 );
       
   711             painter.setPen( normalPen );
       
   712 
       
   713             // Draw the frequency text and its 00 decimals
       
   714             painter.setFont( FrequencyStrip::DECIMAL_FONT );
       
   715             const int decimalWidth = painter.fontMetrics().width( FrequencyStrip::DECIMAL_TEXT );
       
   716             const int decimalSpace = painter.fontMetrics().leftBearing( '.' );
       
   717             painter.setFont( FrequencyStrip::FREQUENCY_FONT );
       
   718             const int frequencyWidth = painter.fontMetrics().width( itemText );
       
   719             const int textPosX = int( pixels + leftOverlap - ( frequencyWidth + decimalSpace + decimalWidth ) / 2 );
       
   720             painter.drawText( QPoint( textPosX, FrequencyStrip::FREQUENCY_TEXT_Y_POS ), itemText );
       
   721             painter.setFont( FrequencyStrip::DECIMAL_FONT );
       
   722             painter.drawText( QPoint( textPosX + frequencyWidth + decimalSpace, FrequencyStrip::FREQUENCY_TEXT_Y_POS ), FrequencyStrip::DECIMAL_TEXT );
       
   723 
       
   724         } else if ( frequency % FrequencyStrip::ONE_TAB_IN_HZ == 0 ) {
       
   725 
       
   726             // Draw the low frequency tab for the uneven number
       
   727             painter.drawLine( makeTab( pixels + leftOverlap, FrequencyStrip::TAB_HEIGHT_SMALL ) );
       
   728 
       
   729         }
       
   730 
       
   731         addFrequencyPos( int( startPixel + pixels + FrequencyStrip::ROUNDER ), frequency, item );
       
   732     }
       
   733 
       
   734     // Draw favorites and local stations
       
   735     favoritePen.setColor( Qt::yellow );
       
   736 
       
   737     foreach ( const FrequencyStrip::StationMarker& station, stations ) {
       
   738         const uint frequency = station.mFrequency;
       
   739         pixels = qreal( frequency - startFrequency ) / FrequencyStrip::PIXEL_IN_HZ;
       
   740 
       
   741         if ( station.mIsFavorite ) {
       
   742             favoritePen.setWidth( FrequencyStrip::PEN_WIDTH_FAVORITE );
       
   743             painter.setPen( favoritePen );
       
   744             painter.drawEllipse( int( pixels + leftOverlap - 3 ), FrequencyStrip::STATION_MARKER_Y_POS - 3, 6, 6 );
       
   745         } else {
       
   746             favoritePen.setWidth( 1 );
       
   747             painter.setPen( favoritePen );
       
   748             painter.drawEllipse( int( pixels + leftOverlap - 4 ), FrequencyStrip::STATION_MARKER_Y_POS - 4, 8, 8 );
       
   749         }
       
   750     }
       
   751 
       
   752     return pixmap;
       
   753 }
       
   754 
       
   755 /*!
       
   756  *
       
   757  */
       
   758 QLineF RadioFrequencyStripBase::makeTab( qreal pos, int height )
       
   759 {
       
   760     return QLineF( pos, mItemHeight - height, pos, mItemHeight );
       
   761 }
       
   762 
       
   763 /*!
       
   764  *
       
   765  */
       
   766 int RadioFrequencyStripBase::selectorPos() const
       
   767 {
       
   768     const int pos = int( -contentWidget()->x() + mSelectorPos + FrequencyStrip::ROUNDER );
       
   769     return pos % mMaxWidth;
       
   770 }
       
   771 
       
   772 /*!
       
   773  *
       
   774  */
       
   775 void RadioFrequencyStripBase::scrollToFrequency( uint frequency, Scroll::Direction direction, int time )
       
   776 {
       
   777     int targetFreqPos = mFrequencies.value( frequency ).mPosition;
       
   778     const int currentFreqPos = mFrequencies.value( mFrequency ).mPosition;
       
   779     const int currentPos = int( -contentWidget()->x() + mSelectorPos + FrequencyStrip::ROUNDER );
       
   780     const bool isInSecondHalf = currentPos >= mMaxWidth - FrequencyStrip::ITEM_WIDTH + mSeparatorPos;
       
   781 
       
   782     // Special case: When there is only one favorite and the user presses skip
       
   783     // the strip must scroll around to the same frequency.
       
   784     if ( mFrequency == frequency && direction != Scroll::Shortest ) {
       
   785         if ( direction == Scroll::Left ) {
       
   786             targetFreqPos += mMaxWidth;
       
   787         } else {
       
   788             targetFreqPos -= mMaxWidth;
       
   789         }
       
   790     }
       
   791 
       
   792     mFrequency = frequency;
       
   793 
       
   794     qreal newPos = targetFreqPos;
       
   795     if ( direction == Scroll::Left ) {
       
   796 
       
   797         if ( currentFreqPos > targetFreqPos ) {
       
   798             newPos += mMaxWidth;
       
   799         }
       
   800 
       
   801     } else if ( direction == Scroll::Right ) {
       
   802 
       
   803         if ( currentFreqPos < targetFreqPos ) {
       
   804             newPos -= mMaxWidth;
       
   805         }
       
   806 
       
   807     }
       
   808 
       
   809     if ( isInSecondHalf ) {
       
   810         newPos += mMaxWidth;
       
   811     }
       
   812 
       
   813     newPos -= mSelectorPos - FrequencyStrip::ROUNDER;
       
   814 
       
   815 //    scrollContentsTo( QPointF( newPos, 0 ), time );
       
   816 // TODO: Remove this and uncomment the above line. This is a temporary workaround to get the strip to move
       
   817     scrollContentsTo( QPointF( newPos, 0 ), 0 );
       
   818 }
       
   819 
       
   820 /*!
       
   821  *
       
   822  */
       
   823 void RadioFrequencyStripBase::hideButtons()
       
   824 {
       
   825     HbEffect::start( mLeftButton, FrequencyStrip::SLIDE_TO_LEFT );
       
   826     HbEffect::start( mRightButton, FrequencyStrip::SLIDE_TO_RIGHT );
       
   827 }
       
   828 
       
   829 /*!
       
   830  *
       
   831  */
       
   832 void RadioFrequencyStripBase::showButtons()
       
   833 {
       
   834     HbEffect::start( mLeftButton, FrequencyStrip::SLIDE_FROM_LEFT );
       
   835     HbEffect::start( mRightButton, FrequencyStrip::SLIDE_FROM_RIGHT );
       
   836 }