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:  Implementation part of bridge pattern in CXnNode

    15 *

    16 */

    17 

    18 // System includes

    19 #include <AknUtils.h>

    20 #include <utf.h>

    21 #include <mmf/common/mmfcontrollerpluginresolver.h>

    22 

    23 // User includes

    24 #include "xnnodeimpl.h"

    25 #include "xnnode.h"

    26 #include "xnpropertylist.h"

    27 #include "xnproperty.h"

    28 #include "xnuiengine.h"

    29 #include "xnappuiadapter.h"

    30 #include "xncontroladapter.h"

    31 #include "xnpopupcontroladapter.h"

    32 #include "xnmenuadapter.h"

    33 #include "xndomlist.h"

    34 #include "xndomdocument.h"

    35 #include "xnpointerarray.h"

    36 #include "xnodt.h"

    37 #include "xntype.h"

    38 #include "xndomnode.h"

    39 #include "xndomattribute.h"

    40 #include "xndompropertyvalue.h"

    41 #include "xnpopup.h"

    42 #include "c_xnutils.h"

    43 #include "xneditmode.h"

    44 #include "xneditor.h"

    45 #include "xntext.h"

    46 #include "xnhittest.h"

    47 #include "xnscrollablecontroladapter.h"

    48 #include "xnviewdata.h"

    49 #include "xnpanic.h"

    50 #include "xnlistquerydialogadapter.h"

    51 #include "xneffectmanager.h"

    52 #include "xnviewadapter.h"

    53 

    54 // Local constants

    55 _LIT8( KRef, "ref" );

    56 _LIT8( KId, "id" );

    57 _LIT8( KName, "name" );

    58 _LIT8( KToolTip, "tooltip" );

    59 _LIT8( KMenuBar, "menubar" );

    60 

    61 _LIT8( KActionsHandler, "actionshandler" );

    62 

    63 const TReal KS60ScrollbarDefaultWidth = 1.5;

    64 const TReal KS60ScrollbarDefaultMargin = 0.25;

    65 const TReal KS60ScrollbarDefaultWidthPenEnabled = 3;

    66 const TReal KS60ScrollbarDefaultMarginPenEnabled = 0.5;

    67 const TInt KUnitMaxLen = 2;

    68 const TInt KOneView = 1;

    69 

    70 _LIT8( KPseudoClassFocus, "focus" );

    71 _LIT8( KPseudoClassPressedDown, "presseddown" );

    72 _LIT8( KPseudoClassPassiveFocus, "passivefocus" );

    73 _LIT8( KPseudoClassHold, "hold" );

    74 _LIT8( KPseudoClassHover, "hover" );

    75 _LIT8( KPseudoClassLink, "link" );

    76 _LIT8( KPseudoClassVisited, "visited" );

    77 _LIT8( KPseudoClassActive, "active" );

    78 _LIT8( KPseudoClassEdit, "edit" );

    79 

    80 _LIT8( KCompound, "compound" );

    81 _LIT8( KTrue, "true" );

    82 _LIT8( KDisplay, "display" );

    83 _LIT8( KBlock, "block" );

    84 _LIT8( KNone, "none" );

    85 _LIT8( KGainEnd, "gainend" );

    86 _LIT8( KLoseEnd, "loseend" );

    87 

    88 // Local classes

    89 struct TXnTimedTrigger

    90     {

    91     CXnNodeImpl* iNodeImpl;

    92     CXnUiEngine* iEngine;

    93     CXnNode* iNode;

    94     CXnNode* iEventData;

    95     CXnDomNode* iActionNode;

    96     CXnDomNode* iTriggerNode;

    97     };

    98 

    99 struct CGridPropertyCache : public CBase

   100     {

   101     CXnProperty* iVisibleRows;

   102     CXnProperty* iGridColumns;

   103     CXnProperty* iGridOrientation;

   104     CXnProperty* iGridVerDirection;

   105     CXnProperty* iGridHorDirection;

   106     CXnProperty* iFocusHorLooping;

   107     CXnProperty* iFocusVerLooping;

   108     CXnProperty* iGridScrollBarWidth;

   109     CXnProperty* iGridScrollBarMargin;

   110     };

   111 

   112 struct CLayoutPropertyCache : public CBase

   113     {

   114     CLayoutPropertyCache() :

   115         iWidths( 1 ),

   116         iHeights( 1 ),

   117         iMarginLefts( 1 ),

   118         iMarginRights( 1 ),

   119         iBorderLefts( 1 ),

   120         iBorderRights( 1 ),

   121         iPaddingLefts( 1 ),

   122         iPaddingRights( 1 ),

   123         iMarginTops( 1 ),

   124         iMarginBottoms( 1 ),

   125         iBorderTops( 1 ),

   126         iBorderBottoms( 1 ),

   127         iPaddingTops( 1 ),

   128         iPaddingBottoms( 1 ),

   129         iBorderWidths( 1 ),

   130         iBlockProgressions( 1 ),

   131         iDirections( 1 ),

   132         iPositions( 1 ),

   133         iMaxHeights( 1 ),

   134         iMinHeights( 1 ),

   135         iMaxWidths( 1 ),

   136         iMinWidths( 1 ),

   137         iDisplays( 2 ),

   138         iVisibilities( 1 ),

   139         iLefts( 1 ),

   140         iRights( 1 ),

   141         iTops( 1 ),

   142         iBottoms( 1 ),

   143         iBorderLeftStyles( 1 ),

   144         iBorderRightStyles( 1 ),

   145         iBorderTopStyles( 1 ),

   146         iBorderBottomStyles( 1 ),

   147         iBorderStyles( 1 ),

   148         iDisplayPriorities( 1 ),

   149         iNavIndexes( 1 ),

   150         iBackgroundColors( 1 ),

   151         iBackgroundImages( 1 ),

   152         iFocusBackgrounds( 2 )

   153             {

   154             }

   155 

   156     ~CLayoutPropertyCache()

   157         {

   158         iWidths.Reset();

   159         iHeights.Reset();

   160         iMarginLefts.Reset();

   161         iMarginRights.Reset();

   162         iBorderLefts.Reset();

   163         iBorderRights.Reset();

   164         iPaddingLefts.Reset();

   165         iPaddingRights.Reset();

   166         iMarginTops.Reset();

   167         iMarginBottoms.Reset();

   168         iBorderTops.Reset();

   169         iBorderBottoms.Reset();

   170         iPaddingTops.Reset();

   171         iPaddingBottoms.Reset();

   172         iBorderWidths.Reset();

   173         iBlockProgressions.Reset();

   174         iDirections.Reset();

   175         iPositions.Reset();

   176         iMaxHeights.Reset();

   177         iMinHeights.Reset();

   178         iMaxWidths.Reset();

   179         iMinWidths.Reset();

   180         iDisplays.Reset();

   181         iVisibilities.Reset();

   182         iLefts.Reset();

   183         iRights.Reset();

   184         iTops.Reset();

   185         iBottoms.Reset();

   186         iBorderLeftStyles.Reset();

   187         iBorderRightStyles.Reset();

   188         iBorderTopStyles.Reset();

   189         iBorderBottomStyles.Reset();

   190         iBorderStyles.Reset();

   191         iDisplayPriorities.Reset();

   192         iNavIndexes.Reset();

   193         iBackgroundColors.Reset();

   194         iZIndexes.Reset();

   195         iBackgroundImages.Reset();

   196         iFocusBackgrounds.Reset();

   197         }

   198 

   199     CXnProperty* iWidth;

   200     RPointerArray< CXnProperty > iWidths;

   201     CXnProperty* iHeight;

   202     RPointerArray< CXnProperty > iHeights;

   203     CXnProperty* iMarginLeft;

   204     RPointerArray< CXnProperty > iMarginLefts;

   205     CXnProperty* iMarginRight;

   206     RPointerArray< CXnProperty > iMarginRights;

   207     CXnProperty* iBorderLeft;

   208     RPointerArray< CXnProperty > iBorderLefts;

   209     CXnProperty* iBorderRight;

   210     RPointerArray< CXnProperty > iBorderRights;

   211     CXnProperty* iPaddingLeft;

   212     RPointerArray< CXnProperty > iPaddingLefts;

   213     CXnProperty* iPaddingRight;

   214     RPointerArray< CXnProperty > iPaddingRights;

   215     CXnProperty* iMarginTop;

   216     RPointerArray< CXnProperty > iMarginTops;

   217     CXnProperty* iMarginBottom;

   218     RPointerArray< CXnProperty > iMarginBottoms;

   219     CXnProperty* iBorderTop;

   220     RPointerArray< CXnProperty > iBorderTops;

   221     CXnProperty* iBorderBottom;

   222     RPointerArray< CXnProperty > iBorderBottoms;

   223     CXnProperty* iPaddingTop;

   224     RPointerArray< CXnProperty > iPaddingTops;

   225     CXnProperty* iPaddingBottom;

   226     RPointerArray< CXnProperty > iPaddingBottoms;

   227     CXnProperty* iBorderWidth;

   228     RPointerArray< CXnProperty > iBorderWidths;

   229     CXnProperty* iBlockProgression;

   230     RPointerArray< CXnProperty > iBlockProgressions;

   231     CXnProperty* iDirection;

   232     RPointerArray< CXnProperty > iDirections;

   233     CXnProperty* iPosition;

   234     RPointerArray< CXnProperty > iPositions;

   235     CXnProperty* iMaxHeight;

   236     RPointerArray< CXnProperty > iMaxHeights;

   237     CXnProperty* iMinHeight;

   238     RPointerArray< CXnProperty > iMinHeights;

   239     CXnProperty* iMaxWidth;

   240     RPointerArray< CXnProperty > iMaxWidths;

   241     CXnProperty* iMinWidth;

   242     RPointerArray< CXnProperty > iMinWidths;

   243     CXnProperty* iDisplay;

   244     RPointerArray< CXnProperty > iDisplays;

   245     CXnProperty* iVisibility;

   246     RPointerArray< CXnProperty > iVisibilities;

   247     CXnProperty* iLeft;

   248     RPointerArray< CXnProperty > iLefts;

   249     CXnProperty* iRight;

   250     RPointerArray< CXnProperty > iRights;

   251     CXnProperty* iTop;

   252     RPointerArray< CXnProperty > iTops;

   253     CXnProperty* iBottom;

   254     RPointerArray< CXnProperty > iBottoms;

   255     CXnProperty* iBorderLeftStyle;

   256     RPointerArray< CXnProperty > iBorderLeftStyles;

   257     CXnProperty* iBorderRightStyle;

   258     RPointerArray< CXnProperty > iBorderRightStyles;

   259     CXnProperty* iBorderTopStyle;

   260     RPointerArray< CXnProperty > iBorderTopStyles;

   261     CXnProperty* iBorderBottomStyle;

   262     RPointerArray< CXnProperty > iBorderBottomStyles;

   263     CXnProperty* iBorderStyle;

   264     RPointerArray< CXnProperty > iBorderStyles;

   265     CXnProperty* iBorderImage;

   266     CXnProperty* iDisplayPriority;

   267     RPointerArray< CXnProperty > iDisplayPriorities;

   268     CXnProperty* iNavIndex;

   269     RPointerArray< CXnProperty > iNavIndexes;

   270     CXnProperty* iZIndex;

   271     RPointerArray< CXnProperty > iZIndexes;

   272     CXnProperty* iBackgroundColor;

   273     RPointerArray< CXnProperty > iBackgroundColors;

   274     CXnProperty* iBackgroundImage;

   275     RPointerArray< CXnProperty > iBackgroundImages;

   276     CXnProperty* iFocusBackground;

   277     RPointerArray< CXnProperty > iFocusBackgrounds;

   278     };

   279 

   280 // Local function prototypes

   281 static TBool IsTriggerRunnableL( CXnDomNode& aTriggerNode );

   282 static CXnNode* RefNodeL(

   283     CXnNodeImpl* aThis, CXnProperty* aRef, CXnUiEngine* aUiEngine );

   284 static const TDesC8* CheckRefAttributeL( CXnProperty* aRef );

   285 static TBool DoMatchTriggerForKeyEventL(

   286     const TKeyEvent& aKeyEvent,

   287     TEventCode aType,

   288     CXnDomNode& aTriggerNode );

   289 static void GetFocusCandidatesL(

   290     CXnNodeImpl* aThis, CXnUiEngine& aEngine, CXnDomNode& aEventNode,

   291     RPointerArray< CXnNode >& aFocusCandidates );

   292 static void RunAppUiNotificationL( CXnUiEngine& aEngine, CXnNode& aNode,

   293     CXnDomNode& aEventNode, CXnDomNode& aTriggerNode, CXnNode& aEventData );

   294 static void RunAppExit( CXnUiEngine& aEngine );

   295 static void RunFullScreenEffectL(

   296     CXnUiEngine& aEngine, CXnDomNode& aEventNode );

   297 static void RunActivateViewL(

   298     CXnNodeImpl* aThis, CXnUiEngine& aEngine, CXnDomNode& aEventNode );

   299 static void RunActivateNextViewL( CXnUiEngine& aEngine );

   300 static void RunActivatePreviousViewL( CXnUiEngine& aEngine );

   301 static void RunAddViewL( CXnUiEngine& aEngine );

   302 static void RunRemoveViewL( CXnUiEngine& aEngine );

   303 static void RunActivateL(

   304     CXnNodeImpl* aThis, CXnUiEngine& aEngine, CXnDomNode& aEventNode );

   305 static void RunDeactivateL(

   306     CXnNodeImpl* aThis, CXnUiEngine& aEngine, CXnDomNode& aEventNode );

   307 static void RunSystemSetPCDataL(

   308     CXnNodeImpl* aThis, CXnUiEngine& aEngine, const TDesC8& aId,

   309     const TDesC8& aData );

   310 static void GetNumberValues( const TDesC8& aData, TReal& aNumber,

   311     CXnDomPropertyValue::TPrimitiveValueType& aValueType );

   312 static void RunSystemSetNumberL( CXnUiEngine& aEngine, CXnNode* aNode,

   313     const TDesC8& aName, const RPointerArray< HBufC8 >& aValues );

   314 static void RunSystemSetRGBL( CXnUiEngine& aEngine, CXnNode* aNode,

   315     const TDesC8& aName, const RPointerArray< HBufC8 >& aValues );

   316 static void RunSystemSetStringL(

   317     CXnUiEngine& aEngine, CXnNode* aNode, const TDesC8& aName,

   318     const RPointerArray< HBufC8 >& aValues,

   319     const CXnDomPropertyValue::TPrimitiveValueType aValueType );

   320 static void GetSystemSetDataL( CXnDomNode& aDomNode, HBufC8*& aId,

   321     const TDesC8** aPseudoClass = NULL, const TDesC8** aName = NULL,

   322     RPointerArray< HBufC8 >* aValues = NULL, const TDesC8** aType = NULL,

   323     TBool aSettings = EFalse, const TDesC8& aProvidedId = KNullDesC8,

   324     const TDesC8** aClassId = NULL );

   325 static void RunSystemSetL(

   326     CXnNodeImpl* aThis, CXnUiEngine& aEngine, CXnDomNode& aEventNode,

   327     TBool aSettings = EFalse, const TDesC8& aId = KNullDesC8 );

   328 static void RunTryDisplayingMenuL(

   329     CXnUiEngine& aEngine, CXnDomNode& aEventNode );

   330 static void RunTryDisplayingStylusPopupL(

   331     CXnNodeImpl* aThis, CXnNode& aNode, CXnUiEngine& aEngine,

   332     CXnDomNode& aEventNode );

   333 static void RunTryDisplayingListQueryDialogL(

   334     CXnNodeImpl* aThis, CXnUiEngine& aEngine, CXnDomNode& aEventNode );

   335 static void RunSetInitialFocusL( CXnUiEngine& aEngine );

   336 static void ResolveTriggerDelayL(

   337     CXnUiEngine& aEngine, CXnDomNode& aNode, TInt& aDelay );

   338 static TBool RunEventL(

   339     CXnNodeImpl* aThis, CXnUiEngine& aEngine, CXnNode& aNode,

   340     CXnDomNode& aEventNode, CXnDomNode& aTriggerNode, CXnNode& aEventData );

   341 static void RunEventsL( CXnNodeImpl* aThis, CXnUiEngine& aEngine, CXnNode& aNode,

   342     CXnDomNode& aActionNode, CXnDomNode& aTriggerNode, CXnNode& aEventData );

   343 static TBool DoMatchTriggerForHighLevelKeyEventL( CXnNode& aNode,

   344     const TKeyEvent& aKeyEvent, TEventCode aType, const TDesC8& highLevelKey );

   345 static TBool MatchTriggerForKeyEventL(

   346     CXnNodeImpl* aThis, CXnUiEngine& aEngine, CXnNode& aNode,

   347     const TKeyEvent& aKeyEvent, TEventCode aType,

   348     CXnDomNode& aActionNode, CXnDomNode& aTriggerNode );

   349 static TBool MatchTriggerForEventL(

   350     CXnNodeImpl* aThis, CXnUiEngine& aEngine, CXnNode& aNode,

   351     CXnNode& aEventData, CXnDomNode& aActionNode, CXnDomNode& aTriggerNode,

   352     TInt aSource );

   353 static TBool MatchActionForKeyEventL(

   354     CXnNodeImpl* aThis, CXnUiEngine& aEngine, CXnNode& aNode,

   355     const TKeyEvent& aKeyEvent, TEventCode aType, CXnDomNode& aActionNode );

   356 static TBool IsTriggerActiveL( CXnDomNode& aNode );

   357 static TBool MatchActionForEventL(

   358     CXnNodeImpl* aThis, CXnUiEngine& aEngine, CXnNode& aNode,

   359     CXnNode& aEventData, CXnDomNode& aActionNode, TInt aSource );

   360 static CXnNode* FindLoopedFocusableNodeL( CXnNode& aNode, TBool aForward );

   361 static CXnNode* FindNextFocusableNodeByNavIndexL( CXnNode& aNode, TBool aForward );

   362 static TBool FindNextFocusableNodeL( CXnNode& aNode, TBool aForward );

   363 static CXnNode* FindNextNodeFromRightL(

   364     RPointerArray< CXnNode >& aArray, CXnNode& aNode, TBool stayInNamespace = EFalse, CXnUiEngine* aEngine = NULL );

   365 static CXnNode* FindNextNodeFromLeftL(

   366     RPointerArray< CXnNode >& aArray, CXnNode& aNode, TBool stayInNamespace = EFalse, CXnUiEngine* aEngine = NULL );

   367 static CXnNode* FindNextNodeFromBelowL(

   368     RPointerArray< CXnNode >& aArray, CXnNode& aNode, TBool stayInNamespace = EFalse );

   369 static CXnNode* FindNextNodeFromAboveL(

   370     RPointerArray< CXnNode >& aArray, CXnNode& aNode, TBool stayInNamespace = EFalse );

   371 static CXnNode* FindPluginNode( CXnNode& aNode );

   372 static TBool DoInternalFocusChangeL(

   373     CXnUiEngine& aEngine, CXnNode& aNode, const TKeyEvent& aKeyEvent,

   374     TEventCode aType );

   375 static TBool DoTriggerKeyEventL(

   376     CXnNodeImpl* aThis, CXnUiEngine& aEngine, CXnNode& aNode,

   377     const TKeyEvent& aKeyEvent, TEventCode aType );

   378 static void DoTriggerEventL(

   379     CXnNodeImpl* aThis, CXnUiEngine& aEngine, CXnNode& aNode,

   380     CXnNode& aActionsParent, CXnNode& aEventData, TInt aSource );

   381 static TBool DoReceiveFocusL( CXnNode& aNode, CXnUiEngine& aEngine );

   382 static CXnNode* BuildActivateTriggerNodeL( CXnUiEngine& aUiEngine );

   383 static void DoSetActiveL( CXnNode& aNode, CXnUiEngine& aUiEngine );

   384 static void InformPropertyChangeL( CXnNode& aNode, CXnProperty* aProperty = NULL );

   385 static CXnNode* BuildEventTypeNodeL( TEventCode aType, CXnUiEngine& aUiEngine );

   386 static CXnNode* BuildModifiersNodeL(

   387     const TKeyEvent& aKeyEvent, CXnUiEngine& aUiEngine );

   388 static CXnNode* BuildKeyCodeNodeL(

   389     const TKeyEvent& aKeyEvent, CXnUiEngine& aUiEngine );

   390 static CXnNode* BuildScanCodeNodeL(

   391     const TKeyEvent& aKeyEvent, CXnUiEngine& aUiEngine );

   392 static CXnNode* BuildRepeatsNodeL(

   393     const TKeyEvent& aKeyEvent, CXnUiEngine& aUiEngine );

   394 static void BuildPropertyNodesL( CXnNode& aNode, const TKeyEvent& aKeyEvent,

   395     TEventCode aType, CXnUiEngine& aUiEngine );

   396 static CXnNode* BuildKeyTriggerNodeL( const TKeyEvent& aKeyEvent, TEventCode aType,

   397     CXnUiEngine& aUiEngine );

   398 static CXnDomPropertyValue* GetNavIndexL( CXnNode& aNode );

   399 static CXnNode* BackwardL( CXnNode& aNode );

   400 static CXnNode* ForwardL( CXnNode& aNode );

   401 static CXnNode* BackwardLoopL( CXnNode& aNode );

   402 static CXnNode* ForwardLoopL( CXnNode& aNode );

   403 static TInt CompareNavIndexesL(

   404     CXnDomPropertyValue* aCurrentPropertyValue,

   405     CXnDomPropertyValue* aNextPropertyValue );

   406 static void ReplaceOrAppend(

   407     CXnProperty* aProperty, RPointerArray< CXnProperty >& aArray,

   408     TBool aAppendOnly );

   409 static TBool DisplayValueMatchL( CXnNode& aNode, const TDesC8& aDisplayValue );

   410 static void SetStringPropertyToNodeL(

   411     CXnDomStringPool& aStringPool, CXnNode& aNode,

   412     const TDesC8& aPropertyName, const TDesC8& aPropertyValue );

   413 static void SetFloatPropertyToNodeL(

   414     CXnDomStringPool& aStringPool, CXnNode& aNode,

   415     const TDesC8& aPropertyName, TReal aPropertyValue,

   416     CXnDomPropertyValue::TPrimitiveValueType aValueType );

   417 static CXnNode* FindYoungestSiblingWithDisplayL(

   418     RPointerArray< CXnNode >& aSiblingArray,

   419     const TDesC8& aDisplayValue,

   420     TInt& aIndex );

   421 static CXnNode* FindOldestSiblingWithDisplayL(

   422     RPointerArray< CXnNode >& aSiblingArray,

   423     const TDesC8& aDisplayValue,

   424     TInt& aIndex );

   425 static TBool IsCompoundNodeL( CXnNode* aNode );

   426 static void NotifyScrollNodeL( CXnNode* aNode, TBool aBegin, TBool aGainEnd );

   427 static void DoCompoundNodeBeginKeyL(

   428     RPointerArray< CXnNode >& aChildren, CXnNode* aFocusedNode );

   429 static void DoCompoundNodeEndKeyL(

   430     RPointerArray< CXnNode >& aChildren, CXnNode* aFocusedNode );

   431 static void DoCompoundNodeScrollingL(

   432     CXnNode& aFocusedNode,

   433     const TKeyEvent& aKeyEvent,

   434     TEventCode aType );

   435 static CXnNode* BuildTriggerNodeL(

   436     CXnUiEngine& aUiEngine, const TDesC8& aTriggerName );

   437 static CXnNode* IsNodeNavigableL( CXnNode* aParent );

   438 static TBool IsNodeNavigableL( CXnNode& aNode, TBool aIgnoreDropped = EFalse );

   439 static TInt DirtyLevelFromPropertyL( CXnNode& aNode, const TDesC8& aPropName );

   440 static TBool IsNodeDisplayedL(

   441     CXnNode& aNode, TBool aCheckVisiblity = EFalse, TBool aCheckParent = ETrue );

   442 static void EnableStatePropertyL(

   443     CXnNode& aNode,

   444     CXnDomProperty::TPseudoClass aPseudoClass,

   445     CXnProperty* ( CXnNode::* aGetCachedPropertyL )(),

   446     CXnProperty*& aProperty,

   447     RPointerArray< CXnProperty >& aArray, TInt& aLevel,

   448     TBool aInformChange = EFalse );

   449 static void DisableStatePropertyL(

   450     CXnNode& aNode,

   451     CXnDomProperty::TPseudoClass aPseudoClass,

   452     CXnProperty* ( CXnNode::* aGetCachedPropertyL )(),

   453     CXnProperty*& aProperty,

   454     RPointerArray< CXnProperty >& aArray,

   455     RArray< CXnDomProperty::TPseudoClass >& aStates, TInt& aLevel,

   456     TBool aInformChange = EFalse );

   457 static TBool MatchTitleScrollTriggerL(

   458     CXnNode& aEventData, CXnDomNode& aTriggerNode );

   459 

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

   461 

   462 // -----------------------------------------------------------------------------

   463 // Checks whether trigger is runnable

   464 // -----------------------------------------------------------------------------

   465 //

   466 TBool IsTriggerRunnableL( CXnDomNode& aTriggerNode )

   467     {

   468     TBool ret( ETrue );

   469     CXnNode* layoutNode = aTriggerNode.LayoutNode();

   470     if ( layoutNode )

   471         {

   472         CXnProperty* display =

   473             layoutNode->GetPropertyL( XnPropertyNames::style::common::KDisplay );

   474 

   475         if ( display && display->StringValue() ==

   476              XnPropertyNames::style::common::display::KNone )

   477             {

   478             ret = EFalse;

   479             }

   480         }

   481     return ret;

   482     }

   483 

   484 // -----------------------------------------------------------------------------

   485 // DirtyLevelFromPropertyL

   486 // -----------------------------------------------------------------------------

   487 //

   488 static TInt DirtyLevelFromPropertyL( CXnNode& aNode, const TDesC8& aPropName )

   489     {

   490     if ( aPropName == XnPropertyNames::style::common::KDisplay ||

   491         aPropName == XnPropertyNames::style::common::KBlockProgression ||

   492         aPropName == XnPropertyNames::style::common::KDirection ||

   493         aPropName == XnPropertyNames::style::common::KPosition ||

   494         aPropName == XnPropertyNames::style::common::KTop ||

   495         aPropName == XnPropertyNames::style::common::KLeft ||

   496         aPropName == XnPropertyNames::style::common::KBottom ||

   497         aPropName == XnPropertyNames::style::common::KRight ||

   498         aPropName == XnPropertyNames::style::common::KWidth ||

   499         aPropName == XnPropertyNames::style::common::KHeight ||

   500         aPropName == XnPropertyNames::style::common::KMinWidth ||

   501         aPropName == XnPropertyNames::style::common::KMaxWidth ||

   502         aPropName == XnPropertyNames::style::common::KMinHeight ||

   503         aPropName == XnPropertyNames::style::common::KMaxHeight ||

   504         aPropName == XnPropertyNames::style::common::KS60DisplayPriority ||

   505         aPropName == XnPropertyNames::style::common::KMarginTop ||

   506         aPropName == XnPropertyNames::style::common::KMarginRight ||

   507         aPropName == XnPropertyNames::style::common::KMarginBottom ||

   508         aPropName == XnPropertyNames::style::common::KMarginLeft ||

   509         aPropName == XnPropertyNames::style::common::KBorderWidth ||

   510         aPropName == XnPropertyNames::style::common::KBorderTopWidth ||

   511         aPropName == XnPropertyNames::style::common::KBorderRightWidth ||

   512         aPropName == XnPropertyNames::style::common::KBorderBottomWidth ||

   513         aPropName == XnPropertyNames::style::common::KBorderLeftWidth ||

   514         aPropName == XnPropertyNames::style::common::KBorderLeftWidth ||

   515         aPropName == XnPropertyNames::style::common::KPaddingRight ||

   516         aPropName == XnPropertyNames::style::common::KPaddingBottom ||

   517         aPropName == XnPropertyNames::style::common::KPaddingLeft )

   518         {

   519         TInt retval( XnDirtyLevel::ELayoutAndRenderSiblings );

   520 

   521         CXnProperty* prop( aNode.PositionL() );

   522 

   523         if ( prop )

   524             {

   525             const TDesC8& value( prop->StringValue() );

   526 

   527             if ( value == XnPropertyNames::style::common::position::KAbsolute ||

   528                  value == XnPropertyNames::style::common::position::KFloating )

   529                 {

   530                 retval = XnDirtyLevel::ELayoutAndRender;

   531                 }

   532             }

   533 

   534         if ( aNode.Type()->Type() == KToolTip )

   535             {

   536             retval = XnDirtyLevel::ELayoutAndRender;

   537             }

   538 

   539         return retval;

   540         }

   541     else

   542         {

   543         return XnDirtyLevel::ERender;

   544         }

   545     }

   546 

   547 // -----------------------------------------------------------------------------

   548 // IsNodeDisplayedL

   549 // Check whether a node is displayed or not

   550 // -----------------------------------------------------------------------------

   551 //

   552 static TBool IsNodeDisplayedL(

   553     CXnNode& aNode,

   554     TBool aCheckVisiblity,

   555     TBool aCheckParent )

   556     {

   557     if ( !aNode.IsLayoutCapable() )

   558         {

   559         return EFalse;

   560         }

   561 

   562     if ( aCheckVisiblity )

   563         {

   564         CXnProperty* visibilityProp( aNode.VisibilityL() );

   565 

   566         // Am I visible?

   567         if ( visibilityProp )

   568             {

   569             const TDesC8& visibility( visibilityProp->StringValue() );

   570 

   571             if ( visibility != XnPropertyNames::style::common::visibility::KVisible )

   572                 {

   573                 return EFalse;

   574                 }

   575             }

   576         }

   577 

   578     // Am I displayed?

   579     CXnProperty* displayProp( aNode.DisplayL() );

   580 

   581     if ( displayProp )

   582         {

   583         const TDesC8& display( displayProp->StringValue() );

   584 

   585         if ( display != XnPropertyNames::style::common::display::KBlock )

   586             {

   587             return EFalse;

   588             }

   589         }

   590 

   591     if ( aCheckParent )

   592         {

   593         CXnNode* parent( aNode.Parent() );

   594 

   595         // Is my parent displayed?

   596         for ( ; parent; parent = parent->Parent() )

   597             {

   598             CXnProperty* displayProp( parent->DisplayL() );

   599 

   600             if ( displayProp )

   601                 {

   602                 const TDesC8& display( displayProp->StringValue() );

   603 

   604                 if ( display != XnPropertyNames::style::common::display::KBlock )

   605                     {

   606                     return EFalse;

   607                     }

   608                 }

   609             }

   610         }

   611 

   612     return ETrue;

   613     }

   614 

   615 // -----------------------------------------------------------------------------

   616 // IsNodeNavigableL

   617 // Check whether a node or its child is navigable, ignores dropped state

   618 // -----------------------------------------------------------------------------

   619 //

   620 static CXnNode* IsNodeNavigableL( CXnNode* aParent )

   621     {

   622     if ( IsNodeNavigableL( *aParent, ETrue ) )

   623         {

   624         return aParent;

   625         }

   626 

   627     RPointerArray< CXnNode >& children( aParent->Children() );

   628 

   629     TInt count( children.Count() );

   630 

   631     CXnNode* retval = NULL;

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

   633         {

   634         retval = IsNodeNavigableL( children[i] );

   635         if ( retval )

   636             {

   637             return retval;

   638             }

   639         }

   640 

   641     return NULL;

   642     }

   643 

   644 // -----------------------------------------------------------------------------

   645 // IsNodeNavigableL()

   646 // Check if node can be navigated

   647 // -----------------------------------------------------------------------------

   648 //

   649 static TBool IsNodeNavigableL( CXnNode& aNode, TBool aIgnoreDropped )

   650     {

   651     if ( !aNode.IsLayoutCapable() || ( !aIgnoreDropped && aNode.IsDropped() ) )

   652         {

   653         return EFalse;

   654         }

   655 

   656     CXnProperty* displayProp( aNode.DisplayL() );

   657 

   658     if ( displayProp )

   659         {

   660         const TDesC8& display( displayProp->StringValue() );

   661 

   662         if ( display != XnPropertyNames::style::common::display::KBlock )

   663             {

   664             return EFalse;

   665             }

   666         }

   667 

   668     CXnProperty* visibilityProp( aNode.VisibilityL() );

   669 

   670     if ( visibilityProp )

   671         {

   672         const TDesC8& visibility( visibilityProp->StringValue() );

   673 

   674         if ( visibility != XnPropertyNames::style::common::visibility::KVisible )

   675             {

   676             return EFalse;

   677             }

   678         }

   679 

   680     CXnProperty* focusableProp(

   681         aNode.GetPropertyL( XnPropertyNames::common::KFocusable ) );

   682 

   683     if ( focusableProp )

   684         {

   685         const TDesC8& focus( focusableProp->StringValue() );

   686 

   687         if ( focus != XnPropertyNames::KTrue )

   688             {

   689             return EFalse;

   690             }

   691         }

   692     else

   693         {

   694         return EFalse;

   695         }

   696     CXnProperty* disabledProp(

   697         aNode.GetPropertyL( XnPropertyNames::common::KDisabled ) );

   698 

   699     if ( disabledProp )

   700         {

   701         const TDesC8& disabled( disabledProp->StringValue() );

   702 

   703         if ( disabled == XnPropertyNames::KTrue )

   704             {

   705             return EFalse;

   706             }

   707         }

   708 

   709     // The node can be navigated. Then check parents display and visibilty properties

   710     CXnNode* parent( aNode.Parent() );

   711 

   712     for ( ; parent; parent = parent->Parent() )

   713         {

   714         CXnProperty* displayProp( parent->DisplayL() );

   715 

   716         if ( displayProp )

   717             {

   718             const TDesC8& display( displayProp->StringValue() );

   719 

   720             if ( display != XnPropertyNames::style::common::display::KBlock )

   721                 {

   722                 return EFalse;

   723                 }

   724             }

   725 

   726         CXnProperty* visibilityProp( parent->VisibilityL() );

   727 

   728         if ( visibilityProp )

   729             {

   730             const TDesC8& visibility( visibilityProp->StringValue() );

   731 

   732             if ( visibility != XnPropertyNames::style::common::visibility::KVisible )

   733                 {

   734                 return EFalse;

   735                 }

   736             }

   737         }

   738 

   739     return ETrue;

   740     }

   741 

   742 // -----------------------------------------------------------------------------

   743 // EnableStatePropertyL()

   744 // -----------------------------------------------------------------------------

   745 //

   746 static void EnableStatePropertyL(

   747     CXnNode& aNode,

   748     CXnDomProperty::TPseudoClass aPseudoClass,

   749     CXnProperty* ( CXnNode::* aGetCachedPropertyL )(),

   750     CXnProperty*& aProperty,

   751     RPointerArray< CXnProperty >& aArray, TInt& aLevel,

   752     TBool aInformChange )

   753     {

   754     TBool doInform( EFalse );

   755 

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

   757         {

   758         if ( aArray[i]->Property()->PseudoClass() == aPseudoClass )

   759             {

   760             CXnProperty* temp( aArray[i] );

   761 

   762             if ( aLevel < XnDirtyLevel::ELayoutAndRenderSiblings ||

   763                  aInformChange )

   764                 {

   765                 TInt level( XnDirtyLevel::ENone );

   766 

   767                 // Get current cached prop

   768                 CXnProperty* prop( ( aNode.*aGetCachedPropertyL )() );

   769 

   770                 if ( !temp && prop )

   771                     {

   772                     level = DirtyLevelFromPropertyL(

   773                         aNode, prop->Property()->Name() );

   774                     }

   775                 else if ( ( temp && !prop ) ||

   776                           ( temp && prop && !prop->EqualsL( *temp ) ) )

   777                     {

   778                     level = DirtyLevelFromPropertyL(

   779                         aNode, temp->Property()->Name() );

   780                     }

   781 

   782                 if ( aInformChange && ( level != XnDirtyLevel::ENone ) )

   783                     {

   784                     doInform = ETrue;

   785                     }

   786 

   787                 if ( level > aLevel && aNode.IsLayoutCapable())

   788                     {

   789                     aLevel = level;

   790                     }

   791                 }

   792 

   793             aProperty = temp;

   794 

   795             if ( doInform )

   796                 {

   797                 // Property is changed

   798                 InformPropertyChangeL( aNode, temp );

   799                 }

   800 

   801             break;

   802             }

   803         }

   804     }

   805 

   806 // -----------------------------------------------------------------------------

   807 // DisableStatePropertyL()

   808 // -----------------------------------------------------------------------------

   809 //

   810 static void DisableStatePropertyL(

   811     CXnNode& aNode,

   812     CXnDomProperty::TPseudoClass aPseudoClass,

   813     CXnProperty* ( CXnNode::* aGetCachedPropertyL )(),

   814     CXnProperty*& aProperty,

   815     RPointerArray< CXnProperty >& aArray,

   816     RArray< CXnDomProperty::TPseudoClass >& aStates, TInt& aLevel,

   817     TBool aInformChange )

   818     {

   819     CXnProperty* currentStateProperty( NULL );

   820 

   821     TBool doInform( EFalse );

   822 

   823     if ( aProperty && aProperty->Property()->PseudoClass() == aPseudoClass )

   824         {

   825         // Is there an other pseudo state where to return?

   826         for ( TInt i = aArray.Count() - 1; !currentStateProperty && i >= 0; --i )

   827             {

   828             for ( TInt j = aStates.Count() - 1; j >= 0; --j )

   829                 {

   830                 if ( aArray[i]->Property()->PseudoClass() == aStates[j] &&

   831                      aArray[i]->Property()->PseudoClass() != aPseudoClass )

   832                     {

   833                     currentStateProperty = aArray[i];

   834                     break;

   835                     }

   836                 }

   837             }

   838 

   839         // No, use the property from state "none"

   840         for ( TInt i = aArray.Count() - 1; !currentStateProperty && i >= 0; --i )

   841             {

   842             for ( TInt j = aStates.Count() - 1; j >= 0; --j )

   843                 {

   844                 if ( aArray[i]->Property()->PseudoClass() == CXnDomProperty::ENone &&

   845                      aArray[i]->Property()->PseudoClass() != aPseudoClass )

   846                     {

   847                     currentStateProperty = aArray[i];

   848                     break;

   849                     }

   850                 }

   851             }

   852 

   853         CXnProperty* temp( currentStateProperty );

   854 

   855         if ( aLevel < XnDirtyLevel::ELayoutAndRenderSiblings || aInformChange )

   856             {

   857             TInt level( XnDirtyLevel::ENone );

   858 

   859             // Get current cached prop

   860             CXnProperty* prop( ( aNode.*aGetCachedPropertyL )() );

   861 

   862             if ( !temp && prop )

   863                 {

   864                 level = DirtyLevelFromPropertyL( aNode, prop->Property()->Name() );

   865                 }

   866             else if ( ( temp && !prop ) || ( temp && prop && !prop->EqualsL( *temp ) ) )

   867                 {

   868                 level = DirtyLevelFromPropertyL( aNode, temp->Property()->Name() );

   869                 }

   870 

   871             if ( aInformChange && ( level != XnDirtyLevel::ENone ) )

   872                 {

   873                 doInform = ETrue;

   874                 }

   875 

   876             if ( level > aLevel && aNode.IsLayoutCapable())

   877                 {

   878                 aLevel = level;

   879                 }

   880             }

   881 

   882         aProperty = temp;

   883 

   884         if ( doInform )

   885             {

   886             // Property is changed

   887             InformPropertyChangeL( aNode, temp );

   888             }

   889         }

   890     }

   891 

   892 // -----------------------------------------------------------------------------

   893 // EnableStatePropertiesL()

   894 // -----------------------------------------------------------------------------

   895 //

   896 static void EnableStatePropertiesL(

   897     CXnNode& aNode,

   898     CXnDomProperty::TPseudoClass aPseudoClass,

   899     CLayoutPropertyCache*& aLayoutPropertyCache )

   900     {

   901     if ( !aLayoutPropertyCache )

   902         {

   903         aLayoutPropertyCache = new ( ELeave ) CLayoutPropertyCache;

   904         }

   905 

   906     TInt level( XnDirtyLevel::ENone );

   907 

   908     EnableStatePropertyL(

   909         aNode, aPseudoClass, CXnNode::WidthL,

   910         aLayoutPropertyCache->iWidth,

   911         aLayoutPropertyCache->iWidths, level );

   912 

   913     EnableStatePropertyL(

   914         aNode, aPseudoClass, CXnNode::HeightL,

   915         aLayoutPropertyCache->iHeight,

   916         aLayoutPropertyCache->iHeights, level );

   917 

   918     EnableStatePropertyL(

   919         aNode, aPseudoClass, CXnNode::MarginLeftL,

   920         aLayoutPropertyCache->iMarginLeft,

   921         aLayoutPropertyCache->iMarginLefts, level );

   922 

   923     EnableStatePropertyL(

   924         aNode, aPseudoClass, CXnNode::MarginRightL,

   925         aLayoutPropertyCache->iMarginRight,

   926         aLayoutPropertyCache->iMarginRights, level );

   927 

   928     EnableStatePropertyL(

   929         aNode, aPseudoClass, CXnNode::BorderLeftL,

   930         aLayoutPropertyCache->iBorderLeft,

   931         aLayoutPropertyCache->iBorderLefts, level );

   932 

   933     EnableStatePropertyL(

   934         aNode, aPseudoClass, CXnNode::BorderRightL,

   935         aLayoutPropertyCache->iBorderRight,

   936         aLayoutPropertyCache->iBorderRights, level );

   937 

   938     EnableStatePropertyL(

   939         aNode, aPseudoClass, CXnNode::PaddingLeftL,

   940         aLayoutPropertyCache->iPaddingLeft,

   941         aLayoutPropertyCache->iPaddingLefts, level );

   942 

   943     EnableStatePropertyL(

   944         aNode, aPseudoClass, CXnNode::PaddingRightL,

   945         aLayoutPropertyCache->iPaddingRight,

   946         aLayoutPropertyCache->iPaddingRights, level );

   947 

   948     EnableStatePropertyL(

   949         aNode, aPseudoClass, CXnNode::MarginTopL,

   950         aLayoutPropertyCache->iMarginTop,

   951         aLayoutPropertyCache->iMarginTops, level );

   952 

   953     EnableStatePropertyL(

   954         aNode, aPseudoClass, CXnNode::MarginBottomL,

   955         aLayoutPropertyCache->iMarginBottom,

   956         aLayoutPropertyCache->iMarginBottoms, level );

   957 

   958     EnableStatePropertyL(

   959         aNode, aPseudoClass, CXnNode::BorderTopL,

   960         aLayoutPropertyCache->iBorderTop,

   961         aLayoutPropertyCache->iBorderTops, level );

   962 

   963     EnableStatePropertyL(

   964         aNode, aPseudoClass, CXnNode::BorderBottomL,

   965         aLayoutPropertyCache->iBorderBottom,

   966         aLayoutPropertyCache->iBorderBottoms, level );

   967 

   968     EnableStatePropertyL(

   969         aNode, aPseudoClass, CXnNode::PaddingTopL,

   970         aLayoutPropertyCache->iPaddingTop,

   971         aLayoutPropertyCache->iPaddingTops, level );

   972 

   973     EnableStatePropertyL(

   974         aNode, aPseudoClass, CXnNode::PaddingBottomL,

   975         aLayoutPropertyCache->iPaddingBottom,

   976         aLayoutPropertyCache->iPaddingBottoms, level );

   977 

   978     EnableStatePropertyL(

   979         aNode, aPseudoClass, CXnNode::BorderWidthL,

   980         aLayoutPropertyCache->iBorderWidth,

   981         aLayoutPropertyCache->iBorderWidths, level );

   982 

   983     EnableStatePropertyL(

   984         aNode, aPseudoClass, CXnNode::BlockProgressionL,

   985         aLayoutPropertyCache->iBlockProgression,

   986         aLayoutPropertyCache->iBlockProgressions, level );

   987 

   988     EnableStatePropertyL(

   989         aNode, aPseudoClass, CXnNode::DirectionL,

   990         aLayoutPropertyCache->iDirection,

   991         aLayoutPropertyCache->iDirections, level );

   992 

   993     EnableStatePropertyL(

   994         aNode, aPseudoClass, CXnNode::PositionL,

   995         aLayoutPropertyCache->iPosition,

   996         aLayoutPropertyCache->iPositions, level );

   997 

   998     EnableStatePropertyL(

   999         aNode, aPseudoClass, CXnNode::MaxHeightL,

  1000         aLayoutPropertyCache->iMaxHeight,

  1001         aLayoutPropertyCache->iMaxHeights, level );

  1002 

  1003     EnableStatePropertyL(

  1004         aNode, aPseudoClass, CXnNode::MinHeightL,

  1005         aLayoutPropertyCache->iMinHeight,

  1006         aLayoutPropertyCache->iMinHeights, level );

  1007 

  1008     EnableStatePropertyL(

  1009         aNode, aPseudoClass, CXnNode::MaxWidthL,

  1010         aLayoutPropertyCache->iMaxWidth,

  1011         aLayoutPropertyCache->iMaxWidths, level );

  1012 

  1013     EnableStatePropertyL(

  1014         aNode, aPseudoClass, CXnNode::MinWidthL,

  1015         aLayoutPropertyCache->iMinWidth,

  1016         aLayoutPropertyCache->iMinWidths, level );

  1017 

  1018     EnableStatePropertyL(

  1019         aNode, aPseudoClass, CXnNode::DisplayL,

  1020         aLayoutPropertyCache->iDisplay,

  1021         aLayoutPropertyCache->iDisplays, level, ETrue );

  1022 

  1023     EnableStatePropertyL(

  1024         aNode, aPseudoClass, CXnNode::VisibilityL,

  1025         aLayoutPropertyCache->iVisibility,

  1026         aLayoutPropertyCache->iVisibilities, level );

  1027 

  1028     EnableStatePropertyL(

  1029         aNode, aPseudoClass, CXnNode::LeftL,

  1030         aLayoutPropertyCache->iLeft,

  1031         aLayoutPropertyCache->iLefts, level );

  1032 

  1033     EnableStatePropertyL(

  1034         aNode, aPseudoClass, CXnNode::RightL,

  1035         aLayoutPropertyCache->iRight,

  1036         aLayoutPropertyCache->iRights, level );

  1037 

  1038     EnableStatePropertyL(

  1039         aNode, aPseudoClass, CXnNode::TopL,

  1040         aLayoutPropertyCache->iTop,

  1041         aLayoutPropertyCache->iTops, level );

  1042 

  1043     EnableStatePropertyL(

  1044         aNode, aPseudoClass, CXnNode::BottomL,

  1045         aLayoutPropertyCache->iBottom,

  1046         aLayoutPropertyCache->iBottoms, level );

  1047 

  1048     EnableStatePropertyL(

  1049         aNode, aPseudoClass, CXnNode::BorderLeftStyleL,

  1050         aLayoutPropertyCache->iBorderLeftStyle,

  1051         aLayoutPropertyCache->iBorderLeftStyles, level );

  1052 

  1053     EnableStatePropertyL(

  1054         aNode, aPseudoClass, CXnNode::BorderRightStyleL,

  1055         aLayoutPropertyCache->iBorderRightStyle,

  1056         aLayoutPropertyCache->iBorderRightStyles, level );

  1057 

  1058     EnableStatePropertyL(

  1059         aNode, aPseudoClass, CXnNode::BorderTopStyleL,

  1060         aLayoutPropertyCache->iBorderTopStyle,

  1061         aLayoutPropertyCache->iBorderTopStyles, level );

  1062 

  1063     EnableStatePropertyL(

  1064         aNode, aPseudoClass, CXnNode::BorderBottomStyleL,

  1065         aLayoutPropertyCache->iBorderBottomStyle,

  1066         aLayoutPropertyCache->iBorderBottomStyles, level );

  1067 

  1068     EnableStatePropertyL(

  1069         aNode, aPseudoClass, CXnNode::BorderStyleL,

  1070         aLayoutPropertyCache->iBorderStyle,

  1071         aLayoutPropertyCache->iBorderStyles, level );

  1072 

  1073     EnableStatePropertyL(

  1074         aNode, aPseudoClass, CXnNode::DisplayPriorityL,

  1075         aLayoutPropertyCache->iDisplayPriority,

  1076         aLayoutPropertyCache->iDisplayPriorities, level );

  1077 

  1078     EnableStatePropertyL(

  1079         aNode, aPseudoClass, CXnNode::NavIndexL,

  1080         aLayoutPropertyCache->iNavIndex,

  1081         aLayoutPropertyCache->iNavIndexes, level );

  1082 

  1083     EnableStatePropertyL(

  1084         aNode, aPseudoClass, CXnNode::ZIndexL,

  1085         aLayoutPropertyCache->iZIndex,

  1086         aLayoutPropertyCache->iZIndexes, level );

  1087 

  1088     EnableStatePropertyL(

  1089         aNode, aPseudoClass, CXnNode::BackgroundColorL,

  1090         aLayoutPropertyCache->iBackgroundColor,

  1091         aLayoutPropertyCache->iBackgroundColors, level );

  1092 

  1093     EnableStatePropertyL(

  1094         aNode, aPseudoClass, CXnNode::BackgroundImageL,

  1095         aLayoutPropertyCache->iBackgroundImage,

  1096         aLayoutPropertyCache->iBackgroundImages, level, ETrue );

  1097 

  1098     EnableStatePropertyL(

  1099         aNode, aPseudoClass, CXnNode::FocusBackgroundL,

  1100         aLayoutPropertyCache->iFocusBackground,

  1101         aLayoutPropertyCache->iFocusBackgrounds, level );

  1102 

  1103     aNode.SetDirtyL( level );

  1104     }

  1105 

  1106 // -----------------------------------------------------------------------------

  1107 // DisableStatePropertiesL()

  1108 // -----------------------------------------------------------------------------

  1109 //

  1110 static void DisableStatePropertiesL(

  1111     CXnNode& aNode,

  1112     CXnDomProperty::TPseudoClass aPseudoClass,

  1113     RArray< CXnDomProperty::TPseudoClass >& aStates,

  1114     CLayoutPropertyCache*& aLayoutPropertyCache )

  1115     {

  1116     if ( !aLayoutPropertyCache )

  1117         {

  1118         aLayoutPropertyCache = new ( ELeave ) CLayoutPropertyCache;

  1119         }

  1120 

  1121     TInt level( XnDirtyLevel::ENone );

  1122 

  1123     DisableStatePropertyL(

  1124         aNode, aPseudoClass, CXnNode::WidthL,

  1125         aLayoutPropertyCache->iWidth,

  1126         aLayoutPropertyCache->iWidths, aStates, level );

  1127 

  1128     DisableStatePropertyL(

  1129         aNode, aPseudoClass, CXnNode::HeightL,

  1130         aLayoutPropertyCache->iHeight,

  1131         aLayoutPropertyCache->iHeights, aStates, level );

  1132 

  1133     DisableStatePropertyL(

  1134         aNode, aPseudoClass, CXnNode::MarginLeftL,