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 #include <AknPriv.hrh> 

    25 #include <debug.h>

    26 

    27 // User includes

    28 #include "xnuiengine.h"

    29 #include "xnuiengineimpl.h"

    30 #include "xnuistatelistener.h"

    31 #include "xnpointerarray.h"

    32 #include "xnodt.h"

    33 #include "xndomlist.h"

    34 #include "xndompropertyvalue.h"

    35 #include "xnmenuadapter.h"

    36 #include "xnpopupcontroladapter.h"

    37 #include "xnviewcontroladapter.h"

    38 #include "xnviewdata.h"

    39 #include "xnnodebreadthfirstiterator.h"

    40 #include "xntype.h"

    41 #include "xnnodepluginif.h"

    42 #include "xncomponentnodeimpl.h"

    43 #include "xnproperty.h"

    44 #include "xnappuiadapter.h"

    45 #include "xnviewadapter.h"

    46 #include "xnwidgetextensionadapter.h"

    47 #include "xnscrollablecontroladapter.h"

    48 #include "xnkeyeventdispatcher.h"

    49 #include <aknlayoutscalable_avkon.cdl.h>

    50 #include "xuikon_builds_cfg.hrh"

    51 #include "xndomdocument.h"

    52 #include "xndomnode.h"

    53 #include "xneditmode.h"

    54 #include "xnnode.h"

    55 #include "xnpanic.h"

    56 #include "xneffectmanager.h"

    57 #include "xneditor.h"

    58 #include "xnbackgroundmanager.h"

    59 #include "xntexteditor.h"

    60 #include "xnrootdata.h"

    61 

    62 #ifdef _XN_PERFORMANCE_TEST_

    63 #include "xntimemon.h"

    64 #endif

    65 

    66 #ifdef _XN3_DEBUG_

    67 #include "xndepthfirsttreeiterator.h" // for TraceTreeL

    68 #endif

    69 

    70 

    71 // CONSTANTS

    72 const TInt KXnBorderThin = 1;

    73 const TInt KXnBorderMedium = 3;

    74 const TInt KXnBorderThick = 5;

    75 const TInt KXnStackPriorityKeyEventDispatcher = 55;

    76 const TInt KFocusGrowValue = 3;

    77 

    78 _LIT8( KBoxNodeName, "box" );

    79 _LIT8( KButtonNodeName, "button" );

    80 _LIT8( KWidgetNodeName, "widget" );

    81 _LIT8( KWidgetExtensionNodeName, "widgetextension" );

    82 _LIT8( KScrollableBoxNodeName, "scrollablebox" );

    83 _LIT8( KMenuBar, "menubar" );

    84 _LIT8( KPopUpNodeName, "popup" );

    85 _LIT8( KEditorNodeName, "texteditor" );

    86 

    87 _LIT8( KPlugin, "plugin" );

    88 

    89 // LOCAL CONSTANTS AND MACROS

    90 static const TReal KIntConversionConstant = 0.5;

    91 static const TReal KIntPercentageConstant =

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

    93 static const TReal KInchesAsTwips = 1440;

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

    95 static const TReal KCentimetersAsTwips = KCentimetersAsInches * KInchesAsTwips;

    96 static const TReal KMillimetersAsInches =

    97     KCentimetersAsInches / static_cast< TReal >( 10 );

    98 static const TReal KMillimetersAsTwips = KMillimetersAsInches * KInchesAsTwips;

    99 static const TReal KPointsAsInches =

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

   101 static const TReal KPointsAsTwips = KPointsAsInches * KInchesAsTwips;

   102 static const TReal KPicasAsInches =

   103     KPointsAsInches / static_cast< TReal >( 12 );

   104 static const TReal KPicasAsTwips = KPicasAsInches * KInchesAsTwips;

   105 

   106 // MODULE DATA STRUCTURES

   107 

   108 // LOCAL FUNCTION PROTOTYPES

   109 

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

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

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

   113     TInt aHeightToFit, RArray< TPtrC8 >& aAutoProperties,

   114     TRect& aParentRect, CGraphicsDevice& aGraphicsDevice,

   115     TReal aHorizontalUnitInPixels, TReal aVerticalUnitInPixels );

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

   117     TInt aHeightToFit, RArray< TPtrC8 >& aAutoProperties,

   118     TRect& aParentRect, CGraphicsDevice& aGraphicsDevice,

   119     TReal aHorizontalUnitInPixels, TReal aVerticalUnitInPixels );

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

   121     TInt aHeightToFit, RArray< TPtrC8 >& aAutoProperties,

   122     TRect& aParentRect, CGraphicsDevice& aGraphicsDevice,

   123     TReal aHorizontalUnitInPixels, TReal aVerticalUnitInPixels );

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

   125     TInt aHeightToFit, RArray< TPtrC8 >& aAutoProperties,

   126     TRect& aParentRect, CGraphicsDevice& aGraphicsDevice,

   127     TReal aHorizontalUnitInPixels, TReal aVerticalUnitInPixels );

   128 static void CalculateAbsolutePositionsL( CXnNode& aNode,

   129     TRect& aParentRect, CGraphicsDevice& aGraphicsDevice,

   130     TReal aHorizontalUnitInPixels, TReal aVerticalUnitInPixels );

   131 static void CalculateBorderL( CXnNode& aNode,

   132     TRect& aParentRect, CGraphicsDevice& aGraphicsDevice,

   133     TReal aHorizontalUnitInPixels, TReal aVerticalUnitInPixels );

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

   135     CXnNode* aPreviousSibling, const TDesC8& aParentBlockProgression,

   136     const TDesC8& aParentDirection, TRect& aParentRect,

   137     CGraphicsDevice& aGraphicsDevice, TReal aHorizontalUnitInPixels,

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

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

   140     CGraphicsDevice& aGraphicsDevice, TReal aHorizontalUnitInPixels,

   141     TReal aVerticalUnitInPixels );

   142 

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

   144     CGraphicsDevice& aGraphicsDevice, TReal aHorizontalUnitInPixels,

   145     TReal aVerticalUnitInPixels );

   146 

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

   148     CGraphicsDevice& aGraphicsDevice, TReal aHorizontalUnitInPixels,

   149     TReal aVerticalUnitInPixels );

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

   151     CXnNode& aNode, const TDesC8& aParentBlockProgression,

   152     const TDesC8& aParentDirection, CGraphicsDevice& aScreenDevice,

   153     TReal aHorizontalUnitInPixels, TReal aVerticalUnitInPixels );

   154 

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

   156     TBool aIgnoreMinSizes, TRect& aParentRect,

   157     CGraphicsDevice& aGraphicsDevice, TReal aHorizontalUnitInPixels,

   158     TReal aVerticalUnitInPixels );

   159 static TBool CutOnePixelFromPercentChildNodeL( CXnNode& aNode,

   160     const TDesC8& aParentBlockProgression );

   161 static void DetermineBorderWidthsL( CXnProperty* aBorderWidthProperty,

   162     TInt& aBordervertical, TInt& aBorderhorizontal,

   163     TRect& aParentRect, CGraphicsDevice& aGraphicsDevice,

   164     TReal aHorizontalUnitInPixels, TReal aVerticalUnitInPixels );

   165 static TInt DisplayedChildrenCountL( CXnNode& aNode,

   166     RPointerArray< CXnNode >* aDisplayedChildren = NULL );

   167 static CXnNode* DisplayedParentL( CXnNode& aNode );

   168 static CXnDomPropertyValue* DomPropertyValueFromProperty(

   169     CXnProperty* aProperty );

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

   171     TBool aDropRelativeNode = EFalse );

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

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

   174     TInt& aBottomOffset );

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

   176     TInt aTopOffset, TInt aBottomOffset );

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

   178 static void FitChildrenIntoParentL( CXnNode& aNode,

   179     CGraphicsDevice& aGraphicsDevice, TReal aHorizontalUnitInPixels,

   180     TReal aVerticalUnitInPixels );

   181 static TInt GetPositionL( CXnNode& aNode, 

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

   183 static TInt HasNodeAutoValuesL( CXnNode& aNode );

   184 static TInt HasNodeHorizontalAutoValuesL( CXnNode& aNode );

   185 static TInt HasNodeVerticalAutoValuesL( CXnNode& aNode );

   186 static TBool HasNodeMinSizesL( CXnNode& aNode );

   187 static TBool HasNodeMaxSizesL( CXnNode& aNode );

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

   189     CGraphicsDevice& aScreenDevice, TReal aHorizontalUnitInPixels );

   190 static TInt HorizontalValueToPixelsL( CXnDomPropertyValue* aValue,

   191     TReal aReferenceValue, CGraphicsDevice& aScreenDevice,

   192     TReal aHorizontalUnitInPixels );

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

   194     CGraphicsDevice& aScreenDevice, TReal aHorizontalUnitInPixels,

   195     TReal aVerticalUnitInPixels );

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

   197     CGraphicsDevice& aScreenDevice, TReal aHorizontalUnitInPixels,

   198     TReal aVerticalUnitInPixels );

   199 static TBool IsAbsoluteL( CXnNode& aNode );

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

   201     CGraphicsDevice& aScreenDevice, TReal aHorizontalUnitInPixels,

   202     TReal aVerticalUnitInPixels );

   203 static TBool IsNodeDisplayedL( CXnNode& aNode );

   204 

   205 static TBool IsNodeTooltip( CXnNode& aNode );

   206 static TBool IsPropertyAutoL( CXnProperty& aProperty );

   207 static TBool IsPropertyNone( CXnProperty& aProperty );

   208 static TBool IsRelativeL( CXnNode& aNode );

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

   210     CGraphicsDevice& aScreenDevice, TReal aHorizontalUnitInPixels,

   211     TReal aVerticalUnitInPixels );

   212 static TBool IsValuePercentageL( CXnProperty& aProperty );

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

   214 static void PlaceAreasL( CXnNode& aNode,

   215     RPointerArray< CXnNode >& aLaidOutList,

   216     TInt aLayoutPhase, CGraphicsDevice& aGraphicsDevice,

   217     TReal aHorizontalUnitInPixels, TReal aVerticalUnitInPixels );

   218 static void PriorizeChildrenL( CXnNode& aNode );

   219 static void CalculateAutoPropertiesOfNodesL(

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

   221     TInt& aHeightAutoCount );

   222 static void ProcessAutoAreasL( CXnNode& aParentNode,

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

   224     const TDesC8& aParentDirection, CGraphicsDevice& aGraphicsDevice,

   225     TReal aHorizontalUnitInPixels, TReal aVerticalUnitInPixels );

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

   227     RArray< TInt >& aCollapsedMarginsWidth, 

   228     RArray< TInt >& aCollapsedMarginsHeight,

   229     const TDesC8& aParentBlockProgression,

   230     const TDesC8& aParentDirection );

   231 static TSize CalculateSpaceUsedByAutoChildrenL(

   232     RPointerArray< CXnNode >& aAutoChildren,

   233     RPointerArray< CXnNode >& aCalculatedAutoChildren,

   234     CXnNode& aParent,

   235     const TDesC8& aParentBlockProgression,

   236     const TDesC8& aParentDirection,

   237     CGraphicsDevice& aScreenDevice );

   238 static void MoveAutoAreaL( TRect& parentRect,

   239     RPointerArray< CXnNode >& aChildren,

   240     const TDesC8& aParentBlockProgression,

   241     const TDesC8& aParentDirection );

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

   243     TInt aHeightToFit, const TDesC8& aParentBlockProgression,

   244     const TDesC8& aParentDirection, TRect& aParentRect,

   245     CGraphicsDevice& aGraphicsDevice, TReal aHorizontalUnitInPixels,

   246     TReal aVerticalUnitInPixels );

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

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

   249     const TDesC8& aParentBlockProgression, const TDesC8& aParentDirection,

   250     CGraphicsDevice& aGraphicsDevice );

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

   252     CGraphicsDevice& aScreenDevice, TReal aVerticalUnitInPixels );

   253 static TInt VerticalValueToPixelsL( CXnDomPropertyValue* aValue,

   254     TReal aReferenceValue, CGraphicsDevice& aScreenDevice,

   255     TReal aVerticalUnitInPixels );

   256 static TBool IsStringValueL( CXnProperty& aProperty );

   257 static TInt HorizontalUnitsToPixelsL( TReal aUnits,

   258     TReal aHorizontalUnitInPixels );

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

   260 static void ProcessAdaptiveAreasL( CXnNode& aParent,

   261     CGraphicsDevice& aGraphicsDevice, TReal aHorizontalUnitInPixels,

   262     TReal aVerticalUnitInPixels );

   263 

   264 static void CalculateAdaptiveSizeL( CXnNode& aNode,

   265     const TDesC8& aParentBlockProgression, const TDesC8& aParentDirection,

   266     CGraphicsDevice& aGraphicsDevice, TReal aHorizontalUnitInPixels,

   267     TReal aVerticalUnitInPixels );

   268 

   269 static CXnNode* BuildTriggerNodeLC( CXnUiEngine& aUiEngine,

   270     const TDesC8& aTriggerName );

   271 static void UpdateInternalUnits( TReal&  aHorizontalUnitInPixels,

   272     TReal& aVerticalUnitInPixels, TRect aRect );

   273 static CXnNode* BuildScreenDeviceChangeTriggerNodeLC(

   274     CXnUiEngine& aUiEngine );

   275 static void FillFocusCandidatesL( CXnNode* aParent,

   276     RPointerArray< CXnNode >& aArray );

   277 static TBool SetAdaptivesL( CXnNode& aNode );

   278 

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

   280     CXnPointerArray& aArray, const TDesC8& aNamespace );

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

   282     const TDesC8& aNamespace );

   283 

   284 #ifdef _XN3_DEBUG_

   285 static void TraceTreeL( CXnNode* aRootNode );

   286 #endif

   287 

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

   289 

   290 // -----------------------------------------------------------------------------

   291 // -----------------------------------------------------------------------------

   292 //

   293 CXnNode* FindPlugin( CXnNode& aNode )

   294     {

   295     CXnNode* pluginNode( NULL );

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

   297         {

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

   299             {

   300             pluginNode = node;

   301             break;

   302             }

   303         }

   304     return pluginNode;

   305     }

   306 

   307 // -----------------------------------------------------------------------------

   308 // GrowIfNeeded()

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

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

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

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

   313 // -----------------------------------------------------------------------------

   314 //

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

   316     {

   317     CXnNode* focusedNode(NULL);

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

   319         {

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

   321             {

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

   323                 {

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

   325                 if(adapter)

   326                     {

   327                     aRect = adapter->Rect();

   328                     aRect.Grow( KFocusGrowValue, KFocusGrowValue );

   329                     }

   330                 break;

   331                 }

   332             focusedNode = node;

   333             }

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

   335             {

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

   337                 {

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

   339                 if(adapter)

   340                     {

   341                     aRect = adapter->Rect();

   342                     aRect.Grow( KFocusGrowValue, KFocusGrowValue );

   343                     }

   344                 }

   345             break;

   346             }

   347         }                            

   348     }      

   349 

   350 // -----------------------------------------------------------------------------

   351 // -----------------------------------------------------------------------------

   352 static TBool IsSrollableBox( CXnNode& aNode )

   353     {

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

   355         {

   356         return ETrue;

   357         }

   358     return EFalse;

   359     }

   360 

   361 // -----------------------------------------------------------------------------

   362 // FindNodeByClassL()

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

   364 // -----------------------------------------------------------------------------

   365 //

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

   367     CXnPointerArray& aArray, const TDesC8& aNamespace )

   368     {

   369     ASSERT( aRootNode );

   370     

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

   372         {

   373         // Recursed to wrong namespace

   374         return;

   375         }

   376             

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

   378     

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

   380         {

   381         // Correct id found

   382         if ( aNamespace == KNullDesC8 )

   383             {

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

   385             }

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

   387             {

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

   389             // -> this is perfect match

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

   391             }        

   392         }

   393     

   394     // Recurse children

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

   396     

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

   398         {

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

   400         }

   401     }

   402 

   403 // -----------------------------------------------------------------------------

   404 // FindNodeByIdL()

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

   406 // -----------------------------------------------------------------------------

   407 //

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

   409     const TDesC8& aNamespace )

   410     {

   411     ASSERT( aRootNode );

   412     

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

   414         {

   415         // Recursed to wrong namespace

   416         return NULL;

   417         }

   418                 

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

   420     

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

   422         {

   423         // Correct id found

   424         if ( aNamespace == KNullDesC8 )

   425             {

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

   427             return aRootNode;

   428             }

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

   430             {

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

   432             // -> this is perfect match

   433             return aRootNode;

   434             }        

   435         }

   436         

   437     // No match found, recurse children

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

   439     

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

   441         {

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

   443         

   444         if ( retval )

   445             {

   446             return retval;

   447             }

   448         }

   449     

   450     return NULL;

   451     }

   452 

   453 // -----------------------------------------------------------------------------

   454 // AutoStaticVerticalBTL()

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

   456 // and direction right-to-left

   457 // -----------------------------------------------------------------------------

   458 //

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

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

   461     CGraphicsDevice& aGraphicsDevice, TReal aHorizontalUnitInPixels,

   462     TReal aVerticalUnitInPixels )

   463     {

   464     // Static positioning, vertical, right to left

   465     TBool horizontalMarginProcessed = EFalse;

   466     TBool verticalMarginProcessed = EFalse;

   467     TBool allVerticalValuesProcessed = EFalse;

   468     TBool allHorizontalValuesProcessed = EFalse;

   469 

   470     CXnProperty* maxHeightProperty = aNode.MaxHeightL();

   471     CXnProperty* maxWidthProperty = aNode.MaxWidthL();

   472     CXnProperty* minHeightProperty = aNode.MinHeightL();

   473     CXnProperty* minWidthProperty = aNode.MinWidthL();

   474 

   475     TRect contentRect( aNode.Rect() );

   476     TRect paddingRect( aNode.PaddingRect() );

   477     TRect borderRect( aNode.BorderRect() );

   478     TRect marginRect( aNode.MarginRect() );

   479     TRect normalFlowBorderRect( aNode.NormalFlowBorderRect() );

   480 

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

   482         aGraphicsDevice, aHorizontalUnitInPixels, aVerticalUnitInPixels );

   483 

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

   485         {

   486         // search for height property

   487         const TDesC8& attributeName = aAutoProperties[i];

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

   489             {

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

   491             TInt newHeight = aHeightToFit - size.iHeight;

   492 

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

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

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

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

   497             TRect normalFlowBorderRectDiff( SubtractRect ( normalFlowBorderRect,

   498                 contentRect ) );

   499 

   500             // grow height to fill the void

   501             contentRect.SetHeight( newHeight );

   502             paddingRect = AddRect( contentRect, paddingRectDiff );

   503             borderRect = AddRect( contentRect, borderRectDiff );

   504             normalFlowBorderRect = AddRect( contentRect,

   505                 normalFlowBorderRectDiff );

   506             marginRect = AddRect( contentRect, marginRectDiff );

   507 

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

   509             }

   510         }

   511 

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

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

   514         {

   515         if ( !allHorizontalValuesProcessed )

   516             {

   517             const TDesC8& attributeName = aAutoProperties[0];

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

   519                 {

   520                 TInt remainingWidth = aWidthToFit - size.iWidth;

   521                 if ( remainingWidth < 0 )

   522                     {

   523                     remainingWidth = 0;

   524                     }

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

   526                 TRect paddingRectDiff( SubtractRect( paddingRect,

   527                     contentRect ) );

   528                 TRect borderRectDiff( SubtractRect( borderRect,

   529                     contentRect ) );

   530                 TRect marginRectDiff( SubtractRect( marginRect,

   531                     contentRect ) );

   532                 TRect normalFlowBorderRectDiff( SubtractRect(

   533                     normalFlowBorderRect, contentRect ) );

   534 

   535                 // grow width to fill the void

   536                 contentRect.SetWidth( remainingWidth );

   537                 paddingRect = AddRect( contentRect, paddingRectDiff );

   538                 borderRect = AddRect( contentRect, borderRectDiff );

   539                 normalFlowBorderRect = AddRect( contentRect,

   540                     normalFlowBorderRectDiff );

   541                 marginRect = AddRect( contentRect, marginRectDiff );

   542 

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

   544                 }

   545 

   546             if ( attributeName ==

   547                  XnPropertyNames::style::common::KMarginLeft )

   548                 {

   549                 TInt remainingWidth = aWidthToFit - size.iWidth;

   550                 if ( remainingWidth < 0 )

   551                     {

   552                     remainingWidth = 0;

   553                     }

   554                 contentRect.Move( remainingWidth, 0 );

   555                 borderRect.Move( remainingWidth, 0 );

   556                 normalFlowBorderRect.Move( remainingWidth, 0 );

   557                 marginRect.Resize( remainingWidth, 0 );

   558                 paddingRect.Move( remainingWidth, 0 );

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

   560                 }

   561 

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

   563                 {

   564                 TInt remainingWidth = aWidthToFit - size.iWidth;

   565                 if ( remainingWidth < 0 )

   566                     {

   567                     remainingWidth = 0;

   568                     }

   569                 marginRect.Resize( remainingWidth, 0 );

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

   571                 }

   572 

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

   574                 {

   575                 TInt remainingHeight = aHeightToFit - size.iHeight;

   576                 if ( remainingHeight < 0 )

   577                     {

   578                     remainingHeight = 0;

   579                     }

   580                 marginRect.Resize( 0, remainingHeight );

   581                 marginRect.Move( 0, -remainingHeight );

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

   583                 }

   584 

   585             if ( attributeName == 

   586                  XnPropertyNames::style::common::KMarginBottom )

   587                 {

   588                 TInt remainingHeight = aHeightToFit - size.iHeight;

   589                 if ( remainingHeight < 0 )

   590                     {

   591                     remainingHeight = 0;

   592                     }

   593                 marginRect.Resize( 0, remainingHeight );

   594                 marginRect.Move( 0, -remainingHeight );

   595                 paddingRect.Move( 0, -remainingHeight );

   596                 borderRect.Move( 0, -remainingHeight );

   597                 normalFlowBorderRect.Move( 0, -remainingHeight );

   598                 contentRect.Move( 0, -remainingHeight );

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

   600                 }

   601             }

   602         }

   603     else

   604         {

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

   606             {

   607             const TDesC8& attributeName = aAutoProperties[i];

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

   609                 {

   610                 TInt remainingWidth = aWidthToFit - size.iWidth;

   611                 if ( remainingWidth < 0 )

   612                     {

   613                     remainingWidth = 0;

   614                     }

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

   616                 TRect paddingRectDiff( SubtractRect(

   617                     paddingRect, contentRect ) );

   618                 TRect borderRectDiff( SubtractRect(

   619                     borderRect, contentRect ) );

   620                 TRect marginRectDiff( SubtractRect(

   621                     marginRect, contentRect ) );

   622                 TRect normalFlowBorderRectDiff( SubtractRect(

   623                     normalFlowBorderRect, contentRect ) );

   624 

   625                 // grow width to fill the void

   626                 contentRect.SetWidth( remainingWidth );

   627                 paddingRect = AddRect( contentRect, paddingRectDiff );

   628                 borderRect = AddRect( contentRect, borderRectDiff );

   629                 normalFlowBorderRect = AddRect(

   630                     contentRect, normalFlowBorderRectDiff );

   631                 marginRect = AddRect( contentRect, marginRectDiff );

   632 

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

   634                 }

   635 

   636             // several auto properties

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

   638                 {

   639                 if ( !horizontalMarginProcessed )

   640                     {

   641                     // is right margin also set to AUTO?

   642                     CXnProperty* rightMargin = aNode.MarginRightL();

   643                     if ( rightMargin )

   644                         {

   645                         if ( IsPropertyAutoL( *rightMargin ) )

   646                             {

   647                             // both margins set to AUTO, values equal

   648                             TInt remainingWidth = aWidthToFit - size.iWidth;

   649                             if ( remainingWidth < 0 )

   650                                 {

   651                                 remainingWidth = 0;

   652                                 }

   653                             // move rect right to fill the void

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

   655                             marginRect.Resize( remainingWidth, 0 );

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

   657                             normalFlowBorderRect.Move( (

   658                                 remainingWidth / 2 ), 0 );

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

   660                             horizontalMarginProcessed = ETrue;

   661                             size = TSize( size.iWidth + remainingWidth,

   662                                 size.iHeight );

   663                             }

   664                         else

   665                             {

   666                             // only left margin set to AUTO

   667                             TInt remainingWidth = aWidthToFit - size.iWidth;

   668                             if ( remainingWidth < 0 )

   669                                 {

   670                                 remainingWidth = 0;

   671                                 }

   672                             // move rect right to fill the void

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

   674                             marginRect.Resize( remainingWidth, 0 );

   675                             borderRect.Move( remainingWidth, 0 );

   676                             normalFlowBorderRect.Move( remainingWidth, 0 );

   677                             paddingRect.Move( remainingWidth, 0 );

   678                             horizontalMarginProcessed = ETrue;

   679                             size = TSize( size.iWidth + remainingWidth,

   680                                 size.iHeight );

   681                             }

   682                         }

   683                     }

   684                 }

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

   686                 {

   687                 if ( !horizontalMarginProcessed )

   688                     {

   689                     // is left margin also set to AUTO?

   690                     CXnProperty* leftMargin = aNode.MarginLeftL();

   691                     if ( leftMargin )

   692                         {

   693                         if ( IsPropertyAutoL( *leftMargin ) )

   694                             {

   695                             // both margins set to AUTO, values equal

   696                             TInt remainingWidth = aWidthToFit - size.iWidth;

   697                             if ( remainingWidth < 0 )

   698                                 {

   699                                 remainingWidth = 0;

   700                                 }

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

   702                             marginRect.Resize( remainingWidth, 0 );

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

   704                             normalFlowBorderRect.Move( ( 

   705                                 remainingWidth / 2 ), 0 );

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

   707                             horizontalMarginProcessed = ETrue;

   708                             size = TSize( size.iWidth + remainingWidth,

   709                                 size.iHeight );

   710                             }

   711                         else

   712                             {

   713                             // only right margin set to AUTO

   714                             TInt remainingWidth = aWidthToFit - size.iWidth;

   715                             if ( remainingWidth < 0 )

   716                                 {

   717                                 remainingWidth = 0;

   718                                 }

   719                             marginRect.Resize( remainingWidth, 0 );

   720                             horizontalMarginProcessed = ETrue;

   721                             size = TSize( size.iWidth + remainingWidth,

   722                                 size.iHeight );

   723                             }

   724                         }

   725                     }

   726                 }

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

   728                 {

   729                 if ( !verticalMarginProcessed &&

   730                      !allVerticalValuesProcessed )

   731                     {

   732                     // is bottom margin also set to AUTO?

   733                     CXnProperty* bottomMargin = aNode.MarginBottomL();

   734                     if ( bottomMargin )

   735                         {

   736                         if ( IsPropertyAutoL( *bottomMargin ) )

   737                             {

   738                             // both margins set to AUTO, values equal

   739                             TInt remainingHeight = aHeightToFit - size.iHeight;

   740                             if ( remainingHeight < 0 )

   741                                 {

   742                                 remainingHeight = 0;

   743                                 }

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

   745                             marginRect.Resize( 0, remainingHeight );

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

   747                             normalFlowBorderRect.Move(

   748                                 0, ( remainingHeight / 2 ) );

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

   750                             verticalMarginProcessed = ETrue;

   751                             size = TSize( size.iWidth,

   752                                 size.iHeight + remainingHeight );

   753                             }

   754                         else

   755                             {

   756                             // only top margin set to AUTO

   757                             TInt remainingHeight = aHeightToFit - size.iHeight;

   758                             if ( remainingHeight < 0 )

   759                                 {

   760                                 remainingHeight = 0;

   761                                 }

   762                             marginRect.Resize( 0, remainingHeight );

   763                             marginRect.Move( 0, -remainingHeight );

   764                             verticalMarginProcessed = ETrue;

   765                             size = TSize( size.iWidth,

   766                                 size.iHeight + remainingHeight );

   767                             }

   768                         }

   769                     }

   770                 }

   771             if ( attributeName == 

   772                  XnPropertyNames::style::common::KMarginBottom )

   773                 {

   774                 if ( !verticalMarginProcessed && !allVerticalValuesProcessed )

   775                     {

   776                     // is top margin also set to AUTO?

   777                     CXnProperty* topMargin = aNode.MarginTopL();

   778                     if ( topMargin )

   779                         {

   780                         if ( IsPropertyAutoL( *topMargin ) )

   781                             {

   782                             // both margins set to AUTO, values equal

   783                             TInt remainingHeight =  aHeightToFit - size.iHeight;

   784                             if ( remainingHeight < 0 )

   785                                 {

   786                                 remainingHeight = 0;

   787                                 }

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

   789                             marginRect.Resize( 0, remainingHeight );

   790                             marginRect.Move( 0, -remainingHeight );

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

   792                             normalFlowBorderRect.Move(

   793                                 0, -( remainingHeight / 2 ) );

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

   795                             verticalMarginProcessed = ETrue;

   796                             size = TSize( size.iWidth,

   797                                 size.iHeight + remainingHeight );

   798                             }

   799                         else

   800                             {

   801                             // only bottom margin set to AUTO

   802                             TInt remainingHeight = aHeightToFit - size.iHeight;

   803                             if ( remainingHeight < 0 )

   804                                 {

   805                                 remainingHeight = 0;

   806                                 }

   807                             contentRect.Move( 0, -remainingHeight );

   808                             marginRect.Resize( 0, remainingHeight );

   809                             marginRect.Move( 0, -remainingHeight );

   810                             borderRect.Move( 0, -remainingHeight );

   811                             normalFlowBorderRect.Move(

   812                                 0, -remainingHeight );

   813                             paddingRect.Move( 0, -remainingHeight );

   814                             verticalMarginProcessed = ETrue;

   815                             size = TSize( size.iWidth,

   816                                 size.iHeight + remainingHeight );

   817                             }

   818                         }

   819                     }

   820                 }

   821             }

   822         }

   823     aNode.SetRect( contentRect );

   824     aNode.SetPaddingRect( paddingRect );

   825     aNode.SetBorderRect( borderRect );

   826     aNode.SetMarginRect( marginRect );

   827     aNode.SetNormalFlowBorderRect( normalFlowBorderRect );

   828     return contentRect.Size();

   829     }

   830 

   831 // -----------------------------------------------------------------------------

   832 // AutoStaticLRL()

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

   834 // layout horizontal

   835 // and direction left-to-right

   836 // -----------------------------------------------------------------------------

   837 //

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

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

   840     CGraphicsDevice& aGraphicsDevice, TReal aHorizontalUnitInPixels,

   841     TReal aVerticalUnitInPixels )

   842     {

   843     // Static positioning, horizontal, left to right

   844     TBool horizontalMarginProcessed = EFalse;

   845     TBool verticalMarginProcessed = EFalse;

   846     TBool allVerticalValuesProcessed = EFalse;

   847     TBool allHorizontalValuesProcessed = EFalse;

   848 

   849     CXnProperty* maxHeightProperty = aNode.MaxHeightL();

   850     CXnProperty* maxWidthProperty = aNode.MaxWidthL();

   851     CXnProperty* minHeightProperty = aNode.MinHeightL();

   852     CXnProperty* minWidthProperty = aNode.MinWidthL();

   853 

   854     TRect contentRect = aNode.Rect();

   855     TRect paddingRect = aNode.PaddingRect();

   856     TRect borderRect = aNode.BorderRect();

   857     TRect marginRect = aNode.MarginRect();

   858     TRect normalFlowBorderRect = aNode.NormalFlowBorderRect();

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

   860         aGraphicsDevice, aHorizontalUnitInPixels, aVerticalUnitInPixels );

   861 

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

   863         {

   864         // search for width property

   865         const TDesC8& attributeName = aAutoProperties[i];

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

   867             {

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

   869             TInt newWidth = aWidthToFit - size.iWidth;

   870 

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

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

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

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

   875             TRect normalFlowBorderRectDiff( SubtractRect( normalFlowBorderRect,

   876                 contentRect ) );

   877 

   878             // grow width to fill the void

   879             contentRect.SetWidth( newWidth );

   880             paddingRect = AddRect( contentRect, paddingRectDiff );

   881             borderRect = AddRect( contentRect, borderRectDiff );

   882             normalFlowBorderRect = AddRect(

   883                 contentRect, normalFlowBorderRectDiff );

   884             marginRect = AddRect( contentRect, marginRectDiff );

   885 

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

   887             allHorizontalValuesProcessed = ETrue;

   888             }

   889         }

   890 

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

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

   893         {

   894         if ( !allHorizontalValuesProcessed )

   895             {

   896             const TDesC8& attributeName = aAutoProperties[0];

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

   898                 {

   899                 TInt remainingHeight = aHeightToFit - size.iHeight;

   900                 if ( remainingHeight < 0 )

   901                     {

   902                     remainingHeight = 0;

   903                     }

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

   905                 TRect paddingRectDiff( SubtractRect(

   906                     paddingRect, contentRect ) );

   907                 TRect borderRectDiff( SubtractRect(

   908                     borderRect, contentRect ) );

   909                 TRect marginRectDiff( SubtractRect(

   910                     marginRect, contentRect ) );

   911                 TRect normalFlowBorderRectDiff( SubtractRect(

   912                     normalFlowBorderRect, contentRect ) );

   913 

   914                 // grow height to fill the void

   915                 contentRect.SetHeight( remainingHeight );

   916                 paddingRect = AddRect( contentRect, paddingRectDiff );

   917                 borderRect = AddRect( contentRect, borderRectDiff );

   918                 normalFlowBorderRect = AddRect(

   919                     contentRect, normalFlowBorderRectDiff );

   920                 marginRect = AddRect( contentRect, marginRectDiff );

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

   922                 }

   923 

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

   925                 {

   926                 TInt remainingWidth = aWidthToFit - size.iWidth;

   927                 if ( remainingWidth < 0 )

   928                     {

   929                     remainingWidth = 0;

   930                     }

   931                 // move rect right to fill the void

   932                 contentRect.Move( remainingWidth, 0 );

   933                 paddingRect.Move( remainingWidth, 0 );

   934                 borderRect.Move( remainingWidth, 0 );

   935                 normalFlowBorderRect.Move( remainingWidth, 0 );

   936                 marginRect.Resize( remainingWidth, 0 );

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

   938                 }

   939 

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

   941                 {

   942                 TInt remainingWidth = aWidthToFit - size.iWidth;

   943                 marginRect.Resize( remainingWidth, 0 );

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

   945                 }

   946 

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

   948                 {

   949                 TInt remainingHeight = aHeightToFit - size.iHeight;

   950                 // move rect right to fill the void

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

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

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

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

   955                 marginRect.Resize( 0, remainingHeight );

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

   957                 }

   958 

   959             if ( attributeName ==

   960                  XnPropertyNames::style::common::KMarginBottom )

   961                 {

   962                 TInt remainingHeight = aHeightToFit - size.iHeight;

   963                 if ( remainingHeight < 0 )

   964                     {

   965                     remainingHeight = 0;

   966                     }

   967                 marginRect.Resize( 0, remainingHeight );

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

   969                 }

   970             }

   971         }

   972     else

   973         {

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

   975             {

   976             const TDesC8& attributeName = aAutoProperties[i];

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

   978                 {

   979                 TInt remainingHeight = aHeightToFit - size.iHeight;

   980                 if ( remainingHeight < 0 )

   981                     {

   982                     remainingHeight = 0;

   983                     }

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

   985                 TRect paddingRectDiff( SubtractRect(

   986                     paddingRect, contentRect ) );

   987                 TRect borderRectDiff( SubtractRect(

   988                     borderRect, contentRect ) );

   989                 TRect marginRectDiff( SubtractRect(

   990                     marginRect, contentRect ) );

   991                 TRect normalFlowBorderRectDiff( SubtractRect(

   992                     normalFlowBorderRect, contentRect ) );

   993 

   994                 // grow height to fill the void

   995                 contentRect.SetHeight( remainingHeight );

   996                 paddingRect = AddRect( contentRect, paddingRectDiff );

   997                 borderRect = AddRect( contentRect, borderRectDiff );

   998                 normalFlowBorderRect = AddRect(

   999                     contentRect, normalFlowBorderRectDiff );

  1000                 marginRect = AddRect( contentRect, marginRectDiff );

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

  1002                 }

  1003 

  1004             // several auto properties

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

  1006                 {

  1007                 if ( !horizontalMarginProcessed )

  1008                     {

  1009                     // is right margin also set to AUTO?

  1010                     CXnProperty* rightMargin = aNode.MarginRightL();

  1011                     if ( rightMargin )

  1012                         {

  1013                         if ( IsPropertyAutoL( *rightMargin ) )

  1014                             {

  1015                             // both margins set to AUTO, values equal

  1016                             TInt remainingWidth = aWidthToFit - size.iWidth;

  1017                             if ( remainingWidth < 0 )

  1018                                 {

  1019                                 remainingWidth = 0;

  1020                                 }

  1021                             // move rect right to fill the void

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

  1023                             horizontalMarginProcessed = ETrue;

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

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

  1026                             normalFlowBorderRect.Move( (

  1027                                 remainingWidth / 2 ), 0 );

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

  1029                             size = TSize( size.iWidth + remainingWidth,

  1030                                 size.iHeight );

  1031                             }

  1032                         else

  1033                             {

  1034                             // only left margin set to AUTO

  1035                             TInt remainingWidth = aWidthToFit - size.iWidth;

  1036                             if ( remainingWidth < 0 )

  1037                                 {

  1038                                 remainingWidth = 0;

  1039                                 }

  1040                             // move rect right to fill the void

  1041                             contentRect.Move( remainingWidth, 0 );

  1042                             horizontalMarginProcessed = ETrue;

  1043                             marginRect.Move( remainingWidth, 0 );

  1044                             borderRect.Move( remainingWidth, 0 );

  1045                             normalFlowBorderRect.Move( remainingWidth, 0 );

  1046                             paddingRect.Move( remainingWidth, 0 );

  1047                             size = TSize( size.iWidth + remainingWidth,

  1048                                 size.iHeight );

  1049                             }

  1050                         }

  1051                     }

  1052                 }

  1053 

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

  1055                 {

  1056                 if ( !horizontalMarginProcessed )

  1057                     {

  1058                     // is left margin also set to AUTO?

  1059                     CXnProperty* leftMargin = aNode.MarginLeftL();

  1060                     if ( leftMargin )

  1061                         {

  1062                         if ( IsPropertyAutoL( *leftMargin ) )

  1063                             {

  1064                             // both margins set to AUTO, values equal

  1065                             TInt remainingWidth = aWidthToFit - size.iWidth;

  1066                             if ( remainingWidth < 0 )

  1067                                 {

  1068                                 remainingWidth = 0;

  1069                                 }

  1070                             // move rect right to fill the void

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

  1072                             horizontalMarginProcessed = ETrue;

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

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

  1075                             normalFlowBorderRect.Move( (

  1076                                 remainingWidth / 2 ), 0 );

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

  1078                             size = TSize( size.iWidth + remainingWidth,

  1079                                 size.iHeight );

  1080                             }

  1081                         else

  1082                             {

  1083                             // only right margin set to AUTO

  1084                             horizontalMarginProcessed = ETrue;

  1085                             }

  1086                         }

  1087                     }

  1088                 }

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

  1090                 {

  1091                 if ( !verticalMarginProcessed && !allVerticalValuesProcessed )

  1092                     {

  1093                     // is bottom margin also set to AUTO?

  1094                     CXnProperty* bottomMargin = aNode.MarginBottomL();

  1095                     if ( bottomMargin )

  1096                         {

  1097                         if ( IsPropertyAutoL( *bottomMargin ) )

  1098                             {

  1099                             // both margins set to AUTO, values equal

  1100                             TInt remainingHeight =  aHeightToFit - size.iHeight;

  1101                             if ( remainingHeight < 0 )

  1102                                 {

  1103                                 remainingHeight = 0;

  1104                                 }

  1105                             // move rect right to fill the void

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

  1107                             verticalMarginProcessed = ETrue;

  1108                             marginRect.Resize( 0, remainingHeight );

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

  1110                             normalFlowBorderRect.Move(

  1111                                 0, ( remainingHeight / 2 ) );

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

  1113                             size = TSize( size.iWidth, 

  1114                                 size.iHeight + remainingHeight );

  1115                             }

  1116                         else

  1117                             {

  1118                             // only top margin set to AUTO

  1119                             TInt remainingHeight =  aHeightToFit - size.iHeight;

  1120                             if ( remainingHeight < 0 )

  1121                                 {

  1122                                 remainingHeight = 0;

  1123                                 }

  1124                             // move rect right to fill the void

  1125                             contentRect.Move( 0, remainingHeight );

  1126                             verticalMarginProcessed = ETrue;

  1127                             marginRect.Resize( 0, remainingHeight );

  1128                             borderRect.Move( 0, remainingHeight );

  1129                             normalFlowBorderRect.Move( 0, remainingHeight );

  1130                             paddingRect.Move( 0, remainingHeight );

  1131                             size = TSize( size.iWidth,

  1132                                 size.iHeight + remainingHeight );

  1133                             }

  1134                         }