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