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

**

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

#include "hblistitemcontainer_p.h"

#include "hblistitemcontainer_p_p.h"

#include "hbmodeliterator.h"

#include <hbtumbleview.h>

#include <hbtumbleviewitem.h>

#include <hbevent.h>

#include <QGraphicsSceneMouseEvent>

#include <QStringListModel>

#define HB_TUMBLE_ITEM_ANIMATION_TIME 500

#define HB_TUMBLE_PREFERRED_ITEMS 3

#define DELAYED_SELECT_INTERVAL 100

#define HBTUMBLE_DEBUG

#ifdef HBTUMBLE_DEBUG

#include <QDebug>

#endif

class HbTumbleViewItemContainerPrivate;

class HbTumbleViewItemContainer:public HbListItemContainer

{

    Q_DECLARE_PRIVATE(HbTumbleViewItemContainer)

public:

    HbTumbleViewItemContainer(QGraphicsItem* parent = 0);

    QPointF recycleItems(const QPointF &delta);

    void setLoopingEnabled(bool looping) ;

    bool isLoopingEnabled() const ;

};

class HbTumbleViewItemContainerPrivate:public HbListItemContainerPrivate

{

    Q_DECLARE_PUBLIC(HbTumbleViewItemContainer)

public:

    HbTumbleViewItemContainerPrivate();

    QPointF recycleItems(const QPointF &delta);

    HbAbstractViewItem *shiftDownItem(QPointF& delta);

    HbAbstractViewItem *shiftUpItem(QPointF& delta);

    bool mIsLooped;

};

class HbTumbleViewPrivate : public HbListViewPrivate

{

    Q_DECLARE_PUBLIC(HbTumbleView)

public:

    HbTumbleViewPrivate();

    qreal topBoundary();//virtual functions

    qreal bottomBoundary();

    virtual void updateScrollMetrics();

    virtual void scrollTo(const QModelIndex &index, HbAbstractItemView::ScrollHint hint);

    void init(QAbstractItemModel *model);

    void calculateItemHeight();

    void selectMiddleItem();

    void createPrimitives();

    void delayedSelectCurrent(const QModelIndex& index);

    void _q_scrollingStarted();//private slot

    void _q_scrollingEnded();//private slot

    void _q_delayedSelectCurrent();//private slot

    void setPressedState(HbAbstractViewItem *item);

private:

    qreal mHeight;

    QPointer<HbAbstractViewItem> mPrevSelectedItem;

    bool mInternalScroll;

    bool mStartup;//needed for layout request

    //geometry prob, some how loop setGeometry call is happening

    QRectF mPrevSetGeometryRect;

    QModelIndex mDelayedSelectIndex;

    QTimer mDelayedSelectTimer;

    //primitives

    QGraphicsItem   *mBackground;

    QGraphicsItem   *mFrame;//overlay

    QGraphicsItem   *mHighlight;

    int             mSelected;

    bool mNeedScrolling;

    QGraphicsItem   *mDivider;

};

HbTumbleViewItemContainer::HbTumbleViewItemContainer(QGraphicsItem* parent )

    :HbListItemContainer(*(new HbTumbleViewItemContainerPrivate),parent)

{

}

QPointF HbTumbleViewItemContainer::recycleItems(const QPointF &delta)

{

    Q_D(HbTumbleViewItemContainer);

    if (d->mPrototypes.count() != 1) {

        return delta;

    }

    QRectF viewRect(d->itemBoundingRect(d->mItemView));

    viewRect.moveTopLeft(viewRect.topLeft() + delta);

    int firstVisibleBufferIndex = -1;

    int lastVisibleBufferIndex = -1;

    d->firstAndLastVisibleBufferIndex(firstVisibleBufferIndex, lastVisibleBufferIndex, viewRect, false);

    int hiddenAbove = firstVisibleBufferIndex;

    int hiddenBelow = d->mItems.count() - lastVisibleBufferIndex - 1;

    if (d->mItems.count()

        && (firstVisibleBufferIndex == -1 || lastVisibleBufferIndex == -1)) {

        // All items out of sight.

        if (d->itemBoundingRect(d->mItems.first()).top() < 0) {

            // All items above view.

            hiddenAbove = d->mItems.count();

            hiddenBelow = 0;

        } else {

            // All items below view.

            hiddenAbove = 0;

            hiddenBelow = d->mItems.count();

        }

    }

    QPointF newDelta(delta);

    while (hiddenAbove > hiddenBelow + 1) {

        HbAbstractViewItem *item = d->shiftDownItem(newDelta);

        if (!item){

            break;

        }

        if (!d->visible(item, viewRect)) {

            hiddenBelow++;

        }

        hiddenAbove--;

    }

    while (hiddenBelow > hiddenAbove + 1) {

        HbAbstractViewItem *item = d->shiftUpItem(newDelta);

        if (!item) {

            break;

        }

        if (!d->visible( item, viewRect)) {

            hiddenAbove++;

        }

        hiddenBelow--;

    }

    return newDelta;

}

void HbTumbleViewItemContainer::setLoopingEnabled(bool looped) {

    Q_D(HbTumbleViewItemContainer);

    d->mIsLooped = looped;

}

bool HbTumbleViewItemContainer::isLoopingEnabled() const {

    Q_D(const HbTumbleViewItemContainer);

    return d->mIsLooped;

}

HbTumbleViewItemContainerPrivate::HbTumbleViewItemContainerPrivate()

    : mIsLooped(false) 

{ 

}

HbAbstractViewItem *HbTumbleViewItemContainerPrivate::shiftDownItem(QPointF& delta)

{

    Q_Q(HbTumbleViewItemContainer);

    HbAbstractViewItem *item = 0;

    HbAbstractViewItem *lastItem = mItems.last();

    QModelIndex nextIndex = mItemView->modelIterator()->nextIndex(lastItem->modelIndex());

    if(mIsLooped && (!nextIndex.isValid())){

       nextIndex = mItemView->model()->index(0,0);

    }

    if (nextIndex.isValid()) {

        item = mItems.takeFirst();

        q->itemRemoved(item);

        delta.setY(delta.y() - item->size().height());

        mItems.append(item);

        q->setItemModelIndex(item, nextIndex);

        q->itemAdded(mItems.count() - 1, item);

    }

    return item;

}

HbAbstractViewItem *HbTumbleViewItemContainerPrivate::shiftUpItem(QPointF& delta)

{

    Q_Q(HbTumbleViewItemContainer);

    HbAbstractViewItem *item = 0;

    HbAbstractViewItem *firstItem = mItems.first();

    QModelIndex previousIndex = mItemView->modelIterator()->previousIndex(firstItem->modelIndex());

    if(mIsLooped && !previousIndex.isValid()){

        previousIndex = mItemView->model()->index(mItemView->model()->rowCount()-1,0);

    }

    if (previousIndex.isValid()) {

        item = mItems.takeLast();

        q->itemRemoved(item);

        mItems.insert(0, item);

        q->setItemModelIndex(item, previousIndex);

        qreal itemHeight=0;

        if (q->uniformItemSizes()) {

            itemHeight = mItems.last()->preferredHeight();

        } else {

            //This is time consuming and causes backwards srolling to be slower than forwards.

            //The sizehint of the item is dirty.

            itemHeight = item->preferredHeight();

        }

        delta.setY(delta.y() + itemHeight);

        q->itemAdded(0, item);

    }

    return item;

}

HbTumbleViewPrivate::HbTumbleViewPrivate()

    :HbListViewPrivate()

    ,mHeight(10.0)

    ,mPrevSelectedItem(0)

    ,mInternalScroll(false)

    ,mStartup(true)

    ,mDelayedSelectIndex()

    ,mDelayedSelectTimer(0)

    ,mBackground(0)

    ,mFrame(0)

    ,mHighlight(0)

    ,mSelected(-1)

    ,mNeedScrolling(true)

    ,mDivider(0)

{

}

qreal HbTumbleViewPrivate::topBoundary()

{

    //top boundary and bottom boundary is different for tumble view

    //it is half item less than the middle of the view

    Q_Q( HbTumbleView );

    return (-(q->boundingRect().height()-mHeight)/2);

}

qreal HbTumbleViewPrivate::bottomBoundary()

{

    Q_Q ( HbTumbleView);    

    return mContents->boundingRect().height()-((q->boundingRect().height()+mHeight)/2);

} 

void HbTumbleViewPrivate::init(QAbstractItemModel *model)

{

    Q_Q(HbTumbleView);

    mNeedScrolling = true;

    //list settings

    HbTumbleViewItem *proto = new HbTumbleViewItem();

    proto->setFlag(QGraphicsItem::ItemIsFocusable,false);        

    q->setModel(model,proto);

    q->setSelectionMode(q->HbAbstractItemView::SingleSelection);

    q->setLongPressEnabled(false);

    q->setUniformItemSizes(true);

    q->setEnabledAnimations(HbAbstractItemView::TouchDown);

    //scroll area settings

    q->setClampingStyle(HbScrollArea::BounceBackClamping);

    q->setVerticalScrollBarPolicy(HbScrollArea::ScrollBarAlwaysOff);

    q->setHorizontalScrollBarPolicy(HbScrollArea::ScrollBarAlwaysOff);

    q->setFrictionEnabled(true);

    mDelayedSelectTimer.setSingleShot(true);

    bool b = q->connect(q,SIGNAL(scrollingStarted()),q,SLOT(_q_scrollingStarted()));

    Q_ASSERT(b);

    b = q->connect(q,SIGNAL(scrollingEnded()),q,SLOT(_q_scrollingEnded()));

    Q_ASSERT(b);

    b = q->connect(&mDelayedSelectTimer,SIGNAL(timeout()),q,SLOT(_q_delayedSelectCurrent()));

    Q_UNUSED(b);

    createPrimitives();

}

void HbTumbleViewPrivate::selectMiddleItem()

{

    Q_Q(HbTumbleView);

    //scroll little amount so item settle's in

    if(!q->scene()) {

        return;

    }

    QPointF centerPt = q->mapToScene(q->boundingRect().center());

    HbAbstractViewItem *item = itemAt(centerPt);

    if(item) {

#ifdef HBTUMBLE_DEBUG  

    qDebug() << "HbTumbleViewPrivate::selectMiddleItem - " << item->modelIndex().row() ;

#endif

            delayedSelectCurrent(item->modelIndex());

            mSelected = item->modelIndex().row();

        }

    }

void HbTumbleViewPrivate::scrollTo(const QModelIndex &index, HbAbstractItemView::ScrollHint hint)

{

    Q_Q(HbTumbleView);

#ifdef HBTUMBLE_DEBUG  

    qDebug() << "HbTumbleViewPrivate::scrollTo(" << index.row() << "," << hint << " )";

#endif

    if(!q->scene()) {

        return;

    }

    HbListViewPrivate::scrollTo(index, hint);

    HbAbstractViewItem *item = mContainer->itemByIndex(index);

    if(item) {

        setPressedState(item); 

    } 

#ifdef HBTUMBLE_DEBUG  

    else {

        qDebug() << "HbTumbleViewPrivate::scrollTo(" << index.row() << ",failed to get itembyindex";

    }

#endif

}

void HbTumbleView::scrollTo(const QModelIndex &index, ScrollHint)

{

#ifdef HBTUMBLE_DEBUG  

    qDebug() << "HbTumbleView::scrollTo(" << index.row() << ", )";

#endif

    HbListView::scrollTo(index, PositionAtCenter);

}

void HbTumbleViewPrivate::createPrimitives()

{

    Q_Q(HbTumbleView);

    //this is the highlight which is placed at center

    if(!mHighlight) {

        mHighlight = q->style()->createPrimitive(HbStyle::P_TumbleView_highlight,q);

        q->style()->setItemName(mHighlight,"highlight");

    }

    if(!mDivider){

        mDivider = q->style()->createPrimitive(HbStyle::P_DateTimePicker_separator,q);

        q->style()->setItemName(mDivider,"separator");

        mDivider->hide();

    }

}

void HbTumbleViewPrivate::calculateItemHeight()

{

    Q_Q(HbTumbleView);

    if (!q->items().isEmpty()) {

        //Let's create a temporary item and take the height for the size hint

        HbAbstractViewItem *tempItem = q->itemPrototypes().first()->createItem();

        tempItem->setModelIndex(mModelIterator->nextIndex(QModelIndex()));

        qreal oldHeight = mHeight;

        mHeight = tempItem->effectiveSizeHint(Qt::PreferredSize).height();

        delete tempItem;

        if (mHeight != oldHeight) {

            q->updateGeometry();

        }

    }

}

void HbTumbleViewPrivate::updateScrollMetrics()

{

    mAbleToScrollY = true;

}

/*!

    @proto

    \class HbTumbleView 

    \this is a tumbler widget which lets the user select alphanumeric values from a predefined list of 

    values via vertical flicking and dragging. Typically widgets such as date picker and time picker use the 

    Tumbler. The Tumbler could also be used to change other values such as number code sequence, 

    landmark coordinates, country selection, and currency.

    Only strings can be accepted as HbTumbleView's items.

    \this can be used like this:

    \snippet{ultimatecodesnippet/ultimatecodesnippet.cpp,52}

*/

/*!

    \fn void itemSelected(int index)

    This signal is emitted when an item is selected in date time picker.

    \param index  selected item.

*/

/*!

    HbTumbleView's default constructor.

    \param parent item to set as parent.

*/

HbTumbleView::HbTumbleView(QGraphicsItem *parent)

    :HbListView(*new HbTumbleViewPrivate,

        new HbTumbleViewItemContainer,

        parent)

{

    Q_D(HbTumbleView);

    d->q_ptr = this;

    d->init(new QStringListModel(this));

}

/*!

    HbTumbleView's constructor.

    \param list to be set as data to QStringListModel.

    \parent item to set as parent.

*/

HbTumbleView::HbTumbleView(const QStringList &list,QGraphicsItem *parent)

    :HbListView(*new HbTumbleViewPrivate,

        new HbTumbleViewItemContainer,

        parent)

{

    Q_D(HbTumbleView);

    d->q_ptr = this;

    d->init(new QStringListModel(list,this));

    d->calculateItemHeight();

}

/*!

    Protected constructor.

*/

HbTumbleView::HbTumbleView(HbTumbleViewPrivate &dd, QGraphicsItem *parent):

    HbListView(dd,

        new HbTumbleViewItemContainer,

        parent)

{

    Q_D(HbTumbleView);

    d->q_ptr = this;

    d->init(new QStringListModel(this));

    d->calculateItemHeight();

}

/*!

   Destructor

*/

HbTumbleView::~HbTumbleView()

{

}

/*!

    Sets the HbTumbleView's items to the given string \a list.

    \param list Items to be set as tumble view's model.

*/

void HbTumbleView::setItems(const QStringList &list)

{

    Q_D(HbTumbleView);

    QStringListModel *stringListModel = qobject_cast<QStringListModel *>(model());

    if (stringListModel) {

        stringListModel->setStringList(list);

        d->calculateItemHeight();

    }

    updatePrimitives();

}

/*!

    Returns items in QStringList format.

    \return list of items in tumbleview's model in QStringList format.

*/

QStringList HbTumbleView::items() const