/*

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

#include <HbDialog>

#include <HbInstance>

#include <HbLabel>

#include <HbListWidget>

#include <HbListWidgetItem>

#include <HbMenu>

#include <HbScrollbar>

#include <QActionGroup>

#include <QGraphicsLinearLayout>

#include <QSettings>

#include <QParallelAnimationGroup>

#include <QPropertyAnimation>

#include "hgwidgettestview.h"

#include "hgtestview.h"

#include "hgwidgetoptionsview.h"

#include "hgselectiondialog.h"

#include "hgwidgettestdatamodel.h"

#include "hgflipwidget.h"

#include "hgitemsizedialog.h"

#include "trace.h"

#include "hgcoveritem.h"

#include <hgwidgets/hggrid.h>

#include <hgwidgets/hgmediawall.h>

#include <HbStyleLoader>

static const int GRIDBUFFERSIZE(400);

static const int COVERFLOWBUFFERSIZE(100);

HgWidgetTestView::HgWidgetTestView(QGraphicsItem *parent) :

    HbView(parent),

    mWidget(0),

    mModel(0),

    mWidgetType(HgWidgetNone),

    mListWidget(0),

    mToggleOrientation(false),

    mFlipWidget(0),

    mFrontItem(0),

    mOptionsView(0),

    mItemSizeDialog(0),

    mItemPosDialog(0),

    mDialog(0),

{    

    mModel = new HgWidgetTestDataModel(this);

    mSelectionModel = new QItemSelectionModel(mModel, this);

    mAnimationGroup = new QParallelAnimationGroup();

    createMenu();

    mLayout = new QGraphicsLinearLayout(Qt::Vertical);

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

    setupWidget();

    setLayout(mLayout);

}

HgWidgetTestView::~HgWidgetTestView()

{

    delete mAnimationGroup;

    HbStyleLoader::unregisterFilePath(":/test/hgmediawall.css");

    HbStyleLoader::unregisterFilePath(":/test/hgmediawall.widgetml");

}

void HgWidgetTestView::createMenu()

{

    FUNC_LOG;

    menu()->addAction("Options", this, SLOT(showOptions()));

    menu()->addAction("Reset Options", this, SLOT(resetOptions()));

    menu()->addAction("Toggle scrolldirection", this, SLOT(toggleScrollDirection()));

    menu()->addAction("Simulate orientation switch", this, SLOT(orientationChanged()));

    menu()->addAction("Edit item size", this, SLOT(startItemSizeChange()));

    menu()->addAction("Edit item pos", this, SLOT(startItemPosChange()));

    menu()->addAction("use custom layout", this, SLOT(useCustomLayout()));

    HbMenu *modelChangeSubMenu = menu()->addMenu("Change model");

    modelChangeSubMenu->addAction("Remove items", this, SLOT(openDeleteItemsDialog()));

    modelChangeSubMenu->addAction("Move items", this, SLOT(openMoveItemsDialog()));

    modelChangeSubMenu->addAction("Add items", this, SLOT(openAddItemsDialog()));

    modelChangeSubMenu->addAction("Reset model", this, SLOT(resetModel()));

}

void HgWidgetTestView::toggleScrollDirection()

{

    FUNC_LOG;

    mToggleOrientation = !mToggleOrientation;

    initWidget(mWidgetType);

}

void HgWidgetTestView::initWidget(HgTestWidgetType type)

{

    FUNC_LOG;

    if (mWidgetType != type) {

        mWidgetType = type;

        // TODO, disconnecting signals required?

        if( mWidget )

            mLayout->removeItem(mWidget);

        if( mListWidget )

            mLayout->removeItem(mListWidget);

        delete mWidget;

        mWidget = NULL;

        delete mListWidget;

        mListWidget = NULL;

        mWidget = createWidget(type);

        mLayout->addItem(mWidget);

        switch (type) {

            case HgWidgetGrid:

            	setItemVisible(Hb::AllItems, true);

                mModel->enableLowResImages(false);

                // TODO, init grid different model,

//                mModel->setThumbnailSize(ThumbnailManager::ThumbnailMedium);

                break;

            case HgWidgetCoverflow:

//                mModel->setThumbnailSize(ThumbnailManager::ThumbnailLarge);

                setItemVisible(Hb::AllItems, orientation() != Qt::Horizontal);

                break;

            case HgWidgetTBone:

                {

            	setItemVisible(Hb::AllItems, true);

//                mModel->setThumbnailSize(ThumbnailManager::ThumbnailMedium);

                mListWidget = new HbListWidget;

                mListWidget->setMinimumHeight(360);

                mListWidget->setMaximumHeight(360);

                mListWidget->setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Ignored));

                mLayout->addItem(mListWidget);

                /*mListWidget->addItem( "List item 1");

                mListWidget->addItem( "List item 2");

                mListWidget->addItem( "List item 3");*/

                HgMediawall* mediawall = qobject_cast<HgMediawall*>( mWidget );

                if (mediawall) {

                    connect(mediawall, SIGNAL(animationAboutToEnd(QModelIndex)),

                            SLOT(animationAboutToEnd(QModelIndex)));

                }

                }

                break;

            default:

                break;

        }

        HANDLE_ERROR_NULL(mWidget);

        connect(mWidget, SIGNAL(activated(QModelIndex)), SLOT(openDialog(QModelIndex)));

        connect(mWidget, SIGNAL(longPressed(QModelIndex, QPointF)), SLOT(openView(QModelIndex)));

        QList<HbMainWindow *> mainWindows = hbInstance->allMainWindows();

        if (mainWindows.count() > 0) {

            HbMainWindow *primaryWindow = mainWindows[0];

            connect(primaryWindow, SIGNAL(orientationChanged(Qt::Orientation)), mWidget, SLOT(orientationChanged(Qt::Orientation)));

            connect(primaryWindow, SIGNAL(orientationChanged(Qt::Orientation)), this, SLOT(orientationChanged(Qt::Orientation)));

            primaryWindow->setAutomaticOrientationEffectEnabled(false);

        }

        setupWidgetOptions();

        setupWidgetSize();

        connect(mWidget, SIGNAL(scrollingStarted()), SLOT(onScrollingStarted()));

        connect(mWidget, SIGNAL(scrollingEnded()), SLOT(onScrollingEnded()));

    }

}

void HgWidgetTestView::animationAboutToEnd(const QModelIndex& targetIndex)

{

    FUNC_LOG;

    QVariant texts = mModel->silentData(targetIndex, Qt::DisplayRole);

    if (texts.canConvert<QStringList>()) {

        QStringList strList = texts.toStringList();

        if (strList.count() > 0) {

            if( mListWidget->count() == 1 ) {

                mListWidget->setText(0,strList.at(0));

            } else {

                mListWidget->insertItem(0, strList.at(0));

            }

        }

    }

}

void HgWidgetTestView::changeScrollBarVisibility(HgWidget::ScrollBarPolicy policy)

{

    FUNC_LOG;

    if (mWidget->scrollBarPolicy() != policy) {

        mWidget->setScrollBarPolicy(policy);

    }

}

void HgWidgetTestView::changeScrollBarInteractivity(bool value)

{

    FUNC_LOG;

    if (mWidget->scrollBar()->isInteractive() != value) {

        mWidget->scrollBar()->setInteractive(value);

        if (mWidgetType == HgWidgetCoverflow || mWidgetType == HgWidgetTBone) {

            mWidget->setIndexFeedbackPolicy(HgWidget::IndexFeedbackSingleCharacter);

        }

    }

}

void HgWidgetTestView::changeModelImageType(HgTestImageType type)

{

    FUNC_LOG;

    if (mModel->imageDataType() != type) {

        mModel->setImageDataType(type);

    }

}

void HgWidgetTestView::changeLowResImageUse(bool value)

{

    FUNC_LOG;

    if (mWidgetType == HgWidgetCoverflow || mWidgetType == HgWidgetTBone) {

        mModel->enableLowResImages(value);

        initWidget(mWidgetType);

    }

}

void HgWidgetTestView::changeTitleFont(const HbFontSpec &fontSpec)

{

    FUNC_LOG;

    HgMediawall *mediawall = qobject_cast<HgMediawall *>(mWidget);

    if (mediawall && mediawall->titleFontSpec() != fontSpec) {

        mediawall->setTitleFontSpec(fontSpec);

    }

}

void HgWidgetTestView::changeDescriptionFont(const HbFontSpec &fontSpec)

{

    FUNC_LOG;

    HgMediawall *mediawall = qobject_cast<HgMediawall *>(mWidget);

    if (mediawall && mediawall->descriptionFontSpec() != fontSpec) {

        mediawall->setDescriptionFontSpec(fontSpec);

    }

}

void HgWidgetTestView::changeWidgetHeight(int value)

{

    FUNC_LOG;

    int height(rect().height());

    if (value < height) {

        qreal left(0), top(0), right(0), bottom(0);

        mLayout->getContentsMargins(&left, &top, &right, &bottom);

        if (mWidgetType == HgWidgetTBone) {

            mListWidget->setMinimumHeight(height-value);

            mListWidget->setMaximumHeight(height-value);

            mLayout->setContentsMargins(left, 0, right, 0);

        }

        else {

            int margin(0);

            margin = (height-value)/2;

            mLayout->setContentsMargins(left, margin, right, margin);

        }

    }

}

void HgWidgetTestView::changeWidgetWidth(int value)

{

    FUNC_LOG;

    int width(rect().width());

    int margin(0);

    if (value < width) {

        margin = (width-value)/2;

    }

    qreal left(0), top(0), right(0), bottom(0);

    mLayout->getContentsMargins(&left, &top, &right, &bottom);

    mLayout->setContentsMargins(margin, top, margin, bottom);

}

void HgWidgetTestView::changeReflectionsEnabled(bool enabled)

{

    HgMediawall* wall = qobject_cast<HgMediawall*>(mWidget);

    if (wall)

        wall->enableReflections(enabled);

}

void HgWidgetTestView::changeEffect3dEnabled(bool enabled)

{

    HgGrid* grid = qobject_cast<HgGrid*>(mWidget);

    if (grid)

        grid->setEffect3dEnabled(enabled);

}

void HgWidgetTestView::changeItemSizePolicy(HgMediawall::ItemSizePolicy policy)

{

    FUNC_LOG;

    if (mWidget && mWidget->itemSizePolicy() != policy) {

        mWidget->setItemSizePolicy(policy);

    }

}

void HgWidgetTestView::activated()

{

    mAnimationGroup->setDirection(QAbstractAnimation::Backward);

    connect(mAnimationGroup, SIGNAL(finished()), this, SLOT(animationFinished()));

    mAnimationGroup->start();

}

void HgWidgetTestView::animationFinished()

{

    delete mCoverItem;

    mCoverItem = 0;

    mAnimationGroup->disconnect(this, SIGNAL(animationFinished()));

    mAnimationGroup->setDirection(QAbstractAnimation::Forward);

    mAnimationGroup->clear();

    delete mDialog;

    mDialog = 0;

    mModel->setData(mFlippedIndex, true, Qt::UserRole+1);    

}

void HgWidgetTestView::openDialog(const QModelIndex& index)

{

    FUNC_LOG;

    QVariant image = mModel->silentData(index, Qt::DecorationRole);

    QVariant texts = mModel->silentData(index, Qt::DisplayRole);

    if (mWidgetType == HgWidgetCoverflow )

    {

        startAnimation(index);

        return;

    }

    else if(mWidgetType == HgWidgetTBone)

    {

        if (image.canConvert<QPixmap>() && texts.canConvert<QStringList>())

        {

            QStringList strList = texts.toStringList();

            if (strList.count() > 1)

            {

                if (mFrontItem)

                    mFrontItem->setVisible(false);

                if (mFlipWidget)

                    delete mFlipWidget;

                QPolygonF poly;

                if (!mWidget->getItemOutline(index, poly))

                    return;

                QRectF itemRect = poly.boundingRect();

                itemRect.moveTo(itemRect.topLeft() + mWidget->geometry().topLeft());

                mFlipWidget =

                    new HgFlipWidget(

                        strList.at(0),

                        strList.at(1),

                        image.value<QPixmap>(),

                        this);

                mFlipWidget->setPos(QPointF(

                    itemRect.center().x() - itemRect.width() / 2,

                    itemRect.center().y() - itemRect.height() / 2

                ));

                mFlipWidget->resize(itemRect.width(), itemRect.height());

                mFlipWidget->show();

                QObject::connect(mFlipWidget, SIGNAL(closed()), this, SLOT(flipClosed()));

                mModel->setData(index, false, Qt::UserRole+1);

                mFlippedIndex = index;

            }

        }

        return;

    }

    HbDialog* dlg = new HbDialog();

    dlg->setAttribute(Qt::WA_DeleteOnClose);

    dlg->setTimeout(HbPopup::NoTimeout);

    dlg->setDismissPolicy(HbPopup::TapAnywhere);

    dlg->setModal(false);

    dlg->setBackgroundFaded(false);

    dlg->addAction(new HbAction("Close",dlg));

    if (texts.canConvert<QStringList>())

    {

        QStringList strList = texts.toStringList();

        if (strList.count() > 0)

        {

            dlg->setHeadingWidget(new HbLabel(strList.at(0)));

        }

    }

    if (image.canConvert<QImage>())

    {

        HbLabel *content = new HbLabel;

        QImage realImage(image.value<QImage>());

        QPixmap pixmap = QPixmap::fromImage( realImage  );

        content->setIcon(HbIcon(pixmap));

        dlg->setContentWidget(content);

    }

    dlg->show();

}

void HgWidgetTestView::startAnimation(const QModelIndex& index)

{

    if( mAnimationGroup->state() == QAbstractAnimation::Running ||

        mDialog || mCoverItem ) return;

    QPolygonF poly;

    if (!mWidget->getItemOutline(index, poly))

        return;

    mFlippedIndex = index;

    QRectF itemRect = poly.boundingRect();

    itemRect.moveTo(itemRect.topLeft() + mWidget->geometry().topLeft());

    QVariant image = mModel->silentData(index, Qt::DecorationRole);

    QPixmap pixmap;

    QImage temp = image.value<QImage>();

    QImage scaled = temp.scaled(itemRect.size().toSize());

    if (scaled.isNull()) return;

    QPixmap pixmap2 = pixmap.fromImage(scaled);    

    if(pixmap2.isNull()) return;

    mCoverItem = new HgCoverItem(pixmap2, this);

    mCoverItem->setPos(itemRect.topLeft());

    mCoverItem->setZValue(mWidget->zValue()+2);

    mCoverItem->show();

    QPropertyAnimation* animation = new QPropertyAnimation(mCoverItem, "geometry");

    animation->setDuration(400);        

    animation->setStartValue(itemRect);

    QRectF endRect = itemRect;

    int topLeftX = (mWidget->size().width() - itemRect.size().width()*2)/2;

    endRect.moveTo(topLeftX,endRect.topLeft().y());

    animation->setEndValue(endRect);

    mAnimationGroup->addAnimation(animation);

    HgListWidget* list = new HgListWidget(this);

    mDialog = new HbDialog(this);

    mDialog->setZValue(mWidget->zValue()+1);

    mDialog->setContentWidget(list);

    mDialog->setDismissPolicy(HbPopup::TapOutside);

    list->addItem( "List item 1");

    list->addItem( "List item 2");

    list->addItem( "List item 3");

    list->addItem( "List item 4");

    list->addItem( "List item 5");

    list->addItem( "List item 6");

    list->addItem( "List item 7");

    connect(list,SIGNAL(activated(HbListWidgetItem*)),this, SLOT(activated()));

    connect(list,SIGNAL(close()),this, SLOT(activated()));

    connect(mCoverItem,SIGNAL(close()),this, SLOT(activated()));

    animation = new QPropertyAnimation(mDialog, "geometry");

    animation->setDuration(400);

    animation->setStartValue(itemRect);

    endRect.moveTo(endRect.topRight());

    animation->setEndValue(endRect);

    mModel->setData(mFlippedIndex, false, Qt::UserRole+1);    

    mAnimationGroup->addAnimation(animation);

    mAnimationGroup->start();    

}

void HgWidgetTestView::openView(const QModelIndex& index)

{

    FUNC_LOG;

    QVariant image = mModel->silentData(index, Qt::DecorationRole);