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

**

** 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 "hbeffectscale_p.h"

#include "hbeffectanimation_p.h"

#include "hbeffectutils_p.h"

#include "hbeffectgroup_p.h"

#include "hbeffectscaleanimation_p.h"

#include "hbeffectdef_p.h"

#include <QGraphicsItem>

#include <QtDebug>

#include <QVariantAnimation>

HbEffectScaleAnimation::HbEffectScaleAnimation(

    HbEffectGroup *group,

    HbEffectScale *effect,

{

    setDuration(duration);

}

void HbEffectScaleAnimation::setCenter(qreal center)

{

    mCenter = center;

}

void HbEffectScaleAnimation::handleAnimationUpdate(const QVariant &value)

{

    if (mGroup->isRunning()) {

        mCurrentScaling = qVariantValue<qreal>(value);

        // Prevent negative scale factors, they crash QT.

        if (mCurrentScaling < 0) {

            mCurrentScaling = 0;

        }

        mGroup->updateItemTransform();

    }

}

void HbEffectScaleAnimation::handleAnimationFinish()

{

    // This informs the effect group when both scale_x and scale_y have finished

    mEffect->handleAnimationFinished();

}

// -----------------------------------------------------------------------------

// HbEffectScale

HbEffectScale::HbEffectScale(

    const QList<HbEffectFxmlParamData> &data,

    QGraphicsItem *item,

    HbEffectGroup *group) :

{

    int durationX = 0;

    int durationY = 0;

    QEasingCurve curveX = QEasingCurve::Linear;

    QEasingCurve curveY = QEasingCurve::Linear;

    // Default values if not defined in the data. Value 1.0f means the item's "identity" i.e. its normal size.

    mStartXValue = 1.0f;

    mEndXValue = 1.0f;

    mStartYValue = 1.0f;

    mEndYValue = 1.0f;

    mCenterXValue = 0;

    mCenterYValue = 0;

            mKeyFrameListX = param.keyFrames();

            HbEffectUtils::resolveFxmlDuration(durationX, param);

            HbEffectUtils::resolveFxmlCurveShape(curveX, param);

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

            if (mStartWidthRef.isEmpty() && mEndWidthRef.isEmpty()) {

                mParamRefX = param.getAttribute(FXML_PARAM_REF);

            }

            paramX = &param;

            mKeyFrameListY = param.keyFrames();

            HbEffectUtils::resolveFxmlDuration(durationY, param);

            HbEffectUtils::resolveFxmlCurveShape(curveY, param);

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

            if (mStartHeightRef.isEmpty() && mEndHeightRef.isEmpty()) {

                mParamRefY = param.getAttribute(FXML_PARAM_REF);

            }

            paramY = &param;

            mCenterX = param.getValue();

            mCenterXRef = param.getAttribute(FXML_PARAM_REF);

            mCenterY = param.getValue();

            mCenterYRef = param.getAttribute(FXML_PARAM_REF);

    }

    // Validate references. If start and end references are used, at least one of them must be a visual reference.

    if ((mStartWidthRef.isEmpty() || mStartWidthRef.startsWith(FXML_VISUAL) ||

        // references ok

    } else {

        // Invalid references - disable effect

        durationX = 0;

        durationY = 0;

        mParamRefX.clear();

        mStartWidthRef.clear();

        mStartWidth.clear();

        mEndWidthRef.clear();

        mEndWidth.clear();

        mParamRefY.clear();

        mStartHeightRef.clear();

        mStartHeight.clear();

        mEndHeightRef.clear();

        mEndHeight.clear();

        mCenterX.clear();

        mCenterXRef.clear();

        mCenterY.clear();

        mCenterYRef.clear();

    }

    if (durationX > 0) {

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

        mAnimationX->addLooping(paramX);

        mAnimationX->mCurve = curveX;

    }

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

    if (durationY > 0 || !mAnimationX) {

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

        mAnimationY->addLooping(paramY);

        mAnimationY->mCurve = curveY;

    }

}

/* deletes the effect and rewinds the animation so that next animation can star,

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

    the next effect.

*/

HbEffectScale::~HbEffectScale()

{

    if (mAnimationX) {

        mAnimationX->stop();

        // Applying the cancel policy so that if dynamically new effect is started HbEffect::start then this finishes

        // and the new one starts.

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

        delete mAnimationX;

    }

    if (mAnimationY) {

        mAnimationY->stop();

        delete mAnimationY;

    }

}

QString HbEffectScale::name() const

{

    return HB_EFFECT_NAME_SCALE;

}

void HbEffectScale::init()

{

    QSizeF orgSize = item()->boundingRect().size();

    // Resolve Dynamic attributes at this point

    bool valueOk;

    qreal value;

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

    // start width

    if (!mStartWidth.isEmpty()) {

        value = HbEffectUtils::resolveFxmlRef(

        if (valueOk) {

            mStartXValue = value;

        }

    }

    // start height

    if (!mStartHeight.isEmpty()) {

        value = HbEffectUtils::resolveFxmlRef(mStartHeightRef, mStartHeight, &valueOk, item(), HbEffectUtils::Size, extRect);

        if (valueOk) {

            mStartYValue = value;

        }

    }

    // end width

    if (!mEndWidth.isEmpty()) {

        value = HbEffectUtils::resolveFxmlRef(

        if (valueOk) {

            mEndXValue = value;

        }

    }

    // end height

    if (!mEndHeight.isEmpty()) {

        value = HbEffectUtils::resolveFxmlRef(

        if (valueOk) {

            mEndYValue = value;

        }

    }

    // CenterX

    value = HbEffectUtils::resolveFxmlRef(

    if (valueOk) {

        mCenterXValue = value;

    }

    // CenterY

    value = HbEffectUtils::resolveFxmlRef(

    if (valueOk) {

        mCenterYValue = value;

    }

    // QT's scale animations do not handle 0 value correctly so change it here.

    if (HbEffectUtils::fuzzyIsNull(mStartXValue)) {

        mStartXValue = 0.00002;

    }

    if (HbEffectUtils::fuzzyIsNull(mStartYValue)) {

        mStartYValue = 0.00002;

    }

    if (HbEffectUtils::fuzzyIsNull(mEndXValue)) {

        mEndXValue = 0.00002;

    }

    if (HbEffectUtils::fuzzyIsNull(mEndYValue)) {

        mEndYValue = 0.00002;

    }

    if (mAnimationX) {

        // Start and end values are relative to item's size so value 1 means normal size

        mAnimationX->setStartValue(QVariant(mStartXValue));

        mAnimationX->setEndValue(QVariant(mEndXValue));

        // Center value is in pixels

        mAnimationX->setCenter(mCenterXValue);

        bool startEndRefUsed = !mStartWidthRef.isEmpty() && !mEndWidthRef.isEmpty();

        qreal paramRefValueX = 0.0;

        // Resolve SCALE_X parameter's "ref" value only if that's needed

        if (!startEndRefUsed) {

            paramRefValueX = HbEffectUtils::resolveFxmlRef(

        }

        // Set keyframes in animation

            // 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 = kf.val;

                // Multiply keyframe's value with parameter's "ref" if it is defined

                if (valueOk) {

                    value *= paramRefValueX;

                }

            }

            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) {

        // Start and end values are relative to item's size so value 1 means normal size

        mAnimationY->setStartValue(QVariant(mStartYValue));

        mAnimationY->setEndValue(QVariant(mEndYValue));

        // Center value is in pixels

        mAnimationY->setCenter(mCenterYValue);

        bool startEndRefUsed = !mStartHeightRef.isEmpty() && !mEndHeightRef.isEmpty();

        qreal paramRefValueY = 0.0;

        // Resolve SCALE_Y parameter's "ref" value only if that's needed

        if (!startEndRefUsed) {

            paramRefValueY = HbEffectUtils::resolveFxmlRef(

        }

        // Set keyframes in animation

            // 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 value

            else {

                value = kf.val;

                // Multiply keyframe's value with parameter's "ref" if it is defined

                if (valueOk) {

                    value *= paramRefValueY;

                }

            }

            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 HbEffectScale::setStartState(QTransform &transform)

{

    // Set the start state

    updateItemTransform(transform);

}

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

the result is undefined.

*/

void HbEffectScale::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 HbEffectScale::cancel(QTransform &transform, bool itemIsValid)

{

    Q_UNUSED(itemIsValid)

    if (mAnimationX) {

        mAnimationX->stop();

    }

    if (mAnimationY) {

        mAnimationY->stop();

    }

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

    QTransform newTransform;

    newTransform.translate(mCenterXValue, mCenterYValue);

    newTransform.scale(mEndXValue, mEndYValue);

    newTransform.translate(-mCenterXValue, -mCenterYValue);

    // Combine the new transform with the existing one

    transform *= newTransform;

}

void HbEffectScale::updateItemTransform(QTransform &transform)

{

    QTransform newTransform;

    // Handle centering for scaling the matrix

    newTransform.translate(mCenterXValue, mCenterYValue);

    // Get the current scaling factor from animation or use 1.0 if animation does not exist

    qreal currentScalingX = mAnimationX ? mAnimationX->mCurrentScaling : 1.0;

    qreal currentScalingY = mAnimationY ? mAnimationY->mCurrentScaling : 1.0;

    // Scale the transformation matrix to reach the new scaling factor.

    newTransform.scale(currentScalingX, currentScalingY);

    // Centering must be canceled after the scaling has been done in the matrix

    newTransform.translate(-mCenterXValue, -mCenterYValue);

    // Combine the new transform with the existing one

    transform *= newTransform;

}

void HbEffectScale::handleAnimationFinished()

{

    bool allFinished = true;

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

        allFinished = false;

    }

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

        allFinished = false;

    }

    // Inform the effect group that the whole scale effect has finished (both scaleX and scaleY)

    if (allFinished) {

        group()->effectFinished();

    }

}

void HbEffectScale::pause()

{

    if (mAnimationX) {

        mAnimationX->pause();

    }

    if (mAnimationY) {

        mAnimationY->pause();

    }

}

void HbEffectScale::resume()

{

    if (mAnimationX) {

        mAnimationX->resume();

    }

    if (mAnimationY) {

        mAnimationY->resume();

    }

}