/*

* 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:  Widget interface with utilities for container widget.

*

*/

#include "alfcontainerwidget.h"

#include "alfcontainercontrol.h"

#include "alfcontainerwidgetexception.h"

#include <libc/stdio.h>

#include <libc/string.h>

#include "alf/alfwidget.h"

#include <alf/alfenv.h>

#include <alf/alfmetric.h>

#include <alf/alfgridlayoutmanager.h>

#include <alf/ialfgridlayoutpolicy.h>

#include "alf/attrproperty.h"

namespace Alf

{

AlfContainerWidget::AlfContainerWidget(

	const char* aWidgetName, 

	IAlfContainerWidget& aContainer, 

	CAlfEnv& aEnv, 

	DuiNode* /*aNode*/,

	const char* /*aFilePath*/)

	: mWidget(0), 

	mEnv(aEnv)

    {

    mWidget.reset(new (EMM) AlfWidget(aWidgetName, aContainer, aEnv));

        constructDefault();

        setDefaultLayoutManager();

    }

AlfContainerWidget::~AlfContainerWidget()

    {

    }

CAlfWidgetControl* AlfContainerWidget::control() const

    {

    return mWidget->control();

    }

IAlfContainerWidget* AlfContainerWidget::parent() const

    {

    return mWidget->parent();

    }

void AlfContainerWidget::setControl(CAlfWidgetControl* aControl, bool aDeletePreviousControl)

    {

    mWidget->setControl(aControl, aDeletePreviousControl);

    }

IAlfModel* AlfContainerWidget::model()

    {

    return 0;

    }

void AlfContainerWidget::setModel(IAlfModel* /*aModel*/, bool /*aTakeOwnership*/)

    {

    }

const char* AlfContainerWidget::widgetName() const

    {

    return mWidget->widgetName();

    }

void AlfContainerWidget::setChildFocus(bool /*aFocus*/)

    {

    }

//---------------------------------------------------------------------------

// Creates the presentation for the widget from XML. Destroys any existing

// presentation.

//---------------------------------------------------------------------------

//    

void AlfContainerWidget::setPresentation (const char* aFilePath)

    {

    if(mWidget.get())

    	{

        mWidget->setPresentation(aFilePath);    	

    	}

    }    

int AlfContainerWidget::widgetCount() const

    {

    return mWidget->widgetCount();

    }

void AlfContainerWidget::addWidget(IAlfWidget& aWidget)

    {

    mWidget->addWidget(aWidget);

    }

IAlfWidget* AlfContainerWidget::getWidget(int aIndex) const

    {

    return mWidget->getWidget(aIndex);

    }

int AlfContainerWidget::getWidgetIndex(IAlfWidget& aWidget) const

    {

    return mWidget->getWidgetIndex(aWidget);

    }

void AlfContainerWidget::removeWidget(int aIndex)

    {

    mWidget->removeWidget(aIndex);

    }

void AlfContainerWidget::applyLayout(IAlfLayoutManager& aLayout)

    {

    mWidget->applyLayout(aLayout);

    }

IAlfInterfaceBase* AlfContainerWidget::makeInterface(const IfId& aType)

    {    

    // Type cast to IAlfWidget

    if(!strcmp(aType.mImplementationId, IAlfWidget::type().mImplementationId))

        {

        return static_cast<IAlfWidget*>(this);

        }

    // Type cast to IAlfContainerWidget        

    if(!strcmp(aType.mImplementationId, IAlfContainerWidget::type().mImplementationId))

        {

        return static_cast<IAlfContainerWidget*>(this); 

        } 

    return mWidget->makeInterface ( aType );

    }

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//    

void AlfContainerWidget::constructDefault()

    {

    // Create control for the container widget

    auto_ptr<AlfContainerControl> control(new (EMM) AlfContainerControl(mEnv));    

    setControl(control.get());

    control.release();

    }

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//   

void AlfContainerWidget::setDefaultLayoutManager()

	{

	 // Default layout manager provided by the container widget

    auto_ptr<AlfGridLayoutManager> layoutManager(new (EMM) AlfGridLayoutManager());

    this->applyLayout(*layoutManager.get());

    AlfGridLayoutManager* lm = layoutManager.release();

    IAlfGridLayoutPolicy* gridPolicy = IAlfInterfaceBase::makeInterface<IAlfGridLayoutPolicy>(lm);

    gridPolicy->fillWeights(IAlfGridLayoutPolicy::EGridDimensionColumn, 1, TAlfMetric(1, EAlfUnitWeight));

    gridPolicy->fillWeights(IAlfGridLayoutPolicy::EGridDimensionRow, 1, TAlfMetric(1, EAlfUnitWeight));

	}

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//   

void AlfContainerWidget::constructComponentsFromNode()

	{

	constructDefault();

    //check, if the layoutmanager is already set.

    IAlfLayoutManager* layoutManager = IAlfInterfaceBase::makeInterface<IAlfLayoutManager>(control());

    if (!layoutManager)

        {

        setDefaultLayoutManager();

        }

	}

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//  

void AlfContainerWidget::processTreeRecursively()

    {

    }

//---------------------------------------------------------------------------

//---------------------------------------------------------------------------

//    

void AlfContainerWidget::constructFromPresentationXML(const char* /*aFilePath*/ )

    {

    constructDefault();

    setDefaultLayoutManager();      

    }

}