/*
* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:  FM Radio home screen widget
*
*/

// System includes
#include <HbPushButton>
#include <HbLabel>
#include <HbDocumentLoader>
#include <HbFrameDrawer>
#include <HbFrameItem>
#include <HbIcon>
#include <HbIconAnimationManager>
#include <HbIconAnimationDefinition>
#include <HbColorScheme>
#include <HbMarqueeItem>
#include <HbStyleLoader>
#include <QGraphicsLinearLayout>
#include <QGraphicsItem>
#include <QDesktopServices>

// User includes
#include "fmradiohswidget.h"
#include "fmradiohswidgetprocesshandler.h"
#include "fmradiohswidgetprofilereader.h"
#include "fmradiohswidgetradioserviceclient.h"
#include "radioservicedef.h"
#include "radio_global.h"

/*!
    \ingroup group_fmradiohs_widget
    \class FmRadioHsWidget
    \brief Example implementation for home screen widget.

    FmRadioHsWidget derived from the HbWidget and implements 
    needed functions for the home screen widget. 
*/

// ======== MEMBER FUNCTIONS ========

/*!
    Constructs a widget which is a child of \a parent, with widget flags set to \a flags.
*/
FmRadioHsWidget::FmRadioHsWidget(QGraphicsItem* parent, Qt::WindowFlags flags)
    : HbWidget(parent, flags),
      mRadioPushButton(0),
      mPreviousPushButton(0),
      mPlayPushButton(0),
      mNextPushButton(0),
      mInformationFirstRowLabel(0),
      mInformationSecondRowLabel(0),
      mFmRadioState(Undefined),
      mPlayButtonState(PlayEnabled),
      mIsFavoriteChannels(false),
      mRadioInformation(QHash<QString, QString>()),
      mProcessHandler(0),
      mProfileMonitor(new FmRadioHsWidgetProfileReader(this)),
      mRadioServiceClient(new FmRadioHsWidgetRadioServiceClient(this))
{
    connect(mRadioServiceClient, SIGNAL(radioInformationChanged(int, QVariant)), this,
        SLOT(handleRadioInformationChange(int, QVariant)));
    connect(mRadioServiceClient, SIGNAL(radioStateChanged(QVariant)), this,
        SLOT(handleRadioStateChange(QVariant)));
    connect(mProfileMonitor, SIGNAL(radioRunning(QVariant)), this,
        SLOT(handleRadioStateChange(QVariant)));
    
    load(KDocml);
    
    handleRadioStateChange(mProfileMonitor->radioStatus());

    //mRadioServiceClient->init();
}

/*!
    Destructor
*/
FmRadioHsWidget::~FmRadioHsWidget()
{
}

/*!
    Called when widget is shown in the home screen
*/
void FmRadioHsWidget::onShow()
{
}

/*!
    Called when widget is hidden from the home screen
*/
void FmRadioHsWidget::onHide()
{
}

/*!
    Loads docml files.
*/
void FmRadioHsWidget::load(const QString docml)
{
    bool loaded = false;

    HbDocumentLoader *documentLoader = new HbDocumentLoader();
    documentLoader->reset();
    documentLoader->load(docml, &loaded);

    if (loaded) {
        HbWidget *widget = qobject_cast<HbWidget*> (documentLoader->findWidget(
            KDocmlObjectNameMainLayout));

        HbFrameItem *frameItem = NULL;

        if (widget) {
            //HbWidget *view = qobject_cast<HbWidget*> (widget);
            QGraphicsLinearLayout *mWidgetLayout = new QGraphicsLinearLayout(Qt::Vertical, this);

            HbFrameDrawer *drawer = new HbFrameDrawer("qtg_fr_hswidget_normal",
                HbFrameDrawer::NinePieces);
            frameItem = new HbFrameItem(drawer, widget);
            frameItem->setPreferredSize(widget->preferredSize());

            mWidgetLayout->addItem(widget);
            setLayout(mWidgetLayout);
        }

        mRadioPushButton = qobject_cast<HbPushButton*> (documentLoader->findWidget(
            KDocmlObjectNameRadioIconPushButton));
        if (mRadioPushButton) {
            if (frameItem) {
                frameItem->stackBefore(mRadioPushButton);
            }
            mRadioPushButton->setBackground(HbIcon("qtg_large_radio"));
            mRadioPushButton->icon().setSize(mRadioPushButton->preferredSize());
            QObject::connect(mRadioPushButton, SIGNAL(clicked()), this, SLOT(radioToForeground()));
        }

        mVerticalSeparatorLabel = qobject_cast<HbLabel*> (documentLoader->findWidget(
            KDocmlObjectNameVerticalSeparatorLabel));
        if (mVerticalSeparatorLabel) {
            mVerticalSeparatorLabel->setIcon(HbIcon("qtg_graf_divider_v_thin"));
        }
        
        HbWidget *controlAreaLayoutWidget = qobject_cast<HbWidget*> (documentLoader->findWidget(
            KDocmlObjectNameControlAreaLayout));
        if (controlAreaLayoutWidget) {
        }

        mPreviousPushButton = qobject_cast<HbPushButton *> (documentLoader->findWidget(
            KDocmlObjectNamePreviousPushButton));
        if (mPreviousPushButton) {
            changeControlButtonFrameBackground(false, Left, mPreviousPushButton);
/*
            HbFrameDrawer *previousButtonFrameDrawer = new HbFrameDrawer("qtg_fr_hsbutton_disabled",
                  HbFrameDrawer::ThreePiecesHorizontal);
            previousButtonFrameDrawer->setFileNameSuffixList(QStringList() << "_l" << "_c" << "_cr");
            mPreviousPushButton->setFrameBackground(previousButtonFrameDrawer);
*/            QObject::connect(mPreviousPushButton, SIGNAL(clicked()), this, SLOT(previousChannel()));
        }

        mPlayPushButton = qobject_cast<HbPushButton *> (documentLoader->findWidget(
            KDocmlObjectNamePlayPushButton));
        if (mPlayPushButton) {
            changeControlButtonFrameBackground(false, Center, mPlayPushButton);
/*            HbFrameDrawer *playButtonFrameDrawer = new HbFrameDrawer("qtg_fr_hsbutton_disabled",
                  HbFrameDrawer::ThreePiecesHorizontal);
            playButtonFrameDrawer->setFileNameSuffixList(QStringList() << "_cl" << "_c" << "_cr");
            mPlayPushButton->setFrameBackground(playButtonFrameDrawer);
*/            QObject::connect(mPlayPushButton, SIGNAL(clicked()), this, SLOT(radioToBackground()));
        }

        mNextPushButton = qobject_cast<HbPushButton *> (documentLoader->findWidget(
            KDocmlObjectNameNextPushButton));
        if (mNextPushButton) {
            changeControlButtonFrameBackground(false, Right, mNextPushButton);
/*            HbFrameDrawer *nextButtonFrameDrawer = new HbFrameDrawer("qtg_fr_hsbutton_disabled",
                  HbFrameDrawer::ThreePiecesHorizontal);
            nextButtonFrameDrawer->setFileNameSuffixList(QStringList() << "_cl" << "_c" << "_r");
            mNextPushButton->setFrameBackground(nextButtonFrameDrawer);
*/            QObject::connect(mNextPushButton, SIGNAL(clicked()), this, SLOT(nextChannel()));
        }
        
        //bool b = QFile::exists(KCss);
        bool a = HbStyleLoader::registerFilePath(KCss);

        mInformationAreaTwoRowsLayout = qobject_cast<QGraphicsWidget *> (
            documentLoader->findObject(KDocmlObjectNameTwoRowsLayout));
        if (mInformationAreaTwoRowsLayout) {
            /*
            QGraphicsLinearLayout *layout = new QGraphicsLinearLayout(Qt::Vertical, mInformationAreaTwoRowsLayout);
            mInformationFirstRowMarquee = new HbMarqueeItem();
            HbStyle::setItemName(mInformationFirstRowMarquee, "marquee1");
            mInformationFirstRowMarquee->setObjectName("marquee1");
            mInformationFirstRowMarquee->setText(
                "Long text");
            mInformationFirstRowMarquee->setLoopCount(-1);
            mInformationFirstRowMarquee->startAnimation();
            HbFontSpec fs(HbFontSpec::Secondary);
            mInformationFirstRowMarquee->setFontSpec(fs);
            mInformationFirstRowMarquee->setTextColor(HbColorScheme::color("qtc_hs_list_item_title"));
            mInformationFirstRowMarquee->setPreferredSize(layout->preferredSize());
            layout->addItem(mInformationFirstRowMarquee);
         
            mInformationSecondRowMarquee = new HbMarqueeItem();
            mInformationSecondRowMarquee->setObjectName("marquee2");
            mInformationSecondRowMarquee->setText(
                "Long text to test marquee, Long text to test marquee");
            mInformationSecondRowMarquee->setLoopCount(-1);
            mInformationSecondRowMarquee->startAnimation();
            mInformationSecondRowMarquee->setFontSpec(fs);
            mInformationSecondRowMarquee->setTextColor(HbColorScheme::color("qtc_hs_list_item_title"));
            mInformationSecondRowMarquee->setPreferredSize(layout->preferredSize());
            layout->addItem(mInformationSecondRowMarquee);
            */
        }

        mInformationAreaOneRowLayout = qobject_cast<QGraphicsWidget *> (documentLoader->findObject(
            KDocmlObjectNameOneRowLayout));
        if (mInformationAreaOneRowLayout) {
            /*
            QGraphicsLinearLayout *layout = new QGraphicsLinearLayout(Qt::Vertical, mInformationAreaOneRowLayout);
            mInformationLonelyRowMarquee = new HbMarqueeItem();
            mInformationLonelyRowMarquee->setObjectName("marquee3");
            HbStyle::setItemName(mInformationLonelyRowMarquee, "marquee3");
            mInformationLonelyRowMarquee->setText(
                "Long text");
            mInformationLonelyRowMarquee->setLoopCount(-1);
            mInformationLonelyRowMarquee->startAnimation();
            HbFontSpec fs(HbFontSpec::Secondary);
            mInformationLonelyRowMarquee->setFontSpec(fs);
            mInformationLonelyRowMarquee->setTextColor(HbColorScheme::color("qtc_hs_list_item_title"));
            mInformationLonelyRowMarquee->setPreferredSize(layout->preferredSize());
            layout->addItem(mInformationLonelyRowMarquee);
            */
        }

        mInformationAreaAnimationLayout = qobject_cast<QGraphicsWidget *> (
            documentLoader->findObject(QString(KDocmlObjectNameAnimationLayout)));
        if (mInformationAreaAnimationLayout) {
        }
        
        mInformationFirstRowLabel = qobject_cast<HbLabel *> (documentLoader->findWidget(
            KDocmlObjectNameFirstRowLabel));
        if (mInformationFirstRowLabel) {
            mInformationFirstRowLabel->setTextColor(HbColorScheme::color("qtc_hs_list_item_title"));
        }

        mInformationSecondRowLabel = qobject_cast<HbLabel *> (documentLoader->findWidget(
            KDocmlObjectNameSecondRowLabel));
        if (mInformationSecondRowLabel) {
            mInformationSecondRowLabel->setTextColor(HbColorScheme::color("qtc_hs_list_item_content"));
        }

        mInformationLonelyRowLabel = qobject_cast<HbLabel *> (documentLoader->findWidget(
            KDocmlObjectNameLonelyRowLabel));
        if (mInformationLonelyRowLabel) {
            mInformationLonelyRowLabel->setTextColor(HbColorScheme::color("qtc_hs_list_item_content"));
        }

        mAnimationIcon = qobject_cast<HbLabel *> (documentLoader->findWidget(
            KDocmlObjectNameAnimationIcon));
        if (mAnimationIcon) {
            // Use animation manager to define the frame-by-frame animation.
            HbIconAnimationManager *animationManager = HbIconAnimationManager::global();

            // Create animation definition.
            HbIconAnimationDefinition animationDefinition;
            QList<HbIconAnimationDefinition::AnimationFrame> animationFrameList;

            HbIconAnimationDefinition::AnimationFrame animationFrame;
            QString animationFrameIconName;
            QString animationFrameIconNamePrefix = "qtg_anim_loading_";
            for (int i = 1; i < 11; i++) {
                animationFrame.duration = 100;
                animationFrameIconName.clear();
                animationFrameIconName.append(animationFrameIconNamePrefix);
                animationFrameIconName.append(animationFrameIconName.number(i));
                animationFrame.iconName = animationFrameIconName;
                animationFrameList.append(animationFrame);
            }
            animationDefinition.setPlayMode(HbIconAnimationDefinition::Loop);
            animationDefinition.setFrameList(animationFrameList);
            animationManager->addDefinition("animation", animationDefinition);

            // Construct an icon using the animation definition.
            HbIcon icon("animation");
            
            mAnimationIcon->setIcon(icon);
        }

    }
    delete documentLoader;
}

/*!
 Slot for grouping events.
 */
bool FmRadioHsWidget::eventFilter(QObject */*target*/, QEvent */*event*/)
 {
// This event filter is used to get events from information area layout and from it's components.
// Not yet implemented.   
/*
    if (target == mFrequencyLabel) {
        if (event->type() == QEvent::MouseButtonRelease) {
            qDebug() << "MouseButtonRelease";
            return true;
        }
        else if (event->type() == QEvent::MouseButtonPress) {
            qDebug() << "MouseButtonPress";
            return true;
        }
        else if (event->type() == QEvent::KeyPress) {
            qDebug() << "KeyPress";
            return true;
        }
        else {
            return false;
        }
    }
    else {
        // pass the event on to the parent class
        return HbWidget::eventFilter(target, event);
    }
*/
    return false;
}

/*!
 Mute FM Radio audio.
 */
void FmRadioHsWidget::mute()
{
    mRadioServiceClient->doControlFmRadioAudio(FmRadioHsWidgetRadioServiceClient::Mute);
    //handleRadioStateChange(QVariant(NotControllingAudio));
}

/*!
 Unmute FM Radio audio.
 */
void FmRadioHsWidget::unMute()
{
    mRadioServiceClient->doControlFmRadioAudio(FmRadioHsWidgetRadioServiceClient::Unmute);
    //handleRadioStateChange(QVariant(ControllingAudio));
}

/*!
 Slot for previous button clicked.
 */
void FmRadioHsWidget::previousChannel()
{
    mRadioServiceClient->doChangeFmRadioChannel(FmRadioHsWidgetRadioServiceClient::PreviousFavouriteChannel);
}

/*!
 Slot for next button clicked.
 */
void FmRadioHsWidget::nextChannel()
{
    mRadioServiceClient->doChangeFmRadioChannel(FmRadioHsWidgetRadioServiceClient::NextFavouriteChannel);
}

/*!
 Slot for radio button clicked.
 */
void FmRadioHsWidget::radioToForeground()
{
    if (mFmRadioState == NotRunning) {
        handleRadioStateChange(QVariant(Starting));
        mRadioServiceClient->startMonitoring(FmRadioHsWidgetRadioServiceClient::ToForeground);
    }
    else {
        mRadioServiceClient->doChangeFmRadioVisibility(
            FmRadioHsWidgetRadioServiceClient::ToForeground);
    }
}

/*!
 Slot for radio button clicked.
 */
void FmRadioHsWidget::radioToBackground()
{
    if (mFmRadioState == NotRunning) {
        handleRadioStateChange(QVariant(Starting));
        mRadioServiceClient->startMonitoring(FmRadioHsWidgetRadioServiceClient::ToBackground);
    }
    else if (mFmRadioState == Starting) {
        
    }
    else {
        mRadioServiceClient->doChangeFmRadioVisibility(
            FmRadioHsWidgetRadioServiceClient::ToBackground);
    }
}

/*!
 Opening of url to the browser.
 
 /param url Url to be opened.
 */
bool FmRadioHsWidget::openUrl(QUrl url)
{
    return QDesktopServices::openUrl(url);
}

/*!
 Handles changes in FM Radio information.
 
 /param type Type of changed information.
 /param value Information content.
 */
void FmRadioHsWidget::handleRadioInformationChange(
    int notificationId, QVariant value)
{
    if (!value.isValid()) {
        return;
    }
    switch ( notificationId ) {

        case RadioServiceNotification::FavoriteCount:
            if (value.canConvert(QVariant::Int)) {
                int favoriteCount = value.toInt();
                mIsFavoriteChannels = favoriteCount > 0 ? true : false;
                changeChannelButtonsEnabledState(mIsFavoriteChannels);
            }
            break;

        case RadioServiceNotification::RadioStatus:
            if (value.canConvert(QVariant::Int)) {
                int status = value.toInt();
                switch (status) {
                case RadioStatus::Playing:
                    handleRadioStateChange(QVariant(ControllingAudio));
                    break;
                case RadioStatus::Muted:
                    handleRadioStateChange(QVariant(NotControllingAudio));
                    break;
                case RadioStatus::Seeking:
                    handleRadioStateChange(QVariant(Seeking));
                    break;
                case RadioStatus::NoAntenna:
                    handleRadioStateChange(QVariant(AntennaNotConnected));
                    break;                    
                default:
                    break;
                }
            }
            break;

        case RadioServiceNotification::Frequency:
            if (value.canConvert(QVariant::UInt)) {
                const uint frequency = value.toUInt();
                QString freqString;
                freqString.sprintf("%.1f", qreal(frequency) / KFrequencyMultiplier);
                bool frequencyCleared = false;
                if (mRadioInformation.contains(KRadioInformationFrequency)
                    && mRadioInformation[KRadioInformationFrequency].compare(freqString) != 0) {
                    clearRadioInformation();
                    frequencyCleared = true;
                }
                bool frequencyUpdated = updateRadioInformation(KRadioInformationFrequency, freqString);
                if (frequencyCleared || frequencyUpdated) {
                    radioInformationChanged();
                }
            }
        break;

        case RadioServiceNotification::Name:
            if (value.canConvert(QVariant::String)) {
                if (updateRadioInformation(KRadioInformationStationName, value.toString())) {
                    radioInformationChanged();
                }
            }
        break;

        case RadioServiceNotification::Genre:
            if (value.canConvert(QVariant::String)) {
                if (updateRadioInformation(KRadioInformationPty, value.toString())) {
                    radioInformationChanged();
                }
            }
        break;

        case RadioServiceNotification::RadioText:
            if (value.canConvert(QVariant::String)) {
                if (updateRadioInformation(KRadioInformationRt, value.toString())) {
                    radioInformationChanged();
                }
            }
        break;

        case RadioServiceNotification::HomePage:
            if (value.canConvert(QVariant::String)) {
                if (updateRadioInformation(KRadioInformationHomePage, value.toString())) {
                    radioInformationChanged();
                }
            }
        break;
        
        case RadioServiceNotification::Song:
            if (value.canConvert(QVariant::String)) {
                if (updateRadioInformation(KRadioInformationSong, value.toString())) {
                    radioInformationChanged();
                }
            }
        break;


/*    case FmRadioHsWidgetRadioServiceClient::InformationTypeCallSign:
        if (updateRadioInformation(KRadioInformationCallSign, informationText)) {

        }
        break;
*/
/*    case FmRadioHsWidgetRadioServiceClient::InformationTypeDynamicPsName:
        if (updateRadioInformation(KRadioInformationDynamicPsName,
            informationText)) {

        }
        break;
        */
        
    default:
        break;
    }
}

/*!
 Check if the the radio information is changed. If it is changed update it.
 
 /param informationType Type of the information. 
 /param information  Information text.
 
 /return bool If information is updated, return true. Return false otherwise.
 */
bool FmRadioHsWidget::updateRadioInformation(const QString informationType, QString information)
{
    // If hash contains this type
    if (mRadioInformation.contains(informationType)) {
        // If new information is empty
        if (information.isEmpty()) {
            // Remove it from the hash
            mRadioInformation.remove(informationType);
            // Return true to indicate the change
            return true;
        }
        // If new information differs from the old one
        if (mRadioInformation[informationType].compare(information) != 0) {
            // Update the information
            mRadioInformation[informationType] = information;
            // And return true to indicate the change
            return true;
        }
    } else { // Hash do not contain the information
        // If new information is not empty
        if (!information.isEmpty()) {
            // Add it to the hash
            mRadioInformation[informationType] = information;
            // Return true to indicate the change
            return true;
        }
    }
    // Return false to indicate that nothing changed
    return false;
}

/*!
 Formatting radio information texts after change. 
 */
void FmRadioHsWidget::radioInformationChanged()
{
    mRadioInformationFirstRow = "";
    mRadioInformationSecondRow = "";

    // Lets formulate the first row, first station name
    if (mRadioInformation.contains(KRadioInformationStationName)) {
        mRadioInformationFirstRow.append(mRadioInformation.value(KRadioInformationStationName));
    }
    // Second call sign
    if (mRadioInformation.contains(KRadioInformationCallSign)) {
        mRadioInformationFirstRow.append(" " + mRadioInformation.value(KRadioInformationCallSign));
    }
    // Third frequency
    if (mRadioInformation.contains(KRadioInformationFrequency)) {
        mRadioInformationFirstRow.append(" " + mRadioInformation.value(KRadioInformationFrequency)
            + " " + KMhzText);
    }
    // Second row of information contains first rt
    if (mRadioInformation.contains(KRadioInformationRt)) {
        mRadioInformationSecondRow.append(mRadioInformation.value(KRadioInformationRt));
    }
    // Second is dynamic ps name
    if (mRadioInformation.contains(KRadioInformationDynamicPsName)) {
        mRadioInformationSecondRow.append(" " + mRadioInformation.value(
            KRadioInformationDynamicPsName));
    }
    // Third is pty 
    if (mRadioInformation.contains(KRadioInformationPty)) {
        mRadioInformationSecondRow.append(" " + mRadioInformation.value(KRadioInformationPty));
    }

    if (mRadioInformationSecondRow.isEmpty()) {
        mInformationLonelyRowLabel->setPlainText(mRadioInformationFirstRow);
        changeInformationAreaLayout(OneRow);
    }
    else {
        mInformationFirstRowLabel->setPlainText(mRadioInformationFirstRow);
        mInformationSecondRowLabel->setPlainText(mRadioInformationSecondRow);
        changeInformationAreaLayout(TwoRows);
    }
}

/*!
 Clears the radio station information. For example, when the channel is
 changed, old information should be cleared.
 */
void FmRadioHsWidget::clearRadioInformation()
{
    if (!mRadioInformation.isEmpty()) {
        mRadioInformation.clear();
    }
}

/*!
 Handles changes in FM Radio state.
 
 /param value Information content.
 */
void FmRadioHsWidget::handleRadioStateChange(QVariant value)
{
    int state;
    if (value.canConvert(QVariant::Int)) {
        state = value.toInt();
    } else {
        return;
    }
    
    if (state == mFmRadioState) {
        // State did not change, so return.
        return;
    }
    
    switch (state) {
    case Undefined:
        // TODO: Some error occured because we do not have the state information. Handle this.
        mFmRadioState = Undefined;
        break;
    case NotRunning:
        mFmRadioState = NotRunning;
        mRadioServiceClient->stopMonitoring();
        //changeControlButtonState(ChannelsDisabledPlay);
        QObject::disconnect(mPlayPushButton, SIGNAL(clicked()), this,
            SLOT(unMute()));
        QObject::disconnect(mPlayPushButton, SIGNAL(clicked()), this,
            SLOT(mute()));
        QObject::connect(mPlayPushButton, SIGNAL(clicked()), this,
            SLOT(radioToBackground()));
        changePlayButtonState(PlayEnabled);
        mIsFavoriteChannels = false;
        changeChannelButtonsEnabledState(false);
        mInformationFirstRowLabel->setPlainText("");
        mInformationSecondRowLabel->setPlainText("");
        mInformationLonelyRowLabel->setPlainText(KFmRadioText);
        changeInformationAreaLayout(OneRow);
        break;
    case Starting:
        mFmRadioState = Starting;
        //changeControlButtonState(ChannelsDisabledStop);
        changePlayButtonState(StopDisabled);
        // TODO: What should the stop button do? Should it close the radio?
        changeChannelButtonsEnabledState(false);
        changeInformationAreaLayout(Animation);
        break;
    case Running:
        mFmRadioState = Running;
        mRadioServiceClient->startMonitoring(FmRadioHsWidgetRadioServiceClient::DoNotChange);
        //changeControlButtonState(ChannelsEnabledStop);
        QObject::disconnect(mPlayPushButton, SIGNAL(clicked()), this,
            SLOT(radioToBackground()));
        QObject::disconnect(mPlayPushButton, SIGNAL(clicked()), this,
            SLOT(unMute()));
        QObject::connect(mPlayPushButton, SIGNAL(clicked()), this,
            SLOT(mute()));
        changePlayButtonState(StopEnabled);
        changeChannelButtonsEnabledState(mIsFavoriteChannels);
        changeInformationAreaLayout(OneRow);
        break;
    case ControllingAudio:
        mFmRadioState = ControllingAudio;
        //changeControlButtonState(ChannelsEnabledStop);
        QObject::disconnect(mPlayPushButton, SIGNAL(clicked()), this,
            SLOT(radioToBackground()));
        QObject::disconnect(mPlayPushButton, SIGNAL(clicked()), this,
            SLOT(unMute()));
        QObject::connect(mPlayPushButton, SIGNAL(clicked()), this,
            SLOT(mute()));
        changePlayButtonState(StopEnabled);
        changeChannelButtonsEnabledState(mIsFavoriteChannels);
        radioInformationChanged();
        break;
    case NotControllingAudio:
        mFmRadioState = NotControllingAudio;
        //changeControlButtonState(ChannelsEnabledPlay);
        QObject::disconnect(mPlayPushButton, SIGNAL(clicked()), this,
            SLOT(radioToBackground()));
        QObject::disconnect(mPlayPushButton, SIGNAL(clicked()), this,
            SLOT(mute()));
        QObject::connect(mPlayPushButton, SIGNAL(clicked()), this,
            SLOT(unMute()));
        changePlayButtonState(PlayEnabled);
        changeChannelButtonsEnabledState(mIsFavoriteChannels);
        radioInformationChanged();
        break;
    case Seeking:
        mFmRadioState = Seeking;
        //changeControlButtonState(AllDisabledStop);
        changePlayButtonState(StopDisabled);
        changeChannelButtonsEnabledState(false);
        changeInformationAreaLayout(Animation);
        break;
    case AntennaNotConnected:
        mFmRadioState = AntennaNotConnected;
        //changeControlButtonState(AllDisabledPlay);
        changePlayButtonState(StopDisabled);
        changeChannelButtonsEnabledState(false);
        mInformationFirstRowLabel->setPlainText("");
        mInformationSecondRowLabel->setPlainText("");
        mInformationLonelyRowLabel->setPlainText(KConnectHeadsetText);
        changeInformationAreaLayout(OneRow);
        break;
    default:
        break;
    }
}

/*!
 Changes visible layout of information area.
 
 /param InformationAreaLayout The layout to switch visible.
 */
void FmRadioHsWidget::changeInformationAreaLayout(InformationAreaLayout layout)
{
    switch (layout) {
    case OneRow:
        mInformationAreaOneRowLayout->show();
        ((QGraphicsWidget*) mInformationAreaTwoRowsLayout)->hide();
        mInformationAreaAnimationLayout->hide();
        break;
    case TwoRows:
        mInformationAreaOneRowLayout->hide();
        ((QGraphicsWidget*) mInformationAreaTwoRowsLayout)->show();
        mInformationAreaAnimationLayout->hide();
        break;
    case Animation:
        mInformationAreaOneRowLayout->hide();
        ((QGraphicsWidget*) mInformationAreaTwoRowsLayout)->hide();
        mInformationAreaAnimationLayout->show();
        break;
    default:
        break;
    }
}

/*!
 Changes state of the control buttons.
 
 /param ControlButtonState State of the control buttons.
 */
void FmRadioHsWidget::changeControlButtonState(ControlButtonState buttonState)
{
    QString iconName;
    switch (buttonState) {
    case AllDisabledPlay:
        changeControlButtonFrameBackground(false, Left, mPreviousPushButton);
        iconName.append("qtg_mono_play");
        mPlayPushButton->setIcon(HbIcon(iconName));
        changeControlButtonFrameBackground(false, Center, mPlayPushButton);
        changeControlButtonFrameBackground(false, Right, mNextPushButton);
        break;
    case AllDisabledStop:
        changeControlButtonFrameBackground(false, Left, mPreviousPushButton);
        iconName.append("qtg_mono_stop");
        mPlayPushButton->setIcon(HbIcon(iconName));
        changeControlButtonFrameBackground(false, Center, mPlayPushButton);
        changeControlButtonFrameBackground(false, Right, mNextPushButton);
        break;
    case ChannelsDisabledPlay:
        changeControlButtonFrameBackground(false, Left, mPreviousPushButton);
        QObject::disconnect(mPlayPushButton, SIGNAL(clicked()), this,
            SLOT(unMute()));
        QObject::disconnect(mPlayPushButton, SIGNAL(clicked()), this,
            SLOT(mute()));
        QObject::connect(mPlayPushButton, SIGNAL(clicked()), this,
            SLOT(radioToBackground()));
        iconName.append("qtg_mono_play");
        mPlayPushButton->setIcon(HbIcon(iconName));
        changeControlButtonFrameBackground(true, Center, mPlayPushButton);
        changeControlButtonFrameBackground(false, Right, mNextPushButton);
        break;
    case ChannelsDisabledStop:
        changeControlButtonFrameBackground(false, Left, mPreviousPushButton);
        iconName.append("qtg_mono_stop");
        mPlayPushButton->setIcon(HbIcon(iconName));
        changeControlButtonFrameBackground(true, Center, mPlayPushButton);
        changeControlButtonFrameBackground(false, Right, mNextPushButton);
        break;
    case ChannelsEnabledPlay:
        changeControlButtonFrameBackground(true, Left, mPreviousPushButton);
        QObject::disconnect(mPlayPushButton, SIGNAL(clicked()), this,
            SLOT(radioToBackground()));
        QObject::disconnect(mPlayPushButton, SIGNAL(clicked()), this,
            SLOT(mute()));
        QObject::connect(mPlayPushButton, SIGNAL(clicked()), this,
            SLOT(unMute()));
        iconName.append("qtg_mono_play");
        mPlayPushButton->setIcon(HbIcon(iconName));
        changeControlButtonFrameBackground(true, Center, mPlayPushButton);
        changeControlButtonFrameBackground(true, Right, mNextPushButton);
        break;
    case ChannelsEnabledStop:
        changeControlButtonFrameBackground(true, Left, mPreviousPushButton);
        QObject::disconnect(mPlayPushButton, SIGNAL(clicked()), this,
            SLOT(radioToBackground()));
        QObject::disconnect(mPlayPushButton, SIGNAL(clicked()), this,
            SLOT(unMute()));
        QObject::connect(mPlayPushButton, SIGNAL(clicked()), this,
            SLOT(mute()));
        iconName.append("qtg_mono_stop");
        mPlayPushButton->setIcon(HbIcon(iconName));
        changeControlButtonFrameBackground(true, Center, mPlayPushButton);
        changeControlButtonFrameBackground(true, Right, mNextPushButton);
        break;
    default:
        break;
    }
}

/*!
 Changes enabled state of channel buttons.
 
 */
void FmRadioHsWidget::changePlayButtonState(PlayButtonState buttonState)
{
    QString iconName;
    bool enabled = false;
    switch (buttonState) {
    case PlayDisabled:
        iconName.append("qtg_mono_play");
        mPlayPushButton->setIcon(HbIcon(iconName));
        enabled = false;
        break;
    case PlayEnabled:
        iconName.append("qtg_mono_play");
        mPlayPushButton->setIcon(HbIcon(iconName));
        enabled = true;
        break;
    case StopDisabled:
        iconName.append("qtg_mono_stop");
        mPlayPushButton->setIcon(HbIcon(iconName));
        enabled = false;
        break;
    case StopEnabled:
        iconName.append("qtg_mono_stop");
        mPlayPushButton->setIcon(HbIcon(iconName));
        enabled = true;
        break;
    default:
        break;
    }
    changeControlButtonFrameBackground(enabled, Center, mPlayPushButton);
}

/*!
 Changes enabled state of channel buttons.
 
 */
void FmRadioHsWidget::changeChannelButtonsEnabledState(bool enabled)
{
    changeControlButtonFrameBackground(enabled, Left, mPreviousPushButton);
    changeControlButtonFrameBackground(enabled, Right, mNextPushButton);
}

/*!
 Changes background of control button.
 
 /param enabled Is button enabled or disabled.
 /param position Position of the control button in button group.
 /param button The button to change the background.
 */
void FmRadioHsWidget::changeControlButtonFrameBackground(bool enabled,
    ControlButtonPosition position, HbPushButton *button)
{
    QString frameGraphicsName("qtg_fr_hsbutton_");
    if (enabled) {
        frameGraphicsName.append("normal");
    } else {
        frameGraphicsName.append("disabled");
    }
    HbFrameDrawer *frameDrawer = new HbFrameDrawer(frameGraphicsName,
        HbFrameDrawer::ThreePiecesHorizontal);
    switch (position) {
    case Left:
        frameDrawer->setFileNameSuffixList(QStringList() << "_l" << "_c" << "_cr");
        break;
    case Center:
        frameDrawer->setFileNameSuffixList(QStringList() << "_cl" << "_c" << "_cr");
        break;
    case Right:
        frameDrawer->setFileNameSuffixList(QStringList() << "_cl" << "_c" << "_r");
        break;
    default:
        break;
    }
    button->setFrameBackground(frameDrawer);
    button->setEnabled(enabled);
}