/*

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

*

*/

#include <alf/alfexceptions.h>

#include "alf/alfattribute.h"

#include <alf/alfwidgetcontrol.h>

#include <alf/ialfelement.h>

#include <osn/ustring.h>

#include "alf/attrproperty.h"

#include "alf/alfattributecontainer.h" 

#include <alf/alfwidgetcommand.h> 

#include "alfwidgetattributeownerimpl.h"

using namespace duiuimodel;

namespace Alf

    {

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

// Constructor.

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

//

AlfWidgetAttributeOwnerImpl::AlfWidgetAttributeOwnerImpl(

    CAlfWidgetControl* aControl) :

    mControl(aControl)

    {

    mAttributeList.setAutoDelete(true);    

    }

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

// Destructor.

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

//

AlfWidgetAttributeOwnerImpl::~AlfWidgetAttributeOwnerImpl()

    {

    mAttributeList.clear();

    }

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

// From class IAlfInterfaceBase.

// Getter for interfaces provided by the widget.

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

//

IAlfInterfaceBase* AlfWidgetAttributeOwnerImpl::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 AlfWidgetAttributeOwnerImpl::attributeCount() const

    {

    int count = mAttributeList.count();

    // Add control attribute count.

    IAlfAttributeOwner* control =

        IAlfInterfaceBase::makeInterface<IAlfAttributeOwner>(mControl);

    if (control)

        {

        count += control->attributeCount();

        // Add root element attribute count

        for (int i = 0; i < mControl->numElements(); i++)

            {

             IAlfElement& element = mControl->element(i);

             if (element.parentElement() == 0)

                {

                // Get the attribute interface

                IAlfAttributeOwner* attributeOwner = 

                    IAlfInterfaceBase::makeInterface<IAlfAttributeOwner>(&element);

                if (attributeOwner)

                    {

                    count += attributeOwner->attributeCount();

                    }

                }

            }

        }

    return count;

    }

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

// Gets the attribute with the given name.

// From class IAlfAttributeOwner.

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

//

const AlfAttribute* AlfWidgetAttributeOwnerImpl::getAttribute(

    const UString& aAttribName) const

    {

    const AlfAttribute* attribute = 0;

    // Try to find from widget

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

 	    {

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

 		    {

 			attribute = mAttributeList[i];

 			break;

 		    }

 	    }

    if (!attribute)

        {

        // Try to find from control

        IAlfAttributeOwner* control =

            IAlfInterfaceBase::makeInterface<IAlfAttributeOwner>(mControl);

        if (control)

            {

            attribute = control->getAttribute(aAttribName);

            }

        if (!attribute)

            {

            // Try to find from root elements

            for (int i = 0; i < mControl->numElements(); i++)

                {

                 IAlfElement& element = mControl->element(i);

                 if (element.parentElement() == 0)

                    {

                    // Get the attribute interface

                    IAlfAttributeOwner* attributeOwner = 

                        IAlfInterfaceBase::makeInterface<IAlfAttributeOwner>(&element);

                    if (attributeOwner)

                        {

                        attribute = attributeOwner->getAttribute(aAttribName);

                        if (attribute)

                            {

                            break;

                            }

                        }

                    }

                }

            }

        }

    return attribute;

    }

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

// Set a value of an attribute.

// From class IAlfAttributeOwner.

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

//

bool AlfWidgetAttributeOwnerImpl::setAttribute(const AlfAttribute& aAttribute)

    {

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

    if (!aAttribute.getTargetValueCount())

        {

        ALF_THROW(

            AlfAttributeException, EInvalidAttribute, "AlfWidgetAttributeOwnerImpl")

        }   

    if (canHandleAttribute(aAttribute.name()))

        {

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

        }

    bool supported(false);

    bool sendevent(true);

    // Let the control try to handle attribute.

    IAlfAttributeOwner* control =

        IAlfInterfaceBase::makeInterface<IAlfAttributeOwner>(mControl);

    if (control)

        {

        supported = control->setAttribute(aAttribute);

        }

    // Let the root elements try to handle attribute

    if (!supported)

        {

        supported = handleElementAttribute(aAttribute);

        sendevent = false; //event already sent

        }

    //inform env of attribute setting

    if (supported && sendevent)

        {

        UString target;

        auto_ptr<AlfAttribute> attribute(new (EMM) AlfAttribute());

        *attribute.get() = aAttribute;

        TAlfWidgetAttributeCommand command(attribute.get(), target, mControl->widget());

        attribute.release();

        command.ExecuteL(mControl->Env());

        }

    return (supported);

    }

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

// Set a value of an attribute.

// From class IAlfAttributeOwner.

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

//

bool AlfWidgetAttributeOwnerImpl::setAttribute(

    const UString& aAttribName, AlfAttributeValueType* aValue)

    {

    if (!aValue)

        {

        ALF_THROW(

            AlfAttributeException, EInvalidAttribute, "AlfWidgetAttributeOwnerImpl")

        }

    // 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 AlfWidgetAttributeOwnerImpl::setAttribute( const UString& aTargetId , 

												AlfAttribute& aAttribute ) 

	{

 	bool supported(false);

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

	if (!aAttribute.getTargetValueCount())

	    {

	    ALF_THROW(

	        AlfAttributeException, EInvalidAttribute, "AlfWidgetAttributeOwnerImpl")

	    }

    if (!aTargetId.isEmpty()

         && mControl)

        {

        // Try to find from control

        IAlfAttributeOwner* control =

            IAlfInterfaceBase::makeInterface<IAlfAttributeOwner>(mControl);

        if (control)

            {

            supported = control->setAttribute(aTargetId, aAttribute);

            }

        if (!supported)

            {

		    // Try finding element class using targetId

 		    IAlfElement* elem = mControl->findElement(aTargetId.getUtf8());

 		  	if (elem)	

		  		{

			    IAlfAttributeOwner* elementOwner =  IAlfInterfaceBase::makeInterface<IAlfAttributeOwner>(elem);

				if (elementOwner)

					{

					supported = elementOwner->setAttribute(aTargetId, aAttribute);	

					}

		  		}

	        }

	    }

	//inform env of attribute change

    if (supported)

        {

        UString target(aTargetId);

        auto_ptr<AlfAttribute> attribute(new (EMM) AlfAttribute());

        *attribute.get() = aAttribute;

        TAlfWidgetAttributeCommand command(attribute.get(), target, mControl->widget());

        attribute.release();

        command.ExecuteL(mControl->Env());

        }

    return supported;

	}

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

// Set a value of an attribute.

// From class IAlfAttributeOwner.

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

//

bool AlfWidgetAttributeOwnerImpl::setAttribute( const UString& aTargetId, 

											    const UString& aAttribName, 

											    AlfAttributeValueType* aValue )

	{

	bool ret(false);

    if (!aValue)

	    {

	    ALF_THROW(

	        AlfAttributeException, EInvalidAttribute, "AlfWidgetAttributeOwnerImpl")

	    }

    if (!aTargetId.isEmpty())

	    {

	    // Create a new static attribute.

	    auto_ptr<AlfAttribute> attribute(

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

	    attribute->addTargetValue(aValue);

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

		}

	return ret;    

	}

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

// Gets the attribute with the given name.

// From class IAlfAttributeOwner.

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

//

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

															    const UString& aAttribName ) const

	{

	const AlfAttribute* attr(0);

	if (!aTargetId.isEmpty()

	    && mControl)

        {

        // Try to find from control

        IAlfAttributeOwner* control =

            IAlfInterfaceBase::makeInterface<IAlfAttributeOwner>(mControl);

        if (control)

            {

            attr = control->getAttribute(aTargetId, aAttribName);

            }

        if (!attr)

            {

	        // Try finding element class from control

	        IAlfElement* element = mControl->findElement(aTargetId.getUtf8());

	        if (element)

		        {

		        // Get the attribute interface

		        IAlfAttributeOwner* attributeOwner = 

		            IAlfInterfaceBase::makeInterface<IAlfAttributeOwner>(element);

		        if (attributeOwner)

		            {

		            attr = attributeOwner->getAttribute(aTargetId, aAttribName); 

		            }

		        }

            }

	    }

	return attr;

	}

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

// Sets the attributes from container

// From class IAlfAttributeOwner.

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

//

bool AlfWidgetAttributeOwnerImpl::setAttributeContainer( AlfAttributeContainer& aAttributeContainer )

  	{

  	bool ret(true);

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

        {

        AlfAttribute& attr = aAttributeContainer.getAttribute(i);

        bool supported = setAttribute(attr);

        if (!supported)

	        {

	        ret = false;	

	        }

	    }

	return ret;

 	}

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

// Sets the attributes from container using targetId

// From class IAlfAttributeOwner.

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

//

bool AlfWidgetAttributeOwnerImpl::setAttributeContainer( const UString& aTargetId , 

                               AlfAttributeContainer& aAttributeContainer )

	{

	bool ret(true);

	if (!aTargetId.isEmpty() )

		{

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

	        {

	        AlfAttribute& attr = aAttributeContainer.getAttribute(i);

	        bool supported = setAttribute(aTargetId, attr);

	        if (!supported)

		        {

		        ret = false;	

		        }

	        }

	    }

	return ret;

	}

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

// Handles the attribute, sets proper values.

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

//

bool AlfWidgetAttributeOwnerImpl::handleElementAttribute(

    const AlfAttribute& aAttribute)

    {

    bool supported(false);

    // Let the root elements try to handle attribute

    const char* attrName = aAttribute.name();   // for debuging

    int elementCount = mControl->numElements();

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

        {

         IAlfElement& element = mControl->element(i);

         if (element.parentElement() == 0)

            {

            // Get the attribute interface

            IAlfAttributeOwner* attributeOwner = 

                IAlfInterfaceBase::makeInterface<IAlfAttributeOwner>(&element);

            if (attributeOwner)

                {

                // let all IAlfAttributeOwners set the attribute

                if (attributeOwner->setAttribute(aAttribute))

                    {

                    UString target(element.name());

                    auto_ptr<AlfAttribute> attribute(new (EMM) AlfAttribute());

                    *attribute.get() = aAttribute;

                    TAlfWidgetAttributeCommand command(attribute.get(), target, mControl->widget());

                    attribute.release();

                    command.ExecuteL(mControl->Env());

                    supported = true;

                    }

                }

            }

        }

    return supported;               

    }       

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

// Handles the attribute, sets proper values.

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

//

void AlfWidgetAttributeOwnerImpl::handleAttribute(

    const AlfAttribute& /*aAttribute*/)

    {

    // Add common widget specific attribute handling here

    }

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

// Can attribute be handled with this widget.

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

//

bool AlfWidgetAttributeOwnerImpl::canHandleAttribute(

    const char* /*aAttributeName*/)

    {

    bool canHandle(false);

    // Add common wigdet specific attribute checking here like:

/*    if (!strcmp(aAttributeName, commonvisualattributes::KOpacity))  

        {

        canHandle = true;

        }*/

    return canHandle;        

    }

    } // namespace Alf