#include <HbSwipeGesture>

#include "radiostationmodel.h"

//const int KPixmapWidth = KWidth + KOneTabDistance;

const char* KSlideToLeft        = "SlideToLeft";

const char* KSlideFromLeft      = "SlideFromLeft";

const char* KSlideToRight       = "SlideToRight";

const char* KSlideFromRight     = "SlideFromRight";

const char* LEFT_BUTTON         = "tv:left_button";

const char* RIGHT_BUTTON        = "tv:right_button";

const char* TEXT_COLOR_ATTRIBUTE = "text";

const int BUTTON_HIDE_TIMEOUT = 500;

const int BUTTON_SHOW_TIMEOUT = 1000;

RadioFrequencyStrip::RadioFrequencyStrip() :

    RadioStripBase(),

    mUiEngine( NULL ),

    mMinFrequency( 87500000 ),

    mMaxFrequency( 108000000 ),

    mFrequencyStepSize( 100000 ),

    mFrequency( 87500000 ),

    mButtonTimer( NULL ),

    mButtonsVisible( true ),

    mUserIsScrolling( false ),

    mForegroundColor( Qt::white )//HbColorScheme::color( TEXT_COLOR_ATTRIBUTE ) )

    setScrollingStyle( HbScrollArea::Pan );

    initButtons();

    initEmptyItems();

    mFrequency = RadioUiEngine::lastTunedFrequency();

    scrollToFrequency( mFrequency, 0 );

        mLeftButtonIcon.setColor( Qt::white );

        mRightButtonIcon.setColor( Qt::white );

void RadioFrequencyStrip::init( RadioUiEngine* engine )

    mUiEngine = engine;

    mMinFrequency       = mUiEngine->minFrequency();

    mMaxFrequency       = mUiEngine->maxFrequency();

    mFrequencyStepSize  = mUiEngine->frequencyStepSize();

    mFrequency          = mUiEngine->currentFrequency();

    scrollToFrequency( mFrequency, 0 );

    mButtonTimer = new QTimer( this );

    mButtonTimer->setInterval( BUTTON_HIDE_TIMEOUT );

    mButtonTimer->setSingleShot( true );

    connectAndTest( mButtonTimer, SIGNAL(timeout()),

                    this,         SLOT(toggleButtons()) );

    connectAndTest( mLeftButton,    SIGNAL(clicked()),

                    this,           SLOT(handleLeftButton()) );

    connectAndTest( mRightButton,   SIGNAL(clicked()),

                    this,           SLOT(handleRightButton()) );

    connectAndTest( mLeftButton,    SIGNAL(longPress(QPointF)),

                    this,           SLOT(handleLongLeftButton()) );

    connectAndTest( mRightButton,   SIGNAL(longPress(QPointF)),

                    this,           SLOT(handleLongRightButton()) );

    connectAndTest( this,           SIGNAL(scrollingEnded()),

                    this,           SLOT(checkIllegalPos()) );

    grabGesture( Qt::SwipeGesture );

    //TODO: Remove. Stepsize hardcoded to 100 Khz in europe region during demo

    if ( mFrequencyStepSize < K100Khz ) {

        mFrequencyStepSize = K100Khz;

    RadioStationModel* stationModel = &mUiEngine->stationModel();

    connectAndTest( stationModel,   SIGNAL(rowsInserted(QModelIndex,int,int)),

                    this,           SLOT(updateStation(QModelIndex,int,int)) );

    connectAndTest( stationModel,   SIGNAL(rowsRemoved(QModelIndex,int,int)),

                    this,           SLOT(updateStation(QModelIndex,int,int)) );

    connectAndTest( stationModel,   SIGNAL(modelReset()),

                    this,           SLOT(initEmptyItems()) );

    initPositions();

    void updateItems();

void RadioFrequencyStrip::setFrequency( const uint frequency, int reason )

    LOG_FORMAT( "RadioFrequencyStrip::setFrequency, frequency: %d, reason: %d", frequency, reason );

    if ( reason != TuneReason::FrequencyStrip &&            // Not sent by the FrequencyStrip

         frequency != mFrequency &&                         // Different from the current

         mFrequencies.contains( frequency ) )               // 0 frequency means any illegal value

    {

        scrollToFrequency( frequency, mAutoScrollTime );

        if ( reason != TuneReason::Skip && reason != TuneReason::StationScan ) {

            emitFrequencyChanged( frequency );

        }

    }

uint RadioFrequencyStrip::frequency() const

    return mFrequency;

void RadioFrequencyStrip::updateFavorite( const RadioStation& station )

    mButtonTimer->stop();

    if ( isScanning ) {

        scrollToFrequency( mMinFrequency, mAutoScrollTime );

        hideButtons();

    } else {

        showButtons();

void RadioFrequencyStrip::updateStation( const QModelIndex& parent, int first, int last )

    Q_UNUSED( parent );

    RadioStationModel& model = mUiEngine->stationModel();

    uint frequency = 0;

    for ( int i = first; i <= last; ++i ) {

        frequency = model.data( model.index( i, 0, QModelIndex() ),

                                RadioStationModel::RadioStationRole ).value<RadioStation>().frequency();

        if ( mFrequencies.contains( frequency ) ) {

            FrequencyPos pos = mFrequencies.value( frequency );

            updateFavorites( pos.mItem );

        }

    }

void RadioFrequencyStrip::initEmptyItems()

    LOG_METHOD;

    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 );

 */

void RadioFrequencyStrip::handleLongLeftButton()

{

    emit seekRequested( Seeking::Down );

}

/*!

 * Private slot

void RadioFrequencyStrip::handleRightButton()

    emit skipRequested( StationSkip::NextFavorite );

}

/*!

 * Private slot

 */

void RadioFrequencyStrip::handleLongRightButton()

{

    emit seekRequested( Seeking::Up );

    if ( mButtonsVisible ) {

        hideButtons();

    } else {

        showButtons();

    }

}

/*!

 * Private slot

 */

void RadioFrequencyStrip::checkIllegalPos()

{

    // Check if the selector is in the invalid area where the strip loops around

    const int selectorPosition = selectorPos();

    if ( !mPositions.contains( selectorPosition ) ) {

        if ( selectorPosition < mMaxWidth - KWidth + mSeparatorPos ) {

            scrollToFrequency( mMaxFrequency, 500 );

            emitFrequencyChanged( mMaxFrequency );

        } else {

            scrollToFrequency( mMinFrequency, 500 );

            emitFrequencyChanged( mMinFrequency );

        }

    }

    if ( mUserIsScrolling ) {

        mForegroundColor = Qt::white;// HbColorScheme::color( TEXT_COLOR_ATTRIBUTE );

        updateItems();

    mUserIsScrolling = true;

    mButtonTimer->start( BUTTON_HIDE_TIMEOUT );

    mUserIsScrolling = false;

    if ( !mButtonsVisible ) {

        mButtonTimer->start( BUTTON_SHOW_TIMEOUT );

    }

}

/*!

 * \reimp

 */

void RadioFrequencyStrip::gestureEvent( QGestureEvent* event )

{

    if ( HbSwipeGesture* gesture = static_cast<HbSwipeGesture*>( event->gesture( Qt::SwipeGesture ) ) ) {

        if ( gesture->state() == Qt::GestureFinished ) {

            if ( gesture->horizontalDirection() == QSwipeGesture::Left ) {

                emit skipRequested( StationSkip::Next );

            } else if ( gesture->horizontalDirection() == QSwipeGesture::Right ) {

                emit skipRequested( StationSkip::Previous );

            }

        }

    } else {

        RadioStripBase::gestureEvent( event );

    }