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

**

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

#include "hbeffectdef_p.h"

#include "hbeffectfxmldata_p.h"

#include "hbdeviceprofile.h"

#include <QGraphicsItem>

#include <QEasingCurve>

// ===========================================================================

/*

    \class HbEffectUtils

    \brief HbEffectUtils is an internal helper class used by effect framework.

....HbEffectUtils is an internal class used by effect framework to get common functionalities.

    \warning This class is a part of internal library implementation and may

    be removed or modified!

    \internal

*/

qreal HbEffectUtils::resolveFxmlRef(

    const QString &ref,

    const QString &value,

    bool* ok,

    const QGraphicsItem *item,

    HbEffectUtils::valueType type,

    const QRectF &extRect)

{

    bool valueOk = false;

    bool refOk = false;

    // Resolve value parameter

    qreal ret = value.toFloat(&valueOk);

    qreal refValue = 0;

    bool mapToItemCoordinates = false;

    bool addToPos = false;

    QRectF srcRect;

    bool x = false;

    bool y = false;

    QRectF rect = item->boundingRect();

    if (!ref.isEmpty()) {

        refOk = true; // changed to false if no match

        // Visual values

        if (ref == FXML_KEYWORD_VISUAL_LEFT) {

            refValue = 0;

            addToPos = true;

            x = true;

        }

        else if (ref == FXML_KEYWORD_VISUAL_RIGHT) {

            refValue = rect.width();

            addToPos = true;

            x = true;

        }

        else if (ref == FXML_KEYWORD_VISUAL_TOP) {

            refValue = 0;

            addToPos = true;

            y = true;

        }

        else if (ref == FXML_KEYWORD_VISUAL_BOTTOM) {

            refValue = rect.height();

            addToPos = true;

            y = true;

        }

        else if (ref == FXML_KEYWORD_VISUAL_WIDTH) {

            refValue = rect.width();

            addToPos = true;

            x = true;

        }

        else if (ref == FXML_KEYWORD_VISUAL_HEIGHT) {

            refValue = rect.height();

            addToPos = true;

            y = true;

        }

        else {

            // Reference is something else than visual, so need to map to item's coordinates

            mapToItemCoordinates = true;

            srcRect = extRect;

            // Extrect values

            if (ref == FXML_KEYWORD_EXTRECT_LEFT) {

                refValue = extRect.left();

                x = true;

            }

            else if (ref == FXML_KEYWORD_EXTRECT_RIGHT) {

                refValue = extRect.right();

                x = true;

            }

            else if (ref == FXML_KEYWORD_EXTRECT_TOP) {

                refValue = extRect.top();

                y = true;

            }

            else if (ref == FXML_KEYWORD_EXTRECT_BOTTOM) {

                refValue = extRect.bottom();

                y = true;

            }

            else if (ref == FXML_KEYWORD_EXTRECT_WIDTH) {

                refValue = extRect.width();

                x = true;

            }

            else if (ref == FXML_KEYWORD_EXTRECT_HEIGHT) {

                refValue = extRect.height();

                y = true;

            }

            else {

			    // Screen values

			    QSize screenSize = HbDeviceProfile::profile(item).logicalSize();

                srcRect = QRectF(QPointF(0,0), screenSize);

                if (ref == FXML_KEYWORD_SCREEN_LEFT) {

                    refValue = 0;

                    x = true;

                }

                else if (ref == FXML_KEYWORD_SCREEN_RIGHT) {

                    refValue = screenSize.width();

                    x = true;

                }

                else if (ref == FXML_KEYWORD_SCREEN_TOP) {

                    refValue = 0;

                    y = true;

                }

                else if (ref == FXML_KEYWORD_SCREEN_BOTTOM) {

                    refValue = screenSize.height();

                    y = true;

                }

                else if (ref == FXML_KEYWORD_SCREEN_WIDTH) {

                    refValue = screenSize.width();

                    x = true;

                }

                else if (ref == FXML_KEYWORD_SCREEN_HEIGHT) {

                    refValue = screenSize.height();

                    y = true;

                }

                // If nothing matched, set ok to false

                else {

                    refOk = false;

                }

            }

        }

    }

    if (refOk) {

        // If value is ok, multiply reference value with it (e.g. 0.5 x screen.height)

        if (valueOk) {

            refValue *= ret;

        }

        // Add calculated value to item position if the reference was visual's width or height

        if (addToPos && type == HbEffectUtils::Position) {

            if (x) {

                refValue += item->pos().x();

            }

            else {

                refValue += item->pos().y();

            }

        }

        if (type == HbEffectUtils::Position || type == HbEffectUtils::Center) {

            // Map to parent coordinates if needed

            if (mapToItemCoordinates && item->parentItem()) {

                if (x) {

                    refValue = item->mapToParent(item->mapFromScene(refValue, 0)).x();

                } else if (y) {

                    refValue = item->mapToParent(item->mapFromScene(0, refValue)).y();

                }

            }

            // Calculate distance from item origin if needed

            if (type == HbEffectUtils::Center && mapToItemCoordinates) {

                if (x) {

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

                } else if (y) {

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

                }

            }

        }

        // Convert to item size units if needed

        if (type == HbEffectUtils::Size) {

            if (x) {

                if (!fuzzyIsNull(rect.width()))

                    refValue /= rect.width();

                 else

                    refValue = 0;

            } else if (y) {

                if (!fuzzyIsNull(rect.height()))

                    refValue /= rect.height();

                else

                    refValue = 0;

            }            

        }

        // This operation is needed e.g. when scale is done from some other rect to target rect

        if (type == HbEffectUtils::CenterMappedToTargetRect && mapToItemCoordinates) {

            QPointF scenePos = item->scenePos();

            // If the item is already translated, have to substract that to get correct result

            QTransform trans = item->transform();

            qreal dx = trans.dx();

            qreal dy = trans.dy();

            scenePos -= QPointF(dx, dy);

            if (x) {

                qreal divider = srcRect.width() - rect.width();

                qreal mapped = !fuzzyIsNull(divider) ? (scenePos.x() - srcRect.left()) / divider : 0;

                mapped *= rect.width();

                // TODO: how should refvalue affect here?

                refValue = mapped;

            } else {

                qreal divider = srcRect.height() - rect.height();

                qreal mapped = !fuzzyIsNull(divider) ? (scenePos.y() - srcRect.top()) / divider : 0;

                mapped *= rect.height();

                // TODO: how should refvalue affect here?

                refValue = mapped;

            }

        }

        ret = refValue;

    }

    *ok = valueOk || refOk;

    return ret;

}

qreal HbEffectUtils::resolveFxmlRef(

    const HbEffectFxmlParamData &data, bool* ok, const QGraphicsItem *item, HbEffectUtils::valueType type, const QRectF &extRect)

{

    return HbEffectUtils::resolveFxmlRef(data.getAttribute(FXML_PARAM_REF), data.getValue(), ok, item, type, extRect);

}

void HbEffectUtils::resolveFxmlCurveShape(QEasingCurve &curve, const HbEffectFxmlParamData &data)

{

    QString style = data.getAttribute(FXML_STYLE);

    if (!style.isEmpty()) {

        if (style == FXML_KEYWORD_STYLE_LINEAR) {

            curve = QEasingCurve::Linear;

        }

        else if (style == FXML_KEYWORD_STYLE_INQUAD) {

            curve = QEasingCurve::InQuad;

        }

        else if (style == FXML_KEYWORD_STYLE_OUTQUAD) {

            curve = QEasingCurve::OutQuad;

        }

        else if (style == FXML_KEYWORD_STYLE_INOUTQUAD) {

            curve = QEasingCurve::InOutQuad;

        }

        else if (style == FXML_KEYWORD_STYLE_OUTINQUAD) {

            curve = QEasingCurve::OutInQuad;

        }

        else if (style == FXML_KEYWORD_STYLE_INBACK) {

            curve = QEasingCurve::InBack;

        }

        else if (style == FXML_KEYWORD_STYLE_OUTBACK) {

            curve = QEasingCurve::OutBack;

        }

        else if (style == FXML_KEYWORD_STYLE_INOUTBACK) {

            curve = QEasingCurve::InOutBack;

        }

        else if (style == FXML_KEYWORD_STYLE_OUTINBACK) {

            curve = QEasingCurve::OutInBack;

        }

   }

}

void HbEffectUtils::resolveFxmlDuration(int &duration, const HbEffectFxmlParamData &data)

{

    QString string = data.duration();

    if (!string.isEmpty()) {

        bool ok = false;

        qreal value = string.toFloat(&ok);

        if (ok) {

            duration = (int)(value * 1000); // convert to milliseconds

        }

    }

}