/*

* 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:  layoutpreferences implementation for flowlayoutmanager.

*

*/

#include <assert.h>

#include <alf/ialfwidgetcontrol.h>

#include "alf/alfwidget.h"

#include <alf/alfexceptions.h>

#include <alf/ialflayoutpreferences.h>

#include <alf/alfflowlayoutmanager.h>

#include <alf/ialfflowlayoutpolicy.h>

#include <osn/osnnew.h>

//stl

#include <algorithm> //for min & max

#include "alfflowlayoutpreferencesimpl.h"

using namespace Alf;

namespace Alf

    {

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

AlfFlowLayoutPreferencesImpl::AlfFlowLayoutPreferencesImpl(

    AlfFlowLayoutManager& aFlowLayoutManager) : 

    mFlowLayoutManager(aFlowLayoutManager), mPreferredSize(TAlfMetric(0))

    {

    }

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

// from IAlfLayoutPreferences

// Returns the minimum area that this layout manager can occupy by observing

// the minimum sizes of the child UI elements in the layout

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

//

bool AlfFlowLayoutPreferencesImpl::getMinimumSize(TAlfXYMetric& aMinSize) const

	{

    return calculateChildSizes(aMinSize, 

        flowLayoutPolicy().flowDirection(), ESizeMin);

	}

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

// from IAlfLayoutPreferences

// Returns the maximum area that this layout manager can occupy by observing

// the maximum sizes of the child UI elements in the layout

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

//

bool AlfFlowLayoutPreferencesImpl::getMaximumSize(TAlfXYMetric& aMaxSize) const

	{

    return calculateChildSizes(aMaxSize, 

        flowLayoutPolicy().flowDirection(), ESizeMax);

	}

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

// Combines and returns the preferred sizes of all child UI elements according

// to the layouting rules.

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

//

bool AlfFlowLayoutPreferencesImpl::getPreferredSize(TAlfXYMetric& aPreferredSize) const

    {

    bool b = false;

    bool manualSet = (mPreferredSize.iX.iMagnitude > 0 && 

                      mPreferredSize.iY.iMagnitude > 0);

    if (manualSet)

        {

        aPreferredSize = mPreferredSize;

        b = true;

        }

    else

        {

        b = calculateChildSizes(aPreferredSize, 

            flowLayoutPolicy().flowDirection(), ESizePreferred);

        }

    return b;

	}

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

// from IAlfLayoutPreferences

// At the moment doesn't do anything since preferred size is being queried

// from the child UI elements added to this layout manager.

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

//

void AlfFlowLayoutPreferencesImpl::setPreferredSize( 

    const TAlfXYMetric& aPreferredSize )

	{

	mPreferredSize = aPreferredSize;

    mFlowLayoutManager.owner().updateParentLayout();

	}

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

// From class IAlfInterfaceBase.

// Getter for interfaces provided by the element.

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

//

IAlfInterfaceBase* AlfFlowLayoutPreferencesImpl::makeInterface(

    const IfId& aType)

    {

    UString param(aType.mImplementationId);

    IAlfInterfaceBase* ret = 0;

    if (param == IAlfLayoutPreferences::type().mImplementationId)

        {

        ret = static_cast<IAlfLayoutPreferences*>(this);

        }

    return ret;    

    }

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

// calculate the min-, preferred-, or max- sizes from the children. 

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

//    

bool AlfFlowLayoutPreferencesImpl::calculateChildSizes(

    TAlfXYMetric& aSize,  

    enum IAlfFlowLayoutPolicy::flowDirection aFlowDirection, 

    enum AlfFlowLayoutPreferencesImpl::sizeType aSizeType) const

    {

	bool ret = false; 

	TAlfXYMetric resultSize(TAlfMetric(0), TAlfMetric(0));

    // Iterate through all the child controls, and get their

    // preferred sizes.

    int childCount = mFlowLayoutManager.count();

    for (int i = 0; i < childCount; i++)

        {

        CAlfWidgetControl* childWidgetControl = mFlowLayoutManager.getControl(i);

        TAlfXYMetric size;

        if (getSize(childWidgetControl, size, aSizeType))

            {

            TAlfRealSize pixelSize = sizeInPixels(size);

            if (aFlowDirection == IAlfFlowLayoutPolicy::EFlowVertical)

                {

                //total width = max preferred width of child widgets.

                //total height = sum of the preferred heights of child widgets.

            	if(pixelSize.iWidth > resultSize.iX.iMagnitude)

            		{

            		resultSize.iX.iMagnitude = pixelSize.iWidth;

            		}

        		resultSize.iY.iMagnitude += pixelSize.iHeight;

        		ret = true;

                }

            else

                {

                //horizontal flow direction

                //total height = max preferred height of child widgets.

                //total width = sum of the preferred widths of child widgets.

            	if(pixelSize.iHeight > resultSize.iY.iMagnitude)

            		{

            		resultSize.iY.iMagnitude = pixelSize.iHeight;

            		}

        		resultSize.iX.iMagnitude += pixelSize.iWidth;

        		ret = true;

                }

            }

        }

    aSize = resultSize;

	return ret;

    }

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

// fetches the size from the IAlfLayoutPreferences-interface of the aControl.

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

//    

bool AlfFlowLayoutPreferencesImpl::getSize(

    CAlfWidgetControl* aControl,

    TAlfXYMetric& aSize,

    enum AlfFlowLayoutPreferencesImpl::sizeType aSizeType) const

    {

    bool ret = false;

    if (aControl)

        {

        const IAlfLayoutPreferences* layoutPrefs = 

            mFlowLayoutManager.getLayoutPreferences(aControl);

        if (layoutPrefs)

            {

            switch(aSizeType)

                {

                case AlfFlowLayoutPreferencesImpl::ESizePreferred:

                    ret = layoutPrefs->getPreferredSize(aSize);

                    break;

                case AlfFlowLayoutPreferencesImpl::ESizeMin:

                    ret = layoutPrefs->getMinimumSize(aSize);

                    break;

                case AlfFlowLayoutPreferencesImpl::ESizeMax:

                    ret = layoutPrefs->getMaximumSize(aSize);

                    break;

                }

            }

        }

    return ret;

    }

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

// get the flowlayoutpolicy-interface.

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

//    

const IAlfFlowLayoutPolicy& AlfFlowLayoutPreferencesImpl::flowLayoutPolicy() const

    {

	AlfFlowLayoutManager* man = 

	    const_cast<AlfFlowLayoutManager*>(&mFlowLayoutManager);

	IAlfFlowLayoutPolicy* policy = 

	    IAlfInterfaceBase::makeInterface<IAlfFlowLayoutPolicy>(man);

    assert(policy);

    return *policy;

    }

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

// converts size in metrics to size in pixels.

// implementation missing!

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

//    

TAlfRealSize AlfFlowLayoutPreferencesImpl::sizeInPixels(

    const TAlfXYMetric& aSize)

    {

    TAlfRealSize s;

    if(aSize.iX.iUnit == EAlfUnitPixel)

    	{

    	s.iWidth = aSize.iX.iMagnitude;

    	}

    if(aSize.iY.iUnit == EAlfUnitPixel)

        {

        s.iHeight = aSize.iY.iMagnitude;

        }

    return s;

    }

} // Alf