/*

* 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 linevisual.

*

*/

//includes

//widget model includes

#include "alf/alfattributecontainer.h"

#include "alf/alfattributevaluetype.h"

#include "alf/alfattribute.h"

#include "alf/alflinevisualattributesetter.h"

#include <alf/alfvisualexception.h>

#include <alf/alfdataexception.h>

#include <alf/alfattributeexception.h>

//osn includes

#include <osn/ustring.h>

#include <osn/alfptrvector.h>

//alf includes

#include <alf/alfenv.h>

#include <alf/alflinevisual.h>

#include <alf/alftexture.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::linevisualattributes;

using namespace duiuimodel::curvepathattributes;

namespace Alf

    {

static void throwIfErr ( int aErr )

    {

    if (aErr!=KErrNone)

        {

        ALF_THROW ( AlfAttributeException, aErr,

                    "AlfLineVisualAttributeSetter")

        }

    }

class AlfLineVisualAttributeSetterImpl

    {

public:

    AlfLineVisualAttributeSetterImpl();

    ~AlfLineVisualAttributeSetterImpl();

public:

    // Texture manager doesn't unload the texture from memory untill Env

    // is deleted. Hence need to unload them once attribute setter is deleted.

    AlfPtrVector<CAlfTexture> mLoadedTextures;

    // Env needed to access TextureManager while unloading textures.

    CAlfEnv* mEnv;

    };

AlfLineVisualAttributeSetterImpl::AlfLineVisualAttributeSetterImpl()

    {

    // Do not delete textures here as they may be in use by the visuals

    // that have not been deleted.

    mLoadedTextures.setAutoDelete(false);

    }

AlfLineVisualAttributeSetterImpl::~AlfLineVisualAttributeSetterImpl()

    {

    // Unload all loaded textures created by this attributesetter to free

    // up the memory.

    for (int i =0;i<mLoadedTextures.count();i++)

        {

        CAlfTexture* Texture = mLoadedTextures[i];

        mEnv->TextureManager().UnloadTexture(Texture->Id());

        }

    mLoadedTextures.clear();

    }

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

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

// Constructor.

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

//

OSN_EXPORT AlfLineVisualAttributeSetter::AlfLineVisualAttributeSetter()

    {

    mImpl.reset(new (EMM) AlfLineVisualAttributeSetterImpl());

    }

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

// Destructor.

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

//

OSN_EXPORT AlfLineVisualAttributeSetter::~AlfLineVisualAttributeSetter()

    {

    }

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

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

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

//

OSN_EXPORT void AlfLineVisualAttributeSetter::setAttributeValue (

    CAlfVisual &aVisual,

    AlfAttributeContainer* aContainer,

    IAlfMap* aData )

    {

    CAlfLineVisual* lineVisual = dynamic_cast<CAlfLineVisual*>( &aVisual);

    if ( !lineVisual )

        {

        ALF_THROW ( AlfVisualException, EInvalidVisual, "AlfLineVisualAttributeSetter" )

        }

    CAlfCurvePath* curve = lineVisual->Path();

    if (curve)

        {

        curve->Reset();

        }

    AlfCommonVisualAttributeSetter::setAttributeValue(aVisual,

            aContainer, aData);

    }

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

// Deprecated

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

//

OSN_EXPORT TAlfCommand* AlfLineVisualAttributeSetter::createCommand (

    CAlfVisual& /*aVisual*/,

    AlfAttributeContainer* /*aContainer*/,

    IAlfMap* /*aData*/,

    int /*aTransitionTime*/,

    CAlfVisual* /*aRefVisual*/ )

    {

    //deprecated

    TAlfCommand* cmd = 0;

    return cmd;

    }

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

// Sends a command to Env

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

//

OSN_EXPORT void AlfLineVisualAttributeSetter::createAndSendCommands (

    CAlfVisual& aVisual,

    AlfAttributeContainer* aContainer,

    CAlfVisual* aRefVisual )

    {

    // SetOffset in CAlfCurvePath,

    // SetThickness,SetShadowThickness SetStartPos & SetEndPos

    // in Line Visual can be sent as a TAlfCustomEventCommand

    AlfCommonVisualAttributeSetter::createAndSendCommands (

        aVisual, aContainer, aRefVisual );

    }

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

// Sets dynamic attributes to visual

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

//

void AlfLineVisualAttributeSetter::handleDynamicAttribute (

    CAlfVisual &aVisual,

    AlfAttribute& aAttr,

    AlfAttributeContainer& aContainer)

    {

    CAlfLineVisual* lineVisual = dynamic_cast<CAlfLineVisual*>( &aVisual);

    if ( !lineVisual )

        {

        return;

        }  

    const char* attrName = aAttr.name();

    if ( !strcmp ( attrName, KThickness ) )

        {

        TAlfTimedValue tVal((TReal32)aAttr.getSourceValue()->realValue());

        tVal.SetTarget ((TReal32)aAttr.getTargetValue()->realValue(),

                        (TInt) aAttr.getTime());

        tVal.SetStyle ( aAttr.getInterpolationStyle() );

        tVal.SetMappingFunctionIdentifier (aAttr.getMappingFunctionId());

        lineVisual->SetThickness(tVal);

        }

    else if ( !strcmp ( attrName, KShadowThickness ) )

        {

        TAlfTimedValue tVal((TReal32)aAttr.getSourceValue()->realValue());

        tVal.SetTarget ((TReal32)aAttr.getTargetValue()->realValue(),

                        (TInt) aAttr.getTime());

        tVal.SetStyle ( aAttr.getInterpolationStyle() );

        tVal.SetMappingFunctionIdentifier (aAttr.getMappingFunctionId());

        lineVisual->SetShadowThickness(tVal);

        }

    else if ( !strcmp ( attrName, KStartPos ) )

        {

        TAlfTimedValue tVal((TReal32)aAttr.getSourceValue()->realValue());

        tVal.SetTarget ((TReal32)aAttr.getTargetValue()->realValue(),

                        (TInt) aAttr.getTime());

        tVal.SetStyle ( aAttr.getInterpolationStyle() );

        tVal.SetMappingFunctionIdentifier (aAttr.getMappingFunctionId());

        lineVisual->SetStartPos(tVal);

        }

    else if ( !strcmp ( attrName, KEndPos ) )

        {

        TAlfTimedValue tVal((TReal32)aAttr.getSourceValue()->realValue());

        tVal.SetTarget ((TReal32)aAttr.getTargetValue()->realValue(),

                        (TInt) aAttr.getTime());

        tVal.SetStyle ( aAttr.getInterpolationStyle() );

        tVal.SetMappingFunctionIdentifier (aAttr.getMappingFunctionId());

        lineVisual->SetEndPos(tVal);

        }

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

        {

        AlfAttribute& offsety = aContainer.getAttributeByName (

                                    KOffsetY );

        AlfAttribute& offsetx = aContainer.getAttributeByName (

                                    KOffsetX );

        //will throw if attribute is not found

        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());

        CAlfCurvePath* curve = this->getCurvePath(lineVisual);

        curve->SetOffset ( offset );

        offsetx.setDirty(false);

        offsety.setDirty(false);

        }

    else

        {

        AlfCommonVisualAttributeSetter::handleDynamicAttribute(

            aVisual, aAttr, aContainer);

        }

    }

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

// Sets static attributes to visual

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

//

void AlfLineVisualAttributeSetter::handleStaticAttribute (

    CAlfVisual& aVisual,

    AlfAttribute& aAttr,

    AlfAttributeContainer& aContainer)

    {

    CAlfLineVisual* lineVisual = dynamic_cast<CAlfLineVisual*>( &aVisual);

    if ( !lineVisual )

        {

        return;

        }  

    const char* attrName = aAttr.name();

    if ( !strcmp ( attrName, KImagePath ) )

        {

        TPtrC8 src;

        src.Set((TUint8*)aAttr.stringValue().getUtf8());

        auto_ptr<HBufC> DesC;

        TRAPD(err1,

            DesC.reset(CnvUtfConverter::ConvertToUnicodeFromUtf8L(src)));

        throwIfErr(err1);

        if (DesC.get())

            {

            CAlfTexture* texture = NULL;

            TRAPD(err2,texture = &(aVisual.Env().TextureManager().

                                   LoadTextureL( *(DesC.get()),

                                       EAlfTextureFlagDefault,

                                       KAlfAutoGeneratedTextureId)));

            throwIfErr(err2);

            lineVisual->SetImage(TAlfImage(*texture));

            mImpl->mEnv = &aVisual.Env();

            mImpl->mLoadedTextures.resize(mImpl->mLoadedTextures.count()+1);

            mImpl->mLoadedTextures.insert(mImpl->mLoadedTextures.count(),

                                       texture);

            }

        }

    else if ( !strcmp ( attrName, KThickness ) )

        {

        TAlfTimedValue val(aAttr.realValue(),0);

        //static attribute,apply with immidiate effect

        lineVisual->SetThickness(val);

        }

    else if ( !strcmp ( attrName, KShadowThickness ) )

        {

        TAlfTimedValue val(aAttr.realValue(),0);

        //static attribute,apply with immidiate effect

        lineVisual->SetShadowThickness(val);

        }

    else if ( !strcmp ( attrName, KStartPos ) )

        {

        TAlfTimedValue val(aAttr.realValue(),0);

        //static attribute,apply with immidiate effect

        lineVisual->SetStartPos(val);

        }

    else if ( !strcmp ( attrName, KEndPos ) )

        {

        TAlfTimedValue val(aAttr.realValue(),0);

        //static attribute,apply with immidiate effect

        lineVisual->SetEndPos(val);

        }

    else if ( !strcmp ( attrName, KAlphaMappingFunction ) )

        {

        // assumption:

        // The int value-mapping function mapping is the following:

        // 0 - KConstMappingFunction

        // 1 - duiuimodel::nodetypes::KLinearMappingFunction

        // 2 - KSineMappingFunction

        // 3 - KCosineMappingFunction

        MAlfMappingFunction* func =  this->getMappingFunction(aAttr,

                                               lineVisual->Env());

        if (!func)

            {

            ALF_THROW ( AlfAttributeException,

                        EInvalidAttribute, "AlfLineVisualAttributeSetter")

            }

        lineVisual->SetAlphaFunction(func);

        }

    else if ( !strcmp ( attrName, KWidthMappingFunction ) )

        {

        //assumption:

        //The int value-mapping function mapping is the following:

        //0 - KConstMappingFunction

        //1 - duiuimodel::nodetypes::KLinearMappingFunction

        //2 - KSineMappingFunction

        //3 - KCosineMappingFunction

        MAlfMappingFunction* func =  this->getMappingFunction(aAttr,

                                     lineVisual->Env());

        if (!func)

            {

            ALF_THROW ( AlfAttributeException,

                        EInvalidAttribute, "AlfLineVisualAttributeSetter")

            }

        lineVisual->SetWidthFunction(func);

        }

    else if ( !strcmp ( attrName, KColor ) )

        {

        if ( 4 == aAttr.getTargetValueCount() &&

                AlfAttributeValueType::EFloat == aAttr.type(0) &&

                AlfAttributeValueType::EFloat == aAttr.type(1) &&

                AlfAttributeValueType::EFloat == aAttr.type(2) &&

                AlfAttributeValueType::EFloat == aAttr.type(3))

            {

            TRgb color ( aAttr.realValue(0),

                         aAttr.realValue(1),

                         aAttr.realValue(2),

                         aAttr.realValue(3) );

            lineVisual->SetColor ( color );

            }

        else

            {

            ALF_THROW ( AlfAttributeException, EInvalidAttribute,

                        "AlfLineVisualAttributeSetter")

            }

        }

    else if ( !strcmp ( attrName, KEnableLoop ) )

        {

        CAlfCurvePath* curve = this->getCurvePath(lineVisual);

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

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

            {

            curve->EnableLoop ();

            }

        else

            {

            int enableLoop = aAttr.intValue();

            TBool flag = ETrue;

            //Assume true for any non-zero value.

            if ( 0 == enableLoop )

                {

                flag = EFalse;

                }

            curve->EnableLoop ( flag );

            }

        }

    else if ( !strcmp ( attrName, KOrigin ) )

        {

        CAlfCurvePath* curve = this->getCurvePath(lineVisual);

        curve->SetOrigin ( aAttr.realValue() );

        }

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

        {

        CAlfCurvePath* curve = this->getCurvePath(lineVisual);

        AlfAttribute& offsety = aContainer.getAttributeByName (

                                               KOffsetY );

        AlfAttribute& offsetx = aContainer.getAttributeByName (

                                               KOffsetX );

        //will throw if attribute is not found

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

        curve->SetOffset ( offset );

        offsetx.setDirty(false);

        offsety.setDirty(false);

        }

    else if ( !strcmp ( attrName, KLine ) )

        {

        CAlfCurvePath* curve = this->getCurvePath(lineVisual);

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

        // startx,starty,endx,endy,linelength

        if ( 5 != aAttr.getTargetValueCount())

            {

            ALF_THROW ( AlfAttributeException, EInvalidAttribute,

                        "CAlfLineVisualLayoutAttributeSetter" );

            }

        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,

              curve->AppendLineL ( TAlfRealPoint(startx,starty),

                                   TAlfRealPoint(endx,endy),len ))

        throwIfErr(err1);

        }

    else if ( !strcmp ( attrName, KArc ) )

        {

        CAlfCurvePath* curve = this->getCurvePath(lineVisual);

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

                        "CAlfLineVisualLayoutAttributeSetter" );

            }

        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,

              curve->AppendArcL(TAlfRealPoint(originx,originy),

                                TAlfRealSize(horzradius,vertradius),

                                startangle, endangle, len))

        throwIfErr(err1);

        }

    else

        {

        AlfCommonVisualAttributeSetter::handleStaticAttribute (

            aVisual, aAttr, aContainer);

        }

    }

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

// Sets dynamic attributes to visual from data

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

//

void AlfLineVisualAttributeSetter::handleDynamicDataAttribute (