133     Q_D(HbTumbleViewItemContainer);

   133     if(size().height() > itemView()->size().height()){

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

   134             Q_D(HbTumbleViewItemContainer);

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

   135             const qreal diff = d->getDiffWithoutScrollareaCompensation(delta);

   136 

   136           

   137     int firstVisibleBufferIndex = -1;

   137             if(diff !=0.0){      

   138     int lastVisibleBufferIndex = -1;

   138                   QPointF newDelta(0.0, 0.0);

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

   139                   qreal result = 0.0;

   140 

   140                   HbAbstractViewItem *item = 0;

   141     int hiddenAbove = firstVisibleBufferIndex;

   141                   if (diff < 0.0) {

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

   142                         while (-newDelta.y() > diff) {

   143 

   143                               item = d->shiftUpItem(newDelta);

   144     if (d->mItems.count()

   144                               if (!item) {

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

   145                                     break;

   146         // All items out of sight.

   146                               }

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

   147                         }

   148             // All items above view.

   148                   }

   149             hiddenAbove = d->mItems.count();

   149 

   150             hiddenBelow = 0;

   150                   else {

   151         } else {

   151                         while (-newDelta.y() < diff) {

   152             // All items below view.

   152                               item = d->shiftDownItem(newDelta);

   153             hiddenAbove = 0;

   153                               if (!item) {

   154             hiddenBelow = d->mItems.count();

   154                                     break;

   155         }

   155                               }

   156     }

   156                         }

   157 

   157                   }

   158     QPointF newDelta(delta);

   158 

   159 

   159                   result = newDelta.y();

   160     while (hiddenAbove > hiddenBelow + 1) {

   160                   return QPointF(delta.x(),delta.y()+result);

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

   161             }

   162         if (!item){

   162       }

   163             break;

   163 

   164         }

   164     return delta;

   165 

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

   167             hiddenBelow++;

   168         }

   169         hiddenAbove--;

   170     }

   171 

   172     while (hiddenBelow > hiddenAbove + 1) {

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

   174         if (!item) {

   175             break;

   176         }

   177 

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

   179             hiddenAbove++;

   180         }

   181         hiddenBelow--;

   182     }

   183 

   184     return newDelta;

   188     d->mIsLooped = looped;

   168     d->mIsLooped = looped;    

   189     if(looped){

   169 

   190         recycleItems(QPointF());

   170     d->mItemView->scrollTo(d->mItemView->currentIndex(),HbAbstractItemView::PositionAtCenter);

   191     }

   171     recycleItems(QPointF());

   192     else{

   193         setModelIndexes(d->mItemView->currentIndex());

   194     }