1 /*

     2 * Copyright (c) 2002-2008 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Layout calculation and UI rendering mechanism implementations.

    15 *

    16 */

    17 

    18 

    19 // System includes

    20 #include <utf.h>

    21 #include <eikapp.h>

    22 #include <AknUtils.h>

    23 #include <layoutmetadata.cdl.h>

    24 

    25 // User includes

    26 #include "xnuiengine.h"

    27 #include "xnuiengineimpl.h"

    28 #include "xnuistatelistener.h"

    29 #include "xnpointerarray.h"

    30 #include "xnodt.h"

    31 #include "xndomlist.h"

    32 #include "xndompropertyvalue.h"

    33 #include "xnmenuadapter.h"

    34 #include "xnpopupcontroladapter.h"

    35 #include "xnviewdata.h"

    36 #include "xnnodebreadthfirstiterator.h"

    37 #include "xntype.h"

    38 #include "xnnodepluginif.h"

    39 #include "xncomponentnodeimpl.h"

    40 #include "xnproperty.h"

    41 #include "xnappuiadapter.h"

    42 #include "xnviewadapter.h"

    43 #include "xnwidgetextensionadapter.h"

    44 #include "xnscrollablecontroladapter.h"

    45 #include "xnkeyeventdispatcher.h"

    46 #include <aknlayoutscalable_avkon.cdl.h>

    47 #include "xuikon_builds_cfg.hrh"

    48 #include "xndomdocument.h"

    49 #include "xndomnode.h"

    50 #include "xneditmode.h"

    51 #include "xnhittest.h"

    52 #include "xnnode.h"

    53 #include "xnpanic.h"

    54 #include "xneffectmanager.h"

    55 

    56 #ifdef _XN_PERFORMANCE_TEST_

    57 #include "xntimemon.h"

    58 #endif

    59 

    60 // CONSTANTS

    61 const TInt KXnBorderThin = 1;

    62 const TInt KXnBorderMedium = 3;

    63 const TInt KXnBorderThick = 5;

    64 const TInt KXnStackPriorityKeyEventDispatcher = 55;

    65 const TInt KFocusGrowValue = 3;

    66 

    67 _LIT8( KBoxNodeName, "box" );

    68 _LIT8( KButtonNodeName, "button" );

    69 _LIT8( KWidgetNodeName, "widget" );

    70 _LIT8( KWidgetExtensionNodeName, "widgetextension" );

    71 _LIT8( KScrollableBoxNodeName, "scrollablebox" );

    72 _LIT8( KMenuBar, "menubar" );

    73 _LIT8( KPopUpNodeName, "popup" );

    74 

    75 _LIT8( KPlugin, "plugin" );

    76 

    77 // LOCAL CONSTANTS AND MACROS

    78 static const TReal KIntConversionConstant = 0.5;

    79 static const TReal KIntPercentageConstant =

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

    81 static const TReal KInchesAsTwips = 1440;

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

    83 static const TReal KCentimetersAsTwips = KCentimetersAsInches * KInchesAsTwips;

    84 static const TReal KMillimetersAsInches =

    85     KCentimetersAsInches / static_cast< TReal >( 10 );

    86 static const TReal KMillimetersAsTwips = KMillimetersAsInches * KInchesAsTwips;

    87 static const TReal KPointsAsInches =

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

    89 static const TReal KPointsAsTwips = KPointsAsInches * KInchesAsTwips;

    90 static const TReal KPicasAsInches =

    91     KPointsAsInches / static_cast< TReal >( 12 );

    92 static const TReal KPicasAsTwips = KPicasAsInches * KInchesAsTwips;

    93 

    94 // MODULE DATA STRUCTURES

    95 

    96 // LOCAL FUNCTION PROTOTYPES

    97 

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

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

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

   101     TInt aHeightToFit, RArray< TPtrC8 >& aAutoProperties,

   102     TRect& aParentRect, CGraphicsDevice& aGraphicsDevice,

   103     TReal aHorizontalUnitInPixels, TReal aVerticalUnitInPixels );

   104 static TSize AutoStaticLRL( CXnNode& aNode, TInt aWidthToFit,

   105     TInt aHeightToFit, RArray< TPtrC8 >& aAutoProperties,

   106     TRect& aParentRect, CGraphicsDevice& aGraphicsDevice,

   107     TReal aHorizontalUnitInPixels, TReal aVerticalUnitInPixels );

   108 static TSize AutoStaticRLL( CXnNode& aNode, TInt aWidthToFit,

   109     TInt aHeightToFit, RArray< TPtrC8 >& aAutoProperties,

   110     TRect& aParentRect, CGraphicsDevice& aGraphicsDevice,

   111     TReal aHorizontalUnitInPixels, TReal aVerticalUnitInPixels );

   112 static TSize AutoStaticTBL( CXnNode& aNode, TInt aWidthToFit,

   113     TInt aHeightToFit, RArray< TPtrC8 >& aAutoProperties,

   114     TRect& aParentRect, CGraphicsDevice& aGraphicsDevice,

   115     TReal aHorizontalUnitInPixels, TReal aVerticalUnitInPixels );

   116 static void CalculateAbsolutePositionsL( CXnNode& aNode,

   117     TRect& aParentRect, CGraphicsDevice& aGraphicsDevice,

   118     TReal aHorizontalUnitInPixels, TReal aVerticalUnitInPixels );

   119 static void CalculateBorderL( CXnNode& aNode,

   120     TRect& aParentRect, CGraphicsDevice& aGraphicsDevice,

   121     TReal aHorizontalUnitInPixels, TReal aVerticalUnitInPixels );

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

   123     CXnNode* aPreviousSibling, const TDesC8& aParentBlockProgression,

   124     const TDesC8& aParentDirection, TRect& aParentRect,

   125     CGraphicsDevice& aGraphicsDevice, TReal aHorizontalUnitInPixels,

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

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

   128     CGraphicsDevice& aGraphicsDevice, TReal aHorizontalUnitInPixels,

   129     TReal aVerticalUnitInPixels );

   130 

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

   132     CGraphicsDevice& aGraphicsDevice, TReal aHorizontalUnitInPixels,

   133     TReal aVerticalUnitInPixels );

   134 

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

   136     CGraphicsDevice& aGraphicsDevice, TReal aHorizontalUnitInPixels,

   137     TReal aVerticalUnitInPixels );

   138 static TSize CalculateSpaceUsedByChildrenL( RPointerArray< CXnNode >& aChildren,

   139     CXnNode& aNode, const TDesC8& aParentBlockProgression,

   140     const TDesC8& aParentDirection, CGraphicsDevice& aScreenDevice,

   141     TReal aHorizontalUnitInPixels, TReal aVerticalUnitInPixels );

   142 

   143 static TSize CalculateTotalDimensionsL( CXnNode& aNode, TBool aIgnoreAutoValues,

   144     TBool aIgnoreMinSizes, TRect& aParentRect,

   145     CGraphicsDevice& aGraphicsDevice, TReal aHorizontalUnitInPixels,

   146     TReal aVerticalUnitInPixels );

   147 static TBool CutOnePixelFromPercentChildNodeL( CXnNode& aNode,

   148     const TDesC8& aParentBlockProgression );

   149 static void DetermineBorderWidthsL( CXnProperty* aBorderWidthProperty,

   150     TInt& aBordervertical, TInt& aBorderhorizontal,

   151     TRect& aParentRect, CGraphicsDevice& aGraphicsDevice,

   152     TReal aHorizontalUnitInPixels, TReal aVerticalUnitInPixels );

   153 static TInt DisplayedChildrenCountL( CXnNode& aNode,

   154     RPointerArray< CXnNode >* aDisplayedChildren = NULL );

   155 static CXnNode* DisplayedParentL( CXnNode& aNode );

   156 static CXnDomPropertyValue* DomPropertyValueFromProperty(

   157     CXnProperty* aProperty );

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

   159     TBool aDropRelativeNode = EFalse );

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

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

   162     TInt& aBottomOffset );

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

   164     TInt aTopOffset, TInt aBottomOffset );

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

   166 static void FitChildrenIntoParentL( CXnNode& aNode,

   167     CGraphicsDevice& aGraphicsDevice, TReal aHorizontalUnitInPixels,

   168     TReal aVerticalUnitInPixels );

   169 static TInt GetPositionL( CXnNode& aNode, 

   170     const TDesC8& aParentBlockProgression, const TDesC8& aParentDirection );

   171 static TInt HasNodeAutoValuesL( CXnNode& aNode );

   172 static TInt HasNodeHorizontalAutoValuesL( CXnNode& aNode );

   173 static TInt HasNodeVerticalAutoValuesL( CXnNode& aNode );

   174 static TBool HasNodeMinSizesL( CXnNode& aNode );

   175 static TBool HasNodeMaxSizesL( CXnNode& aNode );

   176 static TInt HorizontalPixelValueL( CXnProperty* aValue, TInt aReferenceValue,

   177     CGraphicsDevice& aScreenDevice, TReal aHorizontalUnitInPixels );

   178 static TInt HorizontalValueToPixelsL( CXnDomPropertyValue* aValue,

   179     TReal aReferenceValue, CGraphicsDevice& aScreenDevice,

   180     TReal aHorizontalUnitInPixels );

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

   182     CGraphicsDevice& aScreenDevice, TReal aHorizontalUnitInPixels,

   183     TReal aVerticalUnitInPixels );

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

   185     CGraphicsDevice& aScreenDevice, TReal aHorizontalUnitInPixels,

   186     TReal aVerticalUnitInPixels );

   187 static TBool IsAbsoluteL( CXnNode& aNode );

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

   189     CGraphicsDevice& aScreenDevice, TReal aHorizontalUnitInPixels,

   190     TReal aVerticalUnitInPixels );

   191 static TBool IsNodeDisplayedL( CXnNode& aNode );

   192 

   193 static TBool IsNodeTooltip( CXnNode& aNode );

   194 static TBool IsPropertyAutoL( CXnProperty& aProperty );

   195 static TBool IsPropertyNone( CXnProperty& aProperty );

   196 static TBool IsRelativeL( CXnNode& aNode );

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

   198     CGraphicsDevice& aScreenDevice, TReal aHorizontalUnitInPixels,

   199     TReal aVerticalUnitInPixels );

   200 static TBool IsValuePercentageL( CXnProperty& aProperty );

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

   202 static void PlaceAreasL( CXnNode& aNode,

   203     RPointerArray< CXnNode >& aLaidOutList,

   204     TInt aLayoutPhase, CGraphicsDevice& aGraphicsDevice,

   205     TReal aHorizontalUnitInPixels, TReal aVerticalUnitInPixels );

   206 static void PriorizeChildrenL( CXnNode& aNode );

   207 static void CalculateAutoPropertiesOfNodesL(

   208     RPointerArray< CXnNode >* aAutoNodeArray, TInt& aWidthAutoCount,

   209     TInt& aHeightAutoCount );

   210 static void ProcessAutoAreasL( CXnNode& aParentNode,

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

   212     const TDesC8& aParentDirection, CGraphicsDevice& aGraphicsDevice,

   213     TReal aHorizontalUnitInPixels, TReal aVerticalUnitInPixels );

   214 static void CalculateCollapseMarginsL( RPointerArray< CXnNode >& aChildren,

   215     RArray< TInt >& aCollapsedMarginsWidth, 

   216     RArray< TInt >& aCollapsedMarginsHeight,

   217     const TDesC8& aParentBlockProgression,

   218     const TDesC8& aParentDirection );

   219 static TSize CalculateSpaceUsedByAutoChildrenL(

   220     RPointerArray< CXnNode >& aAutoChildren,

   221     RPointerArray< CXnNode >& aCalculatedAutoChildren,

   222     CXnNode& aParent,

   223     const TDesC8& aParentBlockProgression,

   224     const TDesC8& aParentDirection,

   225     CGraphicsDevice& aScreenDevice );

   226 static void MoveAutoAreaL( TRect& parentRect,

   227     RPointerArray< CXnNode >& aChildren,

   228     const TDesC8& aParentBlockProgression,

   229     const TDesC8& aParentDirection );

   230 static TSize ScaleAutoAreaL( CXnNode& aNode, TInt aWidthToFit,

   231     TInt aHeightToFit, const TDesC8& aParentBlockProgression,

   232     const TDesC8& aParentDirection, TRect& aParentRect,

   233     CGraphicsDevice& aGraphicsDevice, TReal aHorizontalUnitInPixels,

   234     TReal aVerticalUnitInPixels );

   235 static void FitAutoChildrenIntoParentL( RPointerArray< CXnNode >& aAutoChildren,

   236     RPointerArray< CXnNode >& aCalculatedAutoChildren, CXnNode& aParent,

   237     const TDesC8& aParentBlockProgression, const TDesC8& aParentDirection,

   238     CGraphicsDevice& aGraphicsDevice );

   239 static TInt VerticalPixelValueL( CXnProperty* aValue, TInt aReferenceValue,

   240     CGraphicsDevice& aScreenDevice, TReal aVerticalUnitInPixels );

   241 static TInt VerticalValueToPixelsL( CXnDomPropertyValue* aValue,

   242     TReal aReferenceValue, CGraphicsDevice& aScreenDevice,

   243     TReal aVerticalUnitInPixels );

   244 static TBool IsStringValueL( CXnProperty& aProperty );

   245 static TInt HorizontalUnitsToPixelsL( TReal aUnits,

   246     TReal aHorizontalUnitInPixels );

   247 static TInt VerticalUnitsToPixelsL( TReal aUnits, TReal aVerticalUnitInPixels );

   248 static void ProcessAdaptiveAreasL( CXnNode& aParent,

   249     CGraphicsDevice& aGraphicsDevice, TReal aHorizontalUnitInPixels,

   250     TReal aVerticalUnitInPixels );

   251 

   252 static void CalculateAdaptiveSizeL( CXnNode& aNode,

   253     const TDesC8& aParentBlockProgression, const TDesC8& aParentDirection,

   254     CGraphicsDevice& aGraphicsDevice, TReal aHorizontalUnitInPixels,

   255     TReal aVerticalUnitInPixels );

   256 

   257 static CXnNode* BuildTriggerNodeLC( CXnUiEngine& aUiEngine,

   258     const TDesC8& aTriggerName );

   259 static void UpdateInternalUnits( TReal&  aHorizontalUnitInPixels,

   260     TReal& aVerticalUnitInPixels, TRect aRect );

   261 static CXnNode* BuildScreenDeviceChangeTriggerNodeLC(

   262     CXnUiEngine& aUiEngine );

   263 static void FillFocusCandidatesL( CXnNode* aParent,

   264     RPointerArray< CXnNode >& aArray );

   265 static TInt DetermineStatusPaneLayout( CXnProperty* aProperty );

   266 static TBool SetAdaptivesL( CXnNode& aNode );

   267 

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

   269     CXnPointerArray& aArray, const TDesC8& aNamespace );

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

   271     const TDesC8& aNamespace );

   272 

   273 #ifdef _XN3_DEBUG_

   274 static void TraceTreeL( CXnNode* aRootNode );

   275 #endif

   276 

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

   278 // -----------------------------------------------------------------------------

   279 // GrowIfNeeded()

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

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

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

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

   284 // -----------------------------------------------------------------------------

   285 //

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

   287     {

   288     CXnNode* focusedNode(NULL);

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

   290         {

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

   292             {

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

   294                 {

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

   296                 if(adapter)

   297                     {

   298                     aRect = adapter->Rect();

   299                     aRect.Grow( KFocusGrowValue, KFocusGrowValue );

   300                     }

   301                 break;

   302                 }

   303             focusedNode = node;

   304             }

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

   306             {

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

   308                 {

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

   310                 if(adapter)

   311                     {

   312                     aRect = adapter->Rect();

   313                     aRect.Grow( KFocusGrowValue, KFocusGrowValue );

   314                     }

   315                 }

   316             break;

   317             }

   318         }                            

   319     }      

   320 

   321 // -----------------------------------------------------------------------------

   322 // -----------------------------------------------------------------------------

   323 static TBool IsSrollableBox( CXnNode& aNode )

   324     {

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

   326         {

   327         return ETrue;

   328         }

   329     return EFalse;

   330     }

   331 

   332 // -----------------------------------------------------------------------------

   333 // FindNodeByClassL()

   334 // Finds recursively a node from current view by class

   335 // -----------------------------------------------------------------------------

   336 //

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

   338     CXnPointerArray& aArray, const TDesC8& aNamespace )

   339     {

   340     ASSERT( aRootNode );

   341     

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

   343         {

   344         // Recursed to wrong namespace

   345         return;

   346         }

   347             

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

   349     

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

   351         {

   352         // Correct id found

   353         if ( aNamespace == KNullDesC8 )

   354             {

   355             aArray.Container().AppendL( aRootNode );

   356             }

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

   358             {

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

   360             // -> this is perfect match

   361             aArray.Container().AppendL( aRootNode );

   362             }        

   363         }

   364     

   365     // Recurse children

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

   367     

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

   369         {

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

   371         }

   372     }

   373 

   374 // -----------------------------------------------------------------------------

   375 // FindNodeByIdL()

   376 // Finds recursively a node from current view by id

   377 // -----------------------------------------------------------------------------

   378 //

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

   380     const TDesC8& aNamespace )

   381     {

   382     ASSERT( aRootNode );

   383     

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

   385         {

   386         // Recursed to wrong namespace

   387         return NULL;

   388         }

   389                 

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

   391     

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

   393         {

   394         // Correct id found

   395         if ( aNamespace == KNullDesC8 )

   396             {

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

   398             return aRootNode;

   399             }

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

   401             {

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

   403             // -> this is perfect match

   404             return aRootNode;

   405             }        

   406         }

   407         

   408     // No match found, recurse children

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

   410     

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

   412         {

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

   414         

   415         if ( retval )

   416             {

   417             return retval;

   418             }

   419         }

   420     

   421     return NULL;

   422     }

   423 

   424 // -----------------------------------------------------------------------------

   425 // AutoStaticVerticalBTL()

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

   427 // and direction right-to-left

   428 // -----------------------------------------------------------------------------

   429 //

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

   431     RArray< TPtrC8 >& aAutoProperties, TRect& aParentRect,

   432     CGraphicsDevice& aGraphicsDevice, TReal aHorizontalUnitInPixels,

   433     TReal aVerticalUnitInPixels )

   434     {

   435     // Static positioning, vertical, right to left

   436     TBool horizontalMarginProcessed = EFalse;

   437     TBool verticalMarginProcessed = EFalse;

   438     TBool allVerticalValuesProcessed = EFalse;

   439     TBool allHorizontalValuesProcessed = EFalse;

   440 

   441     CXnProperty* maxHeightProperty = aNode.MaxHeightL();

   442     CXnProperty* maxWidthProperty = aNode.MaxWidthL();

   443     CXnProperty* minHeightProperty = aNode.MinHeightL();

   444     CXnProperty* minWidthProperty = aNode.MinWidthL();

   445 

   446     TRect contentRect( aNode.Rect() );

   447     TRect paddingRect( aNode.PaddingRect() );

   448     TRect borderRect( aNode.BorderRect() );

   449     TRect marginRect( aNode.MarginRect() );

   450     TRect normalFlowBorderRect( aNode.NormalFlowBorderRect() );

   451 

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

   453         aGraphicsDevice, aHorizontalUnitInPixels, aVerticalUnitInPixels );

   454 

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

   456         {

   457         // search for height property

   458         const TDesC8& attributeName = aAutoProperties[i];

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

   460             {

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

   462             TInt newHeight = aHeightToFit - size.iHeight;

   463 

   464             //  Calculate the difference so that it can be returned

   465             TRect paddingRectDiff( SubtractRect( paddingRect, contentRect ) );

   466             TRect borderRectDiff( SubtractRect( borderRect, contentRect ) );

   467             TRect marginRectDiff( SubtractRect( marginRect, contentRect ) );

   468             TRect normalFlowBorderRectDiff( SubtractRect ( normalFlowBorderRect,

   469                 contentRect ) );

   470 

   471             // grow height to fill the void

   472             contentRect.SetHeight( newHeight );

   473             paddingRect = AddRect( contentRect, paddingRectDiff );

   474             borderRect = AddRect( contentRect, borderRectDiff );

   475             normalFlowBorderRect = AddRect( contentRect,

   476                 normalFlowBorderRectDiff );

   477             marginRect = AddRect( contentRect, marginRectDiff );

   478 

   479             size = TSize( size.iWidth, aHeightToFit );

   480             }

   481         }

   482 

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

   484     if ( aAutoProperties.Count() == 1 )

   485         {

   486         if ( !allHorizontalValuesProcessed )

   487             {

   488             const TDesC8& attributeName = aAutoProperties[0];

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

   490                 {

   491                 TInt remainingWidth = aWidthToFit - size.iWidth;

   492                 if ( remainingWidth < 0 )

   493                     {

   494                     remainingWidth = 0;

   495                     }

   496                 //  Calculate the difference so that it can be returned

   497                 TRect paddingRectDiff( SubtractRect( paddingRect,

   498                     contentRect ) );

   499                 TRect borderRectDiff( SubtractRect( borderRect,

   500                     contentRect ) );

   501                 TRect marginRectDiff( SubtractRect( marginRect,

   502                     contentRect ) );

   503                 TRect normalFlowBorderRectDiff( SubtractRect(

   504                     normalFlowBorderRect, contentRect ) );

   505 

   506                 // grow width to fill the void

   507                 contentRect.SetWidth( remainingWidth );

   508                 paddingRect = AddRect( contentRect, paddingRectDiff );

   509                 borderRect = AddRect( contentRect, borderRectDiff );

   510                 normalFlowBorderRect = AddRect( contentRect,

   511                     normalFlowBorderRectDiff );

   512                 marginRect = AddRect( contentRect, marginRectDiff );

   513 

   514                 size = TSize( aWidthToFit, size.iHeight );

   515                 }

   516 

   517             if ( attributeName ==

   518                  XnPropertyNames::style::common::KMarginLeft )

   519                 {

   520                 TInt remainingWidth = aWidthToFit - size.iWidth;

   521                 if ( remainingWidth < 0 )

   522                     {

   523                     remainingWidth = 0;

   524                     }

   525                 contentRect.Move( remainingWidth, 0 );

   526                 borderRect.Move( remainingWidth, 0 );

   527                 normalFlowBorderRect.Move( remainingWidth, 0 );

   528                 marginRect.Resize( remainingWidth, 0 );

   529                 paddingRect.Move( remainingWidth, 0 );

   530                 size = TSize( size.iWidth + remainingWidth, size.iHeight );

   531                 }

   532 

   533             if ( attributeName == XnPropertyNames::style::common::KMarginRight )

   534                 {

   535                 TInt remainingWidth = aWidthToFit - size.iWidth;

   536                 if ( remainingWidth < 0 )

   537                     {

   538                     remainingWidth = 0;

   539                     }

   540                 marginRect.Resize( remainingWidth, 0 );

   541                 size = TSize( size.iWidth + remainingWidth, size.iHeight );

   542                 }

   543 

   544             if ( attributeName == XnPropertyNames::style::common::KMarginTop )

   545                 {

   546                 TInt remainingHeight = aHeightToFit - size.iHeight;

   547                 if ( remainingHeight < 0 )

   548                     {

   549                     remainingHeight = 0;

   550                     }

   551                 marginRect.Resize( 0, remainingHeight );

   552                 marginRect.Move( 0, -remainingHeight );

   553                 size = TSize( size.iWidth, size.iHeight + remainingHeight );

   554                 }

   555 

   556             if ( attributeName == 

   557                  XnPropertyNames::style::common::KMarginBottom )

   558                 {

   559                 TInt remainingHeight = aHeightToFit - size.iHeight;

   560                 if ( remainingHeight < 0 )

   561                     {

   562                     remainingHeight = 0;

   563                     }

   564                 marginRect.Resize( 0, remainingHeight );

   565                 marginRect.Move( 0, -remainingHeight );

   566                 paddingRect.Move( 0, -remainingHeight );

   567                 borderRect.Move( 0, -remainingHeight );

   568                 normalFlowBorderRect.Move( 0, -remainingHeight );

   569                 contentRect.Move( 0, -remainingHeight );

   570                 size = TSize( size.iWidth, size.iHeight + remainingHeight );

   571                 }

   572             }

   573         }

   574     else

   575         {

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

   577             {

   578             const TDesC8& attributeName = aAutoProperties[i];

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

   580                 {

   581                 TInt remainingWidth = aWidthToFit - size.iWidth;

   582                 if ( remainingWidth < 0 )

   583                     {

   584                     remainingWidth = 0;

   585                     }

   586                 //  Calculate the difference so that it can be returned

   587                 TRect paddingRectDiff( SubtractRect(

   588                     paddingRect, contentRect ) );

   589                 TRect borderRectDiff( SubtractRect(

   590                     borderRect, contentRect ) );

   591                 TRect marginRectDiff( SubtractRect(

   592                     marginRect, contentRect ) );

   593                 TRect normalFlowBorderRectDiff( SubtractRect(

   594                     normalFlowBorderRect, contentRect ) );

   595 

   596                 // grow width to fill the void

   597                 contentRect.SetWidth( remainingWidth );

   598                 paddingRect = AddRect( contentRect, paddingRectDiff );

   599                 borderRect = AddRect( contentRect, borderRectDiff );

   600                 normalFlowBorderRect = AddRect(

   601                     contentRect, normalFlowBorderRectDiff );

   602                 marginRect = AddRect( contentRect, marginRectDiff );

   603 

   604                 size = TSize( aWidthToFit, size.iHeight );

   605                 }

   606 

   607             // several auto properties

   608             if ( attributeName == XnPropertyNames::style::common::KMarginLeft )

   609                 {

   610                 if ( !horizontalMarginProcessed )

   611                     {

   612                     // is right margin also set to AUTO?

   613                     CXnProperty* rightMargin = aNode.MarginRightL();

   614                     if ( rightMargin )

   615                         {

   616                         if ( IsPropertyAutoL( *rightMargin ) )

   617                             {

   618                             // both margins set to AUTO, values equal

   619                             TInt remainingWidth = aWidthToFit - size.iWidth;

   620                             if ( remainingWidth < 0 )

   621                                 {

   622                                 remainingWidth = 0;

   623                                 }

   624                             // move rect right to fill the void

   625                             contentRect.Move( ( remainingWidth / 2 ), 0 );

   626                             marginRect.Resize( remainingWidth, 0 );

   627                             borderRect.Move( ( remainingWidth / 2 ), 0 );

   628                             normalFlowBorderRect.Move( (

   629                                 remainingWidth / 2 ), 0 );

   630                             paddingRect.Move( remainingWidth / 2, 0 );

   631                             horizontalMarginProcessed = ETrue;

   632                             size = TSize( size.iWidth + remainingWidth,

   633                                 size.iHeight );

   634                             }

   635                         else

   636                             {

   637                             // only left margin set to AUTO

   638                             TInt remainingWidth = aWidthToFit - size.iWidth;

   639                             if ( remainingWidth < 0 )

   640                                 {

   641                                 remainingWidth = 0;

   642                                 }

   643                             // move rect right to fill the void

   644                             contentRect.Move( ( remainingWidth ), 0 );

   645                             marginRect.Resize( remainingWidth, 0 );

   646                             borderRect.Move( remainingWidth, 0 );

   647                             normalFlowBorderRect.Move( remainingWidth, 0 );

   648                             paddingRect.Move( remainingWidth, 0 );

   649                             horizontalMarginProcessed = ETrue;

   650                             size = TSize( size.iWidth + remainingWidth,

   651                                 size.iHeight );

   652                             }

   653                         }

   654                     }

   655                 }

   656             if ( attributeName == XnPropertyNames::style::common::KMarginRight )

   657                 {

   658                 if ( !horizontalMarginProcessed )

   659                     {

   660                     // is left margin also set to AUTO?

   661                     CXnProperty* leftMargin = aNode.MarginLeftL();

   662                     if ( leftMargin )

   663                         {

   664                         if ( IsPropertyAutoL( *leftMargin ) )

   665                             {

   666                             // both margins set to AUTO, values equal

   667                             TInt remainingWidth = aWidthToFit - size.iWidth;

   668                             if ( remainingWidth < 0 )

   669                                 {

   670                                 remainingWidth = 0;

   671                                 }

   672                             contentRect.Move( remainingWidth / 2, 0 );

   673                             marginRect.Resize( remainingWidth, 0 );

   674                             borderRect.Move( ( remainingWidth / 2 ), 0 );

   675                             normalFlowBorderRect.Move( ( 

   676                                 remainingWidth / 2 ), 0 );

   677                             paddingRect.Move( remainingWidth / 2, 0 );

   678                             horizontalMarginProcessed = ETrue;

   679                             size = TSize( size.iWidth + remainingWidth,

   680                                 size.iHeight );

   681                             }

   682                         else

   683                             {

   684                             // only right margin set to AUTO

   685                             TInt remainingWidth = aWidthToFit - size.iWidth;

   686                             if ( remainingWidth < 0 )

   687                                 {

   688                                 remainingWidth = 0;

   689                                 }

   690                             marginRect.Resize( remainingWidth, 0 );

   691                             horizontalMarginProcessed = ETrue;

   692                             size = TSize( size.iWidth + remainingWidth,

   693                                 size.iHeight );

   694                             }

   695                         }

   696                     }

   697                 }

   698             if ( attributeName == XnPropertyNames::style::common::KMarginTop )

   699                 {

   700                 if ( !verticalMarginProcessed &&

   701                      !allVerticalValuesProcessed )

   702                     {

   703                     // is bottom margin also set to AUTO?

   704                     CXnProperty* bottomMargin = aNode.MarginBottomL();

   705                     if ( bottomMargin )

   706                         {

   707                         if ( IsPropertyAutoL( *bottomMargin ) )

   708                             {

   709                             // both margins set to AUTO, values equal

   710                             TInt remainingHeight = aHeightToFit - size.iHeight;

   711                             if ( remainingHeight < 0 )

   712                                 {

   713                                 remainingHeight = 0;

   714                                 }

   715                             contentRect.Move( 0, remainingHeight / 2 );

   716                             marginRect.Resize( 0, remainingHeight );

   717                             borderRect.Move( 0, ( remainingHeight / 2 ) );

   718                             normalFlowBorderRect.Move(

   719                                 0, ( remainingHeight / 2 ) );

   720                             paddingRect.Move( 0, remainingHeight / 2 );

   721                             verticalMarginProcessed = ETrue;

   722                             size = TSize( size.iWidth,

   723                                 size.iHeight + remainingHeight );

   724                             }

   725                         else

   726                             {

   727                             // only top margin set to AUTO

   728                             TInt remainingHeight = aHeightToFit - size.iHeight;

   729                             if ( remainingHeight < 0 )

   730                                 {

   731                                 remainingHeight = 0;

   732                                 }

   733                             marginRect.Resize( 0, remainingHeight );

   734                             marginRect.Move( 0, -remainingHeight );

   735                             verticalMarginProcessed = ETrue;

   736                             size = TSize( size.iWidth,

   737                                 size.iHeight + remainingHeight );

   738                             }

   739                         }

   740                     }

   741                 }

   742             if ( attributeName == 

   743                  XnPropertyNames::style::common::KMarginBottom )

   744                 {

   745                 if ( !verticalMarginProcessed && !allVerticalValuesProcessed )

   746                     {

   747                     // is top margin also set to AUTO?

   748                     CXnProperty* topMargin = aNode.MarginTopL();

   749                     if ( topMargin )

   750                         {

   751                         if ( IsPropertyAutoL( *topMargin ) )

   752                             {

   753                             // both margins set to AUTO, values equal

   754                             TInt remainingHeight =  aHeightToFit - size.iHeight;

   755                             if ( remainingHeight < 0 )

   756                                 {

   757                                 remainingHeight = 0;

   758                                 }

   759                             contentRect.Move( 0, -( remainingHeight / 2 ) );

   760                             marginRect.Resize( 0, remainingHeight );

   761                             marginRect.Move( 0, -remainingHeight );

   762                             borderRect.Move( 0, -( remainingHeight / 2 ) );

   763                             normalFlowBorderRect.Move(

   764                                 0, -( remainingHeight / 2 ) );

   765                             paddingRect.Move( 0, -( remainingHeight / 2 ) );

   766                             verticalMarginProcessed = ETrue;

   767                             size = TSize( size.iWidth,

   768                                 size.iHeight + remainingHeight );

   769                             }

   770                         else

   771                             {

   772                             // only bottom margin set to AUTO

   773                             TInt remainingHeight = aHeightToFit - size.iHeight;

   774                             if ( remainingHeight < 0 )

   775                                 {

   776                                 remainingHeight = 0;

   777                                 }

   778                             contentRect.Move( 0, -remainingHeight );

   779                             marginRect.Resize( 0, remainingHeight );

   780                             marginRect.Move( 0, -remainingHeight );

   781                             borderRect.Move( 0, -remainingHeight );

   782                             normalFlowBorderRect.Move(

   783                                 0, -remainingHeight );

   784                             paddingRect.Move( 0, -remainingHeight );

   785                             verticalMarginProcessed = ETrue;

   786                             size = TSize( size.iWidth,

   787                                 size.iHeight + remainingHeight );

   788                             }

   789                         }

   790                     }

   791                 }

   792             }

   793         }

   794     aNode.SetRect( contentRect );

   795     aNode.SetPaddingRect( paddingRect );

   796     aNode.SetBorderRect( borderRect );

   797     aNode.SetMarginRect( marginRect );

   798     aNode.SetNormalFlowBorderRect( normalFlowBorderRect );

   799     return contentRect.Size();

   800     }

   801 

   802 // -----------------------------------------------------------------------------

   803 // AutoStaticLRL()

   804 // Calculate properties set to AUTO when positioning is static,

   805 // layout horizontal

   806 // and direction left-to-right

   807 // -----------------------------------------------------------------------------

   808 //

   809 static TSize AutoStaticLRL( CXnNode& aNode, TInt aWidthToFit, TInt aHeightToFit,

   810     RArray< TPtrC8 >& aAutoProperties, TRect& aParentRect,

   811     CGraphicsDevice& aGraphicsDevice, TReal aHorizontalUnitInPixels,

   812     TReal aVerticalUnitInPixels )

   813     {

   814     // Static positioning, horizontal, left to right

   815     TBool horizontalMarginProcessed = EFalse;

   816     TBool verticalMarginProcessed = EFalse;

   817     TBool allVerticalValuesProcessed = EFalse;

   818     TBool allHorizontalValuesProcessed = EFalse;

   819 

   820     CXnProperty* maxHeightProperty = aNode.MaxHeightL();

   821     CXnProperty* maxWidthProperty = aNode.MaxWidthL();

   822     CXnProperty* minHeightProperty = aNode.MinHeightL();

   823     CXnProperty* minWidthProperty = aNode.MinWidthL();

   824 

   825     TRect contentRect = aNode.Rect();

   826     TRect paddingRect = aNode.PaddingRect();

   827     TRect borderRect = aNode.BorderRect();

   828     TRect marginRect = aNode.MarginRect();

   829     TRect normalFlowBorderRect = aNode.NormalFlowBorderRect();

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

   831         aGraphicsDevice, aHorizontalUnitInPixels, aVerticalUnitInPixels );

   832 

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

   834         {

   835         // search for width property

   836         const TDesC8& attributeName = aAutoProperties[i];

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

   838             {

   839             // width was AUTO, all other vertical auto values are 0

   840             TInt newWidth = aWidthToFit - size.iWidth;

   841 

   842             //  Calculate the difference so that it can be returned

   843             TRect paddingRectDiff( SubtractRect( paddingRect, contentRect ) );

   844             TRect borderRectDiff( SubtractRect( borderRect, contentRect ) );

   845             TRect marginRectDiff( SubtractRect( marginRect, contentRect ) );

   846             TRect normalFlowBorderRectDiff( SubtractRect( normalFlowBorderRect,

   847                 contentRect ) );

   848 

   849             // grow width to fill the void

   850             contentRect.SetWidth( newWidth );

   851             paddingRect = AddRect( contentRect, paddingRectDiff );

   852             borderRect = AddRect( contentRect, borderRectDiff );

   853             normalFlowBorderRect = AddRect(

   854                 contentRect, normalFlowBorderRectDiff );

   855             marginRect = AddRect( contentRect, marginRectDiff );

   856 

   857             size = TSize( aWidthToFit, size.iHeight );

   858             allHorizontalValuesProcessed = ETrue;

   859             }

   860         }

   861 

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

   863     if ( aAutoProperties.Count() == 1 )

   864         {

   865         if ( !allHorizontalValuesProcessed )

   866             {

   867             const TDesC8& attributeName = aAutoProperties[0];

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

   869                 {

   870                 TInt remainingHeight = aHeightToFit - size.iHeight;

   871                 if ( remainingHeight < 0 )

   872                     {

   873                     remainingHeight = 0;

   874                     }

   875                 //  Calculate the difference so that it can be returned

   876                 TRect paddingRectDiff( SubtractRect(

   877                     paddingRect, contentRect ) );

   878                 TRect borderRectDiff( SubtractRect(

   879                     borderRect, contentRect ) );

   880                 TRect marginRectDiff( SubtractRect(

   881                     marginRect, contentRect ) );

   882                 TRect normalFlowBorderRectDiff( SubtractRect(

   883                     normalFlowBorderRect, contentRect ) );

   884 

   885                 // grow height to fill the void

   886                 contentRect.SetHeight( remainingHeight );

   887                 paddingRect = AddRect( contentRect, paddingRectDiff );

   888                 borderRect = AddRect( contentRect, borderRectDiff );

   889                 normalFlowBorderRect = AddRect(

   890                     contentRect, normalFlowBorderRectDiff );

   891                 marginRect = AddRect( contentRect, marginRectDiff );

   892                 size = TSize( size.iWidth, aHeightToFit );

   893                 }

   894 

   895             if ( attributeName == XnPropertyNames::style::common::KMarginLeft )

   896                 {

   897                 TInt remainingWidth = aWidthToFit - size.iWidth;

   898                 if ( remainingWidth < 0 )

   899                     {

   900                     remainingWidth = 0;

   901                     }

   902                 // move rect right to fill the void

   903                 contentRect.Move( remainingWidth, 0 );

   904                 paddingRect.Move( remainingWidth, 0 );

   905                 borderRect.Move( remainingWidth, 0 );

   906                 normalFlowBorderRect.Move( remainingWidth, 0 );

   907                 marginRect.Resize( remainingWidth, 0 );

   908                 size = TSize( size.iWidth + remainingWidth, size.iHeight );

   909                 }

   910 

   911             if ( attributeName == XnPropertyNames::style::common::KMarginRight )

   912                 {

   913                 TInt remainingWidth = aWidthToFit - size.iWidth;

   914                 marginRect.Resize( remainingWidth, 0 );

   915                 size = TSize( size.iWidth + remainingWidth, size.iHeight );

   916                 }

   917 

   918             if ( attributeName == XnPropertyNames::style::common::KMarginTop )

   919                 {

   920                 TInt remainingHeight = aHeightToFit - size.iHeight;

   921                 // move rect right to fill the void

   922                 contentRect.Move( 0, remainingHeight / 2 );

   923                 paddingRect.Move( 0, remainingHeight / 2 );

   924                 borderRect.Move( 0, remainingHeight / 2 );

   925                 normalFlowBorderRect.Move( 0, remainingHeight / 2 );

   926                 marginRect.Resize( 0, remainingHeight );

   927                 size = TSize( size.iWidth, size.iHeight + remainingHeight );

   928                 }

   929 

   930             if ( attributeName ==

   931                  XnPropertyNames::style::common::KMarginBottom )

   932                 {

   933                 TInt remainingHeight = aHeightToFit - size.iHeight;

   934                 if ( remainingHeight < 0 )

   935                     {

   936                     remainingHeight = 0;

   937                     }

   938                 marginRect.Resize( 0, remainingHeight );

   939                 size = TSize( size.iWidth, size.iHeight + remainingHeight );

   940                 }

   941             }

   942         }

   943     else

   944         {

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

   946             {

   947             const TDesC8& attributeName = aAutoProperties[i];

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

   949                 {

   950                 TInt remainingHeight = aHeightToFit - size.iHeight;

   951                 if ( remainingHeight < 0 )

   952                     {

   953                     remainingHeight = 0;

   954                     }

   955                 //  Calculate the difference so that it can be returned

   956                 TRect paddingRectDiff( SubtractRect(

   957                     paddingRect, contentRect ) );

   958                 TRect borderRectDiff( SubtractRect(

   959                     borderRect, contentRect ) );

   960                 TRect marginRectDiff( SubtractRect(

   961                     marginRect, contentRect ) );

   962                 TRect normalFlowBorderRectDiff( SubtractRect(

   963                     normalFlowBorderRect, contentRect ) );

   964 

   965                 // grow height to fill the void

   966                 contentRect.SetHeight( remainingHeight );

   967                 paddingRect = AddRect( contentRect, paddingRectDiff );

   968                 borderRect = AddRect( contentRect, borderRectDiff );

   969                 normalFlowBorderRect = AddRect(

   970                     contentRect, normalFlowBorderRectDiff );

   971                 marginRect = AddRect( contentRect, marginRectDiff );

   972                 size = TSize( size.iWidth, aHeightToFit );

   973                 }

   974 

   975             // several auto properties

   976             if ( attributeName == XnPropertyNames::style::common::KMarginLeft )

   977                 {

   978                 if ( !horizontalMarginProcessed )

   979                     {

   980                     // is right margin also set to AUTO?

   981                     CXnProperty* rightMargin = aNode.MarginRightL();

   982                     if ( rightMargin )

   983                         {

   984                         if ( IsPropertyAutoL( *rightMargin ) )

   985                             {

   986                             // both margins set to AUTO, values equal

   987                             TInt remainingWidth = aWidthToFit - size.iWidth;

   988                             if ( remainingWidth < 0 )

   989                                 {

   990                                 remainingWidth = 0;

   991                                 }

   992                             // move rect right to fill the void

   993                             contentRect.Move( ( remainingWidth / 2 ), 0 );

   994                             horizontalMarginProcessed = ETrue;

   995                             marginRect.Resize( ( remainingWidth ), 0 );

   996                             borderRect.Move( ( remainingWidth / 2 ), 0 );

   997                             normalFlowBorderRect.Move( (

   998                                 remainingWidth / 2 ), 0 );

   999                             paddingRect.Move( ( remainingWidth / 2 ), 0 );

  1000                             size = TSize( size.iWidth + remainingWidth,

  1001                                 size.iHeight );

  1002                             }

  1003                         else

  1004                             {

  1005                             // only left margin set to AUTO

  1006                             TInt remainingWidth = aWidthToFit - size.iWidth;

  1007                             if ( remainingWidth < 0 )

  1008                                 {

  1009                                 remainingWidth = 0;

  1010                                 }

  1011                             // move rect right to fill the void

  1012                             contentRect.Move( remainingWidth, 0 );

  1013                             horizontalMarginProcessed = ETrue;

  1014                             marginRect.Move( remainingWidth, 0 );

  1015                             borderRect.Move( remainingWidth, 0 );

  1016                             normalFlowBorderRect.Move( remainingWidth, 0 );

  1017                             paddingRect.Move( remainingWidth, 0 );

  1018                             size = TSize( size.iWidth + remainingWidth,

  1019                                 size.iHeight );

  1020                             }

  1021                         }

  1022                     }

  1023                 }

  1024 

  1025             if ( attributeName == XnPropertyNames::style::common::KMarginRight )

  1026                 {

  1027                 if ( !horizontalMarginProcessed )

  1028                     {

  1029                     // is left margin also set to AUTO?

  1030                     CXnProperty* leftMargin = aNode.MarginLeftL();

  1031                     if ( leftMargin )

  1032                         {

  1033                         if ( IsPropertyAutoL( *leftMargin ) )

  1034                             {

  1035                             // both margins set to AUTO, values equal

  1036                             TInt remainingWidth = aWidthToFit - size.iWidth;

  1037                             if ( remainingWidth < 0 )

  1038                                 {

  1039                                 remainingWidth = 0;

  1040                                 }

  1041                             // move rect right to fill the void

  1042                             contentRect.Move( ( remainingWidth / 2 ), 0 );

  1043                             horizontalMarginProcessed = ETrue;

  1044                             marginRect.Resize( ( remainingWidth ), 0 );

  1045                             borderRect.Move( ( remainingWidth / 2 ), 0 );

  1046                             normalFlowBorderRect.Move( (

  1047                                 remainingWidth / 2 ), 0 );

  1048                             paddingRect.Move( ( remainingWidth / 2 ), 0 );

  1049                             size = TSize( size.iWidth + remainingWidth,

  1050                                 size.iHeight );

  1051                             }

  1052                         else

  1053                             {

  1054                             // only right margin set to AUTO

  1055                             horizontalMarginProcessed = ETrue;

  1056                             }

  1057                         }

  1058                     }

  1059                 }

  1060             if ( attributeName == XnPropertyNames::style::common::KMarginTop )

  1061                 {

  1062                 if ( !verticalMarginProcessed && !allVerticalValuesProcessed )

  1063                     {

  1064                     // is bottom margin also set to AUTO?

  1065                     CXnProperty* bottomMargin = aNode.MarginBottomL();

  1066                     if ( bottomMargin )

  1067                         {

  1068                         if ( IsPropertyAutoL( *bottomMargin ) )

  1069                             {

  1070                             // both margins set to AUTO, values equal

  1071                             TInt remainingHeight =  aHeightToFit - size.iHeight;

  1072                             if ( remainingHeight < 0 )

  1073                                 {

  1074                                 remainingHeight = 0;

  1075                                 }

  1076                             // move rect right to fill the void

  1077                             contentRect.Move( 0, ( remainingHeight / 2 ) );

  1078                             verticalMarginProcessed = ETrue;

  1079                             marginRect.Resize( 0, remainingHeight );

  1080                             borderRect.Move( 0, ( remainingHeight / 2 ) );

  1081                             normalFlowBorderRect.Move(

  1082                                 0, ( remainingHeight / 2 ) );

  1083                             paddingRect.Move( 0, ( remainingHeight / 2 ) );

  1084                             size = TSize( size.iWidth, 

  1085                                 size.iHeight + remainingHeight );

  1086                             }

  1087                         else

  1088                             {

  1089                             // only top margin set to AUTO

  1090                             TInt remainingHeight =  aHeightToFit - size.iHeight;

  1091                             if ( remainingHeight < 0 )

  1092                                 {

  1093                                 remainingHeight = 0;

  1094                                 }

  1095                             // move rect right to fill the void

  1096                             contentRect.Move( 0, remainingHeight );

  1097                             verticalMarginProcessed = ETrue;

  1098                             marginRect.Resize( 0, remainingHeight );

  1099                             borderRect.Move( 0, remainingHeight );

  1100                             normalFlowBorderRect.Move( 0, remainingHeight );

  1101                             paddingRect.Move( 0, remainingHeight );

  1102                             size = TSize( size.iWidth,

  1103                                 size.iHeight + remainingHeight );

  1104                             }

  1105                         }

  1106                     }

  1107                  }

  1108 

  1109             if ( attributeName ==

  1110                  XnPropertyNames::style::common::KMarginBottom )

  1111                 {

  1112                 if ( !verticalMarginProcessed && !allVerticalValuesProcessed )

  1113                     {

  1114                     // is top margin also set to AUTO?

  1115                     CXnProperty* topMargin = aNode.MarginTopL();

  1116                     if ( topMargin )

  1117                         {

  1118                         if ( IsPropertyAutoL( *topMargin ) )

  1119                             {

  1120                             // both margins set to AUTO, values equal

  1121                             TInt remainingHeight =  aHeightToFit - size.iHeight;

  1122                             if ( remainingHeight < 0 )

  1123                                 {

  1124                                 remainingHeight = 0;

  1125                                 }

  1126                             // move rect right to fill the void

  1127                             contentRect.Move( 0, remainingHeight / 2 );

  1128                             verticalMarginProcessed = ETrue;

  1129                             marginRect.Resize( 0, remainingHeight );

  1130                             borderRect.Move( 0, remainingHeight / 2 );

  1131                             normalFlowBorderRect.Move(

  1132                                 0, remainingHeight / 2 );

  1133                             paddingRect.Move( 0, remainingHeight / 2 );

  1134                             size = TSize( size.iWidth,