/*

* 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 of CHuiLayout class. Layouts are visuals that 

*                manage the placement of a set of child visuals.

*

*/

#include <AknUtils.h>

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

#include "uiacceltk/HuiControl.h"

#include "uiacceltk/HuiDrawing.h"

#include "uiacceltk/HuiDisplay.h"

#include "uiacceltk/HuiPanic.h"

#include "uiacceltk/HuiUtil.h"

#include "HuiRosterImpl.h"

#include "huilayoutdata.h"

#include "HuiFxEffect.h"

#include "HuiRenderPlugin.h"

#include "huicanvasgc.h"

#include "Matrix.h"

// 

// methods

//

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

                                         CHuiLayout* aParentLayout)

    {

    CHuiLayout* layout = aOwnerControl.AppendLayoutL(EHuiLayoutTypeLayout,

                                                     aParentLayout);

    return layout;

    }

EXPORT_C CHuiLayout::CHuiLayout(MHuiVisualOwner& aOwner)

        : CHuiVisual(aOwner)

    {

    }

EXPORT_C void CHuiLayout::ConstructL()

    {

    CHuiVisual::ConstructL();

    iHuiLayoutPrivateData = new (ELeave) THuiLayoutPrivateData;

    iHuiLayoutPrivateData->iGc = NULL;

    }

EXPORT_C CHuiLayout::~CHuiLayout()

    {

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

    	{

	    delete iHuiLayoutPrivateData->iScroll;

	    // Remove children in reverse order.

	    for(TInt i = Count() - 1; i >= 0; --i)

	        {

	        Remove(iHuiLayoutPrivateData->iChildren[i]);

	        }

	    iHuiLayoutPrivateData->iChildren.Reset();

	    delete iHuiLayoutPrivateData->iGc;

	    iHuiLayoutPrivateData->iGc = NULL;

	    delete iHuiLayoutPrivateData;

    	}

    }

EXPORT_C void CHuiLayout::RemoveAndDestroyAllD()

    {

    // Make sure we do not re-layout during destruction

    SetFlag( EHuiVisualFlagFreezeLayout );

    for(TInt i = Count() - 1; i >= 0; --i)

        {

        iHuiLayoutPrivateData->iChildren[i]->RemoveAndDestroyAllD();

        }

    iHuiLayoutPrivateData->iChildren.Reset();

    CHuiVisual::RemoveAndDestroyAllD();

    }

EXPORT_C void CHuiLayout::AppendL(CHuiVisual* aVisual, TInt aLayoutTransitionTime)

    {

    ASSERT(aVisual != NULL);

    __ASSERT_ALWAYS( iHuiLayoutPrivateData->iChildren.Find(aVisual) == KErrNotFound,

                     THuiPanic::Panic(THuiPanic::ELayoutDuplicateVisual) );

    User::LeaveIfError( iHuiLayoutPrivateData->iChildren.Append(aVisual) );

    CHuiLayout* oldLayout = aVisual->Layout();

    if (oldLayout != NULL)

    	{

    	// If this visual is already a member of another layout, remove it from the old one first.

    	oldLayout->Remove(aVisual);

	    }

	else

	    {

	    // if the visual is a showing as root visual before, remove it from the roster

	    if ( aVisual->Display() )

	        {

	        aVisual->Display()->Roster().HideVisual( aVisual );

	        }

	    }

    aVisual->SetLayout(this);

    // Update the visual's layout immediately.

    if(!(Flags() & EHuiVisualFlagFreezeLayout))

        {

        UpdateChildrenLayout(aLayoutTransitionTime);

        }

    SetChanged();

    }

EXPORT_C void CHuiLayout::InsertL(CHuiVisual* aVisual, TInt aPosition, TInt aLayoutTransitionTime)

    {

    ASSERT(aVisual != NULL);

    __ASSERT_ALWAYS( iHuiLayoutPrivateData->iChildren.Find(aVisual) == KErrNotFound,

                     THuiPanic::Panic(THuiPanic::ELayoutDuplicateVisual) );

    ASSERT((aPosition >= 0) && aPosition <= Count());

    iHuiLayoutPrivateData->iChildren.InsertL(aVisual, aPosition);

    CHuiLayout* oldLayout = aVisual->Layout();

    if (oldLayout != NULL)

    	{

    	// If this visual is already a member of another layout, remove it from the old one first.

    	oldLayout->Remove(aVisual);

	    }

	else

	    {

	    // if the visual is a showing as root visual before, remove it from the roster

	    if ( aVisual->Display() )

	        {

	        aVisual->Display()->Roster().HideVisual( aVisual );

	        }

	    }

    // Update the visual's layout immediately.

    aVisual->SetLayout(this);

    if(!(Flags() & EHuiVisualFlagFreezeLayout))

        {

        UpdateChildrenLayout(aLayoutTransitionTime);

        }

    SetChanged();

    }

EXPORT_C void CHuiLayout::Remove(CHuiVisual* aVisual, TInt aLayoutTransitionTime)

    {

    TInt index = iHuiLayoutPrivateData->iChildren.Find(aVisual);

    /*__ASSERT_DEBUG(index != KErrNotFound,

                   THuiPanic::Panic(THuiPanic::EInternal));*/

    if(index != KErrNotFound)

        {

        iHuiLayoutPrivateData->iChildren.Remove(index);

        aVisual->SetLayout(NULL); // defect. this should check if there is a Host()->ContainerLayout()

        // If the control group of the aVisual is showing in a roster,

        // we need to add it as the root visual of that roster

        /*

        for ( TInt d = 0; d < Env().DisplayCount() ; d ++ )

            {

            if ( (Env().Displays())[d]->Roster().Find( aVisual->Owner().ControlGroup() ) != KErrNotFound )

                {

                TRAP_IGNORE( (Env().Displays())[d]->Roster().ShowVisualL( aVisual ) );

                break;

                }

            }*/

        // Update the layout of all the children immediately.

        if(!(Flags() & EHuiVisualFlagFreezeLayout))

            {

            UpdateChildrenLayout(aLayoutTransitionTime);

            }

        SetChanged();

        }

    }

EXPORT_C TInt CHuiLayout::Count() const

    {

    return iHuiLayoutPrivateData->iChildren.Count();

    }

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

    {

    return *(iHuiLayoutPrivateData->iChildren[aIndex]);

    }

EXPORT_C TInt CHuiLayout::FindVisual(const CHuiVisual* aVisual) const

    {

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

        {

        if(&Visual(i) == aVisual)

            {

            return i;

            }

        }

    return KErrNotFound;

    }

THuiRealRect CHuiLayout::BoundingRect() const

    {

    THuiRealPoint min;

    THuiRealPoint max;

    min.iX = 0;

    min.iY = 0;

    max.iX = 0;

    max.iY = 0;

    TInt count = Count();

    if(count > 0) 

    	{

    	min = Visual(0).Pos().Target();

    	max = min + Visual(0).Size().Target();    	

    	}

    for(TInt i = 1; i < count; ++i)

        {

        THuiRealPoint tl = Visual(i).Pos().Target();

        THuiRealPoint br = tl + Visual(i).Size().Target();

        min.iX = Min(min.iX, tl.iX);

        min.iY = Min(min.iY, tl.iY);

        max.iX = Max(max.iX, br.iX);

        max.iY = Max(max.iY, br.iY);

        }

    return THuiRealRect(min, max);

    }

EXPORT_C THuiRealSize CHuiLayout::InnerSize() const __SOFTFP

    {

    // Determine the size of this layout in pixels.

    THuiRealSize innerSizeChild = Size().RealTarget().AsSize(); // not correct units, but will work as fallback value if base unit is in pixels

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

    // Subtract outer paddings.

    THuiRealRect paddingInPixels = PaddingInPixels(EHuiReferenceStateTarget);

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

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

    // Convert the result into base units of *this* layout.

    CHuiVisual* child = 0;

    if (iHuiLayoutPrivateData->iChildren.Count())

        {

        child = iHuiLayoutPrivateData->iChildren[0]; // get the first child, if there isn't one, then nothing to do anyway

        }

    if(child)

        {

        innerSizeChild = child->PixelPointInUnits(innerSizePx, BaseUnit().Abs(), EHuiReferenceStateTarget).AsSize();

        }

    return innerSizeChild;    

    }

EXPORT_C THuiRealPoint CHuiLayout::InnerTopLeft() const __SOFTFP

    {

    THuiRealPoint topLeftChild(0, 0);

    CHuiVisual* child = 0;

    if (iHuiLayoutPrivateData->iChildren.Count())

        {

        child = iHuiLayoutPrivateData->iChildren[0]; // get the first child, if there isn't one, then nothing to do anyway

        }

    if(child)

        {

        topLeftChild = child->PixelPointInUnits(PaddingInPixels().iTl, BaseUnit().Abs(), EHuiReferenceStateTarget);

        }

    return topLeftChild;

    }

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

    {

    CHuiVisual::SetSize(aSize, aTransitionTime);

    // The default layout does not need to update its children.

    }

EXPORT_C void CHuiLayout::UpdateChildrenLayout(TInt aTransitionTime)

    {

    // Update the layout of all children.

    TInt count = Count();

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

        {

        // size and positio changes must go also to inactive visuals

        UpdateChildLayout(i, aTransitionTime); 

        }

    CHuiVisual::UpdateChildrenLayout(aTransitionTime);

    // Report that the layout of this layout visual has been fully updated.

    ReportLayoutUpdate();

    }

EXPORT_C void CHuiLayout::UpdateChildLayout(TInt aIndex, TInt aTransitionTime)

    {

    THuiRealRect rect;

    TSize size;

    TPoint pos;

    TInt ordinal = ChildOrdinal(aIndex);

    CHuiVisual* child = iHuiLayoutPrivateData->iChildren[aIndex];

    TInt flags = child->Flags();

    TInt transitionTime = aTransitionTime;

    if(flags & EHuiVisualFlagManualTransitionTime)

        {

        // override the parent's transition time with our local one.

        transitionTime = TransitionTime();

        }

    // if either flag is missing, call child rect...

    TBool bothManual = (flags & EHuiVisualFlagManualPosition) && (flags & EHuiVisualFlagManualSize);

    if(!bothManual)

        {

        TInt childRectStatus = ChildRect(ordinal, rect);

        if(childRectStatus != THuiLayoutChildRectNotImplemented)

            {

            if(!(flags & EHuiVisualFlagManualPosition) && (childRectStatus & THuiLayoutChildRectPosUpdateNeeded))

                {

                child->SetPos(rect.iTl, transitionTime);

                }

            if(!(flags & EHuiVisualFlagManualSize) && (childRectStatus & THuiLayoutChildRectSizeUpdateNeeded))

                {

                child->SetSize(rect.Size(), transitionTime);

                }

            }

        else

            {

            if(!(flags & EHuiVisualFlagManualPosition) && ChildPos(ordinal, pos))

                {

                child->SetPos(pos, transitionTime);

                }

            if(!(flags & EHuiVisualFlagManualSize) && ChildSize(ordinal, size))

                {

                child->SetSize(size, transitionTime);

                }

            }

        }

    child->ReportLayoutUpdate();

    }

EXPORT_C TInt CHuiLayout::ChildOrdinal(TInt aIndex)

    {

    return aIndex;

    }

EXPORT_C TBool CHuiLayout::ChildSize(TInt /*aOrdinal*/, TSize& /*aSize*/)

    {

    // The default layout doesn't constrain the sizes of the children.

    return EFalse;

    }

EXPORT_C TBool CHuiLayout::ChildPos(TInt /*aOrdinal*/, TPoint& /*aPos*/)

    {

    // The default layout lets the children position themselves.

    return EFalse;

    }

EXPORT_C TInt CHuiLayout::ChildRect(TInt /*aOrdinal*/, THuiRealRect& /*aPos*/)

    {

    // The default layout lets the children position themselves.

    return THuiLayoutChildRectNotImplemented;

    }

EXPORT_C void CHuiLayout::SetInnerPadding(const TPoint& aInnerPadding)

    {

    iHuiLayoutPrivateData->iInnerPadding.iX = THuiMetric(aInnerPadding.iX, EHuiUnitPixel);

    iHuiLayoutPrivateData->iInnerPadding.iY = THuiMetric(aInnerPadding.iY, EHuiUnitPixel);

    SetChanged();

    }

EXPORT_C void CHuiLayout::SetInnerPadding(const THuiXYMetric& aInnerPadding)

    {

    iHuiLayoutPrivateData->iInnerPadding = aInnerPadding;

    SetChanged();

    }

EXPORT_C const THuiXYMetric& CHuiLayout::InnerPadding() const

    {

    return iHuiLayoutPrivateData->iInnerPadding;

    }

EXPORT_C THuiRealPoint CHuiLayout::InnerPaddingInBaseUnits() const __SOFTFP

    {

    THuiRealPoint innerPaddingPx = MetricToPixels(iHuiLayoutPrivateData->iInnerPadding, EHuiReferenceStateTarget);

    return PixelPointInUnits(innerPaddingPx, BaseUnit().Abs(), EHuiReferenceStateTarget);    

    }

EXPORT_C TInt CHuiLayout::HorizontalInnerPadding() const

    {

    return 0; //iHuiLayoutPrivateData->iXPadding;

    }

EXPORT_C TInt CHuiLayout::VerticalInnerPadding() const

    {

    return 0; //iHuiLayoutPrivateData->iYPadding;

    }

EXPORT_C TBool CHuiLayout::PrepareDrawL() 

    {

    if (Flags() & EHuiVisualFlagDrawOnlyAsExternalContent)

    	{

   	    // This is used only as external content visual. Return now if we are not currently drawing

   	    // external content.

    	if (!Display() || !Display()->RosterImpl().IsDrawingExternalContent())

    		{

			return ETrue;

    		}

    	}

    // The layout itself is invisible. Only its children can be seen.

    TInt count = Count();

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

        {

        CHuiVisual* visual = iHuiLayoutPrivateData->iChildren[i];

        //Ignore inactive child visuals

        if ( visual->Flags()& EHuiVisualFlagInactive )

        	{

        	continue; 

        	}

        TBool successfullyPrepared = ETrue;

        TRAPD(err, successfullyPrepared = visual->PrepareDrawL());

        if (err != KErrNone)

            {

            // Handle the error by calling the visual owner

            // errorhandling callback

            visual->Owner().VisualPrepareDrawFailed(*visual, err);

            return EFalse;

            }

        if (!successfullyPrepared) 

	        {

	        // we can stop preparing the rest of the children

	        // if one prepare failed (we won't be drawing anything 

	        // anyway)

	        // also if the prepare failed but there was not a leave,

	        // we assume it was already handled 

	        return EFalse;

	        }

        }

    return ETrue;

    }

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

    {

    if (Flags() & EHuiVisualFlagDrawOnlyAsExternalContent)

    	{

   	    // This is used only as external content visual. Return now if we are not currently drawing

   	    // external content.

    	if (!Display() || !Display()->RosterImpl().IsDrawingExternalContent())

    		{

			return;

    		}

    	}

        {

        // This will not be visible due to being completely transparent.

        return;

        }

    if (( IsDelayedEffectSource()||Freezed() ) && StoredRenderBuffer())

        {

        DrawStoredBitmap(aGc);        

        return;

        }

    if (!HasActiveChilderen() && !Brushes() && !Effect())

        {

        // No children, no brushes just return.

        return;            

        }

    /** @todo  Wouldn't it be possible to just extend CHuiVisual::Draw()

               instead of redefining the entire method? */

    THuiRealRect area = DisplayRect();

    // Apply local transformation.

    EnterLocalProjection(aGc, ETrue, 0.f, &area);

    Transform(aGc, ETrue, &area);

    DrawBrushes(aGc, EHuiBrushLayerBackground);

    if(Clipping())

        {