FCL/sf/app/homescreen: comparison idlehomescreen/xmluirendering/uiengine/src/xnuiengineimpl.cpp

equal deleted inserted replaced

-:b01126ce0bec
+:ba63c83f4716
 #include "xneffectmanager.h"
 #include "xneditor.h"
 #include "xnbackgroundmanager.h"
 #include "xntexteditor.h"
 #include "xnrootdata.h"
-#include "xnviewswitcher.h"
 #ifdef _XN_PERFORMANCE_TEST_
 #include "xntimemon.h"
 #endif
 const TInt KXnStackPriorityKeyEventDispatcher = 55;
 const TInt KFocusGrowValue = 3;
 _LIT8( KBoxNodeName, "box" );
 _LIT8( KButtonNodeName, "button" );
+_LIT8( KWidgetNodeName, "widget" );
 _LIT8( KWidgetExtensionNodeName, "widgetextension" );
 _LIT8( KScrollableBoxNodeName, "scrollablebox" );
 _LIT8( KMenuBar, "menubar" );
 _LIT8( KPopUpNodeName, "popup" );
+_LIT8( KEditorNodeName, "texteditor" );
 _LIT8( KPlugin, "plugin" );
-_LIT8( KSplitScreenEnabledTrigger , "splitscreenenabled" );
-_LIT8( KSplitScreenDisabledTrigger, "splitscreendisabled" );
 // LOCAL CONSTANTS AND MACROS
 static const TReal KIntConversionConstant = 0.5;
 static const TReal KIntPercentageConstant =
 static_cast< TReal >( 1 ) / static_cast< TReal >( 100 );
 #endif
 // ============================= LOCAL FUNCTIONS ===============================
 // -----------------------------------------------------------------------------
+// -----------------------------------------------------------------------------
+//
+CXnNode* FindPlugin( CXnNode& aNode )
+{
+CXnNode* pluginNode( NULL );
+for( CXnNode* node = &aNode; node; node = node->Parent() )
+{
+if( node->DomNode()->Name() == KPlugin )
+{
+pluginNode = node;
+break;
+}
+}
+return pluginNode;
+}
+// -----------------------------------------------------------------------------
 // GrowIfNeeded()
 // When a plugin is focused, the focus is a bit bigger than its control
 // (this is a hack fix to get focus visible with WRT widgets).
 // Therefore we need to check if focused node is a plugin,
 // or focused node has same size with its plugin, and grow dirty rect accordingly.
 if ( !layoutUnderPrevious )
 {
 TInt width =
 aNode.BorderRect().Width() + marginLeft + marginRight;
-if ( aColumnMargin < marginRight )
+if ( aColumnMargin < marginLeft )
 {
 width -= aColumnMargin;
 }
 else
 {
-width -= marginRight;
+width -= marginLeft;
 }
 if ( width + aColumnWidth <= aParentRect.Width() )
 {
 offsety = aParentRect.iTl.iY + marginTop;
-if ( aColumnMargin < marginRight )
+if ( aColumnMargin < marginLeft )
 {
 offsetx = aParentRect.iBr.iX - aColumnWidth +
 aColumnMargin - marginRight -
 aNode.BorderRect().Width();
 }
 }
 if ( width + aColumnWidth <= aParentRect.Width() )
 {
 offsety = aParentRect.iBr.iY - marginBottom -
 aNode.BorderRect().Height();
-if ( aColumnMargin < marginRight )
+if ( aColumnMargin < marginLeft )
 {
 offsetx = aParentRect.iBr.iX - aColumnWidth +
 aColumnMargin - marginRight -
 aNode.BorderRect().Width();
 }
 CXnProperty* top = aNode.TopL();
 if ( IsPropertyAutoL( *top ) )
 {
 TPtrC8 propertyName = top->Property()->Name();
-autoArray.AppendL( propertyName );
+autoArray.Append( propertyName );
 }
 CXnProperty* bottom = aNode.BottomL();
 if ( IsPropertyAutoL( *bottom ) )
 {
 TPtrC8 propertyName = bottom->Property()->Name();
-autoArray.AppendL( propertyName );
+autoArray.Append( propertyName );
 }
 CXnProperty* left = aNode.LeftL();
 if ( IsPropertyAutoL( *left ) )
 {
 TPtrC8 propertyName = left->Property()->Name();
-autoArray.AppendL( propertyName );
+autoArray.Append( propertyName );
 }
 CXnProperty* right = aNode.RightL();
 if ( IsPropertyAutoL( *right ) )
 {
 TPtrC8 propertyName = right->Property()->Name();
-autoArray.AppendL( propertyName );
+autoArray.Append( propertyName );
 }
 CXnProperty* width = aNode.WidthL();
 if ( IsPropertyAutoL( *width ) )
 {
 TPtrC8 propertyName = width->Property()->Name();
-autoArray.AppendL( propertyName );
+autoArray.Append( propertyName );
 }
 if ( !width )
 {
 TPtrC8 propertyName = XnPropertyNames::style::common::KWidth();
-autoArray.AppendL( propertyName );
+autoArray.Append( propertyName );
 }
 CXnProperty* height = aNode.HeightL();
 if ( IsPropertyAutoL( *height ) )
 {
 TPtrC8 propertyName = height->Property()->Name();
-autoArray.AppendL( propertyName );
+autoArray.Append( propertyName );
 }
 if ( !height )
 {
 TPtrC8 propertyName = XnPropertyNames::style::common::KHeight();
-autoArray.AppendL( propertyName );
+autoArray.Append( propertyName );
 }
 CXnProperty* marginTop = aNode.MarginTopL();
 if ( IsPropertyAutoL( *marginTop ) )
 {
 TPtrC8 propertyName = marginTop->Property()->Name();
-autoArray.AppendL( propertyName );
+autoArray.Append( propertyName );
 }
 CXnProperty* marginBottom = aNode.MarginBottomL();
 if ( IsPropertyAutoL( *marginBottom ) )
 {
 TPtrC8 propertyName = marginBottom->Property()->Name();
-autoArray.AppendL( propertyName );
+autoArray.Append( propertyName );
 }
 CXnProperty* marginLeft = aNode.MarginLeftL();
 if ( IsPropertyAutoL( *marginLeft ) )
 {
 TPtrC8 propertyName = marginLeft->Property()->Name();
-autoArray.AppendL( propertyName );
+autoArray.Append( propertyName );
 }
 CXnProperty* marginRight = aNode.MarginRightL();
 if ( IsPropertyAutoL( *marginRight ) )
 {
 TPtrC8 propertyName = marginRight->Property()->Name();
-autoArray.AppendL( propertyName );
+autoArray.Append( propertyName );
 }
 if ( aParentDirection == XnPropertyNames::style::common::direction::KLTR )
 {
 if ( aParentBlockProgression ==
 return node;
 }
 // -----------------------------------------------------------------------------
-// -----------------------------------------------------------------------------
-//
-static void ReportScreenDeviceChangedL( const CXnPluginData& aPluginData )
-{
-CXnNode* node( NULL );
-if ( aPluginData.Node() )
-{
-node = aPluginData.Node()->LayoutNode();
-}
-if ( !node )
-{
-return;
-}
-CXnNode* trigger( BuildScreenDeviceChangeTriggerNodeLC( *node->UiEngine() ) );
-node->ReportXuikonEventL( *trigger );
-CleanupStack::PopAndDestroy( trigger );
-RPointerArray< CXnPluginData >& plugins( aPluginData.PluginData() );
-for( TInt i = 0; i < plugins.Count(); i++ )
-{
-ReportScreenDeviceChangedL( *plugins[i] );
-}
-}
-// -----------------------------------------------------------------------------
 // FillFocusCandidatesL
 // -----------------------------------------------------------------------------
 //
 static void FillFocusCandidatesL( CXnNode* aParent,
 RPointerArray< CXnNode >& aArray )
 iViewManager.RemoveObserver( *this );
 delete iEditMode;
 iFocusCandidateList.Reset();
+if ( iRedrawRegions.Count() )
+{
+iRedrawRegions.ResetAndDestroy();
+}
+iDirtyList.Reset();
 }
 // -----------------------------------------------------------------------------
 // CXnUiEngineImpl::AppUiAdapter()
 // -----------------------------------------------------------------------------
 // -----------------------------------------------------------------------------
 // CXnUiEngineImpl::LayoutUIL()
 // -----------------------------------------------------------------------------
 //
-void CXnUiEngineImpl::LayoutUIL( CXnNode* aNode )
+void CXnUiEngineImpl::LayoutUIL( CXnNode* /*aNode*/ )
 {
-if( aNode )
+if ( IsLayoutDisabled() )
-{
-TXnDirtyRegion* dirtyRegion = FindDirtyRegionL( *aNode );
-if( dirtyRegion )
-{
-LayoutL( *dirtyRegion );
-}
-}
-else
-{
-CXnViewData* viewData = iViewManager.ActiveAppData().ViewData( *iCurrentView );
-if( viewData )
-{
-RPointerArray<TXnDirtyRegion> arr;
-CleanupClosePushL( arr );
-viewData->GetDirtyRegions( arr );
-for( TInt i = 0; i < arr.Count(); i++ )
-{
-LayoutL( *arr[i] );
-}
-CleanupStack::PopAndDestroy( &arr );
-}
-}
-}
-// -----------------------------------------------------------------------------
-// CXnUiEngineImpl::LayoutUIL()
-// -----------------------------------------------------------------------------
-//
-void CXnUiEngineImpl::LayoutL( TXnDirtyRegion& aRegion )
-{
-if ( IsLayoutDisabled( aRegion ) )
 {
-aRegion.iLayoutControl |= XnLayoutControl::ELayoutUI;
+iLayoutControl |= XnLayoutControl::ELayoutUI;
 return;
 }
-aRegion.iLayoutControl &= ~XnLayoutControl::ELayoutUI;
+iLayoutControl &= ~XnLayoutControl::ELayoutUI;
-if ( aRegion.iDirtyList.Count() == 0 )
+if ( iDirtyList.Count() == 0 )
 {
 // Nothing to do, layout is up-to-date
 return;
 }
 DisableRenderUiLC();
+CXnNode* candidate( StartLayoutFromL() );
-CXnNode* candidate( StartLayoutFromL( aRegion ) );
+PrepareRunLayoutL();
-if( !candidate )
+iDirtyList.Reset();
-{
-return;
-}
-PrepareRunLayoutL( aRegion );
-aRegion.iDirtyList.Reset();
 // Run layout until it is fully calculated
 do
 {
-iLayoutPhase = RunLayoutL( aRegion, *candidate );
+iLayoutPhase = RunLayoutL( candidate );
 }
 while ( iLayoutPhase != XnLayoutPhase::ENone );
-// Run these only if the current view is being layouted
+CXnNode* focused( FocusedNode() );
-if( iCurrentView == aRegion.iRootNode )
-{
+if ( focused && focused->IsDropped() )
-CXnNode* focused( FocusedNode() );
+{
+// The currently focused node is dropped, run losevisualization
-if ( focused && focused->IsDropped() )
+CXnNode* loseVisualisation =
-{
+BuildTriggerNodeLC( *iUiEngine,
-// The currently focused node is dropped, run losevisualization
+XnPropertyNames::action::trigger::name::KLoseVisualisation );
-CXnNode* loseVisualisation =
-BuildTriggerNodeLC( *iUiEngine,
+focused->ReportXuikonEventL( *loseVisualisation );
-XnPropertyNames::action::trigger::name::KLoseVisualisation );
+CleanupStack::PopAndDestroy( loseVisualisation );
-focused->ReportXuikonEventL( *loseVisualisation );
+if ( FocusedNode() == focused )
-CleanupStack::PopAndDestroy( loseVisualisation );
+{
+// Remove focus as losevisualization trigger didn't
-if ( FocusedNode() == focused )
+// change focus from dropped node to another one
-{
+SetFocusedNodeL( NULL );
-// Remove focus as losevisualization trigger didn't
+}
-// change focus from dropped node to another one
+}
-SetFocusedNodeL( NULL );
-}
+if ( !FocusedNode() && iAppUiAdapter.FocusShown() )
-}
+{
+// No focus, try if some of the focus candidates can be focused
-if ( !FocusedNode() && iAppUiAdapter.FocusShown() )
+RootNode()->RunFocusChangeL( iFocusCandidateList );
-{
+}
-// No focus, try if some of the focus candidates can be focused
-RootNode()->RunFocusChangeL( iFocusCandidateList );
+iFocusCandidateList.Reset();
-}
+iAppUiAdapter.EffectManager()->UiLayouted();
-iFocusCandidateList.Reset();
-iAppUiAdapter.EffectManager()->UiLayouted();
-}
 // Layout is now recalculated
 CleanupStack::PopAndDestroy(); // anonymous
 }
 // -----------------------------------------------------------------------------
 // PrepareRunLayoutL()
 // Set dropped flags of all nodes in the tree to ENone.
 // -----------------------------------------------------------------------------
 //
-void CXnUiEngineImpl::PrepareRunLayoutL( TXnDirtyRegion& aDirtyRegion )
+void CXnUiEngineImpl::PrepareRunLayoutL()
 {
 if ( iLayoutPhase == XnLayoutPhase::ENone )
 {
 iLayoutPhase = XnLayoutPhase::ELayout;
-for ( TInt i = 0; i < aDirtyRegion.iDirtyList.Count(); i++ )
+for ( TInt i = 0; i < iDirtyList.Count(); i++ )
 {
-CXnNode* dirty( aDirtyRegion.iDirtyList[i] );
+CXnNode* dirty( iDirtyList[i] );
 // Clear dropped flags recursively
 SetNodeDroppedL( *dirty, XnNodeLayout::ENone );
 if ( SetAdaptivesL( *dirty ) )
 // -----------------------------------------------------------------------------
 // CXnUiEngineImpl::RunLayoutL()
 // -----------------------------------------------------------------------------
 //
-TInt CXnUiEngineImpl::RunLayoutL( TXnDirtyRegion& aDirtyRegion, CXnNode& aNode )
+TInt CXnUiEngineImpl::RunLayoutL( CXnNode* aNode )
 {
 TRect clientRect( ClientRect() );
 // Move it to 0, 0
 clientRect.Move( -clientRect.iTl.iX, -clientRect.iTl.iY );
 RPointerArray< CXnNode > laidOutList;
 CleanupClosePushL( laidOutList );
-if ( IsNodeDisplayedL( aNode ) )
+if ( IsNodeDisplayedL( *aNode ) )
 {
-if ( aNode.ViewNodeImpl() && !aNode.IsLaidOut() )
+if ( aNode->ViewNodeImpl() && !aNode ->IsLaidOut() )
 {
-aNode.SetMarginRect( clientRect );
+aNode->SetMarginRect( clientRect );
-aNode.SetBorderRect( clientRect );
+aNode->SetBorderRect( clientRect );
-aNode.SetNormalFlowBorderRect( clientRect );
+aNode->SetNormalFlowBorderRect( clientRect );
-aNode.SetPaddingRect( clientRect );
+aNode->SetPaddingRect( clientRect );
-aNode.SetRect( clientRect );
+aNode->SetRect( clientRect );
 }
 // Put areas to place
-PlaceAreasL( aNode, laidOutList, iLayoutPhase,
+PlaceAreasL( *aNode, laidOutList, iLayoutPhase,
 *iCurrentGraphicsDevice, iHorizontalUnitInPixels,
 iVerticalUnitInPixels );
 }
 TInt nextPhase;
 case XnLayoutPhase::EMeasure:
 nextPhase = XnLayoutPhase::ELayout;
 break;
 case XnLayoutPhase::ELayout:
 // Layout is now calculated
-aDirtyRegion.iRootNode->SetLaidOutL();
+iCurrentView->SetLaidOutL();
-aDirtyRegion.iLayoutControl &= ~XnLayoutControl::EViewDirty;
+iLayoutControl &= ~XnLayoutControl::EViewDirty;
 // Check nodes which dimensions are changed
 for ( TInt i = 0; i < laidOutList.Count(); i++ )
 {
 CXnNode* node( laidOutList[i] );
 if( IsSrollableBox( *node ) && node->ScrollableControl() )
 rect = node->BorderRect();
 }
 if ( adapter->Rect() != rect )
 {
-AddToRedrawListL( aDirtyRegion, *node, rect );
+AddToRedrawListL( node, rect );
 adapter->SetRect( rect );
 CXnProperty* prop = node->GetPropertyL(
 XnPropertyNames::common::KSizeAware );
 // -----------------------------------------------------------------------------
 // CXnUiEngineImpl::RenderUIL()
 // -----------------------------------------------------------------------------
 //
-void CXnUiEngineImpl::RenderUIL( CXnNode* aNode )
+void CXnUiEngineImpl::RenderUIL( CXnNode* /*aNode*/ )
 {
-if( aNode )
+if ( IsLayoutDisabled() )
-{
-TXnDirtyRegion* dirtyRegion = FindDirtyRegionL( *aNode );
-if( dirtyRegion )
-{
-RenderL( *dirtyRegion );
-}
-}
-else
-{
-CXnViewData* viewData = iViewManager.ActiveAppData().ViewData( *iCurrentView );
-if( viewData )
-{
-RPointerArray<TXnDirtyRegion> arr;
-CleanupClosePushL( arr );
-viewData->GetDirtyRegions( arr );
-for( TInt i = 0; i < arr.Count(); i++ )
-{
-RenderL( *arr[i] );
-}
-CleanupStack::PopAndDestroy( &arr );
-}
-}
-}
-// -----------------------------------------------------------------------------
-// CXnUiEngineImpl::RenderUIL()
-// -----------------------------------------------------------------------------
-//
-void CXnUiEngineImpl::RenderL( TXnDirtyRegion& aRegion )
-{
-if ( IsLayoutDisabled( aRegion ) )
 {
 // Layout is not up-to-date
-aRegion.iLayoutControl |= XnLayoutControl::ERenderUI;
+iLayoutControl |= XnLayoutControl::ERenderUI;
 return;
 }
-TBool belongsToCurrentView( EFalse );
-if( iCurrentView == aRegion.iRootNode )
-{
-belongsToCurrentView = ETrue;
-}
 #ifdef _XN3_DEBUG_
-TraceTreeL( aRegion.RootNode );
+TraceTreeL(iCurrentView );
 #endif
 __PRINTS("*** CXnUiEngineImpl::RenderUIL ***");
+for( TInt i=0; i<iRedrawRegions.Count(); i++)
+{
+CCoeControl* control = iRedrawRegions[i]->iControl;
+RRegion& redrawRegion = iRedrawRegions[i]->iRegion;
-CCoeControl* control = aRegion.iControl;
+if( redrawRegion.CheckError() )
-RRegion& redrawRegion = aRegion.iRegion;
+{
-if( redrawRegion.CheckError() )
-{
-// Mark tree rendered
-aRegion.iRootNode->SetRenderedL();
-// Error occured during dirty set, redraw whole window
-control->DrawNow();
-__PRINTS("* CXnUiEngineImpl::RenderUIL - redraw region error -> full redraw ***");
-}
-else
-{
-if( !redrawRegion.IsEmpty() )
-{
 // Mark tree rendered
-aRegion.iRootNode->SetRenderedL();
+iCurrentView->SetRenderedL();
+// Error occured during dirty set, redraw whole window
+control->DrawNow();
+__PRINTS("* CXnUiEngineImpl::RenderUIL - redraw region error -> full redraw ***");
+}
+else
+{
+if( !redrawRegion.IsEmpty() )
+{
+// Mark tree rendered
+iCurrentView->SetRenderedL();
+if ( iAppUiAdapter.EffectManager()->ControlEffectActive( control ) )
+{
+// control effect is ongoing, no need to draw control yet
+redrawRegion.Clear();
+continue;
+}
-TBool effectOngoing( EFalse );
-if ( iAppUiAdapter.EffectManager()->ControlEffectActive( control ) &&
-belongsToCurrentView )
-{
-// control effect is ongoing, no need to draw control yet,
-// if current view in question
-redrawRegion.Clear();
-effectOngoing = ETrue;
-}
-if( !effectOngoing )
-{
 TInt count( redrawRegion.Count() );
 if( count > 2 )
 {
 // Make bounding rect over the dirty areas
 {
 for( TInt i = 0; i < count; i++ )
 {
 // Draw every dirty area separately
 TRect redrawRect( redrawRegion[i] );
 __PRINT( __DBG_FORMAT( "* CXnUiEngineImpl::RenderUIL - redrawing rect iTl.iX: %d, iTl.iY: %d, iBr.iX: %d, iBr.iY: %d" ),
 redrawRect.iTl.iX, redrawRect.iTl.iY, redrawRect.iBr.iX, redrawRect.iBr.iY );
 control->DrawNow( redrawRect );
 }
 }
 }
-}
+else
-else
+{
-{
+__PRINTS("* CXnUiEngineImpl::RenderUIL - nothing to redraw ***");
-__PRINTS("* CXnUiEngineImpl::RenderUIL - nothing to redraw ***");
+}
 }
-}
+redrawRegion.Clear();
+}
+RefreshMenuL();
+iLayoutControl &= ~XnLayoutControl::ERenderUI;
-redrawRegion.Clear();
+iAppUiAdapter.EffectManager()->UiRendered();
-RefreshMenuL( &aRegion );
-aRegion.iLayoutControl &= ~XnLayoutControl::ERenderUI;
-if( belongsToCurrentView )
-{
-iAppUiAdapter.EffectManager()->UiRendered();
-}
 __PRINTS("*** CXnUiEngineImpl::RenderUIL - done ***");
 }
 // -----------------------------------------------------------------------------
 {
 iCurrentView = iViewManager.ViewNode();
 iControlAdapterList = &iViewManager.Controls();
 iCurrentViewControlAdapter = iCurrentView->Control();
+iDirtyList.Reset();
+iRedrawRegions.ResetAndDestroy();
 // Remove previous menubar and stylus popup node
 iMenuNode = NULL;
 iStylusPopupNode = NULL;
 static_cast< CXnPopupControlAdapter* >
 				( node->Control() )->SetObserver( *this );
 }
 }
+ReportScreenDeviceChangeL();
 SetClientRectL( iAppUiAdapter.ClientRect(), EFalse );
 RootNode()->SetDirtyL();
 ForceRenderUIL();
-TXnDirtyRegion* dirtyRegion = FindDirtyRegionL( *iCurrentView );
+iLayoutControl &= ~XnLayoutControl::ERefreshMenu;
-if( dirtyRegion )
-{
-dirtyRegion->iDirtyList.Reset();
-dirtyRegion->iLayoutControl &= ~XnLayoutControl::ERefreshMenu;
-}
-}
-// -----------------------------------------------------------------------------
-// CXnUiEngineImpl::NotifyViewLoadedL()
-// -----------------------------------------------------------------------------
-//
-void CXnUiEngineImpl::NotifyViewLoadedL( const CXnViewData& aViewData )
-{
-ReportScreenDeviceChangedL( aViewData );
 }
 // -----------------------------------------------------------------------------
 // CXnUiEngineImpl::NotifyWidgetAdditionL()
 // -----------------------------------------------------------------------------
 //
 void CXnUiEngineImpl::NotifyWidgetAdditionL(
-const CXnPluginData& aPluginData )
+const CXnPluginData& /*aPluginData*/ )
 {
-ReportScreenDeviceChangedL( aPluginData );
+}
-}
-// -----------------------------------------------------------------------------
-// CXnUiEngineImpl::NotifyViewAdditionL()
-// -----------------------------------------------------------------------------
-//
-void CXnUiEngineImpl::NotifyViewAdditionL( const CXnViewData& aViewData )
-{
-ReportScreenDeviceChangedL( aViewData );
-}
 // -----------------------------------------------------------------------------
 // CXnUiEngineImpl::DynInitMenuItemL()
 // -----------------------------------------------------------------------------
 //
 TBool CXnUiEngineImpl::DynInitMenuItemL( CXnNodeAppIf& aMenuItem,
 // Refresh current menu
 // -----------------------------------------------------------------------------
 //
 void CXnUiEngineImpl::RefreshMenuL()
 {
-RefreshMenuL( NULL );
+if ( IsLayoutDisabled() )
-}
+{
+return;
-// -----------------------------------------------------------------------------
-// CXnUiEngineImpl::RefreshMenuL
-// Refresh current menu
-// -----------------------------------------------------------------------------
-//
-void CXnUiEngineImpl::RefreshMenuL( TXnDirtyRegion* aDirtyRegion )
-{
-TXnDirtyRegion* dirtyRegion = aDirtyRegion;
-if( !dirtyRegion )
-{
-dirtyRegion = FindDirtyRegionL( *iCurrentView );
 }
-if ( IsLayoutDisabled( *dirtyRegion ) )
+if ( iLayoutControl & XnLayoutControl::ERefreshMenu )
-{
-return;
-}
-if ( dirtyRegion &&
-dirtyRegion->iLayoutControl & XnLayoutControl::ERefreshMenu )
 {
 if ( iKeyEventDispatcher )
 {
-dirtyRegion->iLayoutControl &= ~XnLayoutControl::ERefreshMenu;
+iLayoutControl &= ~XnLayoutControl::ERefreshMenu;
 iKeyEventDispatcher->RefreshMenuL();
 }
 }
 }
 // Add a dirty node. This method must be called via CXnNode SetDirtyL
 // -----------------------------------------------------------------------------
 //
 void CXnUiEngineImpl::AddDirtyNodeL( CXnNode* aNode, TInt aLevel )
 {
-if ( !aNode )
+CXnViewData& data( iViewManager.ActiveViewData() );
-{
+if ( !aNode || ( aNode != RootNode() && !data.Plugin( aNode->Namespace() ) ) )
+{
+// No node, or node doesn't belong to active view namespace
 return;
 }
-if ( aNode == RootNode() )
+if ( aNode->Type()->Type() == KMenuBar )
 {
-// Force relayout and redraw from current view
+iLayoutControl |= XnLayoutControl::ERefreshMenu;
-iViewManager.ActiveAppData().PluginData();
+return;
-if ( !iCurrentView )
+}
-{
-iCurrentView = iViewManager.ViewNode();
+if ( iLayoutControl & XnLayoutControl::EViewDirty )
-}
+{
+// nothing to do
-TXnDirtyRegion* dirtyRegion = FindDirtyRegionL( *iCurrentView );
+return;
-if( dirtyRegion )
+}
-{
-dirtyRegion->iRegion.Clear();
+if ( aLevel == XnDirtyLevel::ERender )
-}
+{
-else
+if( aNode == RootNode() )
 {
-return;
+TXnDirtyRegion* dirtyRegion = FindDirtyRegionL( *iCurrentView );
-}
+if( dirtyRegion )
+{
-dirtyRegion->iDirtyList.Reset();
+dirtyRegion->iRegion.Clear();
-dirtyRegion->iDirtyList.AppendL( iCurrentView );
+}
+aNode = iCurrentView;
-dirtyRegion->iLayoutControl |= XnLayoutControl::EViewDirty;
+}
-iCurrentView->ClearRenderedAndLaidOut();
+// Add to redraw list
-// Add to draw list for redraw
+AddToRedrawListL( aNode );
-AddToRedrawListL( *dirtyRegion, *iCurrentView );
 }
 else
 {
-TXnDirtyRegion* dirtyRegion( FindDirtyRegionL( *aNode ) );
+// Add to dirty list for relayout and redraw
-if( !dirtyRegion )
+AddToDirtyListL( aNode );
-{
-return;
-}
-if ( aNode->Type()->Type() == KMenuBar )
-{
-dirtyRegion->iLayoutControl |= XnLayoutControl::ERefreshMenu;
-return;
-}
-if ( dirtyRegion->iLayoutControl & XnLayoutControl::EViewDirty )
-{
-// nothing to do
-return;
-}
-if ( aLevel == XnDirtyLevel::ERender )
-{
-if( aNode == RootNode() )
-{
-TXnDirtyRegion* dirtyRegion = FindDirtyRegionL( *iCurrentView );
-if( dirtyRegion )
-{
-dirtyRegion->iRegion.Clear();
-}
-aNode = iCurrentView;
-}
-// Add to redraw list
-AddToRedrawListL( *dirtyRegion, *aNode );
-}
-else
-{
-// Add to dirty list for relayout and redraw
-AddToDirtyListL( *dirtyRegion, *aNode );
-}
 }
 }
 // -----------------------------------------------------------------------------
 // CXnUiEngineImpl::ScreenDeviceSize
 HandleDynamicLayoutVariantSwitchL();
 }
 else if ( aType == KAknsMessageSkinChange )
 {
 HandleSkinChangeL();
+}
+else if( iCurrentViewControlAdapter )
+{
+iCurrentViewControlAdapter->HandleResourceChange( aType );
 }
 }
 // -----------------------------------------------------------------------------
 // CXnUiEngineImpl::HandleSkinChangeL
 // -----------------------------------------------------------------------------
 // CXnUiEngineImpl::IsLayoutDisabled
 // -----------------------------------------------------------------------------
 //
-TBool CXnUiEngineImpl::IsLayoutDisabled( TXnDirtyRegion& aDirtyRegion )
+TBool CXnUiEngineImpl::IsLayoutDisabled()
 {
 if ( !iCurrentView )
 {
 return ETrue;
 }
 TBool retval( EFalse );
-if ( !( aDirtyRegion.iLayoutControl & XnLayoutControl::EIgnoreState ) )
+if ( !( iLayoutControl & XnLayoutControl::EIgnoreState ) )
 {
 if ( iDisableCount > 0 )
 {
 retval = ETrue;
 }
 // -----------------------------------------------------------------------------
 // AddToRedrawListL
 // Mark Control's appearance to be redrawn
 // -----------------------------------------------------------------------------
 //
-void CXnUiEngineImpl::AddToRedrawListL( TXnDirtyRegion& aRegion,
+void CXnUiEngineImpl::AddToRedrawListL( CXnNode* aNode, TRect aRect )
-CXnNode& aNode, TRect aRect )
 {
-CXnControlAdapter* aAdapter( aNode.Control() );
+CXnControlAdapter* aAdapter( aNode->Control() );
 if( !aAdapter )
 {
 return;
 }
 if( aRect != TRect::EUninitialized )
 {
 // This is the new rect which will be set by layout algo
-aRegion.iRegion.AddRect( aRect );
+AddRedrawRectL( aRect, *aNode );
-aRegion.iRegion.Tidy();
 }
 TRect rect( aAdapter->Rect() );
 if( rect == TRect::EUninitialized )
 {
 // Don't add uninitialized rect
 return;
 }
-GrowIfNeeded( &aNode, rect );
+/*
+if( aNode->IsStateSet( XnPropertyNames::style::common::KFocus ) )
-aRegion.iRegion.AddRect( rect );
+{
-aRegion.iRegion.Tidy();
+const TDesC8& name( aNode->DomNode()->Name() );
+if( name == KPlugin )
+{
+rect.Grow( KFocusGrowValue, KFocusGrowValue );
+}
+else
+{
+TRect marginRect( aNode->MarginRect() );
+CXnNode* parent( aNode->Parent() );
+for( ; parent; parent = parent->Parent() )
+{
+if( parent->DomNode()->Name() == KPlugin )
+{
+if( parent->Rect() == marginRect )
+{
+rect.Grow( KFocusGrowValue, KFocusGrowValue );
+}
+break;
+}
+}
+}
+}
+*/
+GrowIfNeeded(aNode, rect);
+AddRedrawRectL( rect, *aNode );
 }
 // -----------------------------------------------------------------------------
 // AddToDirtyListL
 // Mark node to dirty list for relayout
 // -----------------------------------------------------------------------------
 //
-void CXnUiEngineImpl::AddToDirtyListL( TXnDirtyRegion& aRegion, CXnNode& aNode )
+void CXnUiEngineImpl::AddToDirtyListL( CXnNode* aNode )
 {
-CXnNode* nodeToRedrawList( &aNode );
-CXnNode* nodeToDirtyList( &aNode );
+if ( aNode )
+{
-if ( !IsAbsoluteL( aNode ) && !IsNodeTooltip( aNode ) )
+CXnNode* nodeToRedrawList( aNode );
-{
+CXnNode* nodeToDirtyList( aNode );
-// Check adaptives in normal flow
-CXnNode* oldest( NULL );
+if ( aNode == RootNode() )
-CXnNode* adaptive( &aNode );
+{
+// Force relayout and redraw from current view
-if ( !aNode.IsAdaptive( ETrue ) )
+iDirtyList.Reset();
-{
+if ( !iCurrentView )
-adaptive = aNode.Parent();
+{
-}
+iCurrentView = iViewManager.ViewNode();
+}
-for ( ; adaptive && adaptive->IsAdaptive( ETrue );
+iDirtyList.AppendL( iCurrentView );
-adaptive = adaptive->Parent() )
+TXnDirtyRegion* dirtyRegion = FindDirtyRegionL( *iCurrentView );
-{
+if( dirtyRegion )
-oldest = adaptive;
+{
-}
+dirtyRegion->iRegion.Clear();
+}
-// Now we have found the oldest adaptive node if present
+iLayoutControl |= XnLayoutControl::EViewDirty;
-if ( oldest )
+nodeToDirtyList = nodeToRedrawList = iCurrentView;
-{
+nodeToDirtyList->ClearRenderedAndLaidOut();
-nodeToRedrawList = nodeToDirtyList = adaptive;
-}
+// Add to draw list for redraw
-}
+AddToRedrawListL( nodeToRedrawList );
+}
-RPointerArray< CXnNode > dirtyList;
+else
-CleanupClosePushL( dirtyList );
+{
-TInt count( aRegion.iDirtyList.Count() );
+if ( !IsAbsoluteL( *aNode ) && !IsNodeTooltip( *aNode ) )
-TBool found;
+{
+// Check adaptives in normal flow
-// first, check that aNode's children are not in the dirty array
+CXnNode* oldest( NULL );
-for ( TInt i = 0; i < count; ++i )
+CXnNode* adaptive( aNode );
-{
-found = EFalse;
+if ( !aNode->IsAdaptive( ETrue ) )
-CXnNode* candidate( aRegion.iDirtyList[i] );
+{
+adaptive = aNode->Parent();
-for ( CXnNode* node = candidate->Parent(); node && !found;
+}
-node = node->Parent() )
-{
+for ( ; adaptive && adaptive->IsAdaptive( ETrue );
-if ( nodeToDirtyList == node )
+adaptive = adaptive->Parent() )
 {
-found = ETrue;
+oldest = adaptive;
 }
-}
+// Now we have found the oldest adaptive node if present
-if ( !found )
+if ( oldest )
 {
-// Put candidate back to list as child is not found
+nodeToRedrawList = nodeToDirtyList = adaptive;
-dirtyList.AppendL( candidate );
+}
 }
-}
+RPointerArray< CXnNode > dirtyList;
-found = EFalse;
+CleanupClosePushL( dirtyList );
+TInt count( iDirtyList.Count() );
-// second, check that aNode's parent is not in dirty array
+TBool found;
-for ( TInt i = 0; i < count && !found; ++i )
-{
+// first, check that aNode's children are not in the dirty array
-CXnNode* candidate( aRegion.iDirtyList[i] );
+for ( TInt i = 0; i < count; ++i )
+{
-for ( CXnNode* node = nodeToDirtyList; node && !found;
+found = EFalse;
-node = node->Parent() )
+CXnNode* candidate( iDirtyList[i] );
-{
-if ( node == candidate )
+for ( CXnNode* node = candidate->Parent(); node && !found;
-{
+node = node->Parent() )
-found = ETrue;
+{
-}
+if ( nodeToDirtyList == node )
-}
+{
-}
+found = ETrue;
+}
-if ( !found && aRegion.iDirtyList.Find( nodeToDirtyList ) == KErrNotFound )
+}
-{
-// Add node to dirty list as parent is neither found
+if ( !found )
-dirtyList.AppendL( nodeToDirtyList );
+{
-nodeToDirtyList->ClearRenderedAndLaidOut();
+// Put candidate back to list as child is not found
+dirtyList.AppendL( candidate );
-// Add to draw list for redraw
+}
-AddToRedrawListL( aRegion, *nodeToRedrawList );
+}
-}
+found = EFalse;
-// finally update the dirty list
-aRegion.iDirtyList.Reset();
+// second, check that aNode's parent is not in dirty array
-aRegion.iDirtyList = dirtyList;
+for ( TInt i = 0; i < count && !found; ++i )
+{
-CleanupStack::Pop( &dirtyList );
+CXnNode* candidate( iDirtyList[i] );
+for ( CXnNode* node = nodeToDirtyList; node && !found;
+node = node->Parent() )
+{
+if ( node == candidate )
+{
+found = ETrue;
+}
+}
+}
+if ( !found && iDirtyList.Find( nodeToDirtyList ) == KErrNotFound )
+{
+// Add node to dirty list as parent is neither found
+dirtyList.AppendL( nodeToDirtyList );
+nodeToDirtyList->ClearRenderedAndLaidOut();
+// Add to draw list for redraw
+AddToRedrawListL( nodeToRedrawList );
+}
+// finally update the dirty list
+iDirtyList.Reset();
+iDirtyList = dirtyList;
+CleanupStack::Pop( &dirtyList );
+}
+}
 }
 // -----------------------------------------------------------------------------
 // CXnUiEngineImpl::SetClientRectL
 // -----------------------------------------------------------------------------
 UpdateInternalUnits( iHorizontalUnitInPixels, iVerticalUnitInPixels,
 iClientRect );
 iEditMode->SetClientRect( aRect );
-CXnViewSwitcher* viewSwitcher( iAppUiAdapter.ViewSwitcher() );
-if( viewSwitcher )
-{
-viewSwitcher->SizeChanged( aRect );
-}
 if ( aDrawNow )
 {
 RootNode()->SetDirtyL();
 iUiEngine->RenderUIL();
 }
 // -----------------------------------------------------------------------------
 // CXnUiEngineImpl::StartLayoutFromL
 // -----------------------------------------------------------------------------
 //
-CXnNode* CXnUiEngineImpl::StartLayoutFromL( TXnDirtyRegion& aDirtyRegion )
+CXnNode* CXnUiEngineImpl::StartLayoutFromL()
 {
-CXnNode* viewNode( aDirtyRegion.iRootNode );
+if ( iLayoutControl & XnLayoutControl::EViewDirty )
-if( !viewNode )
+{
-{
+return iCurrentView;
-return NULL;
-}
-if ( aDirtyRegion.iLayoutControl & XnLayoutControl::EViewDirty )
-{
-return viewNode;
 }
 RPointerArray< CXnNode >parentArray;
 CleanupClosePushL( parentArray );
-TInt dirtyCount = aDirtyRegion.iDirtyList.Count();
+TInt dirtyCount = iDirtyList.Count();
 CXnNode* startNode( NULL );
 for ( TInt dirtyIndex = 0; dirtyIndex < dirtyCount; dirtyIndex++ )
 {
-startNode = aDirtyRegion.iDirtyList[dirtyIndex];
+startNode = iDirtyList[dirtyIndex];
-for ( ;startNode && startNode != viewNode; )
+for ( ;startNode && startNode != iCurrentView; )
 {
 parentArray.Append( startNode->Parent() );
 startNode = startNode->Parent();
 }
 }
 }
 }
 CleanupStack::PopAndDestroy( &parentArray );
-return viewNode;
+return iCurrentView;
 }
 // -----------------------------------------------------------------------------
 // CXnUiEngineImpl::Plugins
 // -----------------------------------------------------------------------------
 // CXnUiEngineImpl::ForceRenderUIL
 // -----------------------------------------------------------------------------
 //
 void CXnUiEngineImpl::ForceRenderUIL( TBool aLayoutOnly )
 {
-TXnDirtyRegion* dirtyRegion = FindDirtyRegionL( *iCurrentView );
+iLayoutControl |= XnLayoutControl::EIgnoreState;
-if( !dirtyRegion )
-{
-return;
-}
-dirtyRegion->iLayoutControl |= XnLayoutControl::EIgnoreState;
 if ( aLayoutOnly )
 {
 LayoutUIL();
 }
 else
 {
 LayoutUIL();
 RenderUIL();
 }
+iLayoutControl &= ~XnLayoutControl::EIgnoreState;
-dirtyRegion->iLayoutControl &= ~XnLayoutControl::EIgnoreState;
 }
 // -----------------------------------------------------------------------------
 // CXnUiEngineImpl::GetThemeResource
 // -----------------------------------------------------------------------------
 {
 self->iDisableCount--;
 if ( self->iDisableCount == 0 )
 {
-TRAP_IGNORE( self->EnableRenderUiL() );
+TRAP_IGNORE(
-}
-}
-}
-// -----------------------------------------------------------------------------
-// -----------------------------------------------------------------------------
-//
-void CXnUiEngineImpl::EnableRenderUiL()
-{
-CXnViewData* viewData = iViewManager.ActiveAppData().ViewData( *iCurrentView );
-if( viewData )
-{
-RPointerArray<TXnDirtyRegion> arr;
-CleanupClosePushL( arr );
-viewData->GetDirtyRegions( arr );
-for( TInt i = 0; i < arr.Count(); i++ )
-{
-TXnDirtyRegion* dirtyRegion = arr[i];
 // Is menu refresh pending?
-if ( ( dirtyRegion->iLayoutControl & XnLayoutControl::ERefreshMenu ) &&
+if ( ( self->iLayoutControl & XnLayoutControl::ERefreshMenu ) &&
-IsMenuDisplaying() )
+!self->IsMenuDisplaying() )
 {
 // RefreshMenuL will reset the state flag
-RefreshMenuL( dirtyRegion );
+self->RefreshMenuL();
 }
 // Is layout pending?
-if ( dirtyRegion->iLayoutControl & XnLayoutControl::ELayoutUI )
+if ( self->iLayoutControl & XnLayoutControl::ELayoutUI )
 {
-LayoutL( *dirtyRegion );
+self->LayoutUIL();
 }
 // Is render pending?
-if ( dirtyRegion->iLayoutControl & XnLayoutControl::ERenderUI )
+if ( self->iLayoutControl & XnLayoutControl::ERenderUI )
 {
-RenderL( *dirtyRegion );
+self->RenderUIL();
 }
-}
+);
-CleanupStack::PopAndDestroy( &arr);
+}
 }
 }
 // -----------------------------------------------------------------------------
 // -----------------------------------------------------------------------------
 //
 void CXnUiEngineImpl::ReportScreenDeviceChangeL()
 {
-// Notify current orientation to all views
+CXnNode* trigger( BuildScreenDeviceChangeTriggerNodeLC( *iUiEngine ) );
-RPointerArray< CXnPluginData >& plugins(
-iViewManager.ActiveAppData().PluginData() );
+// Notify current orientation to iCurrentView
+iCurrentView->ReportXuikonEventL( *trigger );
-for( TInt i = 0; i < plugins.Count(); i++ )
-{
+// Notify also plugins
-ReportScreenDeviceChangedL( *plugins[i] );
+RPointerArray<CXnNode> plugins = *Plugins();
-CXnDomNode* domNode( plugins[i]->Node() );
+for( TInt i=0; i<plugins.Count(); i++ )
-if( domNode )
+{
-{
+CXnNode* pluginNode = plugins[i];
-CXnNode* node( domNode->LayoutNode() );
+RPointerArray<CXnNode> pluginChildren = pluginNode->Children();
-if( node )
+for( TInt ii=0; ii<pluginChildren.Count(); ii++ )
 {
-node->SetDirtyL();
+CXnDomNode* widgetNode = pluginChildren[ii]->DomNode();
-}
+if( widgetNode && widgetNode->Name() == KWidgetNodeName )
-}
+{
-}
+pluginChildren[ii]->ReportXuikonEventL( *trigger );
+}
+}
+}
+CleanupStack::PopAndDestroy(); // trigger
 }
 // -----------------------------------------------------------------------------
 // CXnUiEngineImpl::HandlePartialTouchInputL()
 // -----------------------------------------------------------------------------
-void CXnUiEngineImpl::HandlePartialTouchInputL( CXnNode* aNode, TBool aEnable )
+void CXnUiEngineImpl::HandlePartialTouchInputL( CXnNode& aNode, TBool aEnable )
 {
-CXnViewData& view( iViewManager.ActiveViewData() );
+CXnNode* editorplugin = FindPlugin( aNode );
+if ( !editorplugin )
-CXnNode* editor( aEnable ? aNode : iSplitScreenState.iPartialScreenEditorNode );
+{
+User::Leave( KErrNotFound );
-CXnPluginData* plugin( view.Plugin( editor ) );
+}
-if ( !plugin || !editor )
-{
-return;
-}
-CXnNode* editorplugin( plugin->Owner()->LayoutNode() );
 DisableRenderUiLC();
 if ( aEnable )
 {
 iSplitScreenState.iPartialScreenOpen = ETrue;
-iSplitScreenState.iPartialScreenEditorNode = editor;
+iSplitScreenState.iPartialScreenEditorNode = &aNode;
 // make sure that we always get up event
-CXnViewControlAdapter* control =
+CXnViewControlAdapter* control = static_cast< CXnViewControlAdapter* >(
-static_cast< CXnViewControlAdapter* >( view.ViewNode()->Control() );
+iViewManager.ActiveViewData().ViewNode()->Control() );
 control->ResetGrabbing();
 // Block progression must be bottom-to-top when partial screen is open
 // Previous value needs to be stored first
 CXnProperty* prop(
 }
 RootNode()->SetDirtyL();
 ForceRenderUIL();
 CleanupStack::PopAndDestroy();
+}
-if ( aEnable )
-{
+// -----------------------------------------------------------------------------
-editor->PluginIfL().ReportTriggerEventL(
+// -----------------------------------------------------------------------------
-KSplitScreenEnabledTrigger, KNullDesC8, KNullDesC8 );
+CCoeControl* CXnUiEngineImpl::WindowOwningControl( CXnNode& aNode )
-}
-else
-{
-editor->PluginIfL().ReportTriggerEventL(
-KSplitScreenDisabledTrigger, KNullDesC8, KNullDesC8 );
-}
-}
-// -----------------------------------------------------------------------------
-// -----------------------------------------------------------------------------
-CXnNode* CXnUiEngineImpl::WindowOwningNode( CXnNode& aNode )
 {
 CXnNode* parent = &aNode;
 while( parent )
 {
 CXnControlAdapter* adapter = parent->Control();
 if( adapter )
 {
 if( parent->ViewNodeImpl() &&
 adapter == iCurrentViewControlAdapter )
 {
-return parent;
+return adapter;
 }
 else if( adapter->OwnsWindow() )
 {
 if( !IsNodeTooltip( *parent ) )
 {
-return parent;
+return adapter;
 }
 else
 {
 return NULL;
 }
 // -----------------------------------------------------------------------------
 // -----------------------------------------------------------------------------
 TXnDirtyRegion* CXnUiEngineImpl::FindDirtyRegionL( CXnNode& aNode )
 {
-CXnNode* node( WindowOwningNode( aNode ) );
+CCoeControl* control = WindowOwningControl( aNode );
-if( !node )
+if( !control )
 {
 return NULL;
 }
+for( TInt i=0; i<iRedrawRegions.Count(); i++ )
+{
+if( iRedrawRegions[i]->iControl == control )
+{
+return iRedrawRegions[i];
+}
+}
+TXnDirtyRegion* region = new (ELeave) TXnDirtyRegion;
+CleanupStack::PushL( region );
+region->iControl = control;
+iRedrawRegions.AppendL( region );
+CleanupStack::Pop();
+return region;
+}
+// -----------------------------------------------------------------------------
+// -----------------------------------------------------------------------------
+void CXnUiEngineImpl::AddRedrawRectL( TRect aRect, CXnNode& aNode )
+{
+TXnDirtyRegion* dirtyReg = FindDirtyRegionL( aNode );
+if( dirtyReg )
+{
+dirtyReg->iRegion.AddRect( aRect );
+dirtyReg->iRegion.Tidy();
+}
+}
+// -----------------------------------------------------------------------------
+// SetEventDispatcher
+// -----------------------------------------------------------------------------
+void CXnUiEngineImpl::SetEventDispatcher( CXnKeyEventDispatcher* aDispatcher )
+{
+iKeyEventDispatcher = aDispatcher;
+}
+// -----------------------------------------------------------------------------
+// NotifyStatusPaneSizeChanged
+// -----------------------------------------------------------------------------
+void CXnUiEngineImpl::NotifyStatusPaneSizeChanged()
+{
+TRAP_IGNORE( iUiEngine->SetClientRectL( iAppUiAdapter.ClientRect(), EFalse ) );
+}
-CCoeControl* control( node->Control() );
-if( !control )
-{
-return NULL;
-}
-TXnDirtyRegion* region( NULL );
-CXnViewData* viewData = iViewManager.ActiveAppData().ViewData( *node );
-if( viewData )
-{
-region = viewData->DirtyRegionL( *node );
-}
-return region;
-}
-// -----------------------------------------------------------------------------
-// SetEventDispatcher
-// -----------------------------------------------------------------------------
-void CXnUiEngineImpl::SetEventDispatcher( CXnKeyEventDispatcher* aDispatcher )
-{
-iKeyEventDispatcher = aDispatcher;
-}
-// -----------------------------------------------------------------------------
-// NotifyStatusPaneSizeChanged
-// -----------------------------------------------------------------------------
-void CXnUiEngineImpl::NotifyStatusPaneSizeChanged()
-{
-TRAP_IGNORE( iUiEngine->SetClientRectL( iAppUiAdapter.ClientRect(), EFalse ) );
-}
 // -----------------------------------------------------------------------------
 // NotifyResourceChanged
 // -----------------------------------------------------------------------------
 void CXnUiEngineImpl::NotifyResourceChanged( TInt aType )
 {
 }
 // -----------------------------------------------------------------------------
 // EnablePartialTouchInput
 // -----------------------------------------------------------------------------
-void CXnUiEngineImpl::EnablePartialTouchInput( CXnNode* aNode, TBool aEnable )
+void CXnUiEngineImpl::EnablePartialTouchInput( CXnNode& aNode, TBool aEnable )
 {
 if( aEnable && !iSplitScreenState.iPartialScreenOpen ||
 !aEnable && iSplitScreenState.iPartialScreenOpen )
 {
 TRAP_IGNORE( HandlePartialTouchInputL( aNode, aEnable ) );
 // CXnUiEngineImpl::IsTextEditorActive()
 // -----------------------------------------------------------------------------
 //
 TBool CXnUiEngineImpl::IsTextEditorActive()
 {
-if( iKeyEventDispatcher )
+if( iSplitScreenState.iPartialScreenOpen )
 {
-return iKeyEventDispatcher->IsTextEditorActive();
+return ETrue;
 }
+CXnNode* focusedNode = FocusedNode();
+if( focusedNode )
+{
+if( focusedNode->Type()->Type() == KEditorNodeName )
+{
+return ETrue;
+}
+}
 return EFalse;
 }
 // End of file

branch	RCL_3
changeset 102	ba63c83f4716
parent 93	b01126ce0bec