/*
* 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:   File implements the atrributesetters for the flowlayout.
*
*/



//includes

//widget model includes
#include "alf/alfattributecontainer.h"
#include "alf/alfattribute.h"
#include "alf/alfflowlayoutattributesetter.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/alfflowlayout.h>

//dui includes
#include "alf/attrproperty.h"

//other includes
#include <libc/string.h>



//namespaces
using namespace osncore;
using namespace duiuimodel::layoutattributes;

namespace Alf
    {

// ======== MEMBER FUNCTIONS ========

// ---------------------------------------------------------------------------
// Constructor.
// ---------------------------------------------------------------------------
//
OSN_EXPORT AlfFlowLayoutAttributeSetter::AlfFlowLayoutAttributeSetter()
    {
    }

// ---------------------------------------------------------------------------
// Destructor.
// ---------------------------------------------------------------------------
//
OSN_EXPORT AlfFlowLayoutAttributeSetter::~AlfFlowLayoutAttributeSetter()
    {
    }

// ---------------------------------------------------------------------------
// Sets Attribute Value. Delegates based on attribute Category.
// ---------------------------------------------------------------------------
//
OSN_EXPORT void AlfFlowLayoutAttributeSetter::setAttributeValue (
    CAlfVisual &aVisual,
    AlfAttributeContainer* aContainer,
    IAlfMap* aData )
    {
    // Ensure that the visual is a flow layout
    CAlfFlowLayout* flowLayout = dynamic_cast<CAlfFlowLayout*>(&aVisual);
    if (!flowLayout)
        {
        ALF_THROW ( AlfVisualException, EInvalidVisual, "AlfFlowLayoutAttributeSetter");
        }
    AlfCommonLayoutAttributeSetter::setAttributeValue(aVisual,
            aContainer, aData);
    }
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
OSN_EXPORT TAlfCommand* AlfFlowLayoutAttributeSetter::createCommand(
    CAlfVisual& /*aVisual*/, AlfAttributeContainer* /*aContainer*/,
    IAlfMap* /*aData*/, int /*aTransitionTime*/, CAlfVisual* /*aRefVisual*/)
    {
    TAlfCommand* cmd = 0;
    return cmd;
    }

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
OSN_EXPORT void AlfFlowLayoutAttributeSetter::createAndSendCommands(
    CAlfVisual& aVisual,
    AlfAttributeContainer* aContainer,
    CAlfVisual* aRefVisual )
    {
    // Flow layout does not have any specific API which takes timed value.
    // So, 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 AlfFlowLayoutAttributeSetter::handleDynamicDataAttribute (
    CAlfVisual& aVisual, AlfAttribute& aAttr,
    AlfAttributeContainer& aContainer, IAlfMap* aData)
    {
    // Flow Layout does not have any specific dynamic attribute, so call the
    // base class implementation. It goes through its loop and checks if there
    // are attributes that it handles.
    AlfCommonLayoutAttributeSetter::handleDynamicDataAttribute(aVisual, aAttr,
                                        aContainer, aData);
    }

void AlfFlowLayoutAttributeSetter::handleStaticDataAttribute(
    CAlfVisual &aVisual, AlfAttribute& aAttr,
    AlfAttributeContainer& aContainer, IAlfMap* aData)
    {
    if (!aData)  ALF_THROW ( AlfDataException, EInvalidVariantDataType, "AlfFlowLayoutAttributeSetter" )

    const char* dataField = aAttr.getDataField();
    if ( !dataField )  ALF_THROW ( AlfDataException, EInvalidAttribute, "AlfFlowLayoutAttributeSetter" )

    IAlfVariantType* data = aData->item ( UString(dataField));
    if (data)
        {
        const char* attrName = aAttr.name();
        CAlfFlowLayout* flowLayout = dynamic_cast<CAlfFlowLayout*>(&aVisual);
        if (!flowLayout)
            {
            ALF_THROW ( AlfVisualException, EInvalidVisual, "AlfFlowLayoutAttributeSetter");
            }

        if (!strcmp(attrName,flow::KFlowDirection))
            {
            if (data->type() == IAlfVariantType::EInt)
                {
                int direction = data->integer();
                flowLayout->SetFlowDirection(
                                (CAlfFlowLayout::TFlowDirection)direction);
                }
            else
                {
                ALF_THROW ( AlfDataException, EInvalidVariantDataType, "AlfFlowLayoutAttributeSetter");
                }    
            }
        else if (!strcmp(attrName,flow::KLayoutMode))
            {
            if (data->type() == IAlfVariantType::EInt)
                {
                int layoutMode = data->integer();
                flowLayout->SetMode(layoutMode);
                }
            else
                {
                ALF_THROW ( AlfDataException, EInvalidVariantDataType, "AlfFlowLayoutAttributeSetter");
                }    
            }
        else if (!strcmp(attrName,flow::KLayoutCentering))
            {
            if (data->type() == IAlfVariantType::EBool)
                {
                TBool layoutCentering = data->boolean();
                flowLayout->SetCentering(layoutCentering);
                }
            else
                {
                ALF_THROW ( AlfDataException, EInvalidVariantDataType, "AlfFlowLayoutAttributeSetter");
                }    
            }
        else
            {
            // Call the base class implementation .
            // It goes through its loop and checks if there are attributes 
            // that it handles.
            AlfCommonLayoutAttributeSetter::handleStaticDataAttribute(aVisual,
                                                aAttr, aContainer, aData);
            }
        }
    return;    
    }

void AlfFlowLayoutAttributeSetter::handleDynamicAttribute(
    CAlfVisual &aVisual, AlfAttribute& aAttr, 
    AlfAttributeContainer& aContainer)
    {
    // Flow Layout does not have any specific dynamic attribute, so call the 
    // base class implementation also. It goes through its loop and checks if
    // there are attributes that it handles.
    AlfCommonLayoutAttributeSetter::handleDynamicAttribute(aVisual, aAttr,
                                        aContainer);
    }

void AlfFlowLayoutAttributeSetter::handleStaticAttribute(
    CAlfVisual& aVisual, AlfAttribute& aAttr,
    AlfAttributeContainer& aContainer)
    {
    CAlfFlowLayout* flowLayout = dynamic_cast<CAlfFlowLayout*>(&aVisual);
    if (!flowLayout)
        {
        ALF_THROW ( AlfVisualException, EInvalidVisual, "AlfFlowLayoutAttributeSetter");
        }   

    const char* attrName = aAttr.name();

    if (!strcmp(attrName, flow::KFlowDirection))
        {
        if(aAttr.type() == AlfAttributeValueType::EInt)
            {
            int direction = aAttr.intValue();
            flowLayout->SetFlowDirection(
                        (CAlfFlowLayout::TFlowDirection)direction);
            }
        else
            {
            ALF_THROW ( AlfAttributeException, EInvalidAttributeValue, "AlfFlowLayoutAttributeSetter");
            }    
        }
    else if (!strcmp(attrName, flow::KLayoutMode))
        {
        if (aAttr.type() == AlfAttributeValueType::EInt)
            {
            int layoutMode = aAttr.intValue();
            flowLayout->SetMode(layoutMode);
            }
        else
            {
            ALF_THROW ( AlfAttributeException, EInvalidAttributeValue, "AlfFlowLayoutAttributeSetter");
            }        
        }
    else if (!strcmp(attrName, flow::KLayoutCentering))
        {
        if (aAttr.type() == AlfAttributeValueType::EInt)
            {
            int layoutCentering = aAttr.intValue();
            TBool flag=ETrue;           //Assume true for any non-zero value.
            if (0==layoutCentering) flag=EFalse;
            flowLayout->SetCentering(flag);
            }
        else
            {
            ALF_THROW ( AlfAttributeException, EInvalidAttributeValue, "AlfFlowLayoutAttributeSetter");
            }        
        }
    else // Call the base class implementation also.
         // It goes through the same loop again and checks if there are
         // attributes that it handles.
        {
        AlfCommonLayoutAttributeSetter::handleStaticAttribute(aVisual, aAttr,
                                            aContainer);
        }
    return;
    }

    } // Alf