/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtDeclarative module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "private/qdeclarativeanimation_p.h"

#include "private/qdeclarativeanimation_p_p.h"

#include "private/qdeclarativebehavior_p.h"

#include "private/qdeclarativestateoperations_p.h"

#include "private/qdeclarativecontext_p.h"

#include <qdeclarativepropertyvaluesource.h>

#include <qdeclarative.h>

#include <qdeclarativeinfo.h>

#include <qdeclarativeexpression.h>

#include <qdeclarativestringconverters_p.h>

#include <qdeclarativeglobal_p.h>

#include <qdeclarativemetatype_p.h>

#include <qdeclarativevaluetype_p.h>

#include <qdeclarativeproperty_p.h>

#include <qdeclarativeengine_p.h>

#include <qvariant.h>

#include <qcolor.h>

#include <qfile.h>

#include <QParallelAnimationGroup>

#include <QSequentialAnimationGroup>

#include <QtCore/qset.h>

#include <QtCore/qrect.h>

#include <QtCore/qpoint.h>

#include <QtCore/qsize.h>

#include <QtCore/qmath.h>

#include <private/qvariantanimation_p.h>

QT_BEGIN_NAMESPACE

/*!

    \qmlclass Animation QDeclarativeAbstractAnimation

    \since 4.7

    \brief The Animation element is the base of all QML animations.

    The Animation element cannot be used directly in a QML file.  It exists

    to provide a set of common properties and methods, available across all the

    other animation types that inherit from it.  Attempting to use the Animation

    element directly will result in an error.

*/

QDeclarativeAbstractAnimation::QDeclarativeAbstractAnimation(QObject *parent)

: QObject(*(new QDeclarativeAbstractAnimationPrivate), parent)

{

}

QDeclarativeAbstractAnimation::~QDeclarativeAbstractAnimation()

{

}

QDeclarativeAbstractAnimation::QDeclarativeAbstractAnimation(QDeclarativeAbstractAnimationPrivate &dd, QObject *parent)

: QObject(dd, parent)

{

}

/*!

    \qmlproperty bool Animation::running

    This property holds whether the animation is currently running.

    The \c running property can be set to declaratively control whether or not

    an animation is running.  The following example will animate a rectangle

    whenever the \l MouseArea is pressed.

    \code

    Rectangle {

        width: 100; height: 100

        NumberAnimation on x {

            running: myMouse.pressed

            from: 0; to: 100

        }

        MouseArea { id: myMouse }

    }

    \endcode

    Likewise, the \c running property can be read to determine if the animation

    is running.  In the following example the text element will indicate whether

    or not the animation is running.

    \code

    NumberAnimation { id: myAnimation }

    Text { text: myAnimation.running ? "Animation is running" : "Animation is not running" }

    \endcode

    Animations can also be started and stopped imperatively from JavaScript

    using the \c start() and \c stop() methods.

    By default, animations are not running. Though, when the animations are assigned to properties,

    as property value sources using the \e on syntax, they are set to running by default.

*/

bool QDeclarativeAbstractAnimation::isRunning() const

{

    Q_D(const QDeclarativeAbstractAnimation);

    return d->running;

}

// the behavior calls this function

void QDeclarativeAbstractAnimation::notifyRunningChanged(bool running)

{

    Q_D(QDeclarativeAbstractAnimation);

    if (d->disableUserControl && d->running != running) {

        d->running = running;

        emit runningChanged(running);

    }

}

//commence is called to start an animation when it is used as a

//simple animation, and not as part of a transition

void QDeclarativeAbstractAnimationPrivate::commence()

{

    Q_Q(QDeclarativeAbstractAnimation);

    QDeclarativeStateActions actions;

    QDeclarativeProperties properties;

    q->transition(actions, properties, QDeclarativeAbstractAnimation::Forward);

    q->qtAnimation()->start();

    if (q->qtAnimation()->state() != QAbstractAnimation::Running) {

        running = false;

        emit q->completed();

    }

}

QDeclarativeProperty QDeclarativeAbstractAnimationPrivate::createProperty(QObject *obj, const QString &str, QObject *infoObj)

{

    QDeclarativeProperty prop(obj, str, qmlContext(infoObj));

    if (!prop.isValid()) {

        qmlInfo(infoObj) << QDeclarativeAbstractAnimation::tr("Cannot animate non-existent property \"%1\"").arg(str);

        return QDeclarativeProperty();

    } else if (!prop.isWritable()) {

        qmlInfo(infoObj) << QDeclarativeAbstractAnimation::tr("Cannot animate read-only property \"%1\"").arg(str);

        return QDeclarativeProperty();

    }

    return prop;

}

void QDeclarativeAbstractAnimation::setRunning(bool r)

{

    Q_D(QDeclarativeAbstractAnimation);

    if (!d->componentComplete) {

        if (d->running && r == d->running)    //don't re-register

            return;

        d->running = r;

        if (r == false)

            d->avoidPropertyValueSourceStart = true;

        else {

            QDeclarativeEnginePrivate *engPriv = QDeclarativeEnginePrivate::get(qmlEngine(this));

            engPriv->registerFinalizedParserStatusObject(this, this->metaObject()->indexOfSlot("componentFinalized()"));

        }

        return;

    }

    if (d->running == r)

        return;

    if (d->group || d->disableUserControl) {

        qmlInfo(this) << "setRunning() cannot be used on non-root animation nodes.";

        return;

    }

    d->running = r;

    if (d->running) {

        if (d->alwaysRunToEnd && d->loopCount != 1

            && qtAnimation()->state() == QAbstractAnimation::Running) {

            //we've restarted before the final loop finished; restore proper loop count

            if (d->loopCount == -1)

                qtAnimation()->setLoopCount(d->loopCount);

            else

                qtAnimation()->setLoopCount(qtAnimation()->currentLoop() + d->loopCount);

        }

        if (!d->connectedTimeLine) {

            QObject::connect(qtAnimation(), SIGNAL(finished()),

                             this, SLOT(timelineComplete()));

            d->connectedTimeLine = true;

        }

        d->commence();

        emit started();

    } else {

        if (d->alwaysRunToEnd) {

            if (d->loopCount != 1)

                qtAnimation()->setLoopCount(qtAnimation()->currentLoop()+1);    //finish the current loop

        } else

            qtAnimation()->stop();

        emit completed();

    }

    emit runningChanged(d->running);

}

/*!

    \qmlproperty bool Animation::paused

    This property holds whether the animation is currently paused.

    The \c paused property can be set to declaratively control whether or not

    an animation is paused.

    Animations can also be paused and resumed imperatively from JavaScript

    using the \c pause() and \c resume() methods.

    By default, animations are not paused.

*/

bool QDeclarativeAbstractAnimation::isPaused() const

{

    Q_D(const QDeclarativeAbstractAnimation);

    return d->paused;

}

void QDeclarativeAbstractAnimation::setPaused(bool p)

{

    Q_D(QDeclarativeAbstractAnimation);

    if (d->paused == p)

        return;

    if (d->group || d->disableUserControl) {

        qmlInfo(this) << "setPaused() cannot be used on non-root animation nodes.";

        return;

    }

    d->paused = p;

    if (d->paused)

        qtAnimation()->pause();

    else

        qtAnimation()->resume();

    emit pausedChanged(d->paused);

}

void QDeclarativeAbstractAnimation::classBegin()

{

    Q_D(QDeclarativeAbstractAnimation);

    d->componentComplete = false;

}

void QDeclarativeAbstractAnimation::componentComplete()

{

    Q_D(QDeclarativeAbstractAnimation);

    d->componentComplete = true;

}

void QDeclarativeAbstractAnimation::componentFinalized()

{

    Q_D(QDeclarativeAbstractAnimation);

    if (d->running) {

        d->running = false;

        setRunning(true);

    }

}

/*!

    \qmlproperty bool Animation::alwaysRunToEnd

    This property holds whether the animation should run to completion when it is stopped.

    If this true the animation will complete its current iteration when it

    is stopped - either by setting the \c running property to false, or by

    calling the \c stop() method.  The \c complete() method is not effected

    by this value.

    This behavior is most useful when the \c repeat property is set, as the

    animation will finish playing normally but not restart.

    By default, the alwaysRunToEnd property is not set.

*/

bool QDeclarativeAbstractAnimation::alwaysRunToEnd() const

{

    Q_D(const QDeclarativeAbstractAnimation);

    return d->alwaysRunToEnd;

}

void QDeclarativeAbstractAnimation::setAlwaysRunToEnd(bool f)

{

    Q_D(QDeclarativeAbstractAnimation);

    if (d->alwaysRunToEnd == f)

        return;

    d->alwaysRunToEnd = f;

    emit alwaysRunToEndChanged(f);

}

/*!

    \qmlproperty int Animation::loops

    This property holds the number of times the animation should play.

    By default, \c loops is 1: the animation will play through once and then stop.

    If set to Animation.Infinite, the animation will continuously repeat until it is explicitly

    stopped - either by setting the \c running property to false, or by calling

    the \c stop() method.

    \code

    Rectangle {

        width: 100; height: 100; color: "green"

        RotationAnimation on rotation {

            loops: Animation.Infinite

            from: 0

            to: 360

        }

    }

    \endcode

*/

int QDeclarativeAbstractAnimation::loops() const

{

    Q_D(const QDeclarativeAbstractAnimation);

    return d->loopCount;

}

void QDeclarativeAbstractAnimation::setLoops(int loops)

{

    Q_D(QDeclarativeAbstractAnimation);

    if (loops < 0)

        loops = -1;

    if (loops == d->loopCount)

        return;

    d->loopCount = loops;

    qtAnimation()->setLoopCount(loops);

    emit loopCountChanged(loops);

}

int QDeclarativeAbstractAnimation::currentTime()

{

    return qtAnimation()->currentLoopTime();

}

void QDeclarativeAbstractAnimation::setCurrentTime(int time)

{

    qtAnimation()->setCurrentTime(time);

}

QDeclarativeAnimationGroup *QDeclarativeAbstractAnimation::group() const

{

    Q_D(const QDeclarativeAbstractAnimation);

    return d->group;

}

void QDeclarativeAbstractAnimation::setGroup(QDeclarativeAnimationGroup *g)

{

    Q_D(QDeclarativeAbstractAnimation);

    if (d->group == g)

        return;

    if (d->group)

        static_cast<QDeclarativeAnimationGroupPrivate *>(d->group->d_func())->animations.removeAll(this);

    d->group = g;

    if (d->group && !static_cast<QDeclarativeAnimationGroupPrivate *>(d->group->d_func())->animations.contains(this))

        static_cast<QDeclarativeAnimationGroupPrivate *>(d->group->d_func())->animations.append(this);

    //if (g) //if removed from a group, then the group should no longer be the parent

        setParent(g);

}

/*!

    \qmlmethod Animation::start()

    \brief Starts the animation.

    If the animation is already running, calling this method has no effect.  The

    \c running property will be true following a call to \c start().

*/

void QDeclarativeAbstractAnimation::start()

{

    setRunning(true);

}

/*!

    \qmlmethod Animation::pause()

    \brief Pauses the animation.

    If the animation is already paused, calling this method has no effect.  The

    \c paused property will be true following a call to \c pause().

*/

void QDeclarativeAbstractAnimation::pause()

{

    setPaused(true);

}

/*!

    \qmlmethod Animation::resume()

    \brief Resumes a paused animation.

    If the animation is not paused, calling this method has no effect.  The

    \c paused property will be false following a call to \c resume().

*/

void QDeclarativeAbstractAnimation::resume()

{

    setPaused(false);

}

/*!

    \qmlmethod Animation::stop()

    \brief Stops the animation.

    If the animation is not running, calling this method has no effect.  The

    \c running property will be false following a call to \c stop().

    Normally \c stop() stops the animation immediately, and the animation has

    no further influence on property values.  In this example animation

    \code

    Rectangle {

        NumberAnimation on x { from: 0; to: 100; duration: 500 }

    }

    \endcode

    was stopped at time 250ms, the \c x property will have a value of 50.

    However, if the \c alwaysRunToEnd property is set, the animation will

    continue running until it completes and then stop.  The \c running property

    will still become false immediately.

*/

void QDeclarativeAbstractAnimation::stop()

{

    setRunning(false);

}

/*!

    \qmlmethod Animation::restart()

    \brief Restarts the animation.

    This is a convenience method, and is equivalent to calling \c stop() and

    then \c start().

*/

void QDeclarativeAbstractAnimation::restart()

{

    stop();

    start();

}

/*!

    \qmlmethod Animation::complete()

    \brief Stops the animation, jumping to the final property values.

    If the animation is not running, calling this method has no effect.  The

    \c running property will be false following a call to \c complete().

    Unlike \c stop(), \c complete() immediately fast-forwards the animation to

    its end.  In the following example,

    \code

    Rectangle {

        NumberAnimation on x { from: 0; to: 100; duration: 500 }

    }

    \endcode

    calling \c stop() at time 250ms will result in the \c x property having

    a value of 50, while calling \c complete() will set the \c x property to

    100, exactly as though the animation had played the whole way through.

*/

void QDeclarativeAbstractAnimation::complete()

{

    if (isRunning()) {

         qtAnimation()->setCurrentTime(qtAnimation()->duration());

    }

}

void QDeclarativeAbstractAnimation::setTarget(const QDeclarativeProperty &p)

{

    Q_D(QDeclarativeAbstractAnimation);

    d->defaultProperty = p;

    if (!d->avoidPropertyValueSourceStart)

        setRunning(true);

}

/*

    we rely on setTarget only being called when used as a value source

    so this function allows us to do the same thing as setTarget without

    that assumption

*/

void QDeclarativeAbstractAnimation::setDefaultTarget(const QDeclarativeProperty &p)

{

    Q_D(QDeclarativeAbstractAnimation);

    d->defaultProperty = p;

}

/*

    don't allow start/stop/pause/resume to be manually invoked,

    because something else (like a Behavior) already has control

    over the animation.

*/

void QDeclarativeAbstractAnimation::setDisableUserControl()

{