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

**

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

#include <hbstyle.h>

#include <hbiconitem.h>

#include <hbframebackground.h>

#include <hbabstractitemview_p.h>

#include <hbwidgetfeedback.h>

#include <hbtapgesture.h>

#include <hbnamespace_p.h>

#include <hbevent.h>

#include <QPersistentModelIndex>

#include <QGraphicsLayout>

#include <QVariant>

#include <QCoreApplication>

#include <QEvent>

#include <QTimer>

#include <QGraphicsScene>

#include <QPixmap>

#include <QPainter>

#include <QDebug>

#include <QChildEvent>

#include <QGesture>

#include <QGestureEvent>

#include <QGraphicsSceneEvent>

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

    visualize content within single model index. By default HbAbstractViewItem supports QString and QStringList 

    stored into Qt::DisplayRole role and QIcon, HbIcon or list of them in QVariantList stored into

    Qt::DecoratorRole role.

    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

    When subclassing HbAbstractViewItem, child class must provide implementations of createItem() and updateChildItems() functions.

    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 

    position selection areas etc.) this information can be supplied to transient state model. Transient state model is maintained 

    internally by abstract item view. 

    If item's pixmap cache is enabled derived class should call updatePixmapCache() when ever visual appearance of the item or its children is

    changed. For more information about enabling the pixmap cache see HbAbstractItemView::setItemPixmapCacheEnabled().

    \primitives

    \primitive{background} HbIconItem representing the item background. This primitive exists in cases the model's Qt::BackgroundRole returns HbIcon or QBrush for this item.

    \primitive{frame} HbFrameItem representing the background frame of the item. This primitive exists if background primitive does not exist and the model's Qt::BackgroundRole returns HbFrameBackground or there is a default frame set with the setDefaultFrame(). An item can have either the frame or the background primitive, but not the both at the same time.

    \primitive{selection-icon} HbIconItem representing the checkbox in the multi selection mode.

    \primitive{multiselection-toucharea} HbTouchArea used in extending the touch area of the selection-icon. 

*/

/*!

    \enum HbAbstractViewItem::SelectionAreaType

    Enumeration specifies selection area types. 

    Multiselection selection mode may operate in contiguous selection mode, in which items are selected 

    or deselected by panning over items. Normal multiselection functionality is available also in this mode.

    Location of touch down gesture determines whether contiguous selection mode is activated.

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

*/

/*!

    \var HbAbstractViewItem::SingleSelection

    Selection area for single selection mode.

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

*/

/*!

    \var HbAbstractViewItem::MultiSelection

    Selection area for multiple selection mode.

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

*/

/*!

    \var HbAbstractViewItem::ContiguousSelection

    Selection area for contiguous selection mode. 

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

*/

/*!

    \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.

    Released signal is emitted also when user starts panning or flicks the view.

    \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 HbAbstractViewItemShared::pressStateChangeTimerTriggered()

{

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

    mPressedItem->pressStateChanged(true, mAnimatePress);

}

void HbAbstractViewItemShared::disablePixmapCaches()

{

    mLowGraphicsMemory = true;

    foreach (HbAbstractViewItem *item, mCloneItems) {

        item->update();

    }

}

void HbAbstractViewItemShared::enablePixmapCaches()

{

    mLowGraphicsMemory = false;

    foreach (HbAbstractViewItem *item, mCloneItems) {

        item->update();

    }

}

void HbAbstractViewItemPrivate::init()

{

    Q_Q(HbAbstractViewItem);

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

    q->setFlag(QGraphicsItem::ItemHasNoContents, false);

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

        mFrontPixmapPainter = new HbViewItemPixmapPainter(1000, q);

    }

}

/*!

    Returns Hb::ModelItemType of this view item.

    \sa Hb::ModelItemType

*/

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

            q->scene()->setProperty(HbPrivate::OverridingGesture.latin1(),Qt::TapGesture);

            if (!gesture->property(HbPrivate::ThresholdRect.latin1()).toRect().isValid()) {

                gesture->setProperty(HbPrivate::ThresholdRect.latin1(), q->mapRectToScene(q->boundingRect()).toRect());

            }

            setPressed(true, true);

            emit q->pressed(position);

            break;

        }

        case Qt::GestureUpdated: {

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

                && mSharedData->mItemView

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

                q->scene()->setProperty(HbPrivate::OverridingGesture.latin1(),QVariant());

                setPressed(false, true);

                QPointer<HbAbstractViewItem> item = q;

                emit item->longPressed(position);

                if (item) {

                    revealItem();

                }

            }

            break;

        }

        case Qt::GestureFinished: {

            q->scene()->setProperty(HbPrivate::OverridingGesture.latin1(),QVariant());

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

                || (mSharedData->mItemView

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

                setPressed(false, true);

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

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

                QPointer<HbAbstractViewItem> item = q;

                emit item->activated(position);

                // this viewItem may be deleted in the signal handling, so guarded pointer is used to 

                // to ensure that the item still exists when item is used

                if (item) {

                    emit item->released(position);

                    if (item) {

                        revealItem();

                    }

                }

            } else {

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

                emit q->released(position);

            }

            break;

        }

        case Qt::GestureCanceled: {

            q->scene()->setProperty(HbPrivate::OverridingGesture.latin1(),QVariant());

            // hides focus immediately

            setPressed(false, false);

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

    }

}

void HbAbstractViewItemPrivate::setPressed(bool pressed, bool animate)

{

    Q_Q(HbAbstractViewItem);

    if (pressed != mPressed) {

        mPressed = pressed;

        if (mSharedData->mPressStateChangeTimer) {

            if(!pressed && animate && mSharedData->mPressStateChangeTimer->isActive()) {

                // Release happened while press still delayed

                mSharedData->mPressStateChangeTimer->stop();

                mSharedData->pressStateChangeTimerTriggered();

            } else {

                mSharedData->mPressStateChangeTimer->stop();

            }

        }

        if (mPressed) {

            if (!mSharedData->mPressStateChangeTimer) {

                mSharedData->mPressStateChangeTimer = new QTimer(mSharedData.data());

                mSharedData->mPressStateChangeTimer->setSingleShot(true);

                QObject::connect(mSharedData->mPressStateChangeTimer, SIGNAL(timeout()), mSharedData.data(), SLOT(pressStateChangeTimerTriggered()));

            }

            mSharedData->mPressedItem = q;

            mSharedData->mAnimatePress = animate;

            mSharedData->mPressStateChangeTimer->start(HbViewItemPressDelay);

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

        } else {

            q->pressStateChanged(mPressed, animate);

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

        }

    }

}

void HbAbstractViewItemPrivate::paintItems(QPainter *painter, QStyleOptionGraphicsItem *option, QGraphicsItem *startItem, QGraphicsItem *endItem)

{

    Q_Q(HbAbstractViewItem);

    mInPaintItems = true;

    bool itemPainted = false;

    bool startItemFound = false;

    if (!startItem) {

        startItemFound = true;

    }

    foreach (QGraphicsItem *child, q->childItems()) {

        if (!startItemFound) {

            if (child == startItem) {

                startItemFound = true;

            }

            continue;

        } else if (child == endItem) {

            break;

        }

        if (!child->isVisible() || child == mNonCachableItem || child == mFrontPixmapPainter || child == mBackPixmapPainter) {

            continue;

        }

        if (!itemPainted && child->zValue() >= 0) {

            option->exposedRect = q->boundingRect();

            q->paint(painter, option, 0);

            itemPainted = true;

        }

        if (child == mFrame) {

            QPainter::CompositionMode mode = painter->compositionMode();

            painter->setCompositionMode(QPainter::CompositionMode_Source);

            painter->translate(child->pos());

            option->exposedRect = child->boundingRect();

            child->paint(painter, option, 0);

            painter->setCompositionMode(mode);

            painter->translate(-child->pos());

            continue;

        }

        paintChildItemsRecursively(child,painter,option);

    }

    mInPaintItems = false;

}

void HbAbstractViewItemPrivate::paintChildItemsRecursively(QGraphicsItem *child, QPainter *painter,QStyleOptionGraphicsItem *option)

{

    if (!child->isVisible())

        return;

    int i = 0;

    QList<QGraphicsItem *> children =  child->childItems();

    int count(children.size());

    painter->translate(child->pos());

    // Draw children behind

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

        QGraphicsItem *subChild = children.at(i);

        if (!(subChild->flags() & QGraphicsItem::ItemStacksBehindParent))

            break;

        paintChildItemsRecursively(subChild, painter,option);

    }

    option->exposedRect = child->boundingRect();

    child->paint(painter, option, 0);

    // Draw children in front

    for (; i < count; ++i) {

        QGraphicsItem *subChild = children.at(i);

        paintChildItemsRecursively(subChild, painter,option);

    }

    painter->translate(-child->pos());

}

void HbAbstractViewItemPrivate::setChildFlags(QGraphicsItem *child, bool pixmapCacheEnabled)

{

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

    if (pixmapCacheEnabled) {

        itemFlags |= QGraphicsItem::ItemHasNoContents;

        itemFlags |= QGraphicsItem::ItemIgnoresParentOpacity;