/*

* Copyright (c) 2006-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:   ?Description

*

*/

#include "uiacceltk/HuiGridLayout.h"  // Class definition

#include "uiacceltk/HuiControl.h"

#include "uiacceltk/HuiPanic.h"

#include "uiacceltk/HuiUtil.h"

#include "uiacceltk/huimetric.h"

#include <AknUtils.h>

#define FLOOR(x) (TReal32(TInt(TReal32(x))))

#define FLOOR_INT(x) (TInt((x)))

// Symbian does not have a native ceil() implementation, we need to use "near enough" rounding.

#define CEIL(x) (TReal32(TInt(TReal32(x)+0.999f)))

#define CEIL_INT(x) (TInt(TReal32(x)+0.999f))

// Fractional part of real

#define FRAC(x) (TReal32(x)-FLOOR(x))

//

// Private structures

//

struct TAxis

    {

    /** Array of block weights. Used to calculate relative sizes of lines of blocks. */

    RArray<THuiMetric> iWeights;

    TUint iLayoutFlags;    

    };

/*

 * grid weights

 */

struct CHuiGridLayout::TGridLayoutPrivateData

    {

public:

    TGridLayoutPrivateData();

public:

    RArray<TAxis> iAxes;

    /** Sets the grid dimensions to automatically expand to store more content */

    TInt iExpansionFlags;

    };

CHuiGridLayout::TGridLayoutPrivateData::TGridLayoutPrivateData()

    : 

    iExpansionFlags(0) 

    {

    }

//

// class CHuiGridLayout

//

EXPORT_C CHuiGridLayout* CHuiGridLayout::AddNewL(CHuiControl& aOwnerControl, 

                                                 TInt aColumns, TInt aRows,

                                                 CHuiLayout* aParentLayout)

    {

    CHuiGridLayout* grid = STATIC_CAST(CHuiGridLayout*,

        aOwnerControl.AppendLayoutL(EHuiLayoutTypeGrid, aParentLayout));

    grid->SetColumnsL(aColumns);

    grid->SetRowsL(aRows);

    return grid;

    }

EXPORT_C CHuiGridLayout::CHuiGridLayout(MHuiVisualOwner& aOwner)

        : CHuiLayout(aOwner)

    {

    }

EXPORT_C void CHuiGridLayout::ConstructL()

    {    

    CHuiLayout::ConstructL();

    iGridLayoutData = new(ELeave) TGridLayoutPrivateData;

    for(TInt ii = EHuiGridColumn; ii <= EHuiGridRow; ii++)

        {

        TAxis axis;

        axis.iLayoutFlags = 0;

        iGridLayoutData->iAxes.AppendL(axis);

        }

    SetColumnsL(1);

    SetRowsL(1);

    }

EXPORT_C CHuiGridLayout::~CHuiGridLayout()

    {    

    if ( iGridLayoutData )

        {

        for(TInt ii = EHuiGridColumn; ii <= EHuiGridRow; ii++)

            {

            TAxis& axis = iGridLayoutData->iAxes[ii];

            axis.iWeights.Reset();

            }

        iGridLayoutData->iAxes.Reset();

        }

    delete iGridLayoutData;

    iGridLayoutData = 0;

    }

EXPORT_C TInt CHuiGridLayout::ChildOrdinal(TInt aIndex)

    {

    // Use the visual index as ordinal.

    return EffectiveLayoutOrdinal(Visual(aIndex));

    }

EXPORT_C TPoint CHuiGridLayout::OrdinalToBlock(TInt aOrdinal) const

    {

    TPoint block(0,0);

    TInt cols = ColumnCount();

    TInt rows = RowCount();

    if (cols && rows)

        {

        if ( iGridLayoutData->iExpansionFlags & EExpandHorizontally )

            {

            block.iX = aOrdinal / rows;

            block.iY = aOrdinal % rows;

            }

        else

            {

            // By default the flow is vertically

            block.iX = aOrdinal % cols;

            block.iY = aOrdinal / cols;

            }

        }

    return block;    

    }

EXPORT_C void CHuiGridLayout::SetSize(const THuiRealSize& aSize, TInt aTransitionTime)

    {

    CHuiLayout::SetSize(aSize, aTransitionTime);

    UpdateChildrenLayout(aTransitionTime);    

    }

EXPORT_C TBool CHuiGridLayout::ChildSize(TInt aOrdinal, TSize& aSize)

    {

    TBool result(EFalse);

    THuiRealRect rect;

    TInt childRectStatus(THuiLayoutChildRectUpdateNotNeeded);

    childRectStatus = ChildRect(aOrdinal, rect);

    if(childRectStatus != THuiLayoutChildRectNotImplemented)

        {

        result = (childRectStatus & THuiLayoutChildRectSizeUpdateNeeded);

        if(result)

            {

            THuiRealPoint size(rect.Width(), rect.Height());

            aSize = LocalPointInPixels(size).AsSize();

            }

        }

    return result;

    }

EXPORT_C TBool CHuiGridLayout::ChildPos(TInt aOrdinal, TPoint& aPos)

    {

    TBool result(EFalse);

    THuiRealRect rect;

    TInt childRectStatus(THuiLayoutChildRectUpdateNotNeeded);

    childRectStatus = ChildRect(aOrdinal, rect);

    if(childRectStatus != THuiLayoutChildRectNotImplemented)

        {

        result = (childRectStatus & THuiLayoutChildRectPosUpdateNeeded);

        if(result)

            {

            aPos = LocalPointInPixels(rect.iTl);

            }

        }

    return result;

    }

EXPORT_C TInt CHuiGridLayout::ChildRect(TInt aOrdinal, THuiRealRect& aPos)

    {        

    if (!ColumnCount() || !RowCount())

        {

        return THuiLayoutChildRectUpdateNotNeeded;

        }

    // @todo refactorize with CHuiLayout::InnerSize

    THuiRealRect paddingPx = PaddingInPixels(EHuiReferenceStateTarget);

    // find the inner border and remove the inner paddings

    THuiRealPoint innerSizePx = LocalPointInPixels(Size().RealTarget(), EHuiReferenceStateTarget);

    innerSizePx.iX -= paddingPx.iTl.iX + paddingPx.iBr.iX;

    innerSizePx.iY -= paddingPx.iTl.iY + paddingPx.iBr.iY;

    // subtract the inner padding (space between each child).

    THuiRealPoint innerPaddingPx = MetricToPixels(InnerPadding(), EHuiReferenceStateTarget);

    THuiRealPoint availablePx(innerSizePx.iX - ((ColumnCount() - 1) * innerPaddingPx.iX),

                              innerSizePx.iY - ((RowCount() - 1) * innerPaddingPx.iY));

    TPoint blockLogical = OrdinalToBlock(aOrdinal);

    TPoint blockPosPx;

    TSize blockSizePx;

    CalculateCellInPixels(EHuiGridColumn, blockLogical.iX, availablePx.iX, blockPosPx.iX, blockSizePx.iWidth);

    CalculateCellInPixels(EHuiGridRow, blockLogical.iY, availablePx.iY, blockPosPx.iY, blockSizePx.iHeight);    

    // now add back in the inner paddings and the padding

    blockPosPx.iX += HUI_ROUND_FLOAT_TO_INT( paddingPx.iTl.iX + (blockLogical.iX * innerPaddingPx.iX) );

    blockPosPx.iY += HUI_ROUND_FLOAT_TO_INT( paddingPx.iTl.iY + (blockLogical.iY * innerPaddingPx.iY) );

    // get metric reference, for converting between base units of this layout (from the child visual's perspective) and pixels

    THuiRealPoint layoutRefPx = MetricReferenceForLayoutInPixels(BaseUnit().Abs()); // always target reference

    // Convert the result back into child relative coordinates

    THuiXYMetric blockPosChildMetric = BaseUnit();

    THuiXYMetric blockSizeChildMetric = BaseUnit();

    ConvertPixelsToMetricLength(blockPosChildMetric.iX, TReal32(blockPosPx.iX), layoutRefPx.iX);

    ConvertPixelsToMetricLength(blockPosChildMetric.iY, TReal32(blockPosPx.iY), layoutRefPx.iY);

    ConvertPixelsToMetricLength(blockSizeChildMetric.iX, TReal32(blockSizePx.iWidth), layoutRefPx.iX);

    ConvertPixelsToMetricLength(blockSizeChildMetric.iY, TReal32(blockSizePx.iHeight), layoutRefPx.iY);

    aPos.iTl.iX =  blockPosChildMetric.iX.iMagnitude;

    aPos.iTl.iY =  blockPosChildMetric.iY.iMagnitude;

    aPos.iBr.iX = aPos.iTl.iX + blockSizeChildMetric.iX.iMagnitude;

    aPos.iBr.iY = aPos.iTl.iY + blockSizeChildMetric.iY.iMagnitude;

    return THuiLayoutChildRectLayoutUpdateNeeded;

    }

EXPORT_C void CHuiGridLayout::SetColumnsL(TInt aColumnCount)

    {

    THuiMetric defaultWeight(1.f, EHuiUnitWeight);

    FillWeightsL(EHuiGridColumn, aColumnCount, defaultWeight);    

    }

EXPORT_C void CHuiGridLayout::SetRowsL(TInt aRowCount)

    {

    THuiMetric defaultWeight(1.f, EHuiUnitWeight);

    FillWeightsL(EHuiGridRow, aRowCount, defaultWeight);    

    }

EXPORT_C void CHuiGridLayout::SetColumnsL(const RArray<TInt>& aWeights)

    {

    TAxis& axis = iGridLayoutData->iAxes[EHuiGridColumn];

    axis.iWeights.Reset();

    for(TInt i = 0; i < aWeights.Count(); ++i)

        {

        User::LeaveIfError(axis.iWeights.Append(weight));

        }

    }

EXPORT_C void CHuiGridLayout::SetRowsL(const RArray<TInt>& aWeights)

    {

    TAxis& axis = iGridLayoutData->iAxes[EHuiGridRow];

    axis.iWeights.Reset();

    for(TInt i = 0; i < aWeights.Count(); ++i)

        {

        User::LeaveIfError(axis.iWeights.Append(weight));

        }

    }

EXPORT_C void CHuiGridLayout::FillWeightsL(THuiGridDimension aDim, TInt aCount, const THuiMetric& aWeight)

    {

    if(aDim <= EHuiGridRow)

        {

        TAxis& axis = iGridLayoutData->iAxes[aDim];

        axis.iWeights.Reset();

        for(TInt i = 0; i < aCount; ++i)

            {

            User::LeaveIfError(axis.iWeights.Append(aWeight));

            }

        }

    }

EXPORT_C void CHuiGridLayout::AppendWeightL(THuiGridDimension aDim, const THuiMetric& aWeight)

    {

    if(aDim <= EHuiGridRow)

        {

        TAxis& axis = iGridLayoutData->iAxes[aDim];

        User::LeaveIfError(axis.iWeights.Append(aWeight));

        }

    }

EXPORT_C void CHuiGridLayout::InsertWeightL(THuiGridDimension aDim, const THuiMetric& aWeight, TInt aPos)

    {

    if(aDim <= EHuiGridRow)

        {

        TAxis& axis = iGridLayoutData->iAxes[aDim];

        if(aPos < 0 || aPos >= axis.iWeights.Count())

            {

            User::Leave(KErrArgument);

            }

        else

            {

            User::LeaveIfError(axis.iWeights.Insert(aWeight, aPos));

            }

        }

    }

EXPORT_C void CHuiGridLayout::ReplaceWeightL(THuiGridDimension aDim, const THuiMetric& aWeight, TInt aPos)

    {

    if(aDim <= EHuiGridRow)

        {

        TAxis& axis = iGridLayoutData->iAxes[aDim];

        if(aPos < 0 || aPos >= axis.iWeights.Count())

            {

            User::Leave(KErrArgument);

            }

        else

            {

            axis.iWeights[aPos] = aWeight;

            }

        }

    }

EXPORT_C void CHuiGridLayout::RemoveWeightL(THuiGridDimension aDim, TInt aPos)

    {

    if(aDim <= EHuiGridRow)

        {

        TAxis& axis = iGridLayoutData->iAxes[aDim];

        if(aPos < 0 || aPos >= axis.iWeights.Count())

            {

            User::Leave(KErrArgument);

            }

        else

            {

            axis.iWeights.Remove(aPos);

            }

        }

    }

EXPORT_C THuiMetric CHuiGridLayout::Weight(THuiGridDimension aDim, TInt aPos) const

    {

    THuiMetric metric(0.f, EHuiUnitWeight); 

    if(aDim <= EHuiGridRow)

        {

        TAxis& axis = iGridLayoutData->iAxes[aDim];

        if(aPos < 0 || aPos >= axis.iWeights.Count())

            {

            // use empty weight

            }

        else

            {

            metric = axis.iWeights[aPos];

            }

        }

    return metric;

    }

EXPORT_C TInt CHuiGridLayout::DimensionCount(THuiGridDimension aDim) const

    {

    TInt count = 0;

    if(aDim <= EHuiGridRow)

        {

        count = iGridLayoutData->iAxes[aDim].iWeights.Count();

        }

    return count;

    }

EXPORT_C void CHuiGridLayout::SetExpanding(TInt aFlags)

    {

    iGridLayoutData->iExpansionFlags = aFlags;    

    }

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

// Function that determines if the filling order.

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

//

TBool CHuiGridLayout::UseRightToLeftFillingOrder() const

    {

    return CHuiStatic::LayoutMirrored();

    }

EXPORT_C void CHuiGridLayout::GetClassName(TDes& aName) const

    {

    aName = _L("CHuiGridLayout");

    }

EXPORT_C THuiXYMetric CHuiGridLayout::BaseUnit() const

    {

    return CHuiLayout::BaseUnit();

    }

EXPORT_C CHuiVisual* CHuiGridLayout::FindTag(const TDesC8& aTag)

    {

    return CHuiLayout::FindTag(aTag);

    }

EXPORT_C TInt CHuiGridLayout::Count() const

    {

    return CHuiLayout::Count();

    }

EXPORT_C CHuiVisual& CHuiGridLayout::Visual(TInt aIndex) const

    {

    return CHuiLayout::Visual(aIndex);

    }

EXPORT_C void CHuiGridLayout::SetPos(const THuiRealPoint& aPos, TInt aTransitionTime)

    {

    CHuiLayout::SetPos(aPos, aTransitionTime);

    }

EXPORT_C void CHuiGridLayout::UpdateChildrenLayout(TInt aTransitionTime)

    {

    CHuiLayout::UpdateChildrenLayout(aTransitionTime);

    }

EXPORT_C TBool CHuiGridLayout::PrepareDrawL()

    {

    return CHuiLayout::PrepareDrawL();

    }

EXPORT_C void CHuiGridLayout::Draw(CHuiGc& aGc) const

    {

    CHuiLayout::Draw(aGc);

    }

EXPORT_C void CHuiGridLayout::DrawSelf(CHuiGc& aGc, const TRect& aDisplayRect) const

    {

    CHuiLayout::DrawSelf(aGc, aDisplayRect);

    }

EXPORT_C TBool CHuiGridLayout::Changed() const

    {

    return CHuiLayout::Changed();

    }

EXPORT_C void CHuiGridLayout::ReportChanged()

    {

    CHuiLayout::ReportChanged();

    }

EXPORT_C void CHuiGridLayout::ClearChanged()

    {

    CHuiLayout::ClearChanged();

    }

EXPORT_C void CHuiGridLayout::NotifySkinChangedL()

    {

    CHuiLayout::NotifySkinChangedL();

    }

EXPORT_C void CHuiGridLayout::ExpandRectWithContent(TRect& aRect) const

    {

    CHuiLayout::ExpandRectWithContent(aRect); 

    }

EXPORT_C void CHuiGridLayout::VisualExtension(const TUid& aExtensionUid, TAny** aExtensionParams)

    {

    CHuiLayout::VisualExtension(aExtensionUid, aExtensionParams);

    }

EXPORT_C void CHuiGridLayout::DumpTree() const

    {

    CHuiLayout::DumpTree();

    }

EXPORT_C void CHuiGridLayout::GetInstanceName(TDes& aName) const

    {

    CHuiLayout::GetInstanceName(aName);

    }

EXPORT_C void CHuiGridLayout::RemoveAndDestroyAllD()

    {

    CHuiLayout::RemoveAndDestroyAllD();

    }

HUI_SESSION_OBJECT_IMPL_EXPORT(CHuiGridLayout, ETypeVisual)

EXPORT_C TInt CHuiGridLayout::RowCount() const

    {

    return iGridLayoutData->iAxes[EHuiGridRow].iWeights.Count();

    }

EXPORT_C TInt CHuiGridLayout::ColumnCount() const

    {

    return iGridLayoutData->iAxes[EHuiGridColumn].iWeights.Count();

    }

EXPORT_C void CHuiGridLayout::SetLayoutModeFlags(THuiGridDimension aDim, TUint aGridLayoutModeFlags)

    {

    if(aDim <= EHuiGridRow)

        {

        TAxis& axis = iGridLayoutData->iAxes[aDim];

        TUint oldFlags = axis.iLayoutFlags;

        // The following flags are mutually exclusive, clear existing flags first

        if (aGridLayoutModeFlags&EHuiGridIncreaseInnerPadding)

            {

            axis.iLayoutFlags &= ~EHuiGridDecreaseInnerPadding;

            }