#include "radioutil.h"

#include "radiouiloader.h"

const int TAB_HEIGHT_SMALL = 10;

const int TAB_HEIGHT_BIG = 15;

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 int STRIP_HEIGHT = 50;

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 int MANUALSEEK_START_TIMEOUT = 400;

const int MANUALSEEK_END_TIMEOUT = 2000;

const int MANUALSEEK_SIGNAL_DELAY = 300;

    return QLineF( pos, STRIP_HEIGHT - height, pos, STRIP_HEIGHT );

    mLeftButton( 0 ),

    mRightButton( 0 ),

    mManualSeekTimer( NULL ),

    mManualSeekMode( false ),

    mLastReportedFrequency( 0 ),

    mManualSeekTimerId( 0 ),

    RadioUtil::setFrequencyStrip( this );

    setScrollingStyle( HbScrollArea::PanWithFollowOn );

    setItemSize( QSizeF( ITEM_WIDTH + PIXMAP_OVERLAP / 2, STRIP_HEIGHT ) );

    setOverlap( PIXMAP_OVERLAP / 2 );

    initEmptyItems();

    initPositions();

void RadioFrequencyStrip::init( RadioUiEngine* engine, RadioUiLoader& uiLoader )

    mLeftButton = uiLoader.findWidget<HbPushButton>( DOCML::MV_NAME_PREV_BUTTON );

    mRightButton = uiLoader.findWidget<HbPushButton>( DOCML::MV_NAME_NEXT_BUTTON );

    initButtons();

    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()),

    Radio::connect( mRightButton,   SIGNAL(clicked()),

    Radio::connect( mLeftButton,    SIGNAL(longPress(QPointF)),

    Radio::connect( mRightButton,   SIGNAL(longPress(QPointF)),

    Radio::connect( this,           SIGNAL(scrollingEnded()),

                    this,           SLOT(handleScrollingEnd()) );

    if ( mFrequencyStepSize < ONE_HUNDRED_KHZ ) {

        mFrequencyStepSize = ONE_HUNDRED_KHZ;

    Radio::connect( stationModel,   SIGNAL(rowsInserted(QModelIndex,int,int)),

    Radio::connect( stationModel,   SIGNAL(rowsAboutToBeRemoved(QModelIndex,int,int)),

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

    Radio::connect( stationModel,   SIGNAL(modelReset()),

    updateAllItems();

    showButtons();

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

    Q_UNUSED( reason );

    if ( mFrequencies.contains( frequency ) ) {

        if ( frequency != mFrequency || reason == TuneReason::Skip ) {

            scrollToFrequency( frequency, direction, mAutoScrollTime, RadioUtil::tuneReason( reason ) );

 *

 */

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

}

/*!

    updateItem( pos.mItem );

    mManualSeekTimer->stop();

        initEmptyItems();

        scrollToFrequency( mMinFrequency, Scroll::Shortest, mAutoScrollTime );

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

{

    Q_UNUSED( parent );

    updateStationsInRange( first, last, true );

}

/*!

 * Private slot

 *

 */

    updateStationsInRange( first, last );

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

        }

    emit seekRequested( Seek::Down );

    emit seekRequested( Seek::Up );

 *

void RadioFrequencyStrip::toggleManualSeek()

    mManualSeekMode = !mManualSeekMode;

    emit manualSeekChanged( mManualSeekMode );

    if ( mManualSeekMode ) {

        mManualSeekTimerId = startTimer( MANUALSEEK_SIGNAL_DELAY );

        killTimer( mManualSeekTimerId );

        mManualSeekTimerId = 0;

void RadioFrequencyStrip::handleScrollingEnd()

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

    if ( mManualSeekMode ) {

        const uint frequency = mPositions.value( pos );

        if ( frequency > 0 ) {

            mFrequency = mPositions.value( pos );

            emit frequencyChanged( mFrequency, TuneReason::ManualSeekUpdate, Scroll::Shortest );

        }

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

//void RadioFrequencyStrip::showEvent( QShowEvent* event )

//{

//    RadioStripBase::showEvent( event );

//    scrollToFrequency( mFrequency );

//}

        updateAllItems();

    return RadioStripBase::changeEvent(event);

    mManualSeekTimer->stop();

    if ( !mManualSeekMode ) {

        mManualSeekTimer->start( MANUALSEEK_START_TIMEOUT );

    }

    mManualSeekTimer->stop();

    if ( mManualSeekMode && !isScrolling() ) {

        mManualSeekTimer->start( MANUALSEEK_END_TIMEOUT );

    HbSwipeGesture* swipeGesture = static_cast<HbSwipeGesture*>( event->gesture( Qt::SwipeGesture ) );

    if ( swipeGesture && !mManualSeekMode ) {

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

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

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

    } else if ( mManualSeekMode ) {

 * \reimp

 */

void RadioFrequencyStrip::timerEvent( QTimerEvent* event )

{

    Q_UNUSED( event );

    if ( mLastReportedFrequency != mFrequency ) {

        mLastReportedFrequency = mFrequency;

        emit frequencyChanged( mFrequency, TuneReason::ManualSeekTune, Scroll::Shortest );

    }

}