/*
* 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 anchorlayout.
*
*/



//includes

//widget model includes
#include "alf/alfattributecontainer.h"
#include "alf/alfattributevaluetype.h"
#include "alf/alfattribute.h"
#include "alf/alfanchorlayoutattributesetter.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/alfanchorlayout.h>
#include <alf/alftexture.h>
#include <alf/alfeventhandler.h>
#include <alf/alfevent.h>

//dui includes
#include "alf/attrproperty.h"

//other includes
#include <libc/string.h>
#include <utf.h>



//namespaces

using namespace osncore;

using namespace duiuimodel::anchorlayoutinput;

using namespace duiuimodel::layoutattributes;

using namespace duiuimodel::anchor;

using namespace duiuimodel::metric;

namespace Alf
	{

bool isMultivalueDataAchment ( TAlfAnchorAttachmentOrigin val )
	{
	return ( val == EAlfAnchorAttachmentOriginNone||
			 val == EAlfAnchorAttachmentOriginTopLeft ||
	         val == EAlfAnchorAttachmentOriginTopCenter ||
	         val == EAlfAnchorAttachmentOriginTopRight ||
	         val == EAlfAnchorAttachmentOriginCenterLeft ||
	         val == EAlfAnchorAttachmentOriginCenter ||
	         val == EAlfAnchorAttachmentOriginCenterRight ||
	         val == EAlfAnchorAttachmentOriginBottomLeft ||
	         val == EAlfAnchorAttachmentOriginBottomCenter ||
	         val == EAlfAnchorAttachmentOriginBottomRight );
	}

typedef void ( *pFunc ) ( AlfContainer* aCont, AlfAttribute* aAttrib, IAlfMap* aData );

void addToAnchortypecont ( AlfContainer* aCont, AlfAttribute* aAttrib, IAlfMap* aData )
	{

	if ( aData )
		{
		IAlfVariantType* dataX = aData->item ( UString(aAttrib->getDataField() ));

		if ( dataX && dataX->type() == IAlfVariantType::EInt )
			{
			aCont->addItem ( new ( EMM ) AlfVariantType ( dataX->integer() ) );
			}
		}
	else
		{
		aCont->addItem ( new ( EMM ) AlfVariantType ( aAttrib->intValue() ) );
		}

	}

void addToAttachmentcont ( AlfContainer* aCont, AlfAttribute* aAttrib, IAlfMap* aData )
	{

	if ( aData )
		{
		IAlfVariantType* dataX = aData->item ( UString(aAttrib->getDataField()));

		if ( dataX && dataX->type() == IAlfVariantType::EInt )
			{
			aCont->addItem ( new ( EMM ) AlfVariantType ( dataX->integer() ) );
			}
		}
	else
		{
		aCont->addItem ( new ( EMM ) AlfVariantType ( aAttrib->intValue() ) );
		}
	}

void addToMagnitudecont ( AlfContainer* aCont, AlfAttribute* aAttrib, IAlfMap* aData )
	{

	if ( aData )
		{
		IAlfVariantType* dataX = aData->item ( UString(aAttrib->getDataField()) );

		if ( dataX != NULL && dataX->type() == IAlfVariantType::EMap )
			{
			IAlfVariantType* valueX = dataX->map()->item ( UString("value"));
			IAlfVariantType* unitX = dataX->map()->item ( UString("unit"));
			auto_ptr<AlfContainer> value ( new ( EMM ) AlfContainer() );
			auto_ptr<AlfVariantType> vtype1(new ( EMM ) AlfVariantType ( valueX->real() ));
			value->addItem ( vtype1.get() );
			vtype1.release();
			auto_ptr<AlfVariantType> vtype2(new ( EMM ) AlfVariantType ( unitX->integer() ));
			value->addItem ( vtype2.get() );
			vtype2.release();
			aCont->addItem ( value.release() );

			}
		else if ( dataX != NULL && dataX->type() == IAlfVariantType::EReal )
			{
			auto_ptr<AlfContainer> value ( new ( EMM ) AlfContainer() );
			auto_ptr<AlfVariantType> vtype1(new ( EMM ) AlfVariantType ( dataX->real() ));
			value->addItem ( vtype1.get() );
			vtype1.release();
			auto_ptr<AlfVariantType> vtype2( new ( EMM ) AlfVariantType ( aAttrib->unit() ) );
			
			value->addItem (vtype2.get());
			vtype2.release();
			aCont->addItem ( value.release() );
			}
		}
	else
		{
		auto_ptr<AlfContainer> value ( new ( EMM ) AlfContainer() );
		auto_ptr<AlfVariantType> vtype1( new ( EMM ) AlfVariantType ( aAttrib->realValue() ) );
		value->addItem (vtype1.get());
		vtype1.release();
		auto_ptr<AlfVariantType> vtype2( new ( EMM ) AlfVariantType ( aAttrib->unit() ) );
		
		value->addItem (vtype2.get());
		vtype2.release();
		aCont->addItem ( value.release() );

		}

	}

void addToTextstylecont ( AlfContainer* /*aCont*/, AlfAttribute* /*aAttrib*/, IAlfMap* /*aData*/ )
	{
	}

struct anchormap
	{
	const char* name;
	pFunc addToContainer;
	AlfContainer* pData;
	};

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

// ---------------------------------------------------------------------------
// Constructor.
// ---------------------------------------------------------------------------
//
OSN_EXPORT AlfAnchorLayoutAttributeSetter::AlfAnchorLayoutAttributeSetter()
	{
	}

// ---------------------------------------------------------------------------
// Destructor.
// ---------------------------------------------------------------------------
//
OSN_EXPORT AlfAnchorLayoutAttributeSetter::~AlfAnchorLayoutAttributeSetter()
	{
	}
	
// ---------------------------------------------------------------------------
// Sets Attribute Value. Delegates based on attribute Category.
// ---------------------------------------------------------------------------
//
OSN_EXPORT void AlfAnchorLayoutAttributeSetter::setAttributeValue (
    CAlfVisual &aVisual,
    AlfAttributeContainer* aContainer,
    IAlfMap* aData )
	{
	
	CAlfAnchorLayout* layout = dynamic_cast<CAlfAnchorLayout*> ( &aVisual );

	if ( !layout )
		{
		ALF_THROW ( AlfVisualException, EInvalidVisual, 
		    "AlfAnchorLayoutAttributeSetter" )
		}
		
    AlfCommonLayoutAttributeSetter::setAttributeValue(aVisual, 
        aContainer, aData);
	}
	

// ---------------------------------------------------------------------------
// Deprecated
// ---------------------------------------------------------------------------
//
OSN_EXPORT TAlfCommand* AlfAnchorLayoutAttributeSetter::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 AlfAnchorLayoutAttributeSetter::createAndSendCommands (
    CAlfVisual& aVisual,
    AlfAttributeContainer* aContainer,
    CAlfVisual* aRefVisual )
	{
	//no animatable attributes in grid layout.
	AlfCommonLayoutAttributeSetter::createAndSendCommands ( aVisual, aContainer, aRefVisual );
	}

// ---------------------------------------------------------------------------
// Sets dynamic attributes to visual
// ---------------------------------------------------------------------------
//
void AlfAnchorLayoutAttributeSetter::handleDynamicAttribute ( CAlfVisual &aVisual, AlfAttribute& aAttr, AlfAttributeContainer& aContainer )
	{
	//no dynamic attributes in anchor layout.
	AlfCommonLayoutAttributeSetter::handleDynamicAttribute(aVisual, aAttr, aContainer);
	}
	
// ---------------------------------------------------------------------------
// Sets static attributes to visual
// ---------------------------------------------------------------------------
//		
void AlfAnchorLayoutAttributeSetter::handleStaticAttribute ( 
    CAlfVisual &aVisual, AlfAttribute& aAttr, AlfAttributeContainer& aContainer )
    {
    if (!doHandleStaticAttribute(aVisual, aAttr, aContainer, NULL))
        {
        AlfCommonLayoutAttributeSetter::handleStaticAttribute(aVisual, aAttr, aContainer);
        }
    }

// ---------------------------------------------------------------------------
// Sets static attributes to visual
// ---------------------------------------------------------------------------
//
bool AlfAnchorLayoutAttributeSetter::doHandleStaticAttribute( CAlfVisual &aVisual, 
    AlfAttribute& aAttr, AlfAttributeContainer& aContainer, IAlfMap* aData )
	{
    bool handled = true;
	const char* attrName = aAttr.name();
	CAlfAnchorLayout* layout = dynamic_cast<CAlfAnchorLayout*> ( &aVisual );
	if(!layout)
	    {
	    return false;
	    }

	if ( !strcmp ( attrName, KChildOrdinal )||!strcmp ( attrName, KAttachmentOrdinal ) 
			|| !strcmp ( attrName, KAnchorType )||!strcmp ( attrName, KAttachmentOrigin )
			||!strcmp ( attrName, KMagnitude )||!strcmp ( attrName, KTextStyleId ) )
		{
		AlfAttribute& attachmentordinal = aContainer.getAttributeByName ( KAttachmentOrdinal );
		AlfAttribute& aAttrChildOrdinal = aContainer.getAttributeByName ( KChildOrdinal );
		float ordianal=0;
		float attachordinalval=-1;
		if(aData)
			{
			IAlfVariantType* data = aData->item ( UString(aAttrChildOrdinal.getDataField()) );

			if ( data && data->type() == IAlfVariantType::EReal )
				{
					ordianal=data->real();	
				}
			data = aData->item ( UString(attachmentordinal.getDataField()) );
			if ( data && data->type() == IAlfVariantType::EReal )
				{
					attachordinalval=data->real();	
				}
			}
		else
			{
			ordianal=aAttrChildOrdinal.realValue();
			attachordinalval=attachmentordinal.realValue();
			}
		auto_ptr<AlfContainer> anchortypecont ( new ( EMM ) AlfContainer() );
		auto_ptr<AlfContainer> attachmentorigincont ( new ( EMM ) AlfContainer() );
		auto_ptr<AlfContainer> magnitudecont ( new ( EMM ) AlfContainer() );
		auto_ptr<AlfContainer> textstyleidcont ( new ( EMM ) AlfContainer() );

		anchormap maptable[] =
			{
			{KAnchorType, addToAnchortypecont, NULL},
			{KAttachmentOrigin, addToAttachmentcont, NULL},
			{KMagnitude, addToMagnitudecont, NULL},
			{KTextStyleId, addToTextstylecont, NULL}
			};
		unsigned int tableCount = sizeof ( maptable ) / sizeof ( anchormap );
		maptable[0].pData = anchortypecont.get();
		maptable[1].pData = attachmentorigincont.get();
		maptable[2].pData = magnitudecont.get();
		maptable[3].pData = textstyleidcont.get();

		unsigned int attrCount = aContainer.attributeCount();

		for ( int i = 0;i < attrCount;i++ )
			{
			for ( int j = 0;j < tableCount;j++ )
				{
				if ( !strcmp ( maptable[j].name, aContainer.getAttribute ( i ).name() ) )
					{
					maptable[j].addToContainer ( maptable[j].pData, &aContainer.getAttribute ( i ), aData );
					aContainer.getAttribute ( i ).setDirty(false);
					}
				}
			}

		unsigned int totalApitocall = attachmentorigincont->count();

		unsigned int magnitudeindex = 0;

		for ( int counter = 0;counter < totalApitocall;counter++ )
			{
			IAlfVariantType* Origin = attachmentorigincont->item ( counter );
			TAlfAnchorAttachmentOrigin value = static_cast<TAlfAnchorAttachmentOrigin> ( Origin->integer() );

			if ( isMultivalueDataAchment ( value ) )
				{
				IAlfVariantType* aType = anchortypecont->item ( counter );
				TAlfAnchorType type = static_cast<TAlfAnchorType> ( aType->integer() );

				if ( type == EAlfAnchorTypeNone )
					{
					IAlfContainer* magCont1 = static_cast<IAlfContainer*> ( magnitudecont->item ( magnitudeindex ) );
					IAlfContainer* magCont2 = static_cast<IAlfContainer*> ( magnitudecont->item ( magnitudeindex + 1 ) );
					IAlfContainer* magCont3 = static_cast<IAlfContainer*> ( magnitudecont->item ( magnitudeindex + 2 ) );
					IAlfContainer* magCont4 = static_cast<IAlfContainer*> ( magnitudecont->item ( magnitudeindex + 3 ) );

					TAlfMetric metric1 ( magCont1->item ( 0 )->real(), magCont1->item ( 1 )->integer() );
					TAlfMetric metric2 ( magCont2->item ( 0 )->real(), magCont2->item ( 1 )->integer() );
					TAlfMetric metric3 ( magCont3->item ( 0 )->real(), magCont3->item ( 1 )->integer() );
					TAlfMetric metric4 ( magCont4->item ( 0 )->real(), magCont4->item ( 1 )->integer() );
					TAlfBoxMetric boxmetric ( metric1, metric2, metric3, metric4 );
					int err=layout->Attach ( ordianal, boxmetric, value, attachordinalval );
					if(err!=KErrNone)
						{
						ALF_THROW ( AlfVisualException, err, "Anchor Attach Failed" )
						}
					magnitudeindex += 4;
					}
				else
					{
					IAlfContainer* magCont1 = static_cast<IAlfContainer*> ( magnitudecont->item ( magnitudeindex ) );
					IAlfContainer* magCont2 = static_cast<IAlfContainer*> ( magnitudecont->item ( magnitudeindex + 1 ) );

					TAlfMetric metric1 ( magCont1->item ( 0 )->real(), magCont1->item ( 1 )->integer() );
					TAlfMetric metric2 ( magCont2->item ( 0 )->real(), magCont2->item ( 1 )->integer() );



					TAlfXYMetric xymetric ( metric1, metric2 );
				
					int err=layout->Attach ( ordianal, type, xymetric, value, attachordinalval );
					if(err!=KErrNone)
						{
						ALF_THROW ( AlfVisualException, err, "Anchor Attach Failed" )
						}

					magnitudeindex += 2;
					}
				}
			else
				{
				IAlfVariantType* typeVar = anchortypecont->item ( counter );
				TAlfAnchorType type = static_cast<TAlfAnchorType> ( typeVar->integer() );
				IAlfContainer* magCont1 = static_cast<IAlfContainer*> ( magnitudecont->item ( magnitudeindex ) );

				TAlfMetric metric ( magCont1->item ( 0 )->real(), magCont1->item ( 1 )->integer() );


				int err=layout->Attach ( ordianal, type, metric, value, attachordinalval );
				if(err!=KErrNone)
					{
					ALF_THROW ( AlfVisualException, err, "Anchor Attach Failed" )
					}

				magnitudeindex++;
				}
			}
			
		attachmentordinal.setDirty(false);
		aAttrChildOrdinal.setDirty(false);
		}
	else 
		{
		handled = false;
		}
		
    return handled;
	}


// ---------------------------------------------------------------------------
// Sets dynamic attributes to visual from data
// ---------------------------------------------------------------------------
//
void AlfAnchorLayoutAttributeSetter::handleDynamicDataAttribute ( CAlfVisual &aVisual, AlfAttribute& aAttr, AlfAttributeContainer& aContainer, IAlfMap* aData )
	{
	AlfCommonLayoutAttributeSetter::handleDynamicDataAttribute ( aVisual, aAttr, aContainer, aData );
	}

// ---------------------------------------------------------------------------
// Sets static attributes to visual  from data
// ---------------------------------------------------------------------------
//
void AlfAnchorLayoutAttributeSetter::handleStaticDataAttribute ( CAlfVisual &aVisual, AlfAttribute& aAttr, AlfAttributeContainer& aContainer, IAlfMap* aData )
	{
	if (!doHandleStaticAttribute(aVisual, aAttr, aContainer, aData))
	    {
	    AlfCommonLayoutAttributeSetter::handleStaticDataAttribute(aVisual, aAttr, aContainer, aData);
	    }
	}

	} // namespace Alf

// End of file