/*

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

*

*/

#include "alf/alfattribute.h"

#include "alf/alfmeshvisualattributesetter.h"

#include "alf/alfattributevaluetype.h"

#include <alf/alfvisual.h>

#include <alf/alfattributeexception.h>

#include <alf/alfvisualexception.h>

#include "alf/alfattributecontainer.h"

#include <libc/string.h>

#include <osn/ustring.h>

#include "alf/attrproperty.h"

#include <uiacceltk/HuiRealPoint.h>

#include <alf/alfmeshvisual.h>

#include <alf/alftexture.h>

#include <utf.h>

#include <alf/alfenv.h>

#include <alf/alfdataexception.h>

#include <alf/alfdisplay.h>

#include <alf/alfbrusharray.h>

#include <alf/alfframebrush.h>

#include <alf/alfeventhandler.h>

#include <alf/alfevent.h>

#include <osn/alfptrvector.h>

using namespace osncore;

using namespace duiuimodel::meshvisualattributes;

using namespace duiuimodel::commonvisualattributes;

namespace Alf

    {

class AlfMeshVisualAttributeSetterImpl

    {

public:

    AlfMeshVisualAttributeSetterImpl();

    ~AlfMeshVisualAttributeSetterImpl();

public:

    //Keep track of loaded texture for imagevisuals.

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

    };

AlfMeshVisualAttributeSetterImpl::AlfMeshVisualAttributeSetterImpl()

    {

    //Do not delete textures here as they may be in use by the visuals that have not been deleted.

    mEnv = CAlfEnv::Static();

    mLoadedTextures.setAutoDelete(false);

    }

AlfMeshVisualAttributeSetterImpl::~AlfMeshVisualAttributeSetterImpl()

    {

    //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 AlfMeshVisualAttributeSetter::AlfMeshVisualAttributeSetter()

    {

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

    }

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

// Destructor.

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

//

OSN_EXPORT AlfMeshVisualAttributeSetter::~AlfMeshVisualAttributeSetter()

    {

    }

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

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

//

IAlfVariantType* AlfMeshVisualAttributeSetter::getData(AlfAttribute& aAttr, IAlfMap* aData)

    {

    IAlfVariantType* data = 0;

    const char* dataField = aAttr.getDataField();

    if (dataField)

        {

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

        }

    return data;

    }

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

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

//

int AlfMeshVisualAttributeSetter::getTime(const AlfAttribute& aAttr, bool aImmediate)

    {

    int time = 0;

    if (!aImmediate)

        {

        time = aAttr.getTime();

        }

    return time;

    }

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

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

//

void AlfMeshVisualAttributeSetter::handleDynamicDataAttribute(CAlfVisual & aVisual,

        AlfAttribute& aAttr, AlfAttributeContainer& aContainer, IAlfMap* aData)

    {

    if (!doHandleDynamicDataAttribute(aVisual, aAttr, aContainer, aData))

        {

        AlfCommonVisualAttributeSetter::handleDynamicDataAttribute(

            aVisual, aAttr, aContainer, aData);

        }

    }

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

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

//

void AlfMeshVisualAttributeSetter::handleStaticDataAttribute(

    CAlfVisual &aVisual, AlfAttribute& aAttr,

    AlfAttributeContainer& aContainer, IAlfMap* aData)

    {

    CAlfMeshVisual* meshVisual = dynamic_cast<CAlfMeshVisual*>(&aVisual);

    if (!meshVisual)

        {

        ALF_THROW ( AlfDataException, ECommonError, "AlfMeshVisualAttributeSetter" )

        }

    if (!aData)  ALF_THROW ( AlfDataException, EInvalidVariantDataType, "AlfMeshVisualAttributeSetter" )

        const char* dataField = aAttr.getDataField();

    if ( !dataField )  ALF_THROW ( AlfDataException, EInvalidAttribute, "AlfMeshVisualAttributeSetter" )

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

    const char* attrName = aAttr.name();

    if (data)

        {

        if (!strcmp(attrName,KMeshType))

            {

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

                {

                int val = data->integer();

                TRAPD(err,meshVisual->CreateMeshL(val));

                if (err!=KErrNone)

                    {

                    ALF_THROW ( AlfDataException, err, "AlfMeshVisualAttributeSetter")

                    }

                }

            }

        else if (!strcmp(attrName, KImagePath))

            {

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

                {

                TPtrC8 src;

                src.Set((TUint8*)data->string().getUtf8());

                HandleImagePathAttribute( src, meshVisual, primary );

                }

            }

        else if (!strcmp(attrName,KSecondaryImagePath))

            {

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

                {

                TPtrC8 src;

                src.Set((TUint8*)data->string().getUtf8());

                HandleImagePathAttribute( src, meshVisual, secondary );

                }

            }

        else if (!strcmp(attrName,KSpecularImagePath))

            {

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

                {

                TPtrC8 src;

                src.Set((TUint8*)data->string().getUtf8());

                HandleImagePathAttribute( src, meshVisual, specular );

                }

            }

        else

            {

            //check, if dynamic attribute(but set by user as static), if so, set attributes immediately.

            //If not, the function will call baseclass SetAttributeValue.

            if (!doHandleDynamicDataAttribute(aVisual, aAttr, aContainer, aData, true))

                {

                AlfCommonVisualAttributeSetter::handleStaticDataAttribute(

                    aVisual, aAttr, aContainer, aData);

                }

            }

        }

    }

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

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

//

void AlfMeshVisualAttributeSetter::handleDynamicAttribute(CAlfVisual &aVisual,

        AlfAttribute& aAttr, AlfAttributeContainer& aContainer)

    {

    if (!doHandleDynamicAttribute(aVisual, aAttr, aContainer))

        {

        AlfCommonVisualAttributeSetter::handleDynamicAttribute(

            aVisual, aAttr, aContainer);

        }

    }

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

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

//

void AlfMeshVisualAttributeSetter::handleStaticAttribute(

    CAlfVisual& aVisual, AlfAttribute& aAttr, AlfAttributeContainer& aContainer)

    {

    CAlfMeshVisual* meshVisual = dynamic_cast<CAlfMeshVisual*>(&aVisual);

    if(!meshVisual)

        {

        return;

        }

    const char* attrName = aAttr.name();

    // meshVisual attributes

    if (!strcmp(attrName,KMeshType))

        {

        int val = aAttr.intValue();

        TRAPD(err,meshVisual->CreateMeshL(val));

        if (err!=KErrNone)

            {

            ALF_THROW(AlfDataException, err, "AlfMeshVisualAttributeSetter");

            }

        }

    else if (!strcmp(attrName,KImagePath))

        {

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

        HandleImagePathAttribute( src, meshVisual, primary );

        }

    else if (!strcmp(attrName,KSecondaryImagePath))

        {

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

        HandleImagePathAttribute( src, meshVisual, secondary );

        }

    else if (!strcmp(attrName,KSpecularImagePath))

        {

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

        HandleImagePathAttribute( src, meshVisual, specular );

        }

    else

        {

        if (!doHandleDynamicAttribute(aVisual, aAttr, aContainer, true))

            {

            AlfCommonVisualAttributeSetter::handleStaticAttribute(aVisual, aAttr, aContainer);

            }

        }

    }

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

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

//

OSN_EXPORT void AlfMeshVisualAttributeSetter::setAttributeValue(

    CAlfVisual &aVisual,

    AlfAttributeContainer* aContainer,

    IAlfMap* aData)

    {

    CAlfMeshVisual* meshVisual = dynamic_cast<CAlfMeshVisual*>(&aVisual);

    if (!meshVisual)

        {

        ALF_THROW ( AlfVisualException, EInvalidVisual, "AlfMeshVisualAttributeSetter")

        }

    AlfCommonVisualAttributeSetter::setAttributeValue(

        aVisual, aContainer, aData);

    }

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

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

//

OSN_EXPORT TAlfCommand* AlfMeshVisualAttributeSetter::createCommand(

    CAlfVisual& /*aVisual*/, AlfAttributeContainer* /*aContainer*/,

    IAlfMap* /*aData*/, int /*aTransitionTime*/, CAlfVisual* /*aRefVisual*/)

    {

    TAlfCommand* cmd = 0;

    return cmd;

    }

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

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

//

OSN_EXPORT void AlfMeshVisualAttributeSetter::createAndSendCommands(

    CAlfVisual& aVisual,

    AlfAttributeContainer* aContainer,

    CAlfVisual* aRefVisual )

    {

    // Call the base class implementation.It goes through its loop and checks if there are attributes

    // that it handles.

    AlfCommonVisualAttributeSetter::createAndSendCommands(

        aVisual,

        aContainer,

        aRefVisual );

    }

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

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

//

bool AlfMeshVisualAttributeSetter::doHandleDynamicDataAttribute(CAlfVisual & aVisual,

        AlfAttribute& aAttr, AlfAttributeContainer& /*aContainer*/, IAlfMap* aData, bool aImmediate)

    {

    bool handled = true;

    if (!aData)

        {

        ALF_THROW ( AlfDataException, EInvalidVariantDataType, "AlfMeshVisualAttributeSetter" )

        }

    else

        {

        CAlfMeshVisual* meshVisual = dynamic_cast<CAlfMeshVisual*>(&aVisual);

        if(!meshVisual)

            {

            return false;

            }

        const char* attrName = aAttr.name();

        if ( !strcmp( attrName, KSecondaryAlpha ) )

            {

            const IAlfVariantType* data = getData(aAttr, aData);

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

                {

                TAlfTimedValue tVal(data->real(), getTime(aAttr, aImmediate));

                tVal.SetStyle(aAttr.getInterpolationStyle());

                tVal.SetMappingFunctionIdentifier( aAttr.getMappingFunctionId() );

                meshVisual->SetSecondaryAlpha( tVal );

                }

            }

        else if ( !strcmp( attrName, KYawAngle ) )

            {

            const IAlfVariantType* data = getData(aAttr, aData);

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

                {

                TAlfTimedValue tVal(data->real(), getTime(aAttr, aImmediate));

                tVal.SetStyle(aAttr.getInterpolationStyle());

                tVal.SetMappingFunctionIdentifier( aAttr.getMappingFunctionId() );

                meshVisual->SetYawAngle( tVal );

                }

            }

        else if ( !strcmp( attrName, KPitchAngle ) )

            {

            const IAlfVariantType* data = getData(aAttr, aData);

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

                {

                TAlfTimedValue tVal(data->real(), getTime(aAttr, aImmediate));

                tVal.SetStyle(aAttr.getInterpolationStyle());

                tVal.SetMappingFunctionIdentifier( aAttr.getMappingFunctionId() );

                meshVisual->SetPitchAngle( tVal );

                }

            }

        else if ( !strcmp( attrName, KScale ) )

            {

            const IAlfVariantType* data = getData(aAttr, aData);

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

                {

                TAlfTimedValue tVal(data->real(), getTime(aAttr, aImmediate));

                tVal.SetStyle(aAttr.getInterpolationStyle());

                tVal.SetMappingFunctionIdentifier( aAttr.getMappingFunctionId() );

                meshVisual->SetScale( tVal );

                }

            }

        else

            {

            handled = false;

            }

        }

    return handled;

    }

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

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

//

bool AlfMeshVisualAttributeSetter::doHandleDynamicAttribute(

    CAlfVisual &aVisual, AlfAttribute& aAttr,

    AlfAttributeContainer& /*aContainer*/, bool aImmediate)

    {

    CAlfMeshVisual* meshVisual = dynamic_cast<CAlfMeshVisual*>(&aVisual);

    if(!meshVisual)

        {

        return false;

        }

    const char* attrName = aAttr.name();

    bool handled = true;

    // KSecondaryAlpha

    if (!strcmp(attrName, KSecondaryAlpha))

        {

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

        tVal.SetTarget(aAttr.getTargetValue()->realValue(),getTime(aAttr, aImmediate));

        tVal.SetStyle( aAttr.getInterpolationStyle() );

        tVal.SetMappingFunctionIdentifier( aAttr.getMappingFunctionId() );

        meshVisual->SetSecondaryAlpha( tVal );

        }

    //KYawAngle

    else if (!strcmp(attrName, KYawAngle))

        {

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

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

        tVal.SetStyle( aAttr.getInterpolationStyle() );

        tVal.SetMappingFunctionIdentifier( aAttr.getMappingFunctionId() );

        meshVisual->SetYawAngle( tVal );

        }

    //KPitchAngle

    else if (!strcmp(attrName, KPitchAngle))

        {

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

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

        tVal.SetStyle( aAttr.getInterpolationStyle() );

        tVal.SetMappingFunctionIdentifier( aAttr.getMappingFunctionId() );

        meshVisual->SetPitchAngle( tVal );

        }

    //KScale

    else if (!strcmp(attrName,KScale))

        {

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

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

        tVal.SetStyle( aAttr.getInterpolationStyle() );

        tVal.SetMappingFunctionIdentifier( aAttr.getMappingFunctionId());

        meshVisual->SetScale( tVal );

        }

    else // Call the base class implementation also.

        //It goes through the same loop again and checks if there are attributes that it handles.

        {

        handled = false;

        }

    return handled;

    }

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

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

//

void AlfMeshVisualAttributeSetter::HandleImagePathAttribute(

    const TPtrC8& aStringValue,

    CAlfMeshVisual* aVisual,

    imageCategory aImageCategory )

    {

    auto_ptr<HBufC> DesC;

    TRAPD( err, DesC.reset(CnvUtfConverter::ConvertToUnicodeFromUtf8L(aStringValue)));

    if ( err != KErrNone )

        {

        ALF_THROW( AlfDataException, err, "AlfMeshVisualAttributeSetter" );

        }

    // check if the texture is already loaded

    const TInt existingTextureId = aVisual->Env().TextureManager().TextureId(*(DesC.get()));

    if ( existingTextureId != KErrNotFound )

        {

        const CAlfTexture* texture = aVisual->Env().TextureManager().Texture( existingTextureId );

        if ( aImageCategory == primary )

            {

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

            }

        else if ( aImageCategory == secondary )

            {

            aVisual->SetSecondaryImage(TAlfImage(*texture));

            }

        else // specular image

            {

            aVisual->SetSpecularImage(TAlfImage(*texture));

            }

        }

    else

        {

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

        CAlfTexture* texture = NULL;

        TRAP( err, texture = &(aVisual->Env().TextureManager().LoadTextureL(

            *(DesC.get()), EAlfTextureFlagDefault, KAlfAutoGeneratedTextureId)));

        if ( err != KErrNone )

            {

            ALF_THROW( AlfDataException, err, "AlfMeshVisualAttributeSetter" );

            }

        // This cannot fail because the array has already been resized

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

        if ( aImageCategory == primary )

            {

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

            }

        else if ( aImageCategory == secondary )

            {

            aVisual->SetSecondaryImage(TAlfImage(*texture));

            }

        else // specular image