55     q->setClampingStyle(q->BounceBackClamping);

    53     q->connect(q, SIGNAL(scrollDirectionsChanged(Qt::Orientations)),

    56     q->setScrollingStyle(q->PanOrFlick);

    54                q, SLOT(scrollDirectionChanged(Qt::Orientations)));

    57     q->setVerticalScrollBarPolicy(HbScrollArea::ScrollBarAlwaysOff);

    58     q->setHorizontalScrollBarPolicy(HbScrollArea::ScrollBarAlwaysOff);

    59     q->setFrictionEnabled(false);

    60     q->setFlag(QGraphicsItem::ItemClipsToShape);

    61     QObject::connect(q, SIGNAL(scrollDirectionsChanged(Qt::Orientations)),

    62                       q, SLOT(scrollDirectionChanged(Qt::Orientations)));

   135     if (!mContainer->itemRecycling()

   165     if (!handleScrollBar(orientation)) {

   136         || mContainer->itemPrototypes().count() != 1 

   137         || mContainer->items().count() == 0) {

   143         if (orientation == Qt::Vertical) {

   171 

   144             updateVerticalScrollBar();

   172         qreal thumbPos = calculateScrollBarPos();

   145         } else {

   173         HbScrollBar *scrollBar = getScrollDirectionScrollBar();

   146             updateHorizontalScrollBar();

   174         scrollBar->setValue(thumbPos);

   147         }

   175     }

   148     }

   176 }

   149 } 

   177 

   150 

   178 /*!

   151 void HbGridViewPrivate::updateHorizontalScrollBar()

   179     \reimp

   152 {    

   180 */

   153     Q_Q(const HbGridView);

   154     

   155     HbAbstractViewItem *firstItem = mContainer->items().first();

   156     qreal uniformItemWidth = firstItem->size().width();

   157 

   158     int rowCount = q->rowCount();

   159     int indexCount = mModelIterator->indexCount();

   160 

   161     int virtualColumnCount = indexCount / rowCount;

   162     int remainder = indexCount % rowCount;

   163     if (remainder != 0) {

   164         virtualColumnCount++;

   165     }

   166 

   167     int firstItemModelRowNumber = mModelIterator->indexPosition(firstItem->modelIndex());

   168     int firstBufferItemRowNumber = firstItemModelRowNumber / rowCount; 

   169 

   170     QRectF itemRect = itemBoundingRect(firstItem);

   171     qreal realLeftBoundary = itemRect.left();   

   172     qreal virtualLeftBoundary = realLeftBoundary - (firstBufferItemRowNumber*uniformItemWidth); 

   173 

   174     qreal containerVirtualWidth = uniformItemWidth *  virtualColumnCount;

   175     qreal thumbPosition(0);

   176 

   177     // The scrollbar "thumb" position is the current position of the contents widget divided

   178     // by the difference between the width of the contents widget and the width of the scroll area.

   179     // This formula assumes that the "thumb" of the the scroll bar is sized proportionately to

   180     // the width of the contents widget.

   181     qreal hiddenVirtualWidth = containerVirtualWidth - q->boundingRect().width();

   182     if (hiddenVirtualWidth != 0) {

   183         thumbPosition = (-virtualLeftBoundary)  / hiddenVirtualWidth;

   184     }

   185 

   186     if (thumbPosition < 0.0)

   187         thumbPosition = 0.0;

   188     else if (thumbPosition > 1.0)

   189         thumbPosition = 1.0;

   190 

   191     if (mHorizontalScrollBar) {

   192         if (containerVirtualWidth!=0) {

   193             mHorizontalScrollBar->setPageSize(qBound ( (qreal)0.0,

   194                                      q->boundingRect().width() / containerVirtualWidth,

   195                                       (qreal)1.0));

   196         }

   197         mHorizontalScrollBar->setValue(thumbPosition); 

   198     }

   199 }

   200 

   201 void HbGridViewPrivate::updateVerticalScrollBar()

   202 {

   203     Q_Q(const HbGridView);

   204 

   205     HbAbstractViewItem *firstItem = mContainer->items().first();

   206     qreal uniformItemHeight = firstItem->size().height();

   207 

   208     int columnCount = q->columnCount();

   209     int indexCount = mModelIterator->indexCount();

   210 

   211     int virtualRowCount = indexCount / columnCount;

   212     int remainder = indexCount % columnCount;

   213     if (remainder != 0) {  //even one item requires the whole row

   214         virtualRowCount++;

   215     }

   216 

   217     int firstItemModelRowNumber = mModelIterator->indexPosition(firstItem->modelIndex());

   218     int firstBufferItemRowNumber = firstItemModelRowNumber / columnCount; 

   219 

   220     QRectF itemRect = itemBoundingRect(firstItem);

   221     qreal realTopBoundary = itemRect.top();

   222     qreal virtualTopBoundary = realTopBoundary - (firstBufferItemRowNumber*uniformItemHeight); 

   223 

   224     qreal containerVirtualHeight = uniformItemHeight *  virtualRowCount;

   225     qreal thumbPosition = 0;

   226 

   227     // The scrollbar "thumb" position is the current position of the contents widget divided

   228     // by the difference between the height of the contents widget and the height of the scroll area.

   229     // This formula assumes that the "thumb" of the the scroll bar is sized proportionately to

   230     // the height of the contents widget.

   231     qreal hiddenVirtualHeight = containerVirtualHeight - q->boundingRect().height();

   232     if (hiddenVirtualHeight != 0) {

   233         thumbPosition = (-virtualTopBoundary) / hiddenVirtualHeight;

   234     } 

   235 

   236     if (thumbPosition < 0.0)

   237         thumbPosition = 0.0;

   238     else if (thumbPosition > 1.0)

   239         thumbPosition = 1.0;

   240 

   241     if (mVerticalScrollBar) {

   242         if (containerVirtualHeight!=0) {

   243             mVerticalScrollBar->setPageSize(qBound ( (qreal)0.0,

   244                                      q->boundingRect().height() / containerVirtualHeight,

   245                                       (qreal)1.0));

   246         }

   247         mVerticalScrollBar->setValue(thumbPosition); 

   248     }    

   249 }

   250 

   252 {   

   182 {

   253     if (!mContainer->itemRecycling()

   183     if (!handleScrollBar(orientation)) {

   254         || mContainer->itemPrototypes().count() != 1 

   255         || mContainer->items().count() == 0)  {

   258         //We just make sure that the base clas is not called

   186         if (mContainer->layout() && !mContainer->layout()->isActivated()) {

   259         //It set the page size wrongly

   187             mContainer->layout()->activate();

   260         updateScrollBar(orientation); 

   188         }

   261     }

   189 

   262 } 

   190         qreal thumbSize = calculateScrollBarThumbSize();

   263 

   191         HbScrollBar *scrollBar = getScrollDirectionScrollBar();

   264 void HbGridViewPrivate::setContentPosition( qreal value, Qt::Orientation orientation, bool animate )

   192         scrollBar->setPageSize(thumbSize);

   193     }

   194 }

   195 

   196 /*!

   197     \reimp

   198 */

   199 void HbGridViewPrivate::setContentPosition(qreal value, Qt::Orientation orientation, bool animate)

   273         qreal filteredValue = (int)(value * 1000) / 1000.0;        

   208         int columnCount = getScrollDirectionColumnCount();

   274 

   209         int rowCount = getScrollDirectionRowCount();

   275         HbAbstractViewItem *firstItem = mContainer->items().first();

   210         int modelRowCount = (mModelIterator->indexCount() + columnCount - 1) / columnCount;

   276 

   211         modelRowCount -= rowCount;

   277         qreal uniformItemDimension = 0; // width or height of item

   212         qreal thumbPos = calculateScrollBarPos();

   278         qreal dimension = 0; // width or height of view

   213         qreal itemSize = getScrollDirectionItemSize();

   279         int dimensionCount = 0; // rowcount or columncount

   214         qreal diff = (value - thumbPos) * itemSize * modelRowCount;

   280         qreal posInBeginning = 0; // top or left position of first item in buffer

   283             posInBeginning = itemBoundingRect(firstItem).top();

   217             q->scrollByAmount(QPointF(0, diff));

   284             uniformItemDimension = firstItem->size().height();

   285             dimension = q->boundingRect().height();

   286             dimensionCount = q->columnCount();

   288             posInBeginning = itemBoundingRect(firstItem).left();

   219             q->scrollByAmount(QPointF(diff, 0));

   289             uniformItemDimension = firstItem->size().width();

   290             dimension = q->boundingRect().width();

   291             dimensionCount = q->rowCount();

   292         }

   293 

   294         int indexCount = mModelIterator->indexCount();

   295         int virtualCount = indexCount / dimensionCount; // amount of rows/columns in "complete" grid

   296         int remainder = indexCount % dimensionCount;

   297         if (remainder != 0) {  //even one item requires the whole row

   298             virtualCount++;

   299         }

   300 

   301         qreal target = virtualCount * filteredValue;  // target position in "complete" grid (in rows/columns)

   302         int virtualItemCount = virtualCount * dimensionCount; // item count when all the "empty" items are also counted in

   303         qreal posToBeInView = dimension * filteredValue; 

   304 

   305         QModelIndex newIndex = mModelIterator->index(qMin((int)(virtualItemCount * filteredValue), indexCount - 1));

   306 

   307         if (!mContainer->itemByIndex(newIndex)) {

   308             //jump

   309             int itemsInBuffer = mContainer->items().count();

   310 

   311             int newBufferStartItem = (int)(virtualItemCount * filteredValue) - qMin(itemsInBuffer - 1, (int)(itemsInBuffer * filteredValue));

   312             mContainer->setModelIndexes(mModelIterator->index(newBufferStartItem));

   313             int newBufferStartRow = newBufferStartItem / dimensionCount;

   314 

   315             qreal posToBeInBuffer = ((target - newBufferStartRow) * uniformItemDimension);

   316 

   317             qreal posToBe = posToBeInView - posToBeInBuffer;

   318 

   319             if (orientation == Qt::Vertical) {

   320                 HbScrollAreaPrivate::setContentPosition(QPointF(0, posToBe)); 

   321             } else {

   322                 HbScrollAreaPrivate::setContentPosition(QPointF(posToBe, 0)); 

   323             }

   324         } else {

   325             // scroll

   326             int firstItemRow = mContainer->items().first()->modelIndex().row() / dimensionCount;

   327 

   328             qreal posToBeInBuffer = (target - firstItemRow) * uniformItemDimension;

   329             

   330             qreal posToBe = posToBeInView - posToBeInBuffer;

   331 

   332             if (orientation == Qt::Vertical) {

   333                 q->scrollByAmount(QPointF(0, posInBeginning - posToBe));

   334             } else {

   335                 q->scrollByAmount(QPointF(posInBeginning - posToBe, 0));

   336             }