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

equal deleted inserted replaced

-:5dc02b23752f
+:3e2da88830cd
 emit pageChanged();
 }
 QDeclarativeFlickablePrivate::QDeclarativeFlickablePrivate()
-: viewport(new QDeclarativeItem)
+: contentItem(new QDeclarativeItem)
 , hData(this, &QDeclarativeFlickablePrivate::setRoundedViewportX)
 , vData(this, &QDeclarativeFlickablePrivate::setRoundedViewportY)
 , flickingHorizontally(false), flickingVertically(false)
 , hMoved(false), vMoved(false)
 , movingHorizontally(false), movingVertically(false)
 }
 void QDeclarativeFlickablePrivate::init()
 {
 Q_Q(QDeclarativeFlickable);
-QDeclarative_setParent_noEvent(viewport, q);
+QDeclarative_setParent_noEvent(contentItem, q);
-viewport->setParentItem(q);
+contentItem->setParentItem(q);
 static int timelineUpdatedIdx = -1;
 static int timelineCompletedIdx = -1;
 static int flickableTickedIdx = -1;
 static int flickableMovementEndingIdx = -1;
 if (timelineUpdatedIdx == -1) {
 q, flickableTickedIdx, Qt::DirectConnection);
 QMetaObject::connect(&timeline, timelineCompletedIdx,
 q, flickableMovementEndingIdx, Qt::DirectConnection);
 q->setAcceptedMouseButtons(Qt::LeftButton);
 q->setFiltersChildEvents(true);
-QDeclarativeItemPrivate *viewportPrivate = static_cast<QDeclarativeItemPrivate*>(QGraphicsItemPrivate::get(viewport));
+QDeclarativeItemPrivate *viewportPrivate = static_cast<QDeclarativeItemPrivate*>(QGraphicsItemPrivate::get(contentItem));
 viewportPrivate->addItemChangeListener(this, QDeclarativeItemPrivate::Geometry);
+lastPosTime.invalidate();
 }
 /*
 Returns the amount to overshoot by given a velocity.
 Will be roughly in range 0 - size/4
 }
 void QDeclarativeFlickablePrivate::itemGeometryChanged(QDeclarativeItem *item, const QRectF &newGeom, const QRectF &oldGeom)
 {
 Q_Q(QDeclarativeFlickable);
-if (item == viewport) {
+if (item == contentItem) {
 if (newGeom.x() != oldGeom.x())
 emit q->contentXChanged();
 if (newGeom.y() != oldGeom.y())
 emit q->contentYChanged();
 }
 \inherits Item
 Flickable places its children on a surface that can be dragged and flicked.
 \code
+import Qt 4.7
 Flickable {
 width: 200; height: 200
 contentWidth: image.width; contentHeight: image.height
 Image { id: image; source: "bigImage.png" }
 void QDeclarativeFlickable::ticked()
 {
 viewportMoved();
 }
-QDeclarativeItem *QDeclarativeFlickable::viewport()
+/*!
-{
+\qmlproperty Item Flickable::contentItem
-Q_D(QDeclarativeFlickable);
-return d->viewport;
+The internal item that contains the Items to be moved in the Flickable.
+Items declared as children of a Flickable are automatically parented to the Flickable's contentItem.
+Items created dynamically need to be explicitly parented to the \e contentItem:
+\code
+Flickable {
+id: myFlickable
+function addItem(file) {
+var component = Qt.createComponent(file)
+component.createObject(myFlickable.contentItem);
+}
+}
+\endcode
+*/
+QDeclarativeItem *QDeclarativeFlickable::contentItem()
+{
+Q_D(QDeclarativeFlickable);
+return d->contentItem;
 }
 QDeclarativeFlickableVisibleArea *QDeclarativeFlickable::visibleArea()
 {
 Q_D(QDeclarativeFlickable);
 Q_D(QDeclarativeFlickable);
 if (direction != d->flickableDirection) {
 d->flickableDirection = direction;
 emit flickableDirectionChanged();
 }
-}
-QDeclarativeFlickable::FlickableDirection QDeclarativeFlickable::flickDirection() const
-{
-qmlInfo(this) << "'flickDirection' is deprecated. Please use 'flickableDirection' instead.";
-return flickableDirection();
-}
-void QDeclarativeFlickable::setFlickDirection(FlickableDirection direction)
-{
-qmlInfo(this) << "'flickDirection' is deprecated. Please use 'flickableDirection' instead.";
-setFlickableDirection(direction);
 }
 void QDeclarativeFlickablePrivate::handleMousePressEvent(QGraphicsSceneMouseEvent *event)
 {
 if (interactive && timeline.isActive() && (qAbs(hData.velocity) > 10 || qAbs(vData.velocity) > 10))
 }
 void QDeclarativeFlickablePrivate::handleMouseMoveEvent(QGraphicsSceneMouseEvent *event)
 {
 Q_Q(QDeclarativeFlickable);
-if (!interactive || lastPosTime.isNull())
+if (!interactive || !lastPosTime.isValid())
 return;
 bool rejectY = false;
 bool rejectX = false;
 if (q->yflick()) {
 {
 Q_Q(QDeclarativeFlickable);
 stealMouse = false;
 q->setKeepMouseGrab(false);
 pressed = false;
-if (lastPosTime.isNull())
+if (!lastPosTime.isValid())
 return;
 if (QDeclarativeItemPrivate::elapsed(lastPosTime) > 100) {
 // if we drag then pause before release we should not cause a flick.
 hData.velocity = 0.0;
 flickX(velocity);
 } else {
 fixupX();
 }
-lastPosTime = QTime();
+lastPosTime.invalidate();
 if (!timeline.isActive())
 q->movementEnding();
 }
 }
 }
 void QDeclarativeFlickablePrivate::setRoundedViewportX(qreal x)
 {
-viewport->setX(qRound(x));
+contentItem->setX(qRound(x));
 }
 void QDeclarativeFlickablePrivate::setRoundedViewportY(qreal y)
 {
-viewport->setY(qRound(y));
+contentItem->setY(qRound(y));
 }
 void QDeclarativeFlickable::timerEvent(QTimerEvent *event)
 {
 Q_D(QDeclarativeFlickable);
 if (event->timerId() == d->delayedPressTimer.timerId()) {
 d->delayedPressTimer.stop();
 if (d->delayedPressEvent) {
 QDeclarativeItem *grabber = scene() ? qobject_cast<QDeclarativeItem*>(scene()->mouseGrabberItem()) : 0;
-if (!grabber || grabber != this)
+if (!grabber || grabber != this) {
-scene()->sendEvent(d->delayedPressTarget, d->delayedPressEvent);
+// We replay the mouse press but the grabber we had might not be interessted by the event (e.g. overlay)
+// so we reset the grabber
+if (scene()->mouseGrabberItem() == d->delayedPressTarget)
+d->delayedPressTarget->ungrabMouse();
+//Use the event handler that will take care of finding the proper item to propagate the event
+QApplication::sendEvent(scene(), d->delayedPressEvent);
+}
 delete d->delayedPressEvent;
 d->delayedPressEvent = 0;
 }
 }
 }
 }
 void QDeclarativeFlickable::viewportMoved()
 {
 Q_D(QDeclarativeFlickable);
-int elapsed = QDeclarativeItemPrivate::restart(d->velocityTime);
-if (!elapsed)
-return;
 qreal prevY = d->lastFlickablePosition.x();
 qreal prevX = d->lastFlickablePosition.y();
 d->velocityTimeline.clear();
 if (d->pressed) {
-qreal horizontalVelocity = (prevX - d->hData.move.value()) * 1000 / elapsed;
+int elapsed = QDeclarativeItemPrivate::restart(d->velocityTime);
-qreal verticalVelocity = (prevY - d->vData.move.value()) * 1000 / elapsed;
+if (elapsed > 0) {
-d->velocityTimeline.move(d->hData.smoothVelocity, horizontalVelocity, d->reportedVelocitySmoothing);
+qreal horizontalVelocity = (prevX - d->hData.move.value()) * 1000 / elapsed;
-d->velocityTimeline.move(d->hData.smoothVelocity, 0, d->reportedVelocitySmoothing);
+qreal verticalVelocity = (prevY - d->vData.move.value()) * 1000 / elapsed;
-d->velocityTimeline.move(d->vData.smoothVelocity, verticalVelocity, d->reportedVelocitySmoothing);
+d->velocityTimeline.move(d->hData.smoothVelocity, horizontalVelocity, d->reportedVelocitySmoothing);
-d->velocityTimeline.move(d->vData.smoothVelocity, 0, d->reportedVelocitySmoothing);
+d->velocityTimeline.move(d->hData.smoothVelocity, 0, d->reportedVelocitySmoothing);
+d->velocityTimeline.move(d->vData.smoothVelocity, verticalVelocity, d->reportedVelocitySmoothing);
+d->velocityTimeline.move(d->vData.smoothVelocity, 0, d->reportedVelocitySmoothing);
+}
 } else {
 if (d->timeline.time() > d->vTime) {
 qreal horizontalVelocity = (prevX - d->hData.move.value()) * 1000 / (d->timeline.time() - d->vTime);
 qreal verticalVelocity = (prevY - d->vData.move.value()) * 1000 / (d->timeline.time() - d->vTime);
 d->hData.smoothVelocity.setValue(horizontalVelocity);
 QDeclarativeItem::geometryChanged(newGeometry, oldGeometry);
 bool changed = false;
 if (newGeometry.width() != oldGeometry.width()) {
 if (d->hData.viewSize < 0) {
-d->viewport->setWidth(width());
+d->contentItem->setWidth(width());
 emit contentWidthChanged();
 }
 }
 if (newGeometry.height() != oldGeometry.height()) {
 if (d->vData.viewSize < 0) {
-d->viewport->setHeight(height());
+d->contentItem->setHeight(height());
 emit contentHeightChanged();
 }
 }
 if (changed)
 void QDeclarativeFlickablePrivate::data_append(QDeclarativeListProperty<QObject> *prop, QObject *o)
 {
 QDeclarativeItem *i = qobject_cast<QDeclarativeItem *>(o);
 if (i)
-i->setParentItem(static_cast<QDeclarativeFlickablePrivate*>(prop->data)->viewport);
+i->setParentItem(static_cast<QDeclarativeFlickablePrivate*>(prop->data)->contentItem);
 else
 o->setParent(prop->object);
 }
 QDeclarativeListProperty<QObject> QDeclarativeFlickable::flickableData()
 }
 QDeclarativeListProperty<QGraphicsObject> QDeclarativeFlickable::flickableChildren()
 {
 Q_D(QDeclarativeFlickable);
-return QGraphicsItemPrivate::get(d->viewport)->childrenList();
+return QGraphicsItemPrivate::get(d->contentItem)->childrenList();
-}
-bool QDeclarativeFlickable::overShoot() const
-{
-Q_D(const QDeclarativeFlickable);
-return d->boundsBehavior == DragAndOvershootBounds;
-}
-void QDeclarativeFlickable::setOverShoot(bool o)
-{
-Q_D(QDeclarativeFlickable);
-if ((o && d->boundsBehavior == DragAndOvershootBounds)
-|| (!o && d->boundsBehavior == StopAtBounds))
-return;
-qmlInfo(this) << "overshoot is deprecated and will be removed imminently - use boundsBehavior.";
-d->boundsBehavior = o ? DragAndOvershootBounds : StopAtBounds;
-emit boundsBehaviorChanged();
-emit overShootChanged();
 }
 /*!
 \qmlproperty enumeration Flickable::boundsBehavior
 This property holds whether the surface may be dragged
 rather than a hard physical boundary.
 The \c boundsBehavior can be one of:
 \list
-\o \e Flickable.StopAtBounds - the contents can not be dragged beyond the boundary
+\o Flickable.StopAtBounds - the contents can not be dragged beyond the boundary
 of the flickable, and flicks will not overshoot.
-\o \e Flickable.DragOverBounds - the contents can be dragged beyond the boundary
+\o Flickable.DragOverBounds - the contents can be dragged beyond the boundary
 of the Flickable, but flicks will not overshoot.
-\o \e Flickable.DragAndOvershootBounds (default) - the contents can be dragged
+\o Flickable.DragAndOvershootBounds (default) - the contents can be dragged
 beyond the boundary of the Flickable, and can overshoot the
 boundary when flicked.
 \endlist
 */
 QDeclarativeFlickable::BoundsBehavior QDeclarativeFlickable::boundsBehavior() const
 Q_D(QDeclarativeFlickable);
 if (b == d->boundsBehavior)
 return;
 d->boundsBehavior = b;
 emit boundsBehaviorChanged();
-emit overShootChanged();
 }
 /*!
 \qmlproperty int Flickable::contentWidth
 \qmlproperty int Flickable::contentHeight
 Q_D(QDeclarativeFlickable);
 if (d->hData.viewSize == w)
 return;
 d->hData.viewSize = w;
 if (w < 0)
-d->viewport->setWidth(width());
+d->contentItem->setWidth(width());
 else
-d->viewport->setWidth(w);
+d->contentItem->setWidth(w);
 // Make sure that we're entirely in view.
 if (!d->pressed && !d->movingHorizontally && !d->movingVertically) {
 int oldDuration = d->fixupDuration;
 d->fixupDuration = 0;
 d->fixupX();
 Q_D(QDeclarativeFlickable);
 if (d->vData.viewSize == h)
 return;
 d->vData.viewSize = h;
 if (h < 0)
-d->viewport->setHeight(height());
+d->contentItem->setHeight(height());
 else
-d->viewport->setHeight(h);
+d->contentItem->setHeight(h);
 // Make sure that we're entirely in view.
 if (!d->pressed && !d->movingHorizontally && !d->movingVertically) {
 int oldDuration = d->fixupDuration;
 d->fixupDuration = 0;
 d->fixupY();
 if (d->delayedPressEvent)
 return false;
 d->handleMousePressEvent(&mouseEvent);
 d->captureDelayedPress(event);
+stealThisEvent = d->stealMouse;   // Update stealThisEvent in case changed by function call above
 break;
 case QEvent::GraphicsSceneMouseRelease:
 if (d->delayedPressEvent) {
-scene()->sendEvent(d->delayedPressTarget, d->delayedPressEvent);
+// We replay the mouse press but the grabber we had might not be interessted by the event (e.g. overlay)
+// so we reset the grabber
+if (s->mouseGrabberItem() == d->delayedPressTarget)
+d->delayedPressTarget->ungrabMouse();
+//Use the event handler that will take care of finding the proper item to propagate the event
+QApplication::sendEvent(scene(), d->delayedPressEvent);
 d->clearDelayedPress();
+// We send the release
+scene()->sendEvent(s->mouseGrabberItem(), event);
+// And the event has been consumed
+return true;
 }
 d->handleMouseReleaseEvent(&mouseEvent);
 break;
 default:
 break;
 d->clearDelayedPress();
 grabMouse();
 }
 return stealThisEvent || d->delayedPressEvent;
-} else if (!d->lastPosTime.isNull()) {
+} else if (d->lastPosTime.isValid()) {
-d->lastPosTime = QTime();
+d->lastPosTime.invalidate();
 }
 if (mouseEvent.type() == QEvent::GraphicsSceneMouseRelease) {
 d->clearDelayedPress();
 d->stealMouse = false;
 }
 /*!
 \qmlproperty int Flickable::pressDelay
 This property holds the time to delay (ms) delivering a press to
 children of the Flickable.  This can be useful where reacting
-to a press before a flicking action has undesireable effects.
+to a press before a flicking action has undesirable effects.
 If the flickable is dragged/flicked before the delay times out
 the press event will not be delivered.  If the button is released
 within the timeout, both the press and release will be delivered.
 */

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