emit anchorPointChanged(point);
}
+qreal QSGPathAnimation::orientationEntryInterval() const
+{
+ Q_D(const QSGPathAnimation);
+ return d->entryInterval;
+}
+
+void QSGPathAnimation::setOrientationEntryInterval(qreal interval)
+{
+ Q_D(QSGPathAnimation);
+ if (d->entryInterval == interval)
+ return;
+ d->entryInterval = interval;
+ emit orientationEntryIntervalChanged(interval);
+}
+
+qreal QSGPathAnimation::orientationExitInterval() const
+{
+ Q_D(const QSGPathAnimation);
+ return d->exitInterval;
+}
+
+void QSGPathAnimation::setOrientationExitInterval(qreal interval)
+{
+ Q_D(QSGPathAnimation);
+ if (d->exitInterval == interval)
+ return;
+ d->exitInterval = interval;
+ emit orientationExitIntervalChanged(interval);
+}
+
+qreal QSGPathAnimation::endRotation() const
+{
+ Q_D(const QSGPathAnimation);
+ return d->endRotation.isNull ? qreal(0) : d->endRotation.value;
+}
+
+void QSGPathAnimation::setEndRotation(qreal rotation)
+{
+ Q_D(QSGPathAnimation);
+ if (!d->endRotation.isNull && d->endRotation == rotation)
+ return;
+
+ d->endRotation = rotation;
+ emit endRotationChanged(d->endRotation);
+}
+
+
QAbstractAnimation *QSGPathAnimation::qtAnimation()
{
Q_D(QSGPathAnimation);
data->orientation = d->orientation;
data->anchorPoint = d->anchorPoint;
+ data->entryInterval = d->entryInterval;
+ data->exitInterval = d->exitInterval;
+ data->endRotation = d->endRotation;
data->reverse = direction == Backward ? true : false;
data->fromSourced = false;
- data->fromDefined = d->path ? !d->path->hasStartX() || !d->path->hasStartY() ? false : true : false; //### handle x/y separately, as well as endpoint specification?
+ data->fromDefined = (d->path && d->path->hasStartX() && d->path->hasStartY()) ? true : false;
+ data->toDefined = d->path ? d->path->hasEnd() : false;
int origModifiedSize = modified.count();
for (int i = 0; i < actions.count(); ++i) {
}
if (d->target && d->path &&
- (modified.count() > origModifiedSize || data->fromDefined)) {
+ (modified.count() > origModifiedSize || data->toDefined)) {
data->target = d->target;
data->path = d->path;
if (!d->rangeIsSet) {
d->pa->setEndValue(qreal(1));
d->rangeIsSet = true;
}
+ /*
+ NOTE: The following block relies on the fact that the previous value hasn't
+ yet been deleted, and has the same target, etc, which may be a bit fragile.
+ */
+ if (d->pa->getAnimValue()) {
+ QSGPathAnimationUpdater *prevData = static_cast<QSGPathAnimationUpdater*>(d->pa->getAnimValue());
+
+ // get the original start angle that was used (so we can exactly reverse).
+ data->startRotation = prevData->startRotation;
+
+ // treat interruptions specially, otherwise we end up with strange paths
+ if ((data->reverse || prevData->reverse) && prevData->currentV > 0 && prevData->currentV < 1) {
+ if (!data->fromDefined && !data->toDefined && !prevData->painterPath.isEmpty()) {
+ QPointF pathPos = QDeclarativePath::sequentialPointAt(prevData->painterPath, prevData->pathLength, prevData->attributePoints, prevData->prevBez, prevData->currentV);
+ if (!prevData->anchorPoint.isNull())
+ pathPos -= prevData->anchorPoint;
+ if (pathPos == data->target->pos()) { //only treat as interruption if we interrupted ourself
+ data->painterPath = prevData->painterPath;
+ data->toDefined = data->fromDefined = data->fromSourced = true;
+ data->prevBez.isValid = false;
+ data->interruptStart = prevData->currentV;
+ data->startRotation = prevData->startRotation;
+ data->pathLength = prevData->pathLength;
+ data->attributePoints = prevData->attributePoints;
+ }
+ }
+ }
+ }
d->pa->setFromSourcedValue(&data->fromSourced);
d->pa->setAnimValue(data, QAbstractAnimation::DeleteWhenStopped);
} else {
void QSGPathAnimationUpdater::setValue(qreal v)
{
- if (!fromSourced && !fromDefined) { //### check if !toDefined?
+ if (interruptStart.isValid()) {
+ if (reverse)
+ v = 1 - v;
+ qreal end = reverse ? 0.0 : 1.0;
+ v = interruptStart + v * (end-interruptStart);
+ }
+ currentV = v;
+ bool atStart = ((reverse && v == 1.0) || (!reverse && v == 0.0));
+ if (!fromSourced && (!fromDefined || !toDefined)) {
qreal startX = reverse ? toX + anchorPoint.x() : target->x() + anchorPoint.x();
qreal startY = reverse ? toY + anchorPoint.y() : target->y() + anchorPoint.y();
qreal endX = reverse ? target->x() + anchorPoint.x() : toX + anchorPoint.x();
//adjust position according to anchor point
if (!anchorPoint.isNull()) {
currentPos -= anchorPoint;
- if ((reverse && v == 1.0) || (!reverse && v == 0.0)) {
+ if (atStart) {
if (!anchorPoint.isNull() && !fixed)
target->setTransformOriginPoint(anchorPoint);
}
}
- //### too expensive to reconstruct properties each time?
+ //### could cache properties rather than reconstructing each time
QDeclarativePropertyPrivate::write(QDeclarativeProperty(target, "x"), currentPos.x(), QDeclarativePropertyPrivate::BypassInterceptor | QDeclarativePropertyPrivate::DontRemoveBinding);
QDeclarativePropertyPrivate::write(QDeclarativeProperty(target, "y"), currentPos.y(), QDeclarativePropertyPrivate::BypassInterceptor | QDeclarativePropertyPrivate::DontRemoveBinding);
case QSGPathAnimation::RightFirst:
angle = -angle;
break;
+ case QSGPathAnimation::TopFirst:
+ angle = -angle + 90;
+ break;
case QSGPathAnimation::LeftFirst:
angle = -angle + 180;
break;
case QSGPathAnimation::BottomFirst:
angle = -angle + 270;
break;
- case QSGPathAnimation::TopFirst:
- angle = -angle + 450;
- break;
default:
angle = 0;
break;
}
+
+ if (atStart && !reverse) {
+ startRotation = target->rotation();
+
+ //shortest distance to correct orientation
+ qreal diff = angle - startRotation;
+ while (diff > 180.0) {
+ startRotation.value += 360.0;
+ diff -= 360.0;
+ }
+ while (diff < -180.0) {
+ startRotation.value -= 360.0;
+ diff += 360.0;
+ }
+ }
+
+ //smoothly transition to the desired orientation
+ if (startRotation.isValid()) {
+ if (reverse && v == 0.0)
+ angle = startRotation;
+ else if (v < entryInterval)
+ angle = angle * v / entryInterval + startRotation * (entryInterval - v) / entryInterval;
+ }
+ if (endRotation.isValid()) {
+ qreal exitStart = 1 - exitInterval;
+ if (!reverse && v == 1.0)
+ angle = endRotation;
+ else if (v > exitStart)
+ angle = endRotation * (v - exitStart) / exitInterval + angle * (exitInterval - (v - exitStart)) / exitInterval;
+ }
QDeclarativePropertyPrivate::write(QDeclarativeProperty(target, "rotation"), angle, QDeclarativePropertyPrivate::BypassInterceptor | QDeclarativePropertyPrivate::DontRemoveBinding);
}
- //### resetting transform causes visual jump if ending on an angle
-// if ((reverse && v == 0.0) || (!reverse && v == 1.0)) {
-// if (!anchorPoint.isNull() && !fixed)
-// target->setTransformOriginPoint(QPointF());
-// }
+ /*
+ NOTE: we don't always reset the transform origin, as it can cause a
+ visual jump if ending on an angle. This means that in some cases
+ (anchor point and orientation both specified, and ending at an angle)
+ the transform origin will always be set after running the path animation.
+ */
+ if ((reverse && v == 0.0) || (!reverse && v == 1.0)) {
+ if (!anchorPoint.isNull() && !fixed && qFuzzyIsNull(angle))
+ target->setTransformOriginPoint(QPointF());
+ }
}
QT_END_NAMESPACE
Q_PROPERTY(QSGItem *target READ target WRITE setTarget NOTIFY targetChanged)
Q_PROPERTY(Orientation orientation READ orientation WRITE setOrientation NOTIFY orientationChanged)
Q_PROPERTY(QPointF anchorPoint READ anchorPoint WRITE setAnchorPoint NOTIFY anchorPointChanged)
+ Q_PROPERTY(qreal orientationEntryInterval READ orientationEntryInterval WRITE setOrientationEntryInterval NOTIFY orientationEntryIntervalChanged)
+ Q_PROPERTY(qreal orientationExitInterval READ orientationExitInterval WRITE setOrientationExitInterval NOTIFY orientationExitIntervalChanged)
+ Q_PROPERTY(qreal endRotation READ endRotation WRITE setEndRotation NOTIFY endRotationChanged)
public:
QSGPathAnimation(QObject *parent=0);
QPointF anchorPoint() const;
void setAnchorPoint(const QPointF &point);
+ qreal orientationEntryInterval() const;
+ void setOrientationEntryInterval(qreal);
+
+ qreal orientationExitInterval() const;
+ void setOrientationExitInterval(qreal);
+
+ qreal endRotation() const;
+ void setEndRotation(qreal);
+
protected:
virtual void transition(QDeclarativeStateActions &actions,
QDeclarativeProperties &modified,
void targetChanged();
void orientationChanged(Orientation);
void anchorPointChanged(const QPointF &);
+ void orientationEntryIntervalChanged(qreal);
+ void orientationExitIntervalChanged(qreal);
+ void endRotationChanged(qreal);
};
QT_END_NAMESPACE
class QSGPathAnimationUpdater : public QDeclarativeBulkValueUpdater
{
public:
+ QSGPathAnimationUpdater() : path(0), target(0), reverse(false),
+ fromSourced(false), fromDefined(false), toDefined(false),
+ toX(0), toY(0), currentV(0), orientation(QSGPathAnimation::Fixed),
+ entryInterval(0), exitInterval(0) {}
+ ~QSGPathAnimationUpdater() {}
+
+ void setValue(qreal v);
+
QDeclarativePath *path;
QPainterPath painterPath;
bool reverse;
bool fromSourced;
bool fromDefined;
+ bool toDefined;
qreal toX;
qreal toY;
+ qreal currentV;
+ QDeclarativeNullableValue<qreal> interruptStart;
+ //TODO: bundle below into common struct
QSGPathAnimation::Orientation orientation;
QPointF anchorPoint;
- QSGPathAnimationUpdater() : path(0), target(0), reverse(false),
- fromSourced(false), fromDefined(false), toX(0), toY(0), orientation(QSGPathAnimation::Fixed) {}
- ~QSGPathAnimationUpdater() {}
- void setValue(qreal v);
+ qreal entryInterval;
+ qreal exitInterval;
+ QDeclarativeNullableValue<qreal> endRotation;
+ QDeclarativeNullableValue<qreal> startRotation;
};
class QSGPathAnimationPrivate : public QDeclarativeAbstractAnimationPrivate
Q_DECLARE_PUBLIC(QSGPathAnimation)
public:
QSGPathAnimationPrivate() : path(0), target(0),
- rangeIsSet(false), orientation(QSGPathAnimation::Fixed), pa(0) {}
+ rangeIsSet(false), orientation(QSGPathAnimation::Fixed), entryInterval(0), exitInterval(0), pa(0) {}
QDeclarativePath *path;
QSGItem *target;
bool rangeIsSet;
QSGPathAnimation::Orientation orientation;
QPointF anchorPoint;
+ qreal entryInterval;
+ qreal exitInterval;
+ QDeclarativeNullableValue<qreal> endRotation;
QDeclarativeBulkValueAnimator *pa;
};
animValue = value;
policy = p;
}
+ QDeclarativeBulkValueUpdater *getAnimValue() const
+ {
+ return animValue;
+ }
void setFromSourcedValue(bool *value)
{
fromSourced = value;
return d->closed;
}
+bool QDeclarativePath::hasEnd() const
+{
+ Q_D(const QDeclarativePath);
+ for (int i = d->_pathElements.count() - 1; i > -1; --i) {
+ if (QDeclarativeCurve *curve = qobject_cast<QDeclarativeCurve *>(d->_pathElements.at(i))) {
+ if ((!curve->hasX() && !curve->hasRelativeX()) || (!curve->hasY() && !curve->hasRelativeY()))
+ return false;
+ else
+ return true;
+ }
+ }
+ return hasStartX() && hasStartY();
+}
+
/*!
\qmlproperty list<PathElement> QtQuick2::Path::pathElements
This property holds the objects composing the path.
return d->_attributes;
}
-static inline QBezier nextBezier(const QPainterPath &path, int *from, qreal *bezLength, bool reverse = false)
+static inline QBezier nextBezier(const QPainterPath &path, int *current, qreal *bezLength, bool reverse = false)
{
const int lastElement = reverse ? 0 : path.elementCount() - 1;
- for (int i=*from; reverse ? i >= lastElement : i <= lastElement; reverse ? --i : ++i) {
+ const int start = reverse ? *current - 1 : *current + 1;
+ for (int i=start; reverse ? i >= lastElement : i <= lastElement; reverse ? --i : ++i) {
const QPainterPath::Element &e = path.elementAt(i);
switch (e.type) {
*bezLength = line.length();
QPointF a = path.elementAt(i-1);
QPointF delta = e - a;
- *from = reverse ? i-1 : i+1;
+ *current = i;
return QBezier::fromPoints(a, a + delta / 3, a + 2 * delta / 3, e);
}
case QPainterPath::CurveToElement:
path.elementAt(i+1),
path.elementAt(i+2));
*bezLength = b.length();
- *from = reverse ? i-1 : i+3;
+ *current = i;
return b;
}
default:
break;
}
}
- *from = lastElement;
+ *current = lastElement;
*bezLength = 0;
return QBezier();
}
const int lastElement = d->_path.elementCount() - 1;
d->_pointCache.resize(points+1);
- int currElement = 0;
+ int currElement = -1;
qreal bezLength = 0;
QBezier currBez = nextBezier(d->_path, &currElement, &bezLength);
qreal currLength = bezLength;
const int lastElement = path.elementCount() - 1;
bool haveCachedBez = prevBez.isValid;
- int currElement = haveCachedBez ? prevBez.element : 0;
+ int currElement = haveCachedBez ? prevBez.element : -1;
qreal bezLength = haveCachedBez ? prevBez.bezLength : 0;
QBezier currBez = haveCachedBez ? prevBez.bezier : nextBezier(path, &currElement, &bezLength);
qreal currLength = haveCachedBez ? prevBez.currLength : bezLength;
qreal spc = prevOrigPercent + elementPercent * point.scale;
while (spc > epc) {
- if (currElement > lastElement)
- break;
+ Q_ASSERT(!(currElement > lastElement));
currBez = nextBezier(path, &currElement, &bezLength);
- /*if (bezLength == 0.0) {
- currLength = pathLength;
- epc = 1.0;
- break;
- }*/
currLength += bezLength;
epc = currLength / pathLength;
}
const int firstElement = 0;
bool haveCachedBez = prevBez.isValid;
- int currElement = haveCachedBez ? prevBez.element : path.elementCount() - 1;
+ int currElement = haveCachedBez ? prevBez.element : path.elementCount();
qreal bezLength = haveCachedBez ? prevBez.bezLength : 0;
QBezier currBez = haveCachedBez ? prevBez.bezier : nextBezier(path, &currElement, &bezLength, true /*reverse*/);
qreal currLength = haveCachedBez ? prevBez.currLength : pathLength;
qreal spc = prevPoint.origpercent + elementPercent * point.scale;
while (spc < epc) {
- if (currElement < firstElement)
- break;
+ Q_ASSERT(!(currElement < firstElement));
currBez = nextBezier(path, &currElement, &bezLength, true /*reverse*/);
- /*if (bezLength == 0.0) {
- currLength = 0;
- epc = 0.0;
- break;
- }*/
currLength = prevLength;
epc = (currLength - bezLength) / pathLength;
}
bool hasStartY() const;
bool isClosed() const;
+ bool hasEnd() const;
QPainterPath path() const;
QStringList attributes() const;
--- /dev/null
+import QtQuick 2.0
+
+Rectangle {
+ width: 400
+ height: 400
+
+ Rectangle {
+ id: redRect
+ color: "red"
+ width: 100; height: 100
+ x: 50; y: 50
+ }
+
+ PathAnimation {
+ target: redRect
+ duration: 100;
+ endRotation: 0
+ orientationEntryInterval: .1
+ orientationExitInterval: .1
+ orientation: PathAnimation.RightFirst
+ path: Path {
+ startX: 50; startY: 50
+ PathLine { x: 300; y: 300 }
+ }
+ }
+}
--- /dev/null
+import QtQuick 2.0
+
+Rectangle {
+ width: 400
+ height: 400
+
+ Rectangle {
+ id: redRect
+ color: "red"
+ width: 100; height: 100
+ x: 50; y: 50
+ }
+
+ PathAnimation {
+ target: redRect
+ duration: 100;
+ path: Path {
+ //no startX/Y defined (should automatically start from redRects pos)
+ PathCubic {
+ x: 300; y: 300
+
+ control1X: 300; control1Y: 50
+ control2X: 50; control2Y: 300
+ }
+ }
+ }
+}
#include <QVariantAnimation>
#include <QEasingCurve>
+#include <limits.h>
+#include <math.h>
+
#include "../../../shared/util.h"
#ifdef Q_OS_SYMBIAN
void simpleRotation();
void simplePath();
void pathInterpolator();
+ void pathWithNoStart();
void alwaysRunToEnd();
void complete();
void resume();
void tst_qdeclarativeanimations::simplePath()
{
- QDeclarativeEngine engine;
- QDeclarativeComponent c(&engine, QUrl::fromLocalFile(SRCDIR "/data/pathAnimation.qml"));
- QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
- QVERIFY(rect);
+ {
+ QDeclarativeEngine engine;
+ QDeclarativeComponent c(&engine, QUrl::fromLocalFile(SRCDIR "/data/pathAnimation.qml"));
+ QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QVERIFY(rect);
- QSGRectangle *redRect = rect->findChild<QSGRectangle*>();
- QVERIFY(redRect);
- QSGPathAnimation *pathAnim = rect->findChild<QSGPathAnimation*>();
- QVERIFY(pathAnim);
+ QSGRectangle *redRect = rect->findChild<QSGRectangle*>();
+ QVERIFY(redRect);
+ QSGPathAnimation *pathAnim = rect->findChild<QSGPathAnimation*>();
+ QVERIFY(pathAnim);
+
+ pathAnim->start();
+ pathAnim->pause();
+
+ pathAnim->setCurrentTime(30);
+ QCOMPARE(redRect->x(), qreal(167));
+ QCOMPARE(redRect->y(), qreal(104));
+
+ pathAnim->setCurrentTime(100);
+ QCOMPARE(redRect->x(), qreal(300));
+ QCOMPARE(redRect->y(), qreal(300));
+
+ //verify animation runs to end
+ pathAnim->start();
+ QCOMPARE(redRect->x(), qreal(50));
+ QCOMPARE(redRect->y(), qreal(50));
+ QTRY_COMPARE(redRect->x(), qreal(300));
+ QCOMPARE(redRect->y(), qreal(300));
+
+ pathAnim->setOrientation(QSGPathAnimation::RightFirst);
+ QCOMPARE(pathAnim->orientation(), QSGPathAnimation::RightFirst);
+ pathAnim->start();
+ QTRY_VERIFY(redRect->rotation() != 0);
+ pathAnim->stop();
+ }
- pathAnim->start();
- pathAnim->pause();
+ {
+ QDeclarativeEngine engine;
+ QDeclarativeComponent c(&engine, QUrl::fromLocalFile(SRCDIR "/data/pathAnimation2.qml"));
+ QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QVERIFY(rect);
- pathAnim->setCurrentTime(50);
- QCOMPARE(redRect->x(), qreal(175));
- QCOMPARE(redRect->y(), qreal(175));
+ QSGRectangle *redRect = rect->findChild<QSGRectangle*>();
+ QVERIFY(redRect);
+ QSGPathAnimation *pathAnim = rect->findChild<QSGPathAnimation*>();
+ QVERIFY(pathAnim);
- pathAnim->setCurrentTime(100);
- QCOMPARE(redRect->x(), qreal(300));
- QCOMPARE(redRect->y(), qreal(300));
+ QCOMPARE(pathAnim->orientation(), QSGPathAnimation::RightFirst);
- //verify animation runs to end
- pathAnim->start();
- QCOMPARE(redRect->x(), qreal(50));
- QCOMPARE(redRect->y(), qreal(50));
- QTRY_COMPARE(redRect->x(), qreal(300));
- QCOMPARE(redRect->y(), qreal(300));
+ pathAnim->start();
+ pathAnim->pause();
+ QCOMPARE(redRect->x(), qreal(50));
+ QCOMPARE(redRect->y(), qreal(50));
+ QCOMPARE(redRect->rotation(), qreal(-360));
+
+ pathAnim->setCurrentTime(50);
+ QCOMPARE(redRect->x(), qreal(175));
+ QCOMPARE(redRect->y(), qreal(175));
+ QCOMPARE(redRect->rotation(), qreal(-315));
+
+ pathAnim->setCurrentTime(100);
+ QCOMPARE(redRect->x(), qreal(300));
+ QCOMPARE(redRect->y(), qreal(300));
+ QCOMPARE(redRect->rotation(), qreal(0));
+ }
}
void tst_qdeclarativeanimations::pathInterpolator()
QCOMPARE(interpolator->angle(), qreal(0));
}
+void tst_qdeclarativeanimations::pathWithNoStart()
+{
+ QDeclarativeEngine engine;
+ QDeclarativeComponent c(&engine, QUrl::fromLocalFile(SRCDIR "/data/pathAnimationNoStart.qml"));
+ QSGRectangle *rect = qobject_cast<QSGRectangle*>(c.create());
+ QVERIFY(rect);
+
+ QSGRectangle *redRect = rect->findChild<QSGRectangle*>();
+ QVERIFY(redRect);
+ QSGPathAnimation *pathAnim = rect->findChild<QSGPathAnimation*>();
+ QVERIFY(pathAnim);
+
+ pathAnim->start();
+ pathAnim->pause();
+ QCOMPARE(redRect->x(), qreal(50));
+ QCOMPARE(redRect->y(), qreal(50));
+
+ pathAnim->setCurrentTime(50);
+ QCOMPARE(redRect->x(), qreal(175));
+ QCOMPARE(redRect->y(), qreal(175));
+
+ pathAnim->setCurrentTime(100);
+ QCOMPARE(redRect->x(), qreal(300));
+ QCOMPARE(redRect->y(), qreal(300));
+
+ redRect->setX(100);
+ redRect->setY(100);
+ pathAnim->start();
+ QCOMPARE(redRect->x(), qreal(100));
+ QCOMPARE(redRect->y(), qreal(100));
+ QTRY_COMPARE(redRect->x(), qreal(300));
+ QCOMPARE(redRect->y(), qreal(300));
+}
+
void tst_qdeclarativeanimations::alwaysRunToEnd()
{
QSGRectangle rect;
projects / konrad/qtdeclarative.git / commitdiff