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

**

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

** All rights reserved.

** Contact: Nokia Corporation (developer.feedback@nokia.com)

**

** This file is part of the HbCore module of the UI Extensions for Mobile.

**

** GNU Lesser General Public License Usage

** 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 developer.feedback@nokia.com.

**

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

#include "hbeffecttranslate_p.h"

#include "hbeffectanimation_p.h"

#include "hbeffectutils_p.h"

#include "hbeffectgroup_p.h"

#include "hbeffectdef_p.h"

#include <QGraphicsItem>

#include <QtDebug>

HbEffectTranslateAnimation::HbEffectTranslateAnimation(

    HbEffectGroup *group,

    HbEffectTranslate *effect,

    int duration) :

        effect(effect)

{

    setDuration(duration);

}

void HbEffectTranslateAnimation::setOriginalPos(qreal pos)

{

    originalPos = pos;

}

void HbEffectTranslateAnimation::handleAnimationUpdate(const QVariant &value)

{

        currentPos = qVariantValue<qreal>(value);

    }

}

void HbEffectTranslateAnimation::handleAnimationFinish()

{

    // This informs the effect group when both translate_x and translate_y have finished

    effect->handleAnimationFinished();

}

// HbEffectTranslate

HbEffectTranslate::HbEffectTranslate(

    const QList<HbEffectFxmlParamData> &data,

    QGraphicsItem *item,

    HbEffectGroup *group) :

        HbEffectAbstract(0, item, group),

        mAnimationX(0),

        mAnimationY(0)

{

    // Default values if something is not passed in FXML

    int durationX = 0;

    int durationY = 0;

    QEasingCurve curveShapeX = QEasingCurve::Linear;

    QEasingCurve curveShapeY = QEasingCurve::Linear;

    const HbEffectFxmlParamData* paramX = 0;

    const HbEffectFxmlParamData* paramY = 0;

    // Handle FXML parameters

    Q_FOREACH(const HbEffectFxmlParamData &param, data) {

	    if (param.name() == FXML_KEYWORD_TRANSLATION_X) {

            mKeyFrameListX = param.keyFrames();

            HbEffectUtils::resolveFxmlDuration(durationX, param);

            HbEffectUtils::resolveFxmlCurveShape(curveShapeX, param);

			mStartXRef = param.startRef();

			mEndXRef = param.endRef();

			mStartX = param.getAttribute(FXML_KEYWORD_START);

			mEndX = param.getAttribute(FXML_KEYWORD_END);

            // Only if "start ref" and "end ref" are not used, read parameter's "ref" attribute

            if (mStartXRef.isEmpty() && mEndXRef.isEmpty()) {

                mParamRefX = param.getAttribute(FXML_PARAM_REF);

            }

            paramX = &param;

	    }

	    else if (param.name() == FXML_KEYWORD_TRANSLATION_Y) {

            mKeyFrameListY = param.keyFrames();

            HbEffectUtils::resolveFxmlDuration(durationY, param);

            HbEffectUtils::resolveFxmlCurveShape(curveShapeY, param);

			mStartYRef = param.startRef();

			mEndYRef = param.endRef();

			mStartY = param.getAttribute(FXML_KEYWORD_START);

			mEndY = param.getAttribute(FXML_KEYWORD_END);

            // Only if "start ref" and "end ref" are not used, read parameter's "ref" attribute

            if (mStartYRef.isEmpty() && mEndYRef.isEmpty()) {

                mParamRefY = param.getAttribute(FXML_PARAM_REF);

            }

            paramY = &param;

	    }

    }

    if (durationX > 0) {

        mAnimationX = new HbEffectTranslateAnimation(group, this, durationX);

        mAnimationX->mCurve = curveShapeX;

    }

    // Create at least one animation even if both durations are zero for handling animation finish easily.

    if (durationY > 0 || !mAnimationX) {

        mAnimationY = new HbEffectTranslateAnimation(group, this, durationY);

        mAnimationY->mCurve = curveShapeY;

    }

}

/*  Deletes the effect and rewinds the animation so that next animation can start,

    rewind is necessary as the general use case is that the effect is restarted before 

    being complete, in which case the rewind would transform the item and prepare for

    the next effect,otherwise would result in flicker.

*/

HbEffectTranslate::~HbEffectTranslate()

{

    if (mAnimationX) {

        mAnimationX->stop();

        delete mAnimationX;

    }

    if (mAnimationY) {

        mAnimationY->stop();

        delete mAnimationY;

    }

}

QString HbEffectTranslate::name() const

{

    return HB_EFFECT_NAME_TRANSLATE;

}

void HbEffectTranslate::init()

{

    // Resolve the dynamic attributes at this point

    bool valueOk;

    const QRectF &extRect = group()->extRect();

    // StartX

    qreal value = HbEffectUtils::resolveFxmlRef(

        mStartXRef, mStartX, &valueOk, item(), HbEffectUtils::Position, extRect);

    if (valueOk) {

        mStartXValue = value;

    } else {

        // Failed to resolve parameters, use item's current position.

        mStartXValue = item()->pos().x();

    }

    // StartY

    value = HbEffectUtils::resolveFxmlRef(

        mStartYRef, mStartY, &valueOk, item(), HbEffectUtils::Position, extRect);

    if (valueOk) {

        mStartYValue = value;

    } else {

        // Failed to resolve parameters, use item's current position.

        mStartYValue = item()->pos().y();

    }

    // EndX

    value = HbEffectUtils::resolveFxmlRef(

        mEndXRef, mEndX, &valueOk, item(), HbEffectUtils::Position, extRect);

    if (valueOk) {

        mEndXValue = value;

    } else {

        // Failed to resolve parameters, use item's current position.

        mEndXValue = item()->pos().x();

    }

    // EndY

    value = HbEffectUtils::resolveFxmlRef(

        mEndYRef, mEndY, &valueOk, item(), HbEffectUtils::Position, extRect);

    if (valueOk) {

        mEndYValue = value;

    } else {

        // Failed to resolve parameters, use item's current position.

        mEndYValue = item()->pos().y();

    }

    if (mAnimationX) {

        mAnimationX->setOriginalPos(item()->pos().x());

        mAnimationX->setStartValue(QVariant(mStartXValue));

        mAnimationX->setEndValue(QVariant(mEndXValue));

        bool startEndRefUsed = !mStartXRef.isEmpty() && !mEndXRef.isEmpty();

        // Set keyframes in animation

        foreach(const HbKeyFrame &kf, mKeyFrameListX) {

            // If start and end references are used,

            // value at given step is (1-c)*startX + c*endX where c is the keyframe coefficient value

            if (startEndRefUsed) {

                value = (1 - kf.val) * mStartXValue + kf.val * mEndXValue;

            }

            // Otherwise c defines the value

            else {

                value = HbEffectUtils::resolveFxmlRef(

                    mParamRefX, QString().setNum(kf.val), &valueOk, item(), HbEffectUtils::Position, extRect);

                if (!valueOk) {

                    // Default to item's position if failed

                    value = item()->pos().x();

                }

            }

            mAnimationX->setKeyValueAt(kf.pos, QVariant(value));

            // Update also stored start and end values if keyframe refers to those

            if (HbEffectUtils::fuzzyIsNull(kf.pos)) {

                mStartXValue = value;

            } else if (HbEffectUtils::fuzzyIsOneOrGreater(kf.pos)) {

                mEndXValue = value;

            }

        }

    }

    if (mAnimationY) {

        mAnimationY->setOriginalPos(item()->pos().y());

        mAnimationY->setStartValue(QVariant(mStartYValue));

        mAnimationY->setEndValue(QVariant(mEndYValue));

        bool startEndRefUsed = !mStartYRef.isEmpty() && !mEndYRef.isEmpty();

        // Set keyframes in animation

        foreach(const HbKeyFrame &kf, mKeyFrameListY) {

            // If start and end references are used,

            // value at given step is (1-c)*startY + c*endY where c is the keyframe coefficient value

            if (startEndRefUsed) {

                value = (1 - kf.val) * mStartYValue + kf.val * mEndYValue;

            }

            // Otherwise c defines the relative value to parameter's reference

            else {

                value = HbEffectUtils::resolveFxmlRef(

                    mParamRefY, QString().setNum(kf.val), &valueOk, item(), HbEffectUtils::Position, extRect);

                if (!valueOk) {

                    // Default to item's position if failed

                    value = item()->pos().y();

                }

            }

            mAnimationY->setKeyValueAt(kf.pos, QVariant(value));

            // Update also stored start and end values if keyframe refers to those

            if (HbEffectUtils::fuzzyIsNull(kf.pos)) {

                mStartYValue = value;

            } else if (HbEffectUtils::fuzzyIsOneOrGreater(kf.pos)) {

                mEndYValue = value;

            }

        }

    }

}

void HbEffectTranslate::setStartState(QTransform &transform)

{   

    qreal translateX = mAnimationX ? mStartXValue - mAnimationX->originalPos : 0;

    qreal translateY = mAnimationY ? mStartYValue - mAnimationY->originalPos : 0;

    QTransform newTransform;

    newTransform.translate(translateX, translateY);

    // Combine the new transform with the existing one

    transform *= newTransform;

}

/*  Starts the translate effect animation. If the effect is already started,

the result is undefined.

*/

void HbEffectTranslate::start()

{

    if (mAnimationX) {

        mAnimationX->stop(); // rewind the animation before starting again

        mAnimationX->setCurrentTime(0);

        mAnimationX->mFinished = false;

        mAnimationX->start();

    }

    if (mAnimationY) {

        mAnimationY->stop(); // rewind the animation before starting again

        mAnimationY->setCurrentTime(0);

        mAnimationY->mFinished = false;

        mAnimationY->start();

    }

}

/*  Cancels the effect animation and sets the animation end state immediately.

*/

void HbEffectTranslate::cancel(QTransform &transform, bool itemIsValid)

{

    Q_UNUSED(itemIsValid)

    if (mAnimationX) {

        mAnimationX->stop();

    }

    if (mAnimationY) {

        mAnimationY->stop();

    }

    qreal translateX = mAnimationX ? mEndXValue - mAnimationX->originalPos : 0;

    qreal translateY = mAnimationY ? mEndYValue - mAnimationY->originalPos : 0;

    // This will set the endstate for the object correctly when cancelling effect

    QTransform newTransform;

    newTransform.translate(translateX, translateY);

    // Combine the new transform with the existing one

    transform *= newTransform;

}

void HbEffectTranslate::updateItemTransform(QTransform &transform)

{

    qreal translateX = mAnimationX ? mAnimationX->currentPos - mAnimationX->originalPos : 0;

    qreal translateY = mAnimationY ? mAnimationY->currentPos - mAnimationY->originalPos : 0;

    QTransform newTransform;

    newTransform.translate(translateX, translateY);

    // Combine the new transform with the existing one

    transform *= newTransform;

}

void HbEffectTranslate::handleAnimationFinished()

{

    bool allFinished = true;

    if (mAnimationX && !mAnimationX->mFinished) {

        allFinished = false;

    }

    if (mAnimationY && !mAnimationY->mFinished) {

        allFinished = false;

    }

    // Inform the effect group that the whole translate effect has finished (both translate_x and translate_y)

    if (allFinished) {

        group()->effectFinished();

    }

}

void HbEffectTranslate::pause()

{

    if (mAnimationX) {

        mAnimationX->pause();

    }

    if (mAnimationY) {

        mAnimationY->pause();

    }

}

void HbEffectTranslate::resume()

{

    if (mAnimationX) {

        mAnimationX->resume();

    }

    if (mAnimationY) {

        mAnimationY->resume();

    }

}