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 "xnscrollablecontroladapter.h"

    47 #include "xnviewdata.h"

    48 #include "xnrootdata.h"

    49 #include "xnpanic.h"

    50 #include "xnlistquerydialogadapter.h"

    51 #include "xneffectmanager.h"

    52 #include "xnviewadapter.h"

    53 #include "xnbackgroundmanager.h"

    54 #include "xntexteditor.h"

    55 #include "xnitemactivator.h"

    56 

    57 // Local constants

    58 _LIT8( KId, "id" );

    59 _LIT8( KName, "name" );

    60 _LIT8( KToolTip, "tooltip" );

    61 _LIT8( KMenuBar, "menubar" );

    62 _LIT8( KTextEditor, "texteditor" );

    63 _LIT8( KPlugin, "plugin" );

    64 _LIT8( KTemplate, "template" );

    65 _LIT8( KIndex, "index" );

    66 

    67 _LIT8( KActionsHandler, "actionshandler" );

    68 

    69 const TInt KUnitMaxLen = 2;

    70 const TInt KOneView = 1;

    71 

    72 _LIT8( KPseudoClassFocus, "focus" );

    73 _LIT8( KPseudoClassPressedDown, "presseddown" );

    74 _LIT8( KPseudoClassPassiveFocus, "passivefocus" );

    75 _LIT8( KPseudoClassHold, "hold" );

    76 _LIT8( KPseudoClassHover, "hover" );

    77 _LIT8( KPseudoClassLink, "link" );

    78 _LIT8( KPseudoClassVisited, "visited" );

    79 _LIT8( KPseudoClassActive, "active" );

    80 _LIT8( KPseudoClassEdit, "edit" );

    81 

    82 _LIT8( KCompound, "compound" );

    83 _LIT8( KTrue, "true" );

    84 _LIT8( KDisplay, "display" );

    85 _LIT8( KBlock, "block" );

    86 _LIT8( KNone, "none" );

    87 _LIT8( KGainEnd, "gainend" );

    88 _LIT8( KLoseEnd, "loseend" );

    89 

    90 struct CLayoutPropertyCache : public CBase

    91     {

    92     CLayoutPropertyCache() :

    93         iWidths( 1 ),

    94         iHeights( 1 ),

    95         iMarginLefts( 1 ),

    96         iMarginRights( 1 ),

    97         iBorderLefts( 1 ),

    98         iBorderRights( 1 ),

    99         iPaddingLefts( 1 ),

   100         iPaddingRights( 1 ),

   101         iMarginTops( 1 ),

   102         iMarginBottoms( 1 ),

   103         iBorderTops( 1 ),

   104         iBorderBottoms( 1 ),

   105         iPaddingTops( 1 ),

   106         iPaddingBottoms( 1 ),

   107         iBorderWidths( 1 ),

   108         iBlockProgressions( 1 ),

   109         iDirections( 1 ),

   110         iPositions( 1 ),

   111         iMaxHeights( 1 ),

   112         iMinHeights( 1 ),

   113         iMaxWidths( 1 ),

   114         iMinWidths( 1 ),

   115         iDisplays( 2 ),

   116         iVisibilities( 1 ),

   117         iLefts( 1 ),

   118         iRights( 1 ),

   119         iTops( 1 ),

   120         iBottoms( 1 ),

   121         iBorderLeftStyles( 1 ),

   122         iBorderRightStyles( 1 ),

   123         iBorderTopStyles( 1 ),

   124         iBorderBottomStyles( 1 ),

   125         iBorderStyles( 1 ),

   126         iDisplayPriorities( 1 ),

   127         iNavIndexes( 1 ),

   128         iBackgroundColors( 1 ),

   129         iBackgroundImages( 1 ),

   130         iFocusBackgrounds( 2 )

   131             {

   132             }

   133 

   134     ~CLayoutPropertyCache()

   135         {

   136         iWidths.Reset();

   137         iHeights.Reset();

   138         iMarginLefts.Reset();

   139         iMarginRights.Reset();

   140         iBorderLefts.Reset();

   141         iBorderRights.Reset();

   142         iPaddingLefts.Reset();

   143         iPaddingRights.Reset();

   144         iMarginTops.Reset();

   145         iMarginBottoms.Reset();

   146         iBorderTops.Reset();

   147         iBorderBottoms.Reset();

   148         iPaddingTops.Reset();

   149         iPaddingBottoms.Reset();

   150         iBorderWidths.Reset();

   151         iBlockProgressions.Reset();

   152         iDirections.Reset();

   153         iPositions.Reset();

   154         iMaxHeights.Reset();

   155         iMinHeights.Reset();

   156         iMaxWidths.Reset();

   157         iMinWidths.Reset();

   158         iDisplays.Reset();

   159         iVisibilities.Reset();

   160         iLefts.Reset();

   161         iRights.Reset();

   162         iTops.Reset();

   163         iBottoms.Reset();

   164         iBorderLeftStyles.Reset();

   165         iBorderRightStyles.Reset();

   166         iBorderTopStyles.Reset();

   167         iBorderBottomStyles.Reset();

   168         iBorderStyles.Reset();

   169         iDisplayPriorities.Reset();

   170         iNavIndexes.Reset();

   171         iBackgroundColors.Reset();

   172         iZIndexes.Reset();

   173         iBackgroundImages.Reset();

   174         iFocusBackgrounds.Reset();

   175         }

   176 

   177     CXnProperty* iWidth;

   178     RPointerArray< CXnProperty > iWidths;

   179     CXnProperty* iHeight;

   180     RPointerArray< CXnProperty > iHeights;

   181     CXnProperty* iMarginLeft;

   182     RPointerArray< CXnProperty > iMarginLefts;

   183     CXnProperty* iMarginRight;

   184     RPointerArray< CXnProperty > iMarginRights;

   185     CXnProperty* iBorderLeft;

   186     RPointerArray< CXnProperty > iBorderLefts;

   187     CXnProperty* iBorderRight;

   188     RPointerArray< CXnProperty > iBorderRights;

   189     CXnProperty* iPaddingLeft;

   190     RPointerArray< CXnProperty > iPaddingLefts;

   191     CXnProperty* iPaddingRight;

   192     RPointerArray< CXnProperty > iPaddingRights;

   193     CXnProperty* iMarginTop;

   194     RPointerArray< CXnProperty > iMarginTops;

   195     CXnProperty* iMarginBottom;

   196     RPointerArray< CXnProperty > iMarginBottoms;

   197     CXnProperty* iBorderTop;

   198     RPointerArray< CXnProperty > iBorderTops;

   199     CXnProperty* iBorderBottom;

   200     RPointerArray< CXnProperty > iBorderBottoms;

   201     CXnProperty* iPaddingTop;

   202     RPointerArray< CXnProperty > iPaddingTops;

   203     CXnProperty* iPaddingBottom;

   204     RPointerArray< CXnProperty > iPaddingBottoms;

   205     CXnProperty* iBorderWidth;

   206     RPointerArray< CXnProperty > iBorderWidths;

   207     CXnProperty* iBlockProgression;

   208     RPointerArray< CXnProperty > iBlockProgressions;

   209     CXnProperty* iDirection;

   210     RPointerArray< CXnProperty > iDirections;

   211     CXnProperty* iPosition;

   212     RPointerArray< CXnProperty > iPositions;

   213     CXnProperty* iMaxHeight;

   214     RPointerArray< CXnProperty > iMaxHeights;

   215     CXnProperty* iMinHeight;

   216     RPointerArray< CXnProperty > iMinHeights;

   217     CXnProperty* iMaxWidth;

   218     RPointerArray< CXnProperty > iMaxWidths;

   219     CXnProperty* iMinWidth;

   220     RPointerArray< CXnProperty > iMinWidths;

   221     CXnProperty* iDisplay;

   222     RPointerArray< CXnProperty > iDisplays;

   223     CXnProperty* iVisibility;

   224     RPointerArray< CXnProperty > iVisibilities;

   225     CXnProperty* iLeft;

   226     RPointerArray< CXnProperty > iLefts;

   227     CXnProperty* iRight;

   228     RPointerArray< CXnProperty > iRights;

   229     CXnProperty* iTop;

   230     RPointerArray< CXnProperty > iTops;

   231     CXnProperty* iBottom;

   232     RPointerArray< CXnProperty > iBottoms;

   233     CXnProperty* iBorderLeftStyle;

   234     RPointerArray< CXnProperty > iBorderLeftStyles;

   235     CXnProperty* iBorderRightStyle;

   236     RPointerArray< CXnProperty > iBorderRightStyles;

   237     CXnProperty* iBorderTopStyle;

   238     RPointerArray< CXnProperty > iBorderTopStyles;

   239     CXnProperty* iBorderBottomStyle;

   240     RPointerArray< CXnProperty > iBorderBottomStyles;

   241     CXnProperty* iBorderStyle;

   242     RPointerArray< CXnProperty > iBorderStyles;

   243     CXnProperty* iBorderImage;

   244     CXnProperty* iDisplayPriority;

   245     RPointerArray< CXnProperty > iDisplayPriorities;

   246     CXnProperty* iNavIndex;

   247     RPointerArray< CXnProperty > iNavIndexes;

   248     CXnProperty* iZIndex;

   249     RPointerArray< CXnProperty > iZIndexes;

   250     CXnProperty* iBackgroundColor;

   251     RPointerArray< CXnProperty > iBackgroundColors;

   252     CXnProperty* iBackgroundImage;

   253     RPointerArray< CXnProperty > iBackgroundImages;

   254     CXnProperty* iFocusBackground;

   255     RPointerArray< CXnProperty > iFocusBackgrounds;

   256     };

   257 

   258 // Local function prototypes

   259 static TBool IsTriggerRunnableL( CXnDomNode& aTriggerNode );

   260 static TBool DoMatchTriggerForKeyEventL(

   261     const TKeyEvent& aKeyEvent,

   262     TEventCode aType,

   263     CXnDomNode& aTriggerNode );

   264 static void GetFocusCandidatesL(

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

   266     RPointerArray< CXnNode >& aFocusCandidates );

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

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

   269 static void RunFullScreenEffectL(

   270     CXnUiEngine& aEngine, CXnDomNode& aEventNode );

   271 static void RunActivateNextViewL( CXnUiEngine& aEngine, CXnDomNode& aEventNode );

   272 static void RunActivatePreviousViewL( CXnUiEngine& aEngine, CXnDomNode& aEventNode );

   273 static void RunAddViewL( CXnUiEngine& aEngine, CXnDomNode& aEventNode );

   274 static void RunRemoveViewL( CXnUiEngine& aEngine, CXnDomNode& aEventNode );

   275 static void RunActivateL(

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

   277 static void RunActivateEditorL( CXnNodeImpl* aThis, CXnNode& aLayoutNode,

   278     CXnUiEngine& aEngine, CXnDomNode& aEventNode, TBool aActivate );

   279 static void RunDeactivateL(

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

   281 static void RunSystemSetPCDataL(

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

   283     const TDesC8& aData );

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

   285     CXnDomPropertyValue::TPrimitiveValueType& aValueType );

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

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

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

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

   290 static void RunSystemSetStringL(

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

   292     const RPointerArray< HBufC8 >& aValues,

   293     const CXnDomPropertyValue::TPrimitiveValueType aValueType );

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

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

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

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

   298     const TDesC8** aClassId = NULL );

   299 static void RunSystemSetL(

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

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

   302 static void RunTryDisplayingMenuL(

   303     CXnUiEngine& aEngine, CXnDomNode& aEventNode );

   304 static void RunTryDisplayingStylusPopupL(

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

   306     CXnDomNode& aEventNode );

   307 static void RunTryDisplayingListQueryDialogL(

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

   309 static void RunSetInitialFocusL( CXnUiEngine& aEngine );

   310 static TBool RunEventL(

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

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

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

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

   315 static TBool DoMatchTriggerForHighLevelKeyEventL( CXnNode& aNode,

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

   317 static TBool MatchTriggerForKeyEventL(

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

   319     const TKeyEvent& aKeyEvent, TEventCode aType,

   320     CXnDomNode& aActionNode, CXnDomNode& aTriggerNode );

   321 static TBool MatchTriggerForEventL(

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

   323     CXnNode& aEventData, CXnDomNode& aActionNode, CXnDomNode& aTriggerNode,

   324     TInt aSource );

   325 static TBool MatchActionForKeyEventL(

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

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

   328 static TBool IsTriggerActiveL( CXnDomNode& aNode );

   329 static TBool MatchActionForEventL(

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

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

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

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

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

   335 static CXnNode* FindNextNodeFromRightL(

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

   337 static CXnNode* FindNextNodeFromLeftL(

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

   339 static CXnNode* FindNextNodeFromBelowL(

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

   341 static CXnNode* FindNextNodeFromAboveL(

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

   343 static CXnNode* FindPluginNode( CXnNode& aNode );

   344 static TBool DoInternalFocusChangeL(

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

   346     TEventCode aType );

   347 static TBool DoTriggerKeyEventL(

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

   349     const TKeyEvent& aKeyEvent, TEventCode aType );

   350 static void DoTriggerEventL(

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

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

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

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

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

   356 static CXnNode* BuildModifiersNodeL(

   357     const TKeyEvent& aKeyEvent, CXnUiEngine& aUiEngine );

   358 static CXnNode* BuildKeyCodeNodeL(

   359     const TKeyEvent& aKeyEvent, CXnUiEngine& aUiEngine );

   360 static CXnNode* BuildScanCodeNodeL(

   361     const TKeyEvent& aKeyEvent, CXnUiEngine& aUiEngine );

   362 static CXnNode* BuildRepeatsNodeL(

   363     const TKeyEvent& aKeyEvent, CXnUiEngine& aUiEngine );

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

   365     TEventCode aType, CXnUiEngine& aUiEngine );

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

   367     CXnUiEngine& aUiEngine );

   368 static CXnDomPropertyValue* GetNavIndexL( CXnNode& aNode );

   369 static CXnNode* BackwardL( CXnNode& aNode );

   370 static CXnNode* ForwardL( CXnNode& aNode );

   371 static CXnNode* BackwardLoopL( CXnNode& aNode );

   372 static CXnNode* ForwardLoopL( CXnNode& aNode );

   373 static TInt CompareNavIndexesL(

   374     CXnDomPropertyValue* aCurrentPropertyValue,

   375     CXnDomPropertyValue* aNextPropertyValue );

   376 static void ReplaceOrAppend(

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

   378     TBool aAppendOnly );

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

   380 static void SetStringPropertyToNodeL(

   381     CXnDomStringPool& aStringPool, CXnNode& aNode,

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

   383 static void SetFloatPropertyToNodeL(

   384     CXnDomStringPool& aStringPool, CXnNode& aNode,

   385     const TDesC8& aPropertyName, TReal aPropertyValue,

   386     CXnDomPropertyValue::TPrimitiveValueType aValueType );

   387 static CXnNode* FindYoungestSiblingWithDisplayL(

   388     RPointerArray< CXnNode >& aSiblingArray,

   389     const TDesC8& aDisplayValue,

   390     TInt& aIndex );

   391 static CXnNode* FindOldestSiblingWithDisplayL(

   392     RPointerArray< CXnNode >& aSiblingArray,

   393     const TDesC8& aDisplayValue,

   394     TInt& aIndex );

   395 static TBool IsCompoundNodeL( CXnNode* aNode );

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

   397 static void DoCompoundNodeBeginKeyL(

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

   399 static void DoCompoundNodeEndKeyL(

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

   401 static void DoCompoundNodeScrollingL(

   402     CXnNode& aFocusedNode,

   403     const TKeyEvent& aKeyEvent,

   404     TEventCode aType );

   405 static CXnNode* BuildTriggerNodeL(

   406     CXnUiEngine& aUiEngine, const TDesC8& aTriggerName );

   407 static CXnNode* IsNodeNavigableL( CXnNode* aParent );

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

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

   410 static TBool IsNodeDisplayedL(

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

   412 static void EnableStatePropertyL(

   413     CXnNode& aNode,

   414     CXnDomProperty::TPseudoClass aPseudoClass,

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

   416     CXnProperty*& aProperty,

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

   418     TBool aInformChange = EFalse );

   419 static void DisableStatePropertyL(

   420     CXnNode& aNode,

   421     CXnDomProperty::TPseudoClass aPseudoClass,

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

   423     CXnProperty*& aProperty,

   424     RPointerArray< CXnProperty >& aArray,

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

   426     TBool aInformChange = EFalse );

   427 static TBool MatchTitleScrollTriggerL(

   428     CXnNode& aEventData, CXnDomNode& aTriggerNode );

   429 static CXnDomNode* GetTemplateEventL( 

   430     const TDesC8& aTemplate, 

   431     CXnNode& aNode, 

   432     CXnDomNode& aEventNode );    

   433 

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

   435 // -----------------------------------------------------------------------------

   436 // GetTemplateEventL

   437 // -----------------------------------------------------------------------------

   438 //

   439 static CXnDomNode* GetTemplateEventL( const TDesC8& aTemplate, CXnNode& aNode, 

   440     CXnDomNode& aEventNode )

   441     {

   442     CXnDomNode* retval( NULL );

   443     

   444     if ( aTemplate == KIndex() )

   445         {

   446         _LIT8( KTemplateIndex, "(#)" );

   447         

   448         const TDesC8& eventString( aEventNode.AttributeValue( KName ) );

   449         

   450         TInt index( eventString.Find( KTemplateIndex ) );

   451         

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

   453         

   454         if ( index != KErrNotFound && parent )

   455             {                                

   456             RPointerArray< CXnNode >& siblings( parent->Children() );

   457             

   458             TInt itemindex( siblings.Find( &aNode ) );

   459             

   460             if ( itemindex != KErrNotFound )

   461                 {

   462                 TBuf8< 4 > buf;

   463                 buf.AppendNum( itemindex );

   464     

   465                 CXnDomNode* clone( 

   466                     aEventNode.CloneL( *aEventNode.StringPool() ) );

   467                 CleanupStack::PushL( clone );

   468                 

   469                 HBufC8* templateString = 

   470                     HBufC8::NewLC( eventString.Length() + 4 );

   471 

   472                 TPtr8 ptr( templateString->Des() );

   473                 

   474                 ptr.Copy( eventString );

   475                 ptr.Delete( index + 1, 1 );                    

   476                 ptr.Insert( index + 1, buf );

   477                                 

   478                 CXnDomAttribute* attribute = static_cast< CXnDomAttribute* > 

   479                     ( clone->AttributeList().FindByName( 

   480                         XnPropertyNames::action::event::KName ) );

   481                                                 

   482                 if ( attribute )

   483                     {                                        

   484                     attribute->SetValueL( ptr );

   485                     }

   486                                 

   487                 CleanupStack::PopAndDestroy( templateString );

   488                 

   489                 CleanupStack::Pop( clone );

   490                 retval = clone;

   491                 }

   492             }    

   493         }

   494     

   495     return retval;

   496     }

   497     

   498 // -----------------------------------------------------------------------------

   499 // ResolveEffectId

   500 // -----------------------------------------------------------------------------

   501 //

   502 static TInt ResolveEffectId( CXnDomNode& aEventNode )

   503     {

   504     TInt effect( 0 );

   505     const TDesC8& value( aEventNode.AttributeValue( 

   506         XnPropertyNames::common::KEffectId ) );

   507     if( value != KNullDesC8 )

   508         {

   509         TLex8 lex( value );

   510         lex.Val( effect );    

   511         }

   512     return effect;

   513     }

   514 

   515 // -----------------------------------------------------------------------------

   516 // Checks whether trigger is runnable

   517 // -----------------------------------------------------------------------------

   518 //

   519 TBool IsTriggerRunnableL( CXnDomNode& aTriggerNode )

   520     {

   521     TBool ret( ETrue );

   522     CXnNode* layoutNode = aTriggerNode.LayoutNode();

   523     if ( layoutNode )

   524         {

   525         CXnProperty* display =

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

   527 

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

   529              XnPropertyNames::style::common::display::KNone )

   530             {

   531             ret = EFalse;

   532             }

   533         }

   534     return ret;

   535     }

   536 

   537 // -----------------------------------------------------------------------------

   538 // DirtyLevelFromPropertyL

   539 // -----------------------------------------------------------------------------

   540 //

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

   542     {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   571         {

   572         TInt retval( XnDirtyLevel::ELayoutAndRenderSiblings );

   573 

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

   575 

   576         if ( prop )

   577             {

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

   579 

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

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

   582                 {

   583                 retval = XnDirtyLevel::ELayoutAndRender;

   584                 }

   585             }

   586 

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

   588             {

   589             retval = XnDirtyLevel::ELayoutAndRender;

   590             }

   591 

   592         return retval;

   593         }

   594     else

   595         {

   596         return XnDirtyLevel::ERender;

   597         }

   598     }

   599 

   600 // -----------------------------------------------------------------------------

   601 // IsNodeDisplayedL

   602 // Check whether a node is displayed or not

   603 // -----------------------------------------------------------------------------

   604 //

   605 static TBool IsNodeDisplayedL(

   606     CXnNode& aNode,

   607     TBool aCheckVisiblity,

   608     TBool aCheckParent )

   609     {

   610     if ( !aNode.IsLayoutCapable() )

   611         {

   612         return EFalse;

   613         }

   614 

   615     if ( aCheckVisiblity )

   616         {

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

   618 

   619         // Am I visible?

   620         if ( visibilityProp )

   621             {

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

   623 

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

   625                 {

   626                 return EFalse;

   627                 }

   628             }

   629         }

   630 

   631     // Am I displayed?

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

   633 

   634     if ( displayProp )

   635         {

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

   637 

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

   639             {

   640             return EFalse;

   641             }

   642         }

   643 

   644     if ( aCheckParent )

   645         {

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

   647 

   648         // Is my parent displayed?

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

   650             {

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

   652 

   653             if ( displayProp )

   654                 {

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

   656 

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

   658                     {

   659                     return EFalse;

   660                     }

   661                 }

   662             }

   663         }

   664 

   665     return ETrue;

   666     }

   667 

   668 // -----------------------------------------------------------------------------

   669 // IsNodeNavigableL

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

   671 // -----------------------------------------------------------------------------

   672 //

   673 static CXnNode* IsNodeNavigableL( CXnNode* aParent )

   674     {

   675     if ( IsNodeNavigableL( *aParent, ETrue ) )

   676         {

   677         return aParent;

   678         }

   679 

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

   681 

   682     TInt count( children.Count() );

   683 

   684     CXnNode* retval = NULL;

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

   686         {

   687         retval = IsNodeNavigableL( children[i] );

   688         if ( retval )

   689             {

   690             return retval;

   691             }

   692         }

   693 

   694     return NULL;

   695     }

   696 

   697 // -----------------------------------------------------------------------------

   698 // IsNodeNavigableL()

   699 // Check if node can be navigated

   700 // -----------------------------------------------------------------------------

   701 //

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

   703     {

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

   705         {

   706         return EFalse;

   707         }

   708 

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

   710 

   711     if ( displayProp )

   712         {

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

   714 

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

   716             {

   717             return EFalse;

   718             }

   719         }

   720 

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

   722 

   723     if ( visibilityProp )

   724         {

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

   726 

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

   728             {

   729             return EFalse;

   730             }

   731         }

   732 

   733     CXnProperty* focusableProp(

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

   735 

   736     if ( focusableProp )

   737         {

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

   739 

   740         if ( focus != XnPropertyNames::KTrue )

   741             {

   742             return EFalse;

   743             }

   744         }

   745     else

   746         {

   747         return EFalse;

   748         }

   749     CXnProperty* disabledProp(

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

   751 

   752     if ( disabledProp )

   753         {

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

   755 

   756         if ( disabled == XnPropertyNames::KTrue )

   757             {

   758             return EFalse;

   759             }

   760         }

   761 

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

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

   764 

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

   766         {

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

   768 

   769         if ( displayProp )

   770             {

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

   772 

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

   774                 {

   775                 return EFalse;

   776                 }

   777             }

   778 

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

   780 

   781         if ( visibilityProp )

   782             {

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

   784 

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

   786                 {

   787                 return EFalse;

   788                 }

   789             }

   790         }

   791 

   792     return ETrue;

   793     }

   794 

   795 // -----------------------------------------------------------------------------

   796 // EnableStatePropertyL()

   797 // -----------------------------------------------------------------------------

   798 //

   799 static void EnableStatePropertyL(

   800     CXnNode& aNode,

   801     CXnDomProperty::TPseudoClass aPseudoClass,

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

   803     CXnProperty*& aProperty,

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

   805     TBool aInformChange )

   806     {

   807     TBool doInform( EFalse );

   808 

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

   810         {

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

   812             {

   813             CXnProperty* temp( aArray[i] );

   814 

   815             if ( aLevel < XnDirtyLevel::ELayoutAndRenderSiblings ||

   816                  aInformChange )

   817                 {

   818                 TInt level( XnDirtyLevel::ENone );

   819 

   820                 // Get current cached prop

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

   822 

   823                 if ( !temp && prop )

   824                     {

   825                     level = DirtyLevelFromPropertyL(

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

   827                     }

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

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

   830                     {

   831                     level = DirtyLevelFromPropertyL(

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

   833                     }

   834 

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

   836                     {

   837                     doInform = ETrue;

   838                     }

   839 

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

   841                     {

   842                     aLevel = level;

   843                     }

   844                 }

   845 

   846             aProperty = temp;

   847 

   848             if ( doInform )

   849                 {

   850                 // Property is changed

   851                 InformPropertyChangeL( aNode, temp );

   852                 }

   853 

   854             break;

   855             }

   856         }

   857     }

   858 

   859 // -----------------------------------------------------------------------------

   860 // DisableStatePropertyL()

   861 // -----------------------------------------------------------------------------

   862 //

   863 static void DisableStatePropertyL(

   864     CXnNode& aNode,

   865     CXnDomProperty::TPseudoClass aPseudoClass,

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

   867     CXnProperty*& aProperty,

   868     RPointerArray< CXnProperty >& aArray,

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

   870     TBool aInformChange )

   871     {

   872     CXnProperty* currentStateProperty( NULL );

   873 

   874     TBool doInform( EFalse );

   875 

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

   877         {

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

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

   880             {

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

   882                 {

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

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

   885                     {

   886                     currentStateProperty = aArray[i];

   887                     break;

   888                     }

   889                 }

   890             }

   891 

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

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

   894             {

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

   896                 {

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

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

   899                     {

   900                     currentStateProperty = aArray[i];

   901                     break;

   902                     }

   903                 }

   904             }

   905 

   906         CXnProperty* temp( currentStateProperty );

   907 

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

   909             {

   910             TInt level( XnDirtyLevel::ENone );

   911 

   912             // Get current cached prop

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

   914 

   915             if ( !temp && prop )

   916                 {

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

   918                 }

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

   920                 {

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

   922                 }

   923 

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

   925                 {

   926                 doInform = ETrue;

   927                 }

   928 

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

   930                 {

   931                 aLevel = level;

   932                 }

   933             }

   934 

   935         aProperty = temp;

   936 

   937         if ( doInform )

   938             {

   939             // Property is changed

   940             InformPropertyChangeL( aNode, temp );

   941             }

   942         }

   943     }

   944 

   945 // -----------------------------------------------------------------------------

   946 // EnableStatePropertiesL()

   947 // -----------------------------------------------------------------------------

   948 //

   949 static void EnableStatePropertiesL(

   950     CXnNode& aNode,

   951     CXnDomProperty::TPseudoClass aPseudoClass,

   952     CLayoutPropertyCache*& aLayoutPropertyCache )

   953     {

   954     if ( !aLayoutPropertyCache )

   955         {

   956         aLayoutPropertyCache = new ( ELeave ) CLayoutPropertyCache;

   957         }

   958 

   959     TInt level( XnDirtyLevel::ENone );

   960 

   961     EnableStatePropertyL(

   962         aNode, aPseudoClass, &CXnNode::WidthL,

   963         aLayoutPropertyCache->iWidth,

   964         aLayoutPropertyCache->iWidths, level );

   965 

   966     EnableStatePropertyL(

   967         aNode, aPseudoClass, &CXnNode::HeightL,

   968         aLayoutPropertyCache->iHeight,

   969         aLayoutPropertyCache->iHeights, level );

   970 

   971     EnableStatePropertyL(

   972         aNode, aPseudoClass, &CXnNode::MarginLeftL,

   973         aLayoutPropertyCache->iMarginLeft,

   974         aLayoutPropertyCache->iMarginLefts, level );

   975 

   976     EnableStatePropertyL(

   977         aNode, aPseudoClass, &CXnNode::MarginRightL,

   978         aLayoutPropertyCache->iMarginRight,

   979         aLayoutPropertyCache->iMarginRights, level );

   980 

   981     EnableStatePropertyL(

   982         aNode, aPseudoClass, &CXnNode::BorderLeftL,

   983         aLayoutPropertyCache->iBorderLeft,

   984         aLayoutPropertyCache->iBorderLefts, level );

   985 

   986     EnableStatePropertyL(

   987         aNode, aPseudoClass, &CXnNode::BorderRightL,

   988         aLayoutPropertyCache->iBorderRight,

   989         aLayoutPropertyCache->iBorderRights, level );

   990 

   991     EnableStatePropertyL(

   992         aNode, aPseudoClass, &CXnNode::PaddingLeftL,

   993         aLayoutPropertyCache->iPaddingLeft,

   994         aLayoutPropertyCache->iPaddingLefts, level );

   995 

   996     EnableStatePropertyL(

   997         aNode, aPseudoClass, &CXnNode::PaddingRightL,

   998         aLayoutPropertyCache->iPaddingRight,

   999         aLayoutPropertyCache->iPaddingRights, level );

  1000 

  1001     EnableStatePropertyL(

  1002         aNode, aPseudoClass, &CXnNode::MarginTopL,

  1003         aLayoutPropertyCache->iMarginTop,

  1004         aLayoutPropertyCache->iMarginTops, level );

  1005 

  1006     EnableStatePropertyL(

  1007         aNode, aPseudoClass, &CXnNode::MarginBottomL,

  1008         aLayoutPropertyCache->iMarginBottom,

  1009         aLayoutPropertyCache->iMarginBottoms, level );

  1010 

  1011     EnableStatePropertyL(

  1012         aNode, aPseudoClass, &CXnNode::BorderTopL,

  1013         aLayoutPropertyCache->iBorderTop,

  1014         aLayoutPropertyCache->iBorderTops, level );

  1015 

  1016     EnableStatePropertyL(

  1017         aNode, aPseudoClass, &CXnNode::BorderBottomL,

  1018         aLayoutPropertyCache->iBorderBottom,

  1019         aLayoutPropertyCache->iBorderBottoms, level );

  1020 

  1021     EnableStatePropertyL(

  1022         aNode, aPseudoClass, &CXnNode::PaddingTopL,

  1023         aLayoutPropertyCache->iPaddingTop,

  1024         aLayoutPropertyCache->iPaddingTops, level );

  1025 

  1026     EnableStatePropertyL(

  1027         aNode, aPseudoClass, &CXnNode::PaddingBottomL,

  1028         aLayoutPropertyCache->iPaddingBottom,

  1029         aLayoutPropertyCache->iPaddingBottoms, level );

  1030 

  1031     EnableStatePropertyL(

  1032         aNode, aPseudoClass, &CXnNode::BorderWidthL,

  1033         aLayoutPropertyCache->iBorderWidth,

  1034         aLayoutPropertyCache->iBorderWidths, level );

  1035 

  1036     EnableStatePropertyL(

  1037         aNode, aPseudoClass, &CXnNode::BlockProgressionL,

  1038         aLayoutPropertyCache->iBlockProgression,

  1039         aLayoutPropertyCache->iBlockProgressions, level );

  1040 

  1041     EnableStatePropertyL(

  1042         aNode, aPseudoClass, &CXnNode::DirectionL,

  1043         aLayoutPropertyCache->iDirection,

  1044         aLayoutPropertyCache->iDirections, level );

  1045 

  1046     EnableStatePropertyL(

  1047         aNode, aPseudoClass, &CXnNode::PositionL,

  1048         aLayoutPropertyCache->iPosition,

  1049         aLayoutPropertyCache->iPositions, level );

  1050 

  1051     EnableStatePropertyL(

  1052         aNode, aPseudoClass, &CXnNode::MaxHeightL,

  1053         aLayoutPropertyCache->iMaxHeight,

  1054         aLayoutPropertyCache->iMaxHeights, level );

  1055 

  1056     EnableStatePropertyL(

  1057         aNode, aPseudoClass, &CXnNode::MinHeightL,

  1058         aLayoutPropertyCache->iMinHeight,

  1059         aLayoutPropertyCache->iMinHeights, level );

  1060 

  1061     EnableStatePropertyL(

  1062         aNode, aPseudoClass, &CXnNode::MaxWidthL,

  1063         aLayoutPropertyCache->iMaxWidth,

  1064         aLayoutPropertyCache->iMaxWidths, level );

  1065 

  1066     EnableStatePropertyL(

  1067         aNode, aPseudoClass, &CXnNode::MinWidthL,

  1068         aLayoutPropertyCache->iMinWidth,

  1069         aLayoutPropertyCache->iMinWidths, level );

  1070 

  1071     EnableStatePropertyL(

  1072         aNode, aPseudoClass, &CXnNode::DisplayL,

  1073         aLayoutPropertyCache->iDisplay,

  1074         aLayoutPropertyCache->iDisplays, level, ETrue );

  1075 

  1076     EnableStatePropertyL(

  1077         aNode, aPseudoClass, &CXnNode::VisibilityL,

  1078         aLayoutPropertyCache->iVisibility,

  1079         aLayoutPropertyCache->iVisibilities, level );

  1080 

  1081     EnableStatePropertyL(

  1082         aNode, aPseudoClass, &CXnNode::LeftL,

  1083         aLayoutPropertyCache->iLeft,

  1084         aLayoutPropertyCache->iLefts, level );

  1085 

  1086     EnableStatePropertyL(

  1087         aNode, aPseudoClass, &CXnNode::RightL,

  1088         aLayoutPropertyCache->iRight,

  1089         aLayoutPropertyCache->iRights, level );

  1090 

  1091     EnableStatePropertyL(

  1092         aNode, aPseudoClass, &CXnNode::TopL,

  1093         aLayoutPropertyCache->iTop,

  1094         aLayoutPropertyCache->iTops, level );

  1095 

  1096     EnableStatePropertyL(

  1097         aNode, aPseudoClass, &CXnNode::BottomL,

  1098         aLayoutPropertyCache->iBottom,

  1099         aLayoutPropertyCache->iBottoms, level );

  1100 

  1101     EnableStatePropertyL(

  1102         aNode, aPseudoClass, &CXnNode::BorderLeftStyleL,

  1103         aLayoutPropertyCache->iBorderLeftStyle,

  1104         aLayoutPropertyCache->iBorderLeftStyles, level );

  1105 

  1106     EnableStatePropertyL(

  1107         aNode, aPseudoClass, &CXnNode::BorderRightStyleL,

  1108         aLayoutPropertyCache->iBorderRightStyle,

  1109         aLayoutPropertyCache->iBorderRightStyles, level );

  1110 

  1111     EnableStatePropertyL(

  1112         aNode, aPseudoClass, &CXnNode::BorderTopStyleL,

  1113         aLayoutPropertyCache->iBorderTopStyle,

  1114         aLayoutPropertyCache->iBorderTopStyles, level );

  1115 

  1116     EnableStatePropertyL(

  1117         aNode, aPseudoClass, &CXnNode::BorderBottomStyleL,

  1118         aLayoutPropertyCache->iBorderBottomStyle,

  1119         aLayoutPropertyCache->iBorderBottomStyles, level );

  1120 

  1121     EnableStatePropertyL(

  1122         aNode, aPseudoClass, &CXnNode::BorderStyleL,

  1123         aLayoutPropertyCache->iBorderStyle,

  1124         aLayoutPropertyCache->iBorderStyles, level );

  1125 

  1126     EnableStatePropertyL(

  1127         aNode, aPseudoClass, &CXnNode::DisplayPriorityL,

  1128         aLayoutPropertyCache->iDisplayPriority,

  1129         aLayoutPropertyCache->iDisplayPriorities, level );

  1130 

  1131     EnableStatePropertyL(

  1132         aNode, aPseudoClass, &CXnNode::NavIndexL,

  1133         aLayoutPropertyCache->iNavIndex,