/*

 * 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 <QPainter>

#include <QPainterPath>

#include <QBrush>

#include <QGraphicsLinearLayout>

#include <QApplication>

#include <QLocale>

#include <QTranslator>

#include <QScopedPointer>

#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. 

   Derived from HbWidget.

*/

// Local constants 

const int INFOWIDGET_DEFAULT_HEIGHT = 100;

const int INFOWIDGET_DEFAULT_WIDTH = 200;

const char *TS_FILE_OPERATOR_WIDGET = "operator_widget"; 

const char *TS_FILE_COMMON = "common";

const char *BACKGROUND_FRAME_NAME = "qtg_fr_hswidget_normal"; 

/*!

    InfoWidget::InfoWidget() 

*/

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

    m_initialized(false)

{

    INSTALL_TRACE_MSG_HANDLER; 

    DPRINT << ": IN";

    // Localization file loading

    installTranslator(TS_FILE_OPERATOR_WIDGET);

    installTranslator(TS_FILE_COMMON);

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

    DPRINT << ": OUT";

}

/*!

    InfoWidget::~InfoWidget() 

*/

InfoWidget::~InfoWidget()

{

    DPRINT << ": IN";

    // Force layout manager to delete widgets 

    // before InfoWidget is destroyed   

    m_layoutManager->destroyWidgets(); 

    // Remove and delete language translators 

    removeTranslators(); 

    DPRINT << ": OUT"; 

    UNINSTALL_TRACE_MSG_HANDLER;

}

/*!

    InfoWidget::onInitialize()

    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 << ": IN";

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

    DPRINT << ": OUT";

}

/*!

    InfoWidget::onUninitialize() 

*/

void InfoWidget::onUninitialize()

{

    DPRINT << ": IN";

    stopMarquees();

    m_initialized = false; 

    m_engine->suspend();

    DPRINT << ": OUT";

}

/*!

    InfoWidget::onShow() 

*/

void InfoWidget::onShow()

{

    DPRINT;

    if (m_initialized) { 

        m_engine->resume();

        updateInfoDisplay(); 

    }

}

/*!

    InfoWidget::onHide() 

*/

void InfoWidget::onHide()

{

    DPRINT;

    if (m_initialized) { 

        m_engine->suspend();

        stopMarquees(); 

    }

}

/*!

    InfoWidget::timerEvent() 

*/

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;

    }

}

/*!

    InfoWidget::installTranslator() 

*/

bool InfoWidget::installTranslator(QString translationFile)

{

    DPRINT << ": IN";

    QString lang = QLocale::system().name();

    QString path = "z:/resource/qt/translations/";

    bool translatorLoaded(false);  

    QScopedPointer<QTranslator> widgetTranslator; 

    widgetTranslator.reset(new QTranslator);

    translatorLoaded = widgetTranslator->load(

            path + translationFile + "_" + lang);

    if (translatorLoaded) {

        qApp->installTranslator(widgetTranslator.data());

        m_translators.append(widgetTranslator.take()); 

        DPRINT << ": translator installed: " << translationFile; 

    }

    DPRINT << ": OUT";

    return translatorLoaded;

}

/*!

    InfoWidget::removeTranslators()

    Remove translators from qApp and delete objects 

*/

void InfoWidget::removeTranslators()

{

    DPRINT << ": IN";

    foreach (QTranslator *translator, m_translators) {

        qApp->removeTranslator(translator);

    }    

    qDeleteAll(m_translators);

    m_translators.clear();

    DPRINT << ": OUT";

}

/*!

    InfoWidget::boundingRect() 

*/

QRectF InfoWidget::boundingRect() const

{   

    return rect();

}

/*!

    InfoWidget::sizeHint() 

    Calculate size hint based on visible rows 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);

        }

    }

    DPRINT << ": returning size: " << requiredSize;

    return requiredSize; 

}

/*!

    InfoWidget::sizePolicy() 

*/

QSizePolicy InfoWidget::sizePolicy () const 

{

    DPRINT;

    return QSizePolicy(

            QSizePolicy::Fixed, 

            QSizePolicy::Fixed); 

}

/*!

    InfoWidget::updateItemsVisibility() 

*/

void InfoWidget::updateItemsVisibility()

{

    DPRINT <<": IN"; 

    int layoutRows = 0; 

    QList<QGraphicsWidget *> widgetsToHide; 

    // Update layout according to item visibility settings

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

            DISPLAY_SETTING_ON) == 0) {

        layoutRows++;

    } else {

        m_layoutManager->removeWidget(InfoWidgetLayoutManager::RoleSpnMarqueeItem); 

        m_layoutManager->removeWidget(InfoWidgetLayoutManager::RoleSpnIcon); 

    }

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

            DISPLAY_SETTING_ON) == 0) {

        layoutRows++;

    } else {

        m_layoutManager->removeWidget(InfoWidgetLayoutManager::RoleMcnMarqueeItem); 

        m_layoutManager->removeWidget(InfoWidgetLayoutManager::RoleMcnIcon); 

    }

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

            DISPLAY_SETTING_ON) == 0) {

        layoutRows++;

    } else {

        m_layoutManager->removeWidget(InfoWidgetLayoutManager::RoleSatMarqueeItem); 

        m_layoutManager->removeWidget(InfoWidgetLayoutManager::RoleSatTextIcon); 

    }

    DPRINT << ": visible layout rows count: " << layoutRows;

    m_layoutManager->setLayoutRows(layoutRows);

}

/*!

    InfoWidget::layoutInfoDisplay()

    Layout info display    

*/

void InfoWidget::layoutInfoDisplay()

{  

    DPRINT << ": IN";

    QGraphicsLayout *infoDisplayLayout = 

        m_layoutManager->layoutInfoDisplay(); 

    if (!m_layout->count()) {

        QGraphicsWidget *contentWidget = 

                m_layoutManager->contentWidget();

        if (contentWidget) {

            // Add content widget to main layout 

            m_layout->addItem(contentWidget);

        }

    }

    updateItemsVisibility(); 

    endChanges();

    DPRINT << ": OUT";

}

/*!

    InfoWidget::layoutSettingsDialog()

    Layout and display settings dialog    

*/

void InfoWidget::layoutSettingsDialog()

{  

    DPRINT << ": IN";

    startChanges();

    m_layoutManager->reloadWidgets(InfoWidgetLayoutManager::SettingsDialog); 

    QGraphicsLayout *settingDialogLayout =

            m_layoutManager->layoutSettingsDialog(); 

    if (settingDialogLayout) {

        HbDialog *settingsDialog = qobject_cast<HbDialog *>(

                m_layoutManager->getWidget(InfoWidgetLayoutManager::

                RoleSettingsDialog)); 

        if (settingsDialog) {

            DPRINT << ": settingsDialog has been returned from layout manager";

            initializeSettingsDialogItems();

            settingsDialog->setDismissPolicy(HbDialog::NoDismiss); 

            settingsDialog->setTimeout(HbDialog::NoTimeout);

            settingsDialog->open(this, 

                    SLOT(settingsDialogClosed(HbAction *))); 

            }

    }    

    DPRINT << ": OUT";

}

/*!

    InfoWidget::initializeSettingsDialogItems()

    Set up initial check box states 

    and connect signals to local slots  

*/

void InfoWidget::initializeSettingsDialogItems()

{  

    DPRINT << ": IN";

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

    }

    DPRINT << ": OUT";

}

/*!

    InfoWidget::updateInfoDisplayItem() 

    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 if not already set  

        marqueeItem->adjustSize(); 

        if (!m_layoutManager->textFitsToRect(

                text,

                marqueeItem->font(), 

                marqueeItem->rect())) {

            DPRINT << ": enable marquee animation";

            m_animatingItems.append(marqueeItem);

        }

    }

}

/*!

    InfoWidget::updateInfoDisplay() 

    Model or visibility data has changed, 

    update info display widgets accordingly. 

*/

void InfoWidget::updateInfoDisplay()

{

    DPRINT << ": IN"; 

    if (m_initialized) {

        stopMarquees();