* Copyright (c) 2009-2010 Nokia Corporation and/or its subsidiary(-ies).

* Description:   This module contains the implementation of IAUpdateMainView

*                class member functions.

#include <hbaction.h>

#include <QGraphicsWidget>

#include <QGraphicsLayout>

#include <QGraphicsLayoutItem>

#include <QGraphicsLinearLayout>

#include <hbdockwidget.h>

#include <hblistwidget.h>

#include <hblistviewitem.h>

#include <hblistwidgetitem.h>

#include <hbtoolbar.h>

#include <hbmenu.h>

#include <hbdocumentloader.h>

#include <xqconversions.h>

#include <hbmessagebox.h>

#include <hblabel.h>

#include <hbgroupbox.h>

#include <hbdataform.h>

#include <hbtranslator.h>

#include "iaupdateengine.h"

#include "iaupdateagreement.h"

#include "iaupdatedeputils.h"

#include "iaupdateversion.h"

const int KKiloByte = 1024;

const int KMegaByte = 1024 * 1024;

const int KMaxShownInKiloBytes = 10 * KMegaByte;

const QString KTranslationsPath = "/resource/qt/translations/";

const QString KTranslationsFile = "swupdate";

IAUpdateMainView::IAUpdateMainView(IAUpdateEngine *engine):

mEngine(engine)        

{

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::IAUpdateMainView() begin");

    mFwListView = NULL;

    mApplicationUpdatesGroupBox = NULL;;

    mFwNSUGroupBox = NULL;

    mContentDataForm = NULL;

    mDialogUtil = NULL;

    mDialogState = NoDialog;

    mPrimaryAction = NULL;

    mNode = NULL;

    mSelectionUpdate = false;

    mSelectionConnect = false;

    mTranslator = NULL;

    //mTranslator = new HbTranslator(KTranslationsPath, KTranslationsFile);

    HbDocumentLoader loader;

    bool ok = false;

    loader.load(":/xml/iaupdate_mainview.docml", &ok);

    // Exit if the file format is invalid

    Q_ASSERT_X(ok, "Software update", "Invalid docml file");

    // Create the view from DocML

    HbView* loadedWidget = qobject_cast<HbView*>(loader.findWidget("view"));

    Q_ASSERT_X(loadedWidget != 0, "Software update", "View not found");

    QString viewTitle(loadedWidget->title());

    // Set the IAUpdateMainView view to be the widget that was loaded from the xml

    setWidget(loadedWidget);

    setTitle(viewTitle);

    HbToolBar *toolBar = qobject_cast< HbToolBar*>( loader.findWidget("viewToolbar") );

    //setToolBar(toolBar);

    HbMenu *menu = qobject_cast< HbMenu*>( loader.findWidget("viewMenu") );

    setMenu(menu);

    //Get the Action objects from the docml file

    HbAction *action = qobject_cast<HbAction*>(loader.findObject("action"));

    HbAction *action_1 = qobject_cast<HbAction*>(loader.findObject("action_1"));

    HbAction *action_2 = qobject_cast<HbAction*>(loader.findObject("action_2"));

    connect(action, SIGNAL(triggered()), this, SLOT(handleStartUpdate()));

    connect(action_1, SIGNAL(triggered()), this, SLOT(handleSettings()));

    connect(action_2, SIGNAL(triggered()), this, SLOT(handleDisclaimer()));

    mContent = qobject_cast< HbWidget*>( loader.findWidget("content") );

    mListView = qobject_cast<HbListWidget*>( loader.findWidget("listWidget") );

    mListView->setSelectionMode( HbAbstractItemView::MultiSelection );

    connect( mListView, SIGNAL( longPressed( HbAbstractViewItem *, const QPointF & ) ),

            this, SLOT( handleDetails( HbAbstractViewItem *, const QPointF & ) ) ); 

    HbListViewItem *prototype = mListView->listItemPrototype();

    prototype->setGraphicsSize(HbListViewItem::LargeIcon);

    HbDockWidget *dock = new HbDockWidget(this);

    HbWidget *dockContainer = new HbWidget(dock);

    QGraphicsLinearLayout *dockLayout = new QGraphicsLinearLayout(dockContainer);

    dockLayout->setOrientation(Qt::Vertical);

    dockContainer->setLayout(dockLayout);

    mSelections = new HbGroupBox(dockContainer);

    mSelections->setHeading("Selected 0/0 (0 kB)");

    //QString selectedString = QString(hbTrId("txt_software_subhead_selected_1l_2l_3l_kb")).arg(0).arg(0).arg(0);

    //mSelections->setHeading(selectedString);                                            

    dockLayout->addItem( mSelections);

    dockLayout->addItem(toolBar);

    dock->setWidget(dockContainer);

    setDockWidget(dock);

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::IAUpdateMainView() end");

}

IAUpdateMainView::~IAUpdateMainView()

{

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::~IAUpdateMainView() begin");

    //delete mTranslator;

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::~IAUpdateMainView() end");

}

// IAUpdateMainView::refresh

void IAUpdateMainView::refresh(const RPointerArray<MIAUpdateNode> &nodes,

                               const RPointerArray<MIAUpdateFwNode> &fwNodes,

                               int error)

{   

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::refresh() begin");

    removeCurrentContentLayout();

    refreshFirmwareUpdates(fwNodes);

    refreshApplicationUpdates(nodes);

    if (nodes.Count() == 0 && fwNodes.Count() == 0 && 

        error != KErrCancel && error != KErrAbort)

    {    

        if (!mContentDataForm)

        {

            mContentDataForm  = new HbDataForm(mContent); 

        }

        QGraphicsLinearLayout *linearLayout = (QGraphicsLinearLayout*) mContent->layout();

        linearLayout->addItem(mContentDataForm);

        QString formText;

        if (error == KErrNone)

        {

            formText = QString("Applications are up to date");

            //formText = hbTrId("txt_software_formlabel_applications_are_up_to_date");

        }

        else

            formText = QString("Refreshing failed. Try again later.");

        }

        mContentDataForm->setDescription(formText);

    }

    updateSelectionInfoInDock();  

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::refresh() end");

}

void IAUpdateMainView::handleStartUpdate()

{

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::handleStartUpdate() begin");

    mEngine->StartUpdate(fotaSelected());

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::handleStartUpdate() end");

}

void IAUpdateMainView::handleSettings()

{

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::handleSettings() begin");

    emit toSettingView();

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::handleSettings() end");

}

void IAUpdateMainView::handleDisclaimer()

{

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::handleDisclaimer() begin");

    if (!mDialogUtil)

    {

        mDialogUtil = new IAUpdateDialogUtil(this);

    }

    if (mDialogUtil)

    {

        HbAction *primaryAction = new HbAction(hbTrId("txt_common_button_ok"));

        mDialogUtil->showAgreement(primaryAction);

    }

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::handleDisclaimer() end");

}

void IAUpdateMainView::handleDetails(HbAbstractViewItem * item, const QPointF &)

{

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::handleDetails() begin");

    int ind = item->modelIndex().row();

    if (getApplicationNode(ind) != NULL)

    {    

        showDetails(*getApplicationNode(ind));

    }

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::handleDetails() end");

}

void IAUpdateMainView::handleFotaDetails(HbAbstractViewItem *, const QPointF &)

{

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::handleFotaDetails begin");

    //only one FOTA item in a list, just use it

    for (int i = 0; i < mFwNodes.Count(); i++)

    {

        if (mFwNodes[i]->FwType() == MIAUpdateFwNode::EFotaDp2)

        {

            showDetails(*mFwNodes[i]);

        }

    }

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::handleFotaDetails end");

}

void IAUpdateMainView::handleSelectionChanged(const QItemSelection &selected, const QItemSelection &deselected)

{

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::handleSelectionChanged begin");

    if (!mSelectionUpdate)

    {

        bool changedItemFound = false; 

        QModelIndexList indexList = selected.indexes();

        for (int i = 0; !changedItemFound && i < indexList.count(); ++i)

        {    

            changedItemFound = true;

            markListItem(true, indexList.at(i).row());

        }

        if (!changedItemFound)

        {

            indexList = deselected.indexes();

            for (int i = 0; !changedItemFound && i < indexList.count(); ++i)

            {    

                changedItemFound = true;

                markListItem(false, indexList.at(i).row());

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::handleSelectionChanged end");

}

void IAUpdateMainView::handleFwSelectionChanged(const QItemSelection &selected, const QItemSelection &deselected)

{

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::handleFwSelectionChanged begin");

    if (!mSelectionUpdate)

        bool changedItemFound = false; 

        QModelIndexList indexList = selected.indexes();

        for (int i = 0; !changedItemFound && i < indexList.count(); ++i)

        {    

            changedItemFound = true;

            markFotaItem(true);

        }

        if (!changedItemFound)

        {

            indexList = deselected.indexes();

            for (int i = 0; !changedItemFound && i < indexList.count(); ++i)

            {    

                changedItemFound = true;

                markFotaItem(false);

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::handleFwSelectionChanged end");

}

void IAUpdateMainView::dialogFinished(HbAction *action)

{

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::dialogFinished begin");

    DialogState dialogState = mDialogState;

    mDialogState = NoDialog;

    switch ( dialogState )

        case Dependencies:

            if (action == mPrimaryAction)

                updateSelectionsToNodeArray(*mNode,mMark);

            updateSelectionsToList();

            updateSelectionInfoInDock();

            break;

        case CannotOmit:    

            break;

        case Details:

            break; 

        default: 

            break;

    }

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::dialogFinished end");

}

bool IAUpdateMainView::fotaSelected() const

{

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::fotaSelected() begin");

    bool selected = false;

    for (int i = 0; i < mFwNodes.Count() && !selected; ++i)

    {

        if ( mFwNodes[i]->FwType() == MIAUpdateFwNode::EFotaDp2 && mFwNodes[i]->Base().IsSelected() )

        {    

            selected = true;

        }

    }

    if (selected)

        {

        IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::fotaSelected() Fota item is selected");

        }

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::fotaSelected() end");

    return selected;

}

void IAUpdateMainView::markListItem(bool mark, int index)

{

    IAUPDATE_TRACE_2("[IAUPDATE] IAUpdateMainView::markListItem() begin mark: %d index %d", mark, index);

    if (mark)

    {

        //It's Mark Command

        if (fotaSelected())

        {    

            //FOTA item is selected, unmark FOTA item

            //FOTA item and application update items can't be selected at the same time 

            markFotaItem(false);

        }    

    }

    bool accepted = false;

    if(index > -1)

    {

        accepted = true;

        MIAUpdateNode* node = mNodes[index];

        RPointerArray<MIAUpdateNode> mands;

        RPointerArray<MIAUpdateNode> deps;

        if (mark)

        {

            TRAPD(err,IAUpdateDepUtils::GetDependenciesL(*node, mNodes, deps));

            if (err != KErrNone)

                deps.Close();

                updateSelectionsToList();

                IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::markListItem() return end");

                return;

            }

            if (!getMandatoryNodes(mands))

                // error when creating mandatory node list

                mands.Close();

                updateSelectionsToList();

                IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::markListItem() return end");

                return;

                }

        }

        else

        {

            //mandatory item is not allowed to be unmarked

            if (mNodes[index]->Base().Importance() == MIAUpdateBaseNode::EMandatory)

            {

                //show dialog  

                showUpdateCannotOmitDialog();

                updateSelectionsToList();

                IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::markListItem() return end");

                return;

            }

            TRAPD(err,IAUpdateDepUtils::GetDependantsL(*node, mNodes, deps));  

            if (err != KErrNone)

            {

                deps.Close();

                updateSelectionsToList();

                IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::markListItem() return end");

                return;

            }

            // item is not allowed to be unmarked if its dependant is mandatory

            bool mandatoryDependantFound = false;

            for(int i = 0; i < deps.Count() && !mandatoryDependantFound; i++)

            {

                if (deps[i]->Base().Importance() == MIAUpdateBaseNode::EMandatory)

                {

                    mandatoryDependantFound = true;

                }

            }

            if (mandatoryDependantFound)

            {

                showUpdateCannotOmitDialog();

                deps.Close();

                updateSelectionsToList();

                IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::markListItem() return end");

                return;

            }

        }

        int depCount = deps.Count();

        if (depCount > 0)

        {

            QString text;

            QString names;

            MIAUpdateNode* depNode = NULL;

            QString separator(",");

            for(int i = 0; i < depCount; i++)  

            {

                depNode = deps[i];

                if (i > 0)

                {

                    names.append(separator);

                    names.append(QString(" "));

                }

                names.append(XQConversions::s60DescToQString(depNode->Base().Name()));

            }

            if (mark)

            {

                if (depCount > 1) 

                {

                    text.append("This update needs also updates "); 

                    text.append(names);

                    text.append(" for working");

                } 

                else

                {

                    text.append("This update needs also \""); 

                    text.append(names);

                    text.append("\" for working");

            {

                if (depCount > 1) 

                    text.append("Updates "); 

                    text.append(names);

                    text.append(" need this update for working");

                } 

                else

                {

                    text.append("Update \""); 

                    text.append(names);

                    text.append("\" needs this update for working");

                }   

            if (mark && mNodes[index]->Base().Importance() == MIAUpdateBaseNode::EMandatory)

            {

                // depencencies of mandatory update are also selected without showing dialog

                accepted = true;

            }

            else

                mNode = node;

                mMark = mark;

                accepted = false;

                showDependenciesFoundDialog(text);

        }

        if (accepted)

        {    

            updateSelectionsToNodeArray(*node, mark);   

    if (accepted)