diff -r 000000000000 -r e83bab7cf002 widgetmodel/alfwidgetmodel/src/alfwidgetattributeownerimpl.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/widgetmodel/alfwidgetmodel/src/alfwidgetattributeownerimpl.cpp Thu Dec 17 08:56:02 2009 +0200 @@ -0,0 +1,515 @@ +/* +* 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 +#include "alf/alfattribute.h" +#include +#include +#include +#include "alf/attrproperty.h" +#include "alf/alfattributecontainer.h" +#include + + +#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(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(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(&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(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(&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(aAttribute).clone()); + handleAttribute(*mAttributeList[i]); + return true; + } + + bool supported(false); + bool sendevent(true); + + // Let the control try to handle attribute. + IAlfAttributeOwner* control = + IAlfInterfaceBase::makeInterface(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 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 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(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(elem); + if (elementOwner) + { + supported = elementOwner->setAttribute(aTargetId, aAttribute); + } + } + } + } + + //inform env of attribute change + if (supported) + { + UString target(aTargetId); + auto_ptr 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 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(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(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;inumElements(); + for (int i = 0; i < elementCount; i++) + { + IAlfElement& element = mControl->element(i); + if (element.parentElement() == 0) + { + // Get the attribute interface + IAlfAttributeOwner* attributeOwner = + IAlfInterfaceBase::makeInterface(&element); + + if (attributeOwner) + { + // let all IAlfAttributeOwners set the attribute + if (attributeOwner->setAttribute(aAttribute)) + { + UString target(element.name()); + auto_ptr 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