FxViewItem *item = visibleItems.at(i);
if (item->index != -1 && item->index >= modelIndex) {
item->index += count;
- if (transitioner) {
- if (change.isMove())
- transitioner->transitionNextReposition(item, QQuickItemViewTransitioner::MoveTransition, false);
- else
- transitioner->transitionNextReposition(item, QQuickItemViewTransitioner::AddTransition, false);
- }
+ if (change.isMove())
+ item->transitionNextReposition(transitioner, QQuickItemViewTransitioner::MoveTransition, false);
+ else
+ item->transitionNextReposition(transitioner, QQuickItemViewTransitioner::AddTransition, false);
}
}
insertResult->changedFirstItem = true;
if (!change.isMove()) {
addedItems->append(item);
- if (transitioner)
- transitioner->transitionNextReposition(item, QQuickItemViewTransitioner::AddTransition, true);
+ item->transitionNextReposition(transitioner, QQuickItemViewTransitioner::AddTransition, true);
}
insertResult->sizeChangesBeforeVisiblePos += rowSize();
}
movingIntoView->append(MovedItem(item, change.moveKey(item->index)));
} else {
addedItems->append(item);
- if (transitioner)
- transitioner->transitionNextReposition(item, QQuickItemViewTransitioner::AddTransition, true);
+ item->transitionNextReposition(transitioner, QQuickItemViewTransitioner::AddTransition, true);
}
insertResult->sizeChangesAfterVisiblePos += rowSize();
qreal origColPos = gridItem->rowPos();
int indexDiff = gridItem->index - countItemsRemoved;
gridItem->setPosition((indexDiff % columns) * colSize(), (indexDiff / columns) * rowSize());
- transitioner->transitionNextReposition(gridItem, QQuickItemViewTransitioner::RemoveTransition, false);
+ gridItem->transitionNextReposition(transitioner, QQuickItemViewTransitioner::RemoveTransition, false);
gridItem->setPosition(origRowPos, origColPos);
}
}
FxViewItem::FxViewItem(QQuickItem *i, bool own)
- : QQuickViewItem(i), ownItem(own), releaseAfterTransition(false)
+ : item(i)
+ , transitionableItem(0)
+ , ownItem(own)
+ , releaseAfterTransition(false)
{
}
FxViewItem::~FxViewItem()
{
+ delete transitionableItem;
if (ownItem && item) {
item->setParentItem(0);
item->deleteLater();
}
}
+qreal FxViewItem::itemX() const
+{
+ return transitionableItem ? transitionableItem->itemX() : item->x();
+}
+
+qreal FxViewItem::itemY() const
+{
+ return transitionableItem ? transitionableItem->itemY() : item->y();
+}
+
+void FxViewItem::moveTo(const QPointF &pos)
+{
+ if (transitionableItem)
+ transitionableItem->moveTo(pos);
+ else
+ item->setPos(pos);
+}
+
+void FxViewItem::setVisible(bool visible)
+{
+ if (!visible && transitionableItem && transitionableItem->transitionScheduledOrRunning())
+ return;
+ item->setVisible(visible);
+}
+
+QQuickItemViewTransitioner::TransitionType FxViewItem::scheduledTransitionType() const
+{
+ return transitionableItem ? transitionableItem->nextTransitionType : QQuickItemViewTransitioner::NoTransition;
+}
+
+bool FxViewItem::transitionScheduledOrRunning() const
+{
+ return transitionableItem ? transitionableItem->transitionScheduledOrRunning() : false;
+}
+
+bool FxViewItem::transitionRunning() const
+{
+ return transitionableItem ? transitionableItem->transitionRunning() : false;
+}
+
+bool FxViewItem::isPendingRemoval() const
+{
+ return transitionableItem ? transitionableItem->isPendingRemoval() : false;
+}
+
+void FxViewItem::transitionNextReposition(QQuickItemViewTransitioner *transitioner, QQuickItemViewTransitioner::TransitionType type, bool asTarget)
+{
+ if (!transitioner)
+ return;
+ if (!transitionableItem)
+ transitionableItem = new QQuickItemViewTransitionableItem(item);
+ transitioner->transitionNextReposition(transitionableItem, type, asTarget);
+}
+
+bool FxViewItem::prepareTransition(QQuickItemViewTransitioner *transitioner, const QRectF &viewBounds)
+{
+ return transitionableItem ? transitionableItem->prepareTransition(transitioner, index, viewBounds) : false;
+}
+
+void FxViewItem::startTransition(QQuickItemViewTransitioner *transitioner)
+{
+ if (transitionableItem)
+ transitionableItem->startTransition(transitioner, index);
+}
+
QQuickItemViewChangeSet::QQuickItemViewChangeSet()
: active(false)
// assume that any items moving now are moving due to the remove - if they schedule
// a different transition, that will override this one anyway
for (int i=0; i<visibleItems.count(); i++)
- transitioner->transitionNextReposition(visibleItems[i], QQuickItemViewTransitioner::RemoveTransition, false);
+ visibleItems[i]->transitionNextReposition(transitioner, QQuickItemViewTransitioner::RemoveTransition, false);
}
ChangeResult insertionPosChanges;
if (transitioner && transitioner->canTransition(QQuickItemViewTransitioner::PopulateTransition, true)) {
for (int i=0; i<visibleItems.count(); i++)
- transitioner->transitionNextReposition(visibleItems.at(i), QQuickItemViewTransitioner::PopulateTransition, true);
+ visibleItems.at(i)->transitionNextReposition(transitioner, QQuickItemViewTransitioner::PopulateTransition, true);
}
layoutVisibleItems();
repositionItemAt(movingIntoView[i].item, fromIndex, -totalInsertionResult->sizeChangesAfterVisiblePos);
else
repositionItemAt(movingIntoView[i].item, fromIndex, totalInsertionResult->sizeChangesAfterVisiblePos);
- transitioner->transitionNextReposition(movingIntoView[i].item, QQuickItemViewTransitioner::MoveTransition, true);
+ movingIntoView[i].item->transitionNextReposition(transitioner, QQuickItemViewTransitioner::MoveTransition, true);
}
}
}
} else if (item->index >= removal.index + removal.count) {
// after removed items
item->index -= removal.count;
- if (transitioner) {
- if (removal.isMove())
- transitioner->transitionNextReposition(item, QQuickItemViewTransitioner::MoveTransition, false);
- else
- transitioner->transitionNextReposition(item, QQuickItemViewTransitioner::RemoveTransition, false);
- }
+ if (removal.isMove())
+ item->transitionNextReposition(transitioner, QQuickItemViewTransitioner::MoveTransition, false);
+ else
+ item->transitionNextReposition(transitioner, QQuickItemViewTransitioner::RemoveTransition, false);
++it;
} else {
// removed item
}
if (removal.isMove()) {
currentChanges.removedItems.insert(removal.moveKey(item->index), item);
- if (transitioner)
- transitioner->transitionNextReposition(item, QQuickItemViewTransitioner::MoveTransition, true);
+ item->transitionNextReposition(transitioner, QQuickItemViewTransitioner::MoveTransition, true);
} else {
// track item so it is released later
currentChanges.removedItems.insertMulti(QQuickChangeSet::MoveKey(), item);
FxViewItem *item = *it;
item->releaseAfterTransition = true;
releasePendingTransition.append(item);
- transitioner->transitionNextReposition(item, QQuickItemViewTransitioner::RemoveTransition, true);
+ item->transitionNextReposition(transitioner, QQuickItemViewTransitioner::RemoveTransition, true);
it = removedItems->erase(it);
} else {
++it;
if (!transitioner)
return false;
- if (item->nextTransitionType == QQuickItemViewTransitioner::MoveTransition)
+ if (item->scheduledTransitionType() == QQuickItemViewTransitioner::MoveTransition)
repositionItemAt(item, item->index, 0);
if (item->prepareTransition(transitioner, viewBounds)) {
return false;
}
-void QQuickItemViewPrivate::viewItemTransitionFinished(QQuickViewItem *i)
+void QQuickItemViewPrivate::viewItemTransitionFinished(QQuickItemViewTransitionableItem *item)
{
- FxViewItem *item = static_cast<FxViewItem *>(i);
- if (item->releaseAfterTransition) {
- releasePendingTransition.removeOne(item);
- releaseItem(item);
+ for (int i=0; i<releasePendingTransition.count(); i++) {
+ if (releasePendingTransition[i]->transitionableItem == item) {
+ releaseItem(releasePendingTransition.takeAt(i));
+ return;
+ }
}
}
QT_MODULE(Quick)
-class FxViewItem : public QQuickViewItem
+class FxViewItem
{
public:
FxViewItem(QQuickItem *, bool own);
virtual ~FxViewItem();
+ qreal itemX() const;
+ qreal itemY() const;
+
+ void moveTo(const QPointF &pos);
+ void setVisible(bool visible);
+
+ QQuickItemViewTransitioner::TransitionType scheduledTransitionType() const;
+ bool transitionScheduledOrRunning() const;
+ bool transitionRunning() const;
+ bool isPendingRemoval() const;
+
+ void transitionNextReposition(QQuickItemViewTransitioner *transitioner, QQuickItemViewTransitioner::TransitionType type, bool asTarget);
+ bool prepareTransition(QQuickItemViewTransitioner *transitioner, const QRectF &viewBounds);
+ void startTransition(QQuickItemViewTransitioner *transitioner);
+
// these are positions and sizes along the current direction of scrolling/flicking
virtual qreal position() const = 0;
virtual qreal endPosition() const = 0;
virtual bool contains(qreal x, qreal y) const = 0;
+ QQuickItem *item;
+ QQuickItemViewTransitionableItem *transitionableItem;
QQuickItemViewAttached *attached;
+ int index;
bool ownItem;
bool releaseAfterTransition;
};
void prepareVisibleItemTransitions();
void prepareRemoveTransitions(QHash<QQuickChangeSet::MoveKey, FxViewItem *> *removedItems);
bool prepareNonVisibleItemTransition(FxViewItem *item, const QRectF &viewBounds);
- virtual void viewItemTransitionFinished(QQuickViewItem *item);
+ virtual void viewItemTransitionFinished(QQuickItemViewTransitionableItem *item);
int findMoveKeyIndex(QQuickChangeSet::MoveKey key, const QVector<QQuickChangeSet::Remove> &changes) const;
QQuickItemViewTransitionJob();
~QQuickItemViewTransitionJob();
- void startTransition(QQuickViewItem *item, QQuickItemViewTransitioner *transitioner, QQuickItemViewTransitioner::TransitionType type, const QPointF &to, bool isTargetItem);
+ void startTransition(QQuickItemViewTransitionableItem *item, int index, QQuickItemViewTransitioner *transitioner, QQuickItemViewTransitioner::TransitionType type, const QPointF &to, bool isTargetItem);
QQuickItemViewTransitioner *m_transitioner;
- QQuickViewItem *m_item;
+ QQuickItemViewTransitionableItem *m_item;
QPointF m_toPos;
QQuickItemViewTransitioner::TransitionType m_type;
bool m_isTarget;
m_transitioner->runningJobs.remove(this);
}
-void QQuickItemViewTransitionJob::startTransition(QQuickViewItem *item, QQuickItemViewTransitioner *transitioner, QQuickItemViewTransitioner::TransitionType type, const QPointF &to, bool isTargetItem)
+void QQuickItemViewTransitionJob::startTransition(QQuickItemViewTransitionableItem *item, int index, QQuickItemViewTransitioner *transitioner, QQuickItemViewTransitioner::TransitionType type, const QPointF &to, bool isTargetItem)
{
if (type == QQuickItemViewTransitioner::NoTransition)
return;
QQuickViewTransitionAttached *attached =
static_cast<QQuickViewTransitionAttached*>(qmlAttachedPropertiesObject<QQuickViewTransitionAttached>(trans));
if (attached) {
- attached->m_index = item->index;
+ attached->m_index = index;
attached->m_item = item->item;
attached->m_destination = to;
attached->m_targetIndexes = m_transitioner->targetIndexes(type);
return false;
}
-void QQuickItemViewTransitioner::transitionNextReposition(QQuickViewItem *item, QQuickItemViewTransitioner::TransitionType type, bool isTarget)
+void QQuickItemViewTransitioner::transitionNextReposition(QQuickItemViewTransitionableItem *item, QQuickItemViewTransitioner::TransitionType type, bool isTarget)
{
item->setNextTransition(type, isTarget);
}
-void QQuickItemViewTransitioner::addToTargetLists(QQuickItemViewTransitioner::TransitionType type, QQuickViewItem *item, int index)
+void QQuickItemViewTransitioner::addToTargetLists(QQuickItemViewTransitioner::TransitionType type, QQuickItemViewTransitionableItem *item, int index)
{
switch (type) {
case NoTransition:
return qquickitemviewtransition_emptyTargets;
}
-void QQuickItemViewTransitioner::finishedTransition(QQuickItemViewTransitionJob *job, QQuickViewItem *item)
+void QQuickItemViewTransitioner::finishedTransition(QQuickItemViewTransitionJob *job, QQuickItemViewTransitionableItem *item)
{
if (!runningJobs.contains(job))
return;
}
-QQuickViewItem::QQuickViewItem(QQuickItem *i)
+QQuickItemViewTransitionableItem::QQuickItemViewTransitionableItem(QQuickItem *i)
: item(i)
, transition(0)
, nextTransitionType(QQuickItemViewTransitioner::NoTransition)
- , index(-1)
, isTransitionTarget(false)
, nextTransitionToSet(false)
, prepared(false)
{
}
-QQuickViewItem::~QQuickViewItem()
+QQuickItemViewTransitionableItem::~QQuickItemViewTransitionableItem()
{
delete transition;
}
-qreal QQuickViewItem::itemX() const
+qreal QQuickItemViewTransitionableItem::itemX() const
{
if (nextTransitionType != QQuickItemViewTransitioner::NoTransition)
return nextTransitionToSet ? nextTransitionTo.x() : item->x();
return item->x();
}
-qreal QQuickViewItem::itemY() const
+qreal QQuickItemViewTransitionableItem::itemY() const
{
// If item is transitioning to some pos, return that dest pos.
// If item was redirected to some new pos before the current transition finished,
return item->y();
}
-void QQuickViewItem::moveTo(const QPointF &pos)
+void QQuickItemViewTransitionableItem::moveTo(const QPointF &pos)
{
if (transitionScheduledOrRunning()) {
nextTransitionTo = pos;
}
}
-void QQuickViewItem::setVisible(bool visible)
-{
- if (!visible && transitionScheduledOrRunning())
- return;
- item->setVisible(visible);
-}
-
-bool QQuickViewItem::transitionScheduledOrRunning() const
+bool QQuickItemViewTransitionableItem::transitionScheduledOrRunning() const
{
return (transition && transition->isRunning())
|| nextTransitionType != QQuickItemViewTransitioner::NoTransition;
}
-bool QQuickViewItem::transitionRunning() const
+bool QQuickItemViewTransitionableItem::transitionRunning() const
{
return (transition && transition->isRunning());
}
-bool QQuickViewItem::isPendingRemoval() const
+bool QQuickItemViewTransitionableItem::isPendingRemoval() const
{
if (nextTransitionType == QQuickItemViewTransitioner::RemoveTransition)
return isTransitionTarget;
return false;
}
-bool QQuickViewItem::prepareTransition(QQuickItemViewTransitioner *transitioner, const QRectF &viewBounds)
+bool QQuickItemViewTransitionableItem::prepareTransition(QQuickItemViewTransitioner *transitioner, int index, const QRectF &viewBounds)
{
bool doTransition = false;
return doTransition;
}
-void QQuickViewItem::startTransition(QQuickItemViewTransitioner *transitioner)
+void QQuickItemViewTransitionableItem::startTransition(QQuickItemViewTransitioner *transitioner, int index)
{
if (nextTransitionType == QQuickItemViewTransitioner::NoTransition)
return;
if (!nextTransitionToSet)
moveTo(item->pos());
- transition->startTransition(this, transitioner, nextTransitionType, nextTransitionTo, isTransitionTarget);
+ transition->startTransition(this, index, transitioner, nextTransitionType, nextTransitionTo, isTransitionTarget);
nextTransitionType = QQuickItemViewTransitioner::NoTransition;
prepared = false;
}
-void QQuickViewItem::setNextTransition(QQuickItemViewTransitioner::TransitionType type, bool isTargetItem)
+void QQuickItemViewTransitionableItem::setNextTransition(QQuickItemViewTransitioner::TransitionType type, bool isTargetItem)
{
// Don't reset nextTransitionToSet - once it is set, it cannot be changed
// until the animation finishes since the itemX() and itemY() may be used
isTransitionTarget = isTargetItem;
}
-bool QQuickViewItem::transitionWillChangePosition() const
+bool QQuickItemViewTransitionableItem::transitionWillChangePosition() const
{
if (transitionRunning() && transition->m_toPos != nextTransitionTo)
return true;
return nextTransitionTo != item->pos();
}
-void QQuickViewItem::finishedTransition()
+void QQuickItemViewTransitionableItem::finishedTransition()
{
nextTransitionToSet = false;
nextTransitionTo = QPointF();
}
-void QQuickViewItem::resetTransitionData()
+void QQuickItemViewTransitionableItem::resetTransitionData()
{
nextTransitionType = QQuickItemViewTransitioner::NoTransition;
isTransitionTarget = false;
QT_MODULE(Quick)
class QQuickItem;
-class QQuickViewItem;
+class QQuickItemViewTransitionableItem;
class QQuickItemViewTransitionJob;
QQuickItemViewTransitionChangeListener() {}
virtual ~QQuickItemViewTransitionChangeListener() {}
- virtual void viewItemTransitionFinished(QQuickViewItem *item) = 0;
+ virtual void viewItemTransitionFinished(QQuickItemViewTransitionableItem *item) = 0;
};
virtual ~QQuickItemViewTransitioner();
bool canTransition(QQuickItemViewTransitioner::TransitionType type, bool asTarget) const;
- void transitionNextReposition(QQuickViewItem *item, QQuickItemViewTransitioner::TransitionType type, bool isTarget);
+ void transitionNextReposition(QQuickItemViewTransitionableItem *item, QQuickItemViewTransitioner::TransitionType type, bool isTarget);
- void addToTargetLists(QQuickItemViewTransitioner::TransitionType type, QQuickViewItem *item, int index);
+ void addToTargetLists(QQuickItemViewTransitioner::TransitionType type, QQuickItemViewTransitionableItem *item, int index);
void resetTargetLists();
QQuickTransition *transitionObject(QQuickItemViewTransitioner::TransitionType type, bool asTarget);
QQuickItemViewTransitionChangeListener *changeListener;
bool usePopulateTransition;
- void finishedTransition(QQuickItemViewTransitionJob *job, QQuickViewItem *item);
+ void finishedTransition(QQuickItemViewTransitionJob *job, QQuickItemViewTransitionableItem *item);
};
/*
- An item in a view, that can be transitioned using QQuickViewTransitionJob.
+ An item that can be transitioned using QQuickViewTransitionJob.
*/
-class QQuickViewItem
+class QQuickItemViewTransitionableItem
{
public:
- QQuickViewItem(QQuickItem *i);
- virtual ~QQuickViewItem();
+ QQuickItemViewTransitionableItem(QQuickItem *i);
+ virtual ~QQuickItemViewTransitionableItem();
qreal itemX() const;
qreal itemY() const;
void moveTo(const QPointF &pos);
- void setVisible(bool visible);
bool transitionScheduledOrRunning() const;
bool transitionRunning() const;
bool isPendingRemoval() const;
- bool prepareTransition(QQuickItemViewTransitioner *transitioner, const QRectF &viewBounds);
- void startTransition(QQuickItemViewTransitioner *transitioner);
+ bool prepareTransition(QQuickItemViewTransitioner *transitioner, int index, const QRectF &viewBounds);
+ void startTransition(QQuickItemViewTransitioner *transitioner, int index);
QPointF nextTransitionTo;
QQuickItem *item;
QQuickItemViewTransitionJob *transition;
QQuickItemViewTransitioner::TransitionType nextTransitionType;
- int index;
bool isTransitionTarget;
bool nextTransitionToSet;
bool prepared;
insertResult->changedFirstItem = true;
if (!change.isMove()) {
addedItems->append(item);
- if (transitioner)
- transitioner->transitionNextReposition(item, QQuickItemViewTransitioner::AddTransition, true);
+ item->transitionNextReposition(transitioner, QQuickItemViewTransitioner::AddTransition, true);
}
insertResult->sizeChangesBeforeVisiblePos += item->size() + spacing;
pos -= item->size() + spacing;
movingIntoView->append(MovedItem(item, change.moveKey(item->index)));
} else {
addedItems->append(item);
- if (transitioner)
- transitioner->transitionNextReposition(item, QQuickItemViewTransitioner::AddTransition, true);
+ item->transitionNextReposition(transitioner, QQuickItemViewTransitioner::AddTransition, true);
}
insertResult->sizeChangesAfterVisiblePos += item->size() + spacing;
pos += item->size() + spacing;
for (; index < visibleItems.count(); ++index) {
FxViewItem *item = visibleItems.at(index);
- if (item->index != -1)
+ if (item->index != -1) {
item->index += count;
- if (transitioner) {
if (change.isMove())
- transitioner->transitionNextReposition(item, QQuickItemViewTransitioner::MoveTransition, false);
+ item->transitionNextReposition(transitioner, QQuickItemViewTransitioner::MoveTransition, false);
else
- transitioner->transitionNextReposition(item, QQuickItemViewTransitioner::AddTransition, false);
+ item->transitionNextReposition(transitioner, QQuickItemViewTransitioner::AddTransition, false);
}
}
if (!listItem->transitionScheduledOrRunning()) {
qreal pos = listItem->position();
listItem->setPosition(pos - sizeRemoved);
- transitioner->transitionNextReposition(listItem, QQuickItemViewTransitioner::RemoveTransition, false);
+ listItem->transitionNextReposition(transitioner, QQuickItemViewTransitioner::RemoveTransition, false);
listItem->setPosition(pos);
}
}
otherPrivate->removeItemChangeListener(this, watchedChanges);
}
+
+QQuickBasePositioner::PositionedItem::PositionedItem(QQuickItem *i)
+ : item(i)
+ , transitionableItem(0)
+ , index(-1)
+ , isNew(false)
+ , isVisible(true)
+{
+}
+
+QQuickBasePositioner::PositionedItem::~PositionedItem()
+{
+ delete transitionableItem;
+}
+
+qreal QQuickBasePositioner::PositionedItem::itemX() const
+{
+ return transitionableItem ? transitionableItem->itemX() : item->x();
+}
+
+qreal QQuickBasePositioner::PositionedItem::itemY() const
+{
+ return transitionableItem ? transitionableItem->itemY() : item->y();
+}
+
+void QQuickBasePositioner::PositionedItem::moveTo(const QPointF &pos)
+{
+ if (transitionableItem)
+ transitionableItem->moveTo(pos);
+ else
+ item->setPos(pos);
+}
+
+void QQuickBasePositioner::PositionedItem::transitionNextReposition(QQuickItemViewTransitioner *transitioner, QQuickItemViewTransitioner::TransitionType type, bool asTarget)
+{
+ if (!transitioner)
+ return;
+ if (!transitionableItem)
+ transitionableItem = new QQuickItemViewTransitionableItem(item);
+ transitioner->transitionNextReposition(transitionableItem, type, asTarget);
+}
+
+bool QQuickBasePositioner::PositionedItem::prepareTransition(QQuickItemViewTransitioner *transitioner, const QRectF &viewBounds)
+{
+ return transitionableItem ? transitionableItem->prepareTransition(transitioner, index, viewBounds) : false;
+}
+
+void QQuickBasePositioner::PositionedItem::startTransition(QQuickItemViewTransitioner *transitioner)
+{
+ if (transitionableItem)
+ transitionableItem->startTransition(transitioner, index);
+}
+
+
QQuickBasePositioner::QQuickBasePositioner(PositionerType at, QQuickItem *parent)
: QQuickImplicitSizeItem(*(new QQuickBasePositionerPrivate), parent)
{
if (addedIndex < 0)
addedIndex = posItem.index;
PositionedItem *theItem = &positionedItems[positionedItems.count()-1];
- d->transitioner->transitionNextReposition(theItem,
- QQuickItemViewTransitioner::AddTransition, true);
+ theItem->transitionNextReposition(d->transitioner, QQuickItemViewTransitioner::AddTransition, true);
}
}
} else {
if (d->transitioner) {
if (addedIndex < 0)
addedIndex = item->index;
- d->transitioner->transitionNextReposition(&positionedItems[positionedItems.count()-1],
- QQuickItemViewTransitioner::AddTransition, true);
+ positionedItems[positionedItems.count()-1].transitionNextReposition(d->transitioner, QQuickItemViewTransitioner::AddTransition, true);
}
} else {
item->isNew = false;
for (int i=0; i<positionedItems.count(); i++) {
if (!positionedItems[i].isNew) {
if (addedIndex >= 0) {
- d->transitioner->transitionNextReposition(&positionedItems[i], QQuickItemViewTransitioner::AddTransition, false);
+ positionedItems[i].transitionNextReposition(d->transitioner, QQuickItemViewTransitioner::AddTransition, false);
} else {
// just queue the item for a move-type displace - if the item hasn't
// moved anywhere, it won't be transitioned anyway
- d->transitioner->transitionNextReposition(&positionedItems[i], QQuickItemViewTransitioner::MoveTransition, false);
+ positionedItems[i].transitionNextReposition(d->transitioner, QQuickItemViewTransitioner::MoveTransition, false);
}
}
}
virtual void doPositioning(QSizeF *contentSize)=0;
virtual void reportConflictingAnchors()=0;
- class PositionedItem : public QQuickViewItem
+ class PositionedItem
{
public :
- PositionedItem(QQuickItem *i) : QQuickViewItem(i), isNew(false), isVisible(true) {}
+ PositionedItem(QQuickItem *i);
+ ~PositionedItem();
bool operator==(const PositionedItem &other) const { return other.item == item; }
+ qreal itemX() const;
+ qreal itemY() const;
+
+ void moveTo(const QPointF &pos);
+
+ void transitionNextReposition(QQuickItemViewTransitioner *transitioner, QQuickItemViewTransitioner::TransitionType type, bool asTarget);
+ bool prepareTransition(QQuickItemViewTransitioner *transitioner, const QRectF &viewBounds);
+ void startTransition(QQuickItemViewTransitioner *transitioner);
+
+ QQuickItem *item;
+ QQuickItemViewTransitionableItem *transitionableItem;
+ int index;
bool isNew;
bool isVisible;
};