/*

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

*

*/

#include <QGesture>

#include <QPainter>

#include <QTimer>

#include <HbMainWindow>

#include "hgcontainer.h"

#include "hgmediawallrenderer.h"

#include "hgquad.h"

#include "hgvgquadrenderer.h"

#include "hgvgimage.h"

#include "hgwidgetitem.h"

#include "trace.h"

#include <HbCheckBox>

#include <HbGridViewItem>

#include <HbGridView>

#include <HbIconItem>

#include <QAbstractItemModel>

#include <HbTapGesture>

#include "hglongpressvisualizer.h"

static const qreal KSpringKScrolling(50.0);

static const qreal KSpringKScrollBar(10.0);

static const qreal KSpringDampingScrolling(20.0);

static const qreal KSpringDampingScrollBar(5.0);

static const qreal KFramesToZeroVelocity(60.0);

static const int   KLongTapDuration(400);

HgContainer::HgContainer(QGraphicsItem* parent) :

    HbWidget(parent),

    mQuadRenderer(0),

    mRenderer(0),

    mTapCount(0),

    mAnimateUsingScrollBar(false),

    mSelectionMode(HgWidget::NoSelection),

    mSelectionModel(0),

    mMarkImageOn(0),

    mMarkImageOff(0),

    mSpringVelAtDragStart(0),

    mDragged(false),

    mFramesDragged(0),

    mHitItemView(NULL),

    mLongPressVisualizer(NULL),

    mLongPressTimer(NULL),

    mHitItemIndex(-1),

    mItemSizePolicy(HgWidget::ItemSizeAutomatic),

    mOrientation(Qt::Vertical),

    mDelayedScrollToIndex(),

    mIgnoreGestureAction(false),

    mHandleLongPress(false)

{

    FUNC_LOG;

    setFlag(QGraphicsItem::ItemHasNoContents, false);

    grabGesture(Qt::PanGesture);

    grabGesture(Qt::TapGesture);

}

HgContainer::~HgContainer()

{

    FUNC_LOG;

    qDeleteAll(mItems);

    mItems.clear();

    delete mMarkImageOn;

    delete mMarkImageOff;

    delete mRenderer;

}

void HgContainer::setItemCount(int itemCount)

{

    FUNC_LOG;

    qDeleteAll(mItems);

    mItems.clear();

    for (int i=0; i<itemCount; i++) {

        HgWidgetItem* item = new HgWidgetItem(mQuadRenderer);

        mItems.append(item);

    }

}

// TODO: This does exactly the same as HgContainer::imageCount(), should this be thus removed?

int HgContainer::itemCount() const

{

    return mItems.count();

}

int HgContainer::rowCount() const

{

    return mRenderer ? mRenderer->getRowCount() : 0;

}

QList<HgWidgetItem*> HgContainer::items() const

{

    return mItems;

}

HgWidgetItem* HgContainer::itemByIndex(const QModelIndex& index) const

{

    foreach (HgWidgetItem* item, mItems) {

        if (item->modelIndex() == index)

            return item;

    }

    return 0;

}

HgWidgetItem* HgContainer::itemByIndex(const int& index) const

{

    if (mItems.count() > index && index >= 0)

        return mItems.at(index);

    else

        return 0;

}

/*!

    Changes the selection model of the container.

    Ownership is not transferred.

    Widget is redrawn to make new selection visible.

*/

void HgContainer::setSelectionModel(QItemSelectionModel *selectionModel, const QModelIndex &defaultItem)

{

    FUNC_LOG;

    HANDLE_ERROR_NULL(selectionModel); // Parameter is always a valid QItemSelectionModel

    if (mSelectionModel == selectionModel) return;

    bool defaultCurrentSet(false);

    if (!selectionModel->currentIndex().isValid()) { // If there is valid current item, do not change it

        if (!mSelectionModel && defaultItem.isValid()) { // mSelectionModel is 0 when called first time

            selectionModel->setCurrentIndex(defaultItem, QItemSelectionModel::Current);

            defaultCurrentSet = true;

        }

        else if (mSelectionModel && mSelectionModel->currentIndex().isValid()) {

            selectionModel->setCurrentIndex(mSelectionModel->currentIndex(),

            QItemSelectionModel::Current);

        }

    }

    mSelectionModel = selectionModel;

    if (mSelectionModel->currentIndex().isValid() && !defaultCurrentSet) {

        scrollTo(mSelectionModel->currentIndex());

    }

    else {

        update();

    }

}

/*!

    Returns the selection model of the container.

    Ownership is not transferred.

*/

QItemSelectionModel *HgContainer::selectionModel() const

{

    FUNC_LOG;

    return mSelectionModel;

}

/*!

    Changes the selection mode of the container (no selection/multiselection).

*/

void HgContainer::setSelectionMode(HgWidget::SelectionMode mode, bool resetSelection)

{

    FUNC_LOG;

    if (mSelectionMode != mode) {

        mSelectionMode = mode;

        if (mSelectionModel && resetSelection) {

            mSelectionModel->clearSelection();

            update();

        }

    }

}

/*!

    Returns the selection mode of the container (no selection/multiselection).

*/

HgWidget::SelectionMode HgContainer::selectionMode() const

{

    FUNC_LOG;

    return mSelectionMode;

}

void HgContainer::dimensions(qreal &screenSize, qreal &worldSize)

{

    const QRectF containerRect(rect());

    if (scrollDirection()== Qt::Vertical) {

        // assume we are in portrait mode, ofcource this might not be the case

        screenSize = containerRect.height()/(mRenderer->getImageSize().height() + mRenderer->getSpacing().height());

        worldSize = worldWidth();

    }

    else{

        screenSize = containerRect.width()/(mRenderer->getImageSize().width() + mRenderer->getSpacing().width());

        worldSize = worldWidth();

    }

}

Qt::Orientation HgContainer::orientation() const

{

    FUNC_LOG;

    return mOrientation;

}

void HgContainer::setOrientation(Qt::Orientation orientation, bool animate)

{

    FUNC_LOG;

    mOrientation = orientation;

    mRenderer->setOrientation(orientation);

    mRenderer->setScrollDirection(orientation, animate);

    if (mSpring.isActive()) {

        // Need to stop scrolling.

        mSpring.cancel();

    }

}

void HgContainer::scrollToPosition(qreal value, bool animate)

{

    FUNC_LOG;

    scrollToPosition(QPointF(value*worldWidth(), 0), animate);

}

void HgContainer::scrollToPosition(const QPointF& pos, bool animate)

{

    FUNC_LOG;

    mAnimateUsingScrollBar = animate;

    initSpringForScrollBar();

    if (animate)

        mSpring.animateToPos(pos);

    else

        mSpring.gotoPos(pos);

}

void HgContainer::scrollTo(const QModelIndex &index)

{

    FUNC_LOG;

    INFO("Scrolling to" << index);

    if (index.isValid() && mRenderer->getRowCount() > 0 ) {

        QRectF containerRect(rect());

        if (containerRect.isNull()) {

            // Container hasn't been resized yet. We need to know the container

            // size before we can calculate if index we are scrolling to is valid.

            // Store scrollTo index and scrolling is performed when container is resized.

            mDelayedScrollToIndex = index;

            return;

        }

        // Container has some size. We can try to calculate if scrollto index is valid.

        // ScrollTo index will be the top item in grid and left item on coverflow.

        if (!mRenderer->coverflowModeEnabled()) {

            // Grid case

            int itemsOnScreen = 0;

            if (scrollDirection()== Qt::Vertical) {

                const int rowHeight = mRenderer->getImageSize().height() + mRenderer->getSpacing().height();

                itemsOnScreen = containerRect.height()/rowHeight;

                if ((int)containerRect.height()%rowHeight) {

                    itemsOnScreen++;

                }

                itemsOnScreen *= rowCount();

                if (itemsOnScreen + index.row() > mItems.count()) {

                    int newItem = mItems.count()-itemsOnScreen;

                    if (mItems.count()%rowCount())

                        newItem += rowCount() - (mItems.count()%rowCount());

                    if (newItem < 0)

                        newItem = 0;

                    scrollToPosition(QPointF(newItem/mRenderer->getRowCount(),0), false);

                } else {

                    scrollToPosition(QPointF(index.row()/mRenderer->getRowCount(), 0), false);

                }

            } else {

                // Scrolldirection is horizontal

                const int rowWidth = mRenderer->getImageSize().width() + mRenderer->getSpacing().width();

                itemsOnScreen = containerRect.width()/rowWidth;

                if ((int)containerRect.height()%rowWidth) {

                    itemsOnScreen++;

                }

                itemsOnScreen *= rowCount();

                if (itemsOnScreen + index.row() > mItems.count()) {

                    int newItem = mItems.count()-itemsOnScreen;

                    if (mItems.count()%rowCount())

                        newItem += rowCount() - (mItems.count()%rowCount());

                    if (newItem < 0) newItem = 0;

                    scrollToPosition(QPointF(newItem/mRenderer->getRowCount(),0), false);

                } else {

                    scrollToPosition(QPointF(index.row()/mRenderer->getRowCount(), 0), false);

                }

            }

            updateBySpringPosition();

        } else {

            // Coverflow case. TODO, this will need some finetuning.

            scrollToPosition(QPointF(index.row()/mRenderer->getRowCount(), 0), false);

            updateBySpringPosition();

        }

    }

}

void HgContainer::itemDataChanged(const QModelIndex &firstIndex, const QModelIndex &lastIndex)

{

    FUNC_LOG;

    // TODO, fix this

    int columns = firstIndex.model()->columnCount(QModelIndex());

    // Check this!!

    int index = columns*firstIndex.row()+firstIndex.column();

    int index2 = columns*lastIndex.row()+lastIndex.column();

    // convert indeces to match one dimensional item array

    itemDataChanged( index, index2 );

}

void HgContainer::addItems(int start, int end)

{

    FUNC_LOG;

    HANDLE_ERROR_NULL(mSelectionModel);

    int first = qBound(0, start, mItems.count()-1);

    int last = qBound(0, end, mItems.count()-1);

    for (int i = 0; i <= end-start; i++) {

        HgWidgetItem* item = new HgWidgetItem(mQuadRenderer);

        mItems.insert(start, item);

    }

    scrollTo(mSelectionModel->currentIndex());

}

void HgContainer::removeItems(int start, int end)

{

    FUNC_LOG;

    HANDLE_ERROR_NULL(mSelectionModel);

    int first = qBound(0, start, mItems.count()-1);

    int last = qBound(0, end, mItems.count()-1);

    for (int i = last; i >= first; i--) {

        delete mItems.at(i);

        mItems.removeAt(i);

    }

    scrollTo(mSelectionModel->currentIndex());

}

void HgContainer::moveItems(int start, int end, int destination)

{

    FUNC_LOG;

    HANDLE_ERROR_NULL(mSelectionModel);

    int first = qBound(0, start, mItems.count()-1);

    int last = qBound(0, end, mItems.count()-1);

    int target = qBound(0, destination, mItems.count()-1);

    if (target < first) {

        for (int i = 0; i <= last-first; i++) {

            mItems.move(first+i, target+i);

        }

    }

    else if (target > last) {

        for (int i = 0; i <= last-first; i++) {

            mItems.move(last-i, target);

        }

    }

    // else do nothing

    scrollTo(mSelectionModel->currentIndex());

}

// TODO: This does exactly the same as HgContainer::itemCount(), should this be thus removed?

int HgContainer::imageCount() const

{

    return mItems.count();

}

const HgImage *HgContainer::image(int index) const

{

    return mItems[index]->image();

}

int HgContainer::flags(int index) const

{

    if (index >= 0 && index < itemCount()) {

        if (mSelectionMode != HgWidget::NoSelection) {

            if (mSelectionModel && mSelectionModel->isSelected(mSelectionModel->model()->index(index, 0))) {

                return 1; // TODO: Assign flag to mark indicator

            } else

                return 2;

        }

    }

    return 0;

}

const HgImage *HgContainer::indicator(int flags)

{

    if (flags != 0 && (!mMarkImageOff || !mMarkImageOn)) {

        // indicators haven't been loaded yet.

        loadIndicatorGraphics();

    }

    if (flags & 1) {

        return mMarkImageOn;

    }

    else if (flags & 2) {

        return mMarkImageOff;

    }

    return 0;

}

void HgContainer::updateBySpringPosition()

{

    // spring works always in one dimension, that is, x coord.

    qreal pos = mSpring.pos().x();

    onScrollPositionChanged(pos);

    emit scrollPositionChanged(pos, mAnimateUsingScrollBar);

    update();

}

void HgContainer::redraw()

{

    update();

}

void HgContainer::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)

{

    Q_UNUSED(option)

    Q_UNUSED(widget)

    // update spring position at paint if needed,

    // this is hack for scrollbar, since dragging it

    // causes also paint events in here

    if (mSpring.updatePositionIfNeeded())

    {

        qreal pos = mSpring.pos().x();

        onScrollPositionChanged(pos);

        emit scrollPositionChanged(pos, true);

    }

    QPainter::RenderHints hints = painter->renderHints();

    painter->setRenderHint(QPainter::SmoothPixmapTransform, true);

    // interpolate spring velocity towards zero, this is done

    // so that spring velocity for rendering doesn't drop directly to

    // zero when dragging starts

    qreal springVel = mSpring.velocity().x();

    if (mDragged) {

        qreal t = qBound(mFramesDragged / KFramesToZeroVelocity, 0.0f, 1.0f);

        springVel = mSpringVelAtDragStart * (1.0f - t);

        mFramesDragged++;

    }

    // setup rendering and draw the current view

    mRenderer->setCameraDistance(getCameraDistance(springVel));

    mRenderer->setCameraRotationY(getCameraRotationY(springVel));

    mRenderer->draw(mSpring.startPos(), mSpring.pos(), mSpring.endPos(),

                    springVel, painter, sceneTransform(), rect());

    painter->setRenderHint(QPainter::SmoothPixmapTransform, (hints.testFlag(QPainter::SmoothPixmapTransform)) );

}

void HgContainer::resizeEvent(QGraphicsSceneResizeEvent *event)

{

    FUNC_LOG;

    HbWidget::resizeEvent(event);

    if (mDelayedScrollToIndex.isValid()) {

        scrollTo(mDelayedScrollToIndex);

        // set scrollto index to invalid value.

        mDelayedScrollToIndex = QModelIndex();

    }

    // Indicator size depends from the item size so

    // indicators need to be updated. Indicators are created

    // in runtime only for need so if they dont exists they aren't created.

    loadIndicatorGraphics(true);

}

// this needs to be implemented for gesture framework to work

void HgContainer::mousePressEvent(QGraphicsSceneMouseEvent *event)