/*

* 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:   Attribute setter implementation for mulimage visual.

 *

*/

// Class header

#include "../inc/mulimagevisualattributesetter.h"

// Alf headers

#include "alf/alfattribute.h"

#include <alf/alfattributeexception.h>

#include <alf/alfvisualexception.h>

#include "alf/alfattributecontainer.h"

#include <alf/alfimagevisual.h>

#include <alf/alftexture.h> 

#include <alf/alfenv.h>

#include <alf/alfdataexception.h>

#include <alf/alfdisplay.h>

#include <alf/alfbrusharray.h>

#include <alf/alfframebrush.h>

#include <alf/alfimageloaderutil.h>

#include <alf/alfbitmapprovider.h>

#include <alf/alfresourcepool.h> //for resource pooling

#include <alf/alfwidgetenvextension.h> //for resource pooling

// Osn headers

#include <osn/ustring.h>

#include <osn/alfptrvector.h>

//#include <osn/osnlogicerror.h>

// Std headers

#include <libc/string.h>

#include <utf.h>

// DUI headers

#include "alf/attrproperty.h"

//for logs

#include "mullog.h"

#include "mulutility.h"

using namespace osncore;

using namespace duiuimodel::imagevisualattributes;

using namespace duiuimodel::commonvisualattributes;

using namespace duiuimodel::layoutattributes;

namespace Alf

	{

class MulImageVisualAttributeSetterImpl

	{

public:

	MulImageVisualAttributeSetterImpl();

	~MulImageVisualAttributeSetterImpl();

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;

	};

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

// Constructor	

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

//  

MulImageVisualAttributeSetterImpl::MulImageVisualAttributeSetterImpl()

	{

		MUL_LOG_INFO("aakash::CMulImageVisualAttributeSetterImpl::MulImageVisualAttributeSetterImpl");

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

	mLoadedTextures.setAutoDelete (false);

	}

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

// Destructor	

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

//

MulImageVisualAttributeSetterImpl::~MulImageVisualAttributeSetterImpl()

	{

	MUL_LOG_INFO("aakash::CMulImageVisualAttributeSetterImpl::~MulImageVisualAttributeSetterImpl");

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

	}

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

// Constructor	

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

// 

 OSN_EXPORT MulImageVisualAttributeSetter::MulImageVisualAttributeSetter()

	{

	MUL_LOG_INFO("aakash::CMulImageVisualAttributeSetter::MulImageVisualAttributeSetter");

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

	mImageAttrSetter.reset(new (EMM) AlfImageVisualAttributeSetter());

	}

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

// Destructor	

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

//

OSN_EXPORT MulImageVisualAttributeSetter::~MulImageVisualAttributeSetter()

	{

	MUL_LOG_INFO("aakash::CMulImageVisualAttributeSetter::~MulImageVisualAttributeSetter");

	}

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

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

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

//

OSN_EXPORT void MulImageVisualAttributeSetter::setAttributeValue (

											  CAlfVisual &aVisual,

											  AlfAttributeContainer* aContainer,

											  IAlfMap* aData )

    {

    MUL_LOG_INFO("aakash::CMulImageVisualAttributeSetter::setAttributeValue");

    mData = aData;

    CAlfImageVisual* imageVisual = dynamic_cast<CAlfImageVisual*>(&aVisual);

    if (!imageVisual)

        {

        ALF_THROW ( AlfVisualException, EInvalidVisual, "AlfImageVisualAttributeSetter")

        }

    AlfCommonVisualAttributeSetter::setAttributeValue(aVisual,aContainer, aData);

    }

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

// HandleStaticDataAttribute	

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

// 

void MulImageVisualAttributeSetter::handleStaticDataAttribute(

		CAlfVisual &aVisual, AlfAttribute& aAttr,

		AlfAttributeContainer& aContainer, IAlfMap* aData)

	{

	MUL_LOG_INFO("aakash::CMulImageVisualAttributeSetter::handleStaticDataAttribute");

	CAlfImageVisual* imageVisual = dynamic_cast<CAlfImageVisual*>(&aVisual);

	if ( !imageVisual)

		{

		ALF_THROW ( AlfVisualException, EInvalidVisual, "CAlfImageVisualAttributeSetter")

		}

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

	const char* dataField = aAttr.getDataField ();

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

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

	const char* attrName = aAttr.name ();	

	if ( data)

		{

		if( !strcmp(attrName, KImagePath))

			{

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

				{

				if ( IsSVGImage (data->string ()))

					{

					LoadImageFromSvg(data->string (),*imageVisual);

					}

				else if (MulUtility::IsPoolResource(data->string ()))

				{

				//using resource pooling mechanism for image visual

				ResourcePool& pool =  AlfWidgetEnvExtension::resourcePool(imageVisual->Env());

				imageVisual->SetImage(pool.getImageResource((data->string ().getUtf8())));

				}

				else

					{

					//AlfImageVisualAttributeSetter::handleStaticDataAttribute(aVisual,aAttr,aContainer,aData);

					mImageAttrSetter->setAttributeValue(aVisual,&aContainer,aData);

					}

				}

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

				{

				LoadImageFromTexture(data->integer(),*imageVisual);	

				}

			}

		else if( !strcmp(attrName, KSecondaryImagePath))

			{

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

				{

				if ( IsSVGImage (data->string ()))

					{

					LoadImageFromSvg(data->string (),*imageVisual);

					}

				else if (MulUtility::IsPoolResource(data->string ()))

				{

				//using resource pooling mechanism for image visual

				ResourcePool& pool1 =  AlfWidgetEnvExtension::resourcePool(imageVisual->Env());

				imageVisual->SetImage(pool1.getImageResource((data->string ().getUtf8())));

				}

				else

					{

					mImageAttrSetter->setAttributeValue(aVisual,&aContainer,aData);

					}

				}

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

				{

				LoadImageFromTexture(data->integer(),*imageVisual);	

				}

			}

		else

			{

			mImageAttrSetter->setAttributeValue(aVisual,&aContainer,aData);

			}

		}

	}

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

// handleStaticAttribute	

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

//  

void MulImageVisualAttributeSetter::handleStaticAttribute( CAlfVisual& aVisual, 

														   AlfAttribute& aAttr,

														   AlfAttributeContainer& aContainer )

	{

	MUL_LOG_INFO("aakash::CMulImageVisualAttributeSetter::handleStaticAttribute");

	CAlfImageVisual* imageVisual = dynamic_cast<CAlfImageVisual*>(&aVisual);

	if ( !imageVisual)

		{

		ALF_THROW ( AlfVisualException, EInvalidVisual, "AlfImageVisualAttributeSetter")

		}

	const char* attrName = aAttr.name ();

	if( !strcmp(attrName, KImagePath))

		{

		if ( IsSVGImage ( aAttr.stringValue()))

			{

			LoadImageFromSvg( aAttr.stringValue(),*imageVisual);

			}

		else

			{

			mImageAttrSetter->setAttributeValue(aVisual,&aContainer,mData);

			}

		}

	else if( !strcmp(attrName, KSecondaryImagePath))

		{

		if ( IsSVGImage (aAttr.stringValue()))

			{

			LoadImageFromSvg(aAttr.stringValue(),*imageVisual);

			}

		else

			{

			mImageAttrSetter->setAttributeValue(aVisual,&aContainer,mData);

			}

		}

	else

		{

		mImageAttrSetter->setAttributeValue(aVisual,&aContainer,mData);

		}

	}

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

// handleDynamicDataAttribute	

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

//

void MulImageVisualAttributeSetter::handleDynamicDataAttribute(CAlfVisual &aVisual,

																AlfAttribute& /*aAttr*/, 

																AlfAttributeContainer& aContainer,

																IAlfMap* aData)

	{

	MUL_LOG_INFO("aakash::CMulImageVisualAttributeSetter::handleDynamicDataAttribute");

	mImageAttrSetter->setAttributeValue(aVisual,&aContainer,aData);

	}

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

// handleDynamicDataAttribute	

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

//

void MulImageVisualAttributeSetter::handleDynamicAttribute(CAlfVisual &aVisual,

														   AlfAttribute& /*aAttr*/, 

														   AlfAttributeContainer& aContainer)

	{

	MUL_LOG_INFO("aakash::CMulImageVisualAttributeSetter::handleDynamicAttribute");

	mImageAttrSetter->setAttributeValue(aVisual,&aContainer,mData);

	}

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

// IsSVGImage	

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

//

OSN_EXPORT bool MulImageVisualAttributeSetter::IsSVGImage(const UString& aImagePath)

	{

	MUL_LOG_INFO("aakash::CMulImageVisualAttributeSetter::IsSVGImage");

	TPtrC8 src((TUint8*)aImagePath.getUtf8());

    HBufC* srcBuf = HBufC::NewLC(src.Length());

    srcBuf->Des().Copy(src);

    srcBuf->Des().LowerCase();

    _LIT(KSvgFile,".svg");

	bool retval = ( KErrNotFound != srcBuf->FindC(KSvgFile));

    CleanupStack::PopAndDestroy( srcBuf ); 

	return retval;

	}

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

// LoadImageFromSvg	

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

//

OSN_EXPORT void MulImageVisualAttributeSetter::LoadImageFromSvg(const UString& aSvgFilePath,

													 CAlfImageVisual& aImageVisual )

	{

	MUL_LOG_INFO("aakash::CMulImageVisualAttributeSetter::LoadImageFromSvg");

	TPtrC8 src((TUint8*)aSvgFilePath.getUtf8());

	HBufC* imagePath = CnvUtfConverter::ConvertToUnicodeFromUtf8L (src);

	CleanupStack::PushL( imagePath );

	CAlfImageLoaderUtil imgLoaderUtil;

	imgLoaderUtil.SetSize (TSize (50, 50));

	MAlfBitmapProvider* iSvgBitMapProv= imgLoaderUtil.CreateSVGImageLoaderL (*imagePath);

	CAlfTexture &texture = aImageVisual.Env().TextureManager().CreateTextureL (

							KAlfAutoGeneratedTextureId,

							iSvgBitMapProv,

							EAlfTextureFlagDefault);

	aImageVisual.SetScaleMode (CAlfImageVisual::EScaleFit);

	aImageVisual.SetImage (TAlfImage (texture));

	CleanupStack::PopAndDestroy(imagePath);

	}

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

// LoadImageFromTexture	

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

//

OSN_EXPORT void MulImageVisualAttributeSetter::LoadImageFromTexture( int aTextureId,

														  CAlfImageVisual& aImageVisual )

	{

	MUL_LOG_INFO("aakash::CMulImageVisualAttributeSetter::LoadImageFromTexture");

	//Seems like the Env's Texture Manager is not returning a copy. And When Env gets deleted the texture is destroyed

	//So ownership is not with the client

	const CAlfTexture* texture = aImageVisual.Env().TextureManager().Texture (aTextureId);

	if(!texture)

		{

		ALF_THROW ( AlfDataException, EInvalidAttribute, "AlfImageVisualAttributeSetter" )

		}

	aImageVisual.SetImage (TAlfImage (*texture));	

	}

}// Alf