/*

* 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:  Implementation of the IAlfAttributeOwner interface 

*                for AlfElement.

*

*/

#include <alf/alfexceptions.h>

#include "alf/alfattribute.h"

#include "alf/alfattributecontainer.h"

#include "alf/ialfvisualtemplate.h"

#include <alf/alfwidgetcontrol.h>

#include "alf/ialfattributesetter.h"

#include "alf/alfcommonvisualattributesetter.h"

#include "alf/alfelement.h"

#include <osn/ustring.h>

#include "alf/attrproperty.h"

#include <alf/alfwidgetcommand.h>

#include "alfelementattributeownerimpl.h"

using namespace duiuimodel;

namespace Alf

    {

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

// Constructor.

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

//

AlfElementAttributeOwnerImpl::AlfElementAttributeOwnerImpl(

    AlfElement& aElement, CAlfWidgetControl& aControl) :

    mElement(aElement), mControl(aControl)

    {

    mAttributeList.setAutoDelete(true);    

    }

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

// Destructor.

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

//

AlfElementAttributeOwnerImpl::~AlfElementAttributeOwnerImpl()

    {

    mAttributeList.clear();

    }

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

// From class IAlfInterfaceBase.

// Getter for interfaces provided by the element.

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

//

IAlfInterfaceBase* AlfElementAttributeOwnerImpl::makeInterface(

    const IfId& aType)

    {

    UString param(aType.mImplementationId);

    if (param == IAlfAttributeOwner::type().mImplementationId)

        {

    	return static_cast<IAlfAttributeOwner*>(this);

        }

    return 0;

    }    

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

// Get the number of available attributes.

// From class IAlfAttributeOwner.

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

//

int AlfElementAttributeOwnerImpl::attributeCount() const

    {

    return mAttributeList.count();

    }

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

// Gets the attribute with the given name.

// From class IAlfAttributeOwner.

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

//

const AlfAttribute* AlfElementAttributeOwnerImpl::getAttribute(

    const UString& aAttribName) const

    {

    AlfAttribute* attribute = 0;

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

 	    {

 		if (!strcmp(aAttribName.getUtf8(), mAttributeList[i]->name()))

 		    {

 			attribute = mAttributeList[i];

 			break;

 		    }

 	    }

    return attribute;

    }

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

// Set a value of an attribute.

// From class IAlfAttributeOwner.

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

//

bool AlfElementAttributeOwnerImpl::setAttribute(const AlfAttribute& aAttribute)

    {

    // The attribute must have at least one value set.

    if (!aAttribute.getTargetValueCount())

        {

        ALF_THROW(

            AlfAttributeException, EInvalidAttribute, "AlfElementAttributeOwnerImpl")

        }

    if (!canHandleAttribute(aAttribute.name()))

        {

        return false;

        }

    // Check whether the attribute exists already.

    int i = 0;

    for (i = 0; i < mAttributeList.count() ; i++)

 	    {

 		if (!strcmp(aAttribute.name(), mAttributeList[i]->name()))

 		    {

 		    // Attribute exists already, modify the contents.

 			*mAttributeList[i] = aAttribute;

 			handleAttribute(*mAttributeList[i]);

 			return true;

 		    }

        }

    // Attribute with the given name does not exist,

    // clone the given attribute and insert it in the list.

    mAttributeList.resize(mAttributeList.count() + 1);

    // Insert cannot fail because already resized.

    mAttributeList.insert(mAttributeList.count(),

        const_cast<AlfAttribute&>(aAttribute).clone());

    handleAttribute(*mAttributeList[i]);

    return true;

    }

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

// Set a value of an attribute.

// From class IAlfAttributeOwner.

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

//

bool AlfElementAttributeOwnerImpl::setAttribute(

    const UString& aAttribName, AlfAttributeValueType* aValue)

    {

    if (!aValue)

        {

        ALF_THROW(

            AlfAttributeException, EInvalidAttribute, "AlfElementAttributeOwnerImpl")

        }

    // Create a new attribute.

    auto_ptr<AlfAttribute> attribute(

        new (EMM) AlfAttribute(aAttribName.getUtf8(), AlfAttribute::EStatic));

    attribute->addTargetValue(aValue);

    return setAttribute(*attribute.get());

    }      

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

// Set a value of an attribute.

// From class IAlfAttributeOwner.

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

//

bool AlfElementAttributeOwnerImpl::setAttribute( const UString& aTargetId , 

												 AlfAttribute& aAttribute ) 

	{

  	bool ret(false);

	// The attribute must have at least one value set.

	if (!aAttribute.getTargetValueCount())

		{

		ALF_THROW(

		    AlfAttributeException, EInvalidAttribute, "AlfElementAttributeOwnerImpl")

		}

	//check targetId

	if (!aTargetId.isEmpty() 

	 && !aTargetId.compare(mElement.name()) )

		{

		ret = setAttribute(aAttribute);

		}

  	return ret;

  	}

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

// Set a value of an attribute.

// From class IAlfAttributeOwner.

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

//

bool AlfElementAttributeOwnerImpl::setAttribute( const UString& aTargetId, 

												 const UString& aAttribName,

 												 AlfAttributeValueType* aValue )

	{

	bool ret(false);

	if (!aValue)

		{

		ALF_THROW(

		    AlfAttributeException, EInvalidAttribute, "AlfElementAttributeOwnerImpl")

		}

	if (!aTargetId.isEmpty())

		{

		 // Create a new static attribute.

	    auto_ptr<AlfAttribute> attribute(

	        new (EMM) AlfAttribute(aAttribName.getUtf8(), AlfAttribute::EStatic));

	    attribute->addTargetValue(aValue);

	    ret = setAttribute(*attribute.get());

		}

	return ret;

	} 

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

// Gets the attribute with the given name.

// From class IAlfAttributeOwner.

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

//

const AlfAttribute* AlfElementAttributeOwnerImpl::getAttribute( const UString& aTargetId ,

															    const UString& aAttribName ) const

	{

	const AlfAttribute* attr(0);

	//check targetId

	if (!aTargetId.isEmpty() 

	     && !aTargetId.compare(mElement.name()))

		{

		attr = getAttribute(aAttribName); 

		}

	return attr;

	}

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

// Sets the attributes from container

// From class IAlfAttributeOwner.

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

//

bool AlfElementAttributeOwnerImpl::setAttributeContainer( AlfAttributeContainer& aAttributeContainer )

	{

    const int attributeCount = aAttributeContainer.attributeCount();

	int numAttributesHandled = 0;

    for (int i = 0; i < attributeCount ; i++)

        {

        AlfAttribute& attribute = aAttributeContainer.getAttribute(i);

        if (!strcmp(attribute.name(), duiuimodel::tactileattributes::KEventInput))

            {

            // Look for feedback type attribute.

            try

              {

              AlfAttribute& feedBackType = 

              aAttributeContainer.getAttributeByName(duiuimodel::tactileattributes::KFeedbackType);

              handleTactileAttribute(attribute,feedBackType);

              numAttributesHandled += 2;

              }

            catch(AlfDataException& exception)

              {

              // attribute not found,so return false

              return false;

              }

            }

        else if(setAttribute(attribute))

            {

            numAttributesHandled++;

            }

	    }

	return (numAttributesHandled == attributeCount);

	}

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

// Handles the Tactile Attribute.

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

//

void AlfElementAttributeOwnerImpl::handleTactileAttribute(

    AlfAttribute& aAttributeEvent,AlfAttribute& aAttributeFeedback)

    {

	    IAlfVisualTemplate* visualTemplate = mElement.getVisualTemplate();

	    // Find the root layout 

	    CAlfVisual* main = mElement.findVisual(0);//needs to be changed because in some cases id may be

	    										  // set by the user	

	    if(visualTemplate )

	        {

			AlfAttribute* attrEvent = NULL;

			AlfAttribute* attrFeedback = NULL;

	        int setterCount = visualTemplate->numAttributeSetters();

	        bool found(false);

	        for (int j = 0; j < setterCount ; j++)

	            {

	            AlfAttributeContainer& container = visualTemplate->attributeContainer(j);

	            try

	                {

	                //find the attribute in each container until it is found

	                attrEvent = &(container.getAttributeByName(duiuimodel::tactileattributes::KEventInput));

	                attrFeedback = &(container.getAttributeByName(duiuimodel::tactileattributes::KFeedbackType));

	                }

	            catch(AlfDataException& exception)

	                {

	                // attribute not found,so continue

	                continue;

	                }

	            //attribute found in one of the existing containers of the visual template, update it

	            *attrEvent = aAttributeEvent;

	            *attrFeedback = aAttributeFeedback;

	            found = true;

	            IAlfAttributeSetter& setter  = visualTemplate->attributeSetter(j);

	            if(main)

	            	setter.setAttributeValue(*main,&container,0);

	            break;                                            

	            }

	        // attribute not found in any of the containers, so create one attribute container and one 

	        // attribute setter and add both to the visual template        

	        if (!found)

	            {

	            auto_ptr<AlfAttributeContainer> container( 

	                new (EMM) AlfAttributeContainer());

	            auto_ptr<AlfCommonVisualAttributeSetter> setter(

	                new (EMM) AlfCommonVisualAttributeSetter());

	            AlfAttribute* attribe =aAttributeEvent.clone();

	            AlfAttribute* attribf =aAttributeFeedback.clone();

	            container.get()->addAttribute(attribe);

	            container.get()->addAttribute(attribf);

	            if(main)

	            setter.get()->setAttributeValue(*main, container.get(), 0);

	            visualTemplate->addAttributeSetter(setter.release(), 

	                container.release());

	            }

	        }

    }

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

// Sets the attributes from container using targetId

// From class IAlfAttributeOwner.

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

//

bool AlfElementAttributeOwnerImpl::setAttributeContainer( const UString& aTargetId , 

                               AlfAttributeContainer& aAttributeContainer )

	{

    const int attributeCount = aAttributeContainer.attributeCount();

	int numAttributesHandled = 0;

    for (int i = 0; i < attributeCount ; i++)

        {

        AlfAttribute& attribute = aAttributeContainer.getAttribute(i);

        if (!strcmp(attribute.name(), duiuimodel::tactileattributes::KEventInput))

        {

                // Look for feedback type attribute.

        // Look for feedback type attribute.

        try

          {

          AlfAttribute& feedBackType = 

          aAttributeContainer.getAttributeByName(duiuimodel::tactileattributes::KFeedbackType);

          handleTactileAttribute(attribute,feedBackType);

          numAttributesHandled += 2;

          }

        catch(AlfDataException& exception)

          {

          // attribute not found,so return false

          return false;

          }

        }

       else if(setAttribute(aTargetId,attribute))

        {

        	numAttributesHandled++;

        }

	    }

	return (numAttributesHandled == attributeCount);

	}

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

// Handles the attribute, sets proper values.

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

//

void AlfElementAttributeOwnerImpl::handleAttribute(AlfAttribute& aAttribute)

    {

    const char* attrName = aAttribute.name();

    if (!strcmp(attrName, commonvisualattributes::KOpacity)) 

        {

        handleOpacityAttribute(aAttribute);

        }

    else if(!strcmp(attrName, layoutattributes::KPositionX) || 

            !strcmp(attrName, layoutattributes::KPositionY))

        {

        handlePositionAttribute(aAttribute);

        }

    else if(!strcmp(attrName, layoutattributes::KWidth) || 

            !strcmp(attrName, layoutattributes::KHeight))

        {

        handleSizeAttribute(aAttribute);

        }

    else if(!strcmp(attrName, layoutattributes::KMaxWidth) || 

            !strcmp(attrName, layoutattributes::KMaxHeight))

        {

        handleMaxSizeAttribute(aAttribute);

        }

    else if(!strcmp(attrName, layoutattributes::KMinWidth) || 

            !strcmp(attrName, layoutattributes::KMinHeight))

        {

        handleMinSizeAttribute(aAttribute);

        }        

    }

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

// Can attribute be handled with this widget.

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

//

bool AlfElementAttributeOwnerImpl::canHandleAttribute(

    const char* aAttributeName)

    {

    bool canHandle(false);

    if (!strcmp(aAttributeName, commonvisualattributes::KOpacity) ||

        !strcmp(aAttributeName, layoutattributes::KPositionX) ||

        !strcmp(aAttributeName, layoutattributes::KPositionY) ||

        !strcmp(aAttributeName, layoutattributes::KWidth) ||

        !strcmp(aAttributeName, layoutattributes::KHeight) ||  

        !strcmp(aAttributeName, layoutattributes::KMaxWidth) ||

        !strcmp(aAttributeName, layoutattributes::KMaxHeight) ||  

        !strcmp(aAttributeName, layoutattributes::KMinWidth) ||

        !strcmp(aAttributeName, layoutattributes::KMinHeight))  

        {

        canHandle = true;

        }

    return canHandle;        

    }

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

// Handles the Opacity Attribute.

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

//

void AlfElementAttributeOwnerImpl::handleOpacityAttribute(

    AlfAttribute& aAttribute)

    {

    const char* attrName = aAttribute.name();

    IAlfVisualTemplate* visualTemplate = mElement.getVisualTemplate();

    // Find the root layout 

    CAlfVisual* main = mElement.findVisual(0);

    if(visualTemplate && main)

        {

        int setterCount = visualTemplate->numAttributeSetters();

        bool found(false);

        for (int j = 0; j < setterCount && main; j++)

            {

            AlfAttributeContainer& container = visualTemplate->attributeContainer(j);

            AlfAttribute* attr = NULL;

            try

                {

                //find the attribute in each container until it is found

                attr = &(container.getAttributeByName(attrName));

                }

            catch(AlfDataException& exception)

                {

                // attribute not found,so continue

                continue;

                }

            //attribute found in one of the existing containers of the visual template, update it

            *attr = aAttribute;

            found = true;

            IAlfAttributeSetter& setter  = visualTemplate->attributeSetter(j);

            setter.setAttributeValue(*main,&container,0);

            break;                                            

            }

        // attribute not found in any of the containers, so create one attribute container and one 

        // attribute setter and add both to the visual template        

        if (!found)

            {

            auto_ptr<AlfAttributeContainer> container( 

                new (EMM) AlfAttributeContainer());

            auto_ptr<AlfCommonVisualAttributeSetter> setter(

                new (EMM) AlfCommonVisualAttributeSetter());

            AlfAttribute* attribute =aAttribute.clone();

            container.get()->addAttribute(attribute);

            setter.get()->setAttributeValue(*main, container.get(), 0);

            visualTemplate->addAttributeSetter(setter.release(), 

                container.release());

            }

        }

    }

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

// Handles the Position Attribute

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

//    

void AlfElementAttributeOwnerImpl::handlePositionAttribute(AlfAttribute& aAttribute)

    {

    const char* attrName = aAttribute.name();

    const char* attrPair = layoutattributes::KPositionX;

    bool isPositionXAttr = false;

    if(!strcmp(attrName, layoutattributes::KPositionX))

        {

        attrPair = layoutattributes::KPositionY;