MCL/sf/app/homescreen: comparison idlehomescreen/xmluirendering/uiengine/src/xnnodeimpl.cpp

equal deleted inserted replaced

-:f966699dea19
+:ff572dfe6d86
 #include "xnviewadapter.h"
 #include "xnbackgroundmanager.h"
 #include "xntexteditor.h"
 // Local constants
-_LIT8( KRef, "ref" );
 _LIT8( KId, "id" );
 _LIT8( KName, "name" );
 _LIT8( KToolTip, "tooltip" );
 _LIT8( KMenuBar, "menubar" );
 _LIT8( KTextEditor, "texteditor" );
 _LIT8( KActionsHandler, "actionshandler" );
-const TReal KS60ScrollbarDefaultWidth = 1.5;
-const TReal KS60ScrollbarDefaultMargin = 0.25;
-const TReal KS60ScrollbarDefaultWidthPenEnabled = 3;
-const TReal KS60ScrollbarDefaultMarginPenEnabled = 0.5;
 const TInt KUnitMaxLen = 2;
 const TInt KOneView = 1;
 _LIT8( KPseudoClassFocus, "focus" );
 _LIT8( KPseudoClassPressedDown, "presseddown" );
 _LIT8( KDisplay, "display" );
 _LIT8( KBlock, "block" );
 _LIT8( KNone, "none" );
 _LIT8( KGainEnd, "gainend" );
 _LIT8( KLoseEnd, "loseend" );
-// Local classes
-struct TXnTimedTrigger
-{
-CXnNodeImpl* iNodeImpl;
-CXnUiEngine* iEngine;
-CXnNode* iNode;
-CXnNode* iEventData;
-CXnDomNode* iActionNode;
-CXnDomNode* iTriggerNode;
-};
-struct CGridPropertyCache : public CBase
-{
-CXnProperty* iVisibleRows;
-CXnProperty* iGridColumns;
-CXnProperty* iGridOrientation;
-CXnProperty* iGridVerDirection;
-CXnProperty* iGridHorDirection;
-CXnProperty* iFocusHorLooping;
-CXnProperty* iFocusVerLooping;
-CXnProperty* iGridScrollBarWidth;
-CXnProperty* iGridScrollBarMargin;
-};
 struct CLayoutPropertyCache : public CBase
 {
 CLayoutPropertyCache() :
 iWidths( 1 ),
 RPointerArray< CXnProperty > iFocusBackgrounds;
 };
 // Local function prototypes
 static TBool IsTriggerRunnableL( CXnDomNode& aTriggerNode );
-static CXnNode* RefNodeL(
-CXnNodeImpl* aThis, CXnProperty* aRef, CXnUiEngine* aUiEngine );
-static const TDesC8* CheckRefAttributeL( CXnProperty* aRef );
 static TBool DoMatchTriggerForKeyEventL(
 const TKeyEvent& aKeyEvent,
 TEventCode aType,
 CXnDomNode& aTriggerNode );
 static void GetFocusCandidatesL(
 CXnNodeImpl* aThis, CXnUiEngine& aEngine, CXnDomNode& aEventNode,
 RPointerArray< CXnNode >& aFocusCandidates );
 static void RunAppUiNotificationL( CXnUiEngine& aEngine, CXnNode& aNode,
 CXnDomNode& aEventNode, CXnDomNode& aTriggerNode, CXnNode& aEventData );
-static void RunAppExit( CXnUiEngine& aEngine );
 static void RunFullScreenEffectL(
 CXnUiEngine& aEngine, CXnDomNode& aEventNode );
 static void RunActivateViewL(
 CXnNodeImpl* aThis, CXnUiEngine& aEngine, CXnDomNode& aEventNode );
 static void RunActivateNextViewL( CXnUiEngine& aEngine, CXnDomNode& aEventNode );
 CXnNodeImpl* aThis, CXnNode& aNode, CXnUiEngine& aEngine,
 CXnDomNode& aEventNode );
 static void RunTryDisplayingListQueryDialogL(
 CXnNodeImpl* aThis, CXnUiEngine& aEngine, CXnDomNode& aEventNode );
 static void RunSetInitialFocusL( CXnUiEngine& aEngine );
-static void ResolveTriggerDelayL(
-CXnUiEngine& aEngine, CXnDomNode& aNode, TInt& aDelay );
 static TBool RunEventL(
 CXnNodeImpl* aThis, CXnUiEngine& aEngine, CXnNode& aNode,
 CXnDomNode& aEventNode, CXnDomNode& aTriggerNode, CXnNode& aEventData );
 static void RunEventsL( CXnNodeImpl* aThis, CXnUiEngine& aEngine, CXnNode& aNode,
 CXnDomNode& aActionNode, CXnDomNode& aTriggerNode, CXnNode& aEventData );
 // -----------------------------------------------------------------------------
 //
 static void SetCachedProperty(
 CXnProperty* aProperty,
 CLayoutPropertyCache*& aLayoutPropertyCache,
-CXnProperty*& aRef,
 CXnProperty*& aName,
 CXnProperty*& aValue,
 CXnProperty*& aLabel,
 CXnProperty*& aInitialFocus,
 CXnProperty*& aClass,
 CXnProperty*& aId,
 CXnProperty*& aPath,
 CXnProperty*& aMaskPath,
-CGridPropertyCache*& aGridPropertyCache,
 TBool aInitializing,
 TBool aArrayOnly)
 {
 const TDesC8& name = aProperty->Property()->Name();
 if ( !AllocateLayoutCache( aLayoutPropertyCache ) )
 }
 else if ( name == XnPropertyNames::image::KMaskPath )
 {
 aMaskPath = aProperty;
 }
-else if ( name == KRef )
-{
-aRef = aProperty;
-}
 else if ( name == XnPropertyNames::style::common::KMarginLeft )
 {
 DoSetCachedProperty(
 aProperty,
 aLayoutPropertyCache->iMarginLeft,
 DoSetCachedProperty(
 aProperty,
 aLayoutPropertyCache->iNavIndex,
 aLayoutPropertyCache->iNavIndexes,
 aInitializing, aArrayOnly );
-}
-else if ( name == XnPropertyNames::grid::KS60VisibleRows )
-{
-if ( !aGridPropertyCache )
-{
-aGridPropertyCache = new CGridPropertyCache;
-}
-if ( aGridPropertyCache )
-{
-aGridPropertyCache->iVisibleRows = aProperty;
-}
-}
-else if ( name == XnPropertyNames::grid::KS60GridColumns )
-{
-if ( !aGridPropertyCache )
-{
-aGridPropertyCache = new CGridPropertyCache;
-}
-if ( aGridPropertyCache )
-{
-aGridPropertyCache->iGridColumns = aProperty;
-}
-}
-else if ( name == XnPropertyNames::grid::KS60GridOrientation )
-{
-if ( !aGridPropertyCache )
-{
-aGridPropertyCache = new CGridPropertyCache;
-}
-if ( aGridPropertyCache )
-{
-aGridPropertyCache->iGridOrientation = aProperty;
-}
-}
-else if ( name == XnPropertyNames::grid::KS60GridVerDirection )
-{
-if ( !aGridPropertyCache )
-{
-aGridPropertyCache = new CGridPropertyCache;
-}
-if ( aGridPropertyCache )
-{
-aGridPropertyCache->iGridVerDirection = aProperty;
-}
-}
-else if ( name == XnPropertyNames::grid::KS60GridHorDirection )
-{
-if ( !aGridPropertyCache )
-{
-aGridPropertyCache = new CGridPropertyCache;
-}
-if ( aGridPropertyCache )
-{
-aGridPropertyCache->iGridHorDirection = aProperty;
-}
-}
-else if ( name == XnPropertyNames::grid::KS60FocusHorLooping )
-{
-if ( !aGridPropertyCache )
-{
-aGridPropertyCache = new CGridPropertyCache;
-}
-if ( aGridPropertyCache )
-{
-aGridPropertyCache->iFocusHorLooping = aProperty;
-}
-}
-else if ( name == XnPropertyNames::grid::KS60FocusVerLooping )
-{
-if ( !aGridPropertyCache )
-{
-aGridPropertyCache = new CGridPropertyCache;
-}
-if ( aGridPropertyCache )
-{
-aGridPropertyCache->iFocusVerLooping = aProperty;
-}
-}
-else if ( name == XnPropertyNames::grid::KS60GridScrollbarWidth )
-{
-if ( !aGridPropertyCache )
-{
-aGridPropertyCache = new CGridPropertyCache;
-}
-if ( aGridPropertyCache )
-{
-aGridPropertyCache->iGridScrollBarWidth = aProperty;
-}
-}
-else if ( name == XnPropertyNames::grid::KS60GridScrollbarMargin )
-{
-if ( !aGridPropertyCache )
-{
-aGridPropertyCache = new CGridPropertyCache;
-}
-if ( aGridPropertyCache )
-{
-aGridPropertyCache->iGridScrollBarMargin = aProperty;
-}
 }
 }
 // -----------------------------------------------------------------------------
 // ReplaceOrAppend()
 return KNullDesC8;
 }
 }
 // -----------------------------------------------------------------------------
-// CheckRefAttributeL
-// -----------------------------------------------------------------------------
-//
-static const TDesC8* CheckRefAttributeL( CXnProperty* aRef )
-{
-if ( !aRef )
-{
-return NULL;
-}
-return &aRef->StringValue();
-}
-// -----------------------------------------------------------------------------
 // DoMatchTriggerForKeyEventL
 // -----------------------------------------------------------------------------
 //
 static TBool DoMatchTriggerForKeyEventL(
 const TKeyEvent& aKeyEvent, TEventCode aType,
 }
 return EFalse;
 }
 // -----------------------------------------------------------------------------
-// MatchTimedTriggerPropertiesL
-// -----------------------------------------------------------------------------
-//
-static TBool MatchTimedTriggerPropertiesL( CXnDomNode& aTriggerNode )
-{
-CXnDomList& children = aTriggerNode.ChildNodes();
-TInt count = children.Length();
-if ( count > 0 )
-{
-for ( TInt i = 0; i < count; ++i )
-{
-CXnDomNode* child = static_cast< CXnDomNode* >( children.Item( i ) );
-const TDesC8& name = child->AttributeValue( XnPropertyNames::action::KName );
-if ( name == XnPropertyNames::action::trigger::KDelay )
-{
-return ETrue;
-}
-}
-}
-return EFalse;
-}
-// -----------------------------------------------------------------------------
-// MatchStylusTriggerL
-// -----------------------------------------------------------------------------
-//
-static TBool MatchStylusTriggerL(
-CXnNode& aMatchingTriggerNode,
-CXnDomNode& aTreeTriggerNode )
-{
-TInt ret( EFalse );
-CXnDomList& treeChildren = aTreeTriggerNode.ChildNodes();
-TInt treeCount = treeChildren.Length();
-RPointerArray< CXnNode >& matchingChildren = aMatchingTriggerNode.Children();
-TInt matchCount = matchingChildren.Count();
-if ( treeCount == 0 )
-{
-// If stylus-trigger does not have properties, trigger is run with stylus up.
-for ( TInt i = 0; i < matchCount; ++i )
-{
-CXnNode* node = matchingChildren[i];
-CXnProperty* nameProperty = node->NameL();
-if ( nameProperty )
-{
-const TDesC8& name = nameProperty->StringValue();
-if ( name ==
-XnPropertyNames::action::trigger::name::stylus::KStylusEventType )
-{
-CXnProperty* valueProperty = node->ValueL();
-if ( valueProperty )
-{
-const TDesC8& name = valueProperty->StringValue();
-if ( name == XnPropertyNames::action::trigger::name::KDownAndUp )
-{
-return ETrue;
-}
-}
-}
-}
-}
-return EFalse;
-}
-// Fetch trigger data defined in the theme
-TInt treeTriggerState( 1 );
-HBufC8* treeTriggerType( NULL );
-for ( TInt i = 0; i < treeCount; ++i )
-{
-CXnDomNode* domNode = static_cast< CXnDomNode* >( treeChildren.Item( i ) );
-CXnDomList& attrs = domNode->AttributeList();
-CXnDomAttribute* nameAttribute = static_cast< CXnDomAttribute* >(
-attrs.FindByName( XnPropertyNames::action::KName ) );
-CXnDomAttribute* valueAttribute = static_cast< CXnDomAttribute* >(
-attrs.FindByName( XnPropertyNames::action::KValue ) );
-if ( !nameAttribute || !valueAttribute )
-{
-continue;
-}
-if ( nameAttribute->Value() ==
-XnPropertyNames::action::trigger::name::stylus::KStylusState )
-{
-TLex8 lex( valueAttribute->Value() );
-lex.Val( treeTriggerState );
-}
-else if ( nameAttribute->Value() ==
-XnPropertyNames::action::trigger::name::stylus::KStylusEventType )
-{
-// just in case
-if ( treeTriggerType )
-{
-CleanupStack::PopAndDestroy( treeTriggerType );
-treeTriggerType = NULL;
-}
-const TDesC8& value = valueAttribute->Value();
-treeTriggerType = HBufC8::NewL( value.Length() );
-TPtr8 ptr = treeTriggerType->Des();
-ptr = value;
-CleanupStack::PushL( treeTriggerType );
-}
-}
-// If not defined, use the default value 'up'
-if ( !treeTriggerType )
-{
-treeTriggerType = HBufC8::NewL( 10 );
-TPtr8 ptr = treeTriggerType->Des();
-ptr.Append( XnPropertyNames::action::trigger::name::KDownAndUp );
-CleanupStack::PushL( treeTriggerType );
-}
-// Fetch matching trigger data.
-TInt matchTriggerState( 1 );
-HBufC8* matchTriggerType( NULL );
-for ( TInt i = 0; i < matchCount; ++i )
-{
-CXnNode* matchNode = matchingChildren[i];
-CXnProperty* nameProperty = matchNode->NameL();
-CXnProperty* valueProperty = matchNode->ValueL();
-if ( nameProperty && valueProperty )
-{
-if ( nameProperty->StringValue() ==
-XnPropertyNames::action::trigger::name::stylus::KStylusState )
-{
-TLex8 lex( valueProperty->StringValue() );
-lex.Val( matchTriggerState );
-}
-else if ( nameProperty->StringValue() ==
-XnPropertyNames::action::trigger::name::stylus::KStylusEventType )
-{
-// just in case
-if ( matchTriggerType )
-{
-CleanupStack::PopAndDestroy( matchTriggerType );
-matchTriggerType = NULL;
-}
-const TDesC8& value = valueProperty->StringValue();
-matchTriggerType = HBufC8::NewL( value.Length() );
-TPtr8 ptr = matchTriggerType->Des();
-ptr = value;
-CleanupStack::PushL( matchTriggerType );
-}
-}
-}
-if ( treeTriggerState == matchTriggerState )
-{
-// just in case
-if ( !matchTriggerType )
-{
-ret = EFalse;
-}
-else if ( treeTriggerType->Des() == matchTriggerType->Des() )
-{
-ret = ETrue;
-}
-// still, if trigger type is 'KUp' it should match to 'KDownAndUp' event
-else if ( treeTriggerType->Des() ==
-XnPropertyNames::action::trigger::name::KUp )
-{
-if ( matchTriggerType->Des() ==
-XnPropertyNames::action::trigger::name::KDownAndUp )
-{
-ret = ETrue;
-}
-}
-}
-if ( matchTriggerType )
-{
-CleanupStack::PopAndDestroy( matchTriggerType );
-}
-if ( treeTriggerType )
-{
-CleanupStack::PopAndDestroy( treeTriggerType );
-}
-return ret;
-}
-// -----------------------------------------------------------------------------
 // MatchActivateTriggerPropertiesL
 // Checks if triggered node properties match
 // ones defined in theme
 // -----------------------------------------------------------------------------
 //
 CXnDomNode& aTriggerNode )
 {
 CXnDomList& attributeList( aTriggerNode.AttributeList() );
 const TDesC8& reason(
-XnPropertyNames::action::trigger::name::uidefinitionmodification::KReason );
+XnPropertyNames::action::trigger::name::orientation::KReason );
 CXnDomAttribute* attribute( static_cast< CXnDomAttribute* >
 ( attributeList.FindByName( reason ) ) );
 if ( !attribute )
 }
 const TDesC8& value( attribute->Value() );
 if ( value ==
-XnPropertyNames::action::trigger::name::uidefinitionmodification::reason::KLandscape ||
+XnPropertyNames::action::trigger::name::orientation::reason::KLandscape ||
 value ==
-XnPropertyNames::action::trigger::name::uidefinitionmodification::reason::KPortrait )
+XnPropertyNames::action::trigger::name::orientation::reason::KPortrait )
 {
 CXnProperty* reasonProp( aEventData.GetPropertyL( reason ) );
 if ( reasonProp )
 {
 CXnUiEngine& aEngine,
 CXnNode& aNode,
 CXnNode& aEventData,
 CXnDomNode& aActionNode,
 CXnDomNode& aTriggerNode,
-TInt aSource )
+TInt /*aSource*/ )
 {
 const TDesC8& nameString( aTriggerNode.AttributeValue( KName ) );
 if ( nameString == KNullDesC8 )
 {
 CXnProperty* eventName( aEventData.NameL() );
 const TDesC8& eventNameString( eventName->StringValue() );
 if ( nameString == eventNameString )
 {
-if ( nameString == XnPropertyNames::action::trigger::name::KStylus )
-{
-if ( !MatchStylusTriggerL( aEventData, aTriggerNode ) )
-{
-return EFalse;
-}
-}
 // Check if triggernode properties match the ones defined in theme
 // This is for identifying keyup in activate-trigger
-else if ( nameString == XnPropertyNames::action::trigger::name::KActivate )
+if ( nameString == XnPropertyNames::action::trigger::name::KActivate )
 {
 if ( !MatchActivateTriggerPropertiesL( aEventData, aTriggerNode ) )
-{
-return EFalse;
-}
-}
-// Check if the trigger is timed trigger
-else if ( MatchTimedTriggerPropertiesL( aTriggerNode ) )
-{
-if ( !aThis->PeriodicTimer() )
-{
-aThis->CreatePeriodicL();
-}
-if ( !aThis->PeriodicTimer()->IsActive() )
-{
-TXnTimedTrigger* params = new ( ELeave ) TXnTimedTrigger;
-CleanupStack::PushL( params );
-params->iNodeImpl = aThis;
-params->iEngine = &aEngine;
-params->iNode = &aNode;
-params->iEventData = &aEventData;
-params->iActionNode = &aActionNode;
-params->iTriggerNode = &aTriggerNode;
-TInt delay( 0 );
-ResolveTriggerDelayL( aEngine, aTriggerNode, delay );
-aNode.SetTriggerDelay( delay );
-CleanupStack::Pop( params );
-aThis->PeriodicTimer()->Start(
-TTimeIntervalMicroSeconds32( delay ),
-TTimeIntervalMicroSeconds32( delay ),
-TCallBack( CXnNodeImpl::PeriodicEventL, params ) );
-return ETrue;
-}
-else
 {
 return EFalse;
 }
 }
 else if ( nameString == XnPropertyNames::action::trigger::name::KTitleToScroll ||
 nameString == XnPropertyNames::action::trigger::name::KEditMode )
 {
 if ( !MatchValueAttributeTriggerL( aEventData, aTriggerNode ) )
 {
 return EFalse;
-}
-}
-else if ( aSource != XnEventSource::EUnknown )
-{
-CXnDomAttribute* attr = static_cast< CXnDomAttribute* >
-( aTriggerNode.AttributeList().FindByName(
-XnPropertyNames::common::KEventFilter ) );
-if ( attr )
-{
-if ( attr->Value().Find(XnPropertyNames::action::trigger::name::KStylus)
-!= KErrNotFound &&
-aSource == XnEventSource::EStylus )
-{
-return EFalse;
-}
-else if ( attr->Value().Find(XnPropertyNames::action::trigger::name::KKeyEvent)
-!= KErrNotFound &&
-aSource == XnEventSource::EKey )
-{
-return EFalse;
-}
 }
 }
 RunEventsL( aThis, aEngine, aNode, aActionNode, aTriggerNode, aEventData );
 adapter.HandleXuikonEventL(
 aNode.AppIfL(), aEventData.AppIfL(), aTriggerNode, aEventNode );
 }
 // -----------------------------------------------------------------------------
-// RunAppExit
-// -----------------------------------------------------------------------------
-//
-static void RunAppExit( CXnUiEngine& aEngine )
-{
-CXnAppUiAdapter& adapter( aEngine.AppUiAdapter() );
-adapter.Exit();
-}
-// -----------------------------------------------------------------------------
 // RunFullScreenEffectL
 // -----------------------------------------------------------------------------
 //
 static void RunFullScreenEffectL( CXnUiEngine& aEngine, CXnDomNode& aEventNode )
 {
 //
 static void RunEditL(
 CXnNodeImpl* aThis,
 CXnUiEngine& aEngine,
 CXnDomNode& aEventNode )
 {
-TBool keyEditMode(EFalse);
 aEngine.DisableRenderUiLC();
 // Set plugins to edit state
 RPointerArray< CXnPluginData>& plugins(
 aEngine.ViewManager()->ActiveViewData().PluginData() );
 }
 }
 CleanupStack::PopAndDestroy( array );
 }
-else if ( name == XnPropertyNames::common::KKeyMoveMode )
+}
-{
+}
-if ( value == XnPropertyNames::KTrue )
+}
-{
+TBool useEmpty( aEngine.ViewManager()->ActiveViewData().UseEmptyWidget() );
-keyEditMode = ETrue;
-}
+for ( TInt i = 0; i < plugins.Count(); i++ )
-}
+{
-}
+CXnNode* node( plugins[i]->Owner()->LayoutNode() );
-}
-}
-if ( keyEditMode )
-{
-for ( TInt i = 0; i < plugins.Count(); i++ )
-{
-if ( plugins[i]->Occupied() )
-{
-CXnNode* node( plugins[i]->Owner()->LayoutNode() );
-node->SetStateL( XnPropertyNames::style::common::KEdit );
-}
-}
-aEngine.EditMode()->SetEditModeL( CXnEditMode::EKeyMove );
+node->SetStateL( XnPropertyNames::style::common::KEdit );
-// Put focus to parent plugin if focused node is not a plugin already
+if ( !plugins[i]->Occupied() && useEmpty )
-CXnNode* focusedNode = aEngine.FocusedNode();
+{
+// Make empty space visible
-if ( focusedNode && focusedNode->DomNode()->Name() != _L8( "plugin" ) )
+SetStringPropertyToNodeL( *sp, *node,
-{
+XnPropertyNames::style::common::KVisibility,
-for ( CXnNode* candidate =
+XnPropertyNames::style::common::visibility::KVisible );
-focusedNode; candidate; candidate = candidate->Parent() )
+}
-{
+}
-if ( candidate->DomNode()->Name() == _L8( "plugin" ) )
-{
-candidate->SetStateL( XnPropertyNames::style::common::KFocus );
-break;
-}
-}
-}
-}
-else
-{
-TBool useEmpty( aEngine.ViewManager()->ActiveViewData().UseEmptyWidget() );
-for ( TInt i = 0; i < plugins.Count(); i++ )
-{
-CXnNode* node( plugins[i]->Owner()->LayoutNode() );
-node->SetStateL( XnPropertyNames::style::common::KEdit );
-if ( !plugins[i]->Occupied() && useEmpty )
-{
-// Make empty space visible
-SetStringPropertyToNodeL( *sp, *node,
-XnPropertyNames::style::common::KVisibility,
-XnPropertyNames::style::common::visibility::KVisible );
-}
-}
 aEngine.EditMode()->SetEditModeL( CXnEditMode::EDragAndDrop );
-aEngine.AppUiAdapter().ViewAdapter().BgManager().DrawNow();
+aEngine.AppUiAdapter().ViewAdapter().CloseAllPopupsL();
-}
 CleanupStack::PopAndDestroy();
 aEngine.AppUiAdapter().ViewAdapter().UpdateRskByModeL();
 }
 static void RunResetEditL(
 CXnNodeImpl* aThis,
 CXnUiEngine& aEngine,
 CXnDomNode& aEventNode )
 {
-TBool keyEditMode(
-aEngine.EditMode()->EditState() == CXnEditMode::EKeyMove );
 CXnDomList& children( aEventNode.ChildNodes() );
 TInt count( children.Length() );
 for ( TInt i = 0; i < count; ++i )
 RPointerArray< CXnPluginData>& plugins(
 aEngine.ViewManager()->ActiveViewData().PluginData() );
 CXnDomStringPool* sp( aEventNode.StringPool() );
-if ( keyEditMode )
+TBool useEmpty( aEngine.ViewManager()->ActiveViewData().UseEmptyWidget() );
-{
 for ( TInt i = 0; i < plugins.Count(); i++ )
 {
-if ( plugins[i]->Occupied() )
+CXnNode* node( plugins[i]->Owner()->LayoutNode() );
-{
-CXnNode* node( plugins[i]->Owner()->LayoutNode() );
-node->UnsetStateL( XnPropertyNames::style::common::KEdit );
-}
-}
-}
-else
-{
-TBool useEmpty( aEngine.ViewManager()->ActiveViewData().UseEmptyWidget() );
-for ( TInt i = 0; i < plugins.Count(); i++ )
+node->UnsetStateL( XnPropertyNames::style::common::KEdit );
-{
-CXnNode* node( plugins[i]->Owner()->LayoutNode() );
+if ( !plugins[i]->Occupied() && useEmpty )
+{
-node->UnsetStateL( XnPropertyNames::style::common::KEdit );
+// Make empty space blank
+SetStringPropertyToNodeL( *sp, *node,
-if ( !plugins[i]->Occupied() && useEmpty )
+XnPropertyNames::style::common::KVisibility,
-{
+XnPropertyNames::style::common::visibility::KBlank );
-// Make empty space blank
+}
-SetStringPropertyToNodeL( *sp, *node,
+}
-XnPropertyNames::style::common::KVisibility,
-XnPropertyNames::style::common::visibility::KBlank );
-}
-}
-}
 aEngine.EditMode()->SetEditModeL( CXnEditMode::ENone );
-aEngine.AppUiAdapter().ViewAdapter().BgManager().DrawNow();
 aEngine.AppUiAdapter().ViewAdapter().UpdateRskByModeL();
 }
 // -----------------------------------------------------------------------------
 CleanupStack::PushL( propertyValue );
 aNode->SetPropertyL( propertyValue );
 CleanupStack::Pop( propertyValue );
-}
-}
-// -----------------------------------------------------------------------------
-// RunResetStylusCounterL
-// -----------------------------------------------------------------------------
-//
-static void RunResetStylusCounterL(
-CXnNodeImpl* aThis,
-CXnUiEngine& aEngine,
-const TDesC8& aId )
-{
-CXnNode* node( aEngine.FindNodeByIdL( aId, aThis->Namespace() ) );
-if ( node )
-{
-CXnControlAdapter* adapter( node->Control() );
-if ( adapter )
-{
-adapter->ResetStylusCounter();
-}
 }
 }
 // -----------------------------------------------------------------------------
 // GetSystemSetDataL
 RPointerArray< CXnPluginData > plugins;
 CleanupClosePushL( plugins );
 for( TInt i = 0; i < pluginNodes.Count(); i++ )
 {
-CXnPluginData& data( viewData.Plugin( pluginNodes[i] ) );
+CXnPluginData* data( viewData.Plugin( pluginNodes[i] ) );
-if( data.Occupied() )
+if( data && data->Occupied() )
 {
-plugins.AppendL( &data );
+plugins.AppendL( data );
 }
 }
 plugins.Append( &viewData );
 }
 CleanupStack::PopAndDestroy( array );
 }
 CleanupStack::PopAndDestroy( 2, &values );
-}
-// -----------------------------------------------------------------------------
-// ResolveTriggerDelayL
-// -----------------------------------------------------------------------------
-//
-static void ResolveTriggerDelayL(
-CXnUiEngine& /*aEngine*/,
-CXnDomNode& aNode,
-TInt& aDelay )
-{
-CXnDomList& children = aNode.ChildNodes();
-for ( TInt i = 0; i < children.Length(); i++ )
-{
-CXnDomNode* child = static_cast< CXnDomNode* >( children.Item( i ) );
-const TDesC8& name = child->AttributeValue( XnPropertyNames::action::KName );
-if ( name == XnPropertyNames::action::trigger::KDelay )
-{
-const TDesC8& value = child->AttributeValue( XnPropertyNames::action::KValue );
-if ( value != KNullDesC8 )
-{
-TInt triggerDelay( 0 );
-TLex8 lex;
-lex.Assign( value );
-lex.Val( triggerDelay );
-aDelay = triggerDelay;
-}
-}
-}
 }
 // -----------------------------------------------------------------------------
 // RunEventL
 // -----------------------------------------------------------------------------
 else if ( nameString == XnPropertyNames::action::event::KResetEditMode )
 {
 RunResetEditL( aThis, aEngine, aEventNode );
 return ETrue;
 }
-else if ( nameString == XnPropertyNames::action::event::KResetStylusCounter )
-{
-HBufC8* id( NULL );
-GetSystemSetDataL( aEventNode, id );
-CleanupStack::PushL( id );
-RunResetStylusCounterL( aThis, aEngine, *id );
-CleanupStack::PopAndDestroy( id );
-return EFalse;
-}
 else if ( nameString == XnPropertyNames::action::event::KRunAddWidgetQuery )
 {
 aEngine.Editor()->AddWidgetL();
 }
 else if ( nameString == XnPropertyNames::action::event::KRemoveFocusedWidget )
 }
 else if ( nameString == XnPropertyNames::action::event::KDeactivate )
 {
 RunDeactivateL( aThis, aEngine, aEventNode );
 return ETrue;
-}
-else if ( nameString == XnPropertyNames::action::event::KExit )
-{
-RunAppExit( aEngine );
 }
 else if ( nameString == XnPropertyNames::action::event::KTryDisplayingMenu )
 {
 RunTryDisplayingMenuL( aEngine, aEventNode );
 }
 CleanupStack::PopAndDestroy( trigger );
 return ETrue;
 }
-else if ( nameString == XnPropertyNames::action::event::KRestartTriggerTimer )
-{
-TInt delay( 0 );
-ResolveTriggerDelayL( aEngine, aEventNode, delay );
-if ( delay > 0 )
-{
-aNode.RestartTimedTrigger( delay );
-}
-else
-{
-TTimeIntervalMicroSeconds32 delayms = aNode.TriggerDelay();
-aNode.RestartTimedTrigger( delayms.Int() );
-}
-return ETrue;
-}
-else if ( nameString == XnPropertyNames::action::event::KCancelTriggerTimer )
-{
-aNode.RestartTimedTrigger();
-return ETrue;
-}
 else if ( nameString == XnPropertyNames::action::event::KSetWallpaper )
 {
 aEngine.AppUiAdapter().ViewAdapter().BgManager().SetWallpaperL();
 return ETrue;
 }
 XnPropertyNames::style::common::KS60NavLooping );
 if ( navLoopProperty )
 {
 const TDesC8& loopValue = navLoopProperty->StringValue();
 if ( loopValue != KNullDesC8 &&
-loopValue == XnPropertyNames::grid::s60_focus_looping::KStop )
+loopValue == XnPropertyNames::style::common::s60_focus_looping::KStop )
 {
 return NULL;
 }
 }
 if ( aForward )
 CXnProperty* navind = aNode.NavIndexL();
 if ( navind && navind->StringValue() == XnPropertyNames::style::common::KAppearance )
 {
 CXnAppUiAdapter& appui = static_cast< CXnAppUiAdapter& >( *iAvkonAppUi );
-CXnPluginData& plugin(
+CXnPluginData* plugin(
 appui.ViewManager().ActiveViewData().Plugin( &aNode ) );
 // find if node is in a widget that contatins some opened popup window
+TBool containsPopUp = ( plugin ? plugin->IsDisplayingPopup() : EFalse );
-TBool containsPopUp = plugin.IsDisplayingPopup();
 CXnNode* nextNode( NULL );
 RPointerArray< CXnNode >& array = aEngine.ViewManager()->AppearanceNodes();
 if ( aKeyEvent.iScanCode == EStdKeyDownArrow )
 {
 nextNode = FindNextNodeFromBelowL( array, aNode, containsPopUp );
 CXnProperty* navLoopProperty = aNode->GetPropertyL(
 XnPropertyNames::style::common::KS60NavLooping );
 if ( navLoopProperty )
 {
 const TDesC8& loopValue = navLoopProperty->StringValue();
-if ( loopValue == XnPropertyNames::grid::s60_focus_looping::KStop )
+if ( loopValue == XnPropertyNames::style::common::s60_focus_looping::KStop )
 {
 return EFalse;
 }
 }
 return ETrue;
 delete iPropertyList;
 delete iType;
 iPropertyPseudoClasses.Reset();
 iStates.Reset();
 iChildren.ResetAndDestroy();
-delete iGridPropertyCache;
 delete iLayoutPropertyCache;
-DeletePeriodic();
 }
 // -----------------------------------------------------------------------------
 // CXnNodeImpl::SetNode
 // -----------------------------------------------------------------------------
 // Set a property.
 // -----------------------------------------------------------------------------
 //
 const TDesC8& CXnNodeImpl::GetPCData()
 {
-if ( iRef )
-{
-CXnNode* refNode( NULL );
-TRAP_IGNORE( refNode = RefNodeL( this, iRef, iUiEngine ) );
-if ( refNode )
-{
-return refNode->GetPCData();
-}
-}
 return iDomNode->PCData();
 }
 // -----------------------------------------------------------------------------
 // CXnNodeImpl::SetHandleTooltip()
 // -----------------------------------------------------------------------------
 // CXnNodeImpl::ShowPopupsL()
 // Searchs and shoes tooltips
 // -----------------------------------------------------------------------------
 //
-void CXnNodeImpl::ShowPopupsL( TRect aRect, TInt /*aSource*/ )
+void CXnNodeImpl::ShowPopupsL( TRect aRect, TInt aSource )
 {
 if ( iHandleTooltip )
 {
 for ( TInt i = 0; i < iChildren.Count(); i++ )
 {
 XnComponentInterface::MakeInterfaceL( popup, tooltipNode );
 if ( popup )
 {
-popup->ShowPopupL( aRect );
+if ( aSource == XnEventSource::EStylus )
+{
+const TTimeIntervalMicroSeconds32 delay( 0 );
+const TTimeIntervalMicroSeconds32 display( 1000 * 1000 * 6 );
+popup->ShowPopupL( aRect, delay, display );
+}
+else
+{
+popup->ShowPopupL( aRect );
+}
 }
 }
 }
 }
 }
 //
 TInt CXnNodeImpl::DoSetPropertyL( CXnProperty* aProperty )
 {
 TInt level( XnDirtyLevel::ENone );
-const TDesC8* refid( CheckRefAttributeL( iRef ) );
-if ( refid && aProperty->Property()->Name() != XnPropertyNames::common::KId )
-{
-delete aProperty;
-return level;
-}
 const TDesC8& name( aProperty->Property()->Name() );
 CXnProperty* prop( GetPropertyL( name ) );
 if ( prop && prop->EqualsL( *aProperty ) )
 if ( IsStateSet( PseudoClassName( pseudoClass ) ) )
 {
 SetCachedProperty(
 aProperty,
 iLayoutPropertyCache,
-iRef,
 iName,
 iValue,
 iLabel,
 iInitialFocus,
 iClass,
 iId,
 iPath,
 iMaskPath,
-iGridPropertyCache,
 EFalse,
 EFalse );
 }
 }
 else
 {
 SetCachedProperty(
 aProperty,
 iLayoutPropertyCache,
-iRef,
 iName,
 iValue,
 iLabel,
 iInitialFocus,
 iClass,
 iId,
 iPath,
 iMaskPath,
-iGridPropertyCache,
 EFalse,
 EFalse );
 }
 iPropertyList->SetPropertyL( aProperty );
 // Set a property.
 // -----------------------------------------------------------------------------
 //
 void CXnNodeImpl::InitializePropertyL( CXnProperty* aProperty )
 {
-const TDesC8* refid( CheckRefAttributeL( iRef ) );
-if ( refid && aProperty->Property()->Name() != XnPropertyNames::common::KId )
-{
-delete aProperty;
-return;
-}
 if ( aProperty->Property()->PseudoClass() != CXnDomProperty::ENone )
 {
 InsertPropertyPseudoClassL(
 aProperty->Property()->PseudoClass(), iPropertyPseudoClasses );
 SetCachedProperty(
 aProperty,
 iLayoutPropertyCache,
-iRef,
 iName,
 iValue,
 iLabel,
 iInitialFocus,
 iClass,
 iId,
 iPath,
 iMaskPath,
-iGridPropertyCache,
 ETrue,
 ETrue );
 }
 else
 {
 SetCachedProperty(
 aProperty,
 iLayoutPropertyCache,
-iRef,
 iName,
 iValue,
 iLabel,
 iInitialFocus,
 iClass,
 iId,
 iPath,
 iMaskPath,
-iGridPropertyCache,
 ETrue,
 EFalse );
 }
 iPropertyList->SetPropertyL( aProperty );
 // Gets a property.
 // -----------------------------------------------------------------------------
 //
 CXnProperty* CXnNodeImpl::GetPropertyL( const TDesC8& aKey )
 {
-CXnNode* refNode( RefNodeL( this, iRef, iUiEngine ) ) ;
-if ( refNode && aKey != KRef && aKey != KId )
-{
-return refNode->GetPropertyL( aKey );
-}
 CXnDomProperty* attribute = NULL;
 CXnProperty* property = iPropertyList->GetProperty( aKey );
 if ( property )
 {
 // -----------------------------------------------------------------------------
 // PropertyL
 // Returns a property.
 // -----------------------------------------------------------------------------
 //
-static CXnProperty* PropertyL( CXnNodeImpl* aThis, CXnProperty* aProperty,
+static CXnProperty* PropertyL( CXnProperty* aProperty,
-CXnProperty* ( CXnNode::* aFunc )(), CXnUiEngine* aUiEngine,
+CXnProperty* ( CXnNode::* aFunc )(),
-TAny* aLayoutPropertyCache, CXnNode* aParent, CXnProperty* aRef )
+TAny* aLayoutPropertyCache, CXnNode* aParent )
 {
-CXnNode* refNode( RefNodeL( aThis, aRef, aUiEngine ) ) ;
-if ( refNode )
-{
-return ( refNode->*aFunc )();
-}
 if ( aLayoutPropertyCache && aProperty )
 {
 CXnDomProperty* attribute = aProperty->Property();
 CXnDomList& list = attribute->PropertyValueList();
 return NULL;
 }
 // -----------------------------------------------------------------------------
-// ReferredPropertyL
-// Returns a referred property.
-// -----------------------------------------------------------------------------
-//
-static CXnProperty* ReferredPropertyL(
-RPointerArray< CXnProperty >* aPropertyArray,
-RArray< CXnDomProperty::TPseudoClass >& aStates )
-{
-if ( !aPropertyArray )
-{
-return NULL;
-}
-for ( TInt i = aPropertyArray->Count() - 1; i >= 0; --i )
-{
-CXnProperty* tmp = ( *aPropertyArray )[i];
-for ( TInt j = aStates.Count() - 1; j >= 0; --j )
-{
-if ( aStates[j] == tmp->Property()->PseudoClass() )
-{
-return tmp;
-}
-}
-for ( TInt j = aStates.Count() - 1; j >= 0; --j )
-{
-if ( tmp->Property()->PseudoClass() == CXnDomProperty::ENone )
-{
-return tmp;
-}
-}
-}
-for ( TInt i = aPropertyArray->Count() - 1; i >= 0; --i )
-{
-CXnProperty* tmp = ( *aPropertyArray )[i];
-if ( tmp->Property()->PseudoClass() == CXnDomProperty::ENone )
-{
-return tmp;
-}
-}
-return NULL;
-}
-// -----------------------------------------------------------------------------
-// RefNodeL
-// Returns referred node.
-// -----------------------------------------------------------------------------
-//
-static CXnNode* RefNodeL(
-CXnNodeImpl* aThis,
-CXnProperty* aRef,
-CXnUiEngine* aUiEngine )
-{
-const TDesC8* refid( CheckRefAttributeL( aRef ) );
-if ( refid )
-{
-CXnNode* node( aUiEngine->FindNodeByIdL( *refid, aThis->Namespace() ) );
-if ( node )
-{
-return node;
-}
-}
-return NULL;
-}
-// -----------------------------------------------------------------------------
 // CXnNodeImpl::WidthL
 // Returns width property.
 // -----------------------------------------------------------------------------
 //
 CXnProperty* CXnNodeImpl::WidthL()
 {
-CXnNode* refNode = RefNodeL( this, iRef, iUiEngine );
-if ( refNode )
-{
-RPointerArray< CXnProperty >* propertyArray =
-refNode->Impl()->iLayoutPropertyCache ?
-&( refNode->Impl()->iLayoutPropertyCache->iWidths ) :
-NULL;
-return ReferredPropertyL( propertyArray, iStates );
-}
 CXnProperty* property =
 iLayoutPropertyCache ? iLayoutPropertyCache->iWidth : NULL;
-return PropertyL( this, property, &CXnNode::WidthL,
+return PropertyL( property, &CXnNode::WidthL,
-iUiEngine, iLayoutPropertyCache,
+iLayoutPropertyCache, iParent );
-iParent, iRef );
 }
 // -----------------------------------------------------------------------------
 // CXnNodeImpl::HeightL
 // Returns height property.
 // -----------------------------------------------------------------------------
 //
 CXnProperty* CXnNodeImpl::HeightL()
 {
-CXnNode* refNode = RefNodeL( this, iRef, iUiEngine );
-if (refNode)
-{
-RPointerArray< CXnProperty >* propertyArray =
-refNode->Impl()->iLayoutPropertyCache ?
-&( refNode->Impl()->iLayoutPropertyCache->iHeights ) :
-NULL;
-return ReferredPropertyL( propertyArray, iStates );
-}
 CXnProperty* property =
 iLayoutPropertyCache ? iLayoutPropertyCache->iHeight : NULL;
-return PropertyL( this, property, &CXnNode::HeightL,
+return PropertyL( property, &CXnNode::HeightL,
-iUiEngine, iLayoutPropertyCache,
+iLayoutPropertyCache, iParent );
-iParent, iRef );
 }
 // -----------------------------------------------------------------------------
 // CXnNodeImpl::MarginLeftL
 // Returns margin-left property.
 // -----------------------------------------------------------------------------
 //
 CXnProperty* CXnNodeImpl::MarginLeftL()
 {
-CXnNode* refNode = RefNodeL( this, iRef, iUiEngine );
-if ( refNode )
-{
-RPointerArray< CXnProperty >* propertyArray =
-refNode->Impl()->iLayoutPropertyCache ?
-&( refNode->Impl()->iLayoutPropertyCache->iMarginLefts ) :
-NULL;
-return ReferredPropertyL( propertyArray, iStates );
-}
 CXnProperty* property =
 iLayoutPropertyCache ?
 iLayoutPropertyCache->iMarginLeft :
 NULL;
-return PropertyL( this, property, &CXnNode::MarginLeftL,
+return PropertyL( property, &CXnNode::MarginLeftL,
-iUiEngine, iLayoutPropertyCache,
+iLayoutPropertyCache, iParent );
-iParent, iRef );
 }
 // -----------------------------------------------------------------------------
 // CXnNodeImpl::MarginRightL
 // Returns margin-right property.
 // -----------------------------------------------------------------------------
 //
 CXnProperty* CXnNodeImpl::MarginRightL()
 {
-CXnNode* refNode = RefNodeL( this, iRef, iUiEngine );
-if ( refNode )
-{
-RPointerArray< CXnProperty >* propertyArray =
-refNode->Impl()->iLayoutPropertyCache ?
-&( refNode->Impl()->iLayoutPropertyCache->iMarginRights ) :
-NULL;
-return ReferredPropertyL(propertyArray, iStates);
-}
 CXnProperty* property =
 iLayoutPropertyCache ?
 iLayoutPropertyCache->iMarginRight :
 NULL;
-return PropertyL( this, property, &CXnNode::MarginRightL,
+return PropertyL( property, &CXnNode::MarginRightL,
-iUiEngine, iLayoutPropertyCache,
+iLayoutPropertyCache, iParent );
-iParent, iRef );
 }
 // -----------------------------------------------------------------------------
 // CXnNodeImpl::BorderLeftL
 // Returns border-left property.
 // -----------------------------------------------------------------------------
 //
 CXnProperty* CXnNodeImpl::BorderLeftL()
 {
-CXnNode* refNode = RefNodeL( this, iRef, iUiEngine );
-if ( refNode )
-{
-RPointerArray< CXnProperty >* propertyArray =
-refNode->Impl()->iLayoutPropertyCache ?
-&( refNode->Impl()->iLayoutPropertyCache->iBorderLefts ) :
-NULL;
-return ReferredPropertyL( propertyArray, iStates );
-}
 CXnProperty* property = iLayoutPropertyCache ?
 iLayoutPropertyCache->iBorderLeft :
 NULL;
-return PropertyL( this, property, &CXnNode::BorderLeftL,
+return PropertyL( property, &CXnNode::BorderLeftL,
-iUiEngine, iLayoutPropertyCache,
+iLayoutPropertyCache, iParent );
-iParent, iRef );
 }
 // -----------------------------------------------------------------------------
 // CXnNodeImpl::BorderRightL
 // Returns border-right property.
 // -----------------------------------------------------------------------------
 //
 CXnProperty* CXnNodeImpl::BorderRightL()
 {
-CXnNode* refNode = RefNodeL( this, iRef, iUiEngine );
-if ( refNode )
-{
-RPointerArray< CXnProperty >* propertyArray =
-refNode->Impl()->iLayoutPropertyCache ?
-&( refNode->Impl()->iLayoutPropertyCache->iBorderRights ) :
-NULL;
-return ReferredPropertyL( propertyArray, iStates );
-}
 CXnProperty* property =
 iLayoutPropertyCache ?
 iLayoutPropertyCache->iBorderRight :
 NULL;
-return PropertyL( this, property, &CXnNode::BorderRightL,
+return PropertyL( property, &CXnNode::BorderRightL,
-iUiEngine, iLayoutPropertyCache,
+iLayoutPropertyCache, iParent );
-iParent, iRef );
 }
 // -----------------------------------------------------------------------------
 // CXnNodeImpl::PaddingLeftL
 // Returns padding-left property.
 // -----------------------------------------------------------------------------
 //
 CXnProperty* CXnNodeImpl::PaddingLeftL()
 {
-CXnNode* refNode = RefNodeL( this, iRef, iUiEngine );
-if ( refNode )
-{
-RPointerArray< CXnProperty >* propertyArray =
-refNode->Impl()->iLayoutPropertyCache ?
-&( refNode->Impl()->iLayoutPropertyCache->iPaddingLefts ) :
-NULL;
-return ReferredPropertyL( propertyArray, iStates );
-}
 CXnProperty* property =
 iLayoutPropertyCache ?
 iLayoutPropertyCache->iPaddingLeft :
 NULL;
-return PropertyL( this, property, &CXnNode::PaddingLeftL,
+return PropertyL( property, &CXnNode::PaddingLeftL,
-iUiEngine, iLayoutPropertyCache,
+iLayoutPropertyCache, iParent );
-iParent, iRef );
 }
 // -----------------------------------------------------------------------------
 // CXnNodeImpl::PaddingRightL
 // Returns PaddingRightL property.
 // -----------------------------------------------------------------------------
 //
 CXnProperty* CXnNodeImpl::PaddingRightL()
 {
-CXnNode* refNode = RefNodeL( this, iRef, iUiEngine );
-if ( refNode )
-{
-RPointerArray< CXnProperty >* propertyArray =
-refNode->Impl()->iLayoutPropertyCache ?
-&( refNode->Impl()->iLayoutPropertyCache->iPaddingRights ) :
-NULL;
-return ReferredPropertyL( propertyArray, iStates );
-}
 CXnProperty* property =
 iLayoutPropertyCache ? iLayoutPropertyCache->iPaddingRight : NULL;
-return PropertyL( this, property, &CXnNode::PaddingRightL,
+return PropertyL( property, &CXnNode::PaddingRightL,
-iUiEngine, iLayoutPropertyCache,
+iLayoutPropertyCache, iParent );
-iParent, iRef );
 }
 // -----------------------------------------------------------------------------
 // CXnNodeImpl::MarginTopL
 // Returns margin-top property.
 // -----------------------------------------------------------------------------
 //
 CXnProperty* CXnNodeImpl::MarginTopL()
 {
-CXnNode* refNode = RefNodeL( this, iRef, iUiEngine );
-if ( refNode )
-{
-RPointerArray< CXnProperty >* propertyArray =
-refNode->Impl()->iLayoutPropertyCache ?
-&( refNode->Impl()->iLayoutPropertyCache->iMarginTops ) :
-NULL;
-return ReferredPropertyL( propertyArray, iStates );
-}
 CXnProperty* property =
 iLayoutPropertyCache ? iLayoutPropertyCache->iMarginTop : NULL;
-return PropertyL( this, property, &CXnNode::MarginTopL,
+return PropertyL( property, &CXnNode::MarginTopL,
-iUiEngine, iLayoutPropertyCache,
+iLayoutPropertyCache, iParent );
-iParent, iRef );
 }
 // -----------------------------------------------------------------------------
 // CXnNodeImpl::MarginBottomL
 // Returns margin-bottom property.
 // -----------------------------------------------------------------------------
 //
 CXnProperty* CXnNodeImpl::MarginBottomL()
 {
-CXnNode* refNode = RefNodeL( this, iRef, iUiEngine );
-if ( refNode )
-{
-RPointerArray< CXnProperty >* propertyArray =
-refNode->Impl()->iLayoutPropertyCache ?
-&( refNode->Impl()->iLayoutPropertyCache->iMarginBottoms ) :
-NULL;
-return ReferredPropertyL( propertyArray, iStates );
-}
 CXnProperty* property =
 iLayoutPropertyCache ? iLayoutPropertyCache->iMarginBottom : NULL;
-return PropertyL( this, property, &CXnNode::MarginBottomL,
+return PropertyL( property, &CXnNode::MarginBottomL,
-iUiEngine, iLayoutPropertyCache,
+iLayoutPropertyCache, iParent );
-iParent, iRef );
 }
 // -----------------------------------------------------------------------------
 // CXnNodeImpl::BorderTopL
 // Returns border-top property.
 // -----------------------------------------------------------------------------
 //
 CXnProperty* CXnNodeImpl::BorderTopL()
 {
-CXnNode* refNode = RefNodeL( this, iRef, iUiEngine );
-if ( refNode )
-{
-RPointerArray< CXnProperty >* propertyArray =
-refNode->Impl()->iLayoutPropertyCache ?
-&( refNode->Impl()->iLayoutPropertyCache->iBorderTops ) :
-NULL;
-return ReferredPropertyL( propertyArray, iStates );
-}
 CXnProperty* property =
 iLayoutPropertyCache ? iLayoutPropertyCache->iBorderTop : NULL;
-return PropertyL( this, property, &CXnNode::BorderTopL,
+return PropertyL( property, &CXnNode::BorderTopL,
-iUiEngine, iLayoutPropertyCache,
+iLayoutPropertyCache, iParent );
-iParent, iRef );
 }
 // -----------------------------------------------------------------------------
 // CXnNodeImpl::BorderBottomL
 // Returns border-bottom property.
 // -----------------------------------------------------------------------------
 //
 CXnProperty* CXnNodeImpl::BorderBottomL()
 {
-CXnNode* refNode = RefNodeL( this, iRef, iUiEngine );
-if ( refNode )
-{
-RPointerArray< CXnProperty >* propertyArray =
-refNode->Impl()->iLayoutPropertyCache ?
-&( refNode->Impl()->iLayoutPropertyCache->iBorderBottoms ) :
-NULL;
-return ReferredPropertyL( propertyArray, iStates );
-}
 CXnProperty* property =
 iLayoutPropertyCache ? iLayoutPropertyCache->iBorderBottom : NULL;
-return PropertyL( this, property, &CXnNode::BorderBottomL,
+return PropertyL( property, &CXnNode::BorderBottomL,
-iUiEngine, iLayoutPropertyCache,
+iLayoutPropertyCache, iParent );
-iParent, iRef );
 }
 // -----------------------------------------------------------------------------
 // CXnNodeImpl::PaddingTopL
 // Returns padding-top property.
 // -----------------------------------------------------------------------------
 //
 CXnProperty* CXnNodeImpl::PaddingTopL()
 {
-CXnNode* refNode = RefNodeL( this, iRef, iUiEngine );
-if ( refNode )
-{
-RPointerArray< CXnProperty >* propertyArray =
-refNode->Impl()->iLayoutPropertyCache ?
-&( refNode->Impl()->iLayoutPropertyCache->iPaddingTops ) :
-NULL;
-return ReferredPropertyL( propertyArray, iStates );
-}
 CXnProperty* property =
 iLayoutPropertyCache ? iLayoutPropertyCache->iPaddingTop : NULL;
-return PropertyL( this, property, &CXnNode::PaddingTopL,
+return PropertyL( property, &CXnNode::PaddingTopL,
-iUiEngine, iLayoutPropertyCache,
+iLayoutPropertyCache, iParent );
-iParent, iRef );
 }
 // -----------------------------------------------------------------------------
 // CXnNodeImpl::PaddingBottomL
 // Returns padding-bottom property.
 // -----------------------------------------------------------------------------
 //
 CXnProperty* CXnNodeImpl::PaddingBottomL()
 {
-CXnNode* refNode = RefNodeL( this, iRef, iUiEngine );
-if ( refNode )
-{
-RPointerArray< CXnProperty >* propertyArray =
-refNode->Impl()->iLayoutPropertyCache ?
-&( refNode->Impl()->iLayoutPropertyCache->iPaddingBottoms ) :
-NULL;
-return ReferredPropertyL( propertyArray, iStates );
-}
 CXnProperty* property =
 iLayoutPropertyCache ? iLayoutPropertyCache->iPaddingBottom : NULL;
-return PropertyL( this, property, &CXnNode::PaddingBottomL,
+return PropertyL( property, &CXnNode::PaddingBottomL,
-iUiEngine, iLayoutPropertyCache,
+iLayoutPropertyCache, iParent );
-iParent, iRef );
 }
 // -----------------------------------------------------------------------------
 // CXnNodeImpl::BorderWidthL
 // Returns border-width property.
 // -----------------------------------------------------------------------------
 //
 CXnProperty* CXnNodeImpl::BorderWidthL()
 {
-CXnNode* refNode = RefNodeL( this, iRef, iUiEngine );
-if ( refNode )
-{
-RPointerArray< CXnProperty >* propertyArray =
-refNode->Impl()->iLayoutPropertyCache ?
-&( refNode->Impl()->iLayoutPropertyCache->iBorderWidths ) :
-NULL;
-return ReferredPropertyL( propertyArray, iStates );
-}
 CXnProperty* property =
 iLayoutPropertyCache ? iLayoutPropertyCache->iBorderWidth : NULL;
-return PropertyL( this, property, &CXnNode::BorderWidthL,
+return PropertyL( property, &CXnNode::BorderWidthL,
-iUiEngine, iLayoutPropertyCache,
+iLayoutPropertyCache, iParent );
-iParent, iRef );
 }
 // -----------------------------------------------------------------------------
 // CXnNodeImpl::BlockProgressionL
 // Returns block-progression property.
 // -----------------------------------------------------------------------------
 //
 CXnProperty* CXnNodeImpl::BlockProgressionL()
 {
-CXnNode* refNode = RefNodeL( this, iRef, iUiEngine );
-if ( refNode )
-{
-RPointerArray< CXnProperty >* propertyArray =
-refNode->Impl()->iLayoutPropertyCache ?
-&( refNode->Impl()->iLayoutPropertyCache->iBlockProgressions ) :
-NULL;
-return ReferredPropertyL( propertyArray, iStates );
-}
 CXnProperty* property =
 iLayoutPropertyCache ? iLayoutPropertyCache->iBlockProgression : NULL;
-return PropertyL( this, property, &CXnNode::BlockProgressionL,
+return PropertyL( property, &CXnNode::BlockProgressionL,
-iUiEngine, iLayoutPropertyCache,
+iLayoutPropertyCache, iParent );
-iParent, iRef );
 }
 // -----------------------------------------------------------------------------
 // CXnNodeImpl::DirectionL
 // Returns direction property.
 // -----------------------------------------------------------------------------
 //
 CXnProperty* CXnNodeImpl::DirectionL()
 {
-CXnNode* refNode = RefNodeL( this, iRef, iUiEngine );
-if ( refNode )
-{
-RPointerArray< CXnProperty >* propertyArray =
-refNode->Impl()->iLayoutPropertyCache ?
-&( refNode->Impl()->iLayoutPropertyCache->iDirections ) :
-NULL;
-return ReferredPropertyL( propertyArray, iStates );
-}
 CXnProperty* property =
 iLayoutPropertyCache ? iLayoutPropertyCache->iDirection : NULL;
-return PropertyL( this, property, &CXnNode::DirectionL,
+return PropertyL( property, &CXnNode::DirectionL,
-iUiEngine, iLayoutPropertyCache,
+iLayoutPropertyCache, iParent );
-iParent, iRef );
 }
 // -----------------------------------------------------------------------------
 // CXnNodeImpl::PositionL
 // Returns position property.
 // -----------------------------------------------------------------------------
 //
 CXnProperty* CXnNodeImpl::PositionL()
 {
-CXnNode* refNode = RefNodeL( this, iRef, iUiEngine );
-if ( refNode )
-{
-RPointerArray< CXnProperty >* propertyArray =
-refNode->Impl()->iLayoutPropertyCache ?
-&( refNode->Impl()->iLayoutPropertyCache->iPositions ) :
-NULL;
-return ReferredPropertyL( propertyArray, iStates );
-}
 CXnProperty* property =
 iLayoutPropertyCache ? iLayoutPropertyCache->iPosition : NULL;
-return PropertyL( this, property, &CXnNode::PositionL,
+return PropertyL( property, &CXnNode::PositionL,
-iUiEngine, iLayoutPropertyCache,
+iLayoutPropertyCache, iParent );
-iParent, iRef );
 }
 // -----------------------------------------------------------------------------
 // CXnNodeImpl::MaxHeightL
 // Returns max-height property.
 // -----------------------------------------------------------------------------
 //
 CXnProperty* CXnNodeImpl::MaxHeightL()
 {
-CXnNode* refNode = RefNodeL( this, iRef, iUiEngine );
-if ( refNode )
-{
-RPointerArray< CXnProperty >* propertyArray =
-refNode->Impl()->iLayoutPropertyCache ?
-&( refNode->Impl()->iLayoutPropertyCache->iMaxHeights ) :
-NULL;
-return ReferredPropertyL( propertyArray, iStates );
-}
 CXnProperty* property =
 iLayoutPropertyCache ? iLayoutPropertyCache->iMaxHeight : NULL;
-return PropertyL( this, property, &CXnNode::MaxHeightL,
+return PropertyL( property, &CXnNode::MaxHeightL,
-iUiEngine, iLayoutPropertyCache,
+iLayoutPropertyCache, iParent );
-iParent, iRef );
 }
 // -----------------------------------------------------------------------------
 // CXnNodeImpl::MinHeightL
 // Returns min-height property.
 // -----------------------------------------------------------------------------
 //
 CXnProperty* CXnNodeImpl::MinHeightL()
 {
-CXnNode* refNode = RefNodeL( this, iRef, iUiEngine );
-if ( refNode )
-{
-RPointerArray< CXnProperty >* propertyArray =
-refNode->Impl()->iLayoutPropertyCache ?
-&( refNode->Impl()->iLayoutPropertyCache->iMinHeights ) :
-NULL;
-return ReferredPropertyL( propertyArray, iStates );
-}
 CXnProperty* property =
 iLayoutPropertyCache ? iLayoutPropertyCache->iMinHeight : NULL;
-return PropertyL( this, property, &CXnNode::MinHeightL,
+return PropertyL( property, &CXnNode::MinHeightL,
-iUiEngine, iLayoutPropertyCache,
+iLayoutPropertyCache, iParent );
-iParent, iRef );
 }
 // -----------------------------------------------------------------------------
 // CXnNodeImpl::MaxWidthL
 // Returns max-width property.
 // -----------------------------------------------------------------------------
 //
 CXnProperty* CXnNodeImpl::MaxWidthL()
 {
-CXnNode* refNode = RefNodeL( this, iRef, iUiEngine );
-if ( refNode )
-{
-RPointerArray< CXnProperty >* propertyArray =
-refNode->Impl()->iLayoutPropertyCache ?
-&( refNode->Impl()->iLayoutPropertyCache->iMaxWidths ) :
-NULL;
-return ReferredPropertyL( propertyArray, iStates );
-}
 CXnProperty* property =
 iLayoutPropertyCache ? iLayoutPropertyCache->iMaxWidth : NULL;
-return PropertyL( this, property, &CXnNode::MaxWidthL,
+return PropertyL( property, &CXnNode::MaxWidthL,
-iUiEngine, iLayoutPropertyCache,
+iLayoutPropertyCache, iParent );
-iParent, iRef );
 }
 // -----------------------------------------------------------------------------
 // CXnNodeImpl::MinWidthL
 // Returns min-width property.
 // -----------------------------------------------------------------------------
 //
 CXnProperty* CXnNodeImpl::MinWidthL()
 {
-CXnNode* refNode = RefNodeL( this, iRef, iUiEngine );
-if ( refNode )
-{
-RPointerArray< CXnProperty >* propertyArray =
-refNode->Impl()->iLayoutPropertyCache ?
-&( refNode->Impl()->iLayoutPropertyCache->iMinWidths ) :
-NULL;
-return ReferredPropertyL( propertyArray, iStates );
-}
 CXnProperty* property =
 iLayoutPropertyCache ? iLayoutPropertyCache->iMinWidth : NULL;
-return PropertyL( this, property, &CXnNode::MinWidthL,
+return PropertyL( property, &CXnNode::MinWidthL,
-iUiEngine, iLayoutPropertyCache,
+iLayoutPropertyCache, iParent );
-iParent, iRef );
 }
 // -----------------------------------------------------------------------------
 // CXnNodeImpl::DisplayL
 // Returns display property.
 // -----------------------------------------------------------------------------
 //
 CXnProperty* CXnNodeImpl::DisplayL()
 {
-CXnNode* refNode = RefNodeL( this, iRef, iUiEngine );
-if ( refNode )
-{
-RPointerArray< CXnProperty >* propertyArray =
-refNode->Impl()->iLayoutPropertyCache ?
-&( refNode->Impl()->iLayoutPropertyCache->iDisplays ) :
-NULL;
-return ReferredPropertyL( propertyArray, iStates );
-}
 CXnProperty* property =
 iLayoutPropertyCache ? iLayoutPropertyCache->iDisplay : NULL;
-return PropertyL( this, property, &CXnNode::DisplayL,
+return PropertyL( property, &CXnNode::DisplayL,
-iUiEngine, iLayoutPropertyCache,
+iLayoutPropertyCache, iParent );
-iParent, iRef );
 }
 // -----------------------------------------------------------------------------
 // CXnNodeImpl::LeftL
 // Returns left property.
 // -----------------------------------------------------------------------------
 //
 CXnProperty* CXnNodeImpl::LeftL()
 {
-CXnNode* refNode = RefNodeL( this, iRef, iUiEngine );
-if ( refNode )
-{
-RPointerArray< CXnProperty >* propertyArray =
-refNode->Impl()->iLayoutPropertyCache ?
-&( refNode->Impl()->iLayoutPropertyCache->iLefts ) :
-NULL;
-return ReferredPropertyL( propertyArray, iStates );
-}
 CXnProperty* property =
 iLayoutPropertyCache ? iLayoutPropertyCache->iLeft : NULL;
-return PropertyL( this, property, &CXnNode::LeftL,
+return PropertyL( property, &CXnNode::LeftL,
-iUiEngine, iLayoutPropertyCache,
+iLayoutPropertyCache, iParent );
-iParent, iRef );
 }
 // -----------------------------------------------------------------------------
 // CXnNodeImpl::RightL
 // Returns right property.
 // -----------------------------------------------------------------------------
 //
 CXnProperty* CXnNodeImpl::RightL()
 {
-CXnNode* refNode = RefNodeL( this, iRef, iUiEngine );
-if ( refNode )
-{
-RPointerArray< CXnProperty >* propertyArray =
-refNode->Impl()->iLayoutPropertyCache ?
-&( refNode->Impl()->iLayoutPropertyCache->iRights ) :
-NULL;
-return ReferredPropertyL( propertyArray, iStates );
-}
 CXnProperty* property =
 iLayoutPropertyCache ? iLayoutPropertyCache->iRight : NULL;
-return PropertyL( this, property, &CXnNode::RightL,
+return PropertyL( property, &CXnNode::RightL,
-iUiEngine, iLayoutPropertyCache,
+iLayoutPropertyCache, iParent );
-iParent, iRef );
 }
 // -----------------------------------------------------------------------------
 // CXnNodeImpl::TopL
 // Returns top property.
 // -----------------------------------------------------------------------------
 //
 CXnProperty* CXnNodeImpl::TopL()
 {
-CXnNode* refNode = RefNodeL( this, iRef, iUiEngine );
-if ( refNode )
-{
-RPointerArray< CXnProperty >* propertyArray =
-refNode->Impl()->iLayoutPropertyCache ?
-&( refNode->Impl()->iLayoutPropertyCache->iTops ) :
-NULL;
-return ReferredPropertyL( propertyArray, iStates );
-}
 CXnProperty* property =
 iLayoutPropertyCache ? iLayoutPropertyCache->iTop : NULL;
-return PropertyL( this, property, &CXnNode::TopL,
+return PropertyL( property, &CXnNode::TopL,
-iUiEngine, iLayoutPropertyCache,
+iLayoutPropertyCache, iParent );
-iParent, iRef );
 }
 // -----------------------------------------------------------------------------
 // CXnNodeImpl::BottomL
 // Returns bottom property.
 // -----------------------------------------------------------------------------
 //
 CXnProperty* CXnNodeImpl::BottomL()
 {
-CXnNode* refNode = RefNodeL( this, iRef, iUiEngine );
-if ( refNode )
-{
-RPointerArray< CXnProperty >* propertyArray =
-refNode->Impl()->iLayoutPropertyCache ?
-&( refNode->Impl()->iLayoutPropertyCache->iBottoms ) :
-NULL;
-return ReferredPropertyL( propertyArray, iStates );
-}
 CXnProperty* property =
 iLayoutPropertyCache ? iLayoutPropertyCache->iBottom : NULL;
-return PropertyL( this, property, &CXnNode::BottomL,
+return PropertyL( property, &CXnNode::BottomL,
-iUiEngine, iLayoutPropertyCache,
+iLayoutPropertyCache, iParent );
-iParent, iRef );
 }
 // -----------------------------------------------------------------------------
 // CXnNodeImpl::BorderLeftStyleL
 // Returns border-left-style property.
 // -----------------------------------------------------------------------------
 //
 CXnProperty* CXnNodeImpl::BorderLeftStyleL()
 {
-CXnNode* refNode = RefNodeL( this, iRef, iUiEngine );
-if ( refNode )
-{
-RPointerArray< CXnProperty >* propertyArray =
-refNode->Impl()->iLayoutPropertyCache ?
-&( refNode->Impl()->iLayoutPropertyCache->iBorderLeftStyles ) :
-NULL;
-return ReferredPropertyL( propertyArray, iStates );
-}
 CXnProperty* property =
 iLayoutPropertyCache ? iLayoutPropertyCache->iBorderLeftStyle : NULL;
-return PropertyL( this, property, &CXnNode::BorderLeftStyleL,
+return PropertyL( property, &CXnNode::BorderLeftStyleL,
-iUiEngine, iLayoutPropertyCache,
+iLayoutPropertyCache, iParent );
-iParent, iRef );
 }
 // -----------------------------------------------------------------------------
 // CXnNodeImpl::BorderRightStyleL
 // Returns border-right-style property.
 // -----------------------------------------------------------------------------
 //
 CXnProperty* CXnNodeImpl::BorderRightStyleL()
 {
-CXnNode* refNode = RefNodeL( this, iRef, iUiEngine );
-if ( refNode )
-{
-RPointerArray< CXnProperty >* propertyArray =
-refNode->Impl()->iLayoutPropertyCache ?
-&( refNode->Impl()->iLayoutPropertyCache->iBorderRightStyles ) :
-NULL;
-return ReferredPropertyL( propertyArray, iStates );
-}
 CXnProperty* property =
 iLayoutPropertyCache ? iLayoutPropertyCache->iBorderRightStyle : NULL;
-return PropertyL( this, property, &CXnNode::BorderRightStyleL,
+return PropertyL( property, &CXnNode::BorderRightStyleL,
-iUiEngine, iLayoutPropertyCache,
+iLayoutPropertyCache, iParent );
-iParent, iRef );
 }
 // -----------------------------------------------------------------------------
 // CXnNodeImpl::BorderTopStyleL
 // Returns border-top-style property.
 // -----------------------------------------------------------------------------
 //
 CXnProperty* CXnNodeImpl::BorderTopStyleL()
 {
-CXnNode* refNode = RefNodeL( this, iRef, iUiEngine );
-if ( refNode )
-{
-RPointerArray< CXnProperty >* propertyArray =
-refNode->Impl()->iLayoutPropertyCache ?
-&( refNode->Impl()->iLayoutPropertyCache->iBorderTopStyles ) :
-NULL;
-return ReferredPropertyL( propertyArray, iStates );
-}
 CXnProperty* property =
 iLayoutPropertyCache ? iLayoutPropertyCache->iBorderTopStyle : NULL;
-return PropertyL( this, property, &CXnNode::BorderTopStyleL,
+return PropertyL( property, &CXnNode::BorderTopStyleL,
-iUiEngine, iLayoutPropertyCache,
+iLayoutPropertyCache, iParent );
-iParent, iRef );
 }
 // -----------------------------------------------------------------------------
 // CXnNodeImpl::BorderBottomStyleL
 // Returns border-bottom-style property.
 // -----------------------------------------------------------------------------
 //
 CXnProperty* CXnNodeImpl::BorderBottomStyleL()
 {
-CXnNode* refNode = RefNodeL( this, iRef, iUiEngine );
-if ( refNode )
-{
-RPointerArray< CXnProperty >* propertyArray =
-refNode->Impl()->iLayoutPropertyCache ?
-&( refNode->Impl()->iLayoutPropertyCache->iBorderBottomStyles ) :
-NULL;
-return ReferredPropertyL( propertyArray, iStates );
-}
 CXnProperty* property =
 iLayoutPropertyCache ? iLayoutPropertyCache->iBorderBottomStyle : NULL;
-return PropertyL( this, property, &CXnNode::BorderBottomStyleL,
+return PropertyL( property, &CXnNode::BorderBottomStyleL,
-iUiEngine, iLayoutPropertyCache,
+iLayoutPropertyCache, iParent );
-iParent, iRef );
 }
 // -----------------------------------------------------------------------------
 // CXnNodeImpl::BorderStyleL
 // Returns border-style property.
 // -----------------------------------------------------------------------------
 //
 CXnProperty* CXnNodeImpl::BorderStyleL()
 {
-CXnNode* refNode = RefNodeL( this, iRef, iUiEngine );
-if ( refNode )
-{
-RPointerArray< CXnProperty >* propertyArray =
-refNode->Impl()->iLayoutPropertyCache ?
-&( refNode->Impl()->iLayoutPropertyCache->iBorderStyles ) :
-NULL;
-return ReferredPropertyL( propertyArray, iStates );
-}
 CXnProperty* property =
 iLayoutPropertyCache ? iLayoutPropertyCache->iBorderStyle : NULL;
-return PropertyL( this, property, &CXnNode::BorderStyleL,
+return PropertyL( property, &CXnNode::BorderStyleL,
-iUiEngine, iLayoutPropertyCache,
+iLayoutPropertyCache, iParent );
-iParent, iRef );
 }
 // -----------------------------------------------------------------------------
 // CXnNodeImpl::BorderImageL
 // Returns border-image property.
 //
 CXnProperty* CXnNodeImpl::BorderImageL()
 {
 CXnProperty* property =
 iLayoutPropertyCache ? iLayoutPropertyCache->iBorderImage : NULL;
-return PropertyL( this, property, &CXnNode::BorderImageL,
+return PropertyL( property, &CXnNode::BorderImageL,
-iUiEngine, iLayoutPropertyCache,
+iLayoutPropertyCache, iParent );
-iParent, iRef );
 }
 // -----------------------------------------------------------------------------
 // CXnNodeImpl::DisplayPriorityL
 // Returns display-priority property.
 // -----------------------------------------------------------------------------
 //
 CXnProperty* CXnNodeImpl::DisplayPriorityL()
 {
-CXnNode* refNode = RefNodeL( this, iRef, iUiEngine );
-if ( refNode )
-{
-RPointerArray< CXnProperty >* propertyArray =
-refNode->Impl()->iLayoutPropertyCache ?
-&( refNode->Impl()->iLayoutPropertyCache->iDisplayPriorities ) :
-NULL;
-return ReferredPropertyL( propertyArray, iStates );
-}
 CXnProperty* property =
 iLayoutPropertyCache ? iLayoutPropertyCache->iDisplayPriority : NULL;
-return PropertyL( this, property, &CXnNode::DisplayPriorityL,
+return PropertyL( property, &CXnNode::DisplayPriorityL,
-iUiEngine, iLayoutPropertyCache,
+iLayoutPropertyCache, iParent );
-iParent, iRef );
 }
 // -----------------------------------------------------------------------------
 // CXnNodeImpl::NameL
 // Returns name property.
 // -----------------------------------------------------------------------------
 //
 CXnProperty* CXnNodeImpl::NameL()
 {
-return PropertyL( this, iName, &CXnNode::NameL,
+return PropertyL( iName, &CXnNode::NameL, this, iParent );
-iUiEngine, this,
-iParent, iRef );
 }
 // -----------------------------------------------------------------------------
 // CXnNodeImpl::ValueL
 // Returns value property.
 // -----------------------------------------------------------------------------
 //
 CXnProperty* CXnNodeImpl::ValueL()
 {
-return PropertyL( this, iValue, &CXnNode::ValueL,
+return PropertyL( iValue, &CXnNode::ValueL, this, iParent );
-iUiEngine, this,
-iParent, iRef );
 }
 // -----------------------------------------------------------------------------
 // CXnNodeImpl::VisibilityL
 // Returns visibility property.
 // -----------------------------------------------------------------------------
 //
 CXnProperty* CXnNodeImpl::VisibilityL()
 {
-CXnNode* refNode = RefNodeL( this, iRef, iUiEngine );
-if ( refNode )
-{
-RPointerArray< CXnProperty >* propertyArray =
-refNode->Impl()->iLayoutPropertyCache ?
-&( refNode->Impl()->iLayoutPropertyCache->iVisibilities ) :
-NULL;
-return ReferredPropertyL( propertyArray, iStates );
-}
 CXnProperty* property =
 iLayoutPropertyCache ? iLayoutPropertyCache->iVisibility : NULL;
-return PropertyL( this, property, &CXnNode::VisibilityL,
+return PropertyL( property, &CXnNode::VisibilityL,
-iUiEngine, iLayoutPropertyCache,
+iLayoutPropertyCache, iParent );
-iParent, iRef );
 }
 // -----------------------------------------------------------------------------
 // CXnNodeImpl::LabelL
 // Returns label property.
 // -----------------------------------------------------------------------------
 //
 CXnProperty* CXnNodeImpl::LabelL()
 {
-return PropertyL( this, iLabel, &CXnNode::LabelL,
+return PropertyL( iLabel, &CXnNode::LabelL, this, iParent );
-iUiEngine, this,
-iParent, iRef );
 }
 // -----------------------------------------------------------------------------
 // CXnNodeImpl::InitialFocusL
 // Returns initial-focus property.
 // -----------------------------------------------------------------------------
 //
 CXnProperty* CXnNodeImpl::InitialFocusL()
 {
-return PropertyL( this, iInitialFocus, &CXnNode::InitialFocusL,
+return PropertyL( iInitialFocus, &CXnNode::InitialFocusL, this, iParent );
-iUiEngine, this,
-iParent, iRef );
 }
 // -----------------------------------------------------------------------------
 // CXnNodeImpl::ClassL
 // Returns class property.
 // -----------------------------------------------------------------------------
 //
 CXnProperty* CXnNodeImpl::ClassL()
 {
-return PropertyL( this, iClass, &CXnNode::ClassL,
+return PropertyL( iClass, &CXnNode::ClassL, this, iParent );
-iUiEngine, this,
-iParent, iRef );
 }
 // -----------------------------------------------------------------------------
 // CXnNodeImpl::IdL
 // Returns id property.
 // Returns path property.
 // -----------------------------------------------------------------------------
 //
 CXnProperty* CXnNodeImpl::PathL()
 {
-return PropertyL( this, iPath, &CXnNode::PathL,
+return PropertyL( iPath, &CXnNode::PathL, this, iParent );
-iUiEngine, this,
-iParent, iRef );
 }
 // -----------------------------------------------------------------------------
 // CXnNodeImpl::MaskPathL
 // Returns maskpath property.
 // -----------------------------------------------------------------------------
 //
 CXnProperty* CXnNodeImpl::MaskPathL()
 {
-return PropertyL( this, iMaskPath, &CXnNode::MaskPathL,
+return PropertyL( iMaskPath, &CXnNode::MaskPathL, this, iParent );
-iUiEngine, this,
-iParent, iRef );
 }
 // -----------------------------------------------------------------------------
 // CXnNodeImpl::NavIndexL
 // Returns nav-index property.
 // -----------------------------------------------------------------------------
 //
 CXnProperty* CXnNodeImpl::NavIndexL()
 {
-CXnNode* refNode = RefNodeL( this, iRef, iUiEngine );
-if ( refNode )
-{
-RPointerArray< CXnProperty >* propertyArray =
-refNode->Impl()->iLayoutPropertyCache ?
-&( refNode->Impl()->iLayoutPropertyCache->iNavIndexes ) :
-NULL;
-return ReferredPropertyL( propertyArray, iStates );
-}
 CXnProperty* property =
 iLayoutPropertyCache ? iLayoutPropertyCache->iNavIndex : NULL;
-return PropertyL( this, property, &CXnNode::NavIndexL,
+return PropertyL( property, &CXnNode::NavIndexL,
-iUiEngine, iLayoutPropertyCache,
+iLayoutPropertyCache, iParent );
-iParent, iRef );
-}
-// -----------------------------------------------------------------------------
-// CXnNodeImpl::VisibleRowsL
-// Returns visible-rows property.
-// -----------------------------------------------------------------------------
-//
-CXnProperty* CXnNodeImpl::VisibleRowsL()
-{
-CXnProperty* property =
-iGridPropertyCache ? iGridPropertyCache->iVisibleRows : NULL;
-return PropertyL( this, property, &CXnNode::VisibleRowsL,
-iUiEngine, iGridPropertyCache,
-iParent, iRef );
-}
-// -----------------------------------------------------------------------------
-// CXnNodeImpl::GridColumnsL
-// Returns grid-columns property.
-// -----------------------------------------------------------------------------
-//
-CXnProperty* CXnNodeImpl::GridColumnsL()
-{
-CXnProperty* property =
-iGridPropertyCache ? iGridPropertyCache->iGridColumns : NULL;
-return PropertyL( this, property, &CXnNode::GridColumnsL,
-iUiEngine, iGridPropertyCache,
-iParent, iRef );
-}
-// -----------------------------------------------------------------------------
-// CXnNodeImpl::GridOrientationL
-// Returns grid-orientation property.
-// -----------------------------------------------------------------------------
-//
-CXnProperty* CXnNodeImpl::GridOrientationL()
-{
-CXnProperty* property =
-iGridPropertyCache ? iGridPropertyCache->iGridOrientation : NULL;
-return PropertyL( this, property, &CXnNode::GridOrientationL,
-iUiEngine, iGridPropertyCache,
-iParent, iRef );
-}
-// -----------------------------------------------------------------------------
-// CXnNodeImpl::GridVerDirectionL
-// Returns grid-ver-direction property.
-// -----------------------------------------------------------------------------
-//
-CXnProperty* CXnNodeImpl::GridVerDirectionL()
-{
-CXnProperty* property =
-iGridPropertyCache ? iGridPropertyCache->iGridVerDirection : NULL;
-return PropertyL( this, property, &CXnNode::GridVerDirectionL,
-iUiEngine, iGridPropertyCache,
-iParent, iRef );
-}
-// -----------------------------------------------------------------------------
-// CXnNodeImpl::GridHorDirectionL
-// Returns grid-hor-direction property.
-// -----------------------------------------------------------------------------
-//
-CXnProperty* CXnNodeImpl::GridHorDirectionL()
-{
-CXnProperty* property =
-iGridPropertyCache ? iGridPropertyCache->iGridHorDirection : NULL;
-return PropertyL( this, property, &CXnNode::GridHorDirectionL,
-iUiEngine, iGridPropertyCache,
-iParent, iRef );
-}
-// -----------------------------------------------------------------------------
-// CXnNodeImpl::FocusHorLoopingL
-// Returns focus-hor-looping property.
-// -----------------------------------------------------------------------------
-//
-CXnProperty* CXnNodeImpl::FocusHorLoopingL()
-{
-CXnProperty* property =
-iGridPropertyCache ? iGridPropertyCache->iFocusHorLooping : NULL;
-return PropertyL( this, property, &CXnNode::FocusHorLoopingL,
-iUiEngine, iGridPropertyCache,
-iParent, iRef );
-}
-// -----------------------------------------------------------------------------
-// CXnNodeImpl::FocusVerLoopingL
-// Returns focus-ver-looping property.
-// -----------------------------------------------------------------------------
-//
-CXnProperty* CXnNodeImpl::FocusVerLoopingL()
-{
-CXnProperty* property =
-iGridPropertyCache ? iGridPropertyCache->iFocusVerLooping : NULL;
-return PropertyL( this, property, &CXnNode::FocusVerLoopingL,
-iUiEngine, iGridPropertyCache,
-iParent, iRef );
 }
 // -----------------------------------------------------------------------------
 // CXnNodeImpl::ZIndexL
 // Returns z-index property.
 // -----------------------------------------------------------------------------
 //
 CXnProperty* CXnNodeImpl::ZIndexL()
 {
-CXnNode* refNode = RefNodeL( this, iRef, iUiEngine );
-if ( refNode )
-{
-RPointerArray< CXnProperty >* propertyArray =
-refNode->Impl()->iLayoutPropertyCache ?
-&( refNode->Impl()->iLayoutPropertyCache->iZIndexes ) :
-NULL;
-return ReferredPropertyL( propertyArray, iStates );
-}
 CXnProperty* property =
 iLayoutPropertyCache ? iLayoutPropertyCache->iZIndex : NULL;
-return PropertyL( this, property, &CXnNode::ZIndexL,
+return PropertyL( property, &CXnNode::ZIndexL,
-iUiEngine, iLayoutPropertyCache,
+iLayoutPropertyCache, iParent );
-iParent, iRef );
 }
 // -----------------------------------------------------------------------------
 // CXnNodeImpl::BackgroundColorL
 // Returns background-color property.
 // -----------------------------------------------------------------------------
 //
 CXnProperty* CXnNodeImpl::BackgroundColorL()
 {
-CXnNode* refNode = RefNodeL( this, iRef, iUiEngine );
-if ( refNode )
-{
-RPointerArray< CXnProperty >* propertyArray =
-refNode->Impl()->iLayoutPropertyCache ?
-&( refNode->Impl()->iLayoutPropertyCache->iBackgroundColors ) :
-NULL;
-return ReferredPropertyL( propertyArray, iStates );
-}
 CXnProperty* property =
 iLayoutPropertyCache ? iLayoutPropertyCache->iBackgroundColor : NULL;
-return PropertyL( this, property, &CXnNode::BackgroundColorL,
+return PropertyL( property, &CXnNode::BackgroundColorL,
-iUiEngine, iLayoutPropertyCache,
+iLayoutPropertyCache, iParent );
-iParent, iRef );
 }
 // -----------------------------------------------------------------------------
 // CXnNodeImpl::BackgroundImageL
 // Returns background-image property.
 // -----------------------------------------------------------------------------
 //
 CXnProperty* CXnNodeImpl::BackgroundImageL()
 {
-CXnNode* refNode = RefNodeL( this, iRef, iUiEngine );
-if ( refNode )
-{
-RPointerArray< CXnProperty >* propertyArray =
-refNode->Impl()->iLayoutPropertyCache ?
-&( refNode->Impl()->iLayoutPropertyCache->iBackgroundImages ) :
-NULL;
-return ReferredPropertyL( propertyArray, iStates );
-}
 CXnProperty* property =
 iLayoutPropertyCache ? iLayoutPropertyCache->iBackgroundImage : NULL;
-return PropertyL( this, property, &CXnNode::BackgroundImageL,
+return PropertyL( property, &CXnNode::BackgroundImageL,
-iUiEngine, iLayoutPropertyCache,
+iLayoutPropertyCache, iParent );
-iParent, iRef );
 }
 // -----------------------------------------------------------------------------
 // CXnNodeImpl::FocusBackgroundL
 // Returns focus-background property.
 // -----------------------------------------------------------------------------
 //
 CXnProperty* CXnNodeImpl::FocusBackgroundL()
 {
-CXnNode* refNode = RefNodeL( this, iRef, iUiEngine );
-if ( refNode )
-{
-RPointerArray< CXnProperty >* propertyArray =
-refNode->Impl()->iLayoutPropertyCache ?
-&( refNode->Impl()->iLayoutPropertyCache->iFocusBackgrounds ) :
-NULL;
-return ReferredPropertyL( propertyArray, iStates );
-}
 CXnProperty* property =
 iLayoutPropertyCache ? iLayoutPropertyCache->iFocusBackground : NULL;
-return PropertyL( this, property, &CXnNode::FocusBackgroundL,
+return PropertyL( property, &CXnNode::FocusBackgroundL,
-iUiEngine, iLayoutPropertyCache,
+iLayoutPropertyCache, iParent );
-iParent, iRef );
-}
-// -----------------------------------------------------------------------------
-// CXnNodeImpl::RefL
-// Returns ref property.
-// -----------------------------------------------------------------------------
-//
-CXnProperty* CXnNodeImpl::RefL()
-{
-return iRef;
-}
-// -----------------------------------------------------------------------------
-// CXnNodeImpl::GridScrollBarWidthL
-// Returns grid-scrollbar-width property.
-// -----------------------------------------------------------------------------
-//
-CXnProperty* CXnNodeImpl::GridScrollBarWidthL()
-{
-CXnProperty* property = NULL;
-if ( iGridPropertyCache && iGridPropertyCache->iGridScrollBarWidth)
-{
-property = PropertyL(
-this,
-iGridPropertyCache->iGridScrollBarWidth,
-&CXnNode::GridScrollBarWidthL,
-iUiEngine, iGridPropertyCache,
-iParent,
-iRef );
-}
-if ( !property && iRef )
-{
-CXnNode* refNode = RefNodeL( this, iRef, iUiEngine );
-if ( refNode )
-{
-property = refNode->GridScrollBarWidthL();
-}
-}
-if ( !property )
-{
-TReal sbWidth( KS60ScrollbarDefaultWidth );
-// Set default value
-CXnDomDocument& doc = iUiEngine->ODT()->DomDocument();
-CXnDomProperty* domProperty = CXnDomProperty::NewL(
-XnPropertyNames::grid::KS60GridScrollbarWidth, doc.StringPool() );
-CleanupStack::PushL( domProperty );
-CXnDomPropertyValue* propertyValue = CXnDomPropertyValue::NewL(
-doc.StringPool() );
-CleanupStack::PushL( propertyValue );
-if ( AknLayoutUtils::PenEnabled() )
-{
-sbWidth = KS60ScrollbarDefaultWidthPenEnabled;
-}
-propertyValue->SetFloatValueL( CXnDomPropertyValue::EUnitValue, sbWidth );
-domProperty->PropertyValueList().AddItemL( propertyValue );
-CleanupStack::Pop( propertyValue );
-property = CXnProperty::NewL( domProperty );
-CleanupStack::Pop( domProperty );
-CleanupStack::PushL( property );
-// If this is a reference node, set property to the referred node, not this.
-CXnNode* node = RefNodeL( this, iRef, iUiEngine );
-if ( node )
-{
-node->SetPropertyL( property );
-}
-else
-{
-this->SetPropertyL( property ); // deletes existing one
-}
-CleanupStack::Pop( property );
-}
-return property;
-}
-// -----------------------------------------------------------------------------
-// CXnNodeImpl::GridScrollBarMarginL
-// Returns grid-scrollbar-margin property.
-// -----------------------------------------------------------------------------
-//
-CXnProperty* CXnNodeImpl::GridScrollBarMarginL()
-{
-CXnProperty* property = NULL;
-if ( iGridPropertyCache && iGridPropertyCache->iGridScrollBarMargin )
-{
-property = PropertyL(
-this,
-iGridPropertyCache->iGridScrollBarMargin,
-&CXnNode::GridScrollBarMarginL,
-iUiEngine, iGridPropertyCache,
-iParent,
-iRef );
-}
-if ( !property && iRef )
-{
-CXnNode* refNode = RefNodeL( this, iRef, iUiEngine );
-if ( refNode )
-{
-property = refNode->GridScrollBarMarginL();
-}
-}
-if ( !property )
-{
-TReal sbMarginWidth( KS60ScrollbarDefaultMargin );
-// Set default value
-CXnDomDocument& doc = iUiEngine->ODT()->DomDocument();
-CXnDomProperty* domProperty =
-CXnDomProperty::NewL(
-XnPropertyNames::grid::KS60GridScrollbarMargin,
-doc.StringPool() );
-CleanupStack::PushL( domProperty );
-CXnDomPropertyValue* propertyValue = CXnDomPropertyValue::NewL(
-doc.StringPool() );
-CleanupStack::PushL( propertyValue );
-if ( AknLayoutUtils::PenEnabled() )
-{
-sbMarginWidth = KS60ScrollbarDefaultMarginPenEnabled;
-}
-propertyValue->SetFloatValueL(
-CXnDomPropertyValue::EUnitValue, sbMarginWidth );
-domProperty->PropertyValueList().AddItemL( propertyValue );
-CleanupStack::Pop( propertyValue );
-property = CXnProperty::NewL( domProperty );
-CleanupStack::Pop( domProperty );
-CleanupStack::PushL( property );
-// If this is a reference node, set property to the referred node, not this.
-CXnNode* node = RefNodeL( this, iRef, iUiEngine );
-if ( node )
-{
-node->SetPropertyL( property );
-}
-else
-{
-this->SetPropertyL( property ); // deletes existing one
-}
-CleanupStack::Pop(property);
-}
-return property;
 }
 // ----------------------------------------------------------------------------
 // CXnNodeImpl::SetDomNode
 // Sets DOM node
 // Measure done
 iAdaptive &= ~XnAdaptive::EMeasure;
 // Size is now fixed
 iAdaptive |= XnAdaptive::ESizeFixed;
-}
-}
-// ----------------------------------------------------------------------------
-// CXnNodeImpl::PeriodicEventL
-// ----------------------------------------------------------------------------
-//
-TInt CXnNodeImpl::PeriodicEventL( TAny* aPtr )
-{
-TXnTimedTrigger* params = static_cast< TXnTimedTrigger* >( aPtr );
-CXnNodeImpl* impl = params->iNodeImpl;
-CXnUiEngine* engine = params->iEngine;
-CXnNode* node = params->iNode;
-CXnNode* eventData = params->iEventData;
-CXnDomNode* actionNode = params->iActionNode;
-CXnDomNode* triggerNode = params->iTriggerNode;
-RunEventsL( impl, *engine, *node, *actionNode, *triggerNode, *eventData );
-delete params;
-impl->DeletePeriodic();
-return EFalse;
-}
-// ----------------------------------------------------------------------------
-// CXnNodeImpl::PeriodicTimer
-// ----------------------------------------------------------------------------
-//
-CPeriodic* CXnNodeImpl::PeriodicTimer()
-{
-return iPeriodicTimer;
-}
-// ----------------------------------------------------------------------------
-// CXnNodeImpl::CreatePeriodicL
-// ----------------------------------------------------------------------------
-//
-void CXnNodeImpl::CreatePeriodicL()
-{
-iPeriodicTimer = CPeriodic::NewL( CActive::EPriorityIdle );
-}
-// ---------------------------------------------------------
-// CXnNodeImpl::DeletePeriodic
-// ---------------------------------------------------------
-//
-void CXnNodeImpl::DeletePeriodic()
-{
-if ( iPeriodicTimer )
-{
-iPeriodicTimer->Cancel();
-delete iPeriodicTimer;
-iPeriodicTimer = NULL;
 }
 }
 // -----------------------------------------------------------------------------
 // CXnNodeImpl::SetDirtyL
 {
 aRect.Move( iScrollableControl->DeltaPosition() );
 }
 return aRect;
 }

branch	RCL_3
changeset 11	ff572dfe6d86
parent 9	f966699dea19
child 12	9674c1a575e9