/*
* 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 common attributesetters for layout.
*
*/
#include "alf/alfattribute.h"
#include "alf/alfcommonlayoutattributesetter.h"
#include "alf/alfattributevaluetype.h"
#include <alf/alfvisual.h>
#include <alf/alflayout.h>
#include <alf/alfattributeexception.h>
#include "alf/alfattributecontainer.h"
#include <libc/string.h>
#include <osn/ustring.h>
#include "alf/attrproperty.h"
#include <alf/alfexception.h>
#include <alf/alfdataexception.h>
#include <alf/alfvisualexception.h>
#include <e32cmn.h>
#include <utf.h>
using namespace osncore;
using namespace duiuimodel::layoutattributes;
namespace Alf
{
static void throwIfNot ( bool aBoolean )
{
if ( !aBoolean )
{
ALF_THROW ( AlfAttributeException, EInvalidAttribute,"CAlfCommonlayoutAttributeSetter")
}
}
// ======== MEMBER FUNCTIONS ========
// ---------------------------------------------------------------------------
// Constructor.
// ---------------------------------------------------------------------------
//
OSN_EXPORT AlfCommonLayoutAttributeSetter::AlfCommonLayoutAttributeSetter()
{
}
// ---------------------------------------------------------------------------
// Destructor.
// ---------------------------------------------------------------------------
//
OSN_EXPORT AlfCommonLayoutAttributeSetter::~AlfCommonLayoutAttributeSetter()
{
}
// ---------------------------------------------------------------------------
// Sets Attribute Value. Delegates based on attribute Category.
// ---------------------------------------------------------------------------
//
OSN_EXPORT void AlfCommonLayoutAttributeSetter::setAttributeValue (
CAlfVisual &aVisual,
AlfAttributeContainer* aContainer,
IAlfMap* aData )
{
CAlfLayout* layout = dynamic_cast<CAlfLayout*> ( &aVisual );
if ( !layout )
{
ALF_THROW ( AlfVisualException, EInvalidVisual,
"AlfCommonLayoutAttributeSetter" )
}
AlfCommonVisualAttributeSetter::setAttributeValue(aVisual,
aContainer, aData);
}
void AlfCommonLayoutAttributeSetter::handleStaticDataAttribute ( CAlfVisual &aVisual, AlfAttribute& aAttr,
AlfAttributeContainer& aContainer, IAlfMap* aData )
{
if ( aData )
{
CAlfLayout* layout = dynamic_cast<CAlfLayout*> ( &aVisual );
if(!layout)
{
return;
}
const char* attrName = aAttr.name();
if ( !strcmp ( attrName, KBaseUnitX ) )
{
IAlfVariantType* dataX = aData->item ( UString(aAttr.getDataField()) );
AlfAttribute& attrY = aContainer.getAttributeByName ( KBaseUnitY );
IAlfVariantType* dataY = aData->item ( UString(attrY.getDataField()));
if (dataX!=NULL&&dataX->type() == IAlfVariantType::EMap&&
dataY!=NULL&&dataY->type() == IAlfVariantType::EMap)
{
IAlfVariantType* valueX=((IAlfMap*)dataX)->item(UString("value"));
IAlfVariantType* unitX=((IAlfMap*)dataX)->item(UString("unit"));
IAlfVariantType* valueY=((IAlfMap*)dataY)->item(UString("value"));
IAlfVariantType* unitY=((IAlfMap*)dataY)->item(UString("unit"));
TAlfMetric xMetric ( valueX->real(), (TAlfUnit)unitX->integer() );
TAlfMetric yMetric ( valueX->real(), (TAlfUnit)unitX->integer());
TAlfXYMetric xyMetric ( xMetric, yMetric );
layout->SetBaseUnit( xyMetric );
}
else if (dataX!=NULL&&dataX->type() == IAlfVariantType::EReal&&
dataY!=NULL&&dataY->type() == IAlfVariantType::EReal)
{
TAlfMetric xMetric ( (float)dataX->real() );
TAlfMetric yMetric ( (float)dataY->real());
TAlfXYMetric xyMetric ( xMetric, yMetric );
layout->SetBaseUnit( xyMetric );
}
}
else if ( !strcmp ( attrName, KBaseUnitY ) )
{
//we have handled it
}
else if ( !strcmp ( attrName, KUpdateLayoutTime ) )
{
IAlfVariantType* data = aData->item (UString(aAttr.getDataField()) );
if ( data && data->type() == IAlfVariantType::EInt )
{
layout->SetTransitionTime ( data->integer() );
}
else if ( data && data->type() == IAlfVariantType::EReal )
{
layout->SetTransitionTime ( ( int ) data->real() );
}
}
else if ( !strcmp ( attrName, KTransitionTime ) )
{
IAlfVariantType* data = aData->item (UString(aAttr.getDataField()) );
if ( data && data->type() == IAlfVariantType::EInt )
{
layout->SetTransitionTime ( data->integer() );
}
else if ( data && data->type() == IAlfVariantType::EReal )
{
layout->SetTransitionTime ( ( int ) data->real() );
}
}
else if ( !strcmp ( attrName, KAutomaticLocaleMirroring ) )
{
IAlfVariantType* data = aData->item (UString(aAttr.getDataField()) );
throwIfNot ( data != NULL && data->type() == IAlfVariantType::EString );
if ( !strcmp ( data->string().getUtf8(), "true" ) )
layout->SetFlag ( EAlfVisualFlagAutomaticLocaleMirroringEnabled );
else if ( !strcmp ( data->string().getUtf8(), "false" ) )
layout->ClearFlag ( EAlfVisualFlagAutomaticLocaleMirroringEnabled );
}
else if ( !strcmp ( attrName, KInnerPaddingHoriz ) )
{
IAlfVariantType* dataX = aData->item (UString(aAttr.getDataField()) );
AlfAttribute& attrY = aContainer.getAttributeByName ( KInnerPaddingVertical );
IAlfVariantType* dataY = aData->item ( UString(attrY.getDataField() ));
if (dataX&&dataX->type() == IAlfVariantType::EMap&&dataY
&&dataY->type()== IAlfVariantType::EMap)
{
IAlfVariantType* valueX=((IAlfMap*)dataX)->item(UString("value"));
IAlfVariantType* unitX=((IAlfMap*)dataX)->item(UString("unit"));
IAlfVariantType* valueY=((IAlfMap*)dataY)->item(UString("value"));
IAlfVariantType* unitY=((IAlfMap*)dataY)->item(UString("unit"));
TAlfMetric xMetric ( valueX->real(), (TAlfUnit)unitX->integer() );
TAlfMetric yMetric ( valueX->real(), (TAlfUnit)unitX->integer());
TAlfXYMetric xyMetric ( xMetric, yMetric );
layout->SetInnerPadding( xyMetric );
}
if ( dataX&&dataX->type() == IAlfVariantType::EReal&&dataY
&&dataY->type()== IAlfVariantType::EReal)
{
TAlfMetric xMetric ( dataX->real(),EAlfUnitPixel );
TAlfMetric yMetric ( dataY->real() ,EAlfUnitPixel);
TAlfXYMetric xyMetric ( xMetric, yMetric );
layout->SetInnerPadding( xyMetric );
}
}
else if ( !strcmp ( attrName, KInnerPaddingVertical ) )
{
// we have handled it
}
else if ( !strcmp ( attrName, KScrolling ) )
{
IAlfVariantType* data = aData->item ( UString(aAttr.getDataField() ));
throwIfNot ( data != NULL && data->type() == IAlfVariantType::EString );
if ( !strcmp ( data->string().getUtf8(), "true" ) )
{
TRAPD(err,layout->EnableScrollingL())
throwIfNot(err!=KErrNone);
}
else
{
TRAPD(err,layout->EnableScrollingL(false))
throwIfNot(err!=KErrNone);
}
}
else if ( !strcmp ( attrName, KLayoutScrollOffsetX ) )
{
IAlfVariantType* dataX = aData->item ( UString(aAttr.getDataField() ));
throwIfNot ( dataX != NULL && dataX->type() == IAlfVariantType::EReal );
AlfAttribute& attrY = aContainer.getAttributeByName ( KLayoutScrollOffsetY );
IAlfVariantType* dataY = aData->item (UString( attrY.getDataField() ));
throwIfNot ( dataY != NULL && dataY->type() == IAlfVariantType::EReal );
TAlfTimedPoint point ( dataX->real(), dataY->real() );
layout->SetScrollOffset ( point );
}
else if ( !strcmp ( attrName, KLayoutScrollOffsetY ) )
{
// we have handled it
}
else
{
AlfCommonVisualAttributeSetter::handleStaticDataAttribute( aVisual, aAttr, aContainer, aData);
}
}
}
void AlfCommonLayoutAttributeSetter::handleDynamicDataAttribute ( CAlfVisual &aVisual, AlfAttribute& aAttr,
AlfAttributeContainer& aContainer, IAlfMap* aData )
{
AlfCommonVisualAttributeSetter::handleDynamicDataAttribute( aVisual, aAttr, aContainer, aData);
}
void AlfCommonLayoutAttributeSetter::handleStaticAttribute ( CAlfVisual &aVisual, AlfAttribute& aAttr,
AlfAttributeContainer& aContainer)
{
CAlfLayout* layout = dynamic_cast<CAlfLayout*> ( &aVisual );
if(!layout)
{
return;
}
const char* attrName = aAttr.name();
if ( !strcmp ( attrName, KBaseUnitX )||!strcmp ( attrName, KBaseUnitY ) )
{
AlfAttribute& attrX = aContainer.getAttributeByName ( KBaseUnitX );
AlfAttribute& attrY = aContainer.getAttributeByName ( KBaseUnitY );
TAlfMetric xMetric ( attrX.realValue(), attrX.unit() );
TAlfMetric yMetric ( attrY.realValue(), attrY.unit() );
TAlfXYMetric xyMetric ( xMetric, yMetric );
layout->SetBaseUnit ( xyMetric );
attrX.setDirty(false);
attrY.setDirty(false);
}
else if ( !strcmp ( attrName, KUpdateLayoutTime ) )
{
if ( aAttr.type() == AlfAttributeValueType::EInt )
{
layout->SetTransitionTime ( aAttr.intValue() );
}
else if ( aAttr.type() == AlfAttributeValueType::EFloat )
{
layout->SetTransitionTime ( ( int ) aAttr.realValue() );
}
}
else if ( !strcmp ( attrName, KTransitionTime ) )
{
if ( aAttr.type() == AlfAttributeValueType::EInt )
{
layout->SetTransitionTime ( aAttr.intValue() );
}
else if ( aAttr.type() == AlfAttributeValueType::EFloat )
{
layout->SetTransitionTime ( ( int ) aAttr.realValue() );
}
}
else if ( !strcmp ( attrName, KAutomaticLocaleMirroring ) )
{
throwIfNot ( aAttr.type() == AlfAttributeValueType::EString );
if ( !strcmp ( aAttr.stringValue().getUtf8(), "true" ) )
{
layout->SetFlag ( EAlfVisualFlagAutomaticLocaleMirroringEnabled );
}
else if ( !strcmp ( aAttr.stringValue().getUtf8(), "false" ) )
{
layout->ClearFlag ( EAlfVisualFlagAutomaticLocaleMirroringEnabled );
}
}
else if ( !strcmp ( attrName, KInnerPaddingHoriz )||!strcmp ( attrName, KInnerPaddingVertical ) )
{
AlfAttribute& attrY = aContainer.getAttributeByName ( KInnerPaddingVertical );
AlfAttribute& attrX= aContainer.getAttributeByName ( KInnerPaddingHoriz );
throwIfNot ( attrX.type() == AlfAttributeValueType::EFloat );
throwIfNot ( attrY.type() == AlfAttributeValueType::EFloat );
TAlfMetric xMetric ( attrX.realValue(), attrX.unit() );
TAlfMetric yMetric ( attrY.realValue(), attrY.unit() );
TAlfXYMetric xyMetric ( xMetric, yMetric );
layout->SetInnerPadding ( xyMetric );
attrX.setDirty(false);
attrY.setDirty(false);
}
else if ( !strcmp ( attrName, KScrolling ) )
{
throwIfNot ( aAttr.type() == AlfAttributeValueType::EString );
if ( !strcmp ( aAttr.stringValue().getUtf8(), "true" ) )
{
TRAPD(err, layout->EnableScrollingL () );
throwIfNot (err==KErrNone);
}
else
{
TRAPD(err, layout->EnableScrollingL ( false ) );
throwIfNot (err==KErrNone);
}
}
else if ( !strcmp ( attrName, KLayoutScrollOffsetX )||!strcmp ( attrName, KLayoutScrollOffsetY ) )
{
AlfAttribute& attrY = aContainer.getAttributeByName ( KLayoutScrollOffsetY );
AlfAttribute& attrX = aContainer.getAttributeByName ( KLayoutScrollOffsetX );
TAlfTimedPoint point ( attrX.realValue(), attrY.realValue() );
layout->SetScrollOffset ( point );
attrX.setDirty(false);
attrY.setDirty(false);
}
else
{
AlfCommonVisualAttributeSetter::handleStaticAttribute(aVisual, aAttr, aContainer);
}
}
void AlfCommonLayoutAttributeSetter::handleDynamicAttribute( CAlfVisual &aVisual, AlfAttribute& aAttr,
AlfAttributeContainer& aContainer)
{
AlfCommonVisualAttributeSetter::handleDynamicAttribute(
aVisual, aAttr, aContainer);
}
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
OSN_EXPORT TAlfCommand* AlfCommonLayoutAttributeSetter::createCommand (
CAlfVisual& aVisual, AlfAttributeContainer* aContainer,
IAlfMap* aData, int aTransitionTime, CAlfVisual* aRefVisual )
{
TAlfCommand* cmd = 0;
cmd = AlfCommonVisualAttributeSetter::createCommand (
aVisual,
aContainer,
aData,
aTransitionTime,
aRefVisual );
return cmd;
}
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
OSN_EXPORT void AlfCommonLayoutAttributeSetter::createAndSendCommands (
CAlfVisual& aVisual,
AlfAttributeContainer* aContainer,
CAlfVisual* aRefVisual )
{
unsigned int attrCount = aContainer->attributeCount();
for ( int i = 0; i < attrCount; ++i )
{
AlfAttribute* attrib = & ( aContainer->getAttribute ( i ) );
const char* attrName = attrib->name();
if (strcmp ( attrName, KBaseUnitX )&&strcmp ( attrName, KBaseUnitY )
&&strcmp ( attrName, KUpdateLayoutTime )&&strcmp ( attrName, KTransitionTime )
&&strcmp ( attrName, KAutomaticLocaleMirroring )&&strcmp ( attrName, KInnerPaddingHoriz )
&&strcmp ( attrName, KInnerPaddingVertical ))
{
// Call the base class implementation also.
// It goes through the same loop again and checks if there are attributes
// that it handles.
AlfCommonVisualAttributeSetter::createAndSendCommands (
aVisual,
aContainer,
aRefVisual );
}
}
}
} // Alf