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

**

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

#include <hbabstractitemview.h>

#include <hbabstractviewitem.h>

#include <hbevent.h>

#include <hbabstractitemcontainer_p.h>

#include <hbwidgetfeedback.h>

#include <hbinstance.h>

#include <hbscrollbar.h>

#include <hbmodeliterator.h>

#include <QGraphicsSceneMouseEvent>

#include <QGraphicsScene>

#include <QDebug>

#include <QGesture>

#include <QGestureEvent>

#include <QPanGesture>

/*!

    @alpha

    @hbwidgets

    \class HbAbstractItemView

    \brief HbAbstractItemView provides basic functionality for item View Classes.  

    HbAbstractItemView is an abstract class and cannot itself be instantiated.

    HbAbstractItemView class can be used as the base class for every standard view that uses QAbstractItemModel.

    It provides a standard interface for interoperating with models(QAbstractItemModel and QItemSelectionModel)

    through signals and slots mechanism, enabling subclasses to be kept up-to-date with changes to their models.

    This class provides a default selection Model to work with. Application can set its own selection Model.

    There are several functions concerned with selection control like clearSelection(), selectAll(), setSelectionMode().

    HbAbstractItemView provides standard support for mouse navigation and scrolling of items,

    selections.

    \b Subclassing

    HbAbstractItemView can be subclassed for customization purposes. Derived class must provide

    implementation of scrollTo(). 

    Each view item is represented by an instance of HbAbstractViewItem. HbAbstractViewItem

    can be subclassed for customization purposes.

    HbAbstractItemView can use item recycling. This means that only visible items

    plus a small buffer of items above and below the visible area are instantiated at a time. 

    When the view is scrolled view items are recycled so that buffer size above and below the 

    visible area is kept constant.By default this feature is disabled. 

*/

/*!

    \fn void HbAbstractItemView::pressed(const QModelIndex &index)

    This signal is emitted when a touch down event is received within

    Abstract view item that is representing \a index.

    See also released() and activated().

*/

/*!

  \fn void HbAbstractItemView::released(const QModelIndex &index)

    This signal is emitted when a touch release event is received within

    Abstract view item that is representing \a index.

    See also pressed() and activated().

*/

/*!

    \fn void HbAbstractItemView::activated(const QModelIndex &index)

    This signal is emitted when the item specified by \a index is activated by the user.

    How to activate items depends on the input method; e.g., with mouse by clicking the item

    or with touch input by tapping the item.

    See also pressed() and released().

*/

/*!

    \fn void HbAbstractItemView::longPressed(HbAbstractViewItem *item, const QPointF &coords)

    This signal is emitted when long press event is received within

    Abstract view item \a viewItem. \a coords is scene position where the long press event happened.

*/

/*!

    \enum HbAbstractItemView::SelectionMode

    selection types supported by HbAbstractItemView.

    This enum describes different selection types available in LibHb.

*/

/*!

    \var HbAbstractItemView::NoSelection

    Items cannot be selected. This is the default value.

*/

/*!

    \var HbAbstractItemView::SingleSelection

    When the user selects an item, any already-selected item becomes unselected, and the user cannot

    unselect the selected item. 

*/

/*!

    \var HbAbstractItemView::MultiSelection

    When the user selects an item in the usual way, the selection state of that item

    is toggled and the other items are left alone. 

*/

/*!

    \enum HbAbstractItemView::ItemAnimation

    animations in HbAbstractItemView that can be disabled. By default all animations are enabled.

*/

/*!

    \var HbAbstractItemView::Appear

    Animation related to item appearance. Disable this animation in cases you expect many model items to appear,

	for example in case like insertion of a new data source, and you do not wish to see animations.

	Note that the item appearance animations are not used directly after a setModel call to force non-animated model change. 

*/

/*!

    \var HbAbstractItemView::Disappear

    Animation related to item removal. Disable this animation in cases you expect many model items to disappear,

	for example in cases like filtering or removal of a data source, and you do not wish to see animations.

*/

/*!

    \var HbAbstractItemView::TouchDown

    Animation related to item press and release.

*/

/*!

    \var HbAbstractItemView::Expand

    Animation related to setting item expand.

*/

/*!

    \var HbAbstractItemView::Collapse

    Animation related to setting item collapsed.

*/

/*!

    Here are the main properties of the class:

    \li HbAbstractItemView::itemRecycling: ItemRecycling.

    \li HbAbstractItemView::SelectionMode: Different selection types supported by view.

    \li HbAbstractItemView::bufferSize   : Buffer Size used for item recycling.

    \li HbAbstractItemView::uniformItemSizes : This property holds whether all items in the item view have the same size.

*/

/*!

    \fn void HbAbstractItemView::scrollTo(const QModelIndex &index,

        HbAbstractItemView::ScrollHint hint = EnsureVisible)

    Scrolls the view if necessary to ensure that the item at \a index is visible

    in a position according to \a hint. Default value just guarantees, that item will be fully visible. 

*/

/*!

    See also HbAbstractItemManager, HbAbstractViewItem, HbAbstractItemContainer.

*/

/*!

    Constructs a new HbAbstractItemView with \a parent.

*/

HbAbstractItemView::HbAbstractItemView(HbAbstractItemViewPrivate &dd, 

                                       HbAbstractItemContainer *container,

                                       HbModelIterator *modelIterator,

                                       QGraphicsItem *parent)

    : HbScrollArea(dd, parent)

{

    Q_D(HbAbstractItemView);

    Q_ASSERT_X(container, "HbAbstractItemView constructor", "Container is null");

    d->q_ptr = this;

    d->init(container, modelIterator);

}

/*!

    Destructs the abstract item view.

 */

HbAbstractItemView::~HbAbstractItemView()

{

}

/*!

    Returns model that view is currently presenting.

*/

QAbstractItemModel *HbAbstractItemView::model() const

{

    Q_D(const HbAbstractItemView);

    return d->mModelIterator->model();

}

/*!

    Sets the model to \a model and replaces current item prototype with \a prototype.

    Ownership of the model is not taken. Ownership of the prototype is taken. 

    If no prototype has been passed, default prototype is used.

    Note! Itemview may create view items asynchronously.

 */

void HbAbstractItemView::setModel(QAbstractItemModel *model, HbAbstractViewItem *prototype)

{

    Q_D(HbAbstractItemView);

    if(prototype) {

        setItemPrototype(prototype);

    }

    d->setModel(model);

}

/*!

    Returns the list of item prototypes.

*/

QList<HbAbstractViewItem *> HbAbstractItemView::itemPrototypes() const

{

    Q_D(const HbAbstractItemView);

    return d->mContainer->itemPrototypes();

}

/*!

    Replaces current item prototypes with \a prototype. Ownership is taken.

    Concrete item views provided by library have view specific view item prototype set by default.

    Note! This function may cause that view items are recreated. They may be created asynchronously.

*/

void HbAbstractItemView::setItemPrototype(HbAbstractViewItem *prototype)

{

    Q_D(HbAbstractItemView);

    if (prototype && d->mContainer->setItemPrototype(prototype))  {

        d->resetContainer();

    }

}

/*!

    To support multiple Abstractview items within single AbstractItemview.

    Replace current item prototypes with list of \a prototypeList. Ownership is taken.

    Setting more than one prototype will disable item recycling feature.

    When list view item is being created, HbAbstractViewItem::canSetModelIndex()

    is called for every item until item is found, which can create an item for

    a model index. The prototype list is gone through from end to the beginning. 

    Thus specialized prototypes should be in the end of the list and 

    'default' prototype first one. The specialized prototypes usually can create

    only certain types of list view items. The default prototype usually return always true,

    meaning that it can create any type of list view item. 

    Concrete item views provided by library have view specific view item prototype set.

    Note! This function may cause that view items are recreated. They may be created asynchronously.

    \sa HbAbstractViewItem::canSetModelIndex()

*/

void HbAbstractItemView::setItemPrototypes(const QList<HbAbstractViewItem *> &prototypes)

{

    Q_D(HbAbstractItemView);

    if(prototypes.count() > 0) {

        if (d->mContainer->setItemPrototypes(prototypes)) {

            d->resetContainer();

        }

    }

}

/*!

    Returns the current selection model.

*/

QItemSelectionModel *HbAbstractItemView::selectionModel() const

{

    Q_D(const HbAbstractItemView);

    return d->mSelectionModel;

}

/*!

    Sets the current selection model to \a selectionModel.

    Note: If setModel() is called after this function, the given selectionModel will be

    replaced by default selection model of the view.

 */

void HbAbstractItemView::setSelectionModel(QItemSelectionModel *selectionModel)

{

    Q_D(HbAbstractItemView);

    if (selectionModel 

        &&  d->mSelectionModel != selectionModel) {

        d->setSelectionModel(selectionModel);

    }

}

/*!

    If \a newMode is not same as current selection mode of view,

    updates selection mode, all viewitems and clears all existing selections.

 */

void HbAbstractItemView::setSelectionMode(SelectionMode newMode)

{

    Q_D(HbAbstractItemView);

    if (d->mSelectionMode != newMode) {

        d->mSelectionMode = newMode;

        clearSelection();

        d->updateItems();

    }

}

/*!

    Selects all items in the view.

 */

void HbAbstractItemView::selectAll()

{

    Q_D(HbAbstractItemView);

        d->mSelectionModel->select(QItemSelection(firstIndex, lastIndex), QItemSelectionModel::Select);

    }

}

/*!

    Deselects all selected items. The current index will not be changed.

 */

void HbAbstractItemView::clearSelection()

{

    Q_D(HbAbstractItemView);

    if (d->mSelectionModel) {

        d->mClearingSelection = true;

        d->mSelectionModel->clearSelection();

        d->mClearingSelection = false;

    }

}

/*!

    Returns current selection mode used by view.

 */

HbAbstractItemView::SelectionMode HbAbstractItemView::selectionMode() const

{

    Q_D(const HbAbstractItemView);

    return d->mSelectionMode;

}

/*!

    Returns index of current item.

 */

QModelIndex HbAbstractItemView::currentIndex() const

{

    Q_D(const HbAbstractItemView);

    return d->mCurrentIndex;

}

/*!

   Sets current index to \a index. The item is selected depending on the \a selectionFlag.

   By default item is not selected. If current selection mode is NoSelection,

   item is not selected irrespective of the selection flag.

 */

void HbAbstractItemView::setCurrentIndex(const QModelIndex &index, 

                                         QItemSelectionModel::SelectionFlags selectionFlag)

{

    Q_D(HbAbstractItemView);

    if (d->mSelectionModel) {

        if (d->mSelectionMode == NoSelection) {

            selectionFlag = QItemSelectionModel::NoUpdate;

        } else if (d->mSelectionMode == SingleSelection

            && selectionFlag & QItemSelectionModel::Select) {

            selectionFlag |= QItemSelectionModel::Clear;

        }

        d->mSelectionModel->setCurrentIndex(index, selectionFlag);

    }

}

/*!

    Returns model index of the model's root item. 

    The root item is parent item to view's top level items.

    The root can be invalid.

 */

QModelIndex HbAbstractItemView::rootIndex() const

{

    Q_D(const HbAbstractItemView);

    return d->mModelIterator->rootIndex();

}

/*!

    Sets root index to \a index.

    All view items are deleted and recreated

    Note! View items may be created asynchronously.

 */

void HbAbstractItemView::setRootIndex(const QModelIndex &index)

{

    Q_D(HbAbstractItemView);

    if (d->mModelIterator->rootIndex() != index ) {

        d->mModelIterator->setRootIndex(index);

        d->resetContainer();

        setCurrentIndex(QModelIndex(), QItemSelectionModel::NoUpdate);

    }

}

/*!

    Resets Item view.

 */

void HbAbstractItemView::reset()

{

    Q_D(HbAbstractItemView);    

    d->mModelIterator->setRootIndex(QPersistentModelIndex());

    d->resetContainer();

    setCurrentIndex(QModelIndex(), QItemSelectionModel::NoUpdate);

}

/*!

    \reimp

    It should be allways called by child class if overriden.

*/

bool HbAbstractItemView::event(QEvent *e)

{

    Q_D(HbAbstractItemView);

    bool result = HbScrollArea::event(e);

    // The two above statements have to be executed before these

    if (e->type() == HbEvent::ChildFocusIn) {

        HbAbstractViewItem *item = 0;

        QList<HbAbstractViewItem *> items = d->mContainer->items();

        for (QGraphicsItem *currentItem = scene()->focusItem(); currentItem != 0; currentItem = currentItem->parentItem()) {

            item = d->viewItem(currentItem);

            if (item) {

                if (items.indexOf(item) == -1) {

                    item = 0;

                } else {

                    break;

                }

            }

        }

        if (item && item->modelIndex() != d->mCurrentIndex) {

            setCurrentIndex(item->modelIndex());

        }

        result = true;

    } else if (e->type() == QEvent::LayoutRequest) {

        d->mContainer->resizeContainer();

        if (d->mPostponedScrollIndex.isValid()) { 

           d->scrollTo(d->mPostponedScrollIndex, d->mPostponedScrollHint);

        } 

        result = true;

    }

    return result;

}

/*!

    \reimp

    This slot is called when orientation is changed.

    \a newOrientation has the currentOrientation mode.

    Note: Currently platform dependent orientation support is not available

*/

void HbAbstractItemView::orientationChanged(Qt::Orientation newOrientation)

{

    Q_UNUSED(newOrientation);

    Q_D(HbAbstractItemView);