/*

 * Copyright (c) 2009 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:

 *

 */

#include "infowidget.h"

#include <hbiconitem.h>

#include <hbmarqueeitem.h>

#include <hbfontspec.h>

#include <hbaction.h>

#include <hbcheckbox.h>

#include <hbevent.h>

#include <hbcolorscheme.h>

#include <hbdialog.h>

#include <hbmessagebox.h>

#include <hbframedrawer.h>

#include <hbframeitem.h>

#include <hbtapgesture.h>

#include <QPainter>

#include <QPainterPath>

#include <QBrush>

#include <QGraphicsLinearLayout>

#include <QApplication>

#include <QLocale>

#include <QScopedPointer>

#include <QGesture>

#include "infowidgetlogging.h"

#include "infowidgetengine.h"

#include "infowidgetlayoutmanager.h"

#include "infowidgetpreferences.h"

/*!

  \class InfoWidget

  \brief Operator info widget main class. 

   Implements HomeScreen specific slots and 

   graphical representation of the 

   Operator Info widget. 

*/

// Local constants 

const int INFOWIDGET_DEFAULT_HEIGHT = 100;

const int INFOWIDGET_DEFAULT_WIDTH = 200;

const int INFOWIDGET_MARQUEE_START_DELAY = 5000; 

const char *BACKGROUND_FRAME_NAME = "qtg_fr_hswidget_normal"; 

/*!

    Constructor.  

*/

InfoWidget::InfoWidget(QGraphicsItem* parent, Qt::WindowFlags flags)

    : HbWidget(parent, flags),

    m_animationState(AnimationIdle), 

    m_engine(NULL), 

    m_preferences(NULL),

    m_layoutManager(NULL),

    m_layout(NULL),

    m_backgroundFrameItem(NULL),

    m_timerId(0),

    m_layoutChanging(false),

    m_initialized(false)

{

    INSTALL_TRACE_MSG_HANDLER; 

    DPRINT;

    // Create layout & child-widget manager 

    m_layoutManager.reset(new InfoWidgetLayoutManager);

    // Create widget engine 

    m_engine.reset(new InfoWidgetEngine);

    // Create preference store and start listening signal(s) 

    m_preferences.reset(new InfoWidgetPreferences);

    QObject::connect(m_preferences.data(), 

            SIGNAL(preferencesChanged(InfoWidgetPreferences::Options)),

                m_engine.data(), 

            SLOT(handlePreferencesChanged(

                InfoWidgetPreferences::Options)));

    // Setup widget main layout 

    m_layout = new QGraphicsLinearLayout;    

    m_layout->setSpacing(0); 

    m_layout->setContentsMargins(0,0,0,0); 

    setLayout(m_layout);

    // Create and set background frame drawer

    QScopedPointer<HbFrameDrawer> backgroundFrameDrawer(

            new HbFrameDrawer(

                    BACKGROUND_FRAME_NAME, 

                    HbFrameDrawer::NinePieces));

    Q_ASSERT(!backgroundFrameDrawer.isNull()); 

    // Set widget initial size

    resize(INFOWIDGET_DEFAULT_WIDTH,

           INFOWIDGET_DEFAULT_HEIGHT); 

    // Ownership of frame drawer is 

    // transferred for frame item

    m_backgroundFrameItem = new HbFrameItem(

            backgroundFrameDrawer.take(), this);  

    setBackgroundItem(m_backgroundFrameItem);

    // Listen for tap events 

    grabGesture(Qt::TapGesture);

}

/*!

    Destructor.  

*/

InfoWidget::~InfoWidget()

{

    DPRINT;

    // Force layout manager to delete widgets 

    // before InfoWidget is destroyed   

    m_layoutManager->destroyWidgets(); 

    UNINSTALL_TRACE_MSG_HANDLER;

}

/*!

    Called by HS framework, saved preference data

    is available when onInitialize() is called and 

    meta-object data reading should be done here.       

*/

void InfoWidget::onInitialize()

{

    DPRINT; 

    m_initialized = true; 

    // Initialize preferences from meta-object data

    if (!readPersistentPreferences()) {

        // Reading failed, initialize default values  

        m_preferences->setPreference(InfoWidgetPreferences::DisplaySpn, 

                DISPLAY_SETTING_ON);

        m_preferences->setPreference(InfoWidgetPreferences::DisplayMcn, 

                DISPLAY_SETTING_ON);

        m_preferences->setPreference(InfoWidgetPreferences::DisplaySatText, 

                DISPLAY_SETTING_ON);

    } 

    m_preferences->storePreferences(); 

    // Layout components 

    layoutInfoDisplay();

    // Update background frame size  

    m_backgroundFrameItem->resize(size());

    // Listen for model changes 

    QObject::connect(m_engine.data(), SIGNAL(modelChanged()), 

            this, SLOT(readModel()), Qt::UniqueConnection); 

}

/*!

    This slot is called by HomeScreen framework 

    when the widget is uninstalled.    

*/

void InfoWidget::onUninitialize()

{

    DPRINT;

    stopMarquees();

    m_initialized = false; 

    m_engine->suspend();

}

/*!

    This slot is called by HomeScreen framework 

    when the widget visibility is gained.    

*/

void InfoWidget::onShow()

{

    DPRINT;

    if (m_initialized) { 

        m_engine->resume();

        updateInfoDisplay(); 

    }

}

/*!

    This slot is called by HomeScreen framework 

    when the widget visibility is lost.    

*/

void InfoWidget::onHide()

{

    DPRINT;

    if (m_initialized) { 

        m_engine->suspend();

        stopMarquees(); 

    }

}

/*!

    Handles timer events.  

*/

void InfoWidget::timerEvent(QTimerEvent *event)

{

    Q_UNUSED(event); 

    if (m_animationState == AnimationStarting) {

        // Execute delayed start of marquee animation 

        if (m_animatingItem) {

            m_animationState = AnimationOngoing;

            m_animatingItem->startAnimation(); 

        } 

    }

    if (m_timerId) {

        killTimer(m_timerId);

        m_timerId = 0;

    }

}

/*!

    Returns bounding rect. 

*/

QRectF InfoWidget::boundingRect() const

{   

    return rect();

}

/*!

    Calculate widget size hint based on visible row count.  

*/

QSizeF InfoWidget::sizeHint(Qt::SizeHint which, 

        const QSizeF & constraint) const   

{

    Q_UNUSED(which);

    Q_UNUSED(constraint); 

    QSizeF requiredSize(

            INFOWIDGET_DEFAULT_WIDTH,

            INFOWIDGET_DEFAULT_HEIGHT);

    if (m_initialized) { 

        // Read size hint from docml content

        requiredSize = m_layoutManager->contentWidget()->minimumSize();

        // Height according number of rows, if 0 or 1 row use minimum size

        int rowCount = m_preferences->visibleItemCount();

        if (1 < rowCount) {

                requiredSize.rheight() += (rowCount-1)*

                        m_layoutManager->layoutRowHeight();

        }

        // Update background frame size 

        // if widget size is changing

        if (size() != requiredSize) {

            m_backgroundFrameItem->resize(requiredSize);

        }

    }

    return requiredSize; 

}

/*!

    Returns size polizy for the widget.   

*/

QSizePolicy InfoWidget::sizePolicy () const 

{

    DPRINT;

    return QSizePolicy(

            QSizePolicy::Fixed, 

            QSizePolicy::Fixed); 

}

/*!

    Update item visibility based on display preferences.   

*/

void InfoWidget::updateItemsVisibility()

{

    DPRINT; 

    if (m_preferences->preference(InfoWidgetPreferences::DisplaySpn).compare(

            DISPLAY_SETTING_OFF) == 0) {

        m_layoutManager->removeWidget(InfoWidgetLayoutManager::RoleSpnMarqueeItem); 

        m_layoutManager->removeWidget(InfoWidgetLayoutManager::RoleSpnIcon); 

    }

    if (m_preferences->preference(InfoWidgetPreferences::DisplayMcn).compare(

            DISPLAY_SETTING_OFF) == 0) {

        m_layoutManager->removeWidget(InfoWidgetLayoutManager::RoleMcnMarqueeItem); 

        m_layoutManager->removeWidget(InfoWidgetLayoutManager::RoleMcnIcon); 

    }

    if (m_preferences->preference(InfoWidgetPreferences::DisplaySatText).compare(

            DISPLAY_SETTING_OFF) == 0) {

        m_layoutManager->removeWidget(InfoWidgetLayoutManager::RoleSatMarqueeItem); 

        m_layoutManager->removeWidget(InfoWidgetLayoutManager::RoleSatTextIcon); 

    }

}

/*!

    Layout info display.    

*/

void InfoWidget::layoutInfoDisplay()

{  

    DPRINT;

    QGraphicsWidget *infoDisplay = 

        m_layoutManager->layoutInfoDisplay(); 

    if ((!m_layout->count()) && infoDisplay) {

            m_layout->addItem(infoDisplay);

        }

    updateItemsVisibility(); 

    endChanges();

}

/*!

    Layout and display settings dialog.    

*/

void InfoWidget::layoutSettingsDialog()

{  

    DPRINT;

    startChanges();

    HbDialog *settingsDialog =

            qobject_cast<HbDialog *>(

                    m_layoutManager->layoutSettingsDialog()); 

    if (settingsDialog) {

        initializeSettingsDialogItems();

        settingsDialog->setDismissPolicy(HbDialog::NoDismiss); 

        settingsDialog->setTimeout(HbDialog::NoTimeout);

        settingsDialog->open(this, 

                SLOT(settingsDialogClosed(HbAction *))); 

        }

}

/*!

    Set up initial check box states 

    and connect signals to local slots.  

*/

void InfoWidget::initializeSettingsDialogItems()

{  

    DPRINT;

    // Connect display setting check boxes

    HbCheckBox *spnCheckBox = 

            qobject_cast<HbCheckBox *>(m_layoutManager->getWidget(

                    InfoWidgetLayoutManager::RoleSpnCheckBox));

    if (spnCheckBox) {

        spnCheckBox->setChecked(m_preferences->isPreferenceSet(

                InfoWidgetPreferences::DisplaySpn));

        QObject::connect(spnCheckBox, SIGNAL(stateChanged(int)), 

                this, SLOT(spnDisplaySettingChanged(int)), 

                Qt::UniqueConnection); 

    }

    HbCheckBox *mcnCheckBox = 

            qobject_cast<HbCheckBox *>(m_layoutManager->getWidget(

                    InfoWidgetLayoutManager::RoleMcnCheckBox));

    if (mcnCheckBox) {

        mcnCheckBox->setChecked(m_preferences->isPreferenceSet(

                InfoWidgetPreferences::DisplayMcn));

        QObject::connect(mcnCheckBox, SIGNAL(stateChanged(int)), 

                this, SLOT(mcnDisplaySettingChanged(int)), 

                Qt::UniqueConnection); 

    }

    HbCheckBox *satTextCheckBox = 

            qobject_cast<HbCheckBox *>(m_layoutManager->getWidget(

                    InfoWidgetLayoutManager::RoleSatTextCheckBox));

    if (satTextCheckBox) {

        satTextCheckBox->setChecked(m_preferences->isPreferenceSet(

                InfoWidgetPreferences::DisplaySatText));

        QObject::connect(satTextCheckBox, SIGNAL(stateChanged(int)), 

                this, SLOT(satDisplaySettingChanged(int)), 

                Qt::UniqueConnection); 

    }

}

/*!

    Fetch widget based on item role and update 

    item specific data. 

*/

void InfoWidget::updateInfoDisplayItem(

        InfoWidgetLayoutManager::LayoutItemRole itemRole, 

        QString text)

{

    DPRINT; 

    HbMarqueeItem *marqueeItem = qobject_cast<HbMarqueeItem *>(

            m_layoutManager->getWidget(itemRole));

    if (marqueeItem) {

        marqueeItem->setText(text);

        marqueeItem->setTextColor( HbColorScheme::color(

                "qtc_hs_list_item_title_normal"));

        // Update widget effective size

        marqueeItem->adjustSize();

        if (!m_layoutManager->textFitsToRect(

                text,

                marqueeItem->font(), 

                marqueeItem->rect())) {

            DPRINT << ": enable marquee animation";

            m_animatingItems.append(marqueeItem);

        }

    }

}

/*!

    Model or visibility data has changed, 

    update info display widgets accordingly. 

*/

void InfoWidget::updateInfoDisplay()

{

    DPRINT; 

    if (m_initialized) {

        stopMarquees();

        if (m_layoutManager->currentDisplayRole() == 

                InfoWidgetLayoutManager::InfoDisplay) {

            InfoWidgetEngine::ModelData modelData = m_engine->modelData(); 

            // Update service provider name item

            QString text = modelData.serviceProviderName();

            updateInfoDisplayItem(

                    InfoWidgetLayoutManager::RoleSpnMarqueeItem, text); 

            // Update MCN name item

            text = modelData.mcnName();

            updateInfoDisplayItem(

                    InfoWidgetLayoutManager::RoleMcnMarqueeItem, text); 

            // Update SAT display text item

            text = modelData.satDisplayText();

            updateInfoDisplayItem(

                    InfoWidgetLayoutManager::RoleSatMarqueeItem, text); 

        }

        if (m_animatingItems.count() > 0) {

            startMarquees(); 

        }

    }

}

/*!

    Read model data. 

    Model's modelChanged - signal is connected to this slot.  

*/

void InfoWidget::readModel()

{

    DPRINT; 

    if (m_layoutManager->currentDisplayRole() == 

            InfoWidgetLayoutManager::InfoDisplay) { 

        updateInfoDisplay(); 

    }

}

/*!

    Model error signal is connected to this slot. 

*/

void InfoWidget::handleModelError(int operation,int errorCode)

{

    DWARNING << ": operation: " << operation << 

                " error: " << errorCode; 

}

/*!

    Tap gesture handler.   

*/

void InfoWidget::gestureEvent(QGestureEvent *event)

{

HbTapGesture *gesture = qobject_cast<HbTapGesture *>(

        event->gesture(Qt::TapGesture));

if(!gesture)return;

switch (gesture->state()) {

    case Qt::GestureFinished:

        if (gesture->tapStyleHint() == HbTapGesture::Tap) {

            if (m_layoutManager->currentDisplayRole() == 

                            InfoWidgetLayoutManager::InfoDisplay) {

                  DPRINT << ": layout and display settings dialog";

                  layoutSettingsDialog();

              } 

        }

    break;

    default: 

        break;

    }

}

/*!

    Slot for handling Spn display setting change.  

*/

void InfoWidget::spnDisplaySettingChanged(int state)

{

    DPRINT << ": state: " << state;

    if (state == Qt::Checked){

        m_preferences->setPreference(

                InfoWidgetPreferences::DisplaySpn, DISPLAY_SETTING_ON);

    } else {

        m_preferences->setPreference(

                InfoWidgetPreferences::DisplaySpn, DISPLAY_SETTING_OFF);

    }

}

/*!

    Slot for handling Mcn display setting change. 

*/

void InfoWidget::mcnDisplaySettingChanged(int state)

{

    DPRINT << ": state: " << state; 

    if (state == Qt::Checked){

        m_preferences->setPreference(

                InfoWidgetPreferences::DisplayMcn, DISPLAY_SETTING_ON);

    } else {

        m_preferences->setPreference(

                InfoWidgetPreferences::DisplayMcn, DISPLAY_SETTING_OFF);

    }

}

/*!

    Slot for handling SAT display setting change. 

*/

void InfoWidget::satDisplaySettingChanged(int state)

{

    DPRINT << ": state: " << state; 

    if (state == Qt::Checked){

        m_preferences->setPreference(

                InfoWidgetPreferences::DisplaySatText, DISPLAY_SETTING_ON);