#include "qquickcanvas_p.h"
#include "qquickevents_p_p.h"
+#include <QtQuick/private/qquicktransition_p.h>
#include <private/qqmlglobal_p.h>
#include <QtQml/qqmlinfo.h>
}
+class QQuickFlickableReboundTransition : public QQuickTransitionManager
+{
+public:
+ QQuickFlickableReboundTransition(QQuickFlickable *f, const QString &name)
+ : flickable(f), axisData(0), propName(name), active(false)
+ {
+ }
+
+ ~QQuickFlickableReboundTransition()
+ {
+ flickable = 0;
+ }
+
+ bool startTransition(QQuickFlickablePrivate::AxisData *data, qreal toPos) {
+ QQuickFlickablePrivate *fp = QQuickFlickablePrivate::get(flickable);
+ if (!fp->rebound || !fp->rebound->enabled())
+ return false;
+ active = true;
+ axisData = data;
+ axisData->transitionTo = toPos;
+ axisData->transitionToSet = true;
+
+ actions.clear();
+ actions << QQuickAction(fp->contentItem, propName, toPos);
+ QQuickTransitionManager::transition(actions, fp->rebound, fp->contentItem);
+ return true;
+ }
+
+ bool isActive() const {
+ return active;
+ }
+
+ void stopTransition() {
+ if (!flickable || !isRunning())
+ return;
+ QQuickFlickablePrivate *fp = QQuickFlickablePrivate::get(flickable);
+ if (axisData == &fp->hData)
+ axisData->move.setValue(-flickable->contentX());
+ else
+ axisData->move.setValue(-flickable->contentY());
+ cancel();
+ active = false;
+ }
+
+protected:
+ virtual void finished() {
+ if (!flickable)
+ return;
+ axisData->move.setValue(axisData->transitionTo);
+ QQuickFlickablePrivate *fp = QQuickFlickablePrivate::get(flickable);
+ active = false;
+
+ if (!fp->hData.transitionToBounds->isActive()
+ && !fp->vData.transitionToBounds->isActive()) {
+ flickable->movementEnding();
+ }
+ }
+
+private:
+ QQuickStateOperation::ActionList actions;
+ QQuickFlickable *flickable;
+ QQuickFlickablePrivate::AxisData *axisData;
+ QString propName;
+ bool active;
+};
+
+QQuickFlickablePrivate::AxisData::~AxisData()
+{
+ delete transitionToBounds;
+}
+
+
QQuickFlickablePrivate::QQuickFlickablePrivate()
: contentItem(new QQuickItem)
, hData(this, &QQuickFlickablePrivate::setViewportX)
, flickBoost(1.0), fixupMode(Normal), vTime(0), visibleArea(0)
, flickableDirection(QQuickFlickable::AutoFlickDirection)
, boundsBehavior(QQuickFlickable::DragAndOvershootBounds)
+ , rebound(0)
{
}
QQml_setParent_noEvent(contentItem, q);
contentItem->setParentItem(q);
qmlobject_connect(&timeline, QQuickTimeLine, SIGNAL(completed()),
- q, QQuickFlickable, SLOT(movementEnding()))
+ q, QQuickFlickable, SLOT(timelineCompleted()))
q->setAcceptedMouseButtons(Qt::LeftButton);
q->setFiltersChildMouseEvents(true);
QQuickItemPrivate *viewportPrivate = QQuickItemPrivate::get(contentItem);
dist = -target + data.move.value();
accel = v2 / (2.0f * qAbs(dist));
- timeline.reset(data.move);
+ resetTimeline(data);
if (boundsBehavior == QQuickFlickable::DragAndOvershootBounds)
timeline.accel(data.move, v, accel);
else
return !vData.flicking && q->yflick();
return false;
} else {
- timeline.reset(data.move);
+ resetTimeline(data);
fixup(data, minExtent, maxExtent);
return false;
}
fixup(vData, q->minYExtent(), q->maxYExtent());
}
+void QQuickFlickablePrivate::adjustContentPos(AxisData &data, qreal toPos)
+{
+ Q_Q(QQuickFlickable);
+ switch (fixupMode) {
+ case Immediate:
+ timeline.set(data.move, toPos);
+ break;
+ case ExtentChanged:
+ // The target has changed. Don't start from the beginning; just complete the
+ // second half of the animation using the new extent.
+ timeline.move(data.move, toPos, QEasingCurve(QEasingCurve::OutExpo), 3*fixupDuration/4);
+ data.fixingUp = true;
+ break;
+ default: {
+ if (data.transitionToBounds && data.transitionToBounds->startTransition(&data, toPos)) {
+ q->movementStarting();
+ data.fixingUp = true;
+ } else {
+ qreal dist = toPos - data.move;
+ timeline.move(data.move, toPos - dist/2, QEasingCurve(QEasingCurve::InQuad), fixupDuration/4);
+ timeline.move(data.move, toPos, QEasingCurve(QEasingCurve::OutExpo), 3*fixupDuration/4);
+ data.fixingUp = true;
+ }
+ }
+ }
+}
+
+void QQuickFlickablePrivate::resetTimeline(AxisData &data)
+{
+ timeline.reset(data.move);
+ if (data.transitionToBounds)
+ data.transitionToBounds->stopTransition();
+}
+
+void QQuickFlickablePrivate::clearTimeline()
+{
+ timeline.clear();
+ if (hData.transitionToBounds)
+ hData.transitionToBounds->stopTransition();
+ if (vData.transitionToBounds)
+ vData.transitionToBounds->stopTransition();
+}
+
void QQuickFlickablePrivate::fixup(AxisData &data, qreal minExtent, qreal maxExtent)
{
if (data.move.value() > minExtent || maxExtent > minExtent) {
- timeline.reset(data.move);
+ resetTimeline(data);
if (data.move.value() != minExtent) {
- switch (fixupMode) {
- case Immediate:
- timeline.set(data.move, minExtent);
- break;
- case ExtentChanged:
- // The target has changed. Don't start from the beginning; just complete the
- // second half of the animation using the new extent.
- timeline.move(data.move, minExtent, QEasingCurve(QEasingCurve::OutExpo), 3*fixupDuration/4);
- data.fixingUp = true;
- break;
- default: {
- qreal dist = minExtent - data.move;
- timeline.move(data.move, minExtent - dist/2, QEasingCurve(QEasingCurve::InQuad), fixupDuration/4);
- timeline.move(data.move, minExtent, QEasingCurve(QEasingCurve::OutExpo), 3*fixupDuration/4);
- data.fixingUp = true;
- }
- }
+ adjustContentPos(data, minExtent);
}
} else if (data.move.value() < maxExtent) {
- timeline.reset(data.move);
- switch (fixupMode) {
- case Immediate:
- timeline.set(data.move, maxExtent);
- break;
- case ExtentChanged:
- // The target has changed. Don't start from the beginning; just complete the
- // second half of the animation using the new extent.
- timeline.move(data.move, maxExtent, QEasingCurve(QEasingCurve::OutExpo), 3*fixupDuration/4);
- data.fixingUp = true;
- break;
- default: {
- qreal dist = maxExtent - data.move;
- timeline.move(data.move, maxExtent - dist/2, QEasingCurve(QEasingCurve::InQuad), fixupDuration/4);
- timeline.move(data.move, maxExtent, QEasingCurve(QEasingCurve::OutExpo), 3*fixupDuration/4);
- data.fixingUp = true;
- }
- }
+ resetTimeline(data);
+ adjustContentPos(data, maxExtent);
} else if (qRound(data.move.value()) != data.move.value()) {
// We could animate, but since it is less than 0.5 pixel it's probably not worthwhile.
- timeline.reset(data.move);
+ resetTimeline(data);
qreal val = data.move.value();
if (qAbs(qRound(val) - val) < 0.25) // round small differences
val = qRound(val);
{
Q_D(QQuickFlickable);
d->hData.explicitValue = true;
- d->timeline.reset(d->hData.move);
+ d->resetTimeline(d->hData);
d->vTime = d->timeline.time();
movementEnding(true, false);
if (-pos != d->hData.move.value())
{
Q_D(QQuickFlickable);
d->vData.explicitValue = true;
- d->timeline.reset(d->vData.move);
+ d->resetTimeline(d->vData);
d->vTime = d->timeline.time();
movementEnding(false, true);
if (-pos != d->vData.move.value())
if (interactive != d->interactive) {
d->interactive = interactive;
if (!interactive && (d->hData.flicking || d->vData.flicking)) {
- d->timeline.clear();
+ d->clearTimeline();
d->vTime = d->timeline.time();
d->hData.flicking = false;
d->vData.flicking = false;
}
q->setKeepMouseGrab(stealMouse);
pressed = true;
+ if (hData.transitionToBounds)
+ hData.transitionToBounds->stopTransition();
+ if (vData.transitionToBounds)
+ vData.transitionToBounds->stopTransition();
if (!hData.fixingUp)
- timeline.reset(hData.move);
+ resetTimeline(hData);
if (!vData.fixingUp)
- timeline.reset(vData.move);
+ resetTimeline(vData);
+
hData.reset();
vData.reset();
hData.dragMinBound = q->minXExtent();
bool stealY = stealMouse;
bool stealX = stealMouse;
+ bool prevHMoved = hMoved;
+ bool prevVMoved = vMoved;
+
qint64 elapsedSincePress = computeCurrentTime(event) - lastPressTime;
if (q->yflick()) {
qreal dy = event->localPos().y() - pressPos.y();
}
}
if (!rejectY && stealMouse && dy != 0.0) {
- timeline.clear();
+ clearTimeline();
vData.move.setValue(newY);
vMoved = true;
}
}
}
if (!rejectX && stealMouse && dx != 0.0) {
- timeline.clear();
+ clearTimeline();
hData.move.setValue(newX);
hMoved = true;
}
hData.velocity = 0;
}
- if (hMoved || vMoved) {
+ if ((hMoved && !prevHMoved) || (vMoved && !prevVMoved)) {
draggingStarting();
q->movementStarting();
}
}
flickingStarted(flickedH, flickedV);
- if (!timeline.isActive())
+ if (!isViewMoving())
q->movementEnding();
}
: maxYExtent() - d->vData.move.value();
d->vData.inOvershoot = true;
qreal maxDistance = d->overShootDistance(height()) - overBound;
- d->timeline.reset(d->vData.move);
+ d->resetTimeline(d->vData);
if (maxDistance > 0)
d->timeline.accel(d->vData.move, -d->vData.smoothVelocity.value(), d->deceleration*QML_FLICK_OVERSHOOTFRICTION, maxDistance);
d->timeline.callback(QQuickTimeLineCallback(&d->vData.move, d->fixupY_callback, d));
: maxXExtent() - d->hData.move.value();
d->hData.inOvershoot = true;
qreal maxDistance = d->overShootDistance(width()) - overBound;
- d->timeline.reset(d->hData.move);
+ d->resetTimeline(d->hData);
if (maxDistance > 0)
d->timeline.accel(d->hData.move, -d->hData.smoothVelocity.value(), d->deceleration*QML_FLICK_OVERSHOOTFRICTION, maxDistance);
d->timeline.callback(QQuickTimeLineCallback(&d->hData.move, d->fixupX_callback, d));
void QQuickFlickable::cancelFlick()
{
Q_D(QQuickFlickable);
- d->timeline.reset(d->hData.move);
- d->timeline.reset(d->vData.move);
+ d->resetTimeline(d->hData);
+ d->resetTimeline(d->vData);
movementEnding();
}
}
/*!
+ \qmlproperty Transition QtQuick2::Flickable::rebound
+
+ This holds the transition to be applied to the content view when
+ it snaps back to the bounds of the flickable. The transition is
+ triggered when the view is flicked or dragged past the edge of the
+ content area, or when returnToBounds() is called.
+
+ \qml
+ import QtQuick 2.0
+
+ Flickable {
+ width: 150; height: 150
+ contentWidth: 300; contentHeight: 300
+
+ rebound: Transition {
+ NumberAnimation {
+ properties: "x,y"
+ duration: 1000
+ easing.type: Easing.OutBounce
+ }
+ }
+
+ Rectangle {
+ width: 300; height: 300
+ gradient: Gradient {
+ GradientStop { position: 0.0; color: "lightsteelblue" }
+ GradientStop { position: 1.0; color: "blue" }
+ }
+ }
+ }
+ \endqml
+
+ When the above view is flicked beyond its bounds, it will return to its
+ bounds using the transition specified:
+
+ \image flickable-rebound.gif
+
+ If this property is not set, a default animation is applied.
+ */
+QQuickTransition *QQuickFlickable::rebound() const
+{
+ Q_D(const QQuickFlickable);
+ return d->rebound;
+}
+
+void QQuickFlickable::setRebound(QQuickTransition *transition)
+{
+ Q_D(QQuickFlickable);
+ if (transition) {
+ if (!d->hData.transitionToBounds)
+ d->hData.transitionToBounds = new QQuickFlickableReboundTransition(this, QLatin1String("x"));
+ if (!d->vData.transitionToBounds)
+ d->vData.transitionToBounds = new QQuickFlickableReboundTransition(this, QLatin1String("y"));
+ }
+ if (d->rebound != transition) {
+ d->rebound = transition;
+ emit reboundChanged();
+ }
+}
+
+/*!
\qmlproperty real QtQuick2::Flickable::contentWidth
\qmlproperty real QtQuick2::Flickable::contentHeight
setKeepMouseGrab(false);
d->fixupX();
d->fixupY();
- if (!d->timeline.isActive())
+ if (!d->isViewMoving())
movementEnding();
}
}
}
}
+bool QQuickFlickablePrivate::isViewMoving() const
+{
+ if (timeline.isActive()
+ || (hData.transitionToBounds && hData.transitionToBounds->isActive())
+ || (vData.transitionToBounds && vData.transitionToBounds->isActive()) ) {
+ return true;
+ }
+ return false;
+}
+
/*!
\qmlproperty int QtQuick2::Flickable::pressDelay
return d->vData.moving;
}
+void QQuickFlickable::timelineCompleted()
+{
+ Q_D(QQuickFlickable);
+ if ( (d->hData.transitionToBounds && d->hData.transitionToBounds->isActive())
+ || (d->vData.transitionToBounds && d->vData.transitionToBounds->isActive()) ) {
+ return;
+ }
+ movementEnding();
+}
+
void QQuickFlickable::movementStarting()
{
Q_D(QQuickFlickable);
d->vData.moving = true;
emit movingVerticallyChanged();
}
+
if (!wasMoving && (d->hData.moving || d->vData.moving)) {
emit movingChanged();
emit movementStarted();
Q_PROPERTY(qreal verticalVelocity READ verticalVelocity NOTIFY verticalVelocityChanged)
Q_PROPERTY(BoundsBehavior boundsBehavior READ boundsBehavior WRITE setBoundsBehavior NOTIFY boundsBehaviorChanged)
+ Q_PROPERTY(QQuickTransition *rebound READ rebound WRITE setRebound NOTIFY reboundChanged)
Q_PROPERTY(qreal maximumFlickVelocity READ maximumFlickVelocity WRITE setMaximumFlickVelocity NOTIFY maximumFlickVelocityChanged)
Q_PROPERTY(qreal flickDeceleration READ flickDeceleration WRITE setFlickDeceleration NOTIFY flickDecelerationChanged)
Q_PROPERTY(bool moving READ isMoving NOTIFY movingChanged)
BoundsBehavior boundsBehavior() const;
void setBoundsBehavior(BoundsBehavior);
+ QQuickTransition *rebound() const;
+ void setRebound(QQuickTransition *transition);
+
qreal contentWidth() const;
void setContentWidth(qreal);
void flickableDirectionChanged();
void interactiveChanged();
void boundsBehaviorChanged();
+ void reboundChanged();
void maximumFlickVelocityChanged();
void flickDecelerationChanged();
void pressDelayChanged();
void movementStarting();
void movementEnding();
void movementEnding(bool hMovementEnding, bool vMovementEnding);
+ void timelineCompleted();
protected:
virtual qreal minXExtent() const;
Q_DISABLE_COPY(QQuickFlickable)
Q_DECLARE_PRIVATE(QQuickFlickable)
friend class QQuickFlickableVisibleArea;
+ friend class QQuickFlickableReboundTransition;
};
QT_END_NAMESPACE
#include <private/qquicktimeline_p_p.h>
#include <private/qquickanimation_p_p.h>
+#include <private/qquicktransitionmanager_p_p.h>
QT_BEGIN_NAMESPACE
const qreal MinimumFlickVelocity = 75.0;
class QQuickFlickableVisibleArea;
+class QQuickTransition;
+class QQuickFlickableReboundTransition;
+
class Q_AUTOTEST_EXPORT QQuickFlickablePrivate : public QQuickItemPrivate, public QQuickItemChangeListener
{
Q_DECLARE_PUBLIC(QQuickFlickable)
struct AxisData {
AxisData(QQuickFlickablePrivate *fp, void (QQuickFlickablePrivate::*func)(qreal))
- : move(fp, func), viewSize(-1), startMargin(0), endMargin(0)
+ : move(fp, func)
+ , transitionToBounds(0)
+ , viewSize(-1), startMargin(0), endMargin(0)
+ , transitionTo(0)
, continuousFlickVelocity(0)
, smoothVelocity(fp), atEnd(false), atBeginning(true)
+ , transitionToSet(false)
, fixingUp(false), inOvershoot(false), moving(false), flicking(false)
, dragging(false), extentsChanged(false)
, explicitValue(false), minExtentDirty(true), maxExtentDirty(true)
{}
+ ~AxisData();
+
void reset() {
velocityBuffer.clear();
dragStartOffset = 0;
extentsChanged = true;
}
+ void resetTransitionTo() {
+ transitionTo = 0;
+ transitionToSet = false;
+ }
+
void addVelocitySample(qreal v, qreal maxVelocity);
void updateVelocity();
QQuickTimeLineValueProxy<QQuickFlickablePrivate> move;
+ QQuickFlickableReboundTransition *transitionToBounds;
qreal viewSize;
qreal pressPos;
qreal dragStartOffset;
qreal flickTarget;
qreal startMargin;
qreal endMargin;
+ qreal transitionTo;
qreal continuousFlickVelocity;
QQuickFlickablePrivate::Velocity smoothVelocity;
QPODVector<qreal,10> velocityBuffer;
bool atEnd : 1;
bool atBeginning : 1;
+ bool transitionToSet : 1;
bool fixingUp : 1;
bool inOvershoot : 1;
bool moving : 1;
void fixupX();
void fixupY();
virtual void fixup(AxisData &data, qreal minExtent, qreal maxExtent);
+ void adjustContentPos(AxisData &data, qreal toPos);
+ void resetTimeline(AxisData &data);
+ void clearTimeline();
void updateBeginningEnd();
void draggingStarting();
void draggingEnding();
+ bool isViewMoving() const;
+
public:
QQuickItem *contentItem;
QQuickFlickableVisibleArea *visibleArea;
QQuickFlickable::FlickableDirection flickableDirection;
QQuickFlickable::BoundsBehavior boundsBehavior;
+ QQuickTransition *rebound;
void handleMousePressEvent(QMouseEvent *);
void handleMouseMoveEvent(QMouseEvent *);
--- /dev/null
+import QtQuick 2.0
+
+Flickable {
+ id: flick
+
+ property int transitionDuration: 100
+ property bool transitionEnabled: true
+ property int transitionsStarted
+
+ width: 200
+ height: 200
+
+ contentWidth: width * 1.25
+ contentHeight: width * 1.25
+
+ rebound: Transition {
+ objectName: "rebound"
+ enabled: flick.transitionEnabled
+ SequentialAnimation {
+ PropertyAction { target: flick; property: "transitionsStarted"; value: flick.transitionsStarted + 1 }
+ NumberAnimation {
+ properties: "x,y"
+ easing.type: Easing.OutElastic
+ duration: flick.transitionDuration
+ }
+ }
+ }
+
+ Grid {
+ columns: 2
+ Repeater {
+ model: 4
+ Rectangle {
+ width: flick.contentWidth/2
+ height: flick.contentHeight/2
+ color: Qt.rgba(Math.random(), Math.random(), Math.random(), 1)
+ }
+ }
+ }
+}
+
contentWidth: 300
contentHeight: 300
+ rebound: setRebound ? boundsTransition : null
+ Transition {
+ id: boundsTransition
+ objectName: "rebound"
+ NumberAnimation {
+ properties: "x,y"
+ easing.type: Easing.OutElastic
+ }
+ }
+
Rectangle {
width: flick.contentWidth
height: flick.contentHeight
#include <QtQuick/qquickview.h>
#include <private/qquickflickable_p.h>
#include <private/qquickflickable_p_p.h>
+#include <private/qquicktransition_p.h>
#include <private/qqmlvaluetype_p.h>
#include <math.h>
#include "../../shared/util.h"
void verticalViewportSize();
void properties();
void boundsBehavior();
+ void rebound();
void maximumFlickVelocity();
void flickDeceleration();
void pressDelay();
void flickableDirection();
void resizeContent();
void returnToBounds();
+ void returnToBounds_data();
void wheel();
void movingAndFlicking();
void movingAndFlicking_data();
void disabled();
void flickVelocity();
void margins();
- void cancel();
+ void cancelOnMouseGrab();
private:
QQmlEngine engine;
QCOMPARE(spy.count(),3);
}
+void tst_qquickflickable::rebound()
+{
+#ifdef Q_OS_MAC
+ QSKIP("Producing flicks on Mac CI impossible due to timing problems");
+#endif
+
+ QQuickView *canvas = new QQuickView;
+ canvas->setSource(testFileUrl("rebound.qml"));
+ canvas->show();
+ canvas->requestActivateWindow();
+ QVERIFY(canvas->rootObject() != 0);
+
+ QQuickFlickable *flickable = qobject_cast<QQuickFlickable*>(canvas->rootObject());
+ QVERIFY(flickable != 0);
+
+ QQuickTransition *rebound = canvas->rootObject()->findChild<QQuickTransition*>("rebound");
+ QVERIFY(rebound);
+ QSignalSpy reboundSpy(rebound, SIGNAL(runningChanged()));
+
+ QSignalSpy movementStartedSpy(flickable, SIGNAL(movementStarted()));
+ QSignalSpy movementEndedSpy(flickable, SIGNAL(movementEnded()));
+ QSignalSpy vMoveSpy(flickable, SIGNAL(movingVerticallyChanged()));
+ QSignalSpy hMoveSpy(flickable, SIGNAL(movingHorizontallyChanged()));
+
+ // flick and test the transition is run
+ flick(canvas, QPoint(20,20), QPoint(120,120), 200);
+
+ QTRY_COMPARE(canvas->rootObject()->property("transitionsStarted").toInt(), 2);
+ QCOMPARE(hMoveSpy.count(), 1);
+ QCOMPARE(vMoveSpy.count(), 1);
+ QCOMPARE(movementStartedSpy.count(), 1);
+ QCOMPARE(movementEndedSpy.count(), 0);
+ QVERIFY(rebound->running());
+
+ QTRY_VERIFY(!flickable->isMoving());
+ QCOMPARE(flickable->contentX(), 0.0);
+ QCOMPARE(flickable->contentY(), 0.0);
+
+ QCOMPARE(hMoveSpy.count(), 2);
+ QCOMPARE(vMoveSpy.count(), 2);
+ QCOMPARE(movementStartedSpy.count(), 1);
+ QCOMPARE(movementEndedSpy.count(), 1);
+ QCOMPARE(canvas->rootObject()->property("transitionsStarted").toInt(), 2);
+ QVERIFY(!rebound->running());
+ QCOMPARE(reboundSpy.count(), 2);
+
+ hMoveSpy.clear();
+ vMoveSpy.clear();
+ movementStartedSpy.clear();
+ movementEndedSpy.clear();
+ canvas->rootObject()->setProperty("transitionsStarted", 0);
+ canvas->rootObject()->setProperty("transitionsFinished", 0);
+
+ // flick and trigger the transition multiple times
+ // (moving signals are emitted as soon as the first transition starts)
+ flick(canvas, QPoint(20,20), QPoint(120,120), 200); // both x and y will bounce back
+ flick(canvas, QPoint(20,120), QPoint(120,20), 200); // only x will bounce back
+
+ QVERIFY(flickable->isMoving());
+ QVERIFY(canvas->rootObject()->property("transitionsStarted").toInt() >= 1);
+ QCOMPARE(hMoveSpy.count(), 1);
+ QCOMPARE(vMoveSpy.count(), 1);
+ QCOMPARE(movementStartedSpy.count(), 1);
+
+ QTRY_VERIFY(!flickable->isMoving());
+ QCOMPARE(flickable->contentX(), 0.0);
+
+ // moving started/stopped signals should only have been emitted once,
+ // and when they are, all transitions should have finished
+ QCOMPARE(hMoveSpy.count(), 2);
+ QCOMPARE(vMoveSpy.count(), 2);
+ QCOMPARE(movementStartedSpy.count(), 1);
+ QCOMPARE(movementEndedSpy.count(), 1);
+
+ hMoveSpy.clear();
+ vMoveSpy.clear();
+ movementStartedSpy.clear();
+ movementEndedSpy.clear();
+ canvas->rootObject()->setProperty("transitionsStarted", 0);
+ canvas->rootObject()->setProperty("transitionsFinished", 0);
+
+ // disable and the default transition should run
+ // (i.e. moving but transition->running = false)
+ canvas->rootObject()->setProperty("transitionEnabled", false);
+
+ flick(canvas, QPoint(20,20), QPoint(120,120), 200);
+ QCOMPARE(canvas->rootObject()->property("transitionsStarted").toInt(), 0);
+ QCOMPARE(hMoveSpy.count(), 1);
+ QCOMPARE(vMoveSpy.count(), 1);
+ QCOMPARE(movementStartedSpy.count(), 1);
+ QCOMPARE(movementEndedSpy.count(), 0);
+
+ QTRY_VERIFY(!flickable->isMoving());
+ QCOMPARE(hMoveSpy.count(), 2);
+ QCOMPARE(vMoveSpy.count(), 2);
+ QCOMPARE(movementStartedSpy.count(), 1);
+ QCOMPARE(movementEndedSpy.count(), 1);
+ QCOMPARE(canvas->rootObject()->property("transitionsStarted").toInt(), 0);
+
+ delete canvas;
+}
+
void tst_qquickflickable::maximumFlickVelocity()
{
QQmlComponent component(&engine);
delete root;
}
-// QtQuick 1.1
void tst_qquickflickable::returnToBounds()
{
- QQmlEngine engine;
- QQmlComponent c(&engine, testFileUrl("resize.qml"));
- QQuickItem *root = qobject_cast<QQuickItem*>(c.create());
- QQuickFlickable *obj = findItem<QQuickFlickable>(root, "flick");
+ QFETCH(bool, setRebound);
+
+ QQuickView *canvas = new QQuickView;
+ canvas->rootContext()->setContextProperty("setRebound", setRebound);
+ canvas->setSource(testFileUrl("resize.qml"));
+ QVERIFY(canvas->rootObject() != 0);
+ QQuickFlickable *obj = findItem<QQuickFlickable>(canvas->rootObject(), "flick");
+
+ QQuickTransition *rebound = canvas->rootObject()->findChild<QQuickTransition*>("rebound");
+ QVERIFY(rebound);
+ QSignalSpy reboundSpy(rebound, SIGNAL(runningChanged()));
QVERIFY(obj != 0);
QCOMPARE(obj->contentX(), 0.);
QTRY_COMPARE(obj->contentX(), 100.);
QTRY_COMPARE(obj->contentY(), 400.);
- QMetaObject::invokeMethod(root, "returnToBounds");
+ QMetaObject::invokeMethod(canvas->rootObject(), "returnToBounds");
+
+ if (setRebound)
+ QTRY_VERIFY(rebound->running());
QTRY_COMPARE(obj->contentX(), 0.);
QTRY_COMPARE(obj->contentY(), 0.);
- delete root;
+ QVERIFY(!rebound->running());
+ QCOMPARE(reboundSpy.count(), setRebound ? 2 : 0);
+
+ delete canvas;
+}
+
+void tst_qquickflickable::returnToBounds_data()
+{
+ QTest::addColumn<bool>("setRebound");
+
+ QTest::newRow("with bounds transition") << true;
+ QTest::newRow("with bounds transition") << false;
}
void tst_qquickflickable::wheel()
void tst_qquickflickable::movingAndDragging()
{
-#ifdef Q_OS_MAC
- QSKIP("Producing flicks on Mac CI impossible due to timing problems");
-#endif
-
QFETCH(bool, verticalEnabled);
QFETCH(bool, horizontalEnabled);
QFETCH(QPoint, moveByWithoutSnapBack);
#ifdef Q_OS_MAC
QSKIP("Producing flicks on Mac CI impossible due to timing problems");
#endif
-
QQuickView *canvas = new QQuickView;
canvas->setSource(testFileUrl("flickable03.qml"));
canvas->show();
delete root;
}
-void tst_qquickflickable::cancel()
+void tst_qquickflickable::cancelOnMouseGrab()
{
QQuickView *canvas = new QQuickView;
canvas->setSource(testFileUrl("cancel.qml"));
projects / platform / upstream / qtdeclarative.git / commitdiff
