1 /****************************************************************************
2 **
3 ** Copyright (C) 2016 The Qt Company Ltd.
4 ** Contact: https://www.qt.io/licensing/
5 **
6 ** This file is part of the QtQuick module of the Qt Toolkit.
7 **
8 ** $QT_BEGIN_LICENSE:LGPL$
9 ** Commercial License Usage
10 ** Licensees holding valid commercial Qt licenses may use this file in
11 ** accordance with the commercial license agreement provided with the
12 ** Software or, alternatively, in accordance with the terms contained in
13 ** a written agreement between you and The Qt Company. For licensing terms
14 ** and conditions see https://www.qt.io/terms-conditions. For further
15 ** information use the contact form at https://www.qt.io/contact-us.
16 **
17 ** GNU Lesser General Public License Usage
18 ** Alternatively, this file may be used under the terms of the GNU Lesser
19 ** General Public License version 3 as published by the Free Software
20 ** Foundation and appearing in the file LICENSE.LGPL3 included in the
21 ** packaging of this file. Please review the following information to
22 ** ensure the GNU Lesser General Public License version 3 requirements
23 ** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
24 **
25 ** GNU General Public License Usage
26 ** Alternatively, this file may be used under the terms of the GNU
27 ** General Public License version 2.0 or (at your option) the GNU General
28 ** Public license version 3 or any later version approved by the KDE Free
29 ** Qt Foundation. The licenses are as published by the Free Software
30 ** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
31 ** included in the packaging of this file. Please review the following
32 ** information to ensure the GNU General Public License requirements will
33 ** be met: https://www.gnu.org/licenses/gpl-2.0.html and
34 ** https://www.gnu.org/licenses/gpl-3.0.html.
35 **
36 ** $QT_END_LICENSE$
37 **
38 ****************************************************************************/
39 
40 #ifndef QQUICKANIMATION_H
41 #define QQUICKANIMATION_H
42 
43 //
44 //  W A R N I N G
45 //  -------------
46 //
47 // This file is not part of the Qt API.  It exists purely as an
48 // implementation detail.  This header file may change from version to
49 // version without notice, or even be removed.
50 //
51 // We mean it.
52 //
53 
54 #include "qquickstate_p.h"
55 #include <QtGui/qvector3d.h>
56 
57 #include <qqmlpropertyvaluesource.h>
58 #include <qqml.h>
59 #include <qqmlscriptstring.h>
60 
61 #include <QtCore/qvariant.h>
62 #include <QtCore/qeasingcurve.h>
63 #include "private/qabstractanimationjob_p.h"
64 #include <QtGui/qcolor.h>
65 
66 QT_BEGIN_NAMESPACE
67 
68 class QQuickAbstractAnimationPrivate;
69 class QQuickAnimationGroup;
70 class Q_QUICK_PRIVATE_EXPORT QQuickAbstractAnimation : public QObject, public QQmlPropertyValueSource, public QQmlParserStatus
71 {
72     Q_OBJECT
73     Q_DECLARE_PRIVATE(QQuickAbstractAnimation)
74 
75     Q_INTERFACES(QQmlParserStatus)
76     Q_INTERFACES(QQmlPropertyValueSource)
77     Q_PROPERTY(bool running READ isRunning WRITE setRunning NOTIFY runningChanged)
78     Q_PROPERTY(bool paused READ isPaused WRITE setPaused NOTIFY pausedChanged)
79     Q_PROPERTY(bool alwaysRunToEnd READ alwaysRunToEnd WRITE setAlwaysRunToEnd NOTIFY alwaysRunToEndChanged)
80     Q_PROPERTY(int loops READ loops WRITE setLoops NOTIFY loopCountChanged)
81     Q_CLASSINFO("DefaultMethod", "start()")
82 
83     QML_NAMED_ELEMENT(Animation)
84     QML_UNCREATABLE("Animation is an abstract class")
85 
86 public:
87     enum ThreadingModel  {
88         GuiThread,
89         RenderThread,
90         AnyThread
91     };
92 
93     QQuickAbstractAnimation(QObject *parent=nullptr);
94     ~QQuickAbstractAnimation() override;
95 
96     enum Loops { Infinite = -2 };
97     Q_ENUM(Loops)
98 
99     bool isRunning() const;
100     void setRunning(bool);
101     bool isPaused() const;
102     void setPaused(bool);
103     bool alwaysRunToEnd() const;
104     void setAlwaysRunToEnd(bool);
105 
106     int loops() const;
107     void setLoops(int);
108     int duration() const;
109 
110     int currentTime();
111     void setCurrentTime(int);
112 
113     QQuickAnimationGroup *group() const;
114     void setGroup(QQuickAnimationGroup *, int index = -1);
115 
116     void setDefaultTarget(const QQmlProperty &);
117     void setDisableUserControl();
118     void setEnableUserControl();
119     bool userControlDisabled() const;
120     void classBegin() override;
121     void componentComplete() override;
122 
123     virtual ThreadingModel threadingModel() const;
124 
125 Q_SIGNALS:
126     void started();
127     void stopped();
128     void runningChanged(bool);
129     void pausedChanged(bool);
130     void alwaysRunToEndChanged(bool);
131     void loopCountChanged(int);
132     Q_REVISION(12) void finished();
133 
134 public Q_SLOTS:
135     void restart();
136     void start();
137     void pause();
138     void resume();
139     void stop();
140     void complete();
141 
142 protected:
143     QQuickAbstractAnimation(QQuickAbstractAnimationPrivate &dd, QObject *parent);
144     QAbstractAnimationJob* initInstance(QAbstractAnimationJob *animation);
145 
146 public:
147     enum TransitionDirection { Forward, Backward };
148     virtual QAbstractAnimationJob* transition(QQuickStateActions &actions,
149                             QQmlProperties &modified,
150                             TransitionDirection direction,
151                             QObject *defaultTarget = nullptr);
152     QAbstractAnimationJob* qtAnimation();
153 
154 private Q_SLOTS:
155     void componentFinalized();
156 private:
157     void setTarget(const QQmlProperty &) override;
158     void notifyRunningChanged(bool running);
159     friend class QQuickBehavior;
160     friend class QQuickBehaviorPrivate;
161     friend class QQuickAnimationGroup;
162 };
163 
164 class QQuickPauseAnimationPrivate;
165 class Q_QUICK_PRIVATE_EXPORT QQuickPauseAnimation : public QQuickAbstractAnimation
166 {
167     Q_OBJECT
168     Q_DECLARE_PRIVATE(QQuickPauseAnimation)
169 
170     Q_PROPERTY(int duration READ duration WRITE setDuration NOTIFY durationChanged)
171     QML_NAMED_ELEMENT(PauseAnimation)
172 
173 public:
174     QQuickPauseAnimation(QObject *parent=nullptr);
175     ~QQuickPauseAnimation() override;
176 
177     int duration() const;
178     void setDuration(int);
179 
180 Q_SIGNALS:
181     void durationChanged(int);
182 
183 protected:
184     QAbstractAnimationJob* transition(QQuickStateActions &actions,
185                                           QQmlProperties &modified,
186                                           TransitionDirection direction,
187                                           QObject *defaultTarget = nullptr) override;
188 };
189 
190 class QQuickScriptActionPrivate;
191 class QQuickScriptAction : public QQuickAbstractAnimation
192 {
193     Q_OBJECT
194     Q_DECLARE_PRIVATE(QQuickScriptAction)
195 
196     Q_PROPERTY(QQmlScriptString script READ script WRITE setScript)
197     Q_PROPERTY(QString scriptName READ stateChangeScriptName WRITE setStateChangeScriptName)
198     QML_NAMED_ELEMENT(ScriptAction)
199 
200 public:
201     QQuickScriptAction(QObject *parent=nullptr);
202     ~QQuickScriptAction() override;
203 
204     QQmlScriptString script() const;
205     void setScript(const QQmlScriptString &);
206 
207     QString stateChangeScriptName() const;
208     void setStateChangeScriptName(const QString &);
209 
210 protected:
211     QAbstractAnimationJob* transition(QQuickStateActions &actions,
212                             QQmlProperties &modified,
213                             TransitionDirection direction,
214                             QObject *defaultTarget = nullptr) override;
215 };
216 
217 class QQuickPropertyActionPrivate;
218 class QQuickPropertyAction : public QQuickAbstractAnimation
219 {
220     Q_OBJECT
221     Q_DECLARE_PRIVATE(QQuickPropertyAction)
222 
223     Q_PROPERTY(QObject *target READ target WRITE setTargetObject NOTIFY targetChanged)
224     Q_PROPERTY(QString property READ property WRITE setProperty NOTIFY propertyChanged)
225     Q_PROPERTY(QString properties READ properties WRITE setProperties NOTIFY propertiesChanged)
226     Q_PROPERTY(QQmlListProperty<QObject> targets READ targets)
227     Q_PROPERTY(QQmlListProperty<QObject> exclude READ exclude)
228     Q_PROPERTY(QVariant value READ value WRITE setValue NOTIFY valueChanged)
229     QML_NAMED_ELEMENT(PropertyAction)
230 
231 public:
232     QQuickPropertyAction(QObject *parent=nullptr);
233     ~QQuickPropertyAction() override;
234 
235     QObject *target() const;
236     void setTargetObject(QObject *);
237 
238     QString property() const;
239     void setProperty(const QString &);
240 
241     QString properties() const;
242     void setProperties(const QString &);
243 
244     QQmlListProperty<QObject> targets();
245     QQmlListProperty<QObject> exclude();
246 
247     QVariant value() const;
248     void setValue(const QVariant &);
249 
250 Q_SIGNALS:
251     void valueChanged(const QVariant &);
252     void propertiesChanged(const QString &);
253     void targetChanged();
254     void propertyChanged();
255 
256 protected:
257     QAbstractAnimationJob* transition(QQuickStateActions &actions,
258                             QQmlProperties &modified,
259                             TransitionDirection direction,
260                             QObject *defaultTarget = nullptr) override;
261 };
262 
263 class QQuickPropertyAnimationPrivate;
264 class Q_QUICK_PRIVATE_EXPORT QQuickPropertyAnimation : public QQuickAbstractAnimation
265 {
266     Q_OBJECT
267     Q_DECLARE_PRIVATE(QQuickPropertyAnimation)
268 
269     Q_PROPERTY(int duration READ duration WRITE setDuration NOTIFY durationChanged)
270     Q_PROPERTY(QVariant from READ from WRITE setFrom NOTIFY fromChanged)
271     Q_PROPERTY(QVariant to READ to WRITE setTo NOTIFY toChanged)
272     Q_PROPERTY(QEasingCurve easing READ easing WRITE setEasing NOTIFY easingChanged)
273     Q_PROPERTY(QObject *target READ target WRITE setTargetObject NOTIFY targetChanged)
274     Q_PROPERTY(QString property READ property WRITE setProperty NOTIFY propertyChanged)
275     Q_PROPERTY(QString properties READ properties WRITE setProperties NOTIFY propertiesChanged)
276     Q_PROPERTY(QQmlListProperty<QObject> targets READ targets)
277     Q_PROPERTY(QQmlListProperty<QObject> exclude READ exclude)
278     QML_NAMED_ELEMENT(PropertyAnimation)
279 
280 public:
281     QQuickPropertyAnimation(QObject *parent=nullptr);
282     ~QQuickPropertyAnimation() override;
283 
284     virtual int duration() const;
285     virtual void setDuration(int);
286 
287     QVariant from() const;
288     void setFrom(const QVariant &);
289 
290     QVariant to() const;
291     void setTo(const QVariant &);
292 
293     QEasingCurve easing() const;
294     void setEasing(const QEasingCurve &);
295 
296     QObject *target() const;
297     void setTargetObject(QObject *);
298 
299     QString property() const;
300     void setProperty(const QString &);
301 
302     QString properties() const;
303     void setProperties(const QString &);
304 
305     QQmlListProperty<QObject> targets();
306     QQmlListProperty<QObject> exclude();
307 
308 protected:
309     QQuickStateActions createTransitionActions(QQuickStateActions &actions,
310                                                      QQmlProperties &modified,
311                                                      QObject *defaultTarget = nullptr);
312 
313     QQuickPropertyAnimation(QQuickPropertyAnimationPrivate &dd, QObject *parent);
314     QAbstractAnimationJob* transition(QQuickStateActions &actions,
315                             QQmlProperties &modified,
316                             TransitionDirection direction,
317                             QObject *defaultTarget = nullptr) override;
318 Q_SIGNALS:
319     void durationChanged(int);
320     void fromChanged();
321     void toChanged();
322     void easingChanged(const QEasingCurve &);
323     void propertiesChanged(const QString &);
324     void targetChanged();
325     void propertyChanged();
326 };
327 
328 class Q_QUICK_PRIVATE_EXPORT QQuickColorAnimation : public QQuickPropertyAnimation
329 {
330     Q_OBJECT
331     Q_DECLARE_PRIVATE(QQuickPropertyAnimation)
332     Q_PROPERTY(QColor from READ from WRITE setFrom)
333     Q_PROPERTY(QColor to READ to WRITE setTo)
334     QML_NAMED_ELEMENT(ColorAnimation)
335 
336 public:
337     QQuickColorAnimation(QObject *parent=nullptr);
338     ~QQuickColorAnimation() override;
339 
340     QColor from() const;
341     void setFrom(const QColor &);
342 
343     QColor to() const;
344     void setTo(const QColor &);
345 };
346 
347 class Q_QUICK_PRIVATE_EXPORT QQuickNumberAnimation : public QQuickPropertyAnimation
348 {
349     Q_OBJECT
350     Q_DECLARE_PRIVATE(QQuickPropertyAnimation)
351 
352     Q_PROPERTY(qreal from READ from WRITE setFrom NOTIFY fromChanged)
353     Q_PROPERTY(qreal to READ to WRITE setTo NOTIFY toChanged)
354     QML_NAMED_ELEMENT(NumberAnimation)
355 
356 public:
357     QQuickNumberAnimation(QObject *parent=nullptr);
358     ~QQuickNumberAnimation() override;
359 
360     qreal from() const;
361     void setFrom(qreal);
362 
363     qreal to() const;
364     void setTo(qreal);
365 
366 protected:
367     QQuickNumberAnimation(QQuickPropertyAnimationPrivate &dd, QObject *parent);
368 
369 private:
370     void init();
371 };
372 
373 class Q_QUICK_PRIVATE_EXPORT QQuickVector3dAnimation : public QQuickPropertyAnimation
374 {
375     Q_OBJECT
376     Q_DECLARE_PRIVATE(QQuickPropertyAnimation)
377 
378     Q_PROPERTY(QVector3D from READ from WRITE setFrom NOTIFY fromChanged)
379     Q_PROPERTY(QVector3D to READ to WRITE setTo NOTIFY toChanged)
380     QML_NAMED_ELEMENT(Vector3dAnimation)
381 
382 public:
383     QQuickVector3dAnimation(QObject *parent=nullptr);
384     ~QQuickVector3dAnimation() override;
385 
386     QVector3D from() const;
387     void setFrom(QVector3D);
388 
389     QVector3D to() const;
390     void setTo(QVector3D);
391 };
392 
393 class QQuickRotationAnimationPrivate;
394 class Q_QUICK_PRIVATE_EXPORT QQuickRotationAnimation : public QQuickPropertyAnimation
395 {
396     Q_OBJECT
397     Q_DECLARE_PRIVATE(QQuickRotationAnimation)
398 
399     Q_PROPERTY(qreal from READ from WRITE setFrom NOTIFY fromChanged)
400     Q_PROPERTY(qreal to READ to WRITE setTo NOTIFY toChanged)
401     Q_PROPERTY(RotationDirection direction READ direction WRITE setDirection NOTIFY directionChanged)
402     QML_NAMED_ELEMENT(RotationAnimation)
403 
404 public:
405     QQuickRotationAnimation(QObject *parent=nullptr);
406     ~QQuickRotationAnimation() override;
407 
408     qreal from() const;
409     void setFrom(qreal);
410 
411     qreal to() const;
412     void setTo(qreal);
413 
414     enum RotationDirection { Numerical, Shortest, Clockwise, Counterclockwise };
415     Q_ENUM(RotationDirection)
416     RotationDirection direction() const;
417     void setDirection(RotationDirection direction);
418 
419 Q_SIGNALS:
420     void directionChanged();
421 };
422 
423 class QQuickAnimationGroupPrivate;
424 class Q_QUICK_PRIVATE_EXPORT QQuickAnimationGroup : public QQuickAbstractAnimation
425 {
426     Q_OBJECT
427     Q_DECLARE_PRIVATE(QQuickAnimationGroup)
428 
429     Q_CLASSINFO("DefaultProperty", "animations")
430     Q_PROPERTY(QQmlListProperty<QQuickAbstractAnimation> animations READ animations)
431 
432 public:
433     QQuickAnimationGroup(QObject *parent);
434     ~QQuickAnimationGroup() override;
435 
436     QQmlListProperty<QQuickAbstractAnimation> animations();
437     friend class QQuickAbstractAnimation;
438 
439 protected:
440     QQuickAnimationGroup(QQuickAnimationGroupPrivate &dd, QObject *parent);
441 };
442 
443 class QQuickSequentialAnimation : public QQuickAnimationGroup
444 {
445     Q_OBJECT
446     Q_DECLARE_PRIVATE(QQuickAnimationGroup)
447     QML_NAMED_ELEMENT(SequentialAnimation)
448 
449 public:
450     QQuickSequentialAnimation(QObject *parent=nullptr);
451     ~QQuickSequentialAnimation() override;
452 
453 protected:
454     ThreadingModel threadingModel() const override;
455     QAbstractAnimationJob* transition(QQuickStateActions &actions,
456                             QQmlProperties &modified,
457                             TransitionDirection direction,
458                             QObject *defaultTarget = nullptr) override;
459 };
460 
461 class Q_QUICK_PRIVATE_EXPORT QQuickParallelAnimation : public QQuickAnimationGroup
462 {
463     Q_OBJECT
464     Q_DECLARE_PRIVATE(QQuickAnimationGroup)
465     QML_NAMED_ELEMENT(ParallelAnimation)
466 
467 public:
468     QQuickParallelAnimation(QObject *parent=nullptr);
469     ~QQuickParallelAnimation() override;
470 
471 protected:
472     ThreadingModel threadingModel() const override;
473     QAbstractAnimationJob* transition(QQuickStateActions &actions,
474                             QQmlProperties &modified,
475                             TransitionDirection direction,
476                             QObject *defaultTarget = nullptr) override;
477 };
478 
479 
480 QT_END_NAMESPACE
481 
482 QML_DECLARE_TYPE(QQuickAbstractAnimation)
483 QML_DECLARE_TYPE(QQuickPauseAnimation)
484 QML_DECLARE_TYPE(QQuickScriptAction)
485 QML_DECLARE_TYPE(QQuickPropertyAction)
486 QML_DECLARE_TYPE(QQuickPropertyAnimation)
487 QML_DECLARE_TYPE(QQuickColorAnimation)
488 QML_DECLARE_TYPE(QQuickNumberAnimation)
489 QML_DECLARE_TYPE(QQuickSequentialAnimation)
490 QML_DECLARE_TYPE(QQuickParallelAnimation)
491 QML_DECLARE_TYPE(QQuickVector3dAnimation)
492 QML_DECLARE_TYPE(QQuickRotationAnimation)
493 
494 #endif // QQUICKANIMATION_H
495