/*

* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:   Implements attributesetters for curvePathLayout.

*

*/

//includes

//widget model includes

#include "alf/alfattributecontainer.h"

#include "alf/alfattributevaluetype.h"

#include "alf/alfattribute.h"

#include "alf/alfcurvepathlayoutattributesetter.h"

#include <alf/alfvisualexception.h>

#include <alf/alfdataexception.h>

#include <alf/alfattributeexception.h>

//osn includes

#include <osn/ustring.h>

//alf includes

#include <alf/alfenv.h>

#include <alf/alfcurvepathlayout.h>

#include <alf/alfcurvepath.h>

//dui includes

#include "alf/attrproperty.h"

//other includes

#include <libc/string.h>

#include <utf.h>

//namespaces

using namespace osncore;

using namespace duiuimodel::commonvisualattributes;

using namespace duiuimodel::layoutattributes;

using namespace duiuimodel::curvepathattributes;

namespace Alf

    {

static void throwIfErr ( int aErr )

    {

    if (aErr!=KErrNone)

        {

        ALF_THROW ( AlfAttributeException, aErr,

                    "AlfCurvePathLayoutAttributeSetter")

        }

    }

// ======== MEMBER FUNCTIONS ========

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

// Constructor.

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

//

OSN_EXPORT AlfCurvePathLayoutAttributeSetter::

AlfCurvePathLayoutAttributeSetter()

    {

    }

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

// Destructor.

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

//

OSN_EXPORT AlfCurvePathLayoutAttributeSetter::

~AlfCurvePathLayoutAttributeSetter()

    {

    }

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

// Sets Attribute Value. Delegates based on attribute Category.

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

//

OSN_EXPORT void AlfCurvePathLayoutAttributeSetter::setAttributeValue (

    CAlfVisual &aVisual,

    AlfAttributeContainer* aContainer,

    IAlfMap* aData )

    {

    CAlfCurvePathLayout* curvepathlayout =

        dynamic_cast<CAlfCurvePathLayout*>(&aVisual);

    if ( !curvepathlayout )

        {

        ALF_THROW ( AlfVisualException, EInvalidVisual,

                    "AlfCurvePathLayoutAttributeSetter" )

        }

    curvepathlayout->CurvePath().Reset();

    AlfCommonLayoutAttributeSetter::setAttributeValue(aVisual, aContainer,

            aData);

    }

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

// Deprecated

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

//

OSN_EXPORT TAlfCommand* AlfCurvePathLayoutAttributeSetter::createCommand (

    CAlfVisual& /*aVisual*/,

    AlfAttributeContainer* /*aContainer*/,

    IAlfMap* /*aData*/,

    int /*aTransitionTime*/,

    CAlfVisual* /*aRefVisual*/ )

    {

    //deprecated

    TAlfCommand* cmd = NULL;

    return cmd;

    }

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

// Sends a command to Env

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

//

OSN_EXPORT void AlfCurvePathLayoutAttributeSetter::createAndSendCommands (

    CAlfVisual& aVisual,

    AlfAttributeContainer* aContainer,

    CAlfVisual* aRefVisual )

    {

    //SetOffset in CAlfCurvePath can be sent as a TAlfCustomEventCommand

    AlfCommonLayoutAttributeSetter::createAndSendCommands (

        aVisual, aContainer, aRefVisual );

    }

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

// Sets dynamic attributes to visual

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

//

void AlfCurvePathLayoutAttributeSetter::handleDynamicAttribute (

    CAlfVisual &aVisual,

    AlfAttribute& aAttr,

    AlfAttributeContainer& aContainer)

    {

    CAlfCurvePathLayout* curvepathlayout =

        dynamic_cast<CAlfCurvePathLayout*>(&aVisual);

    if(!curvepathlayout)

        {

        return;

        }

    const char* attrName = aAttr.name();

    if ( !strcmp ( attrName, KOffsetX ) ||!strcmp ( attrName, KOffsetY ) )

        {

        // throws if attribute is not found

        AlfAttribute& offsety = aContainer.getAttributeByName ( KOffsetY );

        AlfAttribute& offsetx = aContainer.getAttributeByName ( KOffsetX );

        TAlfTimedPoint offset((TReal32)offsetx.getSourceValue()->realValue(),

                              (TReal32)offsety.getSourceValue()->realValue());

        offset.iX.SetTarget((TReal32)offsetx.getTargetValue()->realValue(),

                            offsetx.getTime());

        offset.iY.SetTarget((TReal32)offsety.getTargetValue()->realValue(),

                            offsety.getTime());

        offset.iX.SetStyle ( offsetx.getInterpolationStyle() );

        offset.iY.SetStyle ( offsety.getInterpolationStyle() );

        offset.iX.SetMappingFunctionIdentifier(

            offsetx.getMappingFunctionId());

        offset.iY.SetMappingFunctionIdentifier(

            offsety.getMappingFunctionId());

        curvepathlayout->CurvePath().SetOffset( offset );

        offsetx.setDirty(false);

        offsety.setDirty(false);

        }

    else

        {

        AlfCommonLayoutAttributeSetter::handleDynamicAttribute(

            aVisual, aAttr, aContainer);

        }

    }

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

// Sets static attributes to visual

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

//

void AlfCurvePathLayoutAttributeSetter::handleStaticAttribute (

    CAlfVisual &aVisual,

    AlfAttribute& aAttr,

    AlfAttributeContainer& aContainer)

    {

    CAlfCurvePathLayout* curvepathlayout =

        dynamic_cast<CAlfCurvePathLayout*>(&aVisual);

    if(!curvepathlayout)

        {

        return;

        }

    const char* attrName = aAttr.name();

    if ( !strcmp ( attrName, KEnableLoop ) )

        {

        // if value is not int, then use default parameter of EnableLoop

        if ( AlfAttributeValueType::EInt != aAttr.type() )

            {

            curvepathlayout->CurvePath().EnableLoop();

            }

        else

            {

            int enableLoop = aAttr.intValue();

            TBool flag = ETrue;      //Assume true for any non-zero value.

            if ( 0 == enableLoop )

                {

                flag = EFalse;

                }

            curvepathlayout->CurvePath().EnableLoop( flag );

            }

        }

    else if ( !strcmp ( attrName, KOrigin ) )

        {

        curvepathlayout->CurvePath().SetOrigin( aAttr.realValue() );

        }

    else if ( !strcmp ( attrName, KOffsetX ) || !strcmp ( attrName, KOffsetY ) )

        {

        // throws if attribute is not found

        AlfAttribute& offsety = aContainer.getAttributeByName ( KOffsetY );

        AlfAttribute& offsetx = aContainer.getAttributeByName ( KOffsetX );

        TAlfTimedPoint offset( offsetx.realValue(), offsety.realValue());

        curvepathlayout->CurvePath().SetOffset ( offset );

        offsety.setDirty(false);

        offsetx.setDirty(false);

        }

    else if ( !strcmp ( attrName, KLine ) )

        {

        // This multi-value attribute has to be filled in this order:

        // startx,starty,endx,endy,linelength

        if ( 5 != aAttr.getTargetValueCount())

            {

            ALF_THROW ( AlfAttributeException, EInvalidAttribute,

                        "AlfCurvePathLayoutAttributeSetter" );

            }

        float startx = this->floatOrInt( aAttr, 0 );

        float starty = this->floatOrInt( aAttr, 1 );

        float endx   = this->floatOrInt( aAttr, 2 );

        float endy   = this->floatOrInt( aAttr, 3 );

        float len    = aAttr.realValue(4);

        TRAPD(err1,curvepathlayout->CurvePath().AppendLineL(

                  TAlfRealPoint(startx,starty),

                  TAlfRealPoint(endx,endy),len )

             );

        throwIfErr(err1);

        }

    else if ( !strcmp ( attrName, KArc ) )

        {

        // This multi-value attribute has to be filled in this order:

        // arcoriginx,arcoriginy,archorzradius,arcvertradius,arcstartangle,

        // arcendangle,arclength

        if ( 7 != aAttr.getTargetValueCount())

            {

            ALF_THROW ( AlfAttributeException, EInvalidAttribute,

                        "AlfCurvePathLayoutAttributeSetter" );

            }

        float originx    = this->floatOrInt( aAttr, 0 );

        float originy    = this->floatOrInt( aAttr, 1 );

        float horzradius = this->floatOrInt( aAttr, 2 );

        float vertradius = this->floatOrInt( aAttr, 3 );

        float startangle = aAttr.realValue(4);

        float endangle   = aAttr.realValue(5);

        float len        = aAttr.realValue(6);

        TRAPD(err1,curvepathlayout->CurvePath().AppendArcL(

                  TAlfRealPoint(originx,originy),

                  TAlfRealSize(horzradius,vertradius),

                  startangle,endangle,len));

        throwIfErr(err1);

        }

    else

        {

        AlfCommonLayoutAttributeSetter::handleStaticAttribute (

            aVisual, aAttr, aContainer);

        }

    }

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

// Sets dynamic attributes to visual from data

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

//

void AlfCurvePathLayoutAttributeSetter::handleDynamicDataAttribute (

    CAlfVisual &aVisual,

    AlfAttribute& aAttr,

    AlfAttributeContainer& aContainer,

    IAlfMap* aData )

    {

    CAlfCurvePathLayout* curvepathlayout =

        dynamic_cast<CAlfCurvePathLayout*> ( &aVisual );

    if ( !curvepathlayout )

        {

        ALF_THROW ( AlfDataException, ECommonError, "AlfCurvePathLayoutAttributeSetter" )

        }        

    const char* attrName = aAttr.name();

    const char* dataField = aAttr.getDataField();

    if ( !dataField )

        {

        ALF_THROW ( AlfDataException, ECommonError, "AlfCurvePathLayoutAttributeSetter" )

        }

    if (!aData)

        {

        ALF_THROW ( AlfDataException, ECommonError,

                    "AlfCurvePathLayoutAttributeSetter" )

        }

    IAlfVariantType* data = aData->item ( UString(dataField) );

    if (data)

        {

        const char* attrName = aAttr.name();

        if ( !strcmp ( attrName, KOffsetX ) )

            {

            // throws if attribute not found

            AlfAttribute& offsety = aContainer.getAttributeByName( KOffsetY );

            const char* offsetyDataField = offsety.getDataField();

            if ( !offsetyDataField )

                {

                ALF_THROW ( AlfDataException,

                            ECommonError, "AlfCurvePathLayoutAttributeSetter")

                }

            IAlfVariantType* offsetyData = aData->item ( UString(offsetyDataField) );

            if ( data->type() == IAlfVariantType::EReal &&

                    offsetyData && offsetyData->type() == IAlfVariantType::EReal)

                {

                // The time value is in the attribute? Is it not

                // part of data as well?

                TAlfTimedPoint offset;

                offset.iX.SetTarget(data->real(), aAttr.getTime());

                offset.iX.SetStyle ( aAttr.getInterpolationStyle() );

                offset.iX.SetMappingFunctionIdentifier (aAttr.getMappingFunctionId());

                offset.iY.SetTarget(offsetyData->real(), offsety.getTime());

                offset.iY.SetStyle ( offsety.getInterpolationStyle() );

                offset.iY.SetMappingFunctionIdentifier (

                    offsety.getMappingFunctionId());

                curvepathlayout->CurvePath().SetOffset( offset );

                }

            }

        else if ( !strcmp ( attrName, KOffsetY ) )

            {

            //Make sure X Attribute also exists, but do nothing.

            //Actual values will be set in the iteration that checks

            //for KOffsetX

            aContainer.getAttributeByName ( KOffsetX );

            //will throw if attribute is not found

            }

        else

            {

            AlfCommonLayoutAttributeSetter::handleDynamicDataAttribute(

                aVisual, aAttr, aContainer, aData);

            }

        }

    }

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

// Sets static attributes to visual  from data

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

//

void AlfCurvePathLayoutAttributeSetter::handleStaticDataAttribute (

    CAlfVisual &aVisual,

    AlfAttribute& aAttr,

    AlfAttributeContainer& aContainer,

    IAlfMap* aData )

    {

    CAlfCurvePathLayout* curvepathlayout =

        dynamic_cast<CAlfCurvePathLayout*> ( &aVisual );

    if(!curvepathlayout)

        {

        ALF_THROW ( AlfDataException, ECommonError,

                            "AlfCurvePathLayoutAttributeSetter" )

        }

    const char* attrName = aAttr.name();

    const char* dataField = aAttr.getDataField();

    if ( !dataField )

        {

        ALF_THROW ( AlfDataException, ECommonError,

                    "AlfCurvePathLayoutAttributeSetter" )

        }

    if (!aData)

        {

        ALF_THROW ( AlfDataException, ECommonError,

                    "AlfCurvePathLayoutAttributeSetter" )

        }

    IAlfVariantType* data = aData->item ( UString(dataField) );

    if ( data )

        {

        if ( !strcmp ( attrName, KEnableLoop ) )

            {

            // if value is not bool, then use default parameter of EnableLoop

            if ( data->type() != IAlfVariantType::EBool )

                {

                curvepathlayout->CurvePath().EnableLoop();

                }

            else

                {

                curvepathlayout->CurvePath().EnableLoop( data->boolean() );

                }

            }

        else if ( !strcmp ( attrName, KOrigin ) )

            {

            if ( data->type() == IAlfVariantType::EReal )

                {

                float origin =  data->real() ;

                curvepathlayout->CurvePath().SetOrigin ( origin );

                }

            }

        else if ( !strcmp ( attrName, KOffsetX ) )

            {

            AlfAttribute& offsety

            = aContainer.getAttributeByName ( KOffsetY );

            //will throw if attribute is not found

            const char* offsetyDataField = offsety.getDataField();

            if ( !offsetyDataField )

                {

                ALF_THROW ( AlfDataException,

                            ECommonError, "AlfCurvePathLayoutAttributeSetter")

                }

            IAlfVariantType* offsetyData = aData->item ( UString(offsetyDataField) );

            if ( data->type() == IAlfVariantType::EReal &&

                    offsetyData && offsetyData->type() == IAlfVariantType::EReal)

                {

                TAlfTimedPoint offset( data->real(), offsetyData->real());

                curvepathlayout->CurvePath().SetOffset( offset );

                }

            }

        else if ( !strcmp ( attrName, KOffsetY ) )

            {

            //Make sure X Attribute also exists, but do nothing.

            //Actual values will be set in the iteration that checks for

            //KOffsetX

            aContainer.getAttributeByName( KOffsetX );

            //will throw if attribute is not found

            }

        else if ( !strcmp ( attrName, KLine ) )

            {

            //if not a container, dont proceed

            if (!(data->type() == IAlfVariantType::EContainer))

                {

                return;

                }

            IAlfContainer* container = data->container();

            //if all item are not present, throw

            if (container->count() != 5)

                {

                ALF_THROW ( AlfAttributeException, EInvalidAttribute,

                            "AlfCurvePathLayoutAttributeSetter" );

                }

            IAlfVariantType* lineStartXvalue = container->item(0);

            IAlfVariantType* lineStartYvalue = container->item(1);

            IAlfVariantType* lineEndXvalue = container->item(2);

            IAlfVariantType* lineEndYvalue = container->item(3);

            IAlfVariantType* lineLengthvalue = container->item(4);

            float startx = this->floatOrIntFromData( lineStartXvalue);

            float starty = this->floatOrIntFromData( lineStartYvalue);

            float endx   = this->floatOrIntFromData( lineEndXvalue  );

            float endy   = this->floatOrIntFromData( lineEndYvalue  );

            float len    = float(lineLengthvalue->real());

            TRAPD(err1,

                  curvepathlayout->CurvePath().AppendLineL(

                      TAlfRealPoint(startx,starty),

                      TAlfRealPoint(endx,endy),len)

                 );

            throwIfErr(err1);

            }

        else if ( !strcmp ( attrName, KArc ) )

            {