/*

* Copyright (c) 2002-2008 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:  Layout calculation and UI rendering mechanism implementations.

*

*/

// System includes

#include <utf.h>

#include <eikapp.h>

#include <AknUtils.h>

#include <layoutmetadata.cdl.h>

// User includes

#include "xnuiengine.h"

#include "xnuiengineimpl.h"

#include "xnuistatelistener.h"

#include "xnpointerarray.h"

#include "xnodt.h"

#include "xndomlist.h"

#include "xndompropertyvalue.h"

#include "xnmenuadapter.h"

#include "xnpopupcontroladapter.h"

#include "xnviewdata.h"

#include "xnnodebreadthfirstiterator.h"

#include "xntype.h"

#include "xnnodepluginif.h"

#include "xncomponentnodeimpl.h"

#include "xnproperty.h"

#include "xnappuiadapter.h"

#include "xnviewadapter.h"

#include "xnwidgetextensionadapter.h"

#include "xnscrollablecontroladapter.h"

#include "xnkeyeventdispatcher.h"

#include <aknlayoutscalable_avkon.cdl.h>

#include "xuikon_builds_cfg.hrh"

#include "xndomdocument.h"

#include "xndomnode.h"

#include "xneditmode.h"

#include "xnhittest.h"

#include "xnnode.h"

#include "xnpanic.h"

#include "xneffectmanager.h"

#ifdef _XN_PERFORMANCE_TEST_

#include "xntimemon.h"

#endif

// CONSTANTS

const TInt KXnBorderThin = 1;

const TInt KXnBorderMedium = 3;

const TInt KXnBorderThick = 5;

const TInt KXnStackPriorityKeyEventDispatcher = 55;

const TInt KFocusGrowValue = 3;

_LIT8( KBoxNodeName, "box" );

_LIT8( KButtonNodeName, "button" );

_LIT8( KWidgetNodeName, "widget" );

_LIT8( KWidgetExtensionNodeName, "widgetextension" );

_LIT8( KScrollableBoxNodeName, "scrollablebox" );

_LIT8( KMenuBar, "menubar" );

_LIT8( KPopUpNodeName, "popup" );

_LIT8( KPlugin, "plugin" );

// LOCAL CONSTANTS AND MACROS

static const TReal KIntConversionConstant = 0.5;

static const TReal KIntPercentageConstant =

    static_cast< TReal >( 1 ) / static_cast< TReal >( 100 );

static const TReal KInchesAsTwips = 1440;

static const TReal KCentimetersAsInches = static_cast< TReal >( 1 ) / 2.54;

static const TReal KCentimetersAsTwips = KCentimetersAsInches * KInchesAsTwips;

static const TReal KMillimetersAsInches =

    KCentimetersAsInches / static_cast< TReal >( 10 );

static const TReal KMillimetersAsTwips = KMillimetersAsInches * KInchesAsTwips;

static const TReal KPointsAsInches =

    static_cast< TReal >( 1 ) / static_cast< TReal >( 72 );

static const TReal KPointsAsTwips = KPointsAsInches * KInchesAsTwips;

static const TReal KPicasAsInches =

    KPointsAsInches / static_cast< TReal >( 12 );

static const TReal KPicasAsTwips = KPicasAsInches * KInchesAsTwips;

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

static TRect AddRect( const TRect& aOriginal, const TRect& aAdded );

static TRect SubtractRect( const TRect& aOriginal, const TRect& aSubtracter );

static TSize AutoStaticBTL( CXnNode& aNode, TInt aWidthToFit,

    TInt aHeightToFit, RArray< TPtrC8 >& aAutoProperties,

    TRect& aParentRect, CGraphicsDevice& aGraphicsDevice,

    TReal aHorizontalUnitInPixels, TReal aVerticalUnitInPixels );

static TSize AutoStaticLRL( CXnNode& aNode, TInt aWidthToFit,

    TInt aHeightToFit, RArray< TPtrC8 >& aAutoProperties,

    TRect& aParentRect, CGraphicsDevice& aGraphicsDevice,

    TReal aHorizontalUnitInPixels, TReal aVerticalUnitInPixels );

static TSize AutoStaticRLL( CXnNode& aNode, TInt aWidthToFit,

    TInt aHeightToFit, RArray< TPtrC8 >& aAutoProperties,

    TRect& aParentRect, CGraphicsDevice& aGraphicsDevice,

    TReal aHorizontalUnitInPixels, TReal aVerticalUnitInPixels );

static TSize AutoStaticTBL( CXnNode& aNode, TInt aWidthToFit,

    TInt aHeightToFit, RArray< TPtrC8 >& aAutoProperties,

    TRect& aParentRect, CGraphicsDevice& aGraphicsDevice,

    TReal aHorizontalUnitInPixels, TReal aVerticalUnitInPixels );

static void CalculateAbsolutePositionsL( CXnNode& aNode,

    TRect& aParentRect, CGraphicsDevice& aGraphicsDevice,

    TReal aHorizontalUnitInPixels, TReal aVerticalUnitInPixels );

static void CalculateBorderL( CXnNode& aNode,

    TRect& aParentRect, CGraphicsDevice& aGraphicsDevice,

    TReal aHorizontalUnitInPixels, TReal aVerticalUnitInPixels );

static void CalculateMarginL( CXnNode& aParent, CXnNode& aNode,

    CXnNode* aPreviousSibling, const TDesC8& aParentBlockProgression,

    const TDesC8& aParentDirection, TRect& aParentRect,

    CGraphicsDevice& aGraphicsDevice, TReal aHorizontalUnitInPixels,

    TReal aVerticalUnitInPixels, TInt& aColumnWidth, TInt& aColumnMargin );

static void CalculatePaddingL( const TRect& aParentRect, CXnNode& aNode,

    CGraphicsDevice& aGraphicsDevice, TReal aHorizontalUnitInPixels,

    TReal aVerticalUnitInPixels );

static void CalculateRectL( CXnNode& aNode, CXnNode& aParent,

    CGraphicsDevice& aGraphicsDevice, TReal aHorizontalUnitInPixels,

    TReal aVerticalUnitInPixels );

static void CalculateRelativePositionsL( const TRect& aRect, CXnNode& aNode,

    CGraphicsDevice& aGraphicsDevice, TReal aHorizontalUnitInPixels,

    TReal aVerticalUnitInPixels );

static TSize CalculateSpaceUsedByChildrenL( RPointerArray< CXnNode >& aChildren,

    CXnNode& aNode, const TDesC8& aParentBlockProgression,

    const TDesC8& aParentDirection, CGraphicsDevice& aScreenDevice,

    TReal aHorizontalUnitInPixels, TReal aVerticalUnitInPixels );

static TSize CalculateTotalDimensionsL( CXnNode& aNode, TBool aIgnoreAutoValues,

    TBool aIgnoreMinSizes, TRect& aParentRect,

    CGraphicsDevice& aGraphicsDevice, TReal aHorizontalUnitInPixels,

    TReal aVerticalUnitInPixels );

static TBool CutOnePixelFromPercentChildNodeL( CXnNode& aNode,

    const TDesC8& aParentBlockProgression );

static void DetermineBorderWidthsL( CXnProperty* aBorderWidthProperty,

    TInt& aBordervertical, TInt& aBorderhorizontal,

    TRect& aParentRect, CGraphicsDevice& aGraphicsDevice,

    TReal aHorizontalUnitInPixels, TReal aVerticalUnitInPixels );

static TInt DisplayedChildrenCountL( CXnNode& aNode,

    RPointerArray< CXnNode >* aDisplayedChildren = NULL );

static CXnNode* DisplayedParentL( CXnNode& aNode );

static CXnDomPropertyValue* DomPropertyValueFromProperty(

    CXnProperty* aProperty );

static void DropExceedingRectL( const TRect& aParentRect, CXnNode& aNode,

    TBool aDropRelativeNode = EFalse );

static TBool CalculateExceedingArea( CXnNode& aParent, CXnNode& aChild,

    TInt& aLeftOffset, TInt& aRightOffset, TInt& aTopOffset,

    TInt& aBottomOffset );

static void AdjustRectsL( CXnNode& aNode, TInt aLeftOffset, TInt aRightOffset,

    TInt aTopOffset, TInt aBottomOffset );

static void ClearRects( CXnNode& aNode, TBool aRecurse = EFalse );

static void FitChildrenIntoParentL( CXnNode& aNode,

    CGraphicsDevice& aGraphicsDevice, TReal aHorizontalUnitInPixels,

    TReal aVerticalUnitInPixels );

static TInt GetPositionL( CXnNode& aNode, 

    const TDesC8& aParentBlockProgression, const TDesC8& aParentDirection );

static TInt HasNodeAutoValuesL( CXnNode& aNode );

static TInt HasNodeHorizontalAutoValuesL( CXnNode& aNode );

static TInt HasNodeVerticalAutoValuesL( CXnNode& aNode );

static TBool HasNodeMinSizesL( CXnNode& aNode );

static TBool HasNodeMaxSizesL( CXnNode& aNode );

static TInt HorizontalPixelValueL( CXnProperty* aValue, TInt aReferenceValue,

    CGraphicsDevice& aScreenDevice, TReal aHorizontalUnitInPixels );

static TInt HorizontalValueToPixelsL( CXnDomPropertyValue* aValue,

    TReal aReferenceValue, CGraphicsDevice& aScreenDevice,

    TReal aHorizontalUnitInPixels );

static void GrowToMinSizeL( CXnNode& aNode, TRect& aParentRect,

    CGraphicsDevice& aScreenDevice, TReal aHorizontalUnitInPixels,

    TReal aVerticalUnitInPixels );

static void ShrinkToMaxSizeL( CXnNode& aNode, TRect& aParentRect,

    CGraphicsDevice& aScreenDevice, TReal aHorizontalUnitInPixels,

    TReal aVerticalUnitInPixels );

static TBool IsAbsoluteL( CXnNode& aNode );

static TBool IsLargerThanMaxSizeL( const TRect& aParentRect, CXnNode& aNode,

    CGraphicsDevice& aScreenDevice, TReal aHorizontalUnitInPixels,

    TReal aVerticalUnitInPixels );

static TBool IsNodeDisplayedL( CXnNode& aNode );

static TBool IsNodeTooltip( CXnNode& aNode );

static TBool IsPropertyAutoL( CXnProperty& aProperty );

static TBool IsPropertyNone( CXnProperty& aProperty );

static TBool IsRelativeL( CXnNode& aNode );

static TBool IsSmallerThanMinSizeL( const TRect& aParentRect, CXnNode& aNode,

    CGraphicsDevice& aScreenDevice, TReal aHorizontalUnitInPixels,

    TReal aVerticalUnitInPixels );

static TBool IsValuePercentageL( CXnProperty& aProperty );

static TInt PercentageToPixelsL( TReal& aPercentage, TReal aReferenceValue );

static void PlaceAreasL( CXnNode& aNode,

    RPointerArray< CXnNode >& aLaidOutList,

    TInt aLayoutPhase, CGraphicsDevice& aGraphicsDevice,

    TReal aHorizontalUnitInPixels, TReal aVerticalUnitInPixels );

static void PriorizeChildrenL( CXnNode& aNode );

static void CalculateAutoPropertiesOfNodesL(

    RPointerArray< CXnNode >* aAutoNodeArray, TInt& aWidthAutoCount,

    TInt& aHeightAutoCount );

static void ProcessAutoAreasL( CXnNode& aParentNode,

    RPointerArray< CXnNode >* aArray, const TDesC8& aParentBlockProgression,

    const TDesC8& aParentDirection, CGraphicsDevice& aGraphicsDevice,

    TReal aHorizontalUnitInPixels, TReal aVerticalUnitInPixels );

static void CalculateCollapseMarginsL( RPointerArray< CXnNode >& aChildren,

    RArray< TInt >& aCollapsedMarginsWidth, 

    RArray< TInt >& aCollapsedMarginsHeight,

    const TDesC8& aParentBlockProgression,

    const TDesC8& aParentDirection );

static TSize CalculateSpaceUsedByAutoChildrenL(

    RPointerArray< CXnNode >& aAutoChildren,

    RPointerArray< CXnNode >& aCalculatedAutoChildren,

    CXnNode& aParent,

    const TDesC8& aParentBlockProgression,

    const TDesC8& aParentDirection,

    CGraphicsDevice& aScreenDevice );

static void MoveAutoAreaL( TRect& parentRect,

    RPointerArray< CXnNode >& aChildren,

    const TDesC8& aParentBlockProgression,

    const TDesC8& aParentDirection );

static TSize ScaleAutoAreaL( CXnNode& aNode, TInt aWidthToFit,

    TInt aHeightToFit, const TDesC8& aParentBlockProgression,

    const TDesC8& aParentDirection, TRect& aParentRect,

    CGraphicsDevice& aGraphicsDevice, TReal aHorizontalUnitInPixels,

    TReal aVerticalUnitInPixels );

static void FitAutoChildrenIntoParentL( RPointerArray< CXnNode >& aAutoChildren,

    RPointerArray< CXnNode >& aCalculatedAutoChildren, CXnNode& aParent,

    const TDesC8& aParentBlockProgression, const TDesC8& aParentDirection,

    CGraphicsDevice& aGraphicsDevice );

static TInt VerticalPixelValueL( CXnProperty* aValue, TInt aReferenceValue,

    CGraphicsDevice& aScreenDevice, TReal aVerticalUnitInPixels );

static TInt VerticalValueToPixelsL( CXnDomPropertyValue* aValue,

    TReal aReferenceValue, CGraphicsDevice& aScreenDevice,

    TReal aVerticalUnitInPixels );

static TBool IsStringValueL( CXnProperty& aProperty );

static TInt HorizontalUnitsToPixelsL( TReal aUnits,

    TReal aHorizontalUnitInPixels );

static TInt VerticalUnitsToPixelsL( TReal aUnits, TReal aVerticalUnitInPixels );

static void ProcessAdaptiveAreasL( CXnNode& aParent,

    CGraphicsDevice& aGraphicsDevice, TReal aHorizontalUnitInPixels,

    TReal aVerticalUnitInPixels );

static void CalculateAdaptiveSizeL( CXnNode& aNode,

    const TDesC8& aParentBlockProgression, const TDesC8& aParentDirection,

    CGraphicsDevice& aGraphicsDevice, TReal aHorizontalUnitInPixels,

    TReal aVerticalUnitInPixels );

static CXnNode* BuildTriggerNodeLC( CXnUiEngine& aUiEngine,

    const TDesC8& aTriggerName );

static void UpdateInternalUnits( TReal&  aHorizontalUnitInPixels,

    TReal& aVerticalUnitInPixels, TRect aRect );

static CXnNode* BuildScreenDeviceChangeTriggerNodeLC(

    CXnUiEngine& aUiEngine );

static void FillFocusCandidatesL( CXnNode* aParent,

    RPointerArray< CXnNode >& aArray );

static TInt DetermineStatusPaneLayout( CXnProperty* aProperty );

static TBool SetAdaptivesL( CXnNode& aNode );

static void FindNodeByClassL( CXnNode* aRootNode, const TDesC8& aClassId,

    CXnPointerArray& aArray, const TDesC8& aNamespace );

static CXnNode* FindNodeByIdL( CXnNode* aRootNode, const TDesC8& aAreaId,

    const TDesC8& aNamespace );

#ifdef _XN3_DEBUG_

static void TraceTreeL( CXnNode* aRootNode );

#endif

// ============================= LOCAL FUNCTIONS ===============================

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

// GrowIfNeeded()

// When a plugin is focused, the focus is a bit bigger than its control 

// (this is a hack fix to get focus visible with WRT widgets).

// Therefore we need to check if focused node is a plugin, 

// or focused node has same size with its plugin, and grow dirty rect accordingly.

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

//

static void GrowIfNeeded(CXnNode* aNode, TRect& aRect)

    {

    CXnNode* focusedNode(NULL);

    for( CXnNode* node = aNode; node; node = node->Parent() )

        {

        if( node->IsStateSet( XnPropertyNames::style::common::KFocus ) )

            {

            if( node->DomNode()->Name() == KPlugin )

                {

                CXnControlAdapter* adapter( node->Control() );

                if(adapter)

                    {

                    aRect = adapter->Rect();

                    aRect.Grow( KFocusGrowValue, KFocusGrowValue );

                    }

                break;

                }

            focusedNode = node;

            }

        else if( node->DomNode()->Name() == KPlugin )

            {

            if( focusedNode && focusedNode->MarginRect() == node->Rect() )

                {

                CXnControlAdapter* adapter( focusedNode->Control() );

                if(adapter)

                    {

                    aRect = adapter->Rect();

                    aRect.Grow( KFocusGrowValue, KFocusGrowValue );

                    }

                }

            break;

            }

        }                            

    }      

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

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

static TBool IsSrollableBox( CXnNode& aNode )

    {

    if( aNode.Type()->Type() == KScrollableBoxNodeName )

        {

        return ETrue;

        }

    return EFalse;

    }

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

// FindNodeByClassL()

// Finds recursively a node from current view by class

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

//

static void FindNodeByClassL( CXnNode* aRootNode, const TDesC8& aClassId,

    CXnPointerArray& aArray, const TDesC8& aNamespace )

    {

    ASSERT( aRootNode );

    if ( aNamespace != KNullDesC8 && aNamespace != aRootNode->Namespace() )

        {

        // Recursed to wrong namespace

        return;

        }

    CXnProperty* prop( aRootNode->ClassL() );

    if ( prop && prop->StringValue() == aClassId )

        {

        // Correct id found

        if ( aNamespace == KNullDesC8 )

            {

            aArray.Container().AppendL( aRootNode );

            }

        else if ( aNamespace == aRootNode->DomNode()->Namespace() )

            {

            // Namespace is defined and this node is in that namespace 

            // -> this is perfect match

            aArray.Container().AppendL( aRootNode );

            }        

        }

    // Recurse children

    RPointerArray< CXnNode >& children( aRootNode->Children() );

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

        {

        FindNodeByClassL( children[i], aClassId, aArray, aNamespace );

        }

    }

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

// FindNodeByIdL()

// Finds recursively a node from current view by id

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

//

static CXnNode* FindNodeByIdL( CXnNode* aRootNode, const TDesC8& aAreaId,        

    const TDesC8& aNamespace )

    {

    ASSERT( aRootNode );

    if ( aNamespace != KNullDesC8 && aNamespace != aRootNode->Namespace() )

        {

        // Recursed to wrong namespace

        return NULL;

        }

    CXnProperty* prop( aRootNode->IdL() );

    if ( prop && prop->StringValue() == aAreaId )

        {

        // Correct id found

        if ( aNamespace == KNullDesC8 )

            {

            // No namespace defined, so this is the first found best match

            return aRootNode;

            }

        else if ( aNamespace == aRootNode->DomNode()->Namespace() )

            {

            // Namespace is defined and this node is in that namespace 

            // -> this is perfect match

            return aRootNode;

            }        

        }

    // No match found, recurse children

    RPointerArray< CXnNode >& children( aRootNode->Children() );

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

        {

        CXnNode* retval( FindNodeByIdL( children[i], aAreaId, aNamespace ) );

        if ( retval )

            {

            return retval;

            }

        }

    return NULL;

    }

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

// AutoStaticVerticalBTL()

// Calculate properties set to AUTO when positioning is static, layout vertical

// and direction right-to-left

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

//

static TSize AutoStaticBTL( CXnNode& aNode, TInt aWidthToFit, TInt aHeightToFit,

    RArray< TPtrC8 >& aAutoProperties, TRect& aParentRect,

    CGraphicsDevice& aGraphicsDevice, TReal aHorizontalUnitInPixels,

    TReal aVerticalUnitInPixels )

    {

    // Static positioning, vertical, right to left

    TBool horizontalMarginProcessed = EFalse;

    TBool verticalMarginProcessed = EFalse;

    TBool allVerticalValuesProcessed = EFalse;

    TBool allHorizontalValuesProcessed = EFalse;

    CXnProperty* maxHeightProperty = aNode.MaxHeightL();

    CXnProperty* maxWidthProperty = aNode.MaxWidthL();

    CXnProperty* minHeightProperty = aNode.MinHeightL();

    CXnProperty* minWidthProperty = aNode.MinWidthL();

    TRect contentRect( aNode.Rect() );

    TRect paddingRect( aNode.PaddingRect() );

    TRect borderRect( aNode.BorderRect() );

    TRect marginRect( aNode.MarginRect() );

    TRect normalFlowBorderRect( aNode.NormalFlowBorderRect() );

    TSize size = CalculateTotalDimensionsL( aNode, EFalse, ETrue, aParentRect,

        aGraphicsDevice, aHorizontalUnitInPixels, aVerticalUnitInPixels );

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

        {

        // search for height property

        const TDesC8& attributeName = aAutoProperties[i];

        if ( attributeName == XnPropertyNames::style::common::KHeight )

            {

            // height was AUTO, all other vertical auto values are 0

            TInt newHeight = aHeightToFit - size.iHeight;

            //  Calculate the difference so that it can be returned

            TRect paddingRectDiff( SubtractRect( paddingRect, contentRect ) );

            TRect borderRectDiff( SubtractRect( borderRect, contentRect ) );

            TRect marginRectDiff( SubtractRect( marginRect, contentRect ) );

            TRect normalFlowBorderRectDiff( SubtractRect ( normalFlowBorderRect,

                contentRect ) );

            // grow height to fill the void

            contentRect.SetHeight( newHeight );

            paddingRect = AddRect( contentRect, paddingRectDiff );

            borderRect = AddRect( contentRect, borderRectDiff );

            normalFlowBorderRect = AddRect( contentRect,

                normalFlowBorderRectDiff );

            marginRect = AddRect( contentRect, marginRectDiff );

            size = TSize( size.iWidth, aHeightToFit );

            }

        }

    // if exactly one value is AUTO, value is computed to make equality true

    if ( aAutoProperties.Count() == 1 )

        {

        if ( !allHorizontalValuesProcessed )

            {

            const TDesC8& attributeName = aAutoProperties[0];

            if ( attributeName == XnPropertyNames::style::common::KWidth )

                {

                TInt remainingWidth = aWidthToFit - size.iWidth;

                if ( remainingWidth < 0 )

                    {

                    remainingWidth = 0;

                    }

                //  Calculate the difference so that it can be returned

                TRect paddingRectDiff( SubtractRect( paddingRect,

                    contentRect ) );

                TRect borderRectDiff( SubtractRect( borderRect,

                    contentRect ) );

                TRect marginRectDiff( SubtractRect( marginRect,

                    contentRect ) );

                TRect normalFlowBorderRectDiff( SubtractRect(

                    normalFlowBorderRect, contentRect ) );

                // grow width to fill the void

                contentRect.SetWidth( remainingWidth );

                paddingRect = AddRect( contentRect, paddingRectDiff );

                borderRect = AddRect( contentRect, borderRectDiff );

                normalFlowBorderRect = AddRect( contentRect,

                    normalFlowBorderRectDiff );

                marginRect = AddRect( contentRect, marginRectDiff );

                size = TSize( aWidthToFit, size.iHeight );

                }

            if ( attributeName ==

                 XnPropertyNames::style::common::KMarginLeft )

                {

                TInt remainingWidth = aWidthToFit - size.iWidth;

                if ( remainingWidth < 0 )

                    {

                    remainingWidth = 0;

                    }

                contentRect.Move( remainingWidth, 0 );

                borderRect.Move( remainingWidth, 0 );

                normalFlowBorderRect.Move( remainingWidth, 0 );

                marginRect.Resize( remainingWidth, 0 );