/*
* 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 ViewPortLayout.
*
*/
//includes
//widget model includes
#include "alf/alfattributecontainer.h"
#include "alf/alfattribute.h"
#include "alf/alfviewportlayoutattributesetter.h"
#include <alf/alfvisualexception.h>
#include <alf/alfdataexception.h>
#include <alf/alfattributeexception.h>
//osn includes
#include <osn/ustring.h>
//alf includes
#include <alf/alfvisual.h>
#include <alf/alfviewportlayout.h>
//dui includes
#include "alf/attrproperty.h"
//other includes
#include <libc/string.h>
//namespaces
using namespace osncore;
using namespace duiuimodel::layoutattributes::viewport;
namespace Alf
{
// ======== MEMBER FUNCTIONS ========
// ---------------------------------------------------------------------------
// Constructor.
// ---------------------------------------------------------------------------
//
OSN_EXPORT AlfViewportLayoutAttributeSetter::AlfViewportLayoutAttributeSetter()
{
}
// ---------------------------------------------------------------------------
// Destructor.
// ---------------------------------------------------------------------------
//
OSN_EXPORT AlfViewportLayoutAttributeSetter::
~AlfViewportLayoutAttributeSetter()
{
}
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
IAlfVariantType* AlfViewportLayoutAttributeSetter::getData(
AlfAttribute& aAttr, IAlfMap* aData)
{
IAlfVariantType* data = 0;
const char* dataField = aAttr.getDataField();
if (dataField)
{
data = aData->item(UString(dataField));
}
return data;
}
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
int AlfViewportLayoutAttributeSetter::getTime(
const AlfAttribute& aAttr, bool aImmediate)
{
int time = 0;
if (!aImmediate)
{
time = aAttr.getTime();
}
return time;
}
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
OSN_EXPORT void AlfViewportLayoutAttributeSetter::setAttributeValue(
CAlfVisual &aVisual, AlfAttributeContainer* aContainer, IAlfMap* aData)
{
CAlfViewportLayout* viewportLayout =
dynamic_cast<CAlfViewportLayout*>(&aVisual);
if (!viewportLayout)
{
ALF_THROW (AlfVisualException, EInvalidVisual, "AlfViewportLayoutAttributeSetter")
}
AlfCommonLayoutAttributeSetter::setAttributeValue(aVisual,
aContainer, aData);
}
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
OSN_EXPORT TAlfCommand* AlfViewportLayoutAttributeSetter::createCommand(
CAlfVisual& /*aVisual*/, AlfAttributeContainer* /*aContainer*/,
IAlfMap* /*aData*/, int /*aTransitionTime*/, CAlfVisual* /*aRefVisual*/)
{
TAlfCommand* cmd = 0;
return cmd;
}
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
OSN_EXPORT void AlfViewportLayoutAttributeSetter::createAndSendCommands(
CAlfVisual& aVisual,
AlfAttributeContainer* aContainer,
CAlfVisual* aRefVisual )
{
// Call the base class implementation.
// It goes through its loop and checks if there are attributes that it
// handles.
AlfCommonLayoutAttributeSetter::createAndSendCommands(aVisual,
aContainer,aRefVisual);
}
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
void AlfViewportLayoutAttributeSetter::handleDynamicDataAttribute(
CAlfVisual& aVisual, AlfAttribute& aAttr,
AlfAttributeContainer& aContainer, IAlfMap* aData)
{
if (!doHandleDynamicDataAttribute(aVisual, aAttr, aContainer, aData))
{
AlfCommonLayoutAttributeSetter::handleDynamicDataAttribute(aVisual,
aAttr, aContainer, aData);
}
}
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
bool AlfViewportLayoutAttributeSetter::doHandleDynamicDataAttribute(
CAlfVisual& aVisual, AlfAttribute& aAttr,
AlfAttributeContainer& aContainer, IAlfMap* aData, bool aImmediate)
{
CAlfViewportLayout* viewportLayout =
dynamic_cast<CAlfViewportLayout*>(&aVisual);
if (!viewportLayout)
{
ALF_THROW (AlfVisualException, EInvalidVisual, "AlfViewportLayoutAttributeSetter")
}
bool handled = true;
if (!aData)
{
ALF_THROW (AlfDataException, EInvalidVariantDataType, "AlfViewportLayoutAttributeSetter" )
}
else
{
const char* attrName = aAttr.name();
if (!strcmp( attrName, KVirtualHeight)) //also handles: KVirtualWidth
{
// item for both virtual height and virtual width should be there.
const IAlfVariantType* virtualHeight = getData(aAttr, aData);
const IAlfVariantType* virtualWidth =
getData(aContainer.getAttributeByName(KVirtualWidth), aData);
if (virtualHeight &&
virtualHeight->type() == IAlfVariantType::EReal &&
virtualWidth && virtualWidth->type() == IAlfVariantType::EReal)
{
viewportLayout->SetVirtualSize(
TAlfRealSize(virtualWidth->real(),virtualHeight->real()),
getTime(aAttr, aImmediate));
}
else
{
ALF_THROW(AlfDataException, EInvalidVariantDataType, "AlfViewportLayoutAttributeSetter")
}
}
else if (!strcmp( attrName, KVirtualWidth))
{
// both virtual height and virtual width should be there
// if attribute for virtual height exists,don't do anything as this
// will be taken care while looking for attribute for virtual
// height, else throw exception
try
{
AlfAttribute& attrWidth =
aContainer.getAttributeByName (KVirtualHeight );
}
catch (...)
{
ALF_THROW(AlfDataException, EIncompleteAttributeValues, "AlfViewportLayoutAttributeSetter")
}
}
//also handles: KViewportWidth
else if (!strcmp( attrName, KViewportHeight))
{
// item for both viewport window height and viewport window width
// should be there.
const IAlfVariantType* viewportHeight = getData(aAttr, aData);
const IAlfVariantType* viewportWidth =
getData(aContainer.getAttributeByName(KViewportWidth), aData);
if (viewportHeight &&
viewportHeight->type() == IAlfVariantType::EReal &&
viewportWidth &&
viewportWidth->type() == IAlfVariantType::EReal)
{
viewportLayout->SetViewportSize(
TAlfRealSize(viewportWidth->real(),viewportHeight->real()),
getTime(aAttr, aImmediate));
}
else
{
ALF_THROW(AlfDataException, EInvalidVariantDataType, "AlfViewportLayoutAttributeSetter")
}
}
else if (!strcmp( attrName, KViewportWidth))
{
// both viewport height and viewport width should be there
// if attribute for viewport height exists,don't do anything as
// this will be taken care while looking for attribute for
// virtual height, else throw exception
try
{
AlfAttribute& attrWidth =
aContainer.getAttributeByName (KViewportHeight );
}
catch (...)
{
ALF_THROW(AlfDataException, EIncompleteAttributeValues, "AlfViewportLayoutAttributeSetter")
}
}
//also handles: KViewportPositionY
else if (!strcmp( attrName, KViewportPositionX))
{
// item for both viewport window X-position and Y-position
// should be there.
const IAlfVariantType* viewportPosX = getData(aAttr, aData);
const IAlfVariantType* viewportPosY =
getData(aContainer.getAttributeByName(KViewportPositionY),
aData);
if (viewportPosX &&
viewportPosX->type() == IAlfVariantType::EReal &&
viewportPosY && viewportPosY->type() == IAlfVariantType::EReal)
{
viewportLayout->SetViewportPos(
TAlfRealPoint(viewportPosX->real(),viewportPosY->real()),
getTime(aAttr, aImmediate));
}
else
{
ALF_THROW(AlfDataException, EInvalidVariantDataType, "AlfViewportLayoutAttributeSetter")
}
}
else if (!strcmp( attrName, KViewportPositionY))
{
// both viewport window X-position and Y-position should be there
// if attribute for viewport window X-position exists,don't do
// anything as this will be taken care while looking for attribute
// for viewport window X-position, else throw exception
try
{
AlfAttribute& attrWidth =
aContainer.getAttributeByName (KViewportPositionX );
}
catch (...)
{
ALF_THROW(AlfDataException, EIncompleteAttributeValues, "AlfViewportLayoutAttributeSetter")
}
}
else
{
handled = false;
}
}
return handled;
}
void AlfViewportLayoutAttributeSetter::handleStaticDataAttribute(
CAlfVisual &aVisual, AlfAttribute& aAttr,
AlfAttributeContainer& aContainer, IAlfMap* aData)
{
// viewport layout does not have any static attribute of its own
// check, if dynamic attribute(but set by user as static), if so,
// set attributes immediately.
if (!doHandleDynamicDataAttribute(aVisual, aAttr,aContainer, aData, true))
{
AlfCommonLayoutAttributeSetter::handleStaticDataAttribute(
aVisual, aAttr, aContainer, aData);
}
}
void AlfViewportLayoutAttributeSetter::handleDynamicAttribute(
CAlfVisual &aVisual, AlfAttribute& aAttr,
AlfAttributeContainer& aContainer)
{
if (!doHandleDynamicAttribute(aVisual, aAttr, aContainer))
{
AlfCommonLayoutAttributeSetter::handleDynamicAttribute(
aVisual, aAttr, aContainer);
}
}
bool AlfViewportLayoutAttributeSetter::doHandleDynamicAttribute(
CAlfVisual &aVisual, AlfAttribute& aAttr,
AlfAttributeContainer& aContainer, bool aImmediate)
{
CAlfViewportLayout* viewportLayout =
dynamic_cast<CAlfViewportLayout*>(&aVisual);
if (!viewportLayout)
{
ALF_THROW (AlfVisualException, EInvalidVisual, "AlfViewportLayoutAttributeSetter")
}
bool handled = true;
const char* attrName = aAttr.name();
if (!strcmp(attrName, KVirtualHeight)||!strcmp(attrName, KVirtualWidth))
{
// both virtual height and virtual width should be there.
AlfAttribute& attrWidth =
aContainer.getAttributeByName (KVirtualWidth );
AlfAttribute& attrHt = aContainer.getAttributeByName (KVirtualHeight );
if(attrWidth.type() == AlfAttributeValueType::EFloat &&
attrHt.type() == AlfAttributeValueType::EFloat )
{
float height = attrHt.realValue();
float width = attrWidth.realValue();
viewportLayout->SetVirtualSize(
TAlfRealSize(width,height),getTime(attrHt, aImmediate));
attrHt.setDirty(false);
attrWidth.setDirty(false);
}
else
{
ALF_THROW ( AlfAttributeException, EInvalidAttributeValue, "AlfViewportLayoutAttributeSetter");
}
}
else if (!strcmp(attrName, KViewportHeight)||
!strcmp(attrName, KViewportWidth))
{
// both viewport window height and width should be there.
AlfAttribute& attrWidth =
aContainer.getAttributeByName (KViewportWidth );
AlfAttribute& attrHt =
aContainer.getAttributeByName (KViewportHeight );
if(attrWidth.type() == AlfAttributeValueType::EFloat &&
attrHt.type() == AlfAttributeValueType::EFloat )
{
float height = attrHt.realValue();
float width = attrWidth.realValue();
viewportLayout->SetViewportSize(
TAlfRealSize(width,height),getTime(attrHt, aImmediate));
attrHt.setDirty(false);
attrWidth.setDirty(false);
}
else
{
ALF_THROW ( AlfAttributeException, EInvalidAttributeValue, "AlfViewportLayoutAttributeSetter");
}
}
else if (!strcmp(attrName, KViewportPositionX)||
!strcmp(attrName, KViewportPositionY))
{
// both viewport window X-position and Y-position should be there.
AlfAttribute& attrWidth =
aContainer.getAttributeByName (KViewportPositionY );
AlfAttribute& attrHt =
aContainer.getAttributeByName (KViewportPositionX );
if(attrWidth.type() == AlfAttributeValueType::EFloat &&
attrHt.type() == AlfAttributeValueType::EFloat )
{
float xPosition = attrHt.realValue();
float yPosition = attrWidth.realValue();
viewportLayout->SetViewportPos(
TAlfRealPoint(xPosition,yPosition),getTime(attrHt, aImmediate));
attrHt.setDirty(false);
attrWidth.setDirty(false);
}
else
{
ALF_THROW ( AlfAttributeException, EInvalidAttributeValue, "AlfViewportLayoutAttributeSetter");
}
}
else
{
handled = false;
}
return handled;
}
void AlfViewportLayoutAttributeSetter::handleStaticAttribute(
CAlfVisual& aVisual, AlfAttribute& aAttr,
AlfAttributeContainer& aContainer)
{
// viewport layout does not have any static attribute of its own
// check, if dynamic attribute(but set as static by the user),
// if so, set attributes immediately.
if (!doHandleDynamicAttribute(aVisual, aAttr, aContainer, true))
{
AlfCommonLayoutAttributeSetter::handleStaticAttribute(aVisual, aAttr,
aContainer);
}
}
} // Alf