/****************************************************************************

**

** Copyright (C) 2008-2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (developer.feedback@nokia.com)

**

** This file is part of the HbWidgets module of the UI Extensions for Mobile.

**

** GNU Lesser General Public License Usage

** This file may be used under the terms of the GNU Lesser General Public

** License version 2.1 as published by the Free Software Foundation and

** appearing in the file LICENSE.LGPL included in the packaging of this file.

** Please review the following information to ensure the GNU Lesser General

** Public License version 2.1 requirements will be met:

** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at developer.feedback@nokia.com.

**

****************************************************************************/

#include "hbabstractitemview_p.h"

#include "hbabstractitemview.h"

#include "hbabstractviewitem.h"

#include "hbabstractitemcontainer_p.h"

#include "hbmodeliterator.h"

#include <hbinstance.h>

#include <hbscrollbar.h>

#include <hbapplication.h>

#include <hbeffect.h>

#include <hbpangesture.h>

#include <hbwidgetfeedback.h>

#include <QGraphicsSceneMouseEvent>

#include <QEvent>

#include <QItemSelectionModel>

#include <QGraphicsScene>

#include <QGraphicsLayout>

#include <QTimer>

#include <QGestureEvent>

#include <QDebug>

static const qreal CONTIGUOUS_SELECTION_SCROLL_SPEED = 0.2;

static const qreal CONTIGUOUS_SELECTION_AREA_THRESHOLD = 0.2;

HbAbstractItemViewPrivate::HbAbstractItemViewPrivate() :

    mSelectionMode(HbAbstractItemView::NoSelection),

    mOptions(NoOptions),

    mSelectionSettings(None),

    mContainer(0),

    mSelectionModel(0),

    mContSelectionAction(QItemSelectionModel::NoUpdate),

    mClearingSelection(false),

    mAnimateItems(false),

    mPostponedScrollHint(HbAbstractItemView::PositionAtTop),

    mPreviousSelectedCommand(QItemSelectionModel::NoUpdate),

    mAnimationTimer(0),

	mModelIterator(0),

    mEnabledAnimations(HbAbstractItemView::All),

    mLongPressEnabled(true),

	mDoingContiguousSelection(false)

{

}

HbAbstractItemViewPrivate::~HbAbstractItemViewPrivate()

{

    if (mModelIterator) {

        delete mModelIterator;

        mModelIterator = 0;

    }

}

/*!

*/

void HbAbstractItemViewPrivate::init(HbAbstractItemContainer *container, HbModelIterator *modelIterator)

{

    Q_Q(HbAbstractItemView);

    q->setLongPressEnabled(true);

    q->setFlag(QGraphicsItem::ItemIsFocusable, true);

    q->setFocusPolicy(Qt::StrongFocus);

    q->setContentWidget(container);

    q->grabGesture(Qt::PanGesture);

    //mAlignment = 0; // no alignment - there is no sense with recycling

    mContainer = container;

    mContainer->setItemView(q);

    mModelIterator = modelIterator;

    q->connect(mContainer, SIGNAL(itemCreated(HbAbstractViewItem *)),

            q, SLOT(itemCreated(HbAbstractViewItem *)));

    HbMainWindow *window = q->mainWindow();

    if (window

        && q->scene()) { // added to scene

        q->connect(window, SIGNAL(aboutToChangeOrientation()),

                   q, SLOT(orientationAboutToBeChanged()));

        q->connect(window, SIGNAL(orientationChanged(Qt::Orientation)),

                   q, SLOT(orientationChanged(Qt::Orientation)));

        if (q->verticalScrollBar()) {

            q->verticalScrollBar()->installSceneEventFilter(q);

        }

        if (q->horizontalScrollBar()) {

            q->horizontalScrollBar()->installSceneEventFilter(q);

        }

    }

}

/*!

    Replaces current model with the given one. This deletes the existing

    view items and calls reset() to update the view to correspond to 

    current model. 

*/

void HbAbstractItemViewPrivate::setModel(QAbstractItemModel *model)

{

    Q_Q(HbAbstractItemView);

    if (model != mModelIterator->model()) {

        mAnimateItems = false;

        clearCurrentModel();

        mModelIterator->setModel(model);

        initializeNewModel();

        q->reset();

        if (!mAnimationTimer) {

            mAnimationTimer = new QTimer(q);

            mAnimationTimer->setObjectName(QString("animationTimer"));

            mAnimationTimer->setSingleShot(true);

            QObject::connect(mAnimationTimer, SIGNAL(timeout()), q, SLOT(_q_animationEnabled()));

        }

        mAnimationTimer->start(3000);

    }

}

/*!

    Resets current model,selection Model,mRootIndex and mCurrentIndex to null. 

*/

void HbAbstractItemViewPrivate::clearCurrentModel()

{

    Q_Q(HbAbstractItemView);

    if (mModelIterator->model()) {

        QAbstractItemModel *model = mModelIterator->model();

        q->disconnect(model, SIGNAL(destroyed()),

                      q, SLOT(_q_modelDestroyed()));

        q->disconnect(model, SIGNAL(dataChanged(QModelIndex,QModelIndex)),

                      q, SLOT( dataChanged(QModelIndex,QModelIndex)));

        q->disconnect(model, SIGNAL(rowsInserted(QModelIndex,int,int)),

                      q, SLOT(rowsInserted(QModelIndex,int,int)));

        q->disconnect(model, SIGNAL(rowsRemoved(QModelIndex,int,int)),

                      q, SLOT(rowsRemoved(QModelIndex,int,int)));

        q->disconnect(model, SIGNAL(rowsAboutToBeRemoved(QModelIndex,int,int)),

                      q, SLOT(rowsAboutToBeRemoved(QModelIndex,int,int)));

        q->disconnect(model, SIGNAL(rowsAboutToBeInserted(QModelIndex,int,int)),

                      q, SLOT(rowsAboutToBeInserted(QModelIndex,int,int)));

        q->disconnect(model, SIGNAL(columnsInserted(QModelIndex,int,int)),

                        q, SLOT(columnsInserted(QModelIndex,int,int)));

        q->disconnect(model, SIGNAL(columnsAboutToBeInserted(QModelIndex,int,int)),

                        q, SLOT(columnsAboutToBeInserted(QModelIndex,int,int)));

        q->disconnect(model, SIGNAL(columnsRemoved(QModelIndex,int,int)),

                        q, SLOT(columnsRemoved(QModelIndex,int,int)));

        q->disconnect(model, SIGNAL(columnsAboutToBeRemoved(QModelIndex,int,int)),

                        q, SLOT(columnsAboutToBeRemoved(QModelIndex,int,int)));

        q->disconnect(model, SIGNAL(modelReset()), q, SLOT(reset()));

        q->disconnect(model, SIGNAL(layoutChanged()), q, SLOT(modelLayoutChanged()));

        mModelIterator->setModel(0);

    }

    setSelectionModel(0);

    mCurrentIndex = QModelIndex();

    mModelIterator->setRootIndex(QPersistentModelIndex());

}

/*!

    Updates current selectionModel to selectionModel.If selectionModel is invalid, current

    selectionModel is not updated.

*/

void HbAbstractItemViewPrivate::setSelectionModel(QItemSelectionModel *selectionModel)

{

    Q_Q( HbAbstractItemView );

    if (selectionModel

        && selectionModel->model() != mModelIterator->model()) {

        qWarning("QAbstractItemView::setSelectionModel() failed: "

                 "Trying to set a selection model, which works on "

                 "a different model than the view.");

        return;

    }

    if (mSelectionModel) {

        q->disconnect(mSelectionModel, SIGNAL(selectionChanged(QItemSelection, QItemSelection)),

                       q, SLOT(currentSelectionChanged(QItemSelection, QItemSelection)));

        q->disconnect(mSelectionModel, SIGNAL(currentChanged(QModelIndex, QModelIndex)),

                       q, SLOT(currentIndexChanged(QModelIndex, QModelIndex)));

        delete mSelectionModel;

        mSelectionModel = 0;

    }

    mSelectionModel = selectionModel;

    if (mSelectionModel) {

        q->connect(mSelectionModel, SIGNAL(selectionChanged(QItemSelection, QItemSelection)),

                   q, SLOT(currentSelectionChanged(QItemSelection, QItemSelection)));

        q->connect(mSelectionModel, SIGNAL(currentChanged(QModelIndex, QModelIndex)),

                    q, SLOT(currentIndexChanged(QModelIndex, QModelIndex)));

    }

}

/*!

    Initializes newModel

*/

void HbAbstractItemViewPrivate::initializeNewModel()

{

    Q_Q(HbAbstractItemView);

    if (mModelIterator->model()) {

        QAbstractItemModel *model = mModelIterator->model();

        // These asserts do basic sanity checking of the model

        Q_ASSERT_X(model->index(0,0) == model->index(0,0),

                   "HbAbstractItemView::setModel",

                   "A model should return the exact same index "

                   "(including its internal id/pointer) when asked for it twice in a row.");

        Q_ASSERT_X(model->index(0,0).parent() == QModelIndex(),

                   "HbAbstractItemView::setModel",

                   "The parent of a top level index should be invalid");

        q->connect(model, SIGNAL(destroyed()),

                   q, SLOT(_q_modelDestroyed()));

        q->connect(model, SIGNAL(dataChanged(QModelIndex,QModelIndex)),

                   q, SLOT( dataChanged(QModelIndex,QModelIndex)));

        q->connect(model, SIGNAL(rowsInserted(QModelIndex,int,int)),

                   q, SLOT(rowsInserted(QModelIndex,int,int)));

        q->connect(model, SIGNAL(rowsAboutToBeRemoved(QModelIndex,int,int)),

                   q, SLOT(rowsAboutToBeRemoved(QModelIndex,int,int)));

        q->connect(model, SIGNAL(rowsRemoved(QModelIndex,int,int)),

                   q, SLOT(rowsRemoved(QModelIndex,int,int)));

        q->connect(model, SIGNAL(rowsAboutToBeInserted(QModelIndex,int,int)),

                   q, SLOT(rowsAboutToBeInserted(QModelIndex,int,int)));

        q->connect(model, SIGNAL(columnsInserted(QModelIndex,int,int)),

                      q, SLOT(columnsInserted(QModelIndex,int,int)));

        q->connect(model, SIGNAL(columnsAboutToBeInserted(QModelIndex,int,int)),

                   q, SLOT(columnsAboutToBeInserted(QModelIndex,int,int)));

        q->connect(model, SIGNAL(columnsRemoved(QModelIndex,int,int)),

                      q, SLOT(columnsRemoved(QModelIndex,int,int)));

        q->connect(model, SIGNAL(columnsAboutToBeRemoved(QModelIndex,int,int)),

                   q, SLOT(columnsAboutToBeRemoved(QModelIndex,int,int)));

        q->connect(model, SIGNAL(modelReset()), q, SLOT(reset()));

        q->connect(model, SIGNAL(layoutChanged()), q, SLOT(modelLayoutChanged()));

        setSelectionModel(new QItemSelectionModel(model, q));

    }   

}

/*!

    \private

    Slot is called whenever the model is destroyed.

    deletes all children and disconnects all signal- slot connections

    with model and selectionmodel

*/

void HbAbstractItemViewPrivate::_q_modelDestroyed()

{

    Q_Q(HbAbstractItemView);

    mModelIterator->setModel(0);

    setSelectionModel(0);

    q->reset();

}

void HbAbstractItemViewPrivate::_q_animationEnabled()

{

    mAnimateItems = true;

}

void HbAbstractItemViewPrivate::_q_animationFinished(const HbEffect::EffectStatus &status)

{

    Q_UNUSED(status);

    if (status.effectEvent == "appear") {

        if (mPostponedScrollIndex.isValid()) { 

            int count = mAppearAnimationIndexes.count();

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

                if (mPostponedScrollIndex == mAppearAnimationIndexes.at(i)) {

                    scrollTo(mPostponedScrollIndex, mPostponedScrollHint);

                    break;

                }

            }

        } 

        status.item->setFlag(QGraphicsItem::ItemSendsGeometryChanges, false);

        mAppearAnimationIndexes.clear();

    }

}

/*!

    \reimp

*/

void HbAbstractItemViewPrivate::setContentPosition(qreal value, Qt::Orientation orientation, bool animate)

{

    Q_Q(HbAbstractItemView);

    if (handleScrollBar(orientation)) {

        if (mContainer->layout() && !mContainer->layout()->isActivated()) {

            mContainer->layout()->activate();

        }

        HbAbstractViewItem *firstItem = mContainer->items().first();

        qreal itemHeight;

        if (mContainer->uniformItemSizes()) {

            itemHeight = firstItem->size().height();

        } else {

            // avarrage height based on container content

            itemHeight = mContainer->size().height() / mContainer->items().size();

        }

        qreal visiblePos = -mContainer->pos().y()

                           + mModelIterator->indexPosition(firstItem->modelIndex()) * itemHeight;

        qreal viewHeight = q->boundingRect().height();

        qreal modelHeight = itemHeight * mModelIterator->indexCount() - viewHeight;

        qreal thumbPos = visiblePos / modelHeight;

        qreal diff = (value - thumbPos) * modelHeight;

        q->scrollByAmount(QPointF(0, diff));

    } else {

        HbScrollAreaPrivate::setContentPosition(value, orientation, animate);

    }

    if (animate) {

        updateScrollBar(orientation);

    }

}

bool HbAbstractItemViewPrivate::panTriggered(QGestureEvent *event)

{

    Q_Q(HbAbstractItemView);

    HbPanGesture *gesture = static_cast<HbPanGesture *>(event->gesture(Qt::PanGesture));

    switch (gesture->state()) {

        case Qt::GestureStarted:

            mOptions |= PanningActive;

            // Fallthrough

        case Qt::GestureUpdated: {

            QPointF scenePos = event->mapToGraphicsScene(gesture->hotSpot());

            if (mDoingContiguousSelection) {

                int retVal = false;

                // loop through the items in the scene

                qreal scenePosY = scenePos.y();

                QPointF lastScenePos = scenePos + gesture->lastOffset() - gesture->offset();

                qreal lastScenePosY = lastScenePos.y();

                QPolygonF polygon;

                polygon << lastScenePos << scenePos;

                QList<QGraphicsItem *> items = q->scene()->items(polygon);

                int itemCount = items.count();

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

                    HbAbstractViewItem *item = viewItem(items.at(current));

                    if (item && item->itemView() == q) {

                        QModelIndex itemIndex(item->modelIndex());

                        QGraphicsSceneMouseEvent mouseMoveEvent(QEvent::GraphicsSceneMouseMove);

                        QPointF scenePosInItemCoordinates = item->mapFromScene(scenePos);

                        QPointF position(qBound((qreal)0.0, scenePosInItemCoordinates.x(), item->size().width()), 

                                         qBound((qreal)0.0, scenePosInItemCoordinates.y(), item->size().height()));

                        mouseMoveEvent.setPos(position);

                        QItemSelectionModel::SelectionFlags command = q->selectionCommand(item, &mouseMoveEvent);

						// in contiguousselectionarea there shall be no panning from HbScrollArea, thus return true

                        if (command != QItemSelectionModel::NoUpdate) {

                            retVal = true;

                        }

                        if ( itemIndex != mPreviousSelectedIndex

                          || command != mPreviousSelectedCommand) {

                            mPreviousSelectedIndex = itemIndex;

                            mPreviousSelectedCommand = command;

                            mSelectionModel->select(itemIndex, command);

                        }

                        // check if we need to start or keep on scrolling

                        int scrollDirection = 0;

                        QPointF pos = q->mapFromScene(scenePos);

                        if (pos.y() < (q->size().height() * CONTIGUOUS_SELECTION_AREA_THRESHOLD)) {

                             if (q->isScrolling()

                                 || (!q->isScrolling()

                                     && lastScenePosY >= scenePosY)) {                                

                                 scrollDirection = 1;

                             }

                        } else if (pos.y() > (q->size().height() * (1 - CONTIGUOUS_SELECTION_AREA_THRESHOLD))) {

                             if (q->isScrolling()

                                 || (!q->isScrolling()

                                     && lastScenePosY <= scenePosY)) {

                                 scrollDirection = -1;

                             }                        

                        }

                        // Start scrolling if needed. 

                        if (scrollDirection != 0) {

                            if (!mIsAnimating) {

                                mPositionInContiguousSelection = scenePos;

                                QObject::connect(q, SIGNAL(scrollPositionChanged(QPointF)), q, SLOT(_q_scrolling(QPointF)));    

                                QObject::connect(q, SIGNAL(scrollingEnded()), q, SLOT(_q_scrollingEnded()));    

                                QObject::connect(q, SIGNAL(scrollingStarted()), q, SLOT(_q_scrollingStarted()));    

                                animateScroll(QPointF (0.0f, scrollDirection * CONTIGUOUS_SELECTION_SCROLL_SPEED));

                                retVal = true;

                            }

                        } else if (q->isScrolling()) {

                            stopAnimating();

                            retVal = true;

                        }

                        break;

                    }

                }

                return retVal;

            }

            else if (!mDoingContiguousSelection){

                HbWidgetFeedback::continuousTriggered(q, Hb::ContinuousScrolled);

            }

            break;

        }

        case Qt::GestureFinished: 

        case Qt::GestureCanceled: {

            mOptions &= ~PanningActive;

            if (mDoingContiguousSelection) {

                stopAnimating();

                mDoingContiguousSelection = false;

                return true;

            }

            else {

                HbWidgetFeedback::continuousStopped(q, Hb::ContinuousScrolled);

            }

            break;

        }

        default:

            break;

    }

    return false;

}

/*!

    This slot is called when the view is scrolling doing countinuousselection. It does the item 

    selection/deselection 

*/

void HbAbstractItemViewPrivate::_q_scrolling(QPointF newPosition)

{

    Q_UNUSED(newPosition);

    HbAbstractViewItem* hitItem = itemAt(mPositionInContiguousSelection);

    if (hitItem) {

        QModelIndex itemIndex(hitItem->modelIndex());

        if ( itemIndex != mPreviousSelectedIndex) {

            mPreviousSelectedIndex = itemIndex;

            mSelectionModel->select(itemIndex, mPreviousSelectedCommand);

        }

    }

}

/*!

    This slot is called when scrolling during continuousselction ends. It restores the original scrolling parameters 

*/

void HbAbstractItemViewPrivate::_q_scrollingEnded()

{

    Q_Q(HbAbstractItemView);

    mFrictionEnabled = mOrigFriction;

    QObject::disconnect(q, SIGNAL(scrollPositionChanged(QPointF)), q, SLOT(_q_scrollingI(QPointF)));    

    QObject::disconnect(q, SIGNAL(scrollingEnded()), q, SLOT(_q_scrollingEnded()));    

    QObject::disconnect(q, SIGNAL(scrollingStarted()), q, SLOT(_q_scrollingStarted()));    

}

/*!

    This slot is called when scrolling during continuousselction starts. It saves the original scrolling parameters 

*/

void HbAbstractItemViewPrivate::_q_scrollingStarted()

{

    mOrigFriction = mFrictionEnabled;

    mFrictionEnabled = false;

}

/*!

    \private

    When orientation switch occurs, 1) or 2) is applied to view after layout switch:

          1) if last item is wholly visible, it will be visible

          2) if last item is not fully visible, the first fully visible item before layout switch is made the 

		     first fully visible item

 */

void HbAbstractItemViewPrivate::saveIndexMadeVisibleAfterMetricsChange()

{

    QModelIndex firstVisibleModelIndex;

    QModelIndex lastVisibleModelIndex;

    mContainer->firstAndLastVisibleModelIndex(firstVisibleModelIndex, lastVisibleModelIndex);