diff -r 923ff622b8b9 -r 4633027730f5 src/hbwidgets/itemviews/hbdatepickerview_p.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/hbwidgets/itemviews/hbdatepickerview_p.cpp	Wed Aug 18 10:05:37 2010 +0300
@@ -0,0 +1,797 @@
+/****************************************************************************
+**
+** 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 "hbdatepickerview_p.h"
+#include "hbabstractitemview_p.h"
+#include "hbabstractitemcontainer_p.h"
+#include "hbabstractitemcontainer_p_p.h"
+#include "hblistlayout_p.h"
+#include "hbstyleoption_p.h"
+
+#include <hbmodeliterator.h>
+#include <hbdatepickerviewitem_p.h>
+#include <hbtapgesture.h>
+
+#include <qmath.h>
+#include <QTimeLine>
+#include <QGraphicsItemAnimation>
+#include <QGestureEvent>
+#include <QGesture>
+#include <QStringListModel>
+#include <QCoreApplication>
+
+#define HB_DATEPICKERVIEW_PREFERRED_ITEMS 3
+
+class HbDatePickerViewPrivate : public HbAbstractItemViewPrivate
+{
+public:
+    HbDatePickerViewPrivate();
+    ~HbDatePickerViewPrivate();
+
+    void _q_scrollingStarted();
+    void _q_scrollingEnded();
+    void _q_itemSelected(QPointF point);
+
+    void createPrimitives();
+    void updateScrollMetrics(){ mAbleToScrollY = true; }
+
+    qreal topBoundary();
+    qreal bottomBoundary();
+
+    HbAbstractViewItem* getCenterItem();
+    void slectItemAt(const QPointF& point,QGraphicsItem* itemToMap);
+
+
+    QTimeLine *animationtimer;
+    QGraphicsItemAnimation *animation;
+    Q_DECLARE_PUBLIC(HbDatePickerView);
+    QGraphicsItem   *mBackground;
+    QGraphicsItem   *mFrame;//overlay
+    QGraphicsItem   *mHighlight;
+    QGraphicsItem   *mDivider;
+   // bool tapActive;
+
+    enum ViewState
+    {
+        NoState = 0,
+        TapStarted = 1,
+        ScrollStarted = 2
+    };
+    Q_DECLARE_FLAGS(ViewStates, ViewState);
+    ViewStates viewStates;
+
+};
+class HbDatePickerContainerPrivate;
+
+
+class HbDatePickerContainer:public HbAbstractItemContainer
+{
+public:
+    HbDatePickerContainer(QGraphicsItem* parent = 0);
+
+    void setModelIndexes(const QModelIndex &startIndex = QModelIndex());
+    void resizeContainer();
+    void itemAdded(int index, HbAbstractViewItem *item, bool animate);
+    void itemRemoved(HbAbstractViewItem *item, bool animate);
+
+    bool isLoopingEnabled(){return true;}
+    bool isLoopingNeeded();
+    int maxItemPossible()const;
+
+protected:
+    QPointF recycleItems(const QPointF &delta);
+    int maxItemCount() const;
+    HbAbstractViewItem *createDefaultPrototype() const;
+    void viewResized(const QSizeF &size);
+
+private:
+    Q_DECLARE_PRIVATE(HbDatePickerContainer);
+    friend class HbDatePickerView;
+    friend class HbDatePickerViewPrivate;
+};
+
+class HbDatePickerContainerPrivate:public HbAbstractItemContainerPrivate
+{
+public:
+    HbDatePickerContainerPrivate();
+    HbAbstractViewItem *shiftDownItem(QPointF& delta);
+    HbAbstractViewItem *shiftUpItem(QPointF& delta);
+    qreal getSmallestItemHeight() const;
+    void init();
+    HbAbstractViewItem *item(const QModelIndex &index) const;
+
+    HbListLayout *mLayout;
+    Q_DECLARE_PUBLIC(HbDatePickerContainer);
+};
+
+HbDatePickerContainerPrivate::HbDatePickerContainerPrivate()
+    :mLayout(0)
+{
+
+}
+
+
+void HbDatePickerContainerPrivate::init()
+{
+    Q_Q(HbDatePickerContainer);
+    mLayout = new HbListLayout();
+    mLayout->setContentsMargins(0, 0, 0, 0);
+    //mLayout->setPreferredWidth(q->size().width());
+
+    q->setLayout(mLayout);
+}
+
+bool HbDatePickerContainer::isLoopingNeeded()
+{
+    Q_D(HbDatePickerContainer);
+    return (isLoopingEnabled() && !(d->mItems.count() < maxItemPossible()));
+}
+
+void HbDatePickerContainer::setModelIndexes(const QModelIndex &startIndex)
+{
+    Q_D(HbDatePickerContainer);
+
+    if (!d->mItemView || !d->mItemView->model()) {
+        return;
+    }
+
+    QModelIndex index = startIndex;
+    if (!index.isValid()) {
+        if (!d->mItems.isEmpty()) {
+            index = d->mItems.first()->modelIndex();
+        }
+
+        if (!index.isValid()) {
+            index = d->mItemView->modelIterator()->nextIndex(index);
+        }
+    }
+
+    QModelIndexList indexList;
+
+    int itemCount(d->mItems.count());
+
+    if (itemCount != 0 && index.isValid()) {
+        indexList.append(index);
+    }
+
+    for (int i = indexList.count(); i < itemCount; ++i) {
+        index = d->mItemView->modelIterator()->nextIndex(indexList.last());
+
+        if (index.isValid()) {
+            indexList.append(index);
+        } else {
+            break;
+        }
+    }
+    if(isLoopingEnabled() && indexList.count()<itemCount){
+        QModelIndex firstModelIndex =  d->mItemView->modelIterator()->index(0,QModelIndex());
+        indexList.append(firstModelIndex);
+        for (int i = indexList.count(); i < itemCount; ++i) {
+            index = d->mItemView->modelIterator()->nextIndex(indexList.last());
+
+            if (index.isValid()) {
+                indexList.append(index);
+            } else {
+                break;
+            }
+        }
+    }
+
+    int indexCount(indexList.count());
+    for (int i = 0; i < itemCount; ++i) {
+        HbAbstractViewItem *item = d->mItems.at(i);
+        HbAbstractViewItem *prototype = 0;
+        // setItemModelIndex() is considered recycling. It is called only, if recycling is permitted
+        if (i < indexCount) {
+            prototype = d->itemPrototype(indexList.at(i));
+        }
+        if (prototype) {
+            if (    prototype == item->prototype()
+                &&  d->mItemRecycling) {
+                setItemModelIndex(item, indexList.at(i));
+            } else if (     d->mItemRecycling
+                       ||   (   !d->mItemRecycling
+                            &&  item->modelIndex() != indexList.at(i))) {
+                d->deleteItem(item);
+                insertItem(i, indexList.at(i));
+            } // else: !d->mItemRecycling && item->modelIndex().isValid() == indexList.at(i))
+        } else {
+            d->deleteItem(item);
+            itemCount--;
+            i--;
+        }
+    }
+}
+
+void HbDatePickerContainer::resizeContainer()
+{
+    Q_D(HbAbstractItemContainer);
+
+    if (d->mItemView) {
+        resize(d->mItemView->size().width(), layout()->preferredHeight());
+    } else {
+        resize(0, layout()->preferredHeight());
+    }
+}
+
+void HbDatePickerContainer::itemAdded(int index, HbAbstractViewItem *item, bool animate)
+{
+    Q_D(HbDatePickerContainer);
+    d->mLayout->insertItem(index,item, animate);
+}
+
+void HbDatePickerContainer::itemRemoved(HbAbstractViewItem *item, bool animate)
+{
+    Q_D(HbDatePickerContainer);
+    d->mLayout->removeItem(item, animate);
+}
+
+void HbDatePickerContainer::viewResized(const QSizeF &viewSize)
+{
+    QSizeF newSize = this->size();
+    newSize.setWidth( viewSize.width() );
+    resize( newSize );
+}
+
+QPointF HbDatePickerContainer::recycleItems(const QPointF &delta)
+{
+    Q_D(HbDatePickerContainer);
+
+    if( itemView()->size().height() < size().height()){
+          const qreal diff = d->getDiffWithoutScrollareaCompensation(delta);
+          if(diff !=0.0){
+                QPointF newDelta(0.0, 0.0);
+                qreal result = 0.0;
+            HbAbstractViewItem *item = 0;
+            if (diff < 0.0) {
+                while (-newDelta.y() > diff) {
+                    item = d->shiftUpItem(newDelta);
+                    if (!item) {
+                        break;
+                    }
+                }
+            }
+            else {
+                while (-newDelta.y() < diff) {
+                    item = d->shiftDownItem(newDelta);
+                    if (!item) {
+                        break;
+                    }
+                }
+            }
+                result = newDelta.y();
+                return QPointF(delta.x(),delta.y()+result);
+
+          }
+      }
+      return delta;
+
+}
+
+HbAbstractViewItem *HbDatePickerContainerPrivate::item(const QModelIndex &index) const
+{
+    int itemCount = mItems.count();
+    for(int i=0;i<itemCount;++i) {
+        if(mItems.at(i)->modelIndex() == index) {
+            return mItems.at(i);
+        }
+    }
+    return 0;
+}
+HbAbstractViewItem *HbDatePickerContainerPrivate::shiftDownItem(QPointF& delta)
+{
+    Q_Q(HbDatePickerContainer);
+
+    HbAbstractViewItem *item = 0;
+    HbAbstractViewItem *lastItem = mItems.last();
+
+    QModelIndex nextIndex = mItemView->modelIterator()->nextIndex(lastItem->modelIndex());
+    if(q->isLoopingEnabled() && (!nextIndex.isValid())){
+       nextIndex = mItemView->model()->index(0,0);
+    }
+    if (nextIndex.isValid()) {
+        item = mItems.takeFirst();
+
+        q->itemRemoved(item,false);
+
+        delta.setY(delta.y() - item->size().height());
+
+        mItems.append(item);
+
+        q->setItemModelIndex(item, nextIndex);
+
+        q->itemAdded(mItems.count() - 1, item,false);
+    }
+    mBufferSize=4;
+    return item;
+}
+
+HbAbstractViewItem *HbDatePickerContainerPrivate::shiftUpItem(QPointF& delta)
+{
+    Q_Q(HbDatePickerContainer);
+
+    HbAbstractViewItem *item = 0;
+    HbAbstractViewItem *firstItem = mItems.first();
+
+    QModelIndex previousIndex = mItemView->modelIterator()->previousIndex(firstItem->modelIndex());
+    if(q->isLoopingEnabled() && !previousIndex.isValid()){
+        previousIndex = mItemView->model()->index(mItemView->model()->rowCount()-1,0);
+    }
+    if (previousIndex.isValid()) {
+        item = mItems.takeLast();
+
+        q->itemRemoved(item,false);
+
+        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,false);
+    }
+    return item;
+}
+qreal HbDatePickerContainerPrivate::getSmallestItemHeight() const
+{
+    Q_Q(const HbDatePickerContainer);
+    qreal minHeight = 0.0;
+    if (mItems.count() > 0) {
+        minHeight = mLayout->smallestItemHeight();
+    }
+    if (minHeight == 0.0) {
+        QModelIndex index;
+        while (mItems.isEmpty()) {
+            // in practise following conditions must apply: itemview is empty and scrollTo() has been called.
+            // Starts populating items from given mFirstItemIndex
+            if ( mFirstItemIndex.isValid()) {
+                index = mFirstItemIndex;
+                const_cast<QPersistentModelIndex&>(mFirstItemIndex) = QModelIndex();
+            } else {
+                index = mItemView->modelIterator()->nextIndex(index);
+            }
+            if (!index.isValid()) {
+                break;
+            }
+            const_cast<HbDatePickerContainer *>(q)->insertItem(0, index);
+        }
+
+        if (!mItems.isEmpty()) {
+            minHeight = mItems.first()->preferredHeight();
+        }
+    }
+    return minHeight;
+}
+int HbDatePickerContainer::maxItemPossible()const
+{
+    Q_D(const HbDatePickerContainer);
+    qreal minHeight = d->getSmallestItemHeight();
+    if (minHeight > 0) {
+        int countEstimate = qCeil(d->mItemView->boundingRect().height() / minHeight)
+            + d->mBufferSize;
+        return countEstimate;
+    }
+    return 0;
+}
+int HbDatePickerContainer::maxItemCount() const
+{
+    Q_D(const HbDatePickerContainer);
+    int targetCount = HbAbstractItemContainer::maxItemCount();
+    if (targetCount > 0
+        && d->mItemRecycling
+        && d->mPrototypes.count() <= 1) {
+
+        qreal minHeight = d->getSmallestItemHeight();
+
+        if (minHeight > 0) {
+            int countEstimate = qCeil(d->mItemView->boundingRect().height() / minHeight)
+                + d->mBufferSize;
+
+            // This limits the targetCount not to be larger
+            // than row count inside model.
+            targetCount = qMin(targetCount, countEstimate);
+        } else {
+            targetCount = 0;
+        }
+    }
+    return targetCount;
+}
+HbAbstractViewItem *HbDatePickerContainer::createDefaultPrototype()const
+{
+    return new HbDatePickerViewItem();
+}
+
+HbDatePickerContainer::HbDatePickerContainer(QGraphicsItem* parent)
+    :HbAbstractItemContainer(*(new HbDatePickerContainerPrivate),parent )
+{
+    Q_D(HbDatePickerContainer);
+    d->init();
+}
+
+HbDatePickerViewPrivate::HbDatePickerViewPrivate()
+    :animationtimer(0),animation(0),
+    mBackground(0),mFrame(0),mHighlight(0),mDivider(0),
+    viewStates(NoState)
+{
+
+}
+HbDatePickerViewPrivate::~HbDatePickerViewPrivate()
+{
+    if(animationtimer){
+        if(animationtimer->state() != QTimeLine::NotRunning) {
+            animationtimer->stop();
+        }
+        delete animationtimer;
+        delete animation;
+    }
+}
+
+
+HbDatePickerView::HbDatePickerView(QGraphicsItem *parent)
+    :HbAbstractItemView(*(new HbDatePickerViewPrivate),new HbDatePickerContainer,new HbModelIterator(),parent)
+{
+    Q_D(HbDatePickerView);
+    d->mAbleToScrollY = true;
+    setSelectionMode(HbAbstractItemView::SingleSelection);
+    setLongPressEnabled(false);
+    setUniformItemSizes(true);
+    setEnabledAnimations(HbAbstractItemView::TouchDown);
+    setItemRecycling(true);
+    //scroll area settings
+    setClampingStyle(HbScrollArea::BounceBackClamping);
+    setVerticalScrollBarPolicy(HbScrollArea::ScrollBarAlwaysOff);
+    setHorizontalScrollBarPolicy(HbScrollArea::ScrollBarAlwaysOff);
+    setFrictionEnabled(true);
+
+    //dont want this to occupy entire screen. preferred is few items.
+    setSizePolicy(QSizePolicy::Preferred,QSizePolicy::Preferred);
+
+
+    bool b = connect(this,SIGNAL(scrollingStarted()),this,SLOT(_q_scrollingStarted()));
+    Q_ASSERT(b);
+    b = connect(this,SIGNAL(scrollingEnded()),this,SLOT(_q_scrollingEnded()));
+    Q_ASSERT(b);
+    d->createPrimitives();
+    updatePrimitives();
+    setModel(new QStringListModel());
+
+}
+
+HbDatePickerView::~HbDatePickerView()
+{
+
+}
+
+void HbDatePickerView::rowsRemoved(const QModelIndex &parent, int start, int end)
+{
+    Q_D(HbDatePickerView);
+
+    HbAbstractItemView::rowsRemoved(parent,start,end);
+    HbDatePickerContainer* container = static_cast<HbDatePickerContainer*>(d->mContainer);
+
+    container->d_func()->updateItemBuffer();
+    //d->mContainer->layout()->activate();
+
+    d->mPostponedScrollIndex = currentIndex();
+    d->mPostponedScrollHint = PositionAtCenter;
+    QCoreApplication::postEvent(this, new QEvent(QEvent::LayoutRequest));
+}
+void HbDatePickerView::rowsAboutToBeInserted(const QModelIndex &index, int start, int end)
+{
+    Q_D(HbDatePickerView);
+    QPointF containerPos =  d->mContainer->pos();
+    if(containerPos.y()>0){
+        containerPos.setY(0);
+        d->mContainer->setPos(containerPos);
+    }
+    HbAbstractItemView::rowsAboutToBeInserted(index,start,end);
+}
+
+void HbDatePickerView::rowsInserted(const QModelIndex &parent, int start, int end)
+{
+    Q_D(HbDatePickerView);
+    HbAbstractItemView::rowsInserted(parent,start,end);
+    //d->mContainer->layout()->activate();
+   // scrollTo(currentIndex(),PositionAtCenter);
+    d->mPostponedScrollIndex = currentIndex();
+    d->mPostponedScrollHint = PositionAtCenter;
+}
+
+void HbDatePickerView::scrollTo(const QModelIndex &index, ScrollHint hint)
+{
+    Q_D(HbDatePickerView);
+    hint = PositionAtCenter;
+    if (!d->mModelIterator->model()
+        ||  index.model() != d->mModelIterator->model()) {
+        return;
+    }
+    //If item is in the buffer, just reveal it.
+    //This is always the case if recycling is off
+    //and sometimes the case when recycling is on
+    if (itemRecycling()) {
+        if (    !d->mContainer->itemByIndex(index)
+            ||  hint != EnsureVisible) {
+            //Now the item is not in the buffer.
+            //We must first set the item to be in the buffer
+            //If the item is above let's put it first and if it is below put it last
+            int newIndex = -1;
+            switch (hint) {
+            case PositionAtCenter: {
+                    int containerCount = d->mContainer->items().count();
+                    newIndex = index.row() - containerCount / 2 ;
+                    if(newIndex < 0){
+                        if(((HbDatePickerContainer*)(d->mContainer))->isLoopingNeeded()){
+                            newIndex = d->mModelIterator->indexCount()+newIndex;
+                        }
+                        else{
+                            newIndex = 0;
+                        }
+                    }
+                    break;
+                }
+            case EnsureVisible:
+            case PositionAtTop:
+            case PositionAtBottom:
+            default: {
+                     }
+            }
+            d->mContainer->setModelIndexes(d->mModelIterator->index(newIndex));
+        }
+    }
+    //HbAbstractItemView::scrollTo(index, hint);
+    if (    index.isValid()
+        &&  d->mModelIterator->model() == index.model()) {
+        d->mPostponedScrollIndex = QPersistentModelIndex();
+        d->scrollTo(index, hint);
+        d->mPostponedScrollIndex = index;
+        d->mPostponedScrollHint = hint;
+        if (    d->mContainer->itemRecycling()
+            &&  !d->mContainer->items().count()) {
+            // settings index from which loading viewitems start when itemview is
+            // empty or reset by setModel()
+            ((HbDatePickerContainer*)d->mContainer)->d_func()->mFirstItemIndex = index;
+        }
+       // QCoreApplication::postEvent(this, new QEvent(QEvent::LayoutRequest));
+    }
+}
+
+void HbDatePickerViewPrivate::_q_scrollingStarted()
+{
+    viewStates |= ScrollStarted;
+}
+
+void HbDatePickerViewPrivate::slectItemAt(const QPointF& point,QGraphicsItem* itemTomap)
+{
+    Q_Q(HbDatePickerView);
+    QPointF mappedPoint = itemTomap->mapToScene(point);
+    HbDatePickerContainer* container = static_cast<HbDatePickerContainer*>(mContainer);
+    HbDatePickerContainerPrivate* containerPriv = container->d_func();
+    
+    HbAbstractViewItem* item = qobject_cast<HbAbstractViewItem*>(itemAt(mappedPoint)); //(q->sender());    
+    if(item){
+        QPointF centerPt = q->mapToScene(q->boundingRect().center());
+        qreal itemHeight = containerPriv->getSmallestItemHeight();
+        centerPt.setY(centerPt.y()- itemHeight/2);
+        QPointF itemPos = q->mapToScene(containerPriv->itemBoundingRect(item).topLeft());
+        QPointF delta = itemPos-centerPt;
+
+        if(qCeil(delta.y())!=0){
+            QPointF contPos = container->pos();
+            QPointF newPos =  contPos-QPointF(0,qCeil(delta.y()));
+            //need to remove already posted request to avoid multiple scrolling
+            QCoreApplication::removePostedEvents(q,QEvent::LayoutRequest);
+          q->scrollContentsTo(-newPos,200);
+        }
+        else {
+            q->setCurrentIndex(item->modelIndex());
+            emit q->itemSelected(item->modelIndex().row());
+        }
+
+    }
+
+}
+
+void HbDatePickerViewPrivate::_q_scrollingEnded()
+{
+    if(mOptions & PanningActive){
+        return;
+    }
+    if(viewStates.testFlag(TapStarted)){
+        viewStates &= ~TapStarted;
+        return;
+    }
+    Q_Q(HbDatePickerView);
+	mContainer->layout()->activate();//call this to get proper item;
+    slectItemAt(q->boundingRect().center(),q);
+}
+
+void HbDatePickerViewPrivate::_q_itemSelected(QPointF point)
+{
+    Q_Q(HbDatePickerView);
+    if(!mIsScrolling && !mIsAnimating){
+        slectItemAt(point,qobject_cast<HbAbstractViewItem*>(q->sender()));
+    }
+
+}
+
+HbAbstractViewItem* HbDatePickerViewPrivate::getCenterItem()
+{
+    Q_Q(HbDatePickerView);
+
+    if(!q->scene()) {
+        return 0;
+    }
+    QPointF centerPt = q->mapToScene(q->boundingRect().center());
+    return itemAt(centerPt);
+}
+qreal HbDatePickerViewPrivate::topBoundary()
+{
+    //top boundary and bottom boundary is different for tumble view
+    //it is half item less than the middle of the view
+    Q_Q( HbDatePickerView );
+    qreal itemheight = (static_cast<HbDatePickerContainer*>(mContainer))->d_func()->getSmallestItemHeight();
+    return (-(q->boundingRect().height()-itemheight)/2);
+}
+
+qreal HbDatePickerViewPrivate::bottomBoundary()
+{
+    Q_Q ( HbDatePickerView);
+    qreal itemheight = (static_cast<HbDatePickerContainer*>(mContainer))->d_func()->getSmallestItemHeight();   
+    return mContents->boundingRect().height()-((q->boundingRect().height()+itemheight)/2);   
+}
+
+QSizeF HbDatePickerView::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
+{
+    Q_UNUSED(constraint);
+    Q_D(const HbDatePickerView);
+    QSizeF sh=HbAbstractItemView::sizeHint(which,constraint);
+    qreal mheight =(static_cast<HbDatePickerContainer*>(d->mContainer))->d_func()->getSmallestItemHeight();
+    switch(which) {
+        case Qt::MinimumSize:
+            sh = QSizeF(sh.width(),HB_DATEPICKERVIEW_PREFERRED_ITEMS*mheight);
+            break;
+        case Qt::PreferredSize:
+            sh = QSizeF(sh.width(),HB_DATEPICKERVIEW_PREFERRED_ITEMS*mheight);
+            sh.setWidth(HbWidget::sizeHint(which, constraint).width());
+            break;
+        case Qt::MaximumSize:
+            break;
+        default:
+            qWarning("HbTumbleView::sizeHint(): unknown 'which'");
+            break;
+    }
+    return sh;
+}
+void HbDatePickerView::setSelected(int row)
+{
+    Q_D(HbDatePickerView);
+    if(model()){
+        setCurrentIndex(model()->index(row,0));
+        d->viewStates &= ~HbDatePickerViewPrivate::ScrollStarted;
+        scrollTo(model()->index(row,0),PositionAtCenter);
+        //scrolling will not be started all the time so we need to emit signal
+        //here in those cases.
+        if(!d->viewStates.testFlag(HbDatePickerViewPrivate::ScrollStarted)){
+            emit itemSelected(row);
+        }
+    }
+}
+
+int HbDatePickerView::selected() const
+{
+    return currentIndex().row();
+}
+
+void HbDatePickerView::setLoopingEnabled(bool looping)
+{
+    Q_UNUSED(looping)
+}
+bool HbDatePickerView::isLoopinEnabled()const
+{
+    return true;
+}
+void HbDatePickerViewPrivate::createPrimitives()
+{
+    Q_Q(HbDatePickerView);
+
+    //this is the highlight which is placed at center
+    if(!mHighlight) {
+        mHighlight = HbStylePrivate::createPrimitive(HbStylePrivate::P_TumbleView_highlight,q);
+        HbStyle::setItemName(mHighlight,"highlight");
+    }
+    if(!mDivider){
+        mDivider = HbStylePrivate::createPrimitive(HbStylePrivate::P_DateTimePicker_separator,q);
+        HbStyle::setItemName(mDivider,"separator");
+        mDivider->hide();
+    }
+
+}
+void HbDatePickerView::updatePrimitives()
+{
+    Q_D(HbDatePickerView);
+
+    HbStyleOption opt;
+    initStyleOption(&opt);
+
+    if(d->mBackground) {
+        HbStylePrivate::updatePrimitive(d->mBackground,HbStylePrivate::P_TumbleView_background,&opt);
+    }
+    if(d->mFrame) {
+        HbStylePrivate::updatePrimitive(d->mFrame,HbStylePrivate::P_TumbleView_frame,&opt);
+    } 
+    if(d->mHighlight) {
+        HbStylePrivate::updatePrimitive(d->mHighlight,HbStylePrivate::P_TumbleView_highlight,&opt);
+    }
+    if(d->mDivider){
+        HbStylePrivate::updatePrimitive(d->mDivider, HbStylePrivate::P_DateTimePicker_separator, &opt);
+    }
+    HbAbstractItemView::updatePrimitives();
+
+}
+
+
+void HbDatePickerView::gestureEvent(QGestureEvent *event)
+{
+    Q_D(HbDatePickerView);
+    if(QTapGesture *gesture = static_cast<QTapGesture*>(event->gesture(Qt::TapGesture))){
+        switch(gesture->state()){
+            case Qt::GestureStarted:
+            d->viewStates |= HbDatePickerViewPrivate::TapStarted;
+                break;
+            case Qt::GestureCanceled:
+
+                break;
+            case Qt::GestureFinished:
+                d->slectItemAt(boundingRect().center(),this);
+                break;
+            default:
+                break;
+
+        }
+    }
+    HbAbstractItemView::gestureEvent(event);
+}
+
+void HbDatePickerView::currentIndexChanged(const QModelIndex &current, const QModelIndex &previous)
+{
+    HbAbstractItemView::currentIndexChanged(current,previous);
+}
+
+void HbDatePickerView::orientationAboutToBeChanged()
+{
+    Q_D(HbDatePickerView);
+    d->mVisibleIndex = currentIndex();
+}
+
+
+#include "moc_hbdatepickerview_p.cpp"