/*

* 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:   Implementation for CHuiAnchorLayout. Anchor layouts 

*                allow specifying the placement of child visuals using 

*                anchors, that can be relative or absolute coordinates and 

*                attached to a specific edge of the layout.

*

*/

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

#include "uiacceltk/HuiControl.h"

#include "uiacceltk/HuiPanic.h"

#include "uiacceltk/HuiUtil.h"

//

// Private structures

//

/*

 * Anchor that defines an edge's position and/or size. 

 */

struct CHuiAnchorLayout::TEdgeAnchor

    {

    THuiAnchorProximity iEdgeProximity;

    THuiMetric iOffset;

    THuiAnchorProximity iAttachmentProximity;

    TInt iAttachmentOrdinal;

    };

/* 

 * an axis can contain up to two edges

 */

struct CHuiAnchorLayout::TAxis

    {

public:

    inline TInt Edge(THuiAnchorProximity aEdgeProximity, TEdgeAnchor*& aEdge) const;

    inline TInt AddEdge(THuiAnchorProximity aEdgeProximity, TEdgeAnchor*& aEdge);

public:

    /** array of edges */

    TFixedArray<TEdgeAnchor, 2> iEdges;

    };

inline TInt CHuiAnchorLayout::TAxis::Edge(THuiAnchorProximity aEdgeProximity, TEdgeAnchor*& aEdge) const

    {

    TInt error = KErrNotFound;

    TInt count = iEdges.Count();

    for(TInt ii = 0; ii < count && error == KErrNotFound ; ii++)

        {

        if(iEdges[ii].iEdgeProximity == aEdgeProximity)

            {

            aEdge = const_cast<TEdgeAnchor*>(&(iEdges[ii])); // uses the const operator[] as this is a const method

            error = KErrNone;

            }

        }

    return error;

    }

TInt CHuiAnchorLayout::TAxis::AddEdge(THuiAnchorProximity aEdgeProximity, TEdgeAnchor*& aEdge)

    {

    TInt error = Edge(aEdgeProximity, aEdge);

    if(error == KErrNotFound)

        {

        // we haven't found the one we're looking for, so now look for an empty slot

        error = Edge(EHuiAnchorProximityNone, aEdge);

        if(error == KErrNotFound)

            {

            // couldn't find an empty slot, so actually we consider that to be an overflow

            error = KErrOverflow;

            }

        }

    return error;

    }

/*

 * axes for a given anchor. 

 *

 */

struct CHuiAnchorLayout::TAnchor

    {

public:

    TAxis& Axis(THuiAnchorAxis aAxis) const;

public:

    /** 

     * array of axes indexed by THuiAnchorAxis, each one contains the edges for a given axis

     */

    TFixedArray<TAxis, 2> iAxes;

    };

CHuiAnchorLayout::TAxis& CHuiAnchorLayout::TAnchor::Axis(THuiAnchorAxis aAxis) const

    {

    // index is an enumeration and cannot go outside array boundaries.

    return const_cast<CHuiAnchorLayout::TAxis&>(iAxes[aAxis]);

    }

/*

 * Internal private data struct.

 */

struct CHuiAnchorLayout::THuiAnchorLayoutPrivateData

    {

public:

    THuiAnchorLayoutPrivateData();

public:

    /*

     * Anchors for a given axis, indexed by ordinal. 

     * @note that if an ordinal is used that is outside the current size of the 

     * array, then empty items will be filled in up to the ordinal needed. However,

     * in general ordinals will correspond to indexes of visuals within the layout, 

     * and therefore we shouldn't expect unreasonable growth of anchors.

     */

    RArray<TAnchor> iAnchors;

    };

CHuiAnchorLayout::THuiAnchorLayoutPrivateData::THuiAnchorLayoutPrivateData()

    {

    }

//

// Methods for compatibility with deprecated APIs

//

THuiAnchorType CHuiAnchorLayout::ConvertDeprecatedAnchorTypeToType(THuiAnchor aAnchor) const

    {

    THuiAnchorType type;

    switch(aAnchor)

        {

        case EHuiAnchorTopLeft:

            type = EHuiAnchorTypeTopLeft;

            break;

        case EHuiAnchorBottomRight:

            type = EHuiAnchorTypeBottomRight;

            break;

        default:

            type = EHuiAnchorTypeNone;

            break;

        }

    return type;

    }

THuiAnchorAttachmentOrigin CHuiAnchorLayout::ConvertDeprecatedOrginToAttachmentOrigin(THuiAnchorOrigin aOrigin) const

    {

    THuiAnchorAttachmentOrigin origin;

    switch(aOrigin)

        {

        case EHuiAnchorOriginLeft:

            origin = EHuiAnchorAttachmentOriginLeft;

            break;

        case EHuiAnchorOriginHCenter:

            origin = EHuiAnchorAttachmentOriginHCenter;

            break;

        case EHuiAnchorOriginRight:

            origin = EHuiAnchorAttachmentOriginRight;

            break;

        case EHuiAnchorOriginTop:

            origin = EHuiAnchorAttachmentOriginTop;

            break;

        case EHuiAnchorOriginVCenter:

            origin = EHuiAnchorAttachmentOriginVCenter;

            break;

        case EHuiAnchorOriginBottom:

            origin = EHuiAnchorAttachmentOriginBottom;

            break;

        default:

            origin = EHuiAnchorAttachmentOriginNone;

            break;

        }

    return origin;

    }

THuiAnchorAttachmentOrigin CHuiAnchorLayout::ConvertDeprecatedOriginsToAttachmentOrigin(THuiAnchorOrigin aHorizOrigin, THuiAnchorOrigin aVertOrigin) const

    {

    THuiAnchorAttachmentOrigin newHorizAttachmentOrigin = ConvertDeprecatedOrginToAttachmentOrigin(aHorizOrigin);

    THuiAnchorAttachmentOrigin newVertAttachmentOrigin = ConvertDeprecatedOrginToAttachmentOrigin(aVertOrigin);

    THuiAnchorAttachmentOrigin origin = THuiAnchorAttachmentOrigin(newHorizAttachmentOrigin | newVertAttachmentOrigin);

    return origin;

    }

THuiMetric CHuiAnchorLayout::ConvertDeprecatedAnchorMetricAndTargetToHuiMetric(THuiAnchorMetric aMetric, TReal32 aTarget) const

    {

    THuiUnit unit;

    switch(aMetric)

        {

        case EHuiAnchorMetricAbsolute:

            unit = EHuiUnitPixel;

            break;

        case EHuiAnchorMetricRelativeToSize:

            unit = EHuiUnitRelativeToMySize;

            break;

        default:

            unit = EHuiUnitPixel;

            break;

        }

    THuiMetric metric(aTarget, unit);

    return metric;

    }

THuiXYMetric CHuiAnchorLayout::ConvertDeprecatedAnchorMetricsAndOffsetToHuiMetric(

    THuiAnchorMetric aHorizMetric,

    THuiAnchorMetric aVertMetric,

    const THuiTimedPoint& aOffset) const

    {

    TReal32 horizTarget = aOffset.iX.Target();

    TReal32 vertTarget = aOffset.iY.Target();

    THuiMetric horizMetric = ConvertDeprecatedAnchorMetricAndTargetToHuiMetric(aHorizMetric, horizTarget);

    THuiMetric vertMetric = ConvertDeprecatedAnchorMetricAndTargetToHuiMetric(aVertMetric, vertTarget);

    THuiXYMetric metric(horizMetric, vertMetric);

    return metric;

    }

//

// Methods for dealing with internal data types

//

THuiAnchorProximity CHuiAnchorLayout::ConvertTypeToProximity(THuiAnchorType aType, THuiAnchorAxis& aAxis) const

    {

    THuiAnchorProximity proximity;

    THuiAnchorProximity proximityH = THuiAnchorProximity((aType & EHuiAnchorBitmaskHorizontal) >> EHuiAnchorBitmaskShiftHorizontal);

    THuiAnchorProximity proximityV = THuiAnchorProximity((aType & EHuiAnchorBitmaskVertical) >> EHuiAnchorBitmaskShiftVertical);

    if(proximityH)

        {

        proximity = proximityH;

        aAxis = EHuiAnchorAxisHorizontal;

        }

    else if(proximityV)

        {

        proximity = proximityV;

        aAxis = EHuiAnchorAxisVertical;

        }

    else 

        {

        proximity = EHuiAnchorProximityNone;

        }

    return proximity;

    }

THuiAnchorProximity CHuiAnchorLayout::ConvertAttachmentOriginToProximity(THuiAnchorAttachmentOrigin aAttachmentOrigin, THuiAnchorAxis& aAxis) const

    {

    THuiAnchorType type = THuiAnchorType(aAttachmentOrigin);

    return ConvertTypeToProximity(type, aAxis);

    }

void CHuiAnchorLayout::ConvertCornerToEdges(THuiAnchorType aCorner, THuiAnchorType& aEdgeH, THuiAnchorType& aEdgeV) const

    {

    aEdgeH = THuiAnchorType(aCorner & EHuiAnchorBitmaskHorizontal);

    aEdgeV = THuiAnchorType(aCorner & EHuiAnchorBitmaskVertical);

    }

void CHuiAnchorLayout::ConvertCornerAttachmentOriginToEdgeAttachmentOrigins(THuiAnchorAttachmentOrigin aCornerOrigin, THuiAnchorAttachmentOrigin& aAttachmentOriginH, THuiAnchorAttachmentOrigin& aAttachmentOriginV) const

    {

    aAttachmentOriginH = THuiAnchorAttachmentOrigin(aCornerOrigin & EHuiAnchorBitmaskHorizontal);

    aAttachmentOriginV = THuiAnchorAttachmentOrigin(aCornerOrigin & EHuiAnchorBitmaskVertical);

    }

//

// Methods

//

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

                                                     CHuiLayout* aParentLayout)

    {

    CHuiAnchorLayout* layout = STATIC_CAST(CHuiAnchorLayout*,

        aOwnerControl.AppendLayoutL(EHuiLayoutTypeAnchor, aParentLayout));

    return layout;

    }

CHuiAnchorLayout::CHuiAnchorLayout(MHuiVisualOwner& aOwner)

        : CHuiLayout(aOwner)

    {

    }

void CHuiAnchorLayout::ConstructL()

    {

    CHuiLayout::ConstructL();

    iHuiAnchorLayoutPrivateData = new (ELeave) THuiAnchorLayoutPrivateData;

    }

EXPORT_C CHuiAnchorLayout::~CHuiAnchorLayout()

    {

    Reset();

    delete iHuiAnchorLayoutPrivateData;

    }

EXPORT_C void CHuiAnchorLayout::Reset()

    {

    if ( iHuiAnchorLayoutPrivateData ) // a Fix for OOM situations, tried to dereference NULL pointer

    	{

	    for(TInt ii = EHuiAnchorAxisHorizontal; ii <= EHuiAnchorAxisVertical; ii++)

	        {

	        iHuiAnchorLayoutPrivateData->iAnchors.Reset();

	        }

    	}

    }

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

    {

    CHuiLayout::SetSize(aSize, aTransitionTime);

    if(!(Flags() & EHuiVisualFlagFreezeLayout))

        {    

        UpdateChildrenLayout(aTransitionTime);

        }

    }

EXPORT_C TBool CHuiAnchorLayout::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, EHuiReferenceStateTarget).AsSize();

            }

        }

    return result;

    }

EXPORT_C TBool CHuiAnchorLayout::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, EHuiReferenceStateTarget);

            }

        }

    return result;

    }

EXPORT_C TInt CHuiAnchorLayout::ChildRect(TInt aOrdinal, THuiRealRect& aRect)

    {

    TInt result(THuiLayoutChildRectUpdateNotNeeded);

    // split inner area (in pixels) into separate axes

    TFixedArray<TReal32, 2> tl;

    TFixedArray<TReal32, 2> br;

    // evaluate the anchor along each axis in turn

    if(aOrdinal < iHuiAnchorLayoutPrivateData->iAnchors.Count())

        {

        TAnchor& anchor = iHuiAnchorLayoutPrivateData->iAnchors[aOrdinal];

        for(TInt ii = EHuiAnchorAxisHorizontal; ii <= EHuiAnchorAxisVertical; ii++)

            {

            THuiAnchorAxis axisId = THuiAnchorAxis(ii);

            TAxis& axis = anchor.Axis(axisId);

            // index is an enumeration and cannot go outside array boundaries

            result |= EvaluateAxis(axisId, axis, tl[axisId], br[axisId]);

            }

        aRect.iTl.iX = tl[EHuiAnchorAxisHorizontal];

        aRect.iTl.iY = tl[EHuiAnchorAxisVertical];

        aRect.iBr.iX = br[EHuiAnchorAxisHorizontal];

        aRect.iBr.iY = br[EHuiAnchorAxisVertical];

        }

    if(result == THuiLayoutChildRectUpdateNotNeeded)

        {

        // No anchor defined at all. Use the default anchor.

        THuiRealPoint topLeft = InnerTopLeft();

        THuiRealSize inner = InnerSize();

        aRect.iTl = topLeft;

        aRect.iBr.iX = inner.iWidth;

        aRect.iBr.iY = inner.iHeight;

        result = THuiLayoutChildRectLayoutUpdateNeeded;

        }

    return result;

    }

/* 

 * the values from the paddings are in parent base units, whilst the anchor edges have 

 * their own units, so we must first convert everything to real pixels, then calculate 

 * the pixel positions, then convert everything back into base units of this layout visual

 */

TInt CHuiAnchorLayout::EvaluateAxis(THuiAnchorAxis aAxisId, const TAxis& aAxis, TReal32& aNear, TReal32& aFar) const

    {

    TInt result(THuiLayoutChildRectUpdateNotNeeded);

    // @todo use cached value if optimization is needed

    // @todo refactorize with CHuiLayout::InnerSize

    THuiRealRect paddingRectPx = PaddingInPixels(EHuiReferenceStateTarget);

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

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

    // switch to near and far along this axis

    TReal32 nearPx = (aAxisId == EHuiAnchorAxisHorizontal) ? paddingRectPx.iTl.iX : paddingRectPx.iTl.iY;

    TReal32 farPaddingPx = (aAxisId == EHuiAnchorAxisHorizontal) ? paddingRectPx.iBr.iX : paddingRectPx.iBr.iY;

    TReal32 sizePx = (aAxisId == EHuiAnchorAxisHorizontal) ? sizePointPx.iX : sizePointPx.iY;

    TReal32 farPx = sizePx - farPaddingPx;

    TReal32 innerPaddingPx= (aAxisId == EHuiAnchorAxisHorizontal) ? innerPaddingPointPx.iX : innerPaddingPointPx.iY;

    // these will be the calculated values, which we build up one edge at a time

    TReal32 nearCalculatedPx(nearPx);

    TReal32 farCalculatedPx(farPx);

    // we iterate over the edges, but we don't know what order

    // they were defined, so have to build up the answer as we go

    TInt count = aAxis.iEdges.Count();

    for(TInt ii = 0; ii < count; ii++)

        {

        const TEdgeAnchor& edge = aAxis.iEdges[ii];

        if(edge.iEdgeProximity != EHuiAnchorProximityNone)

            {

            // now convert this edge anchor's metric offset into pixels

            TReal32 offsetPx = EdgeOffsetInPixels(aAxisId, edge);

            result |= EvaluateEdgeAnchorInPixels(aAxisId, edge, innerPaddingPx , offsetPx, nearPx, nearCalculatedPx, farPx, farCalculatedPx);

            }

        }

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

    // We must calculate metric reference in both directions, but we only need it along this axis

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

    TReal32 childMetricRefPx = (aAxisId == EHuiAnchorAxisHorizontal) ? childMetricRefSizePx.iX :childMetricRefSizePx.iY;

    // Convert the result back into child relative coordinates

    THuiMetric nearCalculated = (aAxisId == EHuiAnchorAxisHorizontal) ? BaseUnit().iX :BaseUnit().iY;

    THuiMetric farCalculated(nearCalculated);

    ConvertPixelsToMetricLength(nearCalculated, nearCalculatedPx, childMetricRefPx);

    ConvertPixelsToMetricLength(farCalculated, farCalculatedPx, childMetricRefPx);

    // back to point and size

    aNear = nearCalculated.iMagnitude; 

    aFar = farCalculated.iMagnitude;

    return result;

    }

TReal32 CHuiAnchorLayout::EdgeOffsetInPixels(THuiAnchorAxis aAxisId, const TEdgeAnchor& aEdge) const

    {

    THuiRealPoint offsetRefSizePx = MetricReferenceInPixels(THuiXYMetric(aEdge.iOffset), EHuiReferenceStateTarget);

    TReal32 offsetRefPx = (aAxisId == EHuiAnchorAxisHorizontal) ? offsetRefSizePx.iX :offsetRefSizePx.iY;

    TReal32 offsetPx(0);

    ConvertMetricLengthToPixels(offsetPx, aEdge.iOffset, offsetRefPx);

    return offsetPx;

    }

TInt CHuiAnchorLayout::EvaluateEdgeAnchorInPixels(

    THuiAnchorAxis aAxisId,

    const TEdgeAnchor& aEdge,

    TReal32 aInnerPaddingPx,

    TReal32 aOffsetPx,

    TReal32 aNearPx, TReal32& aNearCalculatedPx, 

    TReal32 aFarPx, TReal32& aFarCalculatedPx) const

    {

    TInt result(THuiLayoutChildRectUpdateNotNeeded);

    // first calculate the offset caused if there is an attached anchor

    TReal32 attachOriginNearCalculatedPx(aNearPx);

    TReal32 attachOriginFarCalculatedPx(aFarPx);

    result |= EvaluateEdgeAttachmentInPixels(aAxisId, aEdge, aInnerPaddingPx, aNearPx, attachOriginNearCalculatedPx, aFarPx, attachOriginFarCalculatedPx);

    TReal32 origDimensionPx = attachOriginFarCalculatedPx - attachOriginNearCalculatedPx;

    TReal32 nearOriginTransform = attachOriginNearCalculatedPx - aNearPx;

    TReal32 farOriginTransform = attachOriginFarCalculatedPx - aFarPx;

    // Transform to origin

    switch(aEdge.iAttachmentProximity)

        {

        case EHuiAnchorProximitySize:

            // @todo not yet implemented

            return(EFalse);

        case EHuiAnchorProximityNear:

            nearOriginTransform = 0;

            farOriginTransform -= origDimensionPx;

            break;

        case EHuiAnchorProximityCenter:

            nearOriginTransform += origDimensionPx / 2;

            farOriginTransform -= origDimensionPx / 2;

            break;

        case EHuiAnchorProximityFar:

            nearOriginTransform += origDimensionPx;

            farOriginTransform = 0;

            break;

        default:

            break;

        }

    // Apply edge offset.

    switch(aEdge.iEdgeProximity)

        {

        case EHuiAnchorProximitySize:

            // @todo not yet implemented

            return(EFalse);

        case EHuiAnchorProximityNear:

            aNearCalculatedPx = attachOriginNearCalculatedPx + aOffsetPx + nearOriginTransform;

            result |= THuiLayoutChildRectPosUpdateNeeded;

            break;

        case EHuiAnchorProximityCenter:

            // @todo not yet implemented

            return(EFalse);

        case EHuiAnchorProximityFar: