MCL/sf/mw/uiaccelerator: comparison uiacceltk/hitchcock/ServerCore/Src/alfbridge.cpp

equal deleted inserted replaced

-:e5af45d51884
+:31fccae4f8a7
 #ifdef SYMBIAN_BUILD_GCE
 #include <bautils.h>
 #endif
+#ifdef ALF_MEMORYLOGGING
+#include <hal.h>
+#endif
+#include <graphics/fbsrasterizer.h>
+#include <graphics/fbsrasterizerclearcache.h>
 const TInt KVisualTransformationStepRotate    = 0;
 const TReal32 KAlfVisualDefaultOpacity = 1.0f;
 //const TReal32 KAlfVisualDefaultOpacity = 0.5f;
 const TInt KEffectCleanupDelayInMs = 10;
 // Duration to wait if coverage is modified by multiple control groups.
 // This may indicate that topmost application hasn't yet had time to update
 // its layout properly.
 const TInt KAlfCheckCoverageFromMultipleGroups = 20;
+// Duration to wait if visual is not ready for current orientation.
+// 1 unit = 50ms.
+const TInt KAlfCheckVisualIsNotReady = 15;
 NONSHARABLE_CLASS( TAlfBridgeDrawerWrapper ) : public MAlfDrawerScreenInterface
 {
 public:
 TAlfBridgeDrawerWrapper(CAlfBridge& aBridge);
 	    }
 	iAlfRegisteredEffects.Close();
 delete iEffectEndTimer;
 iDeadControlGroups.Close();
 iEffectWindowGroups.Close();
+iWindowChainsArray.Close();
 delete iFSFxData;
 delete iFSFXDataPart2;
 if (iActivated)
 {
 //  a fade that does not belong to the theme may be in use.
 // ---------------------------------------------------------------------------
 void CAlfBridge::RegisterFadeEffectL()
 {
 // TODO: RND, REMOVE MMC DRIVE-F, WHEN NOT REQUIRED FOR TESTING
+#ifdef USE_ALTERNATIVE_EFFECTS_FROM_MMC
 _LIT(KDrivePrefence,"FZC");
+#else
+_LIT(KDrivePrefence,"Z");
+#endif
 // Force register fade effect. Try first MMC, then ROM.
 CHuiFxEngine* engine = iHuiEnv->EffectsEngine();
 RFs& fs = CHuiStatic::FsSession();
 if (fs.Handle() && engine)
 {
 }
 }
 while(node);
 	return NULL;
 }
+// ---------------------------------------------------------------------------
+// FindChainedGroup
+// ---------------------------------------------------------------------------
+//
+TUint32 CAlfBridge::FindChainedGroup(
+TUint32 aTreeNodeId)
+{
+THashMapIter<TUint32, TChainData> iter(iWindowChainsArray);
+TChainData const * data = 0;
+do
+{
+data = iter.NextValue();
+if (data && data->iParent == aTreeNodeId)
+{
+TUint32 chainedTo = FindChainedGroup(data->iChainee);
+if (!chainedTo)
+{
+return data->iChainee;
+}
+else
+{
+return chainedTo;
+}
+}
+}
+while(data);
+return NULL;
+}
+// ---------------------------------------------------------------------------
+// IsChainedGroup
+// ---------------------------------------------------------------------------
+//
+TBool CAlfBridge::IsChainedGroup(
+TUint32 aTreeNodeId)
+{
+THashMapIter<TUint32, TChainData> iter(iWindowChainsArray);
+TChainData const * data = 0;
+do
+{
+data = iter.NextValue();
+if (data && data->iChainee == aTreeNodeId)
+{
+return ETrue;
+}
+}
+while(data);
+return EFalse;
+}
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 //
 CHuiControlGroup* CAlfBridge::FindControlGroup(TInt aWindowGroupNodeId, TInt aScreenNumber )
 {
 // ---------------------------------------------------------------------------
 // FindClientWindowGroupId
 // ---------------------------------------------------------------------------
 //
-TInt CAlfBridge::FindClientWindowGroupId( TInt aScreenNumber, CHuiControlGroup& aControlGroup  )
+TInt CAlfBridge::FindClientWindowGroupId(CHuiControlGroup& aControlGroup  )
 {
-for (TInt i=0; i<iAlfScreens[aScreenNumber]->iControlGroups.Count();i++)
+for (TInt i=0; i<iAlfScreens[0]->iControlGroups.Count();i++)
 {
-if( iAlfScreens[aScreenNumber]->iControlGroups[i].iControlGroup == &aControlGroup )
+if( iAlfScreens[0]->iControlGroups[i].iControlGroup == &aControlGroup )
 {
-return iAlfScreens[aScreenNumber]->iControlGroups[i].iClientWindowGroupId;
+return iAlfScreens[0]->iControlGroups[i].iClientWindowGroupId;
 }
 }
 return KErrNotFound;
 }
 // ---------------------------------------------------------------------------
 // FindWindowGroupNodeId
 // ---------------------------------------------------------------------------
 //
-TInt CAlfBridge::FindWindowGroupNodeId( TInt aScreenNumber, CHuiControlGroup& aControlGroup ) const
+TInt CAlfBridge::FindWindowGroupNodeId(CHuiControlGroup& aControlGroup ) const
 {
-for (TInt i=0; i<iAlfScreens[aScreenNumber]->iControlGroups.Count();i++)
+for (TInt i=0; i<iAlfScreens[0]->iControlGroups.Count();i++)
 {
-if( iAlfScreens[aScreenNumber]->iControlGroups[i].iControlGroup == &aControlGroup )
+if( iAlfScreens[0]->iControlGroups[i].iControlGroup == &aControlGroup )
 {
-return iAlfScreens[aScreenNumber]->iControlGroups[i].iWindowGroupNodeId;
+return iAlfScreens[0]->iControlGroups[i].iWindowGroupNodeId;
 }
 }
 return KErrNotFound;
 }
 return groupEntry.iControlGroup;
 }
 }
 }
 return NULL;
+}
+// ---------------------------------------------------------------------------
+// FindControlGroupBySecureId
+// May return multiple groups
+// ---------------------------------------------------------------------------
+//
+void CAlfBridge::FindControlGroupBySecureId( TInt aSecureId, RPointerArray<CHuiControlGroup>& aGroupList)
+{
+if ( aSecureId == 0 )
+{
+return;
+}
+for ( TInt i = 0; i < iAlfScreens[0]->iControlGroups.Count(); i++ )
+{
+TAlfControlGroupEntry& groupEntry = iAlfScreens[0]->iControlGroups[i];
+if ( groupEntry.iSecureId == aSecureId )
+{
+aGroupList.Append(groupEntry.iControlGroup);
+}
+}
 }
 // ---------------------------------------------------------------------------
 // FindControlGroupByFullScreenToEffect
 // ---------------------------------------------------------------------------
 TInt aWindowGroupNodeId,
 TInt aClientWindowGroupId,
 TInt aSecureId,
 TInt aScreenNumber )
 {
-CHuiControlGroup* group = FindControlGroup(aWindowGroupNodeId,aScreenNumber);
+CHuiControlGroup* group = FindControlGroup(aWindowGroupNodeId);
 if (!group)
 {
 group = &iHuiEnv->NewControlGroupL(aWindowGroupNodeId);
 group->SetSecureId(aSecureId);
 CleanupStack::PushL(group);
 TAlfControlGroupEntry entry;
 entry.iControlGroup = group;
 entry.iWindowGroupNodeId = aWindowGroupNodeId;
 entry.iClientWindowGroupId = aClientWindowGroupId;
 entry.iSecureId = aSecureId;
+// Add to the control group. HandleGfxEventL effect redirection will need this information
+entry.iScreenNumber = aScreenNumber;
+iAlfScreens[aScreenNumber]->iControlGroups.Append(entry);
+CleanupStack::Pop(group);
 // we have received start effect for this group, but the group did not exist in alf universe at the time. hide the group.
 if (iFSFxData
 && (iFSFxData->State() == EWaitingWindowGroup || iFSFxData->State() == EEndFullScreenReceivedWaitingWindowGroup)
 && iFSFxData->iToSecureId == aSecureId)
 {
 // Effect failed, reset state
 __ALFFXLOGSTRING1("CAlfBridge::CreateControlGroupL - effect failed on layout 0x%x", layout);
 HandleGfxStopEvent( EFalse ); // destroys iFSFxData and iFSFXDataPart2
 }
 }
-entry.iScreenNumber = aScreenNumber;
-//        entry.iRole = EHuiWindowGroupContainer;
-iAlfScreens[aScreenNumber]->iControlGroups.Append(entry);
-CleanupStack::Pop(group);
 if (iAlfScreens[aScreenNumber]->iDisplay)
 ShowControlGroupL(iAlfScreens[aScreenNumber]->iDisplay->Roster(), *group, KHuiRosterShowAtTop, aScreenNumber);
 AMT_INC_COUNTER( iTotalControlGroupCount );
 TBool lSyncDone(EFalse);
 if (lSyncAlfAppAndAlfEventGroup && i< (aRoster.Count()-1) )
 {
 lSyncDone = ETrue;
 CHuiControlGroup &lGroup = aRoster.ControlGroup(i+1);
-TInt clientWindowGroupId = FindClientWindowGroupId( aScreenNumber, lGroup );
+TInt clientWindowGroupId = FindClientWindowGroupId(lGroup );
 iAppUi->AdjustWindowGroupPositionL(clientWindowGroupId,CAlfAppServer::EBehindOfParent);
 }
 if(!lSyncDone && aGroup.iAlfApp && aRoster.ControlGroup(i-1).ResourceId() != iAlfWindowGroupNodeId )
 {
 CHuiControlGroup &lGroup = aRoster.ControlGroup(i);
-TInt clientWindowGroupId = FindClientWindowGroupId( aScreenNumber, lGroup );
+TInt clientWindowGroupId = FindClientWindowGroupId(lGroup );
 iAppUi->AdjustWindowGroupPositionL(clientWindowGroupId,CAlfAppServer::EBehindOfParent);
 }
 break;
 }
 if ( iAlfScreens[0]->iControlGroups[i].iSecureId == secureId &&
 iAlfScreens[0]->iControlGroups[i].iClientWindowGroupId != CHuiStatic::RootWin(0)->Identifier())
 {
 iAlfWindowGroupNodeId = iAlfScreens[0]->iControlGroups[i].iWindowGroupNodeId;
-CHuiControlGroup* controlGroup = FindControlGroup(iAlfWindowGroupNodeId, 0);
+CHuiControlGroup* controlGroup = FindControlGroup(iAlfWindowGroupNodeId);
 CHuiControl& control = controlGroup->Control(0);
 CHuiVisual* layout = &control.Visual(0);
 iAlfScreens[0]->iDisplay->Roster().SetAlfEventWindow(layout);
 return;
 }
 {
 TBuf<8> numBuf;
 numBuf.AppendNum(fps, TRealFormat(5,1));
 TRAP_IGNORE(
 {
-iAlfScreens[screenNumber]->iFPSText->SetTextL( numBuf );
+iAlfScreens[0]->iFPSText->SetTextL( numBuf );
 })
 }
 }
 #endif
 if (!iActivated)
 {
 TInt err = iBridgerClient.Connect();
 iActivated = (err == KErrNone);
 }
-if (iAlfScreens[screenNumber]->IsVisualTreeVisibilityChanged())
+if (iAlfScreens[0]->IsVisualTreeVisibilityChanged())
 {
 HandleVisualVisibility( screenNumber );
-iAlfScreens[screenNumber]->SetVisualTreeVisibilityChanged(EFalse);
+iAlfScreens[0]->SetVisualTreeVisibilityChanged(EFalse);
 }
 }
 }
 // ---------------------------------------------------------------------------
 }
 transparent |= (!((aVisual.Flags() & EHuiVisualFlagOpaqueHint) == EHuiVisualFlagOpaqueHint));
 transparent |= (aVisual.iOpacity.Now() < KAlfVisualDefaultOpacity);
 transparent |= (aVisual.iOpacity.Target() < KAlfVisualDefaultOpacity);
+if(aVisual.Effect())
+{
+transparent |= (aVisual.iEffectOpacity < KAlfVisualDefaultOpacity);
+}
 return  !transparent;
 }
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 }
 	TBool alfWindowGroupFoundVisible = EFalse;
 	TBool alfClientWindowGroupVisible = EFalse;
+	TBool firstAlfControlGroupFound = EFalse;
 AMT_SET_VALUE( iVisibleVisualCount, 0 );
 // skip the topmost (effect) layer, start from floating sprite group
 for (TInt j=screen->iDisplay->Roster().Count() - screen->FixedControlGroupCount(); j>=0; j--)
 {
 activeSession = iAppUi->ActiveSession();
 }
 // !fullscreenCovered need to be checked because for fullscreen
 // alf applications alf event window group could be on top of alf client windowgroup
-if ( (alfClientWindowGroupVisible || !fullscreenCovered)  && activeSession)
+if ( (!firstAlfControlGroupFound || !fullscreenCovered)  && activeSession)
 {
 // clear inactive flag if client has not made this controlgroup hidden
 if(!(flags&EHuiVisualFlagUnderOpaqueHint))
 {
 if(iAppUi)
 hostContainer->ClearFlags(EHuiVisualFlagInactive);
 // just add the rect to covered region because alf draws solid background
 iTempRegion.AddRect(fullscreen);
 iTempRegion.Tidy();
 fullscreenCovered = ETrue;
-alfClientWindowGroupVisible = EFalse;  // change flag so that we don't go in this branch again
+firstAlfControlGroupFound = ETrue;  // change flag so that we don't go in this branch again
+}
+else
+{
+hostContainer->SetFlags(EHuiVisualFlagInactive);
 }
 }
 }
 else // else put as inactive
 {
 HandleLayoutVisualVisibility( layout, controlgroup, control,
 fullscreenCovered, fullscreen, screen,
 subTreeCovered, hasLayers, IsVisualOpaque(*layout) );
 }
+if ( hasLayers && iActivated )
-TBool hasFadeEffectsInVisualTree = (layout->CanvasFlags() & EHuiCanvasFlagExternalFadeExistsInsideVisualTree);
+{
+HandleLayerVisibility( layout, controlgroup, control, hasActiveVisualsInVisualTree );
+}
+TBool isLayoutActive = !(layout->Flags() & EHuiVisualFlagInactive);
+// we need to set /clear inactive flags before we evaluate the fade effect,
+// otherwise the fade effect will be removed without a reason in
+// some use cases
+if (isLayoutActive && (fullscreenCovered || (!hasActiveVisualsInVisualTree && !IsOpaqueEffect(layout->Effect()))))
+{
+// don't inactivate alf event wg if alf client is visible
+if( !( alfClientWindowGroupVisible && (controlgroup.ResourceId() == iAlfWindowGroupNodeId)) )
+// Setting also the root visual (layout) as inactive, if it had none
+// active children. This is because otherwise the Inactive checks won't
+// work correctly within RosterImpl ScanDirty & ClearChanged phases.
+// If root visual is having an opaque effect, it must remain active
+{
+layout->SetFlag(EHuiVisualFlagInactive);
+}
+}
+else if(!isLayoutActive && !fullscreenCovered && (hasActiveVisualsInVisualTree || IsOpaqueEffect(layout->Effect())) ||
+(alfClientWindowGroupVisible && (controlgroup.ResourceId() == iAlfWindowGroupNodeId)) )
+{
+layout->ClearFlag(EHuiVisualFlagInactive);
+layout->SetPos(fullscreen.iTl);
+layout->SetSize(fullscreen.Size());
+		    // New visible window group may have received effect just before appearing to the screen.
+			// start the effect if this is the case.
+if(iFSFxData && iFSFxData->iToSecureId == controlgroup.SecureId() )
+{
+TInt windowGroupId = FindClientWindowGroupId(controlgroup);
+if (iFSFxData->iToWg == windowGroupId && iFSFxData->State() == EWaitEndFullScreen &&
+iFSFxData->iTwoPhaseEffect <= CFullScreenEffectState::ESecondPartActive)
+{
+GfxTriggerEffectWhenFullScreenDrawn(&controlgroup);
+}
+}
+}
+// If root visuals effect is marked as opaque, then add whole screen area as covered.
+if (!fullscreenCovered)
+{
+fullscreenCovered = IsOpaqueEffect(layout->Effect());
+}
 // if native alf app is found visible and the client it self is not covering whole screen, we can assume that alf content
 // fills the rest.
 // this is for embedded native alf application cases. Otherwise chained window groups tend to
 // flicker from time to time
 // also if alfcontent is not hided below avkon content the fading effect would reveal alfconent
 iTempRegion.Tidy();
 fullscreenCovered = ETrue;
 alfClientWindowGroupVisible = ETrue;
 }
 }
-// If root visuals effect is marked as opaque, then add whole screen area as covered.
-if (!fullscreenCovered)
-{
-fullscreenCovered = IsOpaqueEffect(layout->Effect());
-}
-if ( hasLayers && iActivated )
-{
-HandleLayerVisibility( layout, controlgroup, control, hasActiveVisualsInVisualTree );
-}
-TBool isLayoutActive = !(layout->Flags() & EHuiVisualFlagInactive);
-// we need to set /clear inactive flags before we evaluate the fade effect,
-// otherwise the fade effect will be removed without a reason in
-// some use cases
-if (isLayoutActive && !hasActiveVisualsInVisualTree && !IsOpaqueEffect(layout->Effect()))
-{
-// Setting also the root visual (layout) as inactive, if it had none
-			// active children. This is because otherwise the Inactive checks won't
-			// work correctly within RosterImpl ScanDirty & ClearChanged phases.
-			// If root visual is having an opaque effect, it must remain active
-layout->SetFlag(EHuiVisualFlagInactive);
-}
-else if(!isLayoutActive && (hasActiveVisualsInVisualTree || IsOpaqueEffect(layout->Effect())))
-{
-layout->ClearFlag(EHuiVisualFlagInactive);
-layout->SetPos(fullscreen.iTl);
-layout->SetSize(fullscreen.Size());
-}
+TBool hasFadeEffectsInVisualTree = (layout->CanvasFlags() & EHuiCanvasFlagExternalFadeExistsInsideVisualTree);
 		// If we layout is active setup the fade effects. Also if it is inactive, but has been
 		// flagged as containing fade effect, then run the setup as well so that effects which
 		// are no more needed get removed.
 if (hasActiveVisualsInVisualTree || (!hasActiveVisualsInVisualTree && hasFadeEffectsInVisualTree))
 {
 case EAlfDSIncludeToVisibilityCalculation:
 {
 HandleIncludeToVisibilityCalculationL( data );
 break;
 }
+case EAlfDSSetScreenDeviceValid:
+{
+HandleSetScreenDeviceValidL( data );
+break;
+}
 case EAlfDSSetWindowArea:
 {
 HandleSetWindowAreaL( data );
 break;
 }
 //                HandleGetNativeWindowDataL( data );
 break;
 }
 case EAlfDSGroupChained:
 	{
-	__ALFLOGSTRING("CAlfBridge::DoDispatchL, EAlfDSGroupChained");
+	HandleGroupChained(data);
-	// TODO, link groups
 	break;
 	}
 case EAlfDSGroupChainBroken:
 	{
-	__ALFLOGSTRING("CAlfBridge::DoDispatchL, EAlfDSGroupChainBroken");
+	HandleGroupChainBroken(data);
-	// TODO, break link
 	break;
 	}
 case EAlfDSMoveWindowToNewGroup:
 	{
 	HandleMoveWindowToNewGroupL( data );
 void CAlfBridge::HandleNewWindowL( TAlfBridgerData& aData )
 	{
 	TInt windowGroupNodeId = aData.iInt1;
 	TInt windowNodeId = aData.iInt2;
 	TAlfWindowAttributes* windowAttributes = (TAlfWindowAttributes*) (*iHost)->GetVarDataL( (TInt)aData.iPtr );
-	TInt screenNumber = windowAttributes->iScreenNumber;
 	__ALFLOGSTRING1("CAlfBridge::HandleNewWindowL: new window %d!",windowNodeId);
 	switch (windowAttributes->iWindowNodeType)
 		{
 		case EAlfWinTreeNodeGroup:
 			{
 			CHuiControlGroup& controlGroup = CreateControlGroupL(
 			        windowGroupNodeId,
 			        windowAttributes->iClientHandle,
 			        windowAttributes->iSecureId,
-			        screenNumber);
+			        0 // Only one screen for avkon content supported
+					);
 			// We just received notification for our own window group creation, store its node id for doing
 			// faster lookups later...
 			if (windowAttributes->iClientHandle == iAlfWindowGroupId)
 				{
 		case EAlfWinTreeNodeRoot: // TODO: Root window receives drawing commands too
 		case EAlfWinTreeNodeAnim:
 		case EAlfWinTreeNodeSprite:
 		case EAlfWinTreeNodeTextCursor:
 			{
-			CHuiControlGroup* controlGroup = FindControlGroup(windowGroupNodeId,screenNumber);
+			CHuiControlGroup* controlGroup = FindControlGroup(windowGroupNodeId);
 			// Floating sprites only require own group. Normal sprites should behave as normal visuals.
 			if (!controlGroup && windowAttributes->iWindowNodeType == EAlfWinTreeNodeSprite )
 				{
-				controlGroup = iAlfScreens[screenNumber]->iFloatingSpriteControlGroup;
+				controlGroup = iAlfScreens[0]->iFloatingSpriteControlGroup;
 				}
 			if (controlGroup)
 				{
 				CHuiControl& control = controlGroup->Control(0);
 		default:
 			{
 			__ALFLOGSTRING("CAlfBridge::HandleNewWindowL: Unknown window node type received !");
 			}
 		}
-	iAlfScreens[screenNumber]->SetVisualTreeVisibilityChanged(ETrue);
+	iAlfScreens[0]->SetVisualTreeVisibilityChanged(ETrue);
+#ifdef ALF_MEMORYLOGGING
+ReportMemory();
+#endif
 	}
 // ---------------------------------------------------------------------------
 // HandleDestroyWindow
 // ---------------------------------------------------------------------------
 	{
 	TInt windowGroupNodeId = aData.iInt1;
 	TInt windowNodeId = aData.iInt2;
 	TAlfWindowAttributes* windowAttributes = (TAlfWindowAttributes*) (*iHost)->GetVarDataL( (TInt)aData.iPtr );
-	TInt screenNumber = windowAttributes->iScreenNumber;
 	switch (windowAttributes->iWindowNodeType)
 		{
 		case EAlfWinTreeNodeGroup:
 			{
 			HandleVisualVisibility(0);
-			DeleteControlGroupL(windowGroupNodeId, screenNumber);
+			DeleteControlGroupL(windowGroupNodeId);
 			break;
 			}
 		case EAlfWinTreeNodeClient:
 		case EAlfWinTreeNodeRoot:
 		case EAlfWinTreeNodeAnim:
 			//just remove the visual
 			CHuiCanvasVisual* viz;
 			viz = (CHuiCanvasVisual*)FindVisual(windowNodeId);
-			CHuiControlGroup* controlGroup = FindControlGroup( windowGroupNodeId, screenNumber );
+			CHuiControlGroup* controlGroup = FindControlGroup( windowGroupNodeId);
 		     // Sprite is in its own group, and can be deleted normally.
 			if ( !controlGroup  && windowAttributes->iWindowNodeType != EAlfWinTreeNodeSprite )
 			    {
 			    __ALFLOGSTRING("CAlfBridge::HandleDestroyWindowL: group containing this visual has been destroyed.");
 			    // the group containing this visual has been destroyed.
 			break;
 			}
 		}
 	// TODO: Toolkit does not support recycling (of visuals),
 	// this is not in line with Nokia environmental policy...
-	iAlfScreens[screenNumber]->SetVisualTreeVisibilityChanged(ETrue);
+	iAlfScreens[0]->SetVisualTreeVisibilityChanged(ETrue);
 	}
 // ---------------------------------------------------------------------------
 // HandleSetWindowPosL
 // ---------------------------------------------------------------------------
 //
 void CAlfBridge::HandleSetWindowPosL( TAlfBridgerData& aData )
 	{
 	TInt windowNodeId = aData.iInt2;
 	TAlfWindowAttributes* windowAttributes = (TAlfWindowAttributes*) (*iHost)->GetVarDataL( (TInt)aData.iPtr );
-	TInt screenNumber = windowAttributes->iScreenNumber;
 	// fetch visual
 	CHuiVisual* viz = FindVisual(windowNodeId);
 	if (viz)
 		{
 #ifdef HUI_DEBUG_TRACK_DRAWING
 		    {
 		    RDebug::Print(_L("CAlfBridge::HandleSetWindowPosL - Tracked visual"));
 		    }
 #endif
-		viz->SetPos(windowAttributes->iPosition, windowAttributes->iTransitionTime);
+viz->SetPos(windowAttributes->iPosition, windowAttributes->iTransitionTime);
-		  iAlfScreens[screenNumber]->SetVisualTreeVisibilityChanged(ETrue); // TODO: Check if really changed
+iAlfScreens[0]->SetVisualTreeVisibilityChanged(ETrue); // TODO: Check if really changed
 		}
 	else
 		{
 		__ALFLOGSTRING("CAlfBridge::HandleSetWindowPosL, EAlfDSSetWindowPos: Visual not found!");
 		}
 //
 void CAlfBridge::HandleSetWindowSizeL( TAlfBridgerData& aData )
 	{
 	TInt windowNodeId = aData.iInt2;
 	TAlfWindowAttributes* windowAttributes = (TAlfWindowAttributes*) (*iHost)->GetVarDataL( (TInt)aData.iPtr );
-	TInt screenNumber = windowAttributes->iScreenNumber;
 	// fetch visual
 	CHuiVisual* viz = FindVisual(windowNodeId);
 	if (viz)
 		{
 #ifdef HUI_DEBUG_TRACK_DRAWING
 		}
 	else
 		{
 		__ALFLOGSTRING("CAlfBridge::HandleSetWindowSizeL, EAlfDSSetWindowSize: Visual not found!");
 		}
-iAlfScreens[screenNumber]->SetVisualTreeVisibilityChanged(ETrue);
+iAlfScreens[0]->SetVisualTreeVisibilityChanged(ETrue);
 AMT_INC_COUNTER_IF(viz, iVisualSizeChangedCount );
 AMT_SET_VALUE_IF(viz, iLatestVisualExtentRect, TRect( windowAttributes->iPosition, windowAttributes->iSize ) );
 AMT_MAP_SET_VALUE_IF( viz, iSizeMap, windowNodeId,
 //
 void CAlfBridge::HandleSetWindowOpacityL( TAlfBridgerData& aData )
 	{
 	TInt windowNodeId = aData.iInt2;
 	TAlfWindowAttributes* windowAttributes = (TAlfWindowAttributes*) (*iHost)->GetVarDataL( (TInt)aData.iPtr );
-	TInt screenNumber = windowAttributes->iScreenNumber;
 	// fetch visual
 	CHuiVisual* viz = FindVisual(windowNodeId);
 	if (viz)
 		{
 #ifdef HUI_DEBUG_TRACK_DRAWING
 if ( viz->Tracking() )
 {
 RDebug::Print(_L("CAlfBridge::HandleSetWindowOpacityL - Tracked visual"));
 }
 #endif
-		viz->iOpacity.Set(windowAttributes->iOpacity, windowAttributes->iTransitionTime);
+viz->iOpacity.Set(windowAttributes->iOpacity, windowAttributes->iTransitionTime);
-		  iAlfScreens[screenNumber]->SetVisualTreeVisibilityChanged(ETrue);  // TODO: Check if really changed
+iAlfScreens[0]->SetVisualTreeVisibilityChanged(ETrue);  // TODO: Check if really changed
-		}
+}
 	else
 		{
 		__ALFLOGSTRING("CAlfBridge::HandleSetWindowOpacityL, EAlfDSSetWindowOpacity: Visual not found!");
 		}
 	}
 //
 void CAlfBridge::HandleSetTransparencyAlphaChannelL( TAlfBridgerData& aData )
 {
 	TInt windowNodeId = aData.iInt2;
 	TAlfWindowAttributes* windowAttributes = (TAlfWindowAttributes*) (*iHost)->GetVarDataL( (TInt)aData.iPtr );
-	TInt screenNumber = windowAttributes->iScreenNumber;
 	// fetch visual
 	CHuiVisual* viz = FindVisual(windowNodeId);
 	if (viz)
 		{
 #ifdef HUI_DEBUG_TRACK_DRAWING
 		else
 		    {
 		    viz->SetFlag( EHuiVisualFlagOpaqueHint );
 		    }
-	    iAlfScreens[screenNumber]->SetVisualTreeVisibilityChanged(ETrue);  // TODO: Check if really changed
+	    iAlfScreens[0]->SetVisualTreeVisibilityChanged(ETrue);  // TODO: Check if really changed
 		}
 	else
 		{
 		__ALFLOGSTRING("CAlfBridge::HandleSetTransparencyAlphaChannel, EAlfDSSetTransparencyAlphaChannel: Visual not found!");
 		}
 //
 void CAlfBridge::HandleIncludeToVisibilityCalculationL( TAlfBridgerData& aData )
 {
 TInt windowNodeId = aData.iInt2;
 TAlfWindowAttributes* windowAttributes = (TAlfWindowAttributes*) (*iHost)->GetVarDataL( (TInt)aData.iPtr );
-TInt screenNumber = windowAttributes->iScreenNumber;
 // fetch visual
 CHuiVisual* viz = FindVisual(windowNodeId);
 if (viz)
 {
 #ifdef HUI_DEBUG_TRACK_DRAWING
 {
 canvasVisual->ClearCanvasFlags( EHuiCanvasFlagIncludeToVisibilityCalculation );
 }
 }
-iAlfScreens[screenNumber]->SetVisualTreeVisibilityChanged(ETrue);  // TODO: Check if really changed
+iAlfScreens[0]->SetVisualTreeVisibilityChanged(ETrue);  // TODO: Check if really changed
 }
 else
 {
 __ALFLOGSTRING("CAlfBridge::HandleIncludeToVisibilityCalculationL, EAlfDSIncludeToVisibilityCalculation: Visual not found!");
 }
+}
+// ---------------------------------------------------------------------------
+// HandleSetScreenDeviceValidL
+// ---------------------------------------------------------------------------
+//
+void CAlfBridge::HandleSetScreenDeviceValidL( TAlfBridgerData& aData )
+{
+	TInt windowNodeId = aData.iInt2;
+	TAlfWindowAttributes* windowAttributes = (TAlfWindowAttributes*) (*iHost)->GetVarDataL( (TInt)aData.iPtr );
+	// fetch visual
+	CHuiCanvasVisual* viz = (CHuiCanvasVisual*)FindVisual(windowNodeId);
+	if (viz)
+		{
+#ifdef HUI_DEBUG_TRACK_DRAWING
+if ( viz->Tracking() )
+{
+RDebug::Print(_L("CAlfBridge::HandleSetScreenDeviceValidL - Tracked visual"));
+}
+#endif
+		if ( windowAttributes->iActive )
+		    {
+		    viz->ClearCanvasFlags( EHuiCanvasVisualFlagNotReady );
+		    }
+		else
+		    {
+		    viz->SetCanvasFlags( EHuiCanvasVisualFlagNotReady );
+		    }
+	    iAlfScreens[0]->SetVisualTreeVisibilityChanged(ETrue);
+		}
+	else
+		{
+		__ALFLOGSTRING("CAlfBridge::HandleSetScreenDeviceValidL, EAlfDSSetScreenDeviceValid: Visual not found!");
+		}
 }
 // ---------------------------------------------------------------------------
 // HandleSetWindowAreaL
 // ---------------------------------------------------------------------------
 void CAlfBridge::HandleSetWindowAreaL( TAlfBridgerData& aData )
 	{
 	TInt windowNodeId = aData.iInt2;
 	TAny* ptr = (TAny*)(*iHost)->GetVarDataL( (TInt)aData.iPtr );
-	TInt screenNumber = 0;
 	TPoint origin;
 	TInt count = 0;
 	RRegion region;
 	CleanupClosePushL( region );
 	    {
 	    RMemReadStream str(ptr, 4*sizeof(TInt32));
-	    screenNumber = str.ReadInt32L();
+	    str.ReadInt32L(); // screen number, obsolete
 	origin.iX = str.ReadInt32L();
 	    origin.iY = str.ReadInt32L();
 	    count = str.ReadInt32L();
 str.Release();
 }
 		CHuiCanvasVisual* canvas = static_cast<CHuiCanvasVisual*>(viz);
 		canvas->SetShape( origin, region );
-		iAlfScreens[screenNumber]->SetVisualTreeVisibilityChanged(ETrue);
+		iAlfScreens[0]->SetVisualTreeVisibilityChanged(ETrue);
 		}
 	else
 		{
 		__ALFLOGSTRING("CAlfBridge::HandleSetWindowAreaL, EAlfDSSetWindowArea: Visual not found!");
 		}
 void CAlfBridge::HandleReorderWindowL( TAlfBridgerData& aData )
 	{
 	TInt windowGroupNodeId = aData.iInt1;
 	TInt windowNodeId = aData.iInt2;
 	TAlfWindowAttributes* windowAttributes = (TAlfWindowAttributes*) (*iHost)->GetVarDataL( (TInt)aData.iPtr );
-	TInt screenNumber = windowAttributes->iScreenNumber;
 	TInt ordinalPosition = windowAttributes->iOrdinalPosition;
 	switch (windowAttributes->iWindowNodeType)
 		{
 		case EAlfWinTreeNodeGroup:
 				{
 				__ALFLOGSTRING1("CAlfBridge::HandleReorderWindowL, EAlfDSReorder: WS window group going to: %d ",windowAttributes->iOrdinalPosition);
 				}
 			#endif
-			CHuiControlGroup* controlGroup = FindControlGroup(windowGroupNodeId,screenNumber);
+TBool wasInvalidReachable = IsVisualNotReadyReachable();
+			CHuiControlGroup* controlGroup = FindControlGroup(windowGroupNodeId);
 if (!controlGroup)
 {
 User::Leave(KErrNotFound);
 }
 ResolveAfterEffectAppearingApplicationL(controlGroup); // does nothing, if effect is not active on this control group
 			// Window server nodes are in inverted Z-order, we switch it here.
-			iAlfScreens[screenNumber]->iDisplay->Roster().Hide(*controlGroup);
+			iAlfScreens[0]->iDisplay->Roster().Hide(*controlGroup);
 			TInt wsWindowGroupCount = 0;
-			for (TInt i=0; i<iAlfScreens[screenNumber]->iDisplay->Roster().Count();i++)
+			for (TInt i=0; i<iAlfScreens[0]->iDisplay->Roster().Count();i++)
 				{
-if (iAlfScreens[screenNumber]->iDisplay->Roster().ControlGroup(i).Control(0).Role()==EHuiWindowGroupContainer)
+if (iAlfScreens[0]->iDisplay->Roster().ControlGroup(i).Control(0).Role()==EHuiWindowGroupContainer)
 					{
 					wsWindowGroupCount++;
 					}
 				}
 			ordinalPosition = wsWindowGroupCount - windowAttributes->iOrdinalPosition;
 			if (ordinalPosition < -1)
 				{
 				ordinalPosition = -1; // show at top ?
 				}
-			if (iAlfScreens[screenNumber]->iDisplay && controlGroup)
+			if (iAlfScreens[0]->iDisplay && controlGroup)
 				{
-				ShowControlGroupL(iAlfScreens[screenNumber]->iDisplay->Roster(), *controlGroup, ordinalPosition, screenNumber);
+				ShowControlGroupL(iAlfScreens[0]->iDisplay->Roster(), *controlGroup, ordinalPosition);
 				}
 			else
 				{
-				__ALFLOGSTRING2("CAlfBridge::HandleReorderWindowL, EAlfDSReorder: Control group not found! Screen: %d, Id: %d ", screenNumber, windowNodeId );
+				__ALFLOGSTRING1("CAlfBridge::HandleReorderWindowL, EAlfDSReorder: Control group not found! Id: %d ", windowNodeId );
 				}
-			ReorderAlfControlGroupsL(screenNumber);
+			ReorderAlfControlGroupsL();
+// Usually, layout switch is initiated by akncapserver before window group in new orientation
+// becomes visible. However, sometimes either akncapserver isn't fast enough or then applications
+// perform operations in wrong order. To reduce flickering, uiaccelerator provides implicit blanker.
+// We will check if there is a visual that is not ready for current orientation.
+// If such visual is found before fullscreen is covered then we will enable
+// implicit blanker. That gives akncapserver some time to start layout switch.
+if (!wasInvalidReachable && IsVisualNotReadyReachable())
+{
+iLayoutSwitchEffectCoordinator->ImplicitBlank();
+}
 			break;
 			}
 		case EAlfWinTreeNodeClient:
 		case EAlfWinTreeNodeRoot:
 		case EAlfWinTreeNodeAnim:
 				pos = layoutCount - pos - 1;
 				layout->Reorder(*viz, pos);
 				}
 			else
 				{
-				__ALFLOGSTRING2("CAlfBridge::HandleReorderWindowL, EAlfDSReorder: Visual not found! Screen: %d, Id: %d ", screenNumber, windowNodeId );
+				__ALFLOGSTRING1("CAlfBridge::HandleReorderWindowL, EAlfDSReorder: Visual not found! Id: %d ", windowNodeId );
 				}
 			break;
 			}
 		default:
 			{
 			__ALFLOGSTRING("CAlfBridge::HandleReorderWindowL: Unknown window node type received !");
 			break;
 			}
 		}
-	iAlfScreens[screenNumber]->SetVisualTreeVisibilityChanged(ETrue); // TODO: Check if really changed
+	iAlfScreens[0]->SetVisualTreeVisibilityChanged(ETrue); // TODO: Check if really changed
 	AMT_MAP_BRIDGE_SET_ORDINAL_POSITION();
 	}
 // ---------------------------------------------------------------------------
 void CAlfBridge::HandlePostCanvasBufferL( TAlfBridgerData& aData )
 	{
 	TInt windowGroupNodeId = aData.iInt1;
 	TInt windowNodeId = aData.iInt2;
 	TAlfWindowCommandBufferAttributes* bufferAttributes = (TAlfWindowCommandBufferAttributes*)(*iHost)->GetVarDataL( (TInt)aData.iPtr );
-	TInt screenNumber = bufferAttributes->iScreenNumber;
 	CHuiCanvasVisual* viz = (CHuiCanvasVisual*)FindVisual(windowNodeId);
 	// For now we omit drawing commands to ALF window group because in some configurations it causes issues
 	// TODO: Possible viz->Flags() & EHuiVisualFlagDrawAf.. is not needed anymore. To be checked. Currently this enables floating sprites on the "root visual"
 	        ||  ( viz && viz->Flags() & EHuiVisualFlagDrawAfterOthers )/* THIS LINE IS HACK FOR DRAWING FLOATING SPRITES */ )
 		{
 #ifdef HUI_DEBUG_TRACK_DRAWING
 TBool tracking( EFalse );
 	CHuiControlGroup* controlGroup = FindControlGroup( windowGroupNodeId, screenNumber );
-	CAlfScreen* screen = iAlfScreens[screenNumber];
+	CAlfScreen* screen = iAlfScreens[0];
 	//TInt clientWindowGroupId = FindClientWindowGroupId( screenNumber, *controlGroup );
 	// NOTE, THE FOLLOWING WServClientFileName MAY CAUSE DEADLOCK.
 	// THIS DOES NOT HAPPEN IF HUI_DEBUG_TRACK_DRAWING IS NOT ENABLED (DEFAULT)
 	TFileName processName;/* = iCommandDebug->WServClientFileName( clientWindowGroupId, CHuiStatic::WsSession() );
 	    if (!viz->HasCommandBuffers(EFalse))
 	        {
 // For performance resons, only set visual tree changed if this
 // was the first buffer for the window.
-	        iAlfScreens[screenNumber]->SetVisualTreeVisibilityChanged(ETrue);
+	        iAlfScreens[0]->SetVisualTreeVisibilityChanged(ETrue);
 	        }
 		TPtrC8 commands((TUint8*)bufferAttributes->iBuffer, bufferAttributes->iBufferLength);
 		if ( bufferAttributes->iEmptyThisBuffer )
 			{
 				break;
 			}
 		}
 	else
 		{
-		__ALFLOGSTRING3("CAlfBridge::HandlePostCanvasBufferL, EAlfDSPostCanvasBuffer: Visual not found! Screen: %d, Id: %d, GroupId: %d ", screenNumber, windowNodeId, windowGroupNodeId );
+		__ALFLOGSTRING2("CAlfBridge::HandlePostCanvasBufferL, EAlfDSPostCanvasBuffer: Visual not found! Id: %d, GroupId: %d ",  windowNodeId, windowGroupNodeId );
 		}
+	    // Uncomment the following for tracking which application is doing drawing
+//__ALFFXLOGSTRING1("CAlfBridge::HandlePostCanvasBufferL 0x%x", viz->Owner().ControlGroup()->SecureId());
 #ifdef	USE_APPLICATION_ENDFULLSCREEN_TIMEOUT
 	    if (iFSFxData
 	            && iFSFxData->iEffectType != CFullScreenEffectState::ENotDefinedEffect
 	            && ((iFSFxData->State() == EWaitEndFullScreen && iFSFxData->iTwoPhaseEffect <= CFullScreenEffectState::ESecondPartActive)))
 	        {
 void CAlfBridge::SetWindowActiveL(CHuiVisual* aVisual, TBool aActive)
 {
 TInt effectIndex;
 if (!HasActiveEffect(aVisual, effectIndex))
 {
+__ALFFXLOGSTRING2("CAlfBridge::SetWindowActiveL 0x%x - New state: %d", aVisual, aActive);
 // Does not have effect
 if (aActive)
 {
 aVisual->ClearFlags(EHuiVisualFlagShouldBeHidden | EHuiVisualFlagShouldBeShown);
 aVisual->iOpacity.Set(KAlfVisualDefaultOpacity);
 void CAlfBridge::HandleSetWindowActiveL( TAlfBridgerData& aData )
 	{
 	TInt windowGroupNodeId = aData.iInt1;
 	TInt windowNodeId = aData.iInt2;
 	TAlfWindowAttributes* windowAttributes = (TAlfWindowAttributes*)(*iHost)->GetVarDataL( (TInt)aData.iPtr );
-	TInt screenNumber = windowAttributes->iScreenNumber;
 if (windowAttributes->iWindowNodeType == EAlfWinTreeNodeTextCursor && iCursorTimer)
 	    {
 		if (!windowAttributes->iActive)
 		    {
 	switch (windowAttributes->iWindowNodeType)
 		{
 		case EAlfWinTreeNodeGroup:
 			{
-			CHuiControlGroup* controlGroup = FindControlGroup(windowGroupNodeId,screenNumber);
+			CHuiControlGroup* controlGroup = FindControlGroup(windowGroupNodeId);
 			if (controlGroup)
 				{
 				CHuiControl& control = controlGroup->Control(0);
 				CHuiLayout* layout = (CHuiLayout*)&control.Visual(0);
 // Uses opacity for now
 			__ALFLOGSTRING("CAlfBridge::HandleSetWindowActiveL, EAlfDSSetWindowActive: Unknown iWindowNodeType!");
 			USER_INVARIANT();
 			break;
 			}
 		}
-iAlfScreens[screenNumber]->SetVisualTreeVisibilityChanged(ETrue);	// TODO: Check if really changed
+iAlfScreens[0]->SetVisualTreeVisibilityChanged(ETrue);	// TODO: Check if really changed
 AMT_INC_COUNTER( iTotalVisualFlagChangedCount );
 AMT_INC_COUNTER_IF( windowAttributes->iActive, iActiveVisualCount );
 AMT_INC_COUNTER_IF( !windowAttributes->iActive, iPassiveVisualCount );
 void CAlfBridge::HandleSetWindowFlagL( TAlfBridgerData& aData, TInt aOp )
 {
 TInt windowGroupNodeId = aData.iInt1;
 TInt windowNodeId = aData.iInt2;
 TAlfWindowAttributes* windowAttributes = (TAlfWindowAttributes*)(*iHost)->GetVarDataL( (TInt)aData.iPtr );
-TInt screenNumber = windowAttributes->iScreenNumber;
 TInt windowFlag = windowAttributes->iActive;
 THuiVisualFlags visualFlag = (THuiVisualFlags)0;
 switch(windowFlag)
 {
 case TAlfWindowData::EShouldInactivate:
 switch (windowAttributes->iWindowNodeType)
 {
 case EAlfWinTreeNodeGroup:
 {
-CHuiControlGroup* controlGroup = FindControlGroup(windowGroupNodeId,screenNumber);
+CHuiControlGroup* controlGroup = FindControlGroup(windowGroupNodeId);
 if (controlGroup)
 {
 CHuiControl& control = controlGroup->Control(0);
 CHuiLayout* layout = (CHuiLayout*)&control.Visual(0);
 // Uses opacity for now
 __ALFLOGSTRING("CAlfBridge::HandleSetWindowFlagL, HandleSetWindowFlagL: Unknown iWindowNodeType!");
 USER_INVARIANT();
 break;
 }
 }
-iAlfScreens[screenNumber]->SetVisualTreeVisibilityChanged(ETrue); // TODO: Check if really changed
+iAlfScreens[0]->SetVisualTreeVisibilityChanged(ETrue); // TODO: Check if really changed
 }
 // ---------------------------------------------------------------------------
 // InsertImageBrushL
 // ---------------------------------------------------------------------------
 void CAlfBridge::HandleSetSurfaceExtentL( TAlfBridgerData& aData )
 	{
 	TInt windowGroupNodeId = aData.iInt1;
 	TInt windowNodeId = aData.iInt2;
 	TAlfWindowAttributes* windowAttributes = (TAlfWindowAttributes*)(*iHost)->GetVarDataL( (TInt)aData.iPtr );
-	TInt screenNumber = windowAttributes->iScreenNumber;
 	// fetch visual
 	CHuiCanvasVisual* viz = FindVisual(windowNodeId);
+	CHuiControlGroup* controlgroup = FindControlGroup(windowGroupNodeId, 0);
 // We should not do this for alf window, but renderstage does not know if it is
 // handling alf window or other window, so we ignore the request here if needed.
 // TODO: When alf apps work in multiple display, check here for every displays alf groups...
-	if (viz && iAlfWindowGroupNodeId != windowGroupNodeId)
+	if (viz && iAlfWindowGroupNodeId != windowGroupNodeId && controlgroup && controlgroup->SecureId() != iAlfSecureId )
 		{
 viz->SetLayerExtent(windowAttributes->iSurfaceExtent);
 		// Set surface extend area to be cleared with fully transparent color
 		// Note: does not support extend that is bigger that the visual
 		// if surface extent is (0,0,0,0) then the background item array is reseted
 	else
 		{
 		if (iAlfWindowGroupNodeId != windowGroupNodeId)
 		    __ALFLOGSTRING("CAlfBridge::HandleSetSurfaceExtentL, EAlfDSSetSurfaceExtent: Visual not found!");
 		}
-iAlfScreens[screenNumber]->SetVisualTreeVisibilityChanged(ETrue); // TODO: Check if really changed
+iAlfScreens[0]->SetVisualTreeVisibilityChanged(ETrue); // TODO: Check if really changed
 	}
 // ---------------------------------------------------------------------------
 // HandleLayerUsesAlphaFlagChanged
 // ---------------------------------------------------------------------------
 void CAlfBridge::HandleLayerUsesAlphaFlagChanged( TAlfBridgerData& aData )
 {
 TInt windowGroupNodeId = aData.iInt1;
 TInt windowNodeId = aData.iInt2;
 TAlfWindowAttributes* windowAttributes = (TAlfWindowAttributes*)(*iHost)->GetVarDataL( (TInt)aData.iPtr );
-TInt screenNumber = windowAttributes->iScreenNumber;
 // fetch visual
 CHuiCanvasVisual* viz = (CHuiCanvasVisual*)FindVisual(windowNodeId);
 // We should not do this for alf window, but renderstage does not know if it is
 else
 {
 if (iAlfWindowGroupNodeId != windowGroupNodeId)
 __ALFLOGSTRING("CAlfBridge::HandleLayerUsesAlphaFlagChanged: Visual not found!");
 }
-iAlfScreens[screenNumber]->SetVisualTreeVisibilityChanged(ETrue); // TODO: Check if really changed
+iAlfScreens[0]->SetVisualTreeVisibilityChanged(ETrue); // TODO: Check if really changed
 }
 // ---------------------------------------------------------------------------
 // HandleGetNativeWindowDataL
 {
 // All children in the tree are not faded, do not apply effect on children.
 effectFlags |= KHuiFxEffectExcludeChildrenFlag;
 //RDebug::Print(_L("CAlfBridge::SetupFadeEffectL - no children faded by parent"));
 }
-__ALFFXLOGSTRING1("CAlfBridge::SetupFadeEffectL - insert fade 0x%x", &aVisual);
-TRAP( err, engine->LoadEffectL(*iFadeEffectFile, effect, aVisual.Effectable(), NULL, NULL, 0, effectFlags ) );
+if (iHuiEnv->MemoryLevel() <= EHuiMemoryLevelLowest)
-didFadeEffectLoad = ETrue;
+{
+__ALFFXLOGSTRING("CAlfBridge::SetupFadeEffectL - Skipping because in SW rendering mode");
+didFadeEffectLoad = EFalse;
+}
+else
+{
+__ALFFXLOGSTRING1("CAlfBridge::SetupFadeEffectL - insert fade 0x%x", &aVisual);
+TRAP( err, engine->LoadEffectL(*iFadeEffectFile, effect, aVisual.Effectable(), NULL, NULL, 0, effectFlags ) );
+didFadeEffectLoad = ETrue;
+}
 		}
 	}
 }
 else
 {
 }
 return (didFadeEffectLoad || alreadyFaded);
 }
+// ---------------------------------------------------------------------------
+//	HandleGroupChained
+//
+// 	Chain information is used for redirecting effects to correct windowgroup
+// ---------------------------------------------------------------------------
+//
+void CAlfBridge::HandleGroupChained( TAlfBridgerData& aData)
+{
+TInt parentId = aData.iInt1;
+TInt chainedId = aData.iInt2;
+TChainData data(parentId, chainedId);
+iWindowChainsArray.Insert(parentId,data);
+__ALFFXLOGSTRING3("CAlfBridge::DoDispatchL, EAlfDSGroupChained %d chained to %d (host), iWindowChainsArray.Count() = %d", chainedId, parentId, iWindowChainsArray.Count());
+#ifdef _ALF_FXLOGGING
+CHuiControlGroup* parent = FindControlGroup(parentId);
+CHuiControlGroup* chained = FindControlGroup(chainedId);
+if (parent)
+{
+RDebug::Printf("CAlfBridge::DoDispatch - parent: 0x%x", parent->SecureId());
+}
+if (chained)
+{
+RDebug::Printf("CAlfBridge::DoDispatch - chained: 0x%x", chained->SecureId());
+}
+#endif
+}
+// ---------------------------------------------------------------------------
+// HandleGroupChainBroken
+// ---------------------------------------------------------------------------
+//
+void CAlfBridge::HandleGroupChainBroken( TAlfBridgerData& aData)
+{
+TInt parentId = aData.iInt2;
+iWindowChainsArray.Remove(parentId);
+__ALFFXLOGSTRING2("CAlfBridge::DoDispatchL, EAlfDSGroupChainBroken - parent: %d, iWindowChainsArray.Count() = %d", parentId, iWindowChainsArray.Count());
+}
 // ---------------------------------------------------------------------------
 // HandleMoveWindowToNewGroupL
 // ---------------------------------------------------------------------------
 //
 void CAlfBridge::HandleMoveWindowToNewGroupL( TAlfBridgerData& aData )
 {
 TInt windowNodeId = aData.iInt1;
-TInt screenNumber = aData.iInt2;
 TInt newWindowGroupNodeId = (TInt)aData.iPtr;
 CHuiCanvasVisual* viz = (CHuiCanvasVisual*)FindVisual(windowNodeId);
 #ifdef _ALF_LOGGING
 CHuiControlGroup* oldControlGroup = viz->Owner().ControlGroup();
 TInt oldWindowGroupId = 0;
 if ( oldControlGroup  )
 {
-oldWindowGroupId = FindWindowGroupNodeId(screenNumber, *oldControlGroup );
+oldWindowGroupId = FindWindowGroupNodeId(*oldControlGroup );
 }
 __ALFLOGSTRING3("CAlfBridge::HandleMoveWindowToNewGroupL moving nodeId 0x%x from group 0x%x to 0x%x ",windowNodeId, oldWindowGroupId, newWindowGroupNodeId );
 #endif
 if (viz)
 // remove from the old control
 viz->Owner().Remove(viz);
 // #2 insert visual to the beginning of the new group
-CHuiControlGroup* newControlGroup = FindControlGroup(newWindowGroupNodeId,screenNumber);
+CHuiControlGroup* newControlGroup = FindControlGroup(newWindowGroupNodeId);
 if (newControlGroup)
 {
 CHuiControl& newControl = newControlGroup->Control(0);
 if ( isRootOfTheMovingTree )
 {
 {
 viz = (CHuiVisual*)FindVisual(windowNodeId);
 }
 else
 {
-CHuiControlGroup* cg = FindControlGroup(windowNodeId, 0); // TODO: Screen
+CHuiControlGroup* cg = FindControlGroup(windowNodeId); // TODO: Screen
 if (cg)
 {
 CHuiControl& control = cg->Control(0);
 viz = &control.Visual(0);
 }
 __ALFFXLOGSTRING("CAlfBridge::StoreLayoutIfRequiredByEffectL - Storing not required");
 return ETrue; // no storing requred, no screenshot required => success
 }
 }
-TBool CAlfBridge::HandleGfxEventL(CFullScreenEffectState& aEvent, CHuiLayout* aToLayout, CHuiLayout *aFromLayout)
+// ---------------------------------------------------------------------------
-{
+// HandleGfxRedirection
-__ALFFXLOGSTRING3("CAlfBridge::HandleGfxEventL - To SecureUid: 0x%x, From SecureUid: 0x%x, effect %S", aEvent.iToSecureId, aEvent.iFromSecureId, aEvent.iEffectName);
+//
-__ALFFXLOGSTRING4("CAlfBridge::HandleGfxEventL - To layout: 0x%x, From layout: 0x%x, Effect handle: %d, Action: %d", aToLayout, aFromLayout, aEvent.iHandle, aEvent.iAction);
+// This effect might have been request for the host application, while the intent was to show it on the application started embedded.
+// Embedded application has its _own_ windowgroup separate from the host application. Fullscreen effect are shown on a windowgroup level.
+// e.g. Messaging -> New Message (editor), or Settings -> Themes (application)
+// Wserv notifies us the window group chaining of applications. See HandleGroupChained and HandleGroupChainBroken for more details. This code
+// will redirect the requested effect on correct windowgroup.
+//
+// NOTE! If embedded application effects are implemented, this will need revision
+// ---------------------------------------------------------------------------
+void CAlfBridge::HandleGfxRedirection(CFullScreenEffectState& aEvent, CHuiLayout*& aToLayout)
+{
+__ALFFXLOGSTRING2("CAlfBridge::HandleGfxRedirection - Redirection check for SecureId 0x%x. Effect setup result: %d.", aEvent.iToSecureId, aEvent.iSetupDone);
+TInt windowGroupNodeId = FindWindowGroupNodeId(*((*aToLayout).Owner().ControlGroup()));
+CHuiControlGroup* chainedGroup = NULL;
+// check, if the effect is being asked for chained application. This propably indicates that there are two or more instances of it and
+// effect was supposed to go to the single standalone instance
+if (IsChainedGroup(windowGroupNodeId))
+{
+RPointerArray<CHuiControlGroup> groupList;
+FindControlGroupBySecureId(aEvent.iToSecureId, groupList);
+TInt i = groupList.Count();
+TInt standaloneGroups = 0;
+while(--i >= 0)
+{
+windowGroupNodeId = FindWindowGroupNodeId(*groupList[i]);
+if (!IsChainedGroup(windowGroupNodeId))
+{
+// This is an educated guess, which will make the standalone version to have effect.
+// Currently (tm) standard appstart effect is never requested for embbedded instances.
+chainedGroup = groupList[i];
+standaloneGroups++;
+__ALFFXLOGSTRING2("CAlfBridge::HandleGfxRedirection - Wg id: %d is NOT chained. Index: %d",windowGroupNodeId, i);
+}
+else
+{
+__ALFFXLOGSTRING2("CAlfBridge::HandleGfxRedirection - Wg id: %d IS chained. Index: %d", windowGroupNodeId, i);
+}
+}
+groupList.Close();
+// Skip effect redirection if the end result is uncertain. This is the case, if
+// there are multiple standalone app groups (e.g. single application having multiple groups),
+if (standaloneGroups>1)
+{
+chainedGroup = NULL;
+aEvent.iIsRedirected = ETrue;
+if (iFSFXDataPart2)
+{
+iFSFXDataPart2->iIsRedirected = ETrue;
+}
+}
+}
+else
+{
+// Which group is chained to this group?
+TUint32 chainedId = FindChainedGroup(windowGroupNodeId);
+chainedGroup = FindControlGroup(chainedId);
+}
+	// Redirection is skipped if the host layout has been already prepared (in practice added
+	// to iEffectCleanupStack) for the effect.
+if (chainedGroup && !aEvent.iSetupDone)
+{
+__ALFFXLOGSTRING2("CAlfBridge::HandleGfxRedirection - Chained app found for this application. Transferring effect from 0x%x to 0x%x.", aToLayout->Owner().ControlGroup()->SecureId(), chainedGroup->SecureId());
+aToLayout = (CHuiLayout*)&chainedGroup->Control(0).Visual(0);
+// we'll change the original effect request to point to this new group. Thus, if effect is
+// canceled, it will be removed from the right place.
+aEvent.iToSecureId = chainedGroup->SecureId(); // Update the effect
+aEvent.iToWg = FindClientWindowGroupId(*chainedGroup);
+if (iFSFXDataPart2)
+{
+iFSFXDataPart2->iToSecureId = aEvent.iToSecureId;
+iFSFXDataPart2->iToWg = aEvent.iToWg;
+}
+}
+else
+{
+__ALFFXLOGSTRING2("CAlfBridge::HandleGfxRedirection - Skip redirection for SecureId 0x%x. Chained group: 0x%x", aEvent.iToSecureId, chainedGroup);
+}
+// Redirection attemp is allowed to happen only once, because this redirects effects for
+	// _running_ embedded applications that must exist at the time of the request.
+	// We are not interested in the embedded applications effects. Start effects for embedded applications
+	// are not currently supported.
+aEvent.iIsRedirected = ETrue;
+if (iFSFXDataPart2)
+{
+iFSFXDataPart2->iIsRedirected = ETrue;
+}
+}
+// ---------------------------------------------------------------------------
+// HandleGfxEventL
+//
+// ---------------------------------------------------------------------------
+//
+TBool CAlfBridge::HandleGfxEventL(CFullScreenEffectState& aEvent, CHuiLayout* aToLayout, CHuiLayout* /*aFromLayout */)
+{
+__ALFFXLOGSTRING4("CAlfBridge::HandleGfxEventL - Operation: %d, To SecureUid: 0x%x, From SecureUid: 0x%x, effect %S", aEvent.iOperation, aEvent.iToSecureId, aEvent.iFromSecureId, aEvent.iEffectName);
+__ALFFXLOGSTRING3("CAlfBridge::HandleGfxEventL - To layout: 0x%x Effect handle: %d, Action: %d", aToLayout, aEvent.iHandle, aEvent.iAction);
+if (!aEvent.iIsRedirected)
+{
+HandleGfxRedirection(aEvent, aToLayout);
+}
 TInt err = KErrNone;
 TBool failed = EFalse;
 // Check if there is an effects engine in HuiEnv
 CHuiFxEffect* effect = NULL;
 case AknTransEffect::EApplicationStartRect:
 case AknTransEffect::EApplicationStartSwitch:
 case AknTransEffect::EApplicationStartSwitchRect:
 case KAlfFSTaskSwapperAppStart:
 {
-aToLayout->iOpacity.Set(0.0f);    // these are meant for applications that are not yet ready to be drawn, but possible already on the foreground
-FreezeLayoutUntilEffectDestroyedL(aFromLayout, aEvent.iHandle);
 aEvent.iEffectType = CFullScreenEffectState::EStartEffect;
 if (iFSFXDataPart2)
 {
 iFSFXDataPart2->iEffectType = CFullScreenEffectState::EStartEffect;
 }
 aToLayout->iOpacity.Set(1.0f);
 }
 if (aToLayout)
 {
-// if this was timeout appstart effect, we need to take screenshot at this point.
+// 1. If this is timeout, then we should be update the
-// It was not taken in the beginfullscreen
+						//    screenshot for the long app start effect usage.
+// 2. For the second part of the effect, screenshot must be
-if (aEvent.iLongAppStartTimeout)
+						//    update. Thus the transition may continue smoothly, where app_start_long.fxml finished.
+						// 3. Sometimes BeginFullScreen has not run for the effect. For instance
+						//    when window group is created after EndFullScreen was received.
+TBool requiresScreenshot = NeedsStoredBuffers(iHuiEnv->EffectsEngine(), *aEvent.iEffectName);
+TBool hasScreenshot = TBool(aToLayout->StoredRenderBuffer());
+if ((aEvent.iLongAppStartTimeout && !hasScreenshot)  // (1)
+|| aEvent.iTwoPhaseEffect == CFullScreenEffectState::ESecondPartActive // (2)
+								|| (requiresScreenshot && !hasScreenshot) // (3)
+)
 {
 __ALFFXLOGSTRING1("CAlfBridge::HandleGfxEventL  - taking screenshot for the timeout appstart effect. Handle: %d",  aEvent.iHandle );
 aToLayout->SetStoredRenderBufferModificationsEnabled(ETrue);
 TBool neededStoredBuffers(EFalse); // dummy
 StoreLayoutIfRequiredByEffectL(aToLayout, aEvent, neededStoredBuffers);
 // Only changing the effect is required.
 layoutEffectable = ETrue;
 }
 else
 {
+								// SetupEffectLayoutContainerL always returns ETrue. Code cleanup needed.
 layoutEffectable = SetupEffectLayoutContainerL(aEvent.iHandle,aToLayout, ETrue, EFalse, aEvent.iCanDestroyOrHideImmediately);
 }
-aEvent.iSetupDone = layoutEffectable;
+aEvent.iSetupDone = ETrue;
+if (iFSFXDataPart2)
+{
+iFSFXDataPart2->iSetupDone = aEvent.iSetupDone;
+}
 aToLayout->SetStoredRenderBufferModificationsEnabled(ETrue);
 }
-if (layoutEffectable)
+if (layoutEffectable) // Note, this is always ETrue
 {
 TInt effectFlags = 0;
 TInt activeEffectGroup = engine->ActiveGroupEffect();
 if (activeEffectGroup != KErrNotFound)
 {
 engine->AddEffectToGroup(activeEffectGroup);
 }
 __ALFFXLOGSTRING1("CAlfBridge::HandleGfxEventL - Active effect group: %d", activeEffectGroup);
 effectFlags = KHuiFxDelayRunUntilFirstFrameHasBeenDrawn;
-if (FxmlHasOpaqueHint(iHuiEnv->EffectsEngine(), *aEvent.iEffectName) ||
+if (FxmlHasOpaqueHint(iHuiEnv->EffectsEngine(), *aEvent.iEffectName))
-aEvent.iTwoPhaseEffect == CFullScreenEffectState::ESecondPartActive)
 {
 effectFlags |= KHuiFxOpaqueHint;
 }
 if (iFSFXDataPart2)
 {
 		__ALFFXLOGSTRING3("CAlfBridge::FreezeLayoutUntilEffectDestroyed - Storing SecureId x%x, StoreRenderBufferStartL call returned: %d for layout 0x%x", aLayout->Owner().ControlGroup()->SecureId(), err, aLayout);
 		if (err == KErrNone)
 			{
 // Freeze only, if buffer was reserved succesfully
 aLayout->SetFreezeState(ETrue);
-	TBool itemsDestroyed;
+	if (!HasActiveEffect(aLayout))
-	    AddFxItemL(aHandle, aLayout, NULL, NULL, EFalse, itemsDestroyed, ETrue, EFalse);
+	    {
+	    TBool itemsDestroyed;
+	    AddFxItemL(aHandle, aLayout, NULL, NULL, EFalse, itemsDestroyed, ETrue, EFalse);
+	    }
 	        iFSFxData->iAppStartScreenshotItemHandle = aHandle;
 			}
 }
 }
 TInt operation = stream.ReadInt32L();
 // If we are in low memory state, we don't want to do any effects
 if(iHuiEnv->MemoryLevel() < EHuiMemoryLevelReduced)
 {
-__ALFFXLOGSTRING("CAlfBridge::HandleGfxEffectsL - Returning because memory level below NORMAL");
+__ALFFXLOGSTRING("CAlfBridge::HandleGfxEffectsL - WARNING! - Returning because memory level below NORMAL - EFFECT IS NOT SHOWN!");
 		stream.Release();
 return;
 }
 if ( operation == MAlfGfxEffectPlugin::EBeginFullscreen )
 if (fxData &&
 toGroup
 && fxData->iOperation == MAlfGfxEffectPlugin::EBeginFullscreen
 && fxData->iEffectType == CFullScreenEffectState::EStartEffect)
 {
+__ALFFXLOGSTRING("CAlfBridge::HandleGfxEffectsL - Try triggering effect immediately");
 GfxTriggerEffectWhenFullScreenDrawn(toGroup);
 }
 }
 for (TInt i = 0; i < iAlfScreens.Count(); i++)
 TBool fullscreenCovered(EFalse);
 TInt dummy = 0;
 CHuiControl& control = aToGroup->Control(0);
 CHuiLayout* toLayout = control.VisualCount() > 0 ? (CHuiLayout*)&control.Visual(0) : NULL;
-if (!toLayout)
+if (!toLayout || (toLayout->Flags() & EHuiVisualFlagInactive ))
 {
 // no point starting effect, if the layout is still inactive.
+		__ALFFXLOGSTRING1("CAlfBridge::GfxTriggerEffectWhenFullScreenDrawn - Do not trigger. Layout 0x%x inactive or not found.", toLayout);
 return EFalse;
 }
 TBool opaque = ETrue; // in app start case the layout is propably not opaque. Fake it.
 IsFullScreenDrawnRecursive(toLayout, *aToGroup, control, fullscreenCovered, fullscreen, screen, dummy, opaque, iAlfScreens[0]->iDisplay->Orientation());
 fullscreenCovered = IsRectCoveredByRegion(fullscreen, iTempRegion);
 // alf content check is relavant only for alf apps
 if (!fullscreenCovered && aToGroup->iAlfApp)
 {
-TInt clientGroupId = FindClientWindowGroupId(0, *aToGroup);
+TInt clientGroupId = FindClientWindowGroupId(*aToGroup);
 if (clientGroupId != KErrNotFound)
 {
 fullscreenCovered = HasActiveAlfContent(clientGroupId);
 }
 }
 }
 CControlEffectState* fxData = new (ELeave) CControlEffectState;
 CleanupStack::PushL(fxData);
 fxData->ConstructL(action, stream);
-iControlEffectData = fxData;
-CleanupStack::Pop(fxData);
 // We now have all the data sent to us.
 stream.Release();
 // We need to pass the filename from the transeffect plugin that handles the controls
 // that define which effect is used for the selected skin or the selected application
 CHuiCanvasVisual* visual = FindVisualByClientSideIds(fxData->iClientHandle, fxData->iClientGroupHandle);
 if (visual)
 {
-HandleGfxControlEventL(*iControlEffectData, visual);
+HandleGfxControlEventL(*fxData, visual);
+CleanupStack::PopAndDestroy(fxData);
 }
 else
 {
+iControlEffectData = fxData; // move ownership
+// Control was not found. Apply effect later when control appears in HandleNewWindow
 __ALFFXLOGSTRING2("CAlfBridge::HandleGfxControlEffectsL - Control not found. iClientHandle %d, iClientGroupHandle %d",
 iControlEffectData->iClientHandle,
 iControlEffectData->iClientGroupHandle);
+CleanupStack::Pop(fxData);
 return;
 }
 iAlfScreens[0]->iDisplay->SetDirty();
 iHuiEnv->ContinueRefresh();
-delete iControlEffectData;
-iControlEffectData = NULL;
 __ALFFXLOGSTRING("HandleGfxControlEffectsL - end");
 }
 void CAlfBridge::HandleGfxControlEventL(CControlEffectState& aEvent,
 sourceViz->Layout()->Remove(sourceViz);
 }
 sourceViz->Owner().Remove(sourceViz);
 delete sourceViz;
-__ALFFXLOGSTRING1("CAlfBridge::RemoveTemporaryPresenterItem - Destroying sourceViz: 0x%x", sourceViz);
+__ALFFXLOGSTRING1("CAlfBridge::CleanFxItem - Destroying sourceViz: 0x%x", sourceViz);
 aEffectItem.iEffectedVisual = NULL;
 }
 else
 {
 DestroyWindow(sourceViz, ETrue);
 // CleanFxVisual removes the temporary presenter visual, and unbinds it from the source.
 TBool CAlfBridge::CleanFxVisual(CHuiVisual* aVisual,
 TInt aHandle)
 {
-__ALFFXLOGSTRING2("CAlfBridge::RemoveTemporaryPresenterVisual - cleaning handle: %d, 0x%x", aHandle, aVisual);
+__ALFFXLOGSTRING2("CAlfBridge::CleanFxVisual - cleaning handle: %d, 0x%x", aHandle, aVisual);
 TInt visualsRemoved = 0;
 for (TInt i = 0; i < iEffectCleanupStack.Count(); i++)
 {
 TEffectCleanupStruct& effectItem = iEffectCleanupStack[i];
 if (aVisual == effectItem.iEffectedVisual ||
 if (!iSwRenderingEnabled && iManualRefreshTimer)
 {
 iManualRefreshTimer->Cancel();
 }
+if (!aEnable)
+{
+ClearRasterizerCache();
+}
+#ifdef ALF_MEMORYLOGGING
+ReportMemory();
+#endif
 }
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 //
 if ( visualIsActive )
 {
 TRect displayRect = visualDisplayRect;
 visualDisplayRect = canvasVisual->CommandBufferCoverage(aOrientation);
+if (aDuration <= KAlfCheckVisualIsNotReady && !visualRectIsCovered && visualIsVisible &&
+!displayRect.IsEmpty() && (canvasVisual->CanvasFlags() & EHuiCanvasVisualFlagNotReady))
+{
+__ALFLOGSTRING("CAlfBridge::IsLayoutSwitchReady not ready - invalid screen device reachable");
+visualTreeReady = EFalse;
+break;
+}
 // Heuristic: Check that visual drawing isn't completely empty.
 if ( aDuration <= KAlfCheckVisualDrawingNotEmpty && !visualRectIsCovered &&
 visualIsVisible && visualDisplayRect.IsEmpty() )
 {
 __ALFLOGSTRING("CAlfBridge::IsLayoutSwitchReady not ready - no drawing");
 } // for loop end : children checking loop
 return visualTreeReady;
 }
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+//
+TBool CAlfBridge::IsVisualNotReadyReachable()
+{
+TBool invalidReachable = ETrue;
+if (!iAlfScreens.Count())
+{
+return EFalse;
+}
+iTempRegion.Clear();
+iTempRegion2.Clear();
+CAlfScreen* screen = iAlfScreens[0];
+TRect fullscreen = TRect(TPoint(0,0), screen->Size());
+TInt orientation = screen->iDisplay->Orientation();
+TBool fullscreenCovered = EFalse;
+	TBool alfClientWindowGroupVisible = EFalse;
+// Skip the topmost (effect) layer, start from floating sprite group
+for (TInt j=screen->iDisplay->Roster().Count() - screen->FixedControlGroupCount(); j>=0; j--)
+{
+CHuiControlGroup& controlgroup = screen->iDisplay->Roster().ControlGroup(j);
+CHuiControl& control = controlgroup.Control(0);
+if (control.Role() == EHuiFpsIndicatorContainer)
+{
+// FPS container doesn't contain canvas visuals
+continue;
+}
+CHuiCanvasVisual* layout = (CHuiCanvasVisual*)&control.Visual(0);
+// For optimization reasons, check if all visuals below in Z-order are covered
+if (!fullscreenCovered)
+{
+fullscreenCovered = IsRectCoveredByRegion(fullscreen, iTempRegion);
+}
+if (fullscreenCovered)
+{
+break;
+}
+// ALF applications are handled by checking if their visuals cover the whole screen.
+if (control.Role() == EHuiSessionContainer)
+{
+CHuiLayout* hostContainer = control.ContainerLayout( NULL );
+TInt flags = hostContainer->Flags();
+if (alfClientWindowGroupVisible)
+{
+// check visual sizes if client has not made this control group hidden
+if(!(flags&EHuiVisualFlagUnderOpaqueHint))
+{
+if(iAppUi)
+{
+CAlfAppSrvSessionBase* alfSrvSession = iAppUi->SrvSessionForControlGroup(controlgroup);
+TInt clientWindowGroupId = alfSrvSession->ClientWindowGroup();
+// checking the case if there are multiple alf application openend.
+if (clientWindowGroupId == iAppUi->GetLastActiveClient())
+{
+return EFalse;
+}
+}
+}
+}
+continue;
+}
+TBool hasActiveVisualsInVisualTree(EFalse);
+if (alfClientWindowGroupVisible && (controlgroup.ResourceId() == iAlfWindowGroupNodeId))
+{
+invalidReachable =
+IsVisualNotReadyReachableRecursive( layout, controlgroup, control,
+hasActiveVisualsInVisualTree, fullscreen, screen,
+IsVisualOpaque(*layout), alfClientWindowGroupVisible);
+}
+else
+{
+invalidReachable =
+IsVisualNotReadyReachableRecursive( layout, controlgroup, control,
+fullscreenCovered, fullscreen, screen,
+IsVisualOpaque(*layout), EFalse);
+}
+if (invalidReachable)
+{
+// Problem found in IsInvalidScreenDeviceVisualReachableRecursive
+break;
+}
+if ( controlgroup.iAlfApp && layout->iOpacity.Now() > 0.0f )
+{
+alfClientWindowGroupVisible = ETrue;
+}
+}
+iTempRegion2.Clear();
+return invalidReachable;
+}
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+//
+TBool CAlfBridge::IsVisualNotReadyReachableRecursive(
+CHuiLayout* aLayout,
+CHuiControlGroup& aControlGroup,
+CHuiControl& aControl,
+TBool& aFullscreenCovered,
+const TRect& aFullscreen,
+CAlfScreen* aScreen,
+TBool aChildCanBeOpaque,
+TBool aOnlyForEmbeddedAlfApp)
+{
+TBool invalidReachable = EFalse;
+TRect visualDisplayRect;
+TBool visualRectIsCovered = EFalse;
+TBool visualIsOpaque = EFalse;
+TBool visualIsActive = EFalse;
+CHuiCanvasVisual* canvasVisual = NULL;
+for (TInt i = aLayout->Count() - 1; i >= 0; i--)
+{
+visualDisplayRect = TRect(0,0,0,0);
+visualRectIsCovered = EFalse;
+visualIsOpaque = EFalse;
+visualIsActive = EFalse;
+canvasVisual = (CHuiCanvasVisual*)(&aLayout->Visual(i));
+// Distraction windows are completely ignored.
+TBool distractionWindow = (canvasVisual->CanvasFlags() & EHuiCanvasFlagDistractionWindow);
+if ( distractionWindow )
+{
+continue;
+}
+visualIsOpaque = aChildCanBeOpaque && IsVisualOpaque(*canvasVisual);
+TBool visualIsVisible = (canvasVisual->iOpacity.Now() > 0.01f);
+if (canvasVisual->Count() && visualIsVisible)
+{
+invalidReachable = IsVisualNotReadyReachableRecursive( canvasVisual, aControlGroup, aControl,
+aFullscreenCovered, aFullscreen, aScreen,
+visualIsOpaque, EFalse);
+if (invalidReachable)
+{
+break;
+}
+}
+// Calculate visual display rect
+visualDisplayRect = canvasVisual->DisplayRect();
+ClipVisualRect(visualDisplayRect, aLayout->DisplayRect());
+ClipVisualRect(visualDisplayRect, aFullscreen);
+// Check if covered.
+if (aFullscreenCovered)
+{
+visualRectIsCovered = ETrue;
+}
+else
+{
+// Check if this visual is covered by other opaque visuals which rects are in "covered" region
+// it should not check for alf event window group, when we have embedded alf application,
+// because we have assumed that alf app will have full screen covered
+if(!aOnlyForEmbeddedAlfApp)
+{
+visualRectIsCovered = IsRectCoveredByRegion(visualDisplayRect, iTempRegion);
+}
+}
+	    // Determine if visual is active from coverage point of view.
+visualIsActive = EFalse;
+if (visualRectIsCovered)
+{
+if (!(canvasVisual->Flags() & EHuiVisualFlagAlwaysDraw))
+{
+visualIsActive = EFalse;
+}
+else
+{
+visualIsActive = ETrue;
+}
+}
+else
+{
+			visualIsActive = ETrue;
+}
+// Sprites and effects as we consider them always as transparent and also
+// if controlgroup is transformed somehow
+if (aControl.Role() == EHuiFullScreenEffectContainer ||
+aControl.Role() == EHuiWindowFloatingSpriteContainer ||
+aControlGroup.IsTransformed())
+{
+visualIsOpaque = EFalse;
+}
+// Check that command buffers are ok.
+if ( visualIsActive )
+{
+if (!visualRectIsCovered && visualIsVisible && !visualDisplayRect.IsEmpty() &&
+(canvasVisual->CanvasFlags() & EHuiCanvasVisualFlagNotReady))
+{
+__ALFLOGSTRING("CAlfBridge::IsLayoutSwitchReady not ready reachable");
+invalidReachable = ETrue;
+break;
+}
+}
+if (visualIsActive && visualIsOpaque && !visualRectIsCovered)
+{
+// New visibility system takes only window shape into account.
+if ( canvasVisual->CanvasFlags() & EHuiCanvasFlagIncludeToVisibilityCalculation )
+{
+if ( !canvasVisual->HasCustomShape() )
+{
+TRect displayRect(canvasVisual->DisplayRect());
+ClipVisualRect(displayRect, aLayout->DisplayRect());
+ClipVisualRect(displayRect, aFullscreen);
+iTempRegion.AddRect(displayRect);
+iTempRegion.Tidy();
+}
+else
+{
+TRect displayRect = canvasVisual->DisplayRect();
+const TRegion& region = canvasVisual->ShapeRegion();
+TPoint delta = -canvasVisual->ShapeOrigin() + displayRect.iTl;
+for (TInt i = 0; i < region.Count(); ++i)
+{
+TRect coveredRect(region[i]);
+coveredRect.Move(delta);
+ClipVisualRect(coveredRect, aFullscreen);
+iTempRegion.AddRect(coveredRect);
+}
+iTempRegion.Tidy();
+}
+}
+}
+} // for loop end : children checking loop
+return invalidReachable;
+}
 TBool CAlfBridge::IsFullScreenDrawnRecursiveAlfContent(CHuiVisual* aVisual, TRect& aFullScreen)
 {
 if(aVisual)
 {
 TInt flags = aVisual->Flags();
 }
 }
 return hasAlfContent;
 }
+void CAlfBridge::ReportMemory()
+{
+#ifdef ALF_MEMORYLOGGING
+TInt totalSpaceAllocated = 0;
+TInt cellsAllocatedInHeap = User::AllocSize(totalSpaceAllocated);
+TInt largestFreeBlock = 0;
+TInt totalFreeSpaceInHeap = User::Available(largestFreeBlock);
+TInt freeRAM = 0;
+if ( HAL::Get( HALData::EMemoryRAMFree, freeRAM ) != KErrNone )
+{
+freeRAM = -1;
+}
+TInt timestamp = User::NTickCount();
+RDebug::Printf("%x CAlfBridge::ReportMemory - Allocated space: %d, Amount of allocated cells: %d, Largest free block: %d, Free space in heap: %d",
+timestamp,
+totalSpaceAllocated,
+cellsAllocatedInHeap,
+largestFreeBlock,
+totalFreeSpaceInHeap);
+RDebug::Printf("%x CAlfBridge::ReportMemory - Free RAM in system: %d", timestamp, freeRAM);
+#endif
+}
+void CAlfBridge::ClearRasterizerCache()
+{
+CFbsRasterizer* rasterizer = CFbsBitmap::Rasterizer();
+MFbsRasterizerClearCache* cacheInterfacePtr = NULL;
+rasterizer->GetInterface(TUid::Uid(KUidFbsRasterizerClearCache), (TAny*&)cacheInterfacePtr);
+if (cacheInterfacePtr)
+{
+cacheInterfacePtr->ClearCache();
+}
+}
 // end of file

branch	RCL_3
changeset 20	31fccae4f8a7
parent 19	e5af45d51884