1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the QtDeclarative module of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include "private/qdeclarativegridview_p.h"

    43 

    44 #include "private/qdeclarativevisualitemmodel_p.h"

    45 #include "private/qdeclarativeflickable_p_p.h"

    46 

    47 #include "private/qdeclarativesmoothedanimation_p_p.h"

    48 #include <qdeclarativeguard_p.h>

    49 

    50 #include <qlistmodelinterface_p.h>

    51 #include <QKeyEvent>

    52 

    53 #include <qmath.h>

    54 #include <math.h>

    55 

    56 QT_BEGIN_NAMESPACE

    57 

    58 

    59 //----------------------------------------------------------------------------

    60 

    61 class FxGridItem

    62 {

    63 public:

    64     FxGridItem(QDeclarativeItem *i, QDeclarativeGridView *v) : item(i), view(v) {

    65         attached = static_cast<QDeclarativeGridViewAttached*>(qmlAttachedPropertiesObject<QDeclarativeGridView>(item));

    66         if (attached)

    67             attached->m_view = view;

    68     }

    69     ~FxGridItem() {}

    70 

    71     qreal rowPos() const { return (view->flow() == QDeclarativeGridView::LeftToRight ? item->y() : item->x()); }

    72     qreal colPos() const { return (view->flow() == QDeclarativeGridView::LeftToRight ? item->x() : item->y()); }

    73     qreal endRowPos() const {

    74         return view->flow() == QDeclarativeGridView::LeftToRight

    75                                 ? item->y() + view->cellHeight() - 1

    76                                 : item->x() + view->cellWidth() - 1;

    77     }

    78     void setPosition(qreal col, qreal row) {

    79         if (view->flow() == QDeclarativeGridView::LeftToRight) {

    80             item->setPos(QPointF(col, row));

    81         } else {

    82             item->setPos(QPointF(row, col));

    83         }

    84     }

    85     bool contains(int x, int y) const {

    86         return (x >= item->x() && x < item->x() + view->cellWidth() &&

    87                 y >= item->y() && y < item->y() + view->cellHeight());

    88     }

    89 

    90     QDeclarativeItem *item;

    91     QDeclarativeGridView *view;

    92     QDeclarativeGridViewAttached *attached;

    93     int index;

    94 };

    95 

    96 //----------------------------------------------------------------------------

    97 

    98 class QDeclarativeGridViewPrivate : public QDeclarativeFlickablePrivate

    99 {

   100     Q_DECLARE_PUBLIC(QDeclarativeGridView)

   101 

   102 public:

   103     QDeclarativeGridViewPrivate()

   104     : currentItem(0), flow(QDeclarativeGridView::LeftToRight)

   105     , visibleIndex(0) , currentIndex(-1)

   106     , cellWidth(100), cellHeight(100), columns(1), requestedIndex(-1), itemCount(0)

   107     , highlightRangeStart(0), highlightRangeEnd(0), highlightRange(QDeclarativeGridView::NoHighlightRange)

   108     , highlightComponent(0), highlight(0), trackedItem(0)

   109     , moveReason(Other), buffer(0), highlightXAnimator(0), highlightYAnimator(0)

   110     , highlightMoveDuration(150)

   111     , bufferMode(BufferBefore | BufferAfter), snapMode(QDeclarativeGridView::NoSnap)

   112     , ownModel(false), wrap(false), autoHighlight(true)

   113     , fixCurrentVisibility(false), lazyRelease(false), layoutScheduled(false)

   114     , deferredRelease(false), haveHighlightRange(false) {}

   115 

   116     void init();

   117     void clear();

   118     FxGridItem *createItem(int modelIndex);

   119     void releaseItem(FxGridItem *item);

   120     void refill(qreal from, qreal to, bool doBuffer=false);

   121 

   122     void updateGrid();

   123     void scheduleLayout();

   124     void layout();

   125     void updateUnrequestedIndexes();

   126     void updateUnrequestedPositions();

   127     void updateTrackedItem();

   128     void createHighlight();

   129     void updateHighlight();

   130     void updateCurrent(int modelIndex);

   131     void fixupPosition();

   132 

   133     FxGridItem *visibleItem(int modelIndex) const {

   134         if (modelIndex >= visibleIndex && modelIndex < visibleIndex + visibleItems.count()) {

   135             for (int i = modelIndex - visibleIndex; i < visibleItems.count(); ++i) {

   136                 FxGridItem *item = visibleItems.at(i);

   137                 if (item->index == modelIndex)

   138                     return item;

   139             }

   140         }

   141         return 0;

   142     }

   143 

   144     qreal position() const {

   145         Q_Q(const QDeclarativeGridView);

   146         return flow == QDeclarativeGridView::LeftToRight ? q->contentY() : q->contentX();

   147     }

   148     void setPosition(qreal pos) {

   149         Q_Q(QDeclarativeGridView);

   150         if (flow == QDeclarativeGridView::LeftToRight)

   151             q->setContentY(pos);

   152         else

   153             q->setContentX(pos);

   154     }

   155     int size() const {

   156         Q_Q(const QDeclarativeGridView);

   157         return flow == QDeclarativeGridView::LeftToRight ? q->height() : q->width();

   158     }

   159     qreal startPosition() const {

   160         qreal pos = 0;

   161         if (!visibleItems.isEmpty())

   162             pos = visibleItems.first()->rowPos() - visibleIndex / columns * rowSize();

   163         return pos;

   164     }

   165 

   166     qreal endPosition() const {

   167         qreal pos = 0;

   168         if (model && model->count())

   169             pos = rowPosAt(model->count() - 1) + rowSize();

   170         return pos;

   171     }

   172 

   173     bool isValid() const {

   174         return model && model->count() && model->isValid();

   175     }

   176 

   177     int rowSize() const {

   178         return flow == QDeclarativeGridView::LeftToRight ? cellHeight : cellWidth;

   179     }

   180     int colSize() const {

   181         return flow == QDeclarativeGridView::LeftToRight ? cellWidth : cellHeight;

   182     }

   183 

   184     qreal colPosAt(int modelIndex) const {

   185         if (FxGridItem *item = visibleItem(modelIndex))

   186             return item->colPos();

   187         if (!visibleItems.isEmpty()) {

   188             if (modelIndex < visibleIndex) {

   189                 int count = (visibleIndex - modelIndex) % columns;

   190                 int col = visibleItems.first()->colPos() / colSize();

   191                 col = (columns - count + col) % columns;

   192                 return col * colSize();

   193             } else {

   194                 int count = columns - 1 - (modelIndex - visibleItems.last()->index - 1) % columns;

   195                 return visibleItems.last()->colPos() - count * colSize();

   196             }

   197         } else {

   198             return (modelIndex % columns) * colSize();

   199         }

   200         return 0;

   201     }

   202     qreal rowPosAt(int modelIndex) const {

   203         if (FxGridItem *item = visibleItem(modelIndex))

   204             return item->rowPos();

   205         if (!visibleItems.isEmpty()) {

   206             if (modelIndex < visibleIndex) {

   207                 int firstCol = visibleItems.first()->colPos() / colSize();

   208                 int col = visibleIndex - modelIndex + (columns - firstCol - 1);

   209                 int rows = col / columns;

   210                 return visibleItems.first()->rowPos() - rows * rowSize();

   211             } else {

   212                 int count = modelIndex - visibleItems.last()->index;

   213                 int col = visibleItems.last()->colPos() + count * colSize();

   214                 int rows = col / (columns * colSize());

   215                 return visibleItems.last()->rowPos() + rows * rowSize();

   216             }

   217         } else {

   218              return (modelIndex / columns) * rowSize();

   219         }

   220         return 0;

   221     }

   222 

   223     FxGridItem *firstVisibleItem() const {

   224         const qreal pos = position();

   225         for (int i = 0; i < visibleItems.count(); ++i) {

   226             FxGridItem *item = visibleItems.at(i);

   227             if (item->index != -1 && item->endRowPos() > pos)

   228                 return item;

   229         }

   230         return visibleItems.count() ? visibleItems.first() : 0;

   231     }

   232 

   233     // Map a model index to visibleItems list index.

   234     // These may differ if removed items are still present in the visible list,

   235     // e.g. doing a removal animation

   236     int mapFromModel(int modelIndex) const {

   237         if (modelIndex < visibleIndex || modelIndex >= visibleIndex + visibleItems.count())

   238             return -1;

   239         for (int i = 0; i < visibleItems.count(); ++i) {

   240             FxGridItem *listItem = visibleItems.at(i);

   241             if (listItem->index == modelIndex)

   242                 return i + visibleIndex;

   243             if (listItem->index > modelIndex)

   244                 return -1;

   245         }

   246         return -1; // Not in visibleList

   247     }

   248 

   249     qreal snapPosAt(qreal pos) {

   250         qreal snapPos = 0;

   251         if (!visibleItems.isEmpty()) {

   252             pos += rowSize()/2;

   253             snapPos = visibleItems.first()->rowPos() - visibleIndex / columns * rowSize();

   254             snapPos = pos - fmodf(pos - snapPos, qreal(rowSize()));

   255         }

   256         return snapPos;

   257     }

   258 

   259     int snapIndex() {

   260         int index = currentIndex;

   261         for (int i = 0; i < visibleItems.count(); ++i) {

   262             FxGridItem *item = visibleItems[i];

   263             if (item->index == -1)

   264                 continue;

   265             qreal itemTop = item->rowPos();

   266             if (itemTop >= highlight->rowPos()-rowSize()/2 && itemTop < highlight->rowPos()+rowSize()/2) {

   267                 index = item->index;

   268                 if (item->colPos() >= highlight->colPos()-colSize()/2 && item->colPos() < highlight->colPos()+colSize()/2)

   269                     return item->index;

   270             }

   271         }

   272         return index;

   273     }

   274 

   275     virtual void itemGeometryChanged(QDeclarativeItem *item, const QRectF &newGeometry, const QRectF &oldGeometry) {

   276         Q_Q(const QDeclarativeGridView);

   277         QDeclarativeFlickablePrivate::itemGeometryChanged(item, newGeometry, oldGeometry);

   278         if (item == q) {

   279             if (newGeometry.height() != oldGeometry.height()

   280                 || newGeometry.width() != oldGeometry.width()) {

   281                 if (q->isComponentComplete()) {

   282                     updateGrid();

   283                     scheduleLayout();

   284                 }

   285             }

   286         }

   287     }

   288 

   289     virtual void fixup(AxisData &data, qreal minExtent, qreal maxExtent);

   290     virtual void flick(AxisData &data, qreal minExtent, qreal maxExtent, qreal vSize,

   291                 QDeclarativeTimeLineCallback::Callback fixupCallback, qreal velocity);

   292 

   293     // for debugging only

   294     void checkVisible() const {

   295         int skip = 0;

   296         for (int i = 0; i < visibleItems.count(); ++i) {

   297             FxGridItem *listItem = visibleItems.at(i);

   298             if (listItem->index == -1) {

   299                 ++skip;

   300             } else if (listItem->index != visibleIndex + i - skip) {

   301                 for (int j = 0; j < visibleItems.count(); j++)

   302                     qDebug() << " index" << j << "item index" << visibleItems.at(j)->index;

   303                 qFatal("index %d %d %d", visibleIndex, i, listItem->index);

   304             }

   305         }

   306     }

   307 

   308     QDeclarativeGuard<QDeclarativeVisualModel> model;

   309     QVariant modelVariant;

   310     QList<FxGridItem*> visibleItems;

   311     QHash<QDeclarativeItem*,int> unrequestedItems;

   312     FxGridItem *currentItem;

   313     QDeclarativeGridView::Flow flow;

   314     int visibleIndex;

   315     int currentIndex;

   316     int cellWidth;

   317     int cellHeight;

   318     int columns;

   319     int requestedIndex;

   320     int itemCount;

   321     qreal highlightRangeStart;

   322     qreal highlightRangeEnd;

   323     QDeclarativeGridView::HighlightRangeMode highlightRange;

   324     QDeclarativeComponent *highlightComponent;

   325     FxGridItem *highlight;

   326     FxGridItem *trackedItem;

   327     enum MovementReason { Other, SetIndex, Mouse };

   328     MovementReason moveReason;

   329     int buffer;

   330     QSmoothedAnimation *highlightXAnimator;

   331     QSmoothedAnimation *highlightYAnimator;

   332     int highlightMoveDuration;

   333     enum BufferMode { NoBuffer = 0x00, BufferBefore = 0x01, BufferAfter = 0x02 };

   334     int bufferMode;

   335     QDeclarativeGridView::SnapMode snapMode;

   336 

   337     bool ownModel : 1;

   338     bool wrap : 1;

   339     bool autoHighlight : 1;

   340     bool fixCurrentVisibility : 1;

   341     bool lazyRelease : 1;

   342     bool layoutScheduled : 1;

   343     bool deferredRelease : 1;

   344     bool haveHighlightRange : 1;

   345 };

   346 

   347 void QDeclarativeGridViewPrivate::init()

   348 {

   349     Q_Q(QDeclarativeGridView);

   350     QObject::connect(q, SIGNAL(movementEnded()), q, SLOT(animStopped()));

   351     q->setFlag(QGraphicsItem::ItemIsFocusScope);

   352     q->setFlickableDirection(QDeclarativeFlickable::VerticalFlick);

   353     addItemChangeListener(this, Geometry);

   354 }

   355 

   356 void QDeclarativeGridViewPrivate::clear()

   357 {

   358     for (int i = 0; i < visibleItems.count(); ++i)

   359         releaseItem(visibleItems.at(i));

   360     visibleItems.clear();

   361     visibleIndex = 0;

   362     releaseItem(currentItem);

   363     currentItem = 0;

   364     createHighlight();

   365     trackedItem = 0;

   366     itemCount = 0;

   367 }

   368 

   369 FxGridItem *QDeclarativeGridViewPrivate::createItem(int modelIndex)

   370 {

   371     Q_Q(QDeclarativeGridView);

   372     // create object

   373     requestedIndex = modelIndex;

   374     FxGridItem *listItem = 0;

   375     if (QDeclarativeItem *item = model->item(modelIndex, false)) {

   376         listItem = new FxGridItem(item, q);

   377         listItem->index = modelIndex;

   378         if (model->completePending()) {

   379             // complete

   380             listItem->item->setZValue(1);

   381             listItem->item->setParentItem(q->viewport());

   382             model->completeItem();

   383         } else {

   384             listItem->item->setParentItem(q->viewport());

   385         }

   386         unrequestedItems.remove(listItem->item);

   387     }

   388     requestedIndex = -1;

   389     return listItem;

   390 }

   391 

   392 

   393 void QDeclarativeGridViewPrivate::releaseItem(FxGridItem *item)

   394 {

   395     Q_Q(QDeclarativeGridView);

   396     if (!item || !model)

   397         return;

   398     if (trackedItem == item) {

   399         QObject::disconnect(trackedItem->item, SIGNAL(yChanged()), q, SLOT(trackedPositionChanged()));

   400         QObject::disconnect(trackedItem->item, SIGNAL(xChanged()), q, SLOT(trackedPositionChanged()));

   401         trackedItem = 0;

   402     }

   403     if (model->release(item->item) == 0) {

   404         // item was not destroyed, and we no longer reference it.

   405         unrequestedItems.insert(item->item, model->indexOf(item->item, q));

   406     }

   407     delete item;

   408 }

   409 

   410 void QDeclarativeGridViewPrivate::refill(qreal from, qreal to, bool doBuffer)

   411 {

   412     Q_Q(QDeclarativeGridView);

   413     if (!isValid() || !q->isComponentComplete())

   414         return;

   415 

   416     itemCount = model->count();

   417     qreal bufferFrom = from - buffer;

   418     qreal bufferTo = to + buffer;

   419     qreal fillFrom = from;

   420     qreal fillTo = to;

   421     if (doBuffer && (bufferMode & BufferAfter))

   422         fillTo = bufferTo;

   423     if (doBuffer && (bufferMode & BufferBefore))

   424         fillFrom = bufferFrom;

   425 

   426     bool changed = false;

   427 

   428     int colPos = colPosAt(visibleIndex);

   429     int rowPos = rowPosAt(visibleIndex);

   430     int modelIndex = visibleIndex;

   431     if (visibleItems.count()) {

   432         rowPos = visibleItems.last()->rowPos();

   433         colPos = visibleItems.last()->colPos() + colSize();

   434         if (colPos > colSize() * (columns-1)) {

   435             colPos = 0;

   436             rowPos += rowSize();

   437         }

   438         int i = visibleItems.count() - 1;

   439         while (i > 0 && visibleItems.at(i)->index == -1)

   440             --i;

   441         modelIndex = visibleItems.at(i)->index + 1;

   442     }

   443     int colNum = colPos / colSize();

   444 

   445     FxGridItem *item = 0;

   446 

   447     // Item creation and release is staggered in order to avoid

   448     // creating/releasing multiple items in one frame

   449     // while flicking (as much as possible).

   450     while (modelIndex < model->count() && rowPos <= fillTo + rowSize()*(columns - colNum)/(columns+1)) {

   451 //        qDebug() << "refill: append item" << modelIndex;

   452         if (!(item = createItem(modelIndex)))

   453             break;

   454         item->setPosition(colPos, rowPos);

   455         visibleItems.append(item);

   456         colPos += colSize();

   457         colNum++;

   458         if (colPos > colSize() * (columns-1)) {

   459             colPos = 0;

   460             colNum = 0;

   461             rowPos += rowSize();

   462         }

   463         ++modelIndex;

   464         changed = true;

   465         if (doBuffer) // never buffer more than one item per frame

   466             break;

   467     }

   468 

   469     if (visibleItems.count()) {

   470         rowPos = visibleItems.first()->rowPos();

   471         colPos = visibleItems.first()->colPos() - colSize();

   472         if (colPos < 0) {

   473             colPos = colSize() * (columns - 1);

   474             rowPos -= rowSize();

   475         }

   476     }

   477     colNum = colPos / colSize();

   478     while (visibleIndex > 0 && rowPos + rowSize() - 1 >= fillFrom - rowSize()*(colNum+1)/(columns+1)){

   479 //        qDebug() << "refill: prepend item" << visibleIndex-1 << "top pos" << rowPos << colPos;

   480         if (!(item = createItem(visibleIndex-1)))

   481             break;

   482         --visibleIndex;

   483         item->setPosition(colPos, rowPos);

   484         visibleItems.prepend(item);

   485         colPos -= colSize();

   486         colNum--;

   487         if (colPos < 0) {

   488             colPos = colSize() * (columns - 1);

   489             colNum = columns-1;

   490             rowPos -= rowSize();

   491         }

   492         changed = true;

   493         if (doBuffer) // never buffer more than one item per frame

   494             break;

   495     }

   496 

   497     if (!lazyRelease || !changed || deferredRelease) { // avoid destroying items in the same frame that we create

   498         while (visibleItems.count() > 1

   499                && (item = visibleItems.first())

   500                     && item->endRowPos() < bufferFrom - rowSize()*(item->colPos()/colSize()+1)/(columns+1)) {

   501             if (item->attached->delayRemove())

   502                 break;

   503 //            qDebug() << "refill: remove first" << visibleIndex << "top end pos" << item->endRowPos();

   504             if (item->index != -1)

   505                 visibleIndex++;

   506             visibleItems.removeFirst();

   507             releaseItem(item);

   508             changed = true;

   509         }

   510         while (visibleItems.count() > 1

   511                && (item = visibleItems.last())

   512                     && item->rowPos() > bufferTo + rowSize()*(columns - item->colPos()/colSize())/(columns+1)) {

   513             if (item->attached->delayRemove())

   514                 break;

   515 //            qDebug() << "refill: remove last" << visibleIndex+visibleItems.count()-1;

   516             visibleItems.removeLast();

   517             releaseItem(item);

   518             changed = true;

   519         }

   520         deferredRelease = false;

   521     } else {

   522         deferredRelease = true;

   523     }

   524     if (changed) {

   525         if (flow == QDeclarativeGridView::LeftToRight)

   526             q->setContentHeight(endPosition() - startPosition());

   527         else

   528             q->setContentWidth(endPosition() - startPosition());

   529     } else if (!doBuffer && buffer && bufferMode != NoBuffer) {

   530         refill(from, to, true);

   531     }

   532     lazyRelease = false;

   533 }

   534 

   535 void QDeclarativeGridViewPrivate::updateGrid()

   536 {

   537     Q_Q(QDeclarativeGridView);

   538     columns = (int)qMax((flow == QDeclarativeGridView::LeftToRight ? q->width() : q->height()) / colSize(), qreal(1.));

   539     if (isValid()) {

   540         if (flow == QDeclarativeGridView::LeftToRight)

   541             q->setContentHeight(endPosition() - startPosition());

   542         else

   543             q->setContentWidth(endPosition() - startPosition());

   544     }

   545 }

   546 

   547 void QDeclarativeGridViewPrivate::scheduleLayout()

   548 {

   549     Q_Q(QDeclarativeGridView);

   550     if (!layoutScheduled) {

   551         layoutScheduled = true;

   552         QCoreApplication::postEvent(q, new QEvent(QEvent::User), Qt::HighEventPriority);

   553     }

   554 }

   555 

   556 void QDeclarativeGridViewPrivate::layout()

   557 {

   558     Q_Q(QDeclarativeGridView);

   559     layoutScheduled = false;

   560     if (!isValid()) {

   561         clear();

   562         return;

   563     }

   564     if (visibleItems.count()) {

   565         qreal rowPos = visibleItems.first()->rowPos();

   566         qreal colPos = visibleItems.first()->colPos();

   567         int col = visibleIndex % columns;

   568         if (colPos != col * colSize()) {

   569             colPos = col * colSize();

   570             visibleItems.first()->setPosition(colPos, rowPos);

   571         }

   572         for (int i = 1; i < visibleItems.count(); ++i) {

   573             FxGridItem *item = visibleItems.at(i);

   574             colPos += colSize();

   575             if (colPos > colSize() * (columns-1)) {

   576                 colPos = 0;

   577                 rowPos += rowSize();

   578             }

   579             item->setPosition(colPos, rowPos);

   580         }

   581     }

   582     q->refill();

   583     updateHighlight();

   584     moveReason = Other;

   585     if (flow == QDeclarativeGridView::LeftToRight) {

   586         q->setContentHeight(endPosition() - startPosition());

   587         fixupY();

   588     } else {

   589         q->setContentWidth(endPosition() - startPosition());

   590         fixupX();

   591     }

   592     updateUnrequestedPositions();

   593 }

   594 

   595 void QDeclarativeGridViewPrivate::updateUnrequestedIndexes()

   596 {

   597     Q_Q(QDeclarativeGridView);

   598     QHash<QDeclarativeItem*,int>::iterator it;

   599     for (it = unrequestedItems.begin(); it != unrequestedItems.end(); ++it)

   600         *it = model->indexOf(it.key(), q);

   601 }

   602 

   603 void QDeclarativeGridViewPrivate::updateUnrequestedPositions()

   604 {

   605     QHash<QDeclarativeItem*,int>::const_iterator it;

   606     for (it = unrequestedItems.begin(); it != unrequestedItems.end(); ++it) {

   607         if (flow == QDeclarativeGridView::LeftToRight) {

   608             it.key()->setPos(QPointF(colPosAt(*it), rowPosAt(*it)));

   609         } else {

   610             it.key()->setPos(QPointF(rowPosAt(*it), colPosAt(*it)));

   611         }

   612     }

   613 }

   614 

   615 void QDeclarativeGridViewPrivate::updateTrackedItem()

   616 {

   617     Q_Q(QDeclarativeGridView);

   618     FxGridItem *item = currentItem;

   619     if (highlight)

   620         item = highlight;

   621 

   622     if (trackedItem && item != trackedItem) {

   623         QObject::disconnect(trackedItem->item, SIGNAL(yChanged()), q, SLOT(trackedPositionChanged()));

   624         QObject::disconnect(trackedItem->item, SIGNAL(xChanged()), q, SLOT(trackedPositionChanged()));

   625         trackedItem = 0;

   626     }

   627 

   628     if (!trackedItem && item) {

   629         trackedItem = item;

   630         QObject::connect(trackedItem->item, SIGNAL(yChanged()), q, SLOT(trackedPositionChanged()));

   631         QObject::connect(trackedItem->item, SIGNAL(xChanged()), q, SLOT(trackedPositionChanged()));

   632     }

   633     if (trackedItem)

   634         q->trackedPositionChanged();

   635 }

   636 

   637 void QDeclarativeGridViewPrivate::createHighlight()

   638 {

   639     Q_Q(QDeclarativeGridView);

   640     bool changed = false;

   641     if (highlight) {

   642         if (trackedItem == highlight)

   643             trackedItem = 0;

   644         delete highlight->item;

   645         delete highlight;

   646         highlight = 0;

   647         delete highlightXAnimator;

   648         delete highlightYAnimator;

   649         highlightXAnimator = 0;

   650         highlightYAnimator = 0;

   651         changed = true;

   652     }

   653 

   654     if (currentItem) {

   655         QDeclarativeItem *item = 0;

   656         if (highlightComponent) {

   657             QDeclarativeContext *highlightContext = new QDeclarativeContext(qmlContext(q));

   658             QObject *nobj = highlightComponent->create(highlightContext);

   659             if (nobj) {

   660                 QDeclarative_setParent_noEvent(highlightContext, nobj);

   661                 item = qobject_cast<QDeclarativeItem *>(nobj);

   662                 if (!item)

   663                     delete nobj;

   664             } else {

   665                 delete highlightContext;

   666             }

   667         } else {

   668             item = new QDeclarativeItem;

   669             QDeclarative_setParent_noEvent(item, q->viewport());

   670             item->setParentItem(q->viewport());

   671         }

   672         if (item) {

   673             QDeclarative_setParent_noEvent(item, q->viewport());

   674             item->setParentItem(q->viewport());

   675             highlight = new FxGridItem(item, q);

   676             highlightXAnimator = new QSmoothedAnimation(q);

   677             highlightXAnimator->target = QDeclarativeProperty(highlight->item, QLatin1String("x"));

   678             highlightXAnimator->userDuration = highlightMoveDuration;

   679             highlightYAnimator = new QSmoothedAnimation(q);

   680             highlightYAnimator->target = QDeclarativeProperty(highlight->item, QLatin1String("y"));

   681             highlightYAnimator->userDuration = highlightMoveDuration;

   682             if (autoHighlight) {

   683                 highlightXAnimator->restart();

   684                 highlightYAnimator->restart();

   685             }

   686             changed = true;

   687         }

   688     }

   689     if (changed)

   690         emit q->highlightItemChanged();

   691 }

   692 

   693 void QDeclarativeGridViewPrivate::updateHighlight()

   694 {

   695     if ((!currentItem && highlight) || (currentItem && !highlight))

   696         createHighlight();

   697     if (currentItem && autoHighlight && highlight && !movingHorizontally && !movingVertically) {

   698         // auto-update highlight

   699         highlightXAnimator->to = currentItem->item->x();

   700         highlightYAnimator->to = currentItem->item->y();

   701         highlight->item->setWidth(currentItem->item->width());

   702         highlight->item->setHeight(currentItem->item->height());

   703         highlightXAnimator->restart();

   704         highlightYAnimator->restart();

   705     }

   706     updateTrackedItem();

   707 }

   708 

   709 void QDeclarativeGridViewPrivate::updateCurrent(int modelIndex)

   710 {

   711     Q_Q(QDeclarativeGridView);

   712     if (!q->isComponentComplete() || !isValid() || modelIndex < 0 || modelIndex >= model->count()) {

   713         if (currentItem) {

   714             currentItem->attached->setIsCurrentItem(false);

   715             releaseItem(currentItem);

   716             currentItem = 0;

   717             currentIndex = -1;

   718             updateHighlight();

   719             emit q->currentIndexChanged();

   720         }

   721         return;

   722     }

   723 

   724     if (currentItem && currentIndex == modelIndex) {

   725         updateHighlight();

   726         return;

   727     }

   728 

   729     FxGridItem *oldCurrentItem = currentItem;

   730     currentIndex = modelIndex;

   731     currentItem = createItem(modelIndex);

   732     fixCurrentVisibility = true;

   733     if (oldCurrentItem && (!currentItem || oldCurrentItem->item != currentItem->item))

   734         oldCurrentItem->attached->setIsCurrentItem(false);

   735     if (currentItem) {

   736         currentItem->setPosition(colPosAt(modelIndex), rowPosAt(modelIndex));

   737         currentItem->item->setFocus(true);

   738         currentItem->attached->setIsCurrentItem(true);

   739     }

   740     updateHighlight();

   741     emit q->currentIndexChanged();

   742     releaseItem(oldCurrentItem);

   743 }

   744 

   745 void QDeclarativeGridViewPrivate::fixupPosition()

   746 {

   747     moveReason = Other;

   748     if (flow == QDeclarativeGridView::LeftToRight)

   749         fixupY();

   750     else

   751         fixupX();

   752 }

   753 

   754 void QDeclarativeGridViewPrivate::fixup(AxisData &data, qreal minExtent, qreal maxExtent)

   755 {

   756     Q_Q(QDeclarativeGridView);

   757     if ((flow == QDeclarativeGridView::TopToBottom && &data == &vData)

   758         || (flow == QDeclarativeGridView::LeftToRight && &data == &hData))

   759         return;

   760 

   761     int oldDuration = fixupDuration;

   762     fixupDuration = moveReason == Mouse ? fixupDuration : 0;

   763 

   764     if (haveHighlightRange && highlightRange == QDeclarativeGridView::StrictlyEnforceRange) {

   765         if (currentItem) {

   766             updateHighlight();

   767             qreal pos = currentItem->rowPos();

   768             qreal viewPos = position();

   769             if (viewPos < pos + rowSize() - highlightRangeEnd)

   770                 viewPos = pos + rowSize() - highlightRangeEnd;

   771             if (viewPos > pos - highlightRangeStart)

   772                 viewPos = pos - highlightRangeStart;

   773 

   774             timeline.reset(data.move);

   775             if (viewPos != position()) {

   776                 if (fixupDuration) {

   777                     timeline.move(data.move, -viewPos, QEasingCurve(QEasingCurve::InOutQuad), fixupDuration/2);

   778                 } else {

   779                     data.move.setValue(-viewPos);

   780                     q->viewportMoved();

   781                 }

   782             }

   783             vTime = timeline.time();

   784         }

   785     } else if (snapMode != QDeclarativeGridView::NoSnap) {

   786         qreal pos = -snapPosAt(-(data.move.value() - highlightRangeStart)) + highlightRangeStart;

   787         pos = qMin(qMax(pos, maxExtent), minExtent);

   788         qreal dist = qAbs(data.move.value() - pos);

   789         if (dist > 0) {

   790             timeline.reset(data.move);

   791             if (fixupDuration) {

   792                 timeline.move(data.move, pos, QEasingCurve(QEasingCurve::InOutQuad), fixupDuration/2);

   793             } else {

   794                 data.move.setValue(pos);

   795                 q->viewportMoved();

   796             }

   797             vTime = timeline.time();

   798         }

   799     } else {

   800         QDeclarativeFlickablePrivate::fixup(data, minExtent, maxExtent);

   801     }

   802     fixupDuration = oldDuration;

   803 }

   804 

   805 void QDeclarativeGridViewPrivate::flick(AxisData &data, qreal minExtent, qreal maxExtent, qreal vSize,

   806                                         QDeclarativeTimeLineCallback::Callback fixupCallback, qreal velocity)

   807 {

   808     Q_Q(QDeclarativeGridView);

   809 

   810     moveReason = Mouse;

   811     if ((!haveHighlightRange || highlightRange != QDeclarativeGridView::StrictlyEnforceRange)

   812         && snapMode == QDeclarativeGridView::NoSnap) {

   813         QDeclarativeFlickablePrivate::flick(data, minExtent, maxExtent, vSize, fixupCallback, velocity);

   814         return;

   815     }

   816     qreal maxDistance = 0;

   817     // -ve velocity means list is moving up

   818     if (velocity > 0) {

   819         if (data.move.value() < minExtent) {

   820             if (snapMode == QDeclarativeGridView::SnapOneRow) {

   821                 if (FxGridItem *item = firstVisibleItem())

   822                     maxDistance = qAbs(item->rowPos() + data.move.value());

   823             } else {

   824                 maxDistance = qAbs(minExtent - data.move.value());

   825             }

   826         }

   827         if (snapMode == QDeclarativeGridView::NoSnap && highlightRange != QDeclarativeGridView::StrictlyEnforceRange)

   828             data.flickTarget = minExtent;

   829     } else {

   830         if (data.move.value() > maxExtent) {

   831             if (snapMode == QDeclarativeGridView::SnapOneRow) {

   832                 qreal pos = snapPosAt(-data.move.value()) + rowSize();

   833                 maxDistance = qAbs(pos + data.move.value());

   834             } else {

   835                 maxDistance = qAbs(maxExtent - data.move.value());

   836             }

   837         }

   838         if (snapMode == QDeclarativeGridView::NoSnap && highlightRange != QDeclarativeGridView::StrictlyEnforceRange)

   839             data.flickTarget = maxExtent;

   840     }

   841     bool overShoot = boundsBehavior == QDeclarativeFlickable::DragAndOvershootBounds;

   842     if (maxDistance > 0 || overShoot) {

   843         // This mode requires the grid to stop exactly on a row boundary.

   844         qreal v = velocity;

   845         if (maxVelocity != -1 && maxVelocity < qAbs(v)) {

   846             if (v < 0)

   847                 v = -maxVelocity;

   848             else

   849                 v = maxVelocity;

   850         }

   851         qreal accel = deceleration;

   852         qreal v2 = v * v;

   853         qreal overshootDist = 0.0;

   854         if (maxDistance > 0.0 && v2 / (2.0f * maxDistance) < accel) {

   855             // + rowSize()/4 to encourage moving at least one item in the flick direction

   856             qreal dist = v2 / (accel * 2.0) + rowSize()/4;

   857             if (v > 0)

   858                 dist = -dist;

   859             data.flickTarget = -snapPosAt(-(data.move.value() - highlightRangeStart) + dist) + highlightRangeStart;

   860             qreal adjDist = -data.flickTarget + data.move.value();

   861             if (qAbs(adjDist) > qAbs(dist)) {

   862                 // Prevent painfully slow flicking - adjust velocity to suit flickDeceleration

   863                 qreal adjv2 = accel * 2.0f * qAbs(adjDist);

   864                 if (adjv2 > v2) {

   865                     v2 = adjv2;

   866                     v = qSqrt(v2);

   867                     if (dist > 0)

   868                         v = -v;

   869                 }

   870             }

   871             dist = adjDist;

   872             accel = v2 / (2.0f * qAbs(dist));

   873         } else {

   874             data.flickTarget = velocity > 0 ? minExtent : maxExtent;

   875             overshootDist = overShoot ? overShootDistance(v, vSize) : 0;

   876         }

   877         timeline.reset(data.move);

   878         timeline.accel(data.move, v, accel, maxDistance + overshootDist);

   879         timeline.callback(QDeclarativeTimeLineCallback(&data.move, fixupCallback, this));

   880         if (!flickingHorizontally && q->xflick()) {

   881             flickingHorizontally = true;

   882             emit q->flickingChanged();

   883             emit q->flickingHorizontallyChanged();

   884             emit q->flickStarted();

   885         }

   886         if (!flickingVertically && q->yflick()) {

   887             flickingVertically = true;

   888             emit q->flickingChanged();

   889             emit q->flickingVerticallyChanged();

   890             emit q->flickStarted();

   891         }

   892     } else {

   893         timeline.reset(data.move);

   894         fixup(data, minExtent, maxExtent);

   895     }

   896 }

   897 

   898 

   899 //----------------------------------------------------------------------------

   900 

   901 /*!

   902     \qmlclass GridView QDeclarativeGridView

   903     \since 4.7

   904     \inherits Flickable

   905     \brief The GridView item provides a grid view of items provided by a model.

   906 

   907     The model is typically provided by a QAbstractListModel "C++ model object",

   908     but can also be created directly in QML.

   909 

   910     The items are laid out top to bottom (vertically) or left to right (horizontally)

   911     and may be flicked to scroll.

   912 

   913     The below example creates a very simple grid, using a QML model.

   914 

   915     \image gridview.png

   916 

   917     \snippet doc/src/snippets/declarative/gridview/gridview.qml 3

   918 

   919     The model is defined as a ListModel using QML:

   920     \quotefile doc/src/snippets/declarative/gridview/dummydata/ContactModel.qml

   921 

   922     In this case ListModel is a handy way for us to test our UI.  In practice

   923     the model would be implemented in C++, or perhaps via a SQL data source.

   924 

   925     Delegates are instantiated as needed and may be destroyed at any time.

   926     State should \e never be stored in a delegate.

   927 

   928     \bold Note that views do not enable \e clip automatically.  If the view

   929     is not clipped by another item or the screen, it will be necessary

   930     to set \e {clip: true} in order to have the out of view items clipped

   931     nicely.

   932 */

   933 QDeclarativeGridView::QDeclarativeGridView(QDeclarativeItem *parent)

   934     : QDeclarativeFlickable(*(new QDeclarativeGridViewPrivate), parent)

   935 {

   936     Q_D(QDeclarativeGridView);

   937     d->init();

   938 }

   939 

   940 QDeclarativeGridView::~QDeclarativeGridView()

   941 {

   942     Q_D(QDeclarativeGridView);

   943     d->clear();

   944     if (d->ownModel)

   945         delete d->model;

   946 }

   947 

   948 /*!

   949     \qmlattachedproperty bool GridView::isCurrentItem

   950     This attched property is true if this delegate is the current item; otherwise false.

   951 

   952     It is attached to each instance of the delegate.

   953 */

   954 

   955 /*!

   956     \qmlattachedproperty GridView GridView::view

   957     This attached property holds the view that manages this delegate instance.

   958 

   959     It is attached to each instance of the delegate.

   960 */

   961 

   962 /*!

   963     \qmlattachedproperty bool GridView::delayRemove

   964     This attached property holds whether the delegate may be destroyed.

   965 

   966     It is attached to each instance of the delegate.

   967 

   968     It is sometimes necessary to delay the destruction of an item

   969     until an animation completes.

   970 

   971     The example below ensures that the animation completes before

   972     the item is removed from the grid.

   973 

   974     \code

   975     Component {

   976         id: myDelegate

   977         Item {

   978             id: wrapper

   979             GridView.onRemove: SequentialAnimation {

   980                 PropertyAction { target: wrapper; property: "GridView.delayRemove"; value: true }

   981                 NumberAnimation { target: wrapper; property: "scale"; to: 0; duration: 250; easing.type: Easing.InOutQuad }

   982                 PropertyAction { target: wrapper; property: "GridView.delayRemove"; value: false }

   983             }

   984         }

   985     }

   986     \endcode

   987 */

   988 

   989 /*!

   990     \qmlattachedsignal GridView::onAdd()

   991     This attached handler is called immediately after an item is added to the view.

   992 */

   993 

   994 /*!

   995     \qmlattachedsignal GridView::onRemove()

   996     This attached handler is called immediately before an item is removed from the view.

   997 */

   998 

   999 

  1000 /*!

  1001   \qmlproperty model GridView::model

  1002   This property holds the model providing data for the grid.

  1003 

  1004   The model provides a set of data that is used to create the items

  1005   for the view.  For large or dynamic datasets the model is usually

  1006   provided by a C++ model object.  The C++ model object must be a \l

  1007   {QAbstractItemModel} subclass, a VisualModel, or a simple list.

  1008 

  1009   \sa {qmlmodels}{Data Models}

  1010 */

  1011 QVariant QDeclarativeGridView::model() const

  1012 {

  1013     Q_D(const QDeclarativeGridView);

  1014     return d->modelVariant;

  1015 }

  1016 

  1017 void QDeclarativeGridView::setModel(const QVariant &model)

  1018 {

  1019     Q_D(QDeclarativeGridView);

  1020     if (d->modelVariant == model)

  1021         return;

  1022     if (d->model) {

  1023         disconnect(d->model, SIGNAL(itemsInserted(int,int)), this, SLOT(itemsInserted(int,int)));

  1024         disconnect(d->model, SIGNAL(itemsRemoved(int,int)), this, SLOT(itemsRemoved(int,int)));

  1025         disconnect(d->model, SIGNAL(itemsMoved(int,int,int)), this, SLOT(itemsMoved(int,int,int)));

  1026         disconnect(d->model, SIGNAL(modelReset()), this, SLOT(modelReset()));

  1027         disconnect(d->model, SIGNAL(createdItem(int, QDeclarativeItem*)), this, SLOT(createdItem(int,QDeclarativeItem*)));

  1028         disconnect(d->model, SIGNAL(destroyingItem(QDeclarativeItem*)), this, SLOT(destroyingItem(QDeclarativeItem*)));

  1029     }

  1030     d->clear();

  1031     d->modelVariant = model;

  1032     QObject *object = qvariant_cast<QObject*>(model);

  1033     QDeclarativeVisualModel *vim = 0;

  1034     if (object && (vim = qobject_cast<QDeclarativeVisualModel *>(object))) {

  1035         if (d->ownModel) {

  1036             delete d->model;

  1037             d->ownModel = false;

  1038         }

  1039         d->model = vim;

  1040     } else {

  1041         if (!d->ownModel) {

  1042             d->model = new QDeclarativeVisualDataModel(qmlContext(this), this);

  1043             d->ownModel = true;

  1044         }

  1045         if (QDeclarativeVisualDataModel *dataModel = qobject_cast<QDeclarativeVisualDataModel*>(d->model))

  1046             dataModel->setModel(model);

  1047     }

  1048     if (d->model) {

  1049         d->bufferMode = QDeclarativeGridViewPrivate::BufferBefore | QDeclarativeGridViewPrivate::BufferAfter;

  1050         if (isComponentComplete()) {

  1051             refill();

  1052             if (d->currentIndex >= d->model->count() || d->currentIndex < 0) {

  1053                 setCurrentIndex(0);

  1054             } else {

  1055                 d->moveReason = QDeclarativeGridViewPrivate::SetIndex;

  1056                 d->updateCurrent(d->currentIndex);

  1057             }

  1058         }

  1059         connect(d->model, SIGNAL(itemsInserted(int,int)), this, SLOT(itemsInserted(int,int)));

  1060         connect(d->model, SIGNAL(itemsRemoved(int,int)), this, SLOT(itemsRemoved(int,int)));

  1061         connect(d->model, SIGNAL(itemsMoved(int,int,int)), this, SLOT(itemsMoved(int,int,int)));

  1062         connect(d->model, SIGNAL(modelReset()), this, SLOT(modelReset()));

  1063         connect(d->model, SIGNAL(createdItem(int, QDeclarativeItem*)), this, SLOT(createdItem(int,QDeclarativeItem*)));

  1064         connect(d->model, SIGNAL(destroyingItem(QDeclarativeItem*)), this, SLOT(destroyingItem(QDeclarativeItem*)));

  1065         emit countChanged();

  1066     }

  1067     emit modelChanged();

  1068 }

  1069 

  1070 /*!

  1071     \qmlproperty Component GridView::delegate

  1072 

  1073     The delegate provides a template defining each item instantiated by the view.

  1074     The index is exposed as an accessible \c index property.  Properties of the

  1075     model are also available depending upon the type of \l {qmlmodels}{Data Model}.

  1076 

  1077     The number of elements in the delegate has a direct effect on the

  1078     flicking performance of the view.  If at all possible, place functionality

  1079     that is not needed for the normal display of the delegate in a \l Loader which

  1080     can load additional elements when needed.

  1081 

  1082     Note that the GridView will layout the items based on the size of the root item

  1083     in the delegate.

  1084 

  1085     Here is an example delegate:

  1086     \snippet doc/src/snippets/declarative/gridview/gridview.qml 0

  1087 */

  1088 QDeclarativeComponent *QDeclarativeGridView::delegate() const

  1089 {

  1090     Q_D(const QDeclarativeGridView);

  1091     if (d->model) {

  1092         if (QDeclarativeVisualDataModel *dataModel = qobject_cast<QDeclarativeVisualDataModel*>(d->model))

  1093             return dataModel->delegate();

  1094     }

  1095 

  1096     return 0;

  1097 }

  1098 

  1099 void QDeclarativeGridView::setDelegate(QDeclarativeComponent *delegate)

  1100 {

  1101     Q_D(QDeclarativeGridView);

  1102     if (delegate == this->delegate())

  1103         return;

  1104 

  1105     if (!d->ownModel) {

  1106         d->model = new QDeclarativeVisualDataModel(qmlContext(this));

  1107         d->ownModel = true;

  1108     }

  1109     if (QDeclarativeVisualDataModel *dataModel = qobject_cast<QDeclarativeVisualDataModel*>(d->model)) {

  1110         dataModel->setDelegate(delegate);

  1111         if (isComponentComplete()) {

  1112             refill();

  1113             d->moveReason = QDeclarativeGridViewPrivate::SetIndex;

  1114             d->updateCurrent(d->currentIndex);

  1115         }

  1116         emit delegateChanged();

  1117     }

  1118 }

  1119 

  1120 /*!

  1121   \qmlproperty int GridView::currentIndex

  1122   \qmlproperty Item GridView::currentItem

  1123 

  1124   \c currentIndex holds the index of the current item.

  1125   \c currentItem is the current item.  Note that the position of the current item

  1126   may only be approximate until it becomes visible in the view.

  1127 */

  1128 int QDeclarativeGridView::currentIndex() const

  1129 {

  1130     Q_D(const QDeclarativeGridView);

  1131     return d->currentIndex;

  1132 }

  1133 

  1134 void QDeclarativeGridView::setCurrentIndex(int index)