diff -r 11b6825f0862 -r 3a6b55c6390c radioapp/radiowidgets/src/radiofrequencystrip.cpp
--- a/radioapp/radiowidgets/src/radiofrequencystrip.cpp	Tue Jul 06 14:16:27 2010 +0300
+++ b/radioapp/radiowidgets/src/radiofrequencystrip.cpp	Wed Aug 18 09:49:03 2010 +0300
@@ -16,19 +16,9 @@
 */
 
 // System includes
-#include <QPainter>
-#include <QStringListModel>
-#include <QGraphicsSceneResizeEvent>
-#include <QPen>
-#include <HbPushButton>
-#include <QTimer>
-#include <HbColorScheme>
-#include <HbEvent>
-#include <HbSwipeGesture>
-#include <HbDeviceProfile>
 
+// User includes
 #include "radiofrequencystrip.h"
-#include "radiofrequencyitem.h"
 #include "radiouiengine.h"
 #include "radiostation.h"
 #include "radiostationmodel.h"
@@ -36,95 +26,11 @@
 #include "radiouiloader.h"
 #include "radiologger.h"
 
-// Frequency lines
-const int TAB_HEIGHT_SMALL = 12;
-const int TAB_HEIGHT_BIG = 18;
-const int PEN_WIDTH_FAVORITE = 4;
-const qreal INDICATOR_WIDTH = 2.0;
-
-const qreal ROUNDER = 0.5;
-const int SELECTOR_WIDTH = 2;
-const int SELECTOR_Z_POS = 100;
-
-const int HALF_HERTZ = ONE_HERTZ / 2;
-const int ONE_TAB_DISTANCE = 20;
-const uint ONE_TAB_IN_HZ = uint( 0.2 * ONE_HERTZ );
-const qreal PIXEL_IN_HZ = ONE_TAB_IN_HZ / ONE_TAB_DISTANCE;
-const qreal PIXMAP_OVERLAP = qreal( ONE_TAB_DISTANCE ) / 2;
-const int ITEM_WIDTH = ONE_TAB_DISTANCE * 5;
-const int PIXMAP_WIDTH = ITEM_WIDTH + (int)PIXMAP_OVERLAP;
-
-const uint ONE_HUNDRED_KHZ = 100000;
-
-const char* DECIMAL_TEXT = ".0";
-
-#ifdef BUILD_WIN32
-    const int FREQUENCY_FONT_SIZE = 12;
-    const int DECIMAL_FONT_SIZE = 8;
-#else
-    const int FREQUENCY_FONT_SIZE = 6;
-    const int DECIMAL_FONT_SIZE = 4;
-#endif // BUILD_WIN32
-
-const QFont FREQUENCY_FONT( "", FREQUENCY_FONT_SIZE );
-const QFont DECIMAL_FONT( "", DECIMAL_FONT_SIZE );
-
-const char* SLIDE_TO_LEFT       = "SlideToLeft";
-const char* SLIDE_FROM_LEFT     = "SlideFromLeft";
-const char* SLIDE_TO_RIGHT      = "SlideToRight";
-const char* SLIDE_FROM_RIGHT    = "SlideFromRight";
-const char* LEFT_BUTTON         = "tv:left_button";
-const char* RIGHT_BUTTON        = "tv:right_button";
-
-const char* TEXT_COLOR_ATTRIBUTE = "text";
-const int MANUALSEEK_START_TIMEOUT = 400;
-const int MANUALSEEK_END_TIMEOUT = 2000;
-const int MANUALSEEK_SIGNAL_DELAY = 300;
-
-/*!
- *
- */
 RadioFrequencyStrip::RadioFrequencyStrip() :
-    RadioStripBase(),
-    mUiEngine( NULL ),
-    mItemHeight( 8 ),
-    mMinFrequency( 87500000 ),
-    mMaxFrequency( 108000000 ),
-    mFrequencyStepSize( 100000 ),
-    mFrequency( 87500000 ),
-    mSelectorImage( new QGraphicsPixmapItem( this ) ),
-    mSeparatorPos( 0.0 ),
-    mMaxWidth( 0 ),
-    mSelectorPos( 0.0 ),
-    mLeftButton( 0 ),
-    mRightButton( 0 ),
-    mManualSeekTimer( NULL ),
-    mManualSeekMode( false ),
-    mLastReportedFrequency( 0 ),
-    mManualSeekTimerId( 0 ),
-    mForegroundColor( Qt::white )//HbColorScheme::color( TEXT_COLOR_ATTRIBUTE ) )
+    RadioFrequencyStripBase(),
+    mUiEngine( NULL )
 {
     RadioUtil::setFrequencyStrip( this );
-
-    setScrollingStyle( HbScrollArea::PanWithFollowOn );
-    setItemSize( QSizeF( ITEM_WIDTH + PIXMAP_OVERLAP / 2, mItemHeight ) );
-    setOverlap( PIXMAP_OVERLAP / 2 );
-}
-
-/*!
- * Property
- */
-void RadioFrequencyStrip::setItemHeight( int itemHeight )
-{
-    mItemHeight = itemHeight;
-}
-
-/*!
- * Property
- */
-int RadioFrequencyStrip::itemHeight() const
-{
-    return mItemHeight;
 }
 
 /*!
@@ -133,46 +39,10 @@
 void RadioFrequencyStrip::init( RadioUiEngine* engine, RadioUiLoader& uiLoader )
 {
     mUiEngine = engine;
-    mMinFrequency       = mUiEngine->minFrequency();
-    mMaxFrequency       = mUiEngine->maxFrequency();
-    mFrequencyStepSize  = mUiEngine->frequencyStepSize();
-    mFrequency          = RadioUiEngine::lastTunedFrequency();
-
-    initModel();
-    initEmptyItems();
-    initPositions();
-
-    HbDeviceProfile deviceProfile;
-    mItemHeight = static_cast<int>( mItemHeight * deviceProfile.unitValue() );
-
-    mLeftButton = uiLoader.findWidget<HbPushButton>( DOCML::MV_NAME_PREV_BUTTON );
-    mRightButton = uiLoader.findWidget<HbPushButton>( DOCML::MV_NAME_NEXT_BUTTON );
-    initButtons();
+    initbase( mUiEngine->minFrequency(), mUiEngine->maxFrequency(),
+              mUiEngine->frequencyStepSize(), RadioUiEngine::lastTunedFrequency() );
 
-    mManualSeekTimer = new QTimer( this );
-    mManualSeekTimer->setInterval( MANUALSEEK_START_TIMEOUT );
-    mManualSeekTimer->setSingleShot( true );
-    Radio::connect( mManualSeekTimer,   SIGNAL(timeout()),
-                    this,               SLOT(toggleManualSeek()) );
-
-    Radio::connect( mLeftButton,    SIGNAL(clicked()),
-                    this,           SLOT(handleLeftButton()) );
-    Radio::connect( mRightButton,   SIGNAL(clicked()),
-                    this,           SLOT(handleRightButton()) );
-    Radio::connect( mLeftButton,    SIGNAL(longPress(QPointF)),
-                    this,           SLOT(handleLongLeftButton()) );
-    Radio::connect( mRightButton,   SIGNAL(longPress(QPointF)),
-                    this,           SLOT(handleLongRightButton()) );
-
-    Radio::connect( this,           SIGNAL(scrollingEnded()),
-                    this,           SLOT(handleScrollingEnd()) );
-
-    grabGesture( Qt::SwipeGesture );
-
-    //TODO: Remove. Stepsize hardcoded to 100 Khz in europe region during demo
-    if ( mFrequencyStepSize < ONE_HUNDRED_KHZ ) {
-        mFrequencyStepSize = ONE_HUNDRED_KHZ;
-    }
+    createButtonsFromDocml( uiLoader, DOCML::MV_NAME_PREV_BUTTON, DOCML::MV_NAME_NEXT_BUTTON );
 
     RadioStationModel* stationModel = &mUiEngine->stationModel();
     Radio::connect( stationModel,   SIGNAL(rowsInserted(QModelIndex,int,int)),
@@ -181,683 +51,118 @@
                     this,           SLOT(removeStation(QModelIndex,int,int)) );
     Radio::connect( stationModel,   SIGNAL(modelReset()),
                     this,           SLOT(initEmptyItems()) );
-
-    updateAllItems();
-
-    showButtons();
-}
-
-/*!
- *
- */
-void RadioFrequencyStrip::setFrequency( const uint frequency, int reason, Scroll::Direction direction )
-{
-    Q_UNUSED( reason );
-    LOG_FORMAT( "RadioFrequencyStrip::setFrequency, frequency: %d, reason: %d", frequency, reason );
-    if ( mFrequencies.contains( frequency ) ) {
-        if ( frequency != mFrequency || reason == TuneReason::Skip ) {
-            scrollToFrequency( frequency, direction, mAutoScrollTime, RadioUtil::tuneReason( reason ) );
-        }
-    }
-}
-
-/*!
- *
- */
-uint RadioFrequencyStrip::frequency() const
-{
-    return mFrequency;
-}
-
-/*!
- *
- */
-bool RadioFrequencyStrip::isInManualSeekMode() const
-{
-    return mManualSeekMode;
-}
-
-/*!
- *
- */
-void RadioFrequencyStrip::cancelManualSeek()
-{
-    mManualSeekTimer->stop();
-    if ( mManualSeekMode ) {
-        toggleManualSeek();
-    }
-}
-
-/*!
- *
- */
-void RadioFrequencyStrip::addScannedStation( const RadioStation& station )
-{
-    FrequencyPos pos = mFrequencies.value( station.frequency() );
-    updateItem( pos.mItem, station.frequency() );
 }
 
 /*!
  *
  */
-void RadioFrequencyStrip::updateFavorite( const RadioStation& station )
-{
-    LOG_SLOT_CALLER;
-    FrequencyPos pos = mFrequencies.value( station.frequency() );
-    updateItem( pos.mItem );
-}
-
-/*!
- * Public slot
- *
- */
-void RadioFrequencyStrip::setScanningMode( bool isScanning )
-{
-    mManualSeekTimer->stop();
-    if ( isScanning ) {
-        initEmptyItems();
-        hideButtons();
-        scrollToFrequency( mMinFrequency, Scroll::Shortest, mAutoScrollTime );
-    } else {
-        showButtons();
-    }
-    setEnabled( !isScanning );
-}
-
-/*!
- * Private slot
- *
- */
-void RadioFrequencyStrip::removeStation( const QModelIndex& parent, int first, int last )
-{
-    Q_UNUSED( parent );
-    updateStationsInRange( first, last, true );
-}
-
-/*!
- * Private slot
- *
- */
-void RadioFrequencyStrip::updateStation( const QModelIndex& parent, int first, int last )
-{
-    Q_UNUSED( parent );
-    updateStationsInRange( first, last );
-}
-
-/*!
- * Private slot
- *
- */
-void RadioFrequencyStrip::initEmptyItems()
-{
-    LOG_METHOD;
-    //TODO: Remove the weird hack of checking the sender
-    if ( !sender() || RadioUtil::scanStatus() != Scan::ScanningInMainView ) {
-        QList<RadioStation> emptyList;
-        foreach ( RadioFrequencyItem* item, mFrequencyItems ) {
-            QPixmap pixmap = drawPixmap( item->frequency(), emptyList, item );
-            item->setPixmap( pixmap );
-        }
-    }
-}
-
-/*!
- * Private slot
- */
-void RadioFrequencyStrip::handleLeftButton()
-{
-    emit skipRequested( StationSkip::PreviousFavorite );
-}
-
-/*!
- * Private slot
- */
-void RadioFrequencyStrip::handleLongLeftButton()
-{
-    emit seekRequested( Seek::Down );
-}
-
-/*!
- * Private slot
- */
-void RadioFrequencyStrip::handleRightButton()
-{
-    emit skipRequested( StationSkip::NextFavorite );
-}
-
-/*!
- * Private slot
- */
-void RadioFrequencyStrip::handleLongRightButton()
-{
-    emit seekRequested( Seek::Up );
-}
-
-/*!
- * Private slot
- *
- */
-void RadioFrequencyStrip::toggleManualSeek()
-{
-    mManualSeekMode = !mManualSeekMode;
-    emit manualSeekChanged( mManualSeekMode );
-
-    if ( mManualSeekMode ) {
-        grabMouse();
-        hideButtons();
-        mManualSeekTimerId = startTimer( MANUALSEEK_SIGNAL_DELAY );
-    } else {
-        ungrabMouse();
-        showButtons();
-        killTimer( mManualSeekTimerId );
-        mManualSeekTimerId = 0;
-    }
-}
-
-/*!
- * Private slot
- */
-void RadioFrequencyStrip::handleScrollingEnd()
+void RadioFrequencyStrip::setFrequency( const uint newFrequency, int reason, Scroll::Direction direction )
 {
-    // Check if the selector is in the invalid area where the strip loops around
-    const int selectorPosition = selectorPos();
-    if ( mManualSeekMode ) {
-        if ( !mPositions.contains( selectorPosition ) ) {
-            if ( selectorPosition < mMaxWidth - ITEM_WIDTH + mSeparatorPos ) {
-                scrollToFrequency( mMaxFrequency, Scroll::Shortest, 500 );
-                emit frequencyChanged( mMaxFrequency, TuneReason::ManualSeekUpdate, Scroll::Shortest );
-            } else {
-                scrollToFrequency( mMinFrequency, Scroll::Shortest, 500 );
-                emit frequencyChanged( mMinFrequency, TuneReason::ManualSeekUpdate, Scroll::Shortest );
-            }
-        }
-
-        mManualSeekTimer->start( MANUALSEEK_END_TIMEOUT );
-    }
-}
-
-/*!
- * \reimp
- */
-void RadioFrequencyStrip::updateItemPrimitive( QGraphicsItem* itemToUpdate, int itemIndex )
-{
-    QGraphicsPixmapItem* item = static_cast<QGraphicsPixmapItem*>( itemToUpdate );
-    if ( itemIndex < mFrequencyItems.count() ) {
-        item->setPixmap( mFrequencyItems.at( itemIndex )->updatePrimitive( item ) );
-    }
-}
-
-/*!
- * \reimp
- */
-QGraphicsItem* RadioFrequencyStrip::createItemPrimitive( QGraphicsItem* parent )
-{
-    return new QGraphicsPixmapItem( parent );
-}
-
-/*!
- * \reimp
- */
-void RadioFrequencyStrip::scrollPosChanged()
-{
-    if ( mManualSeekMode ) {
-        const int pos = selectorPos();
-        const uint frequency = mPositions.value( pos );
-        if ( frequency > 0 ) {
-            mFrequency = mPositions.value( pos );
-            emit frequencyChanged( mFrequency, TuneReason::ManualSeekUpdate, Scroll::Shortest );
-        }
-    }
-}
-
-/*!
- * \reimp
- */
-void RadioFrequencyStrip::resizeEvent ( QGraphicsSceneResizeEvent* event )
-{
-    LOG_METHOD;
-    RadioStripBase::resizeEvent( event );
-
-    initSelector();
-
-    const qreal height = event->newSize().height();
-    const qreal width = event->newSize().width();
-
-    mSelectorPos = width / 2;
-    mSelectorImage->setOffset( mSelectorPos - (INDICATOR_WIDTH / 2), 0.0 );
-
-    if ( mLeftButton && mRightButton ) {
-        mLeftButton->resize( height, height );
-        mRightButton->resize( height, height );
-        mRightButton->setPos( QPointF( width - height, 0 ) );
-    }
-
-    scrollToFrequency( mFrequency );
-}
-
-/*!
- * \reimp
- */
-//void RadioFrequencyStrip::showEvent( QShowEvent* event )
-//{
-//    RadioStripBase::showEvent( event );
-//    scrollToFrequency( mFrequency );
-//}
-
-/*!
- * \reimp
- */
-void RadioFrequencyStrip::changeEvent( QEvent* event )
-{
-    if ( event->type() == HbEvent::ThemeChanged ) {
-        // Update the foreground color and redraw each item
-        mForegroundColor = Qt::white;// HbColorScheme::color( TEXT_COLOR_ATTRIBUTE );
-        updateAllItems();
-    }
-
-    return RadioStripBase::changeEvent(event);
-}
-
-/*!
- * \reimp
- */
-void RadioFrequencyStrip::mousePressEvent( QGraphicsSceneMouseEvent* event )
-{
-    RadioStripBase::mousePressEvent( event );
-
-    mManualSeekTimer->stop();
-    if ( mManualSeekMode ) {
-        const bool insideStrip = rect().contains( event->pos() );
-        if ( !insideStrip ) {
-            toggleManualSeek();
-        }
-    } else {
-        mManualSeekTimer->start( MANUALSEEK_START_TIMEOUT );
-    }
-}
-
-/*!
- * \reimp
- */
-void RadioFrequencyStrip::mouseReleaseEvent( QGraphicsSceneMouseEvent* event )
-{
-    RadioStripBase::mouseReleaseEvent( event );
-
-    mManualSeekTimer->stop();
-    if ( mManualSeekMode && !isScrolling() ) {
-        mManualSeekTimer->start( MANUALSEEK_END_TIMEOUT );
-    }
-}
-
-/*!
- * \reimp
- */
-void RadioFrequencyStrip::gestureEvent( QGestureEvent* event )
-{
-    HbSwipeGesture* swipeGesture = static_cast<HbSwipeGesture*>( event->gesture( Qt::SwipeGesture ) );
-    if ( swipeGesture && !mManualSeekMode ) {
-        if ( swipeGesture->state() == Qt::GestureFinished ) {
-            if ( swipeGesture->horizontalDirection() == QSwipeGesture::Left ) {
-                emit skipRequested( StationSkip::Next );
-            } else if ( swipeGesture->horizontalDirection() == QSwipeGesture::Right ) {
-                emit skipRequested( StationSkip::Previous );
-            }
-        }
-    } else if ( mManualSeekMode ) {
-        RadioStripBase::gestureEvent( event );
+    Q_UNUSED( reason );
+    if ( newFrequency != frequency() || reason == TuneReason::Skip ) {
+        RadioFrequencyStripBase::setFrequency( newFrequency, reason, direction );
     }
 }
 
 /*!
  * \reimp
  */
-void RadioFrequencyStrip::timerEvent( QTimerEvent* event )
+bool RadioFrequencyStrip::isInitialized() const
 {
-    Q_UNUSED( event );
-    if ( mLastReportedFrequency != mFrequency ) {
-        mLastReportedFrequency = mFrequency;
-        emit frequencyChanged( mFrequency, TuneReason::ManualSeekTune, Scroll::Shortest );
-    }
+    return mUiEngine != NULL;
 }
 
 /*!
- *
+ * \reimp
  */
-void RadioFrequencyStrip::initModel()
+QList<FrequencyStrip::StationMarker> RadioFrequencyStrip::stationsInRange( uint minFrequency, uint maxFrequency ) const
 {
-    const uint minFreq = uint( qreal(mMinFrequency) / ONE_HERTZ + ROUNDER );
-    const uint maxFreq = uint( qreal(mMaxFrequency) / ONE_HERTZ + 0.9 ); // always round up
-
-    QStringList list;
-    QString freqText;
-    for ( uint i = minFreq; i <= maxFreq; ++i ) {
-        freqText = QString::number( i );
-        list.append( freqText );
-        mFrequencyItems.append( new RadioFrequencyItem( freqText ) );
+    QList<RadioStation> stations = mUiEngine->stationsInRange( minFrequency, maxFrequency );
+    QList<FrequencyStrip::StationMarker> markers;
+    foreach ( const RadioStation& station, stations ) {
+        markers.append( FrequencyStrip::StationMarker( station.frequency(), station.isFavorite() ) );
     }
-    mFrequencyItems.append( new RadioFrequencyItem( "" ) );
-    list.append( "" );
-
-    mMaxWidth = list.count() * ITEM_WIDTH;
-
-    mSeparatorPos = qreal(ITEM_WIDTH) / 2;
-    const uint minDrawableFreq = minFreq * ONE_HERTZ - HALF_HERTZ;;
-    const uint maxDrawableFreq = maxFreq * ONE_HERTZ + HALF_HERTZ;
-    mSeparatorPos += qreal( ( mMinFrequency  - minDrawableFreq ) / 2 ) / PIXEL_IN_HZ;
-    mSeparatorPos -= qreal( ( maxDrawableFreq - mMaxFrequency ) / 2 ) / PIXEL_IN_HZ;
-
-    setModel( new QStringListModel( list, this ) );
+    return markers;
 }
 
 /*!
- *
+ * \reimp
  */
-void RadioFrequencyStrip::initSelector()
-{
-    QPixmap selectorPixmap = QPixmap( QSize( SELECTOR_WIDTH, (int)size().height() ) );
-    selectorPixmap.fill( Qt::red );
-    mSelectorImage->setPixmap( selectorPixmap );
-    mSelectorImage->setZValue( SELECTOR_Z_POS );
-}
-
-/*!
- *
- */
-void RadioFrequencyStrip::initPositions()
+void RadioFrequencyStrip::emitFrequencyChanged( uint frequency, int reason, int direction )
 {
-    int prevPos = 0;
-    int nextPos = 0;
-    const int lastPos = mFrequencies.value( mMaxFrequency ).mPosition;
-    for ( int i = mFrequencies.value( mMinFrequency ).mPosition; i < lastPos; ++i ) {
-        if ( mPositions.contains( i ) ) {
-            prevPos = i;
-            const uint freq = mPositions.value( prevPos ) + mFrequencyStepSize;
-            if ( mFrequencies.contains( freq ) ) {
-                nextPos = mFrequencies.value( freq ).mPosition;
-            } else {
-                nextPos = prevPos;
-            }
-        } else {
-            const int nearestHit = ( i - prevPos ) < ( nextPos - i ) ? prevPos : nextPos;
-            mPositions.insert( i, mPositions.value( nearestHit ) );
-        }
+    int tuneReason = TuneReason::Unspecified;
+    if ( reason == FrequencyStrip::ManualSeekUpdate ) {
+        tuneReason = TuneReason::ManualSeekUpdate;
+    } else if ( reason == FrequencyStrip::ManualSeekTune ) {
+        tuneReason = TuneReason::ManualSeekTune;
     }
+
+    emit frequencyChanged( frequency, tuneReason, direction );
 }
 
 /*!
  *
  */
-void RadioFrequencyStrip::initButtons()
-{
-    mLeftButton->setZValue( SELECTOR_Z_POS );
-    mLeftButton->setObjectName( LEFT_BUTTON );
-    mRightButton->setZValue( SELECTOR_Z_POS );
-    mRightButton->setObjectName( RIGHT_BUTTON );
-
-    const qreal height = size().height();
-    const qreal width = size().width();
-    mLeftButton->resize( height, height );
-    mRightButton->resize( height, height );
-    mRightButton->setPos( QPointF( width - height, 0 ) );
-
-    QEffectList effectList;
-    effectList.append( EffectInfo( mLeftButton, ":/effects/slide_to_left.fxml", SLIDE_TO_LEFT ) );
-    effectList.append( EffectInfo( mLeftButton, ":/effects/slide_from_left.fxml", SLIDE_FROM_LEFT ) );
-    effectList.append( EffectInfo( mRightButton, ":/effects/slide_to_right.fxml", SLIDE_TO_RIGHT ) );
-    effectList.append( EffectInfo( mRightButton, ":/effects/slide_from_right.fxml", SLIDE_FROM_RIGHT ) );
-    RadioUtil::addEffects( effectList );
-}
-
-/*!
- *
- */
-void RadioFrequencyStrip::addFrequencyPos( int pos, uint frequency, RadioFrequencyItem* item )
-{
-    mFrequencies.insert( frequency, FrequencyPos( pos, item ) );
-    mPositions.insert( pos, frequency );
-}
-
-/*!
- *
- */
-void RadioFrequencyStrip::updateStationsInRange( int first, int last, bool stationRemoved )
+void RadioFrequencyStrip::skipToPrevious()
 {
-    if ( RadioUtil::scanStatus() != Scan::ScanningInMainView ) {
-        RadioStationModel& model = mUiEngine->stationModel();
-        uint frequency = 0;
-        for ( int i = first; i <= last; ++i ) {
-            frequency = model.data( model.index( i, 0, QModelIndex() ),
-                                    RadioRole::RadioStationRole ).value<RadioStation>().frequency();
-            if ( mFrequencies.contains( frequency ) ) {
-                FrequencyPos pos = mFrequencies.value( frequency );
-                updateItem( pos.mItem, 0, stationRemoved ? frequency : 0 );
-            }
-        }
-    }
-}
-
-/*!
- *
- */
-void RadioFrequencyStrip::updateItem( RadioFrequencyItem* item, uint upperRange, uint ignoredFrequency )
-{
-    if ( item ) {
-        uint frequency = item->frequency();
-        QList<RadioStation> stations;
-
-        if ( upperRange == 0 ) {
-            upperRange = frequency + HALF_HERTZ;
-        }
-
-        if ( mUiEngine ) {
-            stations = mUiEngine->stationsInRange( frequency - HALF_HERTZ, upperRange );
-            for ( int i = stations.count() - 1; ignoredFrequency > 0 && i >= 0; --i ) {
-                if ( stations[i].frequency() == ignoredFrequency ) {
-                    stations.removeAt( i );
-                    break;
-                }
-            }
-        }
-
-        QPixmap pixmap = drawPixmap( frequency, stations, item );
-        item->setPixmap( pixmap );
-
-        foreach ( const RadioStation& station, stations ) {
-            frequency = station.frequency();
-            FrequencyPos pos = mFrequencies.value( frequency );
-            mFrequencies.insert( frequency, pos );
-        }
-    }
-}
-
-/*!
- *
- */
-void RadioFrequencyStrip::updateAllItems()
-{
-    foreach ( RadioFrequencyItem* item, mFrequencyItems ) {
-        updateItem( item );
-    }
+    emit skipRequested( StationSkip::Previous );
 }
 
 /*!
  *
  */
-QPixmap RadioFrequencyStrip::drawPixmap( uint frequency, QList<RadioStation> stations, RadioFrequencyItem* item )
+void RadioFrequencyStrip::skipToPreviousFavorite()
 {
-    QPixmap pixmap( PIXMAP_WIDTH, mItemHeight );
-    pixmap.fill( Qt::transparent );
-    QPainter painter( &pixmap );
-    QPen normalPen = painter.pen();
-    QPen favoritePen = normalPen;
-    normalPen.setColor( mForegroundColor );
-    painter.setPen( normalPen );
-
-    if ( frequency == 0 ) {
-        painter.drawLine( makeTab( mSeparatorPos - 1 + ROUNDER, mItemHeight ) );
-        painter.drawLine( makeTab( mSeparatorPos + ROUNDER, mItemHeight ) );
-        return pixmap;
-    }
-
-    const QString itemText = QString::number( frequency / ONE_HERTZ );
-    const uint startFrequency = frequency - HALF_HERTZ;
-    const uint endFrequency = startFrequency + ONE_HERTZ;
-    const uint  roundedMin = int( qreal(mMinFrequency) / ONE_HERTZ + ROUNDER );
-    const uint freq = frequency / ONE_HERTZ;
-    const int diff = freq - roundedMin;
-    const qreal startPixel = diff * ITEM_WIDTH;
-    qreal pixels = 0.0;
-    const qreal leftOverlap = PIXMAP_OVERLAP / 2;
-
-    for ( uint frequency = startFrequency; frequency <= endFrequency; frequency += mFrequencyStepSize ) {
-
-        if ( frequency < mMinFrequency || frequency > mMaxFrequency ) {
-            continue;
-        }
-
-        pixels = qreal( frequency - startFrequency ) / PIXEL_IN_HZ;
-        if ( frequency % ONE_HERTZ == 0 ) {
-
-            // Draw the high frequency tab and the frequency text for the even number
-            normalPen.setWidth( 3 );
-            painter.setPen( normalPen );
-            painter.drawLine( makeTab( pixels + leftOverlap - 1, TAB_HEIGHT_BIG ) );
-            normalPen.setWidth( 1 );
-            painter.setPen( normalPen );
+    emit skipRequested( StationSkip::PreviousFavorite );
+}
 
-            // Draw the frequency text and its 00 decimals
-            painter.setFont( DECIMAL_FONT );
-            const int decimalWidth = painter.fontMetrics().width( DECIMAL_TEXT );
-            const int decimalSpace = painter.fontMetrics().leftBearing( '.' );
-            painter.setFont( FREQUENCY_FONT );
-            const int frequencyWidth = painter.fontMetrics().width( itemText );
-            const int textPosX = int( pixels + leftOverlap - ( frequencyWidth + decimalSpace + decimalWidth ) / 2 );
-            painter.drawText( QPoint( textPosX, 20 ), itemText );
-            painter.setFont( DECIMAL_FONT );
-            painter.drawText( QPoint( textPosX + frequencyWidth + decimalSpace, 20 ), DECIMAL_TEXT );
-
-        } else if ( frequency % ONE_TAB_IN_HZ == 0 ) {
-
-            // Draw the low frequency tab for the uneven number
-            painter.drawLine( makeTab( pixels + leftOverlap, TAB_HEIGHT_SMALL ) );
-
-        }
-
-        addFrequencyPos( int( startPixel + pixels + ROUNDER ), frequency, item );
-    }
+/*!
+ *
+ */
+void RadioFrequencyStrip::skipToNext()
+{
+    emit skipRequested( StationSkip::Next );
+}
 
-    // Draw favorites and local stations
-    favoritePen.setColor( Qt::yellow );
-
-    const int markerYPos = mItemHeight - 28;
-    foreach ( const RadioStation& station, stations ) {
-        const uint frequency = station.frequency();
-        pixels = qreal( frequency - startFrequency ) / PIXEL_IN_HZ;
-
-        if ( station.isFavorite() ) {
-            favoritePen.setWidth( PEN_WIDTH_FAVORITE );
-            painter.setPen( favoritePen );
-            painter.drawEllipse( int( pixels + leftOverlap - 3 ), markerYPos - 3, 6, 6 );
-        } else if ( station.isType( RadioStation::LocalStation ) ) {
-
-            favoritePen.setWidth( 1 );
-            painter.setPen( favoritePen );
-            painter.drawEllipse( int( pixels + leftOverlap - 4 ), markerYPos - 4, 8, 8 );
-        }
-    }
-
-    return pixmap;
+/*!
+ *
+ */
+void RadioFrequencyStrip::skipToNextFavorite()
+{
+    emit skipRequested( StationSkip::NextFavorite );
 }
 
 /*!
  *
  */
-QLineF RadioFrequencyStrip::makeTab( qreal pos, int height )
+void RadioFrequencyStrip::seekDown()
 {
-    return QLineF( pos, mItemHeight - height, pos, mItemHeight );
+    emit seekRequested( Seek::Down );
 }
 
-/*!
- *
- */
-void RadioFrequencyStrip::emitFrequencyChanged( uint frequency )
-{
-    if ( frequency > 0 && frequency != mFrequency ) {
-        mFrequency = frequency;
-        //TOD: Get direction
-        emit frequencyChanged( frequency, TuneReason::FrequencyStrip, Scroll::Shortest );
-    }
-}
-
-/*!
- *
- */
-int RadioFrequencyStrip::selectorPos() const
-{
-    const int pos = int( -contentWidget()->x() + mSelectorPos + ROUNDER );
-    return pos % mMaxWidth;
-}
 
 /*!
  *
  */
-void RadioFrequencyStrip::scrollToFrequency( uint frequency, Scroll::Direction direction, int time, TuneReason::Reason reason )
+void RadioFrequencyStrip::seekUp()
 {
-    int targetFreqPos = mFrequencies.value( frequency ).mPosition;
-    const int currentFreqPos = mFrequencies.value( mFrequency ).mPosition;
-    const int currentPos = int( -contentWidget()->x() + mSelectorPos + ROUNDER );
-    const bool isInSecondHalf = currentPos >= mMaxWidth - ITEM_WIDTH + mSeparatorPos;
-
-    // Special case: When there is only one favorite and the user presses skip
-    // the strip must scroll around to the same frequency.
-    if ( mFrequency == frequency && reason == TuneReason::Skip ) {
-        if ( direction == Scroll::Left ) {
-            targetFreqPos += mMaxWidth;
-        } else {
-        targetFreqPos -= mMaxWidth;
-        }
-    }
-
-    mFrequency = frequency;
-
-    qreal newPos = targetFreqPos;
-    if ( direction == Scroll::Left ) {
-
-        if ( currentFreqPos > targetFreqPos ) {
-            newPos += mMaxWidth;
-        }
-
-    } else if ( direction == Scroll::Right ) {
-
-        if ( currentFreqPos < targetFreqPos ) {
-            newPos -= mMaxWidth;
-        }
-
-    }
-
-    if ( isInSecondHalf ) {
-        newPos += mMaxWidth;
-    }
-
-    newPos -= mSelectorPos - ROUNDER;
-
-    scrollContentsTo( QPointF( newPos, 0 ), time );
+    emit seekRequested( Seek::Up );
 }
 
 /*!
- *
+ * \reimp
  */
-void RadioFrequencyStrip::hideButtons()
+bool RadioFrequencyStrip::isScanning() const
 {
-    HbEffect::start( mLeftButton, SLIDE_TO_LEFT );
-    HbEffect::start( mRightButton, SLIDE_TO_RIGHT );
+    return RadioUtil::scanStatus() == Scan::ScanningInMainView;
 }
 
 /*!
- *
+ * \reimp
  */
-void RadioFrequencyStrip::showButtons()
+uint RadioFrequencyStrip::frequencyAtIndex( int index ) const
 {
-    HbEffect::start( mLeftButton, SLIDE_FROM_LEFT );
-    HbEffect::start( mRightButton, SLIDE_FROM_RIGHT );
+    RadioStationModel& model = mUiEngine->stationModel();
+    return model.data( model.index( index, 0, QModelIndex() ),
+                       RadioRole::RadioStationRole ).value<RadioStation>().frequency();
 }