FCL/sf/mw/qt: comparison src/declarative/graphicsitems/qdeclarativelistview.cpp

equal deleted inserted replaced

-:5dc02b23752f
+:3e2da88830cd
 if (section)
 return (view->orientation() == QDeclarativeListView::Vertical ? section->y() : section->x());
 else
 return (view->orientation() == QDeclarativeListView::Vertical ? item->y() : item->x());
 }
-int size() const {
+qreal size() const {
 if (section)
 return (view->orientation() == QDeclarativeListView::Vertical ? item->height()+section->height() : item->width()+section->height());
 else
 return (view->orientation() == QDeclarativeListView::Vertical ? item->height() : item->width());
 }
 return orient == QDeclarativeListView::Vertical ? q->contentY() : q->contentX();
 }
 void setPosition(qreal pos) {
 Q_Q(QDeclarativeListView);
 if (orient == QDeclarativeListView::Vertical)
-q->setContentY(pos);
+q->QDeclarativeFlickable::setContentY(pos);
 else
-q->setContentX(pos);
+q->QDeclarativeFlickable::setContentX(pos);
 }
 qreal size() const {
 Q_Q(const QDeclarativeListView);
 return orient == QDeclarativeListView::Vertical ? q->height() : q->width();
 }
 }
 void itemGeometryChanged(QDeclarativeItem *item, const QRectF &newGeometry, const QRectF &oldGeometry) {
 Q_Q(QDeclarativeListView);
 QDeclarativeFlickablePrivate::itemGeometryChanged(item, newGeometry, oldGeometry);
-if (item != viewport && (!highlight || item != highlight->item)) {
+if (item != contentItem && (!highlight || item != highlight->item)) {
 if ((orient == QDeclarativeListView::Vertical && newGeometry.height() != oldGeometry.height())
 || (orient == QDeclarativeListView::Horizontal && newGeometry.width() != oldGeometry.width())) {
 scheduleLayout();
 }
 }
+if ((header && header->item == item) || (footer && footer->item == item)) {
+updateHeader();
+updateFooter();
+}
+if (currentItem && currentItem->item == item)
+updateHighlight();
 if (trackedItem && trackedItem->item == item)
 q->trackedPositionChanged();
 }
 // for debugging only
 QVariant modelVariant;
 QList<FxListItem*> visibleItems;
 QHash<QDeclarativeItem*,int> unrequestedItems;
 FxListItem *currentItem;
 QDeclarativeListView::Orientation orient;
-int visiblePos;
+qreal visiblePos;
 int visibleIndex;
 qreal averageSize;
 int currentIndex;
 int requestedIndex;
 int itemCount;
 int buffer;
 QSmoothedAnimation *highlightPosAnimator;
 QSmoothedAnimation *highlightSizeAnimator;
 QDeclarativeViewSection *sectionCriteria;
 QString currentSection;
-static const int sectionCacheSize = 3;
+static const int sectionCacheSize = 4;
 QDeclarativeItem *sectionCache[sectionCacheSize];
 qreal spacing;
 qreal highlightMoveSpeed;
 int highlightMoveDuration;
 qreal highlightResizeSpeed;
 if (modelIndex > 0) {
 if (FxListItem *item = visibleItem(modelIndex-1))
 listItem->attached->m_prevSection = item->attached->section();
 else
 listItem->attached->m_prevSection = sectionAt(modelIndex-1);
+if (FxListItem *item = visibleItem(modelIndex+1))
+listItem->attached->m_nextSection = item->attached->section();
+else if (modelIndex < model->count()-1)
+listItem->attached->m_nextSection = sectionAt(modelIndex+1);
 }
 }
 if (model->completePending()) {
 // complete
 listItem->item->setZValue(1);
-listItem->item->setParentItem(q->viewport());
+listItem->item->setParentItem(q->contentItem());
 model->completeItem();
 } else {
-listItem->item->setParentItem(q->viewport());
+listItem->item->setParentItem(q->contentItem());
 }
 QDeclarativeItemPrivate *itemPrivate = static_cast<QDeclarativeItemPrivate*>(QGraphicsItemPrivate::get(item));
 itemPrivate->addItemChangeListener(this, QDeclarativeItemPrivate::Geometry);
 if (sectionCriteria && sectionCriteria->delegate()) {
 if (listItem->attached->m_prevSection != listItem->attached->m_section)
 modelIndex = visibleItems.at(i)->index + 1;
 }
 bool changed = false;
 FxListItem *item = 0;
-int pos = itemEnd + 1;
+qreal pos = itemEnd + 1;
 while (modelIndex < model->count() && pos <= fillTo) {
 //        qDebug() << "refill: append item" << modelIndex << "pos" << pos;
 if (!(item = createItem(modelIndex)))
 break;
 item->setPosition(pos);
 void QDeclarativeListViewPrivate::layout()
 {
 Q_Q(QDeclarativeListView);
 layoutScheduled = false;
-if (!isValid()) {
+if (!isValid() && !visibleItems.count()) {
 clear();
 setPosition(0);
 return;
 }
 updateSections();
 if (!visibleItems.isEmpty()) {
-int oldEnd = visibleItems.last()->endPosition();
+qreal oldEnd = visibleItems.last()->endPosition();
-int pos = visibleItems.first()->endPosition() + spacing + 1;
+qreal pos = visibleItems.first()->endPosition() + spacing + 1;
 for (int i=1; i < visibleItems.count(); ++i) {
 FxListItem *item = visibleItems.at(i);
 item->setPosition(pos);
 pos += item->size() + spacing;
 }
 }
 } else {
 item = new QDeclarativeItem;
 }
 if (item) {
-QDeclarative_setParent_noEvent(item, q->viewport());
+QDeclarative_setParent_noEvent(item, q->contentItem());
-item->setParentItem(q->viewport());
+item->setParentItem(q->contentItem());
 highlight = new FxListItem(item, q);
 if (currentItem && autoHighlight) {
 if (orient == QDeclarativeListView::Vertical) {
 highlight->item->setHeight(currentItem->item->height());
 } else {
 listItem->section = qobject_cast<QDeclarativeItem *>(nobj);
 if (!listItem->section) {
 delete nobj;
 } else {
 listItem->section->setZValue(1);
-QDeclarative_setParent_noEvent(listItem->section, q->viewport());
+QDeclarative_setParent_noEvent(listItem->section, q->contentItem());
-listItem->section->setParentItem(q->viewport());
+listItem->section->setParentItem(q->contentItem());
 }
 } else {
 delete context;
 }
 }
 {
 if (sectionCriteria) {
 QString prevSection;
 if (visibleIndex > 0)
 prevSection = sectionAt(visibleIndex-1);
+QDeclarativeListViewAttached *prevAtt = 0;
+int idx = -1;
 for (int i = 0; i < visibleItems.count(); ++i) {
 if (visibleItems.at(i)->index != -1) {
 QDeclarativeListViewAttached *attached = visibleItems.at(i)->attached;
 attached->setPrevSection(prevSection);
+if (prevAtt)
+prevAtt->setNextSection(attached->section());
 createSection(visibleItems.at(i));
 prevSection = attached->section();
-}
+prevAtt = attached;
+idx = visibleItems.at(i)->index;
+}
+}
+if (prevAtt) {
+if (idx > 0 && idx < model->count()-1)
+prevAtt->setNextSection(sectionAt(idx+1));
+else
+prevAtt->setNextSection(QString());
 }
 }
 }
 void QDeclarativeListViewPrivate::updateCurrentSection()
 // Its position will be corrected when it becomes visible.
 currentItem->setPosition(positionAt(modelIndex));
 }
 currentItem->item->setFocus(true);
 currentItem->attached->setIsCurrentItem(true);
+// Avoid showing section delegate twice.  We still need the section heading so that
+// currentItem positioning works correctly.
+// This is slightly sub-optimal, but section heading caching minimizes the impact.
+if (currentItem->section)
+currentItem->section->setVisible(false);
 }
 updateHighlight();
 emit q->currentIndexChanged();
 // Release the old current item
 releaseItem(oldCurrentItem);
 if (!visibleItems.count())
 return;
 qreal sum = 0.0;
 for (int i = 0; i < visibleItems.count(); ++i)
 sum += visibleItems.at(i)->size();
-averageSize = sum / visibleItems.count();
+averageSize = qRound(sum / visibleItems.count());
 }
 void QDeclarativeListViewPrivate::updateFooter()
 {
 Q_Q(QDeclarativeListView);
 delete nobj;
 } else {
 delete context;
 }
 if (item) {
-QDeclarative_setParent_noEvent(item, q->viewport());
+QDeclarative_setParent_noEvent(item, q->contentItem());
-item->setParentItem(q->viewport());
+item->setParentItem(q->contentItem());
 item->setZValue(1);
+QDeclarativeItemPrivate *itemPrivate = static_cast<QDeclarativeItemPrivate*>(QGraphicsItemPrivate::get(item));
+itemPrivate->addItemChangeListener(this, QDeclarativeItemPrivate::Geometry);
 footer = new FxListItem(item, q);
 }
 }
 if (footer) {
 if (visibleItems.count()) {
-qreal endPos = endPosition();
+qreal endPos = endPosition() + 1;
 if (lastVisibleIndex() == model->count()-1) {
 footer->setPosition(endPos);
 } else {
 qreal visiblePos = position() + q->height();
 if (endPos <= visiblePos || footer->position() < endPos)
 delete nobj;
 } else {
 delete context;
 }
 if (item) {
-QDeclarative_setParent_noEvent(item, q->viewport());
+QDeclarative_setParent_noEvent(item, q->contentItem());
-item->setParentItem(q->viewport());
+item->setParentItem(q->contentItem());
 item->setZValue(1);
+QDeclarativeItemPrivate *itemPrivate = static_cast<QDeclarativeItemPrivate*>(QGraphicsItemPrivate::get(item));
+itemPrivate->addItemChangeListener(this, QDeclarativeItemPrivate::Geometry);
 header = new FxListItem(item, q);
 if (visibleItems.isEmpty())
 visiblePos = header->size();
 }
 }
 }
 }
 void QDeclarativeListViewPrivate::fixupPosition()
 {
-moveReason = Other;
+if ((haveHighlightRange && highlightRange == QDeclarativeListView::StrictlyEnforceRange)
+|| snapMode != QDeclarativeListView::NoSnap)
+moveReason = Other;
 if (orient == QDeclarativeListView::Vertical)
 fixupY();
 else
 fixupX();
 }
 void QDeclarativeListViewPrivate::fixup(AxisData &data, qreal minExtent, qreal maxExtent)
 {
-Q_Q(QDeclarativeListView);
 if ((orient == QDeclarativeListView::Horizontal && &data == &vData)
 || (orient == QDeclarativeListView::Vertical && &data == &hData))
 return;
 int oldDuration = fixupDuration;
 fixupDuration = moveReason == Mouse ? fixupDuration : 0;
-if (haveHighlightRange && highlightRange == QDeclarativeListView::StrictlyEnforceRange) {
+if (snapMode != QDeclarativeListView::NoSnap) {
+FxListItem *topItem = snapItemAt(position()+highlightRangeStart);
+FxListItem *bottomItem = snapItemAt(position()+highlightRangeEnd);
+qreal pos;
+if (topItem && bottomItem && haveHighlightRange && highlightRange == QDeclarativeListView::StrictlyEnforceRange) {
+qreal topPos = qMin(topItem->position() - highlightRangeStart, -maxExtent);
+qreal bottomPos = qMax(bottomItem->position() - highlightRangeEnd, -minExtent);
+pos = qAbs(data.move + topPos) < qAbs(data.move + bottomPos) ? topPos : bottomPos;
+} else if (topItem) {
+pos = qMax(qMin(topItem->position() - highlightRangeStart, -maxExtent), -minExtent);
+} else if (bottomItem) {
+pos = qMax(qMin(bottomItem->position() - highlightRangeStart, -maxExtent), -minExtent);
+} else {
+fixupDuration = oldDuration;
+return;
+}
+if (currentItem && haveHighlightRange && highlightRange == QDeclarativeListView::StrictlyEnforceRange) {
+updateHighlight();
+qreal currPos = currentItem->position();
+if (pos < currPos + currentItem->size() - highlightRangeEnd)
+pos = currPos + currentItem->size() - highlightRangeEnd;
+if (pos > currPos - highlightRangeStart)
+pos = currPos - highlightRangeStart;
+}
+qreal dist = qAbs(data.move + pos);
+if (dist > 0) {
+timeline.reset(data.move);
+if (fixupDuration)
+timeline.move(data.move, -pos, QEasingCurve(QEasingCurve::InOutQuad), fixupDuration/2);
+else
+timeline.set(data.move, -pos);
+vTime = timeline.time();
+}
+} else if (haveHighlightRange && highlightRange == QDeclarativeListView::StrictlyEnforceRange) {
 if (currentItem) {
 updateHighlight();
 qreal pos = currentItem->position();
 qreal viewPos = position();
 if (viewPos < pos + currentItem->size() - highlightRangeEnd)
 if (viewPos > pos - highlightRangeStart)
 viewPos = pos - highlightRangeStart;
 timeline.reset(data.move);
 if (viewPos != position()) {
-if (fixupDuration) {
+if (fixupDuration)
 timeline.move(data.move, -viewPos, QEasingCurve(QEasingCurve::InOutQuad), fixupDuration/2);
-} else {
+else
-data.move.setValue(-viewPos);
+timeline.set(data.move, -viewPos);
-q->viewportMoved();
-}
 }
 vTime = timeline.time();
-}
-} else if (snapMode != QDeclarativeListView::NoSnap) {
-if (FxListItem *item = snapItemAt(position())) {
-qreal pos = qMin(item->position() - highlightRangeStart, -maxExtent);
-qreal dist = qAbs(data.move + pos);
-if (dist > 0) {
-timeline.reset(data.move);
-if (fixupDuration) {
-timeline.move(data.move, -pos, QEasingCurve(QEasingCurve::InOutQuad), fixupDuration/2);
-} else {
-data.move.setValue(-pos);
-q->viewportMoved();
-}
-vTime = timeline.time();
-}
 }
 } else {
 QDeclarativeFlickablePrivate::fixup(data, minExtent, maxExtent);
 }
 fixupDuration = oldDuration;
 \snippet doc/src/snippets/declarative/listview/ContactModel.qml 0
 Another component can display this model data in a ListView, like this:
-\table
+\snippet doc/src/snippets/declarative/listview/listview.qml import
-\row
-\o \snippet doc/src/snippets/declarative/listview/listview.qml import
 \codeline
 \snippet doc/src/snippets/declarative/listview/listview.qml classdocs simple
-\o \image listview-simple.png
-\endtable
+\image listview-simple.png
 Here, the ListView creates a \c ContactModel component for its model, and a \l Text element
 for its delegate. The view will create a new \l Text component for each item in the model. Notice
 the delegate is able to access the model's \c name and \c number data directly.
 An improved list view is shown below. The delegate is visually improved and is moved
 into a separate \c contactDelegate component. Also, the currently selected item is highlighted
 with a blue \l Rectangle using the \l highlight property, and \c focus is set to \c true
 to enable keyboard navigation for the list view.
-\table
+\snippet doc/src/snippets/declarative/listview/listview.qml classdocs advanced
-\row
+\image listview-highlight.png
-\o \snippet doc/src/snippets/declarative/listview/listview.qml classdocs advanced
-\o \image listview-highlight.png
+In a GridView, delegates are instantiated as needed and may be destroyed at any time.
-\endtable
-In a ListView, delegates are instantiated as needed and may be destroyed at any time.
 State should \e never be stored in a delegate.
 \note Views do not enable \e clip automatically.  If the view
 is not clipped by another item or the screen, it will be necessary
 to set \e {clip: true} in order to have the out of view items clipped
 nicely.
+\sa {Data Models}, GridView, {declarative/modelviews/listview}{ListView examples}
 */
 QDeclarativeListView::QDeclarativeListView(QDeclarativeItem *parent)
 : QDeclarativeFlickable(*(new QDeclarativeListViewPrivate), parent)
 {
 It is attached to each instance of the delegate.
 */
 /*!
-\qmlattachedproperty string ListView::prevSection
+\qmlattachedproperty string ListView::previousSection
 This attached property holds the section of the previous element.
+It is attached to each instance of the delegate.
+The section is evaluated using the \l {ListView::section.property}{section} properties.
+*/
+/*!
+\qmlattachedproperty string ListView::nextSection
+This attached property holds the section of the next element.
 It is attached to each instance of the delegate.
 The section is evaluated using the \l {ListView::section.property}{section} properties.
 */
 disconnect(d->model, SIGNAL(modelReset()), this, SLOT(modelReset()));
 disconnect(d->model, SIGNAL(createdItem(int, QDeclarativeItem*)), this, SLOT(createdItem(int,QDeclarativeItem*)));
 disconnect(d->model, SIGNAL(destroyingItem(QDeclarativeItem*)), this, SLOT(destroyingItem(QDeclarativeItem*)));
 }
 d->clear();
+QDeclarativeVisualModel *oldModel = d->model;
+d->model = 0;
 d->setPosition(0);
 d->modelVariant = model;
 QObject *object = qvariant_cast<QObject*>(model);
 QDeclarativeVisualModel *vim = 0;
 if (object && (vim = qobject_cast<QDeclarativeVisualModel *>(object))) {
 if (d->ownModel) {
-delete d->model;
+delete oldModel;
 d->ownModel = false;
 }
 d->model = vim;
 } else {
 if (!d->ownModel) {
 d->model = new QDeclarativeVisualDataModel(qmlContext(this), this);
 d->ownModel = true;
+} else {
+d->model = oldModel;
 }
 if (QDeclarativeVisualDataModel *dataModel = qobject_cast<QDeclarativeVisualDataModel*>(d->model))
 dataModel->setModel(model);
 }
 if (d->model) {
 if (d->currentIndex >= d->model->count() || d->currentIndex < 0) {
 setCurrentIndex(0);
 } else {
 d->moveReason = QDeclarativeListViewPrivate::SetIndex;
 d->updateCurrent(d->currentIndex);
+if (d->highlight && d->currentItem) {
+d->highlight->setPosition(d->currentItem->position());
+d->updateTrackedItem();
+}
 }
 }
 connect(d->model, SIGNAL(itemsInserted(int,int)), this, SLOT(itemsInserted(int,int)));
 connect(d->model, SIGNAL(itemsRemoved(int,int)), this, SLOT(itemsRemoved(int,int)));
 connect(d->model, SIGNAL(itemsMoved(int,int,int)), this, SLOT(itemsMoved(int,int,int)));
 The number of elements in the delegate has a direct effect on the
 flicking performance of the view.  If at all possible, place functionality
 that is not needed for the normal display of the delegate in a \l Loader which
 can load additional elements when needed.
-Tthe ListView will lay out the items based on the size of the root item
+The ListView will lay out the items based on the size of the root item
 in the delegate.
+It is recommended that the delagate's size be a whole number to avoid sub-pixel
+alignment of items.
 \note Delegates are instantiated as needed and may be destroyed at any time.
 State should \e never be stored in a delegate.
 */
 QDeclarativeComponent *QDeclarativeListView::delegate() const
 d->releaseItem(d->visibleItems.at(i));
 d->visibleItems.clear();
 refill();
 d->moveReason = QDeclarativeListViewPrivate::SetIndex;
 d->updateCurrent(d->currentIndex);
+if (d->highlight && d->currentItem) {
+d->highlight->setPosition(d->currentItem->position());
+d->updateTrackedItem();
+}
 }
 }
 emit delegateChanged();
 }
 /*!
 \qmlproperty int ListView::currentIndex
 \qmlproperty Item ListView::currentItem
-\c currentIndex holds the index of the current item.
+The \c currentIndex property holds the index of the current item, and
-\c currentItem is the current item.  Note that the position of the current item
+\c currentItem holds the current item.
+If highlightFollowsCurrentItem is \c true, setting either of these
+properties will smoothly scroll the ListView so that the current
+item becomes visible.
+Note that the position of the current item
 may only be approximate until it becomes visible in the view.
 */
 int QDeclarativeListView::currentIndex() const
 {
 Q_D(const QDeclarativeListView);
 Q_D(QDeclarativeListView);
 if (d->requestedIndex >= 0)  // currently creating item
 return;
 if (isComponentComplete() && d->isValid() && index != d->currentIndex && index < d->model->count() && index >= 0) {
 d->moveReason = QDeclarativeListViewPrivate::SetIndex;
-cancelFlick();
 d->updateCurrent(index);
 } else if (index != d->currentIndex) {
 d->currentIndex = index;
 emit currentIndexChanged();
 }
 /*!
 \qmlproperty Component ListView::highlight
 This property holds the component to use as the highlight.
 An instance of the highlight component is created for each list.
-The geometry of the resultant component instance is managed by the list
+The geometry of the resulting component instance is managed by the list
 so as to stay with the current item, unless the highlightFollowsCurrentItem
 property is false.
-\sa highlightItem, highlightFollowsCurrentItem
+\sa highlightItem, highlightFollowsCurrentItem, {declarative/modelviews/listview}{ListView examples}
 */
 QDeclarativeComponent *QDeclarativeListView::highlight() const
 {
 Q_D(const QDeclarativeListView);
 return d->highlightComponent;
 /*!
 \qmlproperty bool ListView::highlightFollowsCurrentItem
 This property holds whether the highlight is managed by the view.
-If this property is true, the highlight is moved smoothly
+If this property is true (the default value), the highlight is moved smoothly
 to follow the current item.  Otherwise, the
 highlight is not moved by the view, and any movement must be implemented
 by the highlight.
-Here is a highlight with its motion defined by the a \l {SpringFollow} item:
+Here is a highlight with its motion defined by a \l {SpringAnimation} item:
 \snippet doc/src/snippets/declarative/listview/listview.qml highlightFollowsCurrentItem
 Note that the highlight animation also affects the way that the view
 is scrolled.  This is because the view moves to maintain the
 /*!
 \qmlproperty real ListView::spacing
 This property holds the spacing between items.
+The default value is 0.
 */
 qreal QDeclarativeListView::spacing() const
 {
 Q_D(const QDeclarativeListView);
 return d->spacing;
 }
 }
 /*!
 \qmlproperty bool ListView::keyNavigationWraps
 This property holds whether the list wraps key navigation.
 If this is true, key navigation that would move the current item selection
 past the end of the list instead wraps around and moves the selection to
 the start of the list, and vice-versa.
+By default, key navigation is not wrapped.
 */
 bool QDeclarativeListView::isWrapEnabled() const
 {
 Q_D(const QDeclarativeListView);
 return d->wrap;
 }
 /*!
 \qmlproperty string ListView::section.property
 \qmlproperty enumeration ListView::section.criteria
+\qmlproperty Component ListView::section.delegate
 These properties hold the expression to be evaluated for the \l section attached property.
-\c section.property hold the name of the property to use to determine
+The \l section attached property enables a ListView to be visually
-the section that holds the item.
+separated into different parts. These properties determine how sections
+are created.
-\c section.criteria holds the criteria to use to access the section. It
-can be either:
+\c section.property holds the name of the property that is the basis
+of each section.
+\c section.criteria holds the criteria for forming each section based on
+\c section.property. This value can be one of:
 \list
-\o ViewSection.FullString (default) - section is the value of the property.
+\o ViewSection.FullString (default) - sections are created based on the
-\o ViewSection.FirstCharacter - section is the first character of the property value.
+\c section.property value.
+\o ViewSection.FirstCharacter - sections are created based on the first
+character of the \c section.property value (for example, 'A', 'B', 'C'
+sections, etc. for an address book)
 \endlist
-Each item in the list has attached properties named \c ListView.section and
+\c section.delegate holds the delegate component for each section.
-\c ListView.prevSection.  These may be used to place a section header for
-related items.  The example below assumes that the model is sorted by size of
+Each item in the list has attached properties named \c ListView.section,
-pet.  The section expression is the size property.  If \c ListView.section and
+\c ListView.previousSection and \c ListView.nextSection.  These may be
-\c ListView.prevSection differ, the item will display a section header.
+used to place a section header for related items.
+For example, here is a ListView that displays a list of animals, separated
+into sections. Each item in the ListView is placed in a different section
+depending on the "size" property of the model item. The \c sectionHeading
+delegate component provides the light blue bar that marks the beginning of
+each section.
 \snippet examples/declarative/modelviews/listview/sections.qml 0
-\image ListViewSections.png
+\image qml-listview-sections-example.png
+\sa {declarative/modelviews/listview}{ListView examples}
 */
 QDeclarativeViewSection *QDeclarativeListView::sectionCriteria()
 {
 Q_D(QDeclarativeListView);
 if (!d->sectionCriteria)
 \qmlproperty real ListView::highlightResizeSpeed
 \qmlproperty int ListView::highlightResizeDuration
 These properties hold the move and resize animation speed of the highlight delegate.
-\c highlightFollowsCurrentItem must be true for these properties
+\l highlightFollowsCurrentItem must be true for these properties
 to have effect.
 The default value for the speed properties is 400 pixels/second.
 The default value for the duration properties is -1, i.e. the
 highlight will take as much time as necessary to move at the set speed.
 }
 /*!
 \qmlproperty enumeration ListView::snapMode
-This property determines where the view's scrolling behavior stops following a drag or flick.
+This property determines how the view scrolling will settle following a drag or flick.
-The allowed values are:
+The possible values are:
 \list
 \o ListView.NoSnap (default) - the view stops anywhere within the visible area.
 \o ListView.SnapToItem - the view settles with an item aligned with the start of
 the view.
 d->snapMode = mode;
 emit snapModeChanged();
 }
 }
+/*!
+\qmlproperty Component ListView::footer
+This property holds the component to use as the footer.
+An instance of the footer component is created for each view.  The
+footer is positioned at the end of the view, after any items.
+\sa header
+*/
 QDeclarativeComponent *QDeclarativeListView::footer() const
 {
 Q_D(const QDeclarativeListView);
 return d->footerComponent;
 }
 d->updateViewport();
 emit footerChanged();
 }
 }
+/*!
+\qmlproperty Component ListView::header
+This property holds the component to use as the header.
+An instance of the header component is created for each view.  The
+header is positioned at the beginning of the view, before any items.
+\sa footer
+*/
 QDeclarativeComponent *QDeclarativeListView::header() const
 {
 Q_D(const QDeclarativeListView);
 return d->headerComponent;
 }
 d->updateHeader();
 d->updateFooter();
 d->updateViewport();
 emit headerChanged();
 }
+}
+void QDeclarativeListView::setContentX(qreal pos)
+{
+Q_D(QDeclarativeListView);
+// Positioning the view manually should override any current movement state
+d->moveReason = QDeclarativeListViewPrivate::Other;
+QDeclarativeFlickable::setContentX(pos);
+}
+void QDeclarativeListView::setContentY(qreal pos)
+{
+Q_D(QDeclarativeListView);
+// Positioning the view manually should override any current movement state
+d->moveReason = QDeclarativeListViewPrivate::Other;
+QDeclarativeFlickable::setContentY(pos);
 }
 bool QDeclarativeListView::event(QEvent *event)
 {
 Q_D(QDeclarativeListView);
 {
 Q_D(const QDeclarativeListView);
 if (d->orient == QDeclarativeListView::Horizontal)
 return height();
 if (d->maxExtentDirty) {
-if (d->haveHighlightRange && d->highlightRange == StrictlyEnforceRange) {
+if (!d->model || !d->model->count()) {
+d->maxExtent = 0;
+} else if (d->haveHighlightRange && d->highlightRange == StrictlyEnforceRange) {
 d->maxExtent = -(d->positionAt(d->model->count()-1) - d->highlightRangeStart);
 if (d->highlightRangeEnd != d->highlightRangeStart)
 d->maxExtent = qMin(d->maxExtent, -(d->endPosition() - d->highlightRangeEnd + 1));
 } else {
 d->maxExtent = -(d->endPosition() - height() + 1);
 {
 Q_D(const QDeclarativeListView);
 if (d->orient == QDeclarativeListView::Vertical)
 return width();
 if (d->maxExtentDirty) {
-if (d->haveHighlightRange && d->highlightRange == StrictlyEnforceRange) {
+if (!d->model || !d->model->count()) {
+d->maxExtent = 0;
+} else if (d->haveHighlightRange && d->highlightRange == StrictlyEnforceRange) {
 d->maxExtent = -(d->positionAt(d->model->count()-1) - d->highlightRangeStart);
 if (d->highlightRangeEnd != d->highlightRangeStart)
 d->maxExtent = qMin(d->maxExtent, -(d->endPosition() - d->highlightRangeEnd + 1));
 } else {
 d->maxExtent = -(d->endPosition() - width() + 1);
 /*!
 \qmlmethod ListView::incrementCurrentIndex()
 Increments the current index.  The current index will wrap
 if keyNavigationWraps is true and it is currently at the end.
+\bold Note: methods should only be called after the Component has completed.
 */
 void QDeclarativeListView::incrementCurrentIndex()
 {
 Q_D(QDeclarativeListView);
 if (currentIndex() < d->model->count() - 1 || d->wrap) {
 d->moveReason = QDeclarativeListViewPrivate::SetIndex;
 int index = currentIndex()+1;
-cancelFlick();
 d->updateCurrent(index < d->model->count() ? index : 0);
 }
 }
 /*!
 \qmlmethod ListView::decrementCurrentIndex()
 Decrements the current index.  The current index will wrap
 if keyNavigationWraps is true and it is currently at the beginning.
+\bold Note: methods should only be called after the Component has completed.
 */
 void QDeclarativeListView::decrementCurrentIndex()
 {
 Q_D(QDeclarativeListView);
 if (currentIndex() > 0 || d->wrap) {
 d->moveReason = QDeclarativeListViewPrivate::SetIndex;
 int index = currentIndex()-1;
-cancelFlick();
 d->updateCurrent(index >= 0 ? index : d->model->count()-1);
 }
 }
 /*!
 It is not recommended to use \l {Flickable::}{contentX} or \l {Flickable::}{contentY} to position the view
 at a particular index.  This is unreliable since removing items from the start
 of the list does not cause all other items to be repositioned, and because
 the actual start of the view can vary based on the size of the delegates.
 The correct way to bring an item into view is with \c positionViewAtIndex.
+\bold Note: methods should only be called after the Component has completed.  To position
+the view at startup, this method should be called by Component.onCompleted.  For
+example, to position the view at the end:
+\code
+Component.onCompleted: positionViewAtIndex(count - 1, ListView.Beginning)
+\endcode
 */
 void QDeclarativeListView::positionViewAtIndex(int index, int mode)
 {
 Q_D(QDeclarativeListView);
 if (!d->isValid() || index < 0 || index >= d->model->count())
 return;
 if (mode < Beginning || mode > Contain)
 return;
+if (d->layoutScheduled)
+d->layout();
 qreal pos = d->position();
 FxListItem *item = d->visibleItem(index);
 if (!item) {
 int itemPos = d->positionAt(index);
 // save the currently visible items in case any of them end up visible again
 }
 qreal maxExtent = d->orient == QDeclarativeListView::Vertical ? -maxYExtent() : -maxXExtent();
 pos = qMin(pos, maxExtent);
 qreal minExtent = d->orient == QDeclarativeListView::Vertical ? -minYExtent() : -minXExtent();
 pos = qMax(pos, minExtent);
+d->moveReason = QDeclarativeListViewPrivate::Other;
+cancelFlick();
 d->setPosition(pos);
 }
 d->fixupPosition();
 }
 coordinates.  If there is no item at the point specified, or the item is
 not visible -1 is returned.
 If the item is outside the visible area, -1 is returned, regardless of
 whether an item will exist at that point when scrolled into view.
+\bold Note: methods should only be called after the Component has completed.
 */
 int QDeclarativeListView::indexAt(int x, int y) const
 {
 Q_D(const QDeclarativeListView);
 for (int i = 0; i < d->visibleItems.count(); ++i) {
 d->moveReason = QDeclarativeListViewPrivate::SetIndex;
 if (d->currentIndex < 0)
 d->updateCurrent(0);
 else
 d->updateCurrent(d->currentIndex);
+if (d->highlight && d->currentItem) {
+d->highlight->setPosition(d->currentItem->position());
+d->updateTrackedItem();
+}
+d->moveReason = QDeclarativeListViewPrivate::Other;
 d->fixupPosition();
 }
 }
 void QDeclarativeListView::refill()
 void QDeclarativeListView::trackedPositionChanged()
 {
 Q_D(QDeclarativeListView);
 if (!d->trackedItem || !d->currentItem)
 return;
-if (!d->flickingHorizontally && !d->flickingVertically && !d->movingHorizontally && !d->movingVertically
+if (d->moveReason == QDeclarativeListViewPrivate::SetIndex) {
-&& d->moveReason == QDeclarativeListViewPrivate::SetIndex) {
 const qreal trackedPos = qCeil(d->trackedItem->position());
 const qreal viewPos = d->position();
+qreal pos = viewPos;
 if (d->haveHighlightRange) {
 if (d->highlightRange == StrictlyEnforceRange) {
-qreal pos = viewPos;
 if (trackedPos > pos + d->highlightRangeEnd - d->trackedItem->size())
 pos = trackedPos - d->highlightRangeEnd + d->trackedItem->size();
 if (trackedPos < pos + d->highlightRangeStart)
 pos = trackedPos - d->highlightRangeStart;
-d->setPosition(pos);
 } else {
-qreal pos = viewPos;
 if (trackedPos < d->startPosition() + d->highlightRangeStart) {
 pos = d->startPosition();
 } else if (d->trackedItem->endPosition() > d->endPosition() - d->size() + d->highlightRangeEnd) {
 pos = d->endPosition() - d->size();
 if (pos < d->startPosition())
 pos = trackedPos - d->highlightRangeStart;
 } else if (trackedPos > viewPos + d->highlightRangeEnd - d->trackedItem->size()) {
 pos = trackedPos - d->highlightRangeEnd + d->trackedItem->size();
 }
 }
-d->setPosition(pos);
 }
 } else {
 if (trackedPos < viewPos && d->currentItem->position() < viewPos) {
-d->setPosition(d->currentItem->position() < trackedPos ? trackedPos : d->currentItem->position());
+pos = d->currentItem->position() < trackedPos ? trackedPos : d->currentItem->position();
 } else if (d->trackedItem->endPosition() > viewPos + d->size()
 && d->currentItem->endPosition() > viewPos + d->size()) {
-qreal pos;
 if (d->trackedItem->endPosition() < d->currentItem->endPosition()) {
 pos = d->trackedItem->endPosition() - d->size();
 if (d->trackedItem->size() > d->size())
 pos = trackedPos;
 } else {
 pos = d->currentItem->endPosition() - d->size();
 if (d->currentItem->size() > d->size())
 pos = d->currentItem->position();
 }
-d->setPosition(pos);
+}
 }
+if (viewPos != pos) {
+cancelFlick();
+d->setPosition(pos);
 }
 }
 }
 void QDeclarativeListView::itemsInserted(int modelIndex, int count)
 if (removedVisible && d->visibleItems.isEmpty()) {
 d->visibleIndex = 0;
 d->visiblePos = d->header ? d->header->size() : 0;
 d->timeline.clear();
 d->setPosition(0);
-if (d->itemCount == 0)
+if (d->itemCount == 0) {
+d->updateHeader();
+d->updateFooter();
 update();
+}
 }
 emit countChanged();
 }
 d->clear();
 d->setPosition(0);
 refill();
 d->moveReason = QDeclarativeListViewPrivate::SetIndex;
 d->updateCurrent(d->currentIndex);
+if (d->highlight && d->currentItem) {
+d->highlight->setPosition(d->currentItem->position());
+d->updateTrackedItem();
+}
+d->moveReason = QDeclarativeListViewPrivate::Other;
 emit countChanged();
 }
 void QDeclarativeListView::createdItem(int index, QDeclarativeItem *item)
 {
 Q_D(QDeclarativeListView);
 if (d->requestedIndex != index) {
-item->setParentItem(viewport());
+item->setParentItem(contentItem());
 d->unrequestedItems.insert(item, index);
 if (d->orient == QDeclarativeListView::Vertical)
 item->setY(d->positionAt(index));
 else
 item->setX(d->positionAt(index));

changeset 33	3e2da88830cd
parent 30	5dc02b23752f
child 37	758a864f9613