Inheritance diagram for QDeclarativeListViewPrivate:

Public Types
enum	BufferMode { NoBuffer = 0x00, BufferBefore = 0x01, BufferAfter = 0x02 }

enum	MovementReason { Other, SetIndex, Mouse }

Public Types inherited from QDeclarativeFlickablePrivate
enum	FixupMode { Normal, Immediate, ExtentChanged }

Public Types inherited from QDeclarativeItemPrivate
enum	ChangeType { Geometry = 0x01, SiblingOrder = 0x02, Visibility = 0x04, Opacity = 0x08, Destroyed = 0x10 }

Public Types inherited from QGraphicsItemPrivate
enum	AncestorFlag { NoFlag = 0, AncestorHandlesChildEvents = 0x1, AncestorClipsChildren = 0x2, AncestorIgnoresTransformations = 0x4, AncestorFiltersChildEvents = 0x8 }

enum	Extra { ExtraToolTip, ExtraCursor, ExtraCacheData, ExtraMaxDeviceCoordCacheSize, ExtraBoundingRegionGranularity }

enum	InvalidateReason { OpacityChanged }

Public Functions
void	checkVisible () const

void	clear ()

QDeclarativeItem *	createComponentItem (QDeclarativeComponent *component)

void	createHighlight ()

FxListItem *	createItem (int modelIndex)

void	createSection (FxListItem *)

qreal	endPosition () const

qreal	endPositionAt (int modelIndex) const

FxListItem *	firstVisibleItem () const

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

void	fixupPosition ()

virtual void	flick (QDeclarativeFlickablePrivate::AxisData &data, qreal minExtent, qreal maxExtent, qreal vSize, QDeclarativeTimeLineCallback::Callback fixupCallback, qreal velocity)

void	init ()

bool	isRightToLeft () const

bool	isValid () const

FxListItem *	itemBefore (int modelIndex) const

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

qreal	lastPosition () const

int	lastVisibleIndex () const

void	layout ()

int	mapFromModel (int modelIndex) const

void	mirrorChange ()

qreal	originPosition () const

qreal	position () const

qreal	positionAt (int modelIndex) const

void	positionViewAtIndex (int index, int mode)

	QDeclarativeListViewPrivate ()

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

void	regenerate ()

void	releaseItem (FxListItem *item)

void	scheduleLayout ()

QString	sectionAt (int modelIndex)

void	setPosition (qreal pos)

qreal	size () const

FxListItem *	snapItemAt (qreal pos)

qreal	snapPosAt (qreal pos)

qreal	startPosition () const

void	updateAverage ()

void	updateCurrent (int)

void	updateCurrentSection ()

void	updateFooter ()

void	updateHeader ()

void	updateHighlight ()

void	updateSections ()

void	updateTrackedItem ()

void	updateUnrequestedIndexes ()

void	updateUnrequestedPositions ()

void	updateViewport ()

FxListItem *	visibleItem (int modelIndex) const

Public Functions inherited from QDeclarativeFlickablePrivate
void	captureDelayedPress (QGraphicsSceneMouseEvent *event)

void	clearDelayedPress ()

void	fixupX ()

void	fixupY ()

void	flickX (qreal velocity)

void	flickY (qreal velocity)

void	handleMouseMoveEvent (QGraphicsSceneMouseEvent *)

void	handleMousePressEvent (QGraphicsSceneMouseEvent *)

void	handleMouseReleaseEvent (QGraphicsSceneMouseEvent *)

void	init ()

bool	isOutermostPressDelay () const

qreal	overShootDistance (qreal size)

	QDeclarativeFlickablePrivate ()

void	setRoundedViewportX (qreal x)

void	setRoundedViewportY (qreal y)

void	updateBeginningEnd ()

void	updateVelocity ()

Public Functions inherited from QDeclarativeItemPrivate
QDeclarativeStateGroup *	_states ()

void	addItemChangeListener (QDeclarativeItemChangeListener *listener, ChangeTypes types)

AnchorLines *	anchorLines () const

QDeclarativeAnchors *	anchors ()

QDeclarativeAnchorLine	baseline () const

QDeclarativeAnchorLine	bottom () const

QPointF	computeTransformOrigin () const

QDeclarativeListProperty< QObject >	data ()

virtual void	focusChanged (bool)

virtual void	focusScopeItemChange (bool isSubFocusItem)
	Subclasses can reimplement this function to be notified when an item becomes a focusScopeItem (or is no longer a focusScopeItem). More...

qreal	height () const

QDeclarativeAnchorLine	horizontalCenter () const

virtual qreal	implicitHeight () const

virtual void	implicitHeightChanged ()

virtual qreal	implicitWidth () const

virtual void	implicitWidthChanged ()

void	init (QDeclarativeItem *parent)

bool	isMirrored () const

QDeclarativeAnchorLine	left () const

	QDeclarativeItemPrivate ()

void	removeItemChangeListener (QDeclarativeItemChangeListener *, ChangeTypes types)

void	resetHeight ()

void	resetWidth ()

void	resolveLayoutMirror ()

QDeclarativeListProperty< QObject >	resources ()

QDeclarativeAnchorLine	right () const

void	setHeight (qreal)

void	setImplicitLayoutMirror (bool mirror, bool inherit)

void	setLayoutMirror (bool mirror)

virtual void	setPosHelper (const QPointF &pos)
	Sets the position pos. More...

void	setState (const QString &)

void	setWidth (qreal)

virtual void	siblingOrderChange ()
	Subclasses can reimplement this function to be notified when its siblingIndex order is changed. More...

QString	state () const

QDeclarativeListProperty< QDeclarativeState >	states ()

QDeclarativeAnchorLine	top () const

virtual void	transformChanged ()

QDeclarativeListProperty< QDeclarativeTransition >	transitions ()

QDeclarativeAnchorLine	verticalCenter () const

qreal	width () const

Public Functions inherited from QGraphicsItemPrivate
void	addChild (QGraphicsItem *child)
	QGraphicsScenePrivate::registerTopLevelItem(). More...

void	appendGraphicsTransform (QGraphicsTransform *t)

qreal	calcEffectiveOpacity () const

void	childrenBoundingRectHelper (QTransform x, QRectF rect, QGraphicsItem *topMostEffectItem)
	Returns the bounding rect of this item's children (excluding itself). More...

bool	childrenClippedToShape () const

bool	childrenCombineOpacity () const

QDeclarativeListProperty< QGraphicsObject >	childrenList ()
	Returns a list of this item's children. More...

void	clearFocusHelper (bool giveFocusToParent)

void	clearSubFocus (QGraphicsItem rootItem=0, QGraphicsItem stopItem=0)

qreal	combineOpacityFromParent (qreal parentOpacity) const

void	combineTransformFromParent (QTransform x, const QTransform viewTransform=0) const
	Combines this item's position and transform onto transform. More...

void	combineTransformToParent (QTransform x, const QTransform viewTransform=0) const
	Combines this item's position and transform onto transform. More...

int	depth () const

bool	discardUpdateRequest (bool ignoreVisibleBit=false, bool ignoreDirtyBit=false, bool ignoreOpacity=false) const
	Returns true if we can discard an update request; otherwise false. More...

QRectF	effectiveBoundingRect (QGraphicsItem *topMostEffectItem=0) const
	Returns the effective bounding rect of the item. More...

QRectF	effectiveBoundingRect (const QRectF &rect) const
	Returns the effective bounding rect of the given item space rect. More...

qreal	effectiveOpacity () const

void	ensureSceneTransform ()

void	ensureSceneTransformRecursive (QGraphicsItem **topMostDirtyItem)

void	ensureSequentialSiblingIndex ()
	Ensures that the list of children is sorted by insertion order, and that the siblingIndexes are packed (no gaps), and start at 0. More...

void	ensureSortedChildren ()

QVariant	extra (Extra type) const

QGraphicsItemCache *	extraItemCache () const

QPointF	genericMapFromScene (const QPointF &pos, const QWidget *viewport) const
	Maps the point pos from scene to item coordinates. More...

bool	hasTranslateOnlySceneTransform ()

void	initStyleOption (QStyleOptionGraphicsItem *option, const QTransform &worldTransform, const QRegion &exposedRegion, bool allItems=false) const

virtual QVariant	inputMethodQueryHelper (Qt::InputMethodQuery query) const
	This helper function helped us add input method query support in Qt 4. More...

void	invalidateChildGraphicsEffectsRecursively (InvalidateReason reason)

void	invalidateChildrenSceneTransform ()

void	invalidateDepthRecursively ()

void	invalidateParentGraphicsEffectsRecursively ()

bool	isFullyTransparent () const

bool	isInvisible () const

bool	isOpacityNull () const

virtual bool	isProxyWidget () const

bool	itemIsUntransformable () const

void	markParentDirty (bool updateBoundingRect=false)

QGraphicsItemCache *	maybeExtraItemCache () const

void	prependGraphicsTransform (QGraphicsTransform *t)

	QGraphicsItemPrivate ()

void	remapItemPos (QEvent event, QGraphicsItem item)
	Maps any item pos properties of event to item's coordinate system. More...

void	removeChild (QGraphicsItem *child)
	QGraphicsScenePrivate::unregisterTopLevelItem(). More...

void	removeExtraItemCache ()

void	resetFocusProxy ()
	Sets the focusProxy pointer to 0 for all items that have this item as their focusProxy. More...

void	resolveDepth ()
	Resolves the stacking depth of this object and all its ancestors. More...

virtual void	resolveFont (uint inheritedMask)

virtual void	resolvePalette (uint inheritedMask)

QRectF	sceneEffectiveBoundingRect () const
	Returns the effective bounding rect of this item in scene coordinates, by combining sceneTransform() with boundingRect(), taking into account the effect that the item might have. More...

void	sendScenePosChange ()

void	setEnabledHelper (bool newEnabled, bool explicitly, bool update=true)
	Sets this item's visibility to newEnabled. More...

void	setExtra (Extra type, const QVariant &value)

void	setFocusHelper (Qt::FocusReason focusReason, bool climb, bool focusFromHide)

void	setIsMemberOfGroup (bool enabled)
	Propagates item group membership. More...

void	setParentItemHelper (QGraphicsItem parent, const QVariant newParentVariant, const QVariant *thisPointerVariant)
	Make sure not to trigger any pure virtual function calls (e. More...

void	setSubFocus (QGraphicsItem rootItem=0, QGraphicsItem stopItem=0)

void	setTransformHelper (const QTransform &transform)
	Sets the transform transform. More...

void	setVisibleHelper (bool newVisible, bool explicitly, bool update=true)
	Sets this item's visibility to newVisible. More...

virtual void	subFocusItemChange ()
	Subclasses can reimplement this function to be notified when subFocusItem changes. More...

QTransform	transformToParent () const

void	unsetExtra (Extra type)

void	updateAncestorFlag (QGraphicsItem::GraphicsItemFlag childFlag, AncestorFlag flag=NoFlag, bool enabled=false, bool root=true)
	Propagates the ancestor flag flag with value enabled to all this item's children. More...

void	updateAncestorFlags ()

void	updateChildWithGraphicsEffectFlagRecursively ()

void	updatePaintedViewBoundingRects (bool updateChildren)

virtual void	updateSceneTransformFromParent ()

virtual	~QGraphicsItemPrivate ()

Public Functions inherited from QDeclarativeItemChangeListener
virtual QDeclarativeAnchorsPrivate *	anchorPrivate ()

virtual void	itemDestroyed (QDeclarativeItem *)

virtual void	itemOpacityChanged (QDeclarativeItem *)

virtual void	itemSiblingOrderChanged (QDeclarativeItem *)

virtual void	itemVisibilityChanged (QDeclarativeItem *)

Public Variables
bool	autoHighlight: 1

qreal	averageSize

int	buffer

int	bufferMode

bool	correctFlick: 1

int	currentIndex

bool	currentIndexCleared: 1

FxListItem *	currentItem

QString	currentSection

bool	deferredRelease: 1

FxListItem *	footer

QDeclarativeComponent *	footerComponent

bool	haveHighlightRange: 1

FxListItem *	header

QDeclarativeComponent *	headerComponent

FxListItem *	highlight

QDeclarativeComponent *	highlightComponent

int	highlightMoveDuration

qreal	highlightMoveSpeed

QSmoothedAnimation *	highlightPosAnimator

QDeclarativeListView::HighlightRangeMode	highlightRange

qreal	highlightRangeEnd

bool	highlightRangeEndValid

qreal	highlightRangeStart

bool	highlightRangeStartValid

int	highlightResizeDuration

qreal	highlightResizeSpeed

QSmoothedAnimation *	highlightSizeAnimator

bool	inFlickCorrection: 1

bool	inViewportMoved: 1

int	itemCount

Qt::LayoutDirection	layoutDirection

bool	layoutScheduled: 1

bool	lazyRelease: 1

qreal	maxExtent

bool	maxExtentDirty: 1

qreal	minExtent

bool	minExtentDirty: 1

QDeclarativeGuard< QDeclarativeVisualModel >	model

QVariant	modelVariant

MovementReason	moveReason

QDeclarativeListView::Orientation	orient

qreal	overshootDist

bool	ownModel: 1

int	requestedIndex

QDeclarativeItem *	sectionCache [sectionCacheSize]

QDeclarativeViewSection *	sectionCriteria

QDeclarativeListView::SnapMode	snapMode

qreal	spacing

FxListItem *	trackedItem

QHash< QDeclarativeItem *, int >	unrequestedItems

int	visibleIndex

QList< FxListItem * >	visibleItems

qreal	visiblePos

bool	wrap: 1

Public Variables inherited from QDeclarativeFlickablePrivate
QDeclarativeFlickable::BoundsBehavior	boundsBehavior

bool	calcVelocity: 1

QDeclarativeItem *	contentItem

qreal	deceleration

QGraphicsSceneMouseEvent *	delayedPressEvent

QGraphicsItem *	delayedPressTarget

QBasicTimer	delayedPressTimer

int	fixupDuration

FixupMode	fixupMode

QDeclarativeFlickable::FlickableDirection	flickableDirection

AxisData	hData

bool	hMoved: 1

bool	interactive: 1

QPointF	lastFlickablePosition

QPointF	lastPos

QElapsedTimer	lastPosTime

qreal	maxVelocity

int	pressDelay

bool	pressed: 1

QPointF	pressPos

QElapsedTimer	pressTime

qreal	reportedVelocitySmoothing

bool	stealMouse: 1

QDeclarativeTimeLine	timeline

AxisData	vData

QElapsedTimer	velocityTime

QDeclarativeTimeLine	velocityTimeline

QDeclarativeFlickableVisibleArea *	visibleArea

bool	vMoved: 1

int	vTime

Public Variables inherited from QDeclarativeItemPrivate
AnchorLines *	_anchorLines

QDeclarativeAnchors *	_anchors

QDeclarativeContents *	_contents

QDeclarativeStateGroup *	_stateGroup

QDeclarativeLayoutMirroringAttached *	attachedLayoutDirection

QDeclarativeNullableValue< qreal >	baselineOffset

QPODVector< ChangeListener, 4 >	changeListeners

bool	componentComplete:1

bool	doneEventPreHandler: 1

bool	effectiveLayoutMirror:1

bool	hadActiveFocus:1

bool	hadFocus:1

bool	heightValid:1

bool	inheritedLayoutMirror:1

bool	inheritMirrorFromItem:1

bool	inheritMirrorFromParent:1

bool	isMirrorImplicit:1

bool	keepMouse:1

QDeclarativeItemKeyFilter *	keyHandler

qreal	mHeight

qreal	mImplicitHeight

qreal	mImplicitWidth

qreal	mWidth

QDeclarativeItem::TransformOrigin	origin:5

QDeclarativeNotifier	parentNotifier

bool	smooth:1

bool	transformOriginDirty: 1

bool	widthValid:1

Public Variables inherited from QGraphicsItemPrivate
quint32	acceptDrops: 1

quint32	acceptedMouseButtons: 5

quint32	acceptedTouchBeginEvent: 1

quint32	acceptsHover: 1

quint32	acceptTouchEvents: 1

quint32	allChildrenDirty: 1

quint32	ancestorFlags: 4

quint32	cacheMode: 2

QList< QGraphicsItem * >	children

QRectF	childrenBoundingRect

quint32	dirty: 1

quint32	dirtyChildren: 1

quint32	dirtyChildrenBoundingRect: 1

quint32	dirtySceneTransform: 1

quint32	enabled: 1

quint32	explicitActivate: 1

quint32	explicitlyDisabled: 1

quint32	explicitlyHidden: 1

QList< ExtraStruct >	extras

quint32	filtersDescendantEvents: 1

quint32	flags: 19

QGraphicsItem *	focusProxy

QList< QGraphicsItem ** >	focusProxyRefs

QGraphicsItem *	focusScopeItem

quint32	fullUpdatePending: 1

quint32	geometryChanged: 1

QMap< Qt::GestureType, Qt::GestureFlags >	gestureContext

int	globalStackingOrder

QGraphicsEffect *	graphicsEffect

quint32	handlesChildEvents: 1

quint32	hasBoundingRegionGranularity: 1

quint32	hasCursor: 1

quint32	holesInSiblingIndex: 1

quint32	ignoreOpacity: 1

quint32	ignoreVisible: 1

Qt::InputMethodHints	imHints

quint32	inDestructor: 1

int	index

quint32	inSetPosHelper: 1

quint32	isDeclarativeItem: 1

quint32	isMemberOfGroup: 1

quint32	isObject: 1

quint32	isWidget: 1

int	itemDepth

quint32	itemDiscovered: 1

quint32	localCollisionHack: 1

quint32	mayHaveChildWithGraphicsEffect: 1

quint32	mouseSetsFocus: 1

quint32	needSortChildren: 1

QRectF	needsRepaint

quint32	notifyBoundingRectChanged: 1

quint32	notifyInvalidated: 1

qreal	opacity

quint32	padding: 21

QMap< QWidget *, QRect >	paintedViewBoundingRects

quint32	paintedViewBoundingRectsNeedRepaint: 1

QGraphicsItem::PanelModality	panelModality

QGraphicsItem *	parent

quint32	pendingPolish: 1

QPointF	pos

QGraphicsItem *	q_ptr

QGraphicsScene *	scene

quint32	scenePosDescendants: 1

QTransform	sceneTransform

quint32	sceneTransformTranslateOnly: 1

quint32	selected: 1

quint32	sendParentChangeNotification: 1

quint32	sequentialOrdering: 1

int	siblingIndex

QGraphicsItem *	subFocusItem

TransformData *	transformData

quint32	updateDueToGraphicsEffect: 1

quint32	visible: 1

quint32	wantsActive: 1

qreal	z

Static Public Variables
static const int	sectionCacheSize = 4

Static Public Variables inherited from QDeclarativeItemPrivate
static qint64	consistentTime = -1

Additional Inherited Members
Static Public Functions inherited from QDeclarativeFlickablePrivate
static void	data_append (QDeclarativeListProperty< QObject > , QObject )

static QObject *	data_at (QDeclarativeListProperty< QObject > *, int)

static void	data_clear (QDeclarativeListProperty< QObject > *)

static int	data_count (QDeclarativeListProperty< QObject > *)

static void	fixupX_callback (void *)

static void	fixupY_callback (void *)

Static Public Functions inherited from QDeclarativeItemPrivate
static void	data_append (QDeclarativeListProperty< QObject > , QObject )

static QObject *	data_at (QDeclarativeListProperty< QObject > *, int)

static void	data_clear (QDeclarativeListProperty< QObject > *)

static int	data_count (QDeclarativeListProperty< QObject > *)

static qint64	elapsed (QElapsedTimer &)

static QDeclarativeItemPrivate *	get (QDeclarativeItem *item)

static void	parentProperty (QObject o, void rv, QDeclarativeNotifierEndpoint *e)

static void	resources_append (QDeclarativeListProperty< QObject > , QObject )

static QObject *	resources_at (QDeclarativeListProperty< QObject > *, int)

static void	resources_clear (QDeclarativeListProperty< QObject > *)

static int	resources_count (QDeclarativeListProperty< QObject > *)

static qint64	restart (QElapsedTimer &)

static void	setConsistentTime (qint64 t)

static void	start (QElapsedTimer &)

static void	transform_append (QDeclarativeListProperty< QGraphicsTransform > list, QGraphicsTransform )

static QGraphicsTransform *	transform_at (QDeclarativeListProperty< QGraphicsTransform > *list, int)

static void	transform_clear (QDeclarativeListProperty< QGraphicsTransform > *list)

static int	transform_count (QDeclarativeListProperty< QGraphicsTransform > *list)

Static Public Functions inherited from QGraphicsItemPrivate
static void	children_append (QDeclarativeListProperty< QGraphicsObject > list, QGraphicsObject item)

static QGraphicsObject *	children_at (QDeclarativeListProperty< QGraphicsObject > *list, int)

static void	children_clear (QDeclarativeListProperty< QGraphicsObject > *list)

static int	children_count (QDeclarativeListProperty< QGraphicsObject > *list)

static const QGraphicsItemPrivate *	get (const QGraphicsItem *item)

static QGraphicsItemPrivate *	get (QGraphicsItem *item)

static bool	insertionOrder (QGraphicsItem a, QGraphicsItem b)

static bool	isOpacityNull (qreal opacity)

static bool	movableAncestorIsSelected (const QGraphicsItem *item)

Detailed Description

Definition at line 190 of file qdeclarativelistview.cpp.

Enumerations

◆ BufferMode

enum QDeclarativeListViewPrivate::BufferMode

Enumerator
NoBuffer
BufferBefore
BufferAfter

Definition at line 583 of file qdeclarativelistview.cpp.

583 { NoBuffer = 0x00, BufferBefore = 0x01, BufferAfter = 0x02 };

QDeclarativeListViewPrivate::BufferAfter

Definition: qdeclarativelistview.cpp:583

QDeclarativeListViewPrivate::BufferBefore

Definition: qdeclarativelistview.cpp:583

QDeclarativeListViewPrivate::NoBuffer

Definition: qdeclarativelistview.cpp:583

◆ MovementReason

enum QDeclarativeListViewPrivate::MovementReason

Enumerator
Other
SetIndex
Mouse

Definition at line 562 of file qdeclarativelistview.cpp.

562 { Other, SetIndex, Mouse };

QDeclarativeListViewPrivate::SetIndex

Definition: qdeclarativelistview.cpp:562

QDeclarativeListViewPrivate::Mouse

Definition: qdeclarativelistview.cpp:562

QDeclarativeListViewPrivate::Other

Definition: qdeclarativelistview.cpp:562

Constructors and Destructors

◆ QDeclarativeListViewPrivate()

QDeclarativeListViewPrivate::QDeclarativeListViewPrivate ( )

inline

Definition at line 195 of file qdeclarativelistview.cpp.

         : currentItem(0), orient(QDeclarativeListView::Vertical), layoutDirection(Qt::LeftToRight)
         , visiblePos(0), visibleIndex(0)
         , averageSize(100.0), currentIndex(-1), requestedIndex(-1)
         , itemCount(0), highlightRangeStart(0), highlightRangeEnd(0)
         , highlightRangeStartValid(false), highlightRangeEndValid(false)
         , highlightComponent(0), highlight(0), trackedItem(0)
         , moveReason(Other), buffer(0), highlightPosAnimator(0), highlightSizeAnimator(0)
         , sectionCriteria(0), spacing(0.0)
         , highlightMoveSpeed(400), highlightMoveDuration(-1)
         , highlightResizeSpeed(400), highlightResizeDuration(-1), highlightRange(QDeclarativeListView::NoHighlightRange)
         , snapMode(QDeclarativeListView::NoSnap), overshootDist(0.0)
         , footerComponent(0), footer(0), headerComponent(0), header(0)
         , bufferMode(BufferBefore | BufferAfter)
         , ownModel(false), wrap(false), autoHighlight(true), haveHighlightRange(false)
         , correctFlick(false), inFlickCorrection(false), lazyRelease(false)
         , deferredRelease(false), layoutScheduled(false), currentIndexCleared(false)
         , inViewportMoved(false)
         , minExtentDirty(true), maxExtentDirty(true)
     {}

Functions

◆ checkVisible()

void QDeclarativeListViewPrivate::checkVisible ( ) const

inline

Definition at line 509 of file qdeclarativelistview.cpp.

                               {
         int skip = 0;
         for (int i = 0; i < visibleItems.count(); ++i) {
             FxListItem *listItem = visibleItems.at(i);
             if (listItem->index == -1) {
                 ++skip;
             } else if (listItem->index != visibleIndex + i - skip) {
                 qFatal("index %d %d %d", visibleIndex, i, listItem->index);
             }
         }
     }

◆ clear()

void QDeclarativeListViewPrivate::clear ( )

Definition at line 613 of file qdeclarativelistview.cpp.

 {
     timeline.clear();
     for (int i = 0; i < visibleItems.count(); ++i)
         releaseItem(visibleItems.at(i));
     visibleItems.clear();
     for (int i = 0; i < sectionCacheSize; ++i) {
         delete sectionCache[i];
         sectionCache[i] = 0;
     }
     visiblePos = header ? header->size() : 0;
     visibleIndex = 0;
     releaseItem(currentItem);
     currentItem = 0;
     createHighlight();
     trackedItem = 0;
     minExtentDirty = true;
     maxExtentDirty = true;
     itemCount = 0;
 }

◆ createComponentItem()

QDeclarativeItem * QDeclarativeListViewPrivate::createComponentItem ( QDeclarativeComponent * component )

Definition at line 681 of file qdeclarativelistview.cpp.

 {
     Q_Q(QDeclarativeListView);
     QDeclarativeItem *item = 0;
     QDeclarativeContext *creationContext = component->creationContext();
     QDeclarativeContext *context = new QDeclarativeContext(
                 creationContext ? creationContext : qmlContext(q));
     QObject *nobj = component->create(context);
     if (nobj) {
         QDeclarative_setParent_noEvent(context, nobj);
         item = qobject_cast<QDeclarativeItem *>(nobj);
         if (!item)
             delete nobj;
     } else {
         delete context;
     }
 
     return item;
 }

◆ createHighlight()

void QDeclarativeListViewPrivate::createHighlight ( )

Definition at line 950 of file qdeclarativelistview.cpp.

 {
     Q_Q(QDeclarativeListView);
     bool changed = false;
     if (highlight) {
         if (trackedItem == highlight)
             trackedItem = 0;
         if (highlight->item->scene())
             highlight->item->scene()->removeItem(highlight->item);
         highlight->item->deleteLater();
         delete highlight;
         highlight = 0;
         delete highlightPosAnimator;
         delete highlightSizeAnimator;
         highlightPosAnimator = 0;
         highlightSizeAnimator = 0;
         changed = true;
     }
 
     if (currentItem) {
         QDeclarativeItem *item = 0;
         if (highlightComponent) {
             item = createComponentItem(highlightComponent);
         } else {
             item = new QDeclarativeItem;
         }
         if (item) {
             QDeclarative_setParent_noEvent(item, q->contentItem());
             item->setParentItem(q->contentItem());
             highlight = new FxListItem(item, q);
             if (currentItem && autoHighlight) {
                 if (orient == QDeclarativeListView::Vertical) {
                     highlight->item->setHeight(currentItem->item->height());
                 } else {
                     highlight->item->setWidth(currentItem->item->width());
                 }
                 highlight->setPosition(currentItem->itemPosition());
             }
             QDeclarativeItemPrivate *itemPrivate = static_cast<QDeclarativeItemPrivate*>(QGraphicsItemPrivate::get(item));
             itemPrivate->addItemChangeListener(this, QDeclarativeItemPrivate::Geometry);
             const QLatin1String posProp(orient == QDeclarativeListView::Vertical ? "y" : "x");
             highlightPosAnimator = new QSmoothedAnimation(q);
             highlightPosAnimator->target = QDeclarativeProperty(highlight->item, posProp);
             highlightPosAnimator->velocity = highlightMoveSpeed;
             highlightPosAnimator->userDuration = highlightMoveDuration;
             const QLatin1String sizeProp(orient == QDeclarativeListView::Vertical ? "height" : "width");
             highlightSizeAnimator = new QSmoothedAnimation(q);
             highlightSizeAnimator->velocity = highlightResizeSpeed;
             highlightSizeAnimator->userDuration = highlightResizeDuration;
             highlightSizeAnimator->target = QDeclarativeProperty(highlight->item, sizeProp);
             if (autoHighlight) {
                 highlightPosAnimator->restart();
                 highlightSizeAnimator->restart();
             }
             changed = true;
         }
     }
     if (changed)
         emit q->highlightItemChanged();
 }

◆ createItem()

FxListItem * QDeclarativeListViewPrivate::createItem ( int modelIndex )

Definition at line 634 of file qdeclarativelistview.cpp.

 {
     Q_Q(QDeclarativeListView);
     // create object
     requestedIndex = modelIndex;
     FxListItem *listItem = 0;
     if (QDeclarativeItem *item = model->item(modelIndex, false)) {
         listItem = new FxListItem(item, q);
         listItem->index = modelIndex;
         // initialise attached properties
         if (sectionCriteria) {
             QString propValue = model->stringValue(modelIndex, sectionCriteria->property());
             listItem->attached->m_section = sectionCriteria->sectionString(propValue);
             if (modelIndex > 0) {
                 if (FxListItem *item = itemBefore(modelIndex))
                     listItem->attached->m_prevSection = item->attached->section();
                 else
                     listItem->attached->m_prevSection = sectionAt(modelIndex-1);
             }
             if (modelIndex < model->count()-1) {
                 if (FxListItem *item = visibleItem(modelIndex+1))
                     listItem->attached->m_nextSection = item->attached->section();
                 else
                     listItem->attached->m_nextSection = sectionAt(modelIndex+1);
             }
         }
         if (model->completePending()) {
             // complete
             listItem->item->setZValue(1);
             listItem->item->setParentItem(q->contentItem());
             model->completeItem();
         } else {
             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)
                 createSection(listItem);
         }
         unrequestedItems.remove(listItem->item);
     }
     requestedIndex = -1;
 
     return listItem;
 }

◆ createSection()

void QDeclarativeListViewPrivate::createSection ( FxListItem * listItem )

Definition at line 1034 of file qdeclarativelistview.cpp.

 {
     Q_Q(QDeclarativeListView);
     if (!sectionCriteria || !sectionCriteria->delegate())
         return;
     if (listItem->attached->m_prevSection != listItem->attached->m_section) {
         if (!listItem->section) {
             qreal pos = listItem->position();
             int i = sectionCacheSize-1;
             while (i >= 0 && !sectionCache[i])
                 --i;
             if (i >= 0) {
                 listItem->section = sectionCache[i];
                 sectionCache[i] = 0;
                 listItem->section->setVisible(true);
                 QDeclarativeContext *context = QDeclarativeEngine::contextForObject(listItem->section)->parentContext();
                 context->setContextProperty(QLatin1String("section"), listItem->attached->m_section);
             } else {
                 QDeclarativeContext *context = new QDeclarativeContext(qmlContext(q));
                 context->setContextProperty(QLatin1String("section"), listItem->attached->m_section);
                 QObject *nobj = sectionCriteria->delegate()->beginCreate(context);
                 if (nobj) {
                     QDeclarative_setParent_noEvent(context, nobj);
                     listItem->section = qobject_cast<QDeclarativeItem *>(nobj);
                     if (!listItem->section) {
                         delete nobj;
                     } else {
                         listItem->section->setZValue(1);
                         QDeclarative_setParent_noEvent(listItem->section, q->contentItem());
                         listItem->section->setParentItem(q->contentItem());
                     }
                 } else {
                     delete context;
                 }
                 sectionCriteria->delegate()->completeCreate();
             }
             listItem->setPosition(pos);
         } else {
             QDeclarativeContext *context = QDeclarativeEngine::contextForObject(listItem->section)->parentContext();
             context->setContextProperty(QLatin1String("section"), listItem->attached->m_section);
         }
     } else if (listItem->section) {
         qreal pos = listItem->position();
         int i = 0;
         do {
             if (!sectionCache[i]) {
                 sectionCache[i] = listItem->section;
                 sectionCache[i]->setVisible(false);
                 listItem->section = 0;
                 return;
             }
             ++i;
         } while (i < sectionCacheSize);
         delete listItem->section;
         listItem->section = 0;
         listItem->setPosition(pos);
     }
 }

◆ endPosition()

qreal QDeclarativeListViewPrivate::endPosition ( ) const

inline

Definition at line 350 of file qdeclarativelistview.cpp.

                               {
         return isRightToLeft() ? -originPosition()-1 : lastPosition();
     }

◆ endPositionAt()

qreal QDeclarativeListViewPrivate::endPositionAt ( int modelIndex ) const

inline

Definition at line 382 of file qdeclarativelistview.cpp.

                                               {
         if (FxListItem *item = visibleItem(modelIndex))
             return item->endPosition();
         if (!visibleItems.isEmpty()) {
             if (modelIndex < visibleIndex) {
                 int count = visibleIndex - modelIndex;
                 return (*visibleItems.constBegin())->position() - (count - 1) * (averageSize + spacing) - spacing - 1;
             } else {
                 int idx = visibleItems.count() - 1;
                 while (idx >= 0 && visibleItems.at(idx)->index == -1)
                     --idx;
                 if (idx < 0)
                     idx = visibleIndex;
                 else
                     idx = visibleItems.at(idx)->index;
                 int count = modelIndex - idx - 1;
                 return (*(--visibleItems.constEnd()))->endPosition() + count * (averageSize + spacing);
             }
         }
         return 0;
     }

◆ firstVisibleItem()

FxListItem* QDeclarativeListViewPrivate::firstVisibleItem ( ) const

inline

Definition at line 233 of file qdeclarativelistview.cpp.

                                          {
         const qreal pos = isRightToLeft() ? -position()-size() : position();
         for (int i = 0; i < visibleItems.count(); ++i) {
             FxListItem *item = visibleItems.at(i);
             if (item->index != -1 && item->endPosition() > pos)
                 return item;
         }
         return visibleItems.count() ? visibleItems.first() : 0;
     }

◆ fixup()

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

virtual

Reimplemented from QDeclarativeFlickablePrivate.

Definition at line 1283 of file qdeclarativelistview.cpp.

 {
     if ((orient == QDeclarativeListView::Horizontal && &data == &vData)
         || (orient == QDeclarativeListView::Vertical && &data == &hData))
         return;
 
     correctFlick = false;
     fixupMode = moveReason == Mouse ? fixupMode : Immediate;
     bool strictHighlightRange = haveHighlightRange && highlightRange == QDeclarativeListView::StrictlyEnforceRange;
 
     qreal highlightStart;
     qreal highlightEnd;
     qreal viewPos;
     if (isRightToLeft()) {
         // Handle Right-To-Left exceptions
         viewPos = -position()-size();
         highlightStart = highlightRangeStartValid ? size() - highlightRangeEnd : highlightRangeStart;
         highlightEnd = highlightRangeEndValid ? size() - highlightRangeStart : highlightRangeEnd;
     } else {
         viewPos = position();
         highlightStart = highlightRangeStart;
         highlightEnd = highlightRangeEnd;
     }
 
     if (snapMode != QDeclarativeListView::NoSnap && moveReason != QDeclarativeListViewPrivate::SetIndex) {
         qreal tempPosition = isRightToLeft() ? -position()-size() : position();
         if (snapMode == QDeclarativeListView::SnapOneItem && moveReason == Mouse) {
             // if we've been dragged < averageSize/2 then bias towards the next item
             qreal dist = data.move.value() - (data.pressPos - data.dragStartOffset);
             qreal bias = 0;
             if (data.velocity > 0 && dist > QML_FLICK_SNAPONETHRESHOLD && dist < averageSize/2)
                 bias = averageSize/2;
             else if (data.velocity < 0 && dist < -QML_FLICK_SNAPONETHRESHOLD && dist > -averageSize/2)
                 bias = -averageSize/2;
             if (isRightToLeft())
                 bias = -bias;
             tempPosition -= bias;
         }
         FxListItem *topItem = snapItemAt(tempPosition+highlightStart);
         if (!topItem && strictHighlightRange && currentItem) {
             // StrictlyEnforceRange always keeps an item in range
             updateHighlight();
             topItem = currentItem;
         }
         FxListItem *bottomItem = snapItemAt(tempPosition+highlightEnd);
         if (!bottomItem && strictHighlightRange && currentItem) {
             // StrictlyEnforceRange always keeps an item in range
             updateHighlight();
             bottomItem = currentItem;
         }
         qreal pos;
         bool isInBounds = -position() > maxExtent && -position() <= minExtent;
         if (topItem && (isInBounds || strictHighlightRange)) {
             if (topItem->index == 0 && header && tempPosition+highlightStart < header->position()+header->size()/2 && !strictHighlightRange) {
                 pos = isRightToLeft() ? - header->position() + highlightStart - size() : header->position() - highlightStart;
             } else {
                 if (isRightToLeft())
                     pos = qMax(qMin(-topItem->position() + highlightStart - size(), -maxExtent), -minExtent);
                 else
                     pos = qMax(qMin(topItem->position() - highlightStart, -maxExtent), -minExtent);
             }
         } else if (bottomItem && isInBounds) {
             if (isRightToLeft())
                 pos = qMax(qMin(-bottomItem->position() + highlightEnd - size(), -maxExtent), -minExtent);
             else
                 pos = qMax(qMin(bottomItem->position() - highlightEnd, -maxExtent), -minExtent);
         } else {
             QDeclarativeFlickablePrivate::fixup(data, minExtent, maxExtent);
             return;
         }
 
         qreal dist = qAbs(data.move + pos);
         if (dist > 0) {
             timeline.reset(data.move);
             if (fixupMode != Immediate) {
                 timeline.move(data.move, -pos, QEasingCurve(QEasingCurve::InOutQuad), fixupDuration/2);
                 data.fixingUp = true;
             } else {
                 timeline.set(data.move, -pos);
             }
             vTime = timeline.time();
         }
     } else if (currentItem && strictHighlightRange
                 && moveReason != QDeclarativeListViewPrivate::SetIndex) {
         updateHighlight();
         qreal pos = currentItem->itemPosition();
         if (viewPos < pos + currentItem->itemSize() - highlightEnd)
             viewPos = pos + currentItem->itemSize() - highlightEnd;
         if (viewPos > pos - highlightStart)
             viewPos = pos - highlightStart;
         if (isRightToLeft())
             viewPos = -viewPos-size();
 
         timeline.reset(data.move);
         if (viewPos != position()) {
             if (fixupMode != Immediate) {
                 timeline.move(data.move, -viewPos, QEasingCurve(QEasingCurve::InOutQuad), fixupDuration/2);
                 data.fixingUp = true;
             } else {
                 timeline.set(data.move, -viewPos);
             }
         }
         vTime = timeline.time();
     } else {
         QDeclarativeFlickablePrivate::fixup(data, minExtent, maxExtent);
     }
     data.inOvershoot = false;
     fixupMode = Normal;
 }

◆ fixupPosition()

void QDeclarativeListViewPrivate::fixupPosition ( )

Definition at line 1272 of file qdeclarativelistview.cpp.

 {
     if ((haveHighlightRange && highlightRange == QDeclarativeListView::StrictlyEnforceRange)
         || snapMode != QDeclarativeListView::NoSnap)
         moveReason = Other;
     if (orient == QDeclarativeListView::Vertical)
         fixupY();
     else
         fixupX();
 }

◆ flick()

void QDeclarativeListViewPrivate::flick	(	QDeclarativeFlickablePrivate::AxisData &	data,
		qreal	minExtent,
		qreal	maxExtent,
		qreal	vSize,
		QDeclarativeTimeLineCallback::Callback	fixupCallback,
		qreal	velocity
	)

virtual

Reimplemented from QDeclarativeFlickablePrivate.

Definition at line 1393 of file qdeclarativelistview.cpp.

 {
     Q_Q(QDeclarativeListView);
 
     data.fixingUp = false;
     moveReason = Mouse;
     if ((!haveHighlightRange || highlightRange != QDeclarativeListView::StrictlyEnforceRange) && snapMode == QDeclarativeListView::NoSnap) {
         correctFlick = true;
         QDeclarativeFlickablePrivate::flick(data, minExtent, maxExtent, vSize, fixupCallback, velocity);
         return;
     }
     qreal maxDistance = 0;
     qreal dataValue = isRightToLeft() ? -data.move.value()+size() : data.move.value();
     qreal highlightStart = isRightToLeft() && highlightRangeStartValid ? size()-highlightRangeEnd : highlightRangeStart;
     // -ve velocity means list is moving up/left
     if (velocity > 0) {
         if (data.move.value() < minExtent) {
             if (snapMode == QDeclarativeListView::SnapOneItem && !hData.flicking && !vData.flicking) {
                 // if we've been dragged < averageSize/2 then bias towards the next item
                 qreal dist = data.move.value() - (data.pressPos - data.dragStartOffset);
                 qreal bias = dist < averageSize/2 ? averageSize/2 : 0;
                 if (isRightToLeft())
                     bias = -bias;
                 data.flickTarget = -snapPosAt(-(dataValue - highlightStart) - bias) + highlightStart;
                 maxDistance = qAbs(data.flickTarget - data.move.value());
                 velocity = maxVelocity;
             } else {
                 maxDistance = qAbs(minExtent - data.move.value());
             }
         }
         if (snapMode == QDeclarativeListView::NoSnap && highlightRange != QDeclarativeListView::StrictlyEnforceRange)
             data.flickTarget = minExtent;
     } else {
         if (data.move.value() > maxExtent) {
             if (snapMode == QDeclarativeListView::SnapOneItem && !hData.flicking && !vData.flicking) {
                 // if we've been dragged < averageSize/2 then bias towards the next item
                 qreal dist = data.move.value() - (data.pressPos - data.dragStartOffset);
                 qreal bias = -dist < averageSize/2 ? averageSize/2 : 0;
                 if (isRightToLeft())
                     bias = -bias;
                 data.flickTarget = -snapPosAt(-(dataValue - highlightStart) + bias) + highlightStart;
                 maxDistance = qAbs(data.flickTarget - data.move.value());
                 velocity = -maxVelocity;
             } else {
                 maxDistance = qAbs(maxExtent - data.move.value());
             }
         }
         if (snapMode == QDeclarativeListView::NoSnap && highlightRange != QDeclarativeListView::StrictlyEnforceRange)
             data.flickTarget = maxExtent;
     }
 
     bool overShoot = boundsBehavior == QDeclarativeFlickable::DragAndOvershootBounds;
 
     if (maxDistance > 0 || overShoot) {
         // These modes require the list to stop exactly on an item boundary.
         // The initial flick will estimate the boundary to stop on.
         // Since list items can have variable sizes, the boundary will be
         // reevaluated and adjusted as we approach the boundary.
         qreal v = velocity;
         if (maxVelocity != -1 && maxVelocity < qAbs(v)) {
             if (v < 0)
                 v = -maxVelocity;
             else
                 v = maxVelocity;
         }
         if (!hData.flicking && !vData.flicking) {
             // the initial flick - estimate boundary
             qreal accel = deceleration;
             qreal v2 = v * v;
             overshootDist = qreal(0.0);
             // + averageSize/4 to encourage moving at least one item in the flick direction
             qreal dist = v2 / (accel * qreal(2.0)) + averageSize/4;
             if (maxDistance > 0)
                 dist = qMin(dist, maxDistance);
             if (v > 0)
                 dist = -dist;
             if ((maxDistance > qreal(0.0) && v2 / (2.0f * maxDistance) < accel) || snapMode == QDeclarativeListView::SnapOneItem) {
                 if (snapMode != QDeclarativeListView::SnapOneItem) {
                     qreal distTemp = isRightToLeft() ? -dist : dist;
                     data.flickTarget = -snapPosAt(-(dataValue - highlightStart) + distTemp) + highlightStart;
                 }
                 data.flickTarget = isRightToLeft() ? -data.flickTarget+size() : data.flickTarget;
                 if (overShoot) {
                     if (data.flickTarget >= minExtent) {
                         overshootDist = overShootDistance(vSize);
                         data.flickTarget += overshootDist;
                     } else if (data.flickTarget <= maxExtent) {
                         overshootDist = overShootDistance(vSize);
                         data.flickTarget -= overshootDist;
                     }
                 }
                 qreal adjDist = -data.flickTarget + data.move.value();
                 if (qAbs(adjDist) > qAbs(dist)) {
                     // Prevent painfully slow flicking - adjust velocity to suit flickDeceleration
                     qreal adjv2 = accel * 2.0f * qAbs(adjDist);
                     if (adjv2 > v2) {
                         v2 = adjv2;
                         v = qSqrt(v2);
                         if (dist > 0)
                             v = -v;
                     }
                 }
                 dist = adjDist;
                 accel = v2 / (2.0f * qAbs(dist));
             } else if (overShoot) {
                 data.flickTarget = data.move.value() - dist;
                 if (data.flickTarget >= minExtent) {
                     overshootDist = overShootDistance(vSize);
                     data.flickTarget += overshootDist;
                 } else if (data.flickTarget <= maxExtent) {
                     overshootDist = overShootDistance(vSize);
                     data.flickTarget -= overshootDist;
                 }
             }
 
             timeline.reset(data.move);
             timeline.accel(data.move, v, accel, maxDistance + overshootDist);
             timeline.callback(QDeclarativeTimeLineCallback(&data.move, fixupCallback, this));
             if (!hData.flicking && q->xflick()) {
                 hData.flicking = true;
                 emit q->flickingChanged();
                 emit q->flickingHorizontallyChanged();
                 emit q->flickStarted();
             }
             if (!vData.flicking && q->yflick()) {
                 vData.flicking = true;
                 emit q->flickingChanged();
                 emit q->flickingVerticallyChanged();
                 emit q->flickStarted();
             }
             correctFlick = true;
         } else {
             // reevaluate the target boundary.
             qreal newtarget = data.flickTarget;
             if (snapMode != QDeclarativeListView::NoSnap || highlightRange == QDeclarativeListView::StrictlyEnforceRange) {
                 qreal tempFlickTarget = isRightToLeft() ? -data.flickTarget+size() : data.flickTarget;
                 newtarget = -snapPosAt(-(tempFlickTarget - highlightStart)) + highlightStart;
                 newtarget = isRightToLeft() ? -newtarget+size() : newtarget;
             }
             if (velocity < 0 && newtarget <= maxExtent)
                 newtarget = maxExtent - overshootDist;
             else if (velocity > 0 && newtarget >= minExtent)
                 newtarget = minExtent + overshootDist;
             if (newtarget == data.flickTarget) { // boundary unchanged - nothing to do
                 if (qAbs(velocity) < MinimumFlickVelocity)
                     correctFlick = false;
                 return;
             }
             data.flickTarget = newtarget;
             qreal dist = -newtarget + data.move.value();
             if ((v < 0 && dist < 0) || (v > 0 && dist > 0)) {
                 correctFlick = false;
                 timeline.reset(data.move);
                 fixup(data, minExtent, maxExtent);
                 return;
             }
 
             timeline.reset(data.move);
             timeline.accelDistance(data.move, v, -dist);
             timeline.callback(QDeclarativeTimeLineCallback(&data.move, fixupCallback, this));
         }
     } else {
         correctFlick = false;
         timeline.reset(data.move);
         fixup(data, minExtent, maxExtent);
     }
 }

◆ init()

void QDeclarativeListViewPrivate::init ( )

Definition at line 603 of file qdeclarativelistview.cpp.

 {
     Q_Q(QDeclarativeListView);
     q->setFlag(QGraphicsItem::ItemIsFocusScope);
     addItemChangeListener(this, Geometry);
     QObject::connect(q, SIGNAL(movementEnded()), q, SLOT(animStopped()));
     q->setFlickableDirection(QDeclarativeFlickable::VerticalFlick);
     ::memset(sectionCache, 0, sizeof(QDeclarativeItem*) * sectionCacheSize);
 }

◆ isRightToLeft()

bool QDeclarativeListViewPrivate::isRightToLeft ( ) const

inline

Definition at line 293 of file qdeclarativelistview.cpp.

                                {
         Q_Q(const QDeclarativeListView);
         return orient == QDeclarativeListView::Horizontal && q->effectiveLayoutDirection() == Qt::RightToLeft;
     }

◆ isValid()

bool QDeclarativeListViewPrivate::isValid ( ) const

inline

Definition at line 417 of file qdeclarativelistview.cpp.

                          {
         return model && model->count() && model->isValid();
     }

◆ itemBefore()

FxListItem* QDeclarativeListViewPrivate::itemBefore ( int modelIndex ) const

inline

Definition at line 245 of file qdeclarativelistview.cpp.

                                                  {
         if (modelIndex < visibleIndex)
             return 0;
         int idx = 1;
         int lastIndex = -1;
         while (idx < visibleItems.count()) {
             FxListItem *item = visibleItems.at(idx);
             if (item->index != -1)
                 lastIndex = item->index;
             if (item->index == modelIndex)
                 return visibleItems.at(idx-1);
             ++idx;
         }
         if (lastIndex == modelIndex-1)
             return visibleItems.last();
         return 0;
     }

◆ itemGeometryChanged()

void QDeclarativeListViewPrivate::itemGeometryChanged	(	QDeclarativeItem *	item,
		const QRectF &	newGeometry,
		const QRectF &	oldGeometry
	)

inlinevirtual

Reimplemented from QDeclarativeFlickablePrivate.

Definition at line 485 of file qdeclarativelistview.cpp.

                                                                                                            {
         Q_Q(QDeclarativeListView);
         QDeclarativeFlickablePrivate::itemGeometryChanged(item, newGeometry, oldGeometry);
         if (!q->isComponentComplete())
             return;
         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)) {
             if (header)
                 updateHeader();
             if (footer)
                 updateFooter();
         }
         if (currentItem && currentItem->item == item)
             updateHighlight();
         if (trackedItem && trackedItem->item == item)
             q->trackedPositionChanged();
     }

◆ lastPosition()

qreal QDeclarativeListViewPrivate::lastPosition ( ) const

inline

Definition at line 329 of file qdeclarativelistview.cpp.

                                {
         qreal pos = 0;
         if (!visibleItems.isEmpty()) {
             int invisibleCount = visibleItems.count() - visibleIndex;
             for (int i = visibleItems.count()-1; i >= 0; --i) {
                 if (visibleItems.at(i)->index != -1) {
                     invisibleCount = model->count() - visibleItems.at(i)->index - 1;
                     break;
                 }
             }
             pos = (*(--visibleItems.constEnd()))->endPosition() + invisibleCount * (averageSize + spacing);
         } else if (model && model->count()) {
             pos = model->count() * averageSize + (model->count()-1) * spacing;
         }
         return pos;
     }

◆ lastVisibleIndex()

int QDeclarativeListViewPrivate::lastVisibleIndex ( ) const

inline

Definition at line 450 of file qdeclarativelistview.cpp.

                                  {
         int lastIndex = -1;
         for (int i = visibleItems.count()-1; i >= 0; --i) {
             FxListItem *listItem = visibleItems.at(i);
             if (listItem->index != -1) {
                 lastIndex = listItem->index;
                 break;
             }
         }
         return lastIndex;
     }

◆ layout()

void QDeclarativeListViewPrivate::layout ( )

Definition at line 866 of file qdeclarativelistview.cpp.

 {
     Q_Q(QDeclarativeListView);
     layoutScheduled = false;
     if (!isValid() && !visibleItems.count()) {
         clear();
         setPosition(0);
         return;
     }
     if (!visibleItems.isEmpty()) {
         bool fixedCurrent = currentItem && visibleItems.first()->item == currentItem->item;
         qreal sum = visibleItems.first()->size();
         qreal pos = visibleItems.first()->position() + visibleItems.first()->size() + spacing;
         for (int i=1; i < visibleItems.count(); ++i) {
             FxListItem *item = visibleItems.at(i);
             item->setPosition(pos);
             pos += item->size() + spacing;
             sum += item->size();
             fixedCurrent = fixedCurrent || (currentItem && item->item == currentItem->item);
         }
         averageSize = qRound(sum / visibleItems.count());
         // move current item if it is not a visible item.
         if (currentIndex >= 0 && currentItem && !fixedCurrent)
             currentItem->setPosition(positionAt(currentIndex));
     }
     q->refill();
     minExtentDirty = true;
     maxExtentDirty = true;
     updateHighlight();
     if (!q->isMoving() && !q->isFlicking()) {
         fixupPosition();
         q->refill();
     }
     if (sectionCriteria)
         updateCurrentSection();
     if (header)
         updateHeader();
     if (footer)
         updateFooter();
     updateViewport();
 }

◆ mapFromModel()

int QDeclarativeListViewPrivate::mapFromModel ( int modelIndex ) const

inline

Definition at line 463 of file qdeclarativelistview.cpp.

                                            {
         if (modelIndex < visibleIndex || modelIndex >= visibleIndex + visibleItems.count())
             return -1;
         for (int i = 0; i < visibleItems.count(); ++i) {
             FxListItem *listItem = visibleItems.at(i);
             if (listItem->index == modelIndex)
                 return i;
             if (listItem->index > modelIndex)
                 return -1;
         }
         return -1; // Not in visibleList
     }

◆ mirrorChange()

void QDeclarativeListViewPrivate::mirrorChange ( )

inlinevirtual

Reimplemented from QDeclarativeItemPrivate.

Definition at line 289 of file qdeclarativelistview.cpp.

                         {
         regenerate();
     }

◆ originPosition()

qreal QDeclarativeListViewPrivate::originPosition ( ) const

inline

Definition at line 319 of file qdeclarativelistview.cpp.

                                  {
         qreal pos = 0;
         if (!visibleItems.isEmpty()) {
             pos = (*visibleItems.constBegin())->position();
             if (visibleIndex > 0)
                 pos -= visibleIndex * (averageSize + spacing);
         }
         return pos;
     }

◆ position()

qreal QDeclarativeListViewPrivate::position ( ) const

inline

Definition at line 298 of file qdeclarativelistview.cpp.

                            {
         Q_Q(const QDeclarativeListView);
         return orient == QDeclarativeListView::Vertical ? q->contentY() : q->contentX();
     }

◆ positionAt()

qreal QDeclarativeListViewPrivate::positionAt ( int modelIndex ) const

inline

Definition at line 354 of file qdeclarativelistview.cpp.

                                            {
         if (FxListItem *item = visibleItem(modelIndex))
             return item->position();
         if (!visibleItems.isEmpty()) {
             if (modelIndex < visibleIndex) {
                 int count = visibleIndex - modelIndex;
                 qreal cs = 0;
                 if (modelIndex == currentIndex && currentItem) {
                     cs = currentItem->size() + spacing;
                     --count;
                 }
                 return (*visibleItems.constBegin())->position() - count * (averageSize + spacing) - cs;
             } else {
                 int idx = visibleItems.count() - 1;
                 while (idx >= 0 && visibleItems.at(idx)->index == -1)
                     --idx;
                 if (idx < 0)
                     idx = visibleIndex;
                 else
                     idx = visibleItems.at(idx)->index;
                 int count = modelIndex - idx - 1;
 
                 return (*(--visibleItems.constEnd()))->endPosition() + spacing + count * (averageSize + spacing) + 1;
             }
         }
         return 0;
     }

◆ positionViewAtIndex()

void QDeclarativeListViewPrivate::positionViewAtIndex	(	int	index,
		int	mode
	)

Definition at line 2999 of file qdeclarativelistview.cpp.

 {
     Q_Q(QDeclarativeListView);
     if (!isValid())
         return;
     if (mode < QDeclarativeListView::Beginning || mode > QDeclarativeListView::Contain)
         return;
     int idx = qMax(qMin(index, model->count()-1), 0);
 
     if (layoutScheduled)
         layout();
     qreal pos = isRightToLeft() ? -position() - size() : position();
     FxListItem *item = visibleItem(idx);
     qreal maxExtent;
     if (orient == QDeclarativeListView::Vertical)
         maxExtent = -q->maxYExtent();
     else
         maxExtent = isRightToLeft() ? q->minXExtent()-size(): -q->maxXExtent();
 
     if (!item) {
         int itemPos = positionAt(idx);
         // save the currently visible items in case any of them end up visible again
         QList<FxListItem*> oldVisible = visibleItems;
         visibleItems.clear();
         visiblePos = itemPos;
         visibleIndex = idx;
         setPosition(qMin(qreal(itemPos), maxExtent));
         // now release the reference to all the old visible items.
         for (int i = 0; i < oldVisible.count(); ++i)
             releaseItem(oldVisible.at(i));
         item = visibleItem(idx);
     }
     if (item) {
         const qreal itemPos = item->position();
         switch (mode) {
         case QDeclarativeListView::Beginning:
             pos = itemPos;
             if (index < 0 && header)
                 pos -= header->size();
             break;
         case QDeclarativeListView::Center:
             pos = itemPos - (size() - item->size())/2;
             break;
         case QDeclarativeListView::End:
             pos = itemPos - size() + item->size();
             if (index >= model->count() && footer)
                 pos += footer->size();
             break;
         case QDeclarativeListView::Visible:
             if (itemPos > pos + size())
                 pos = itemPos - size() + item->size();
             else if (item->endPosition() < pos)
                 pos = itemPos;
             break;
         case QDeclarativeListView::Contain:
             if (item->endPosition() > pos + size())
                 pos = itemPos - size() + item->size();
             if (itemPos < pos)
                 pos = itemPos;
         }
         pos = qMin(pos, maxExtent);
         qreal minExtent;
         if (orient == QDeclarativeListView::Vertical) {
             minExtent = -q->minYExtent();
         } else {
             minExtent = isRightToLeft() ? q->maxXExtent()-size(): -q->minXExtent();
         }
         pos = qMax(pos, minExtent);
         moveReason = QDeclarativeListViewPrivate::Other;
         q->cancelFlick();
         setPosition(pos);
         if (highlight) {
             if (autoHighlight) {
                 highlight->setPosition(currentItem->itemPosition());
                 highlight->setSize(currentItem->itemSize());
             }
             updateHighlight();
         }
     }
     fixupPosition();
 }

◆ refill()

void QDeclarativeListViewPrivate::refill	(	qreal	from,
		qreal	to,
		bool	doBuffer = `false`
	)

Definition at line 730 of file qdeclarativelistview.cpp.

 {
     Q_Q(QDeclarativeListView);
     if (!isValid() || !q->isComponentComplete())
         return;
     itemCount = model->count();
     qreal bufferFrom = from - buffer;
     qreal bufferTo = to + buffer;
     qreal fillFrom = from;
     qreal fillTo = to;
     if (doBuffer && (bufferMode & BufferAfter))
         fillTo = bufferTo;
     if (doBuffer && (bufferMode & BufferBefore))
         fillFrom = bufferFrom;
 
     bool haveValidItems = false;
     int modelIndex = visibleIndex;
     qreal itemEnd = visiblePos-1;
     if (!visibleItems.isEmpty()) {
         visiblePos = (*visibleItems.constBegin())->position();
         itemEnd = (*(--visibleItems.constEnd()))->endPosition() + spacing;
         int i = visibleItems.count() - 1;
         while (i > 0 && visibleItems.at(i)->index == -1)
             --i;
         if (visibleItems.at(i)->index != -1) {
             haveValidItems = true;
             modelIndex = visibleItems.at(i)->index + 1;
         }
     }
 
     if (haveValidItems && (fillFrom > itemEnd+averageSize+spacing
         || fillTo < visiblePos - averageSize - spacing)) {
         // We've jumped more than a page.  Estimate which items are now
         // visible and fill from there.
         int count = (fillFrom - itemEnd) / (averageSize + spacing);
         for (int i = 0; i < visibleItems.count(); ++i)
             releaseItem(visibleItems.at(i));
         visibleItems.clear();
         modelIndex += count;
         if (modelIndex >= model->count()) {
             count -= modelIndex - model->count() + 1;
             modelIndex = model->count() - 1;
         } else if (modelIndex < 0) {
             count -= modelIndex;
             modelIndex = 0;
         }
         visibleIndex = modelIndex;
         visiblePos = itemEnd + count * (averageSize + spacing) + 1;
         itemEnd = visiblePos-1;
     }
 
     bool changed = false;
     FxListItem *item = 0;
     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);
         pos += item->size() + spacing;
         visibleItems.append(item);
         ++modelIndex;
         changed = true;
         if (doBuffer) // never buffer more than one item per frame
             break;
     }
     while (visibleIndex > 0 && visibleIndex <= model->count() && visiblePos-1 >= fillFrom) {
 //        qDebug() << "refill: prepend item" << visibleIndex-1 << "current top pos" << visiblePos;
         if (!(item = createItem(visibleIndex-1)))
             break;
         --visibleIndex;
         visiblePos -= item->size() + spacing;
         item->setPosition(visiblePos);
         visibleItems.prepend(item);
         changed = true;
         if (doBuffer) // never buffer more than one item per frame
             break;
     }
 
     if (!lazyRelease || !changed || deferredRelease) { // avoid destroying items in the same frame that we create
         while (visibleItems.count() > 1 && (item = visibleItems.first()) && item->endPosition() < bufferFrom) {
             if (item->attached->delayRemove())
                 break;
 //            qDebug() << "refill: remove first" << visibleIndex << "top end pos" << item->endPosition();
             if (item->index != -1)
                 visibleIndex++;
             visibleItems.removeFirst();
             releaseItem(item);
             changed = true;
         }
         while (visibleItems.count() > 1 && (item = visibleItems.last()) && item->position() > bufferTo) {
             if (item->attached->delayRemove())
                 break;
 //            qDebug() << "refill: remove last" << visibleIndex+visibleItems.count()-1 << item->position();
             visibleItems.removeLast();
             releaseItem(item);
             changed = true;
         }
         deferredRelease = false;
     } else {
         deferredRelease = true;
     }
     if (changed) {
         minExtentDirty = true;
         maxExtentDirty = true;
         if (visibleItems.count())
             visiblePos = (*visibleItems.constBegin())->position();
         updateAverage();
         if (currentIndex >= 0 && currentItem && !visibleItem(currentIndex)) {
             currentItem->setPosition(positionAt(currentIndex));
             updateHighlight();
         }
 
         if (sectionCriteria)
             updateCurrentSection();
         if (header)
             updateHeader();
         if (footer)
             updateFooter();
         updateViewport();
         updateUnrequestedPositions();
     } else if (!doBuffer && buffer && bufferMode != NoBuffer) {
         refill(from, to, true);
     }
     lazyRelease = false;
 }

◆ regenerate()

void QDeclarativeListViewPrivate::regenerate ( )

inline

Definition at line 263 of file qdeclarativelistview.cpp.

                       {
         Q_Q(QDeclarativeListView);
         if (q->isComponentComplete()) {
             if (header) {
                 if (q->scene())
                     q->scene()->removeItem(header->item);
                 header->item->deleteLater();
                 delete header;
                 header = 0;
             }
             if (footer) {
                 if (q->scene())
                     q->scene()->removeItem(footer->item);
                 footer->item->deleteLater();
                 delete footer;
                 footer = 0;
             }
             updateHeader();
             updateFooter();
             clear();
             setPosition(0);
             q->refill();
             updateCurrent(currentIndex);
         }
     }

◆ releaseItem()

void QDeclarativeListViewPrivate::releaseItem ( FxListItem * item )

Definition at line 701 of file qdeclarativelistview.cpp.

 {
     Q_Q(QDeclarativeListView);
     if (!item || !model)
         return;
     if (trackedItem == item)
         trackedItem = 0;
     QDeclarativeItemPrivate *itemPrivate = static_cast<QDeclarativeItemPrivate*>(QGraphicsItemPrivate::get(item->item));
     itemPrivate->removeItemChangeListener(this, QDeclarativeItemPrivate::Geometry);
     if (model->release(item->item) == 0) {
         // item was not destroyed, and we no longer reference it.
         unrequestedItems.insert(item->item, model->indexOf(item->item, q));
     }
     if (item->section) {
         int i = 0;
         do {
             if (!sectionCache[i]) {
                 sectionCache[i] = item->section;
                 sectionCache[i]->setVisible(false);
                 item->section = 0;
                 break;
             }
             ++i;
         } while (i < sectionCacheSize);
         delete item->section;
     }
     delete item;
 }

◆ scheduleLayout()

void QDeclarativeListViewPrivate::scheduleLayout ( )

Definition at line 857 of file qdeclarativelistview.cpp.

 {
     Q_Q(QDeclarativeListView);
     if (!layoutScheduled) {
         layoutScheduled = true;
         QCoreApplication::postEvent(q, new QEvent(QEvent::User), Qt::HighEventPriority);
     }
 }

◆ sectionAt()

QString QDeclarativeListViewPrivate::sectionAt ( int modelIndex )

inline

Definition at line 404 of file qdeclarativelistview.cpp.

                                       {
         if (FxListItem *item = visibleItem(modelIndex))
             return item->attached->section();
 
         QString section;
         if (sectionCriteria) {
             QString propValue = model->stringValue(modelIndex, sectionCriteria->property());
             section = sectionCriteria->sectionString(propValue);
         }
 
         return section;
     }

◆ setPosition()

void QDeclarativeListViewPrivate::setPosition ( qreal pos )

inline

Definition at line 303 of file qdeclarativelistview.cpp.

                                 {
         Q_Q(QDeclarativeListView);
         if (orient == QDeclarativeListView::Vertical) {
             q->QDeclarativeFlickable::setContentY(pos);
         } else {
             if (isRightToLeft())
                 q->QDeclarativeFlickable::setContentX(-pos-size());
             else
                 q->QDeclarativeFlickable::setContentX(pos);
         }
     }

◆ size()

qreal QDeclarativeListViewPrivate::size ( ) const

inline

Definition at line 314 of file qdeclarativelistview.cpp.

                        {
         Q_Q(const QDeclarativeListView);
         return orient == QDeclarativeListView::Vertical ? q->height() : q->width();
     }

◆ snapItemAt()

FxListItem* QDeclarativeListViewPrivate::snapItemAt ( qreal pos )

inline

Definition at line 435 of file qdeclarativelistview.cpp.

                                       {
         FxListItem *snapItem = 0;
         for (int i = 0; i < visibleItems.count(); ++i) {
             FxListItem *item = visibleItems[i];
             if (item->index == -1)
                 continue;
             qreal itemTop = item->position();
             if (highlight && itemTop >= pos && item->endPosition() <= pos + highlight->size() - 1)
                 return item;
             if (itemTop+item->size()/2 >= pos && itemTop-item->size()/2 < pos)
                 snapItem = item;
         }
         return snapItem;
     }

◆ snapPosAt()

qreal QDeclarativeListViewPrivate::snapPosAt ( qreal pos )

inline

Definition at line 421 of file qdeclarativelistview.cpp.

                                {
         if (FxListItem *snapItem = snapItemAt(pos))
             return snapItem->position();
         if (visibleItems.count()) {
             qreal firstPos = visibleItems.first()->position();
             qreal endPos = visibleItems.last()->position();
             if (pos < firstPos) {
                 return firstPos - qRound((firstPos - pos) / averageSize) * averageSize;
             } else if (pos > endPos)
                 return endPos + qRound((pos - endPos) / averageSize) * averageSize;
         }
         return qRound((pos - originPosition()) / averageSize) * averageSize + originPosition();
     }

◆ startPosition()

qreal QDeclarativeListViewPrivate::startPosition ( ) const

inline

Definition at line 346 of file qdeclarativelistview.cpp.

                                 {
         return isRightToLeft() ? -lastPosition()-1 : originPosition();
     }

◆ updateAverage()

void QDeclarativeListViewPrivate::updateAverage ( )

Definition at line 1201 of file qdeclarativelistview.cpp.

 {
     if (!visibleItems.count())
         return;
     qreal sum = 0.0;
     for (int i = 0; i < visibleItems.count(); ++i)
         sum += visibleItems.at(i)->size();
     averageSize = qRound(sum / visibleItems.count());
 }

◆ updateCurrent()

void QDeclarativeListViewPrivate::updateCurrent ( int modelIndex )

Definition at line 1149 of file qdeclarativelistview.cpp.

 {
     Q_Q(QDeclarativeListView);
     if (!q->isComponentComplete() || !isValid() || modelIndex < 0 || modelIndex >= model->count()) {
         if (currentItem) {
             currentItem->attached->setIsCurrentItem(false);
             releaseItem(currentItem);
             currentItem = 0;
             currentIndex = modelIndex;
             emit q->currentIndexChanged();
             updateHighlight();
         } else if (currentIndex != modelIndex) {
             currentIndex = modelIndex;
             emit q->currentIndexChanged();
         }
         return;
     }
 
     if (currentItem && currentIndex == modelIndex) {
         updateHighlight();
         return;
     }
     FxListItem *oldCurrentItem = currentItem;
     currentIndex = modelIndex;
     currentItem = createItem(modelIndex);
     if (oldCurrentItem && (!currentItem || oldCurrentItem->item != currentItem->item))
         oldCurrentItem->attached->setIsCurrentItem(false);
     if (currentItem) {
         if (modelIndex == visibleIndex - 1 && visibleItems.count()) {
             // We can calculate exact postion in this case
             currentItem->setPosition(visibleItems.first()->position() - currentItem->size() - spacing);
         } else {
             // Create current item now and position as best we can.
             // 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);
         if (visibleItems.isEmpty())
             averageSize = currentItem->size();
     }
     updateHighlight();
     emit q->currentIndexChanged();
     // Release the old current item
     releaseItem(oldCurrentItem);
 }

◆ updateCurrentSection()

void QDeclarativeListViewPrivate::updateCurrentSection ( )

Definition at line 1124 of file qdeclarativelistview.cpp.

 {
     Q_Q(QDeclarativeListView);
     if (!sectionCriteria || visibleItems.isEmpty()) {
         if (!currentSection.isEmpty()) {
             currentSection.clear();
             emit q->currentSectionChanged();
         }
         return;
     }
     int index = 0;
     while (index < visibleItems.count() && visibleItems.at(index)->endPosition() < position())
         ++index;
 
     QString newSection = currentSection;
     if (index < visibleItems.count())
         newSection = visibleItems.at(index)->attached->section();
     else
         newSection = visibleItems.first()->attached->section();
     if (newSection != currentSection) {
         currentSection = newSection;
         emit q->currentSectionChanged();
     }
 }

◆ updateFooter()

void QDeclarativeListViewPrivate::updateFooter ( )

Definition at line 1211 of file qdeclarativelistview.cpp.

 {
     Q_Q(QDeclarativeListView);
     if (!footer && footerComponent) {
         QDeclarativeItem *item = createComponentItem(footerComponent);
         if (item) {
             QDeclarative_setParent_noEvent(item, q->contentItem());
             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 = lastPosition() + 1;
             if (lastVisibleIndex() == model->count()-1) {
                 footer->setPosition(endPos);
             } else {
                 qreal visiblePos = position() + q->height();
                 if (endPos <= visiblePos || footer->position() < endPos)
                     footer->setPosition(endPos);
             }
         } else {
             footer->setPosition(visiblePos);
         }
     }
 }

◆ updateHeader()

void QDeclarativeListViewPrivate::updateHeader ( )

Definition at line 1241 of file qdeclarativelistview.cpp.

 {
     Q_Q(QDeclarativeListView);
     if (!header && headerComponent) {
         QDeclarativeItem *item = createComponentItem(headerComponent);
         if (item) {
             QDeclarative_setParent_noEvent(item, q->contentItem());
             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 (header) {
         if (visibleItems.count()) {
             qreal startPos = originPosition();
             if (visibleIndex == 0) {
                 header->setPosition(startPos - header->size());
             } else {
                 if (position() <= startPos || header->position() > startPos - header->size())
                     header->setPosition(startPos - header->size());
             }
         } else {
             if (itemCount == 0)
                 visiblePos = header->size();
             header->setPosition(0);
         }
     }
 }

◆ updateHighlight()

void QDeclarativeListViewPrivate::updateHighlight ( )

Definition at line 1011 of file qdeclarativelistview.cpp.

 {
     if ((!currentItem && highlight) || (currentItem && !highlight))
         createHighlight();
     if (currentItem && autoHighlight && highlight && !hData.moving && !vData.moving) {
         // auto-update highlight
         highlightPosAnimator->to = isRightToLeft()
                 ? -currentItem->itemPosition()-currentItem->itemSize()
                 : currentItem->itemPosition();
         highlightSizeAnimator->to = currentItem->itemSize();
         if (orient == QDeclarativeListView::Vertical) {
             if (highlight->item->width() == 0)
                 highlight->item->setWidth(currentItem->item->width());
         } else {
             if (highlight->item->height() == 0)
                 highlight->item->setHeight(currentItem->item->height());
         }
         highlightPosAnimator->restart();
         highlightSizeAnimator->restart();
     }
     updateTrackedItem();
 }

◆ updateSections()

void QDeclarativeListViewPrivate::updateSections ( )

Definition at line 1093 of file qdeclarativelistview.cpp.

 {
     if (sectionCriteria && !visibleItems.isEmpty()) {
         QString prevSection;
         if (visibleIndex > 0)
             prevSection = sectionAt(visibleIndex-1);
         QDeclarativeListViewAttached *prevAtt = 0;
         int idx = -1;
         for (int i = 0; i < visibleItems.count(); ++i) {
             QDeclarativeListViewAttached *attached = visibleItems.at(i)->attached;
             attached->setPrevSection(prevSection);
             if (visibleItems.at(i)->index != -1) {
                 QString propValue = model->stringValue(visibleItems.at(i)->index, sectionCriteria->property());
                 attached->setSection(sectionCriteria->sectionString(propValue));
                 idx = visibleItems.at(i)->index;
             }
             createSection(visibleItems.at(i));
             if (prevAtt)
                 prevAtt->setNextSection(attached->section());
             prevSection = attached->section();
             prevAtt = attached;
         }
         if (prevAtt) {
             if (idx > 0 && idx < model->count()-1)
                 prevAtt->setNextSection(sectionAt(idx+1));
             else
                 prevAtt->setNextSection(QString());
         }
     }
 }

◆ updateTrackedItem()

void QDeclarativeListViewPrivate::updateTrackedItem ( )

Definition at line 939 of file qdeclarativelistview.cpp.

 {
     Q_Q(QDeclarativeListView);
     FxListItem *item = currentItem;
     if (highlight)
         item = highlight;
     trackedItem = item;
     if (trackedItem)
         q->trackedPositionChanged();
 }

◆ updateUnrequestedIndexes()

void QDeclarativeListViewPrivate::updateUnrequestedIndexes ( )

Definition at line 908 of file qdeclarativelistview.cpp.

 {
     Q_Q(QDeclarativeListView);
     QHash<QDeclarativeItem*,int>::iterator it;
     for (it = unrequestedItems.begin(); it != unrequestedItems.end(); ++it)
         *it = model->indexOf(it.key(), q);
 }

◆ updateUnrequestedPositions()

void QDeclarativeListViewPrivate::updateUnrequestedPositions ( )

Definition at line 916 of file qdeclarativelistview.cpp.

 {
     Q_Q(QDeclarativeListView);
     if (unrequestedItems.count()) {
         qreal pos = position();
         QHash<QDeclarativeItem*,int>::const_iterator it;
         for (it = unrequestedItems.begin(); it != unrequestedItems.end(); ++it) {
             QDeclarativeItem *item = it.key();
             if (orient == QDeclarativeListView::Vertical) {
                 if (item->y() + item->height() > pos && item->y() < pos + q->height())
                     item->setY(positionAt(*it));
             } else {
                 if (item->x() + item->width() > pos && item->x() < pos + q->width()) {
                     if (isRightToLeft())
                         item->setX(-positionAt(*it)-item->width());
                     else
                         item->setX(positionAt(*it));
                 }
             }
         }
     }
 }

◆ updateViewport()

void QDeclarativeListViewPrivate::updateViewport ( )

inline

Definition at line 476 of file qdeclarativelistview.cpp.

                           {
         Q_Q(QDeclarativeListView);
         if (orient == QDeclarativeListView::Vertical) {
             q->setContentHeight(endPosition() - startPosition() + 1);
         } else {
             q->setContentWidth(endPosition() - startPosition() + 1);
         }
     }

◆ visibleItem()

FxListItem* QDeclarativeListViewPrivate::visibleItem ( int modelIndex ) const

inline

Definition at line 222 of file qdeclarativelistview.cpp.

                                                   {
         if (modelIndex >= visibleIndex && modelIndex < visibleIndex + visibleItems.count()) {
             for (int i = modelIndex - visibleIndex; i < visibleItems.count(); ++i) {
                 FxListItem *item = visibleItems.at(i);
                 if (item->index == modelIndex)
                     return item;
             }
         }
         return 0;
     }

Properties

◆ autoHighlight

bool QDeclarativeListViewPrivate::autoHighlight

Definition at line 590 of file qdeclarativelistview.cpp.

◆ averageSize

qreal QDeclarativeListViewPrivate::averageSize

Definition at line 551 of file qdeclarativelistview.cpp.

◆ buffer

int QDeclarativeListViewPrivate::buffer

Definition at line 564 of file qdeclarativelistview.cpp.

◆ bufferMode

int QDeclarativeListViewPrivate::bufferMode

Definition at line 584 of file qdeclarativelistview.cpp.

◆ correctFlick

bool QDeclarativeListViewPrivate::correctFlick

Definition at line 592 of file qdeclarativelistview.cpp.

◆ currentIndex

int QDeclarativeListViewPrivate::currentIndex

Definition at line 552 of file qdeclarativelistview.cpp.

◆ currentIndexCleared

bool QDeclarativeListViewPrivate::currentIndexCleared

Definition at line 597 of file qdeclarativelistview.cpp.

◆ currentItem

FxListItem* QDeclarativeListViewPrivate::currentItem

Definition at line 546 of file qdeclarativelistview.cpp.

◆ currentSection

QString QDeclarativeListViewPrivate::currentSection

Definition at line 568 of file qdeclarativelistview.cpp.

◆ deferredRelease

bool QDeclarativeListViewPrivate::deferredRelease

Definition at line 595 of file qdeclarativelistview.cpp.

◆ footer

FxListItem* QDeclarativeListViewPrivate::footer

Definition at line 580 of file qdeclarativelistview.cpp.

◆ footerComponent

QDeclarativeComponent* QDeclarativeListViewPrivate::footerComponent

Definition at line 579 of file qdeclarativelistview.cpp.

◆ haveHighlightRange

bool QDeclarativeListViewPrivate::haveHighlightRange

Definition at line 591 of file qdeclarativelistview.cpp.

◆ header

FxListItem* QDeclarativeListViewPrivate::header

Definition at line 582 of file qdeclarativelistview.cpp.

◆ headerComponent

QDeclarativeComponent* QDeclarativeListViewPrivate::headerComponent

Definition at line 581 of file qdeclarativelistview.cpp.

◆ highlight

FxListItem* QDeclarativeListViewPrivate::highlight

Definition at line 560 of file qdeclarativelistview.cpp.

◆ highlightComponent

QDeclarativeComponent* QDeclarativeListViewPrivate::highlightComponent

Definition at line 559 of file qdeclarativelistview.cpp.

◆ highlightMoveDuration

int QDeclarativeListViewPrivate::highlightMoveDuration

Definition at line 573 of file qdeclarativelistview.cpp.

◆ highlightMoveSpeed

qreal QDeclarativeListViewPrivate::highlightMoveSpeed

Definition at line 572 of file qdeclarativelistview.cpp.

◆ highlightPosAnimator

QSmoothedAnimation* QDeclarativeListViewPrivate::highlightPosAnimator

Definition at line 565 of file qdeclarativelistview.cpp.

◆ highlightRange

QDeclarativeListView::HighlightRangeMode QDeclarativeListViewPrivate::highlightRange

Definition at line 576 of file qdeclarativelistview.cpp.

◆ highlightRangeEnd

qreal QDeclarativeListViewPrivate::highlightRangeEnd

Definition at line 556 of file qdeclarativelistview.cpp.

◆ highlightRangeEndValid

bool QDeclarativeListViewPrivate::highlightRangeEndValid

Definition at line 558 of file qdeclarativelistview.cpp.

◆ highlightRangeStart

qreal QDeclarativeListViewPrivate::highlightRangeStart

Definition at line 555 of file qdeclarativelistview.cpp.

◆ highlightRangeStartValid

bool QDeclarativeListViewPrivate::highlightRangeStartValid

Definition at line 557 of file qdeclarativelistview.cpp.

◆ highlightResizeDuration

int QDeclarativeListViewPrivate::highlightResizeDuration

Definition at line 575 of file qdeclarativelistview.cpp.

◆ highlightResizeSpeed

qreal QDeclarativeListViewPrivate::highlightResizeSpeed

Definition at line 574 of file qdeclarativelistview.cpp.

◆ highlightSizeAnimator

QSmoothedAnimation* QDeclarativeListViewPrivate::highlightSizeAnimator

Definition at line 566 of file qdeclarativelistview.cpp.

◆ inFlickCorrection

bool QDeclarativeListViewPrivate::inFlickCorrection

Definition at line 593 of file qdeclarativelistview.cpp.

◆ inViewportMoved

bool QDeclarativeListViewPrivate::inViewportMoved

Definition at line 598 of file qdeclarativelistview.cpp.

◆ itemCount

int QDeclarativeListViewPrivate::itemCount

Definition at line 554 of file qdeclarativelistview.cpp.

◆ layoutDirection

Qt::LayoutDirection QDeclarativeListViewPrivate::layoutDirection

Definition at line 548 of file qdeclarativelistview.cpp.

◆ layoutScheduled

bool QDeclarativeListViewPrivate::layoutScheduled

Definition at line 596 of file qdeclarativelistview.cpp.

◆ lazyRelease

bool QDeclarativeListViewPrivate::lazyRelease

Definition at line 594 of file qdeclarativelistview.cpp.

◆ maxExtent

qreal QDeclarativeListViewPrivate::maxExtent

mutable

Definition at line 586 of file qdeclarativelistview.cpp.

◆ maxExtentDirty

bool QDeclarativeListViewPrivate::maxExtentDirty

mutable

Definition at line 600 of file qdeclarativelistview.cpp.

◆ minExtent

qreal QDeclarativeListViewPrivate::minExtent

mutable

Definition at line 585 of file qdeclarativelistview.cpp.

◆ minExtentDirty

bool QDeclarativeListViewPrivate::minExtentDirty

mutable

Definition at line 599 of file qdeclarativelistview.cpp.

◆ model

QDeclarativeGuard<QDeclarativeVisualModel> QDeclarativeListViewPrivate::model

Definition at line 542 of file qdeclarativelistview.cpp.

◆ modelVariant

QVariant QDeclarativeListViewPrivate::modelVariant

Definition at line 543 of file qdeclarativelistview.cpp.

◆ moveReason

MovementReason QDeclarativeListViewPrivate::moveReason

Definition at line 563 of file qdeclarativelistview.cpp.

◆ orient

QDeclarativeListView::Orientation QDeclarativeListViewPrivate::orient

Definition at line 547 of file qdeclarativelistview.cpp.

◆ overshootDist

qreal QDeclarativeListViewPrivate::overshootDist

Definition at line 578 of file qdeclarativelistview.cpp.

◆ ownModel

bool QDeclarativeListViewPrivate::ownModel

Definition at line 588 of file qdeclarativelistview.cpp.

◆ requestedIndex

int QDeclarativeListViewPrivate::requestedIndex

Definition at line 553 of file qdeclarativelistview.cpp.

◆ sectionCache

QDeclarativeItem* QDeclarativeListViewPrivate::sectionCache[sectionCacheSize]

Definition at line 570 of file qdeclarativelistview.cpp.

◆ sectionCacheSize

const int QDeclarativeListViewPrivate::sectionCacheSize = 4

static

Definition at line 569 of file qdeclarativelistview.cpp.

◆ sectionCriteria

QDeclarativeViewSection* QDeclarativeListViewPrivate::sectionCriteria

Definition at line 567 of file qdeclarativelistview.cpp.

◆ snapMode

QDeclarativeListView::SnapMode QDeclarativeListViewPrivate::snapMode

Definition at line 577 of file qdeclarativelistview.cpp.

◆ spacing

qreal QDeclarativeListViewPrivate::spacing

Definition at line 571 of file qdeclarativelistview.cpp.

◆ trackedItem

FxListItem* QDeclarativeListViewPrivate::trackedItem

Definition at line 561 of file qdeclarativelistview.cpp.

◆ unrequestedItems

QHash<QDeclarativeItem*,int> QDeclarativeListViewPrivate::unrequestedItems

Definition at line 545 of file qdeclarativelistview.cpp.

◆ visibleIndex

int QDeclarativeListViewPrivate::visibleIndex

Definition at line 550 of file qdeclarativelistview.cpp.

◆ visibleItems

QList<FxListItem*> QDeclarativeListViewPrivate::visibleItems

Definition at line 544 of file qdeclarativelistview.cpp.

◆ visiblePos

qreal QDeclarativeListViewPrivate::visiblePos

Definition at line 549 of file qdeclarativelistview.cpp.

◆ wrap

bool QDeclarativeListViewPrivate::wrap

Definition at line 589 of file qdeclarativelistview.cpp.

The documentation for this class was generated from the following file:

/src/declarative/graphicsitems/qdeclarativelistview.cpp

Public Types

Public Functions

Public Variables

Static Public Variables

Additional Inherited Members

Detailed Description

Enumerations

◆ BufferMode

◆ MovementReason

Constructors and Destructors

◆ QDeclarativeListViewPrivate()

Functions

◆ checkVisible()

◆ clear()

◆ createComponentItem()

◆ createHighlight()

◆ createItem()

◆ createSection()

◆ endPosition()

◆ endPositionAt()

◆ firstVisibleItem()

◆ fixup()

◆ fixupPosition()

◆ flick()

◆ init()

◆ isRightToLeft()

◆ isValid()

◆ itemBefore()

◆ itemGeometryChanged()

◆ lastPosition()

◆ lastVisibleIndex()

◆ layout()

◆ mapFromModel()

◆ mirrorChange()

◆ originPosition()

◆ position()

◆ positionAt()

◆ positionViewAtIndex()

◆ refill()

◆ regenerate()

◆ releaseItem()

◆ scheduleLayout()

◆ sectionAt()

◆ setPosition()

◆ size()

◆ snapItemAt()

◆ snapPosAt()

◆ startPosition()

◆ updateAverage()

◆ updateCurrent()

◆ updateCurrentSection()

◆ updateFooter()

◆ updateHeader()

◆ updateHighlight()

◆ updateSections()

◆ updateTrackedItem()

◆ updateUnrequestedIndexes()

◆ updateUnrequestedPositions()

◆ updateViewport()

◆ visibleItem()

Properties

◆ autoHighlight

◆ averageSize

◆ buffer

◆ bufferMode

◆ correctFlick

◆ currentIndex

◆ currentIndexCleared

◆ currentItem

◆ currentSection

◆ deferredRelease

◆ footer

◆ footerComponent

◆ haveHighlightRange

◆ header

◆ headerComponent

◆ highlight

◆ highlightComponent

◆ highlightMoveDuration

◆ highlightMoveSpeed