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

**

** 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.h"

#include "hbmodeliterator.h"

#include <hbgesturefilter.h>

#include <hbinstance.h>

#include <hbscrollbar.h>

#include <hbapplication.h>

#include <hbeffect.h>

#include <QGraphicsSceneMouseEvent>

#include <QEvent>

#include <QItemSelectionModel>

#include <QGraphicsScene>

#include <QGraphicsLayout>

#include <QTimer>

#include <QDebug>

HbAbstractItemViewPrivate::HbAbstractItemViewPrivate() :

    mSelectionMode(HbAbstractItemView::NoSelection),

    mOptions(NoOptions),

    mSelectionSettings(None),

    mHitItem(0),

    mContainer(0),

    mSelectionModel(0),

    mContSelectionAction(QItemSelectionModel::NoUpdate),

    mWasScrolling(false),

    mFilterRemoved(false),

    mClearingSelection(false),

    mAnimateItems(false),

    mPostponedScrollHint(HbAbstractItemView::PositionAtTop),

    mPreviousSelectedCommand(QItemSelectionModel::NoUpdate),

    mInstantClickedModifiers(0),

    mAnimationTimer(0),

	mModelIterator(0),

    mEnabledAnimations(HbAbstractItemView::All)

{

}

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

    mContainer = container;

    mContainer->setItemView(q);

    mModelIterator = modelIterator;

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

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

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

}

/*!

    \private

    Slot is called whenever the model layout changes. This resets the container.

*/

void HbAbstractItemViewPrivate::_q_layoutChanged()

{

    mContainer->setModelIndexes(mModelIterator->nextIndex(QModelIndex()));

}

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;

                }

            }

        } 

        mAppearAnimationIndexes.clear();

    }

}

/*!

    \private

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

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

          2) if current item is not wholly visible, first visible item before layout switch is made visible

          In either case the visible item is at top of the view or as near as possible

 */

void HbAbstractItemViewPrivate::saveIndexMadeVisibleAfterMetricsChange()

{

    QModelIndex firstVisibleModelIndex;

    QModelIndex lastVisibleModelIndex;

    mContainer->firstAndLastVisibleModelIndex(firstVisibleModelIndex, lastVisibleModelIndex);

    int firstVisibleRow = firstVisibleModelIndex.isValid() ? firstVisibleModelIndex.row() : 0;

    int lastVisibleRow = lastVisibleModelIndex.isValid() ? lastVisibleModelIndex.row() : 0;

    // save current, if it is visible

    firstVisibleRow = qMax(0, firstVisibleRow);

    lastVisibleRow = qMax(0, lastVisibleRow);

    if (mCurrentIndex.row() >= firstVisibleRow 

        && mCurrentIndex.row() <= lastVisibleRow) {

        mVisibleIndex = mCurrentIndex;

    } else if (mModelIterator->model()) {

        mVisibleIndex = mModelIterator->index(firstVisibleRow);

    }

}

/*!

    \private

    Minimum amount of pixels to scroll to make \a item visible.

    Negative value scrolls view up, and positive value vice versa.

    Returns 0, if no scrolling is needed.

    Horizontally ensures that item is visible. 

 */

QPointF HbAbstractItemViewPrivate::pixelsToScroll(const HbAbstractViewItem *item,

                                                  HbAbstractItemView::ScrollHint hint)

{

    Q_Q(HbAbstractItemView);

    QPointF result(0,0);

    if (item) {

        refreshContainerGeometry();

        QRectF itemRect = itemBoundingRect(item);

        QRectF viewRect = q->boundingRect();

        if (!viewRect.isValid()) {

            return result;

        }

        QSizeF sizeOffset;

        sizeOffset.setHeight(qMin(itemRect.height(), viewRect.height()));

        sizeOffset.setWidth(qMin(itemRect.width(), viewRect.width()));

        if (mScrollDirections & Qt::Vertical) {

            switch (hint) {

                case HbAbstractItemView::PositionAtTop: {

                    result.setY(itemRect.bottom() - viewRect.top() - sizeOffset.height());

                    break;

                }

                case HbAbstractItemView::PositionAtBottom: {

                    result.setY(itemRect.top() + sizeOffset.height() - viewRect.bottom());

                    break;

                }

                case HbAbstractItemView::PositionAtCenter: {

                    qreal yCentre = viewRect.top() + (viewRect.height()) / 2 ;

                    result.setY(itemRect.top() - yCentre + sizeOffset.height()/2);

                    break;

                }

                case HbAbstractItemView::EnsureVisible:

                default: {

                    if (itemRect.top() < viewRect.top()) { 

                        result.setY(itemRect.bottom() - viewRect.top() - sizeOffset.height());

                    } else if (itemRect.bottom() > viewRect.bottom()) {

                        result.setY(itemRect.top() + sizeOffset.height() - viewRect.bottom());

                    }

                    break;

                }

            }

            if (itemRect.width() < viewRect.width()) {

                if (itemRect.left() < viewRect.left()) {

                    result.setX(itemRect.left() - viewRect.left());

                } else if (itemRect.right() > viewRect.right()) {

                    result.setX(itemRect.right() - viewRect.right());

                }

            } else {

                // item does not fit in the screen, always align according to 

                // mirroring 

                if (HbApplication::layoutDirection() == Qt::LeftToRight) {

                    result.setX(itemRect.left() - viewRect.left());

                } else {                

                    result.setX(itemRect.right() - viewRect.right());

                }

            }

        }

        else if (mScrollDirections & Qt::Horizontal) {

            switch (hint) {

                case HbAbstractItemView::PositionAtTop: {    // left

                    result.setX(itemRect.right() - viewRect.left() - sizeOffset.width());

                    break;

                }

                case HbAbstractItemView::PositionAtBottom: { // right

                    result.setX(itemRect.left() + sizeOffset.width() - viewRect.right());

                    break;

                }

                case HbAbstractItemView::PositionAtCenter: {

                    qreal xCentre = viewRect.left() + (viewRect.width()) / 2 ;

                    result.setX(itemRect.left() - xCentre + sizeOffset.width()/2);

                    break;

                }

                case HbAbstractItemView::EnsureVisible:

                default: {

                    if (itemRect.left() < viewRect.left()) { 

                        result.setX(itemRect.right() - viewRect.left() - sizeOffset.width());

                    } else if (itemRect.right() > viewRect.right()) {

                        result.setX(itemRect.left() + sizeOffset.width() - viewRect.right());

                    }

                    break;

                }

            }

            if (itemRect.top() < viewRect.top()) {

                result.setY(itemRect.top() - viewRect.top());

            } else if (itemRect.bottom() > viewRect.bottom()) {

                result.setY(itemRect.bottom() - viewRect.bottom());

            }

        }

    }

    return result;

}

QItemSelectionModel::SelectionFlags HbAbstractItemViewPrivate::singleSelectionCommand(

        const HbAbstractViewItem *item,

        const QEvent *event)

{

    if (item) {

        switch (event->type())  {

        case QEvent::GraphicsSceneMousePress: 

        case QEvent::GraphicsSceneMouseDoubleClick:

            if (item->selectionAreaContains(static_cast<const QGraphicsSceneMouseEvent *>(event)->scenePos())) {

                mSelectionSettings |= Selection;

            }

            break;

        case QEvent::GraphicsSceneMouseRelease:

            if (    mHitItem

                &&  item->modelIndex() == mHitItem->modelIndex()

                &&  mSelectionSettings.testFlag(Selection)) {

                mSelectionSettings &= ~Selection;

                return QItemSelectionModel::ClearAndSelect;

            }

            break;

        default:

            break;

        }

    }

    return QItemSelectionModel::NoUpdate;

}

QItemSelectionModel::SelectionFlags HbAbstractItemViewPrivate::multiSelectionCommand(

        const HbAbstractViewItem *item,

        const QEvent *event)

{

    if (item) {

        switch (event->type())  {

        case QEvent::GraphicsSceneMousePress: 

        case QEvent::GraphicsSceneMouseDoubleClick:

            if (item->selectionAreaContains(static_cast<const QGraphicsSceneMouseEvent *>(event)->scenePos())) {

                mSelectionSettings |= Selection;

            }

            break;

        case QEvent::GraphicsSceneMouseRelease:

            if (mHitItem

                && item->modelIndex() == mHitItem->modelIndex() 

                && mSelectionSettings.testFlag(Selection)) {

                mSelectionSettings &= ~Selection;

                return QItemSelectionModel::Toggle;

            }

            break;

        default:

            break;

        }

    }

    return QItemSelectionModel::NoUpdate;

}

QItemSelectionModel::SelectionFlags HbAbstractItemViewPrivate::contiguousSelectionCommand(

        const HbAbstractViewItem *item,

        const QEvent *event )

{

    Q_Q(HbAbstractItemView);

    if (item) {

        switch (event->type()) {

        case QEvent::GraphicsSceneMousePress: 

        case QEvent::GraphicsSceneMouseDoubleClick: {

            if (item->selectionAreaContains(static_cast<const QGraphicsSceneMouseEvent *>(event)->scenePos())) {

                mSelectionSettings |= Selection;

                if (mSelectionModel && mSelectionModel->isSelected(item->modelIndex())) {

                    mContSelectionAction = QItemSelectionModel::Deselect;

                } else {

                    mContSelectionAction = QItemSelectionModel::Select;

                }

                // TODO: This should be changed to changing the gesture area of effect when that is possible...

                // Gesture filter does not reset all of its internals: workaround is to delete and create the filter

                q->setLongPressEnabled(false);

                q->removeSceneEventFilter(mGestureFilter);

                mFilterRemoved = true;

            }

            break;

            }