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

**

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

#include <hbabstractviewitem.h>

#include <hbabstractitemview.h>

#include <hbnamespace.h>

#include <hbstyle.h>

#include <hbiconitem.h>

#include <hbframebackground.h>

#include <hbabstractitemview_p.h>

#include <hbwidgetfeedback.h>

#include <hbtapgesture.h>

#include <QPersistentModelIndex>

#include <QGraphicsLayout>

#include <QVariant>

#include <QCoreApplication>

#include <QEvent>

#include <QDebug>

#include <QGesture>

#include <QGestureEvent>

const QString KDefaultLayoutOption = "default";

const int HbAbstractViewItemShared::ViewItemDeferredDeleteEvent = QEvent::registerEventType();

/*!

    @alpha

    @hbwidgets

    \class HbAbstractViewItem

    \brief The HbAbstractViewItem class represents a single item in a AbstractItemView.  

    The HbAbstractViewItem class provides an item that is used by HbAbstractItemView class to

    This class is provided mainly for customization purposes but it also acts as a default

    item prototype inside HbAbstractItemView. See HbAbstractItemView how to set customized class as a item prototype.

    \b Subclassing

    To support multiple Abstractview items within single AbstractItemview, you must also provide an implementation of canSetModelIndex().

    If derived abstract view item has transient state information that is not meaningful to store within model index (child item cursor 

*/

/*!

    \fn void HbAbstractViewItem::pressed(const QPointF &position)

    This signal is emitted when a touch down event is received for this view item.

    \a position is position of touch event in view item coordinates.

    \sa HbAbstractViewItem::released(const QPointF &position)

    \sa HbAbstractViewItem::activated(const QPointF &position)

*/

/*!

    \fn void HbAbstractViewItem::released(const QPointF &position)

    This signal is emitted when a touch release event is received for this view item.

    \a position is position of touch event in view item coordinates.

    \sa HbAbstractViewItem::pressed(const QPointF &position)

    \sa HbAbstractViewItem::activated(const QPointF &position)

*/

/*!

    \fn void HbAbstractViewItem::activated(const QPointF &position)

    This signal is emitted when view item 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.

    \a position is position of touch event in view item coordinates.

    \sa HbAbstractViewItem::pressed(const QPointF &position)

    \sa HbAbstractViewItem::released(const QPointF &position)

*/

/*!

    \fn void HbAbstractViewItem::longPressed(const QPointF &position)

    This signal is emitted when long press event is received for this view item and long press is enabled in itemview.

    \a position is position of touch event in view item coordinates.

    \sa HbAbstractItemView::longPressEnabled()

*/

/*!

    \fn HbAbstractViewItem::createItem 

    Creates a new item. 

    In most subclasses, createItem should be implemented like this:

    \snippet{ultimatecodesnippet/customlistviewitem.cpp,1}

*/

void HbAbstractViewItemPrivate::init()

{

    Q_Q(HbAbstractViewItem);

    q->setProperty("state", "normal");

    if (isPrototype()) {

        q->setFocusPolicy(Qt::ClickFocus);

    } else {

        q->grabGesture(Qt::TapGesture);

        QGraphicsItem::GraphicsItemFlags itemFlags = q->flags();

        itemFlags |= QGraphicsItem::ItemIsFocusable;

        q->setFlags(itemFlags);

        q->setFocusPolicy(mSharedData->mPrototype->focusPolicy());

        mSharedData->mCloneItems.append(q);

    }

}

int HbAbstractViewItemPrivate::modelItemType() const

{

    return mIndex.data(Hb::ItemTypeRole).toInt();

}

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

{

    Q_UNUSED(status);

    Q_Q(HbAbstractViewItem);

    if (mFocusItem) {

        QCoreApplication::postEvent(q, new QEvent((QEvent::Type)HbAbstractViewItemShared::ViewItemDeferredDeleteEvent));

    }

}

void HbAbstractViewItemPrivate::repolishCloneItems()

{

    int count(mSharedData->mCloneItems.count());

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

        mSharedData->mCloneItems.at(i)->repolish();

    }

}

void HbAbstractViewItemPrivate::updateCloneItems(bool updateChildItems)

{

    int count(mSharedData->mCloneItems.count());

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

        if (updateChildItems) {

            mSharedData->mCloneItems.at(i)->updateChildItems();

        } else {

            mSharedData->mCloneItems.at(i)->updatePrimitives();

        }

    }

}

void HbAbstractViewItemPrivate::setInsidePopup(bool insidePopup)

{

    Q_Q(HbAbstractViewItem);

    HbWidgetPrivate::setInsidePopup(insidePopup);

    if (q) {

        themingPending = true;

        q->updatePrimitives();

        q->repolish();

    }

}

void HbAbstractViewItemPrivate::tapTriggered(QGestureEvent *event)

{

    Q_Q(HbAbstractViewItem);

    HbTapGesture *gesture = static_cast<HbTapGesture *>(event->gesture(Qt::TapGesture));

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

    position = q->mapFromScene(position);

    switch (gesture->state()) {

        case Qt::GestureStarted: {

            HbWidgetFeedback::triggered(q, Hb::InstantPressed, 0);

            emit q->pressed(position);

            break;

        }

        case Qt::GestureUpdated: {

            if (gesture->tapStyleHint() == HbTapGesture::TapAndHold 

                && mSharedData->mItemView

                && mSharedData->mItemView->longPressEnabled()) {

            }

            break;

        }

        case Qt::GestureFinished: {

            HbWidgetFeedback::triggered(q, Hb::InstantReleased, 0);

            if (gesture->tapStyleHint() == HbTapGesture::Tap 

                && !mSharedData->mItemView->longPressEnabled())) {

                HbWidgetFeedback::triggered(q, Hb::InstantClicked);

            } else {

                emit q->released(position);

            }

            break;

        }

        case Qt::GestureCanceled: {

            // hides focus immediately

            emit q->released(position);

            break;

        }

        default:

            break;

    }

    event->accept();

}

void HbAbstractViewItemPrivate::revealItem()

{

    Q_Q(HbAbstractViewItem);

    if (mSharedData->mItemView) {

        static_cast<HbAbstractItemViewPrivate *>(mSharedData->mItemView->d_func())->revealItem(q, HbAbstractItemView::EnsureVisible);

    }

}

/*!

    Constructs an abstract view item with the given parent.

*/

HbAbstractViewItem::HbAbstractViewItem(QGraphicsItem *parent) : 

    HbWidget( *new HbAbstractViewItemPrivate( this ), parent )

{

    Q_D( HbAbstractViewItem );

    d->q_ptr = this;

    d->init();

}

/*!

    Creates a separate graphics widget with same Abstract view item state as \a source.

*/

HbAbstractViewItem::HbAbstractViewItem( HbAbstractViewItemPrivate &dd, QGraphicsItem *parent):

                    HbWidget( dd, parent )

{

    Q_D( HbAbstractViewItem );

    d->q_ptr = this;

    d->init();

}

/*!

    Creates a separate graphics widget with same abstract view item state as \a source.

*/

HbAbstractViewItem::HbAbstractViewItem(const HbAbstractViewItem &source) :

    HbWidget(*new HbAbstractViewItemPrivate(*source.d_func()), 0)

{

    Q_D( HbAbstractViewItem );

    d->q_ptr = this;

    d->init();

}

/*!

    Assigns the \a source abstract view item to this abstract view item and returns a reference to this item.

*/

HbAbstractViewItem &HbAbstractViewItem::operator=(const HbAbstractViewItem &source)

{

    Q_D( HbAbstractViewItem );

    *d = *source.d_func();

    return *this;

}

/*!

    Destructor.

*/

HbAbstractViewItem::~HbAbstractViewItem()

{

    HB_SDD(HbAbstractViewItem);

    if (d && !d->isPrototype()) {

        sd->mCloneItems.removeOne(this);

    }

}

/*!

    Returns true if \a model index is supported by Abstract view item, otherwise returns false.

    This function is called for every item on the prototype list (, if several prototypes exist)

    until item is found, which can create item for \a 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. 

    \sa HbAbstractItemView::setItemPrototype(HbAbstractViewItem *prototype), HbAbstractItemView::setItemPrototype(const QList<HbAbstractViewItem *> &prototypes)

*/

bool HbAbstractViewItem::canSetModelIndex(const QModelIndex &index) const

{

    Q_UNUSED(index);

    return true;

}

/*!

    Returns model index tied into this Abstract view item.

*/

QModelIndex HbAbstractViewItem::modelIndex() const

{

    Q_D( const HbAbstractViewItem );

    return d->mIndex;

}

/*!

    Sets model \a index where this Abstract view item should retrieve it's content.

*/

void HbAbstractViewItem::setModelIndex(const QModelIndex &index)

{

    Q_D( HbAbstractViewItem );

    if (d->mIndex != index) {

        d->mIndex = index;

        updateChildItems();

    }

}

/*!

    Returns the saved item's transient state. Transient state can be seen as a state data that is 

    wanted to be preserved but it not meaningful to be stored inside model index because of it's

    momentary nature. States will be saved inside AbstractItemview and restored when current model index is

    assigned to certain Abstract view item.

    String in the returned table is usually name of a Qt property.

    Default values of properties should not be added into returned table.

    Derived class should first call base class implementation. After that it adds its own

    state items into returned table.

*/

QHash<QString, QVariant> HbAbstractViewItem::transientState() const

{

    Q_D( const HbAbstractViewItem );

    QHash<QString,QVariant> state;

    if (d->mFocused) {

        state.insert("focused", d->mFocused);

    }

    if (d->mCheckState != Qt::Unchecked) {

        state.insert("checkState", d->mCheckState);

    }

    return state;

}

/*!

    Sets the item's transient state using given \a state data.

*/

void HbAbstractViewItem::setTransientState(const QHash<QString, QVariant> &state)

{

    Q_D( HbAbstractViewItem );

    d->mFocused = state.value("focused").toBool();

    d->mCheckState = (Qt::CheckState)state.value("checkState").toInt();

}

/*!

    Returns a pointer to HbAbstractViewItem prototype that was used to create this

    view item.

*/

HbAbstractViewItem *HbAbstractViewItem::prototype() const

{

    HB_SDD( const HbAbstractViewItem );

    return sd->mPrototype;

}

/*!

    Sets \a AbstractItemView that contains the Abstract view item.

*/

void HbAbstractViewItem::setItemView( HbAbstractItemView *itemView )

{

    HB_SDD( HbAbstractViewItem );

    sd->mItemView = itemView;

}

/*!

    Returns item view that contains the item view item.

*/

HbAbstractItemView *HbAbstractViewItem::itemView() const

{

    HB_SDD( const HbAbstractViewItem );

    return sd->mItemView;

}

/*!

    Populates a style option object for this widget based on its current state, and stores the output in \a option.

*/

void HbAbstractViewItem::initStyleOption(HbStyleOptionAbstractViewItem *option) const

{

    HB_SDD( const HbAbstractViewItem );

    HbWidget::initStyleOption(option);

    option->modelItemType = d->mModelItemType;

    option->index = d->mIndex;

    option->viewItemType = type();

    option->checkState = d->mCheckState;

    option->background = d->mBackground;

    if (!option->background.isValid()) {

        if (option->modelItemType == Hb::StandardItem 

            && !sd->mDefaultFrame.isNull()) {

            option->background = sd->mDefaultFrame;

        }

    }

    if (d->mPressed) {

        option->state |= QStyle::State_Sunken;

    }

    if (    sd->mItemView

        &&  sd->mItemView->selectionMode() == HbAbstractItemView::SingleSelection){

        option->singleSelectionMode = true;

    }

    option->insidePopup = testAttribute(Hb::InsidePopup);

}

/*!

    Check whether \a position is inside the selection area of the given selectionAreaType in the view item.

    Default selection areas are for

    \li HbAbstractViewItem::SingleSelection mode: whole item

    \li HbAbstractViewItem::MultiSelection mode: whole item.

    \li HbAbstractItemView::NoSelection mode: none

    The \a selectionAreaType tells what kind of selection area is requested.  The parameter value ContiguousSelection returns 

	the area where mouse movement will extend the selection to new items. By default this contiguous selection area is 

	the HbStyle::P_ItemViewItem_touchmultiselection.

*/

bool HbAbstractViewItem::selectionAreaContains(const QPointF &position, SelectionAreaType selectionAreaType) const

{

    Q_D(const HbAbstractViewItem);

    bool contains = false;

    if (selectionAreaType == ContiguousSelection) {

        if(     d->mMultiSelectionTouchArea 

            &&  !d->mMultiSelectionTouchArea->boundingRect().isEmpty()) {

                contains = d->mMultiSelectionTouchArea->boundingRect().contains(mapToItem(d->mMultiSelectionTouchArea, position));

            } else if (d->mSelectionItem) {

                contains = d->mSelectionItem->boundingRect().contains(mapToItem(d->mMultiSelectionTouchArea, position));

            }

    } else {