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

equal deleted inserted replaced

-:920e03da86f0
+:1b6909418757
 const TUid KPSSysCategory = { KUidSystemCategoryValue };
 const TUint32 KAlfPSKeyHSVisible = 0x2002EA91;
 const TInt KFadeAction = 6000;
+// IsLayoutSwitchReady heuristic constants:
+// Duration to wait that visual display rects are fully inside fullscreen rect.
+// 1 unit = 50ms.
+const TInt KAlfCheckVisualDisplayRect = 15;
+// Duration to wait that visual has drawing inside screen area.
+const TInt KAlfCheckVisualDrawRect = 15;
+// Duration to wait that visual has drawing that covers the whole display rect.
+const TInt KAlfCheckVisualDrawingComplete = 20;
+// Duration to wait that visual has some drawing (not necessarily complete).
+const TInt KAlfCheckVisualDrawingNotEmpty = 28;
+// Duration to wait that fullscreen is covered by visual drawing.
+const TInt KAlfCheckFullscreenCoveredByVisualDrawing = 50;
+// 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;
 NONSHARABLE_CLASS( TAlfBridgeDrawerWrapper ) : public MAlfDrawerScreenInterface
 {
 public:
 TAlfBridgeDrawerWrapper(CAlfBridge& aBridge);
 TInt GetSizeAndRotation(TSize& aSize, TInt& aRotation);
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 //
 CAlfBridge::~CAlfBridge()
 	{
+iTempRegion2.Close();
 iAlfNativeClientsWgIds.Close();
 	delete iOrphanStorage;
 	delete iFadeEffectFile;
 	iWindowHashArray.Close();
 	for( TInt i = 0; i< iAlfRegisteredEffects.Count(); i++ )
 	    }
 	iAlfRegisteredEffects.Close();
 delete iEffectEndTimer;
 iDeadControlGroups.Close();
 iEffectWindowGroups.Close();
-delete iFullScreenEffectData;
+delete iFSFxData;
-delete iSecondaryFullScreenEffectData;
+delete iFSFXDataPart2;
 if (iActivated)
 {
 iBridgerClient.Close();
 }
 // FindControlGroupByFullScreenToEffect
 // ---------------------------------------------------------------------------
 //
 CHuiControlGroup* CAlfBridge::FindControlGroupByFullScreenToEffect() const
 {
-if ( iFullScreenEffectData )
+if ( iFSFxData )
 {
-return FindControlGroupBySecureId( iFullScreenEffectData->iToSecureId, iFullScreenEffectData->iToWg );
+return FindControlGroupBySecureId( iFSFxData->iToSecureId, iFSFxData->iToWg );
 }
 return NULL;
 }
 // ---------------------------------------------------------------------------
 // FindControlGroupByFullScreenFromEffect
 // ---------------------------------------------------------------------------
 //
 CHuiControlGroup* CAlfBridge::FindControlGroupByFullScreenFromEffect() const
 {
-if ( iFullScreenEffectData )
+if ( iFSFxData )
 {
-return FindControlGroupBySecureId( iFullScreenEffectData->iFromSecureId, iFullScreenEffectData->iFromWg );
+return FindControlGroupBySecureId( iFSFxData->iFromSecureId, iFSFxData->iFromWg );
 }
 return NULL;
 }
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 //
 void CAlfBridge::ResolveAfterEffectAppearingApplicationL(CHuiControlGroup* aGroup)
 {
 #ifdef USE_APPLICATION_ENDFULLSCREEN_TIMEOUT
-if (iFullScreenEffectData && iFullScreenEffectData->iEffectType == CFullScreenEffectState::EExitEffect)
+if (iFSFxData && iFSFxData->iEffectType == CFullScreenEffectState::EExitEffect)
 {
 CHuiControlGroup *exitingGroupInEffect = FindControlGroupByFullScreenToEffect();
 if (exitingGroupInEffect == aGroup)
 {
 CHuiRoster& roster = iAlfScreens[0]->iDisplay->Roster();
 {
 for(TInt j = 0 ; j < iAlfScreens[0]->iControlGroups.Count() - 1 ; j++)
 {
 if (iAlfScreens[0]->iControlGroups[j].iControlGroup == nextToBecomeVisible)
 {
-iFullScreenEffectData->iFromSecureId = iAlfScreens[0]->iControlGroups[j].iSecureId;
+iFSFxData->iFromSecureId = iAlfScreens[0]->iControlGroups[j].iSecureId;
-iFullScreenEffectData->iFromWg = iAlfScreens[0]->iControlGroups[j].iClientWindowGroupId;
+iFSFxData->iFromWg = iAlfScreens[0]->iControlGroups[j].iClientWindowGroupId;
-__ALFFXLOGSTRING2("CAlfBridge::ResolveAfterEffectAppearingApplicationL - Found underneath application uid: 0x%x, window group: %d -  Start track drawing for exit effect.", iFullScreenEffectData->iFromSecureId, iFullScreenEffectData->iFromWg );
+__ALFFXLOGSTRING2("CAlfBridge::ResolveAfterEffectAppearingApplicationL - Found underneath application uid: 0x%x, window group: %d -  Start track drawing for exit effect.", iFSFxData->iFromSecureId, iFSFxData->iFromWg );
 break;
 }
 }
 }
 }
 }
 if (anyVisualHasEffect)
 {
 TInt activeEffectHandle = iEffectCleanupStack[activeEffectIndex].iHandle;
-if (iSecondaryFullScreenEffectData && iSecondaryFullScreenEffectData->iHandle == activeEffectHandle)
+if (iFSFXDataPart2 && iFSFXDataPart2->iHandle == activeEffectHandle)
 {
 __ALFFXLOGSTRING1("CAlfBridge::DeleteControlGroupL - WARNING! Control group with 2 phase effect is being destroyed. Canceling second phase for handle %d", activeEffectHandle);
-delete iSecondaryFullScreenEffectData;
+delete iFSFXDataPart2;
-iSecondaryFullScreenEffectData = NULL;
+iFSFXDataPart2 = NULL;
 }
 __ALFFXLOGSTRING1("Layout 0x%x has external content", layout);
 // EHuiVisualFlagShouldDestroy destroy flag should have come for the windows in this layout already
 layout->SetFlags(EHuiVisualFlagShouldDestroy);
 familyTree[familyIndex]->SetOwner(effectControlGroup);
 if (!HasActiveEffect(familyTree[familyIndex]))
 {
 TInt dummy;
-AddEffectItemL(activeEffectHandle, familyTree[familyIndex], NULL, NULL, EFalse, dummy, ETrue, EFalse);
+AddFxItemL(activeEffectHandle, familyTree[familyIndex], NULL, NULL, EFalse, dummy, ETrue, EFalse);
 }
 }
 }
 else
 {
 // the layout is not have effect, but some child window might.
 // in this case, the child window effects WILL BE REMOVED.
 for(TInt familyIndex = 0; familyIndex < familyTree.Count();familyIndex++)
 {
 CHuiLayout* removedVisual = familyTree[familyIndex];
-RemoveTemporaryPresenterVisual(removedVisual);
+CleanFxVisual(removedVisual);
 if ( removedVisual != layout ) // let control group delete the layout
 					         {
 					         control.Remove(removedVisual); // remove ownership from the original control (group)
 					         __ALFFXLOGSTRING1("CAlfBridge::DeleteControlGroupL - adding to orphonage 0x%x", layout);
-					         RemoveTemporaryPresenterVisual(removedVisual);
+					         CleanFxVisual(removedVisual);
 					         if ( removedVisual->Layout() == layout )
 					             {
 					             iOrphanStorage->AppendL( removedVisual );
 					             }
 					         else
 entry.iControlGroup = group;
 entry.iWindowGroupNodeId = aWindowGroupNodeId;
 entry.iClientWindowGroupId = aClientWindowGroupId;
 entry.iSecureId = aSecureId;
 // we have received start effect for this group, but the group did not exist in alf universe at the time. hide the group.
-if (iFullScreenEffectData
+if (iFSFxData
-&& (iFullScreenEffectData->State() == EWaitingWindowGroup || iFullScreenEffectData->State() == EEndFullScreenReceivedWaitingWindowGroup)
+&& (iFSFxData->State() == EWaitingWindowGroup || iFSFxData->State() == EEndFullScreenReceivedWaitingWindowGroup)
-&& iFullScreenEffectData->iToSecureId == aSecureId)
+&& iFSFxData->iToSecureId == aSecureId)
 {
-iFullScreenEffectData->iToWg = aClientWindowGroupId;
+iFSFxData->iToWg = aClientWindowGroupId;
-if (iSecondaryFullScreenEffectData)
+if (iFSFXDataPart2)
 {
-iSecondaryFullScreenEffectData->iToWg = aClientWindowGroupId;
+iFSFXDataPart2->iToWg = aClientWindowGroupId;
 }
 CHuiControlGroup* fromGroup = NULL;
 CHuiLayout* fromLayout = NULL;
 fromGroup = FindControlGroupByFullScreenFromEffect();
 if (fromGroup)
 }
 // First HandleGfxEvent, then clear iWaitingWindowGroup.
 __ALFFXLOGSTRING1("CAlfBridge::CreateControlGroupL - try triggering effect 0x%x", layout);
-TBool failed = HandleGfxEventL( *iFullScreenEffectData, layout, fromLayout );
+TBool failed = HandleGfxEventL( *iFSFxData, layout, fromLayout );
-if ( iFullScreenEffectData->State() == EWaitingWindowGroup)
+if ( iFSFxData->State() == EWaitingWindowGroup)
 {
-iFullScreenEffectData->SetState(EWaitEndFullScreen);
+iFSFxData->SetState(EWaitEndFullScreen);
 }
 else
 {
 				// was CFullScreenEffectState::EEndFullScreenReceivedWaitingWindowGroup
-iFullScreenEffectData->SetState(EEndFullscreenReceived);
+iFSFxData->SetState(EEndFullscreenReceived);
 }
 if ( failed )
 {
 // Effect failed, reset state
 __ALFFXLOGSTRING1("CAlfBridge::CreateControlGroupL - effect failed on layout 0x%x", layout);
-HandleGfxStopEvent( EFalse ); // destroys iFullScreenEffectData
+HandleGfxStopEvent( EFalse ); // destroys iFSFxData and iFSFXDataPart2
 }
 }
 entry.iScreenNumber = aScreenNumber;
 //        entry.iRole = EHuiWindowGroupContainer;
 else
 {
 TInt index = 0; // Index for Window group control groups
 TBool added = EFalse;
 for (TInt i=0; i<aRoster.Count() - screen->FixedControlGroupCount(); i++)
 {
 if (index == aWhere)
 {
 TBool lSyncAlfAppAndAlfEventGroup = EFalse;
 if ( i>0 &&  aRoster.ControlGroup(i).iAlfApp && aRoster.ControlGroup(i-1).ResourceId() == iAlfWindowGroupNodeId  && &aRoster.ControlGroup(i) != &aGroup)
 {
 // we still need to check that there are no other alf client window groups on top.
-					// if one native alf application is embedding another native alf application, WServ
+// if one native alf application is embedding another native alf application, WServ
-					// seems to update wg chains so that the following check must be done
+// seems to update wg chains so that the following check must be done
 TInt u = i+1;
 TBool clienWgFoundOntop =EFalse;
 for(;u < aRoster.Count() - screen->FixedControlGroupCount(); u++)
 {
 if(aRoster.ControlGroup(u).iAlfApp)
 {
 clienWgFoundOntop = ETrue;
 break;
 }
 }
 if(!clienWgFoundOntop)
 {
 lSyncAlfAppAndAlfEventGroup = ETrue;
 }
 }
 aRoster.ShowL(aGroup, i);
 added = ETrue;
-if (lSyncAlfAppAndAlfEventGroup && i< (aRoster.Count()-1) )
+TBool lSyncDone(EFalse);
-{
+if (lSyncAlfAppAndAlfEventGroup && i< (aRoster.Count()-1) )
-CHuiControlGroup &lGroup = aRoster.ControlGroup(i+1);
+{
-TInt clientWindowGroupId = FindClientWindowGroupId( aScreenNumber, lGroup );
+lSyncDone = ETrue;
-iAppUi->AdjustWindowGroupPositionL(clientWindowGroupId,CAlfAppServer::EBehindOfParent);
+CHuiControlGroup &lGroup = aRoster.ControlGroup(i+1);
-}
+TInt clientWindowGroupId = FindClientWindowGroupId( aScreenNumber, lGroup );
+iAppUi->AdjustWindowGroupPositionL(clientWindowGroupId,CAlfAppServer::EBehindOfParent);
-break;
+}
-}
+if(!lSyncDone && aGroup.iAlfApp && aRoster.ControlGroup(i-1).ResourceId() != iAlfWindowGroupNodeId )
+{
+CHuiControlGroup &lGroup = aRoster.ControlGroup(i);
+TInt clientWindowGroupId = FindClientWindowGroupId( aScreenNumber, lGroup );
+iAppUi->AdjustWindowGroupPositionL(clientWindowGroupId,CAlfAppServer::EBehindOfParent);
+}
+break;
+}
 if (aRoster.ControlGroup(i).Control(0).Role() == EHuiWindowGroupContainer &&
 &aRoster.ControlGroup(i) != &aGroup)
 {
 index++;
 //
 void CAlfBridge::NotifyDisplayRefreshStarted(CHuiDisplay& aDisplay)
 {
 // Look for the correct display
 TInt screenNumber = ResolveScreenNumber(aDisplay);
-RemoveTemporaryPresenterVisuals();
+CleanFxVisuals();
 if ( screenNumber != KErrNotFound )
 {
 // FPS Counter with hitchcock drawing
 #ifdef SYMBIAN_BUILD_GCE
 if(iPrintFPS)
 {
 if (!iAlfScreens.Count())
 return;
 iTempRegion.Clear();
+iTempRegion2.Clear();
 CAlfScreen* screen = iAlfScreens[aScreenNumber];
 TRect fullscreen = TRect(TPoint(0,0), screen->Size());
 TBool checkFadeEffectInScreen = EFalse;
 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());
+}
 		// 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))
 else
 {
 layout->ClearCanvasFlags(EHuiCanvasFlagExternalFadeExistsInsideVisualTree);
 }
 }
-TBool isLayoutActive = !(layout->Flags() & EHuiVisualFlagInactive);
-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());
-}
 #ifdef ALF_DEBUG_PRINT_WINDOWGROUP_ORDER
 __ALFLOGSTRING1(">>>> HandleVisualVisibility: Control group index: %d", j );
 __ALFLOGSTRING1(">>>> HandleVisualVisibility: Active visuals : %d", activevisualcount );
 __ALFLOGSTRING1(">>>> HandleVisualVisibility: Passive visuals: %d", passivevisualcount );
 #endif
 iHomeScreenPSValue = value;
 }
 }
 if ( iSwRenderingEnabled )
 {
-screen->iDisplay->SetForegroundTextureOptions( alfWindowGroupFoundVisible | alfClientWindowGroupVisible );
+screen->iDisplay->SetForegroundTextureOptions( alfWindowGroupFoundVisible || alfClientWindowGroupVisible );
 }
 // Finally, if there are fadeeffects applied to windowgroups, make sure first one does not
 // blend itself, but other windowgroups do blend. Otherwise windowgrouops above others
 // would clear the screen areas where they do not really draw.
 CHuiVisual* layout = &control.Visual(0);
 for (TInt i=layout->Count()-1; i >= 0; i--)
 {
 CHuiCanvasVisual* canvasVisual = (CHuiCanvasVisual*)(&layout->Visual(i));
-if (!aInactiveOnly)
+ClearCanvasVisualCommandSetsRecursive(canvasVisual, aInactiveOnly);
-{
+}
-canvasVisual->ClearCommandSet();
+}
 }
-else if (aInactiveOnly && (canvasVisual->Flags() & EHuiVisualFlagInactive))
-{
-canvasVisual->ClearCommandSet();
+// ---------------------------------------------------------------------------
-}
+// ---------------------------------------------------------------------------
-else
+//
-{
+void CAlfBridge::ClearCanvasVisualCommandSetsRecursive(CHuiCanvasVisual* aVisual, TBool aInactiveOnly)
-// dont clear
+{
-}
+if (!aVisual)
-}
+{
+return;
+}
+if (!aInactiveOnly)
+{
+aVisual->ClearCommandSet();
+}
+else if (aInactiveOnly && (aVisual->Flags() & EHuiVisualFlagInactive))
+{
+aVisual->ClearCommandSet();
+}
+else
+{
+// dont clear
+}
+for (TInt i=aVisual->Count()-1; i >= 0; --i)
+{
+CHuiCanvasVisual* canvasVisual = (CHuiCanvasVisual*)(&aVisual->Visual(i));
+ClearCanvasVisualCommandSetsRecursive(canvasVisual, aInactiveOnly);
 }
 }
 // ---------------------------------------------------------------------------
 	                	iAppUi->AdjustWindowGroupPositionL(0,CAlfAppServer::EAlfWindowSize); // hackish, but one way to enforce alf window resizing
 	                	}
 	                __ALFLOGSTRING1("AlfScreens[0]->iDisplay->SetOrientation: %d",huiOrientation);
 	                }
+if (!iLayoutSwitchInProgress) // LayoutSwitchStart wasn't called, so inform that all is fine.
+{
+if (iActivated)
+{
+iBridgerClient.SendBlind(KAlfCompositionLayoutSwitchComplete, TIpcArgs());
+}
+}
 break;
 }
 case EAlfEffectFxBeginSyncronizedGroup:
 	   {
 	   CHuiFxEngine* engine = iHuiEnv->EffectsEngine();
 for (TInt familyIndex = 1; familyIndex < familyTree.Count();familyIndex++)
 {
 CHuiLayout* lVisual = familyTree[familyIndex];
 lVisual->Owner().Remove(lVisual);
 iOrphanStorage->AppendL( lVisual );
-RemoveTemporaryPresenterVisual(lVisual);
+CleanFxVisual(lVisual);
 __ALFLOGSTRING1("CAlfBridge::DestroyWindow - orphons: %d", iOrphanStorage->VisualCount());
 }
 familyTree.Close();
 // there might be effect on this visual. It is not guaranteen.
 if (!aUseForce)
 {
 // we can remove from iEffectCleanupStack only when this method was called from HandleDestroyWindow. Otherwise
-// messing iEffectCleanupStack is likely to cause forever loop in some RemoveTemporaryPresenterVisuals method
+// messing iEffectCleanupStack is likely to cause forever loop in some CleanFxVisuals method
 for (TInt i = 0; i < iEffectCleanupStack.Count(); i++)
 {
 TEffectCleanupStruct& effectItem = iEffectCleanupStack[i];
 if (aVisual == effectItem.iEffectedVisual)
 {
 	else
 		{
 		__ALFLOGSTRING3("CAlfBridge::HandlePostCanvasBufferL, EAlfDSPostCanvasBuffer: Visual not found! Screen: %d, Id: %d, GroupId: %d ", screenNumber, windowNodeId, windowGroupNodeId );
 		}
 #ifdef	USE_APPLICATION_ENDFULLSCREEN_TIMEOUT
-	    if (iFullScreenEffectData
+	    if (iFSFxData
-	            && !iSecondaryFullScreenEffectData
+	            && iFSFxData->iEffectType != CFullScreenEffectState::ENotDefinedEffect
-	            && iFullScreenEffectData->iEffectType != CFullScreenEffectState::ENotDefinedEffect
+	            && ((iFSFxData->State() == EWaitEndFullScreen && iFSFxData->iTwoPhaseEffect <= CFullScreenEffectState::EFirstPartRunning)))
-	            && iFullScreenEffectData->State() == EWaitEndFullScreen
-	            && iFullScreenEffectData->iTwoPhaseEffect != CFullScreenEffectState::ESecondPartActive)
 	        {
 	        CHuiControlGroup *to_group = NULL;
-if (iFullScreenEffectData->iEffectType == CFullScreenEffectState::EExitEffect)
+if (iFSFxData->iEffectType == CFullScreenEffectState::EExitEffect)
 {
 to_group = FindControlGroupByFullScreenFromEffect();
 }
 else
 {
 // HandleGfxEndFullScreenTimeout
 // ---------------------------------------------------------------------------
 //
 void CAlfBridge::GfxTriggerEndFullScreen(CFullScreenEffectState* aFullScreenEffectData)
 {
-if (iFullScreenEffectData->State() == EFinalEffectActive)
+if (iFSFxData->State() == EFinalEffectActive)
 {
 return;
 }
 CHuiControlGroup *to_group = FindControlGroupByFullScreenToEffect();
 CHuiControlGroup *from_group = FindControlGroupByFullScreenFromEffect();
 }
 aFullScreenEffectData->iOperation = MAlfGfxEffectPlugin::EEndFullscreen;
 if (to_layout)
 {
 // from layout may be undefined
-__ALFFXLOGSTRING1("CAlfBridge::HandleGfxEndFullScreenTimeout : Enough app drawing. Trigger EndFullScreen for layout 0x%x", to_layout);
+__ALFFXLOGSTRING1("CAlfBridge::GfxTriggerEndFullScreen : Enough app drawing. Trigger EndFullScreen for layout 0x%x", to_layout);
 HandleGfxEventL( *aFullScreenEffectData, to_layout, from_layout );
 aFullScreenEffectData->SetState(EFinalEffectActive);
 }
 iAlfScreens[0]->SetVisualTreeVisibilityChanged(ETrue);
 }
 else
 {
 __ALFFXLOGSTRING2("CAlfBridge::SetWindowActiveL 0x%x has active effect. New state: %d", aVisual, aActive);
 // Has effect
-		// these flags are put to action in RemoveTemporaryPresenterItem
+		// these flags are put to action in CleanFxItem
 if (aActive)
 {
 			// this prevents windows appearing before their "effected" time
 if (!iEffectCleanupStack[effectIndex].iHideWhenFinished)
 {
 }
 else
 {
 __ALFLOGSTRING("CAlfBridge::HandleMoveWindowToNewGroupL cannot find new group! orphaning the visual");
-RemoveTemporaryPresenterVisual(viz);
+CleanFxVisual(viz);
 iOrphanStorage->AppendL( viz );
 }
 }
 else
 {
 {
 TInt dummy;
 					if (!HasActiveEffect(aToLayout, dummy))
 						{
 						__ALFFXLOGSTRING2("CAlfBridge::HandleGfxEventL - Add layout 0x%x with handle %d to cleanupstack", aToLayout, aEvent.iHandle);
-	AddEffectItemL(aEvent.iHandle, aToLayout, NULL, NULL, EFalse, dummy, ETrue, EFalse);
+	AddFxItemL(aEvent.iHandle, aToLayout, NULL, NULL, EFalse, dummy, ETrue, EFalse);
 						}
 }
 				// Screenshot was requested, but it could not be taken. Lets cancel the effect.
 				if (!success)
 					{
 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 (iSecondaryFullScreenEffectData)
+if (iFSFXDataPart2)
 {
-iSecondaryFullScreenEffectData->iEffectType = CFullScreenEffectState::EStartEffect;
+iFSFXDataPart2->iEffectType = CFullScreenEffectState::EStartEffect;
 }
 aEvent.iCanDestroyOrHideImmediately = ETrue; // enable hiding of windows during application start/activate effects
 break;
 }
 // Effect end observer is given to engine in LoadEffectL
 // It will be set to effect there and called when the effect ends or is deleted
 // The layout should be visible at this time. if not, then this is assumed
 // as effect to an background application and ignored.
-if (aToLayout->Effect())
-{
+if (aToLayout->Effect()
+							&& !(aToLayout->Effect()->EffectFlags() & KHuiFadeEffectFlag ))
+							{
+							// If the exit effect took a screesnhot (above), then the layout is freezed to show the screenshot.
+							// Layout may not be unfrozen before EndFullScreen, or flicker will occur.
 // effect on a layout must be an application start effect.
 // External content visual is not used for that.
 __ALFFXLOGSTRING2("CAlfBridge::HandleGfxEventL - Found effect on layout 0x%x. Removing effect 0x%x", aToLayout, aToLayout->Effect());
 aToLayout->SetEffect(NULL);
+aToLayout->SetFreezeState(EFalse); // Only if a screenshot was taken earlier then freeze state would be ETrue
 }
 __ALFFXLOGSTRING2("CAlfBridge::HandleGfxEventL - Layout 0x%x is active:  %d", aToLayout, !TBool(aToLayout->Flags() & EHuiVisualFlagInactive) );
 if (!(aToLayout->Flags() & EHuiVisualFlagInactive))
 {
 TInt index;
 if (aToLayout->StoredRenderBuffer()
 {
 iLayoutInitializedForExitEffect = EFalse;
 aEvent.iSetupDone = EFalse;
 failed = ETrue;
 }
-if (iSecondaryFullScreenEffectData)
+if (iFSFXDataPart2)
 {
-iSecondaryFullScreenEffectData->iSetupDone = aEvent.iSetupDone;
+iFSFXDataPart2->iSetupDone = aEvent.iSetupDone;
 }
 return failed;
 }
 default:
 break;
 if (FxmlHasOpaqueHint(iHuiEnv->EffectsEngine(), *aEvent.iEffectName) ||
 aEvent.iTwoPhaseEffect == CFullScreenEffectState::ESecondPartActive)
 {
 effectFlags |= KHuiFxOpaqueHint;
 }
-if (iSecondaryFullScreenEffectData)
+if (iFSFXDataPart2)
 {
-iSecondaryFullScreenEffectData->iSetupDone = ETrue;
+iFSFXDataPart2->iSetupDone = ETrue;
 }
 if (aEvent.iRect != TRect())
 {
 TRAP( err, engine->LoadGroupEffectL( *aEvent.iEffectName, effect, aToLayout->Effectable(), activeEffectGroup, &aEvent.iRect, this, aEvent.iHandle, effectFlags ));
 {
 TRAP( err, engine->LoadGroupEffectL( *aEvent.iEffectName, effect, aToLayout->Effectable(), activeEffectGroup, NULL, this, aEvent.iHandle, effectFlags ) );
 }
 effect = NULL;
 // only use the effect if the effect file was correctly parsed
+aToLayout->SetFreezeState(EFalse);
 if (err != KErrNone)
 {
 // visuals added to "active effect visual" stack, but they wont be used, because effect loading has failed. cleanup.
-RemoveTemporaryPresenterVisual(NULL, aEvent.iHandle);
+CleanFxVisual(NULL, aEvent.iHandle);
 aToLayout->SetEffect(NULL);
 failed = ETrue;
+}
+else
+{
+switch(aEvent.iTwoPhaseEffect)
+{
+case CFullScreenEffectState::EFirstPartActive:
+aEvent.iTwoPhaseEffect = CFullScreenEffectState::EFirstPartRunning;
+break;
+case CFullScreenEffectState::ESecondPartActive:
+aEvent.iTwoPhaseEffect = CFullScreenEffectState::ESecondPartRunning;
+break;
+}
 }
 }
 else
 {
 failed = ETrue;
 		if (err == KErrNone)
 			{
 // Freeze only, if buffer was reserved succesfully
 aLayout->SetFreezeState(ETrue);
 	TBool itemsDestroyed;
-	    AddEffectItemL(aHandle, aLayout, NULL, NULL, EFalse, itemsDestroyed, ETrue, EFalse);
+	    AddFxItemL(aHandle, aLayout, NULL, NULL, EFalse, itemsDestroyed, ETrue, EFalse);
-	        iFullScreenEffectData->iAppStartScreenshotItemHandle = aHandle;
+	        iFSFxData->iAppStartScreenshotItemHandle = aHandle;
 			}
 }
 }
 void CAlfBridge::HandleGfxStopEvent( TBool aClientRequest )
 {
 __ALFFXLOGSTRING("CAlfBridge::HandleGfxStopEvent BEGIN");
-if (!iFullScreenEffectData)
+if (!iFSFxData)
 {
 __ALFFXLOGSTRING("CAlfBridge::HandleGfxStopEvent - END: none");
-RemoveAllTemporaryPresenterVisuals();
+CleanAllFxVisuals();
 delete iControlEffectData;
 iControlEffectData = NULL;
 return;
 }
-CFullScreenEffectState* fxData = iFullScreenEffectData;
+CFullScreenEffectState* fxData = iFSFxData;
-iFullScreenEffectData = NULL;
+iFSFxData = NULL;
 CleanupStack::PushL( fxData );
 __ALFFXLOGSTRING2("CAlfBridge::HandleGfxStopEvent - handle: %d, toAppUid: 0x%x", fxData->iHandle, fxData->iToAppId);
 // clean effects with this handle
-RemoveTemporaryPresenterVisual(NULL, fxData->iHandle);
+CleanFxVisual(NULL, fxData->iHandle);
 // this was abort, so we might have received earlier event hiding this window. Here we'll bring it
 // back
 if (fxData->iToAppId && fxData->iToAppId != KErrNotFound)
 {
 RemoveEffectFromApp(fxData->iToSecureId, fxData->iToWg );
 RemoveEffectFromApp(fxData->iFromSecureId, fxData->iFromWg );
 }
 // abort ALL other possible control effects
-RemoveAllTemporaryPresenterVisuals();
+CleanAllFxVisuals();
 delete iControlEffectData;
 iControlEffectData = NULL;
 iHuiEnv->ContinueRefresh();
 // Aborted errornously, signal client side
 RProperty::Set( KPSAlfDomain, KAlfTransitionStatus, fxData->iCompletionHandle );
 }
 CleanupStack::PopAndDestroy( fxData );
-delete iSecondaryFullScreenEffectData;
+delete iFSFXDataPart2;
-iSecondaryFullScreenEffectData = NULL;
+iFSFXDataPart2 = NULL;
 __ALFFXLOGSTRING("CAlfBridge::HandleGfxStopEvent - END");
 }
 void CAlfBridge::RemoveEffectFromApp(TInt aSecureId, TInt aWgId )
 {
 TInt handle = FindEffectHandle(layout);
 if (handle != KErrNotFound)
 {
 __ALFFXLOGSTRING2("CAlfBridge::HandleGfxStopEvent - layout visual: 0x%x ; handle: %d ", layout, handle);
-RemoveTemporaryPresenterVisual(NULL, handle);
+CleanFxVisual(NULL, handle);
 }
 layout->iOpacity.Set(1.0f);
 }
 }
 return;
 }
 if ( operation == MAlfGfxEffectPlugin::EBeginFullscreen )
 {
-if ( !iFullScreenEffectData || !iFullScreenEffectData->iSetupDone )
+if ( !iFSFxData || !iFSFxData->iSetupDone )
 {
 // No fullsceen effect ongoing or fullscreen effect hasn't yet been set up,
-// so we can initialize iFullScreenEffectData from stream.
+// so we can initialize iFSFxData from stream.
 __ALFFXLOGSTRING("HandleGfxEffectsL - fresh start");
 CFullScreenEffectState* fxData = new (ELeave) CFullScreenEffectState;
 CleanupStack::PushL( fxData );
 fxData->ConstructL( action, stream );
 CleanupStack::Pop( fxData );
 			// the effect handle of freezed layout (iAppStartScreenshotItemHandle) must match the actual
 			// effect handle that is run. Only then frozen application can be freed at the end of the effect
-			if (iFullScreenEffectData)
+			if (iFSFxData)
 			{
 	for (TInt i = 0; i < iEffectCleanupStack.Count(); i++)
 	{
 	 TEffectCleanupStruct& effectItem = iEffectCleanupStack[i];
-	 if (iFullScreenEffectData->iAppStartScreenshotItemHandle == effectItem.iHandle)
+	 if (iFSFxData->iAppStartScreenshotItemHandle == effectItem.iHandle)
 	     {
 	     effectItem.iHandle = fxData->iHandle;
 	     }
 	}
 			}
-if (iFullScreenEffectData && iFullScreenEffectData->iToAppId != fxData->iToAppId)
+if (iFSFxData && iFSFxData->iToAppId != fxData->iToAppId)
 {
 				__ALFFXLOGSTRING("CAlfBridge::HandleGfxEffectsL - WARNING - Another fullscreen effect to different app. Deleting the previous ongoing effect");
-RemoveEffectFromApp(iFullScreenEffectData->iToSecureId, iFullScreenEffectData->iToWg);// Fullscreen effect for another app has arrived, and the previous has not finished and abort effect was not called.
+RemoveEffectFromApp(iFSFxData->iToSecureId, iFSFxData->iToWg);// Fullscreen effect for another app has arrived, and the previous has not finished and abort effect was not called.
-RemoveEffectFromApp(iFullScreenEffectData->iFromSecureId, iFullScreenEffectData->iFromWg);
+RemoveEffectFromApp(iFSFxData->iFromSecureId, iFSFxData->iFromWg);
-__ALFFXLOGSTRING2("CAlfBridge::HandleGfxEffectsL - Effect request has changed from appUid 0x%x to 0x%x. Cancel previous effect.", iFullScreenEffectData->iToAppId, fxData->iToAppId);
+__ALFFXLOGSTRING2("CAlfBridge::HandleGfxEffectsL - Effect request has changed from appUid 0x%x to 0x%x. Cancel previous effect.", iFSFxData->iToAppId, fxData->iToAppId);
-RemoveEffectFromApp(iFullScreenEffectData->iToAppId);
+RemoveEffectFromApp(iFSFxData->iToAppId);
 // Fullscreen effect for another
 }
-delete iFullScreenEffectData;
+delete iFSFxData;
-delete iSecondaryFullScreenEffectData;
+delete iFSFXDataPart2;
-iSecondaryFullScreenEffectData = NULL;
+iFSFXDataPart2 = NULL;
-iFullScreenEffectData = fxData;
+iFSFxData = fxData;
-iFullScreenEffectData->iAppStartScreenshotItemHandle = fxData->iHandle;
+iFSFxData->iAppStartScreenshotItemHandle = fxData->iHandle;
 stream.Release();
 }
 else
 {
 // For now, we continue ongoing.
 __ALFFXLOGSTRING("HandleGfxEffectsL - END: ongoing");
 // Client expects completion to be signalled with this handle.
-iFullScreenEffectData->iCompletionHandle = stream.ReadInt32L();
+iFSFxData->iCompletionHandle = stream.ReadInt32L();
-if (iSecondaryFullScreenEffectData)
+if (iFSFXDataPart2)
 {
 // Two phase effect path has been chosen. First part is now ongoing, and second part will be
 // triggered after that. Client has now notified, that its screen is ready. We may trigger the
 // second effect as soon as the first part finishes.
 __ALFFXLOGSTRING("CAlfBridge::HandleGfxEffectsL - Trigger second part. when 1st part done.");
-iSecondaryFullScreenEffectData->iCompletionHandle = iFullScreenEffectData->iCompletionHandle;
+iFSFXDataPart2->iCompletionHandle = iFSFxData->iCompletionHandle;
 }
 stream.Release();
 return ;
 }
 else // MAlfGfxEffectPlugin::EEndFullscreen
 {
 // End fullscreen signal received. We proceed only if there is really
 // effect ongoing and "end fullscreen" hasn't already been processed.
-if ( !iFullScreenEffectData
+if ( !iFSFxData
-|| iFullScreenEffectData->State() == EFinalEffectActive
+|| iFSFxData->State() == EFinalEffectActive
-|| iFullScreenEffectData->State() == EEndFullscreenReceived)
+|| iFSFxData->State() == EEndFullscreenReceived)
 {
-if (iFullScreenEffectData)
+if (iFSFxData)
-__ALFFXLOGSTRING1("CAlfBridge::HandleGfxEffectsL - END: fx ready, state %d ", iFullScreenEffectData->State());
+__ALFFXLOGSTRING1("CAlfBridge::HandleGfxEffectsL - END: fx ready, state %d ", iFSFxData->State());
 stream.Release();
 return;
 }
 CFullScreenEffectState* fxData = new (ELeave) CFullScreenEffectState;
 CleanupStack::PushL( fxData );
 fxData->ConstructL( KErrUnknown, stream );
 TBool timeout = fxData->iTimeout;
 // could the application be ready?
-CHuiControlGroup* applicationExists = FindControlGroupByFullScreenToEffect();
+TBool applicationExists = FindControlGroupByFullScreenToEffect() != NULL ? ETrue : EFalse;
+// It may be, that application exited already and it was moved already to effect group
+if (iFSFxData->iEffectType == CFullScreenEffectState::EExitEffect && !applicationExists )
+{
+applicationExists = FindLayoutByEffectHandle(fxData->iHandle) != NULL ? ETrue : EFalse;
+}
 TBool longAppStartTimeout = fxData->iLongAppStartTimeout;
-if (iFullScreenEffectData &&
+if (iFSFxData &&
-!iSecondaryFullScreenEffectData && // second part has not been requested yet
+!iFSFXDataPart2 && // second part has not been requested yet
 longAppStartTimeout && // this is indeed timeout for app start effect
-iFullScreenEffectData->iTwoPhaseEffect == CFullScreenEffectState::EOnlyOnePart && // second part has not been activated. note, that iSecondaryFullScreenEffectData would be NULL in this case
+iFSFxData->iTwoPhaseEffect == CFullScreenEffectState::EOnlyOnePart && // second part has not been activated. note, that iFSFXDataPart2 would be NULL in this case
-(iFullScreenEffectData->State() == EWaitEndFullScreen
+(iFSFxData->State() == EWaitEndFullScreen
-|| iFullScreenEffectData->State() == EWaitingWindowGroup))
+|| iFSFxData->State() == EWaitingWindowGroup))
 {
 // Load the whole structure. If timeout was triggered then request effect name to be
 // updated.
 UpdateSecondaryEffectL(*fxData);
-iFullScreenEffectData->iLongAppStartTimeout = fxData->iLongAppStartTimeout;
+iFSFxData->iLongAppStartTimeout = fxData->iLongAppStartTimeout;
-iFullScreenEffectData->iTwoPhaseEffect = CFullScreenEffectState::EFirstPartActive;
+iFSFxData->iTwoPhaseEffect = CFullScreenEffectState::EFirstPartActive;
-iFullScreenEffectData->iOperation = MAlfGfxEffectPlugin::EEndFullscreen;
+iFSFxData->iOperation = MAlfGfxEffectPlugin::EEndFullscreen;
 }
-__ALFFXLOGSTRING4("HandleGfxEffectsL - iTwoPhaseEffect %d, Setup done: %d, Timeout: %d, long app start timeout: %d", iFullScreenEffectData->iTwoPhaseEffect,iFullScreenEffectData->iSetupDone, timeout,longAppStartTimeout);
+__ALFFXLOGSTRING4("HandleGfxEffectsL - iTwoPhaseEffect %d, Setup done: %d, Timeout: %d, long app start timeout: %d", iFSFxData->iTwoPhaseEffect,iFSFxData->iSetupDone, timeout,longAppStartTimeout);
 if (!fxData->iLongAppStartTimeout) // endfullscreen originating from the application
 {
-if (iFullScreenEffectData->State() == EWaitingWindowGroup)
+if (iFSFxData->State() == EWaitingWindowGroup)
 {
-iFullScreenEffectData->SetState(EEndFullScreenReceivedWaitingWindowGroup);
+iFSFxData->SetState(EEndFullScreenReceivedWaitingWindowGroup);
 }
 else
 {
-iFullScreenEffectData->SetState(EEndFullscreenReceived);
+iFSFxData->SetState(EEndFullscreenReceived);
 }
-if (iSecondaryFullScreenEffectData)
+if (iFSFXDataPart2)
 {
-iSecondaryFullScreenEffectData->SetState(EEndFullscreenReceived);
+iFSFXDataPart2->SetState(EEndFullscreenReceived);
 }
 }
 CleanupStack::PopAndDestroy( fxData );
 fxData = NULL;
 __ALFFXLOGSTRING4("CAlfBridge::HandleGfxEffectsL - Regular timeout: %d, Slow start timeout: %d, Effect setup: %d, State: %d",
 timeout,
 longAppStartTimeout,
-iFullScreenEffectData->iSetupDone,
+iFSFxData->iSetupDone,
-iFullScreenEffectData->State());
+iFSFxData->State());
 stream.Release();// We should respect normal timeouts.
-if (iFullScreenEffectData->iTwoPhaseEffect > CFullScreenEffectState::EOnlyOnePart
+if (iFSFxData->iTwoPhaseEffect > CFullScreenEffectState::EOnlyOnePart
-&& iFullScreenEffectData->iSetupDone && timeout && longAppStartTimeout) // timeout = endfullscreen was requested or it was normal endfullscreen timeout, longAppStartTime =
+&& iFSFxData->iSetupDone && timeout && longAppStartTimeout) // timeout = endfullscreen was requested or it was normal endfullscreen timeout, longAppStartTime =
 {
 // If this is two phased effect, it can be started only by application request of endfullscreen (!timeout)
 // or screen drawn (triggered from
 __ALFFXLOGSTRING("HandleGfxEffectsL - Two phase effect. Waiting second part to start. Skip this event.");
 return;
 }
 // If client triggered EndFullScreen has been received, and still we haven't seen sign of the application, we know
 // things have gone wrong and will not go right. Clean up the mess.
-if (iFullScreenEffectData->State() == EEndFullscreenReceived && !applicationExists && !timeout)
+if (iFSFxData->State() == EEndFullscreenReceived && !applicationExists && !timeout)
 {
 HandleGfxStopEvent(ETrue);
 return;
 }
-}
+	    // If a long two part app start effect is ongoing or about to start, we can skip directly to the
+		// second part when EndFullScreen request arrives.
-CFullScreenEffectState* fxData = iFullScreenEffectData;
+if (iFSFXDataPart2 && iFSFxData
+				&& applicationExists
+&& iFSFXDataPart2->State() == EEndFullscreenReceived
+&& iFSFxData->iHandle == iFSFXDataPart2->iHandle )
+{
+AlfGfxEffectEndCallBack(iFSFxData->iHandle);
+return;
+}
+}
+CFullScreenEffectState* fxData = iFSFxData;
 fxData->iOperation = operation;
 __ALFFXLOGSTRING3("CAlfBridge::HandleGfxEffectsL - Operation: %d, handle: %d, type: %d", operation, fxData->iHandle, fxData->iType);
 __ALFFXLOGSTRING2("CAlfBridge::HandleGfxEffectsL - towg: %d, fromwg: %d", fxData->iToWg, fxData->iFromWg);
 {
 failed = HandleGfxEventL(*fxData, toLayout, fromLayout);
 // We found layout, and this was beginfullscreen event. Wait for endfullscreen to be triggered
 if (fxData->iOperation == MAlfGfxEffectPlugin::EBeginFullscreen)
 {
-iFullScreenEffectData->SetState(EWaitEndFullScreen);
+iFSFxData->SetState(EWaitEndFullScreen);
 }
 }
 else
 {
 __ALFFXLOGSTRING("HandleGfxEffectsL - waiting window group");
 }
 if ( failed )
 {
 // Effect failed, reset state
-HandleGfxStopEvent( EFalse ); // destroys iFullScreenEffectData
+HandleGfxStopEvent( EFalse ); // destroys iFSFxData and iFSFXDataPart2
 }
 else
 {
 // it might be that the application is already having drawing for the whole screen.
 		// If so, then trigger EndFullScreen immediately.
 __ALFFXLOGSTRING1("CAlfBridge::UpdateSecondaryEffectL - appstart timeout triggered: %d", aState.iLongAppStartTimeout);
 if (aState.iLongAppStartTimeout) // only application start effects can trigger this timeout
 {
 // clone the primary startup effect for later usage
-delete iSecondaryFullScreenEffectData;
+delete iFSFXDataPart2;
-iSecondaryFullScreenEffectData = new (ELeave) CFullScreenEffectState;
+iFSFXDataPart2 = new (ELeave) CFullScreenEffectState;
-iSecondaryFullScreenEffectData->ConstructL(*iFullScreenEffectData);
+iFSFXDataPart2->ConstructL(*iFSFxData);
-iSecondaryFullScreenEffectData->iLongAppStartTimeout = EFalse;
+iFSFXDataPart2->iLongAppStartTimeout = EFalse;
-delete iFullScreenEffectData->iEffectName;
+delete iFSFxData->iEffectName;
-iFullScreenEffectData->iEffectName = NULL;
+iFSFxData->iEffectName = NULL;
-iFullScreenEffectData->iEffectName = aState.iEffectName->AllocL();
+iFSFxData->iEffectName = aState.iEffectName->AllocL();
 }
 __ALFFXLOGSTRING("CAlfBridge::UpdateSecondaryEffectL <<" );
 return EFalse;
 }
 {
 fullscreenCovered = HasActiveAlfContent(clientGroupId);
 }
 }
-__ALFFXLOGSTRING1("CAlfBridge::GfxTriggerEffectWhenFullScreenDrawn - Covered: %d", fullscreenCovered);
+__ALFFXLOGSTRING2("CAlfBridge::GfxTriggerEffectWhenFullScreenDrawn - SecureId: 0x%x, Covered: %d", aToGroup->SecureId(), fullscreenCovered);
 if (fullscreenCovered)
 {
-GfxTriggerEndFullScreen(iFullScreenEffectData);
+if (iFSFxData->iTwoPhaseEffect == CFullScreenEffectState::EFirstPartRunning)
+{
+// effect has two parts, and the first one is ongoing. We'll skip to the second part.
+delete iFSFxData;
+iFSFxData = iFSFXDataPart2;
+iFSFXDataPart2 = NULL;
+iFSFxData->iTwoPhaseEffect = CFullScreenEffectState::ESecondPartActive;
+// Client notified of the EndFullScreen during the effect. Trigger the end part immediately.
+__ALFFXLOGSTRING("CAlfBridge::AlfGfxEffectEndCallBack - End was received. Trigger second part.");
+GfxTriggerEndFullScreen(iFSFxData);
+iFSFxData->SetState(EFinalEffectActive);
+}
+else
+{
+GfxTriggerEndFullScreen(iFSFxData); // trigger effect
+}
 return ETrue;
 }
 return EFalse;
 }
 TInt toAppUi = stream.ReadInt32L();
 stream.Release();
 // operation tells if this is abort full screen or something else
 // When this function is used to abort control transitions, all data is 0s
-if ( iFullScreenEffectData )
+if ( iFSFxData )
 {
 __ALFFXLOGSTRING("CAlfBridge::HandleGfxStopEffectsL - kill fullscreen");
 HandleGfxStopEvent( ETrue );
 }
 if ( !toAppUi )
 {
 __ALFFXLOGSTRING("CAlfBridge::HandleGfxStopEffectsL - kill all");
-RemoveAllTemporaryPresenterVisuals();
+CleanAllFxVisuals();
 iHuiEnv->ContinueRefresh();
 }
 __ALFFXLOGSTRING("CAlfBridge::HandleGfxStopEffectsL - end");
 }
 iControlEffectData = NULL;
 if (handle != KErrNotFound)
 {
 __ALFFXLOGSTRING1("CAlfBridge::HandleGfxStopControlEffectsL - Remove effect with handle: %d", handle);
-RemoveTemporaryPresenterVisual(NULL, handle);
+CleanFxVisual(NULL, handle);
 iHuiEnv->ContinueRefresh();
 }
 __ALFFXLOGSTRING("CAlfBridge::HandleGfxStopControlEffectsL - end");
 }
 {
 engine->RegisterEffectL(aFilename);
 }
 }
-CHuiCanvasVisual* CAlfBridge::AddEffectItemL(
+CHuiCanvasVisual* CAlfBridge::AddFxItemL(
 TInt aEffectHandle,
 CHuiVisual* aSourceVisual,
 CHuiLayout* aTargetLayout,
 CHuiControl* aEffectControl,
 TBool aInsertTemporaryVisual,
 // removes the effect, and the visual (if EShouldDestroy flag enabled). Removes from effect
 // cleanup stack iEffectCleanupStack
 enableEffect = aSourceVisual->Flags() & EHuiVisualFlagShouldDestroy ? 0 : 1;
 __ALFFXLOGSTRING2("CAlfBridge::SetupEffectLayoutContainerL - visual 0x%x is having effect. EShouldBeDestroyed flag state %d", &aSourceVisual, enableEffect );
-RemoveTemporaryPresenterVisual(aSourceVisual);
+CleanFxVisual(aSourceVisual);
 if (!enableEffect)
 {
 aItemDestroyed++;
 }
 }
 TBool aCanDestroyOrHideImmediately)
 {
 __ALFFXLOGSTRING2("CAlfBridge::AddToEffectLayoutContainerL 0x%x is having %d children", aSourceLayout, aSourceLayout->Count());
 if (aAddLayout)
 {
-AddEffectItemL(aEffectHandle, aSourceLayout, aTargetLayout, aEffectControl, EFalse, aItemsDestroyed, aIsFullScreenEffect, aIsExitEffect, aCanDestroyOrHideImmediately);
+AddFxItemL(aEffectHandle, aSourceLayout, aTargetLayout, aEffectControl, EFalse, aItemsDestroyed, aIsFullScreenEffect, aIsExitEffect, aCanDestroyOrHideImmediately);
 }
 for (TInt i = 0; i < aSourceLayout->Count(); i++)
 {
 CHuiCanvasVisual& sourceVisual = static_cast<CHuiCanvasVisual&> (aSourceLayout->Visual(i));
 {
 CHuiLayout& layout = static_cast<CHuiLayout&> (aSourceLayout->Visual(i));
 AddToEffectLayoutContainerL(aEffectHandle, &layout, NULL, aEffectControl, aItemsDestroyed, aIsFullScreenEffect,  EFalse, aIsExitEffect, aCanDestroyOrHideImmediately );
 }
 TInt oldItemsDestroyed = aItemsDestroyed;
-AddEffectItemL(aEffectHandle, &sourceVisual, aTargetLayout, aEffectControl, EFalse, aItemsDestroyed, aIsFullScreenEffect, aIsExitEffect, aCanDestroyOrHideImmediately);
+AddFxItemL(aEffectHandle, &sourceVisual, aTargetLayout, aEffectControl, EFalse, aItemsDestroyed, aIsFullScreenEffect, aIsExitEffect, aCanDestroyOrHideImmediately);
 if (oldItemsDestroyed != aItemsDestroyed)
 {
 // Visual was destroyed. If so, then we must adjust index.
 --i;
 }
 __ALFFXLOGSTRING2("CAlfBridge::AddToEffectLayoutContainerL 0x%x end of children", aSourceLayout, aSourceLayout->Count());
 }
 TBool CAlfBridge::SetupEffectLayoutContainerL(TInt aHandle,CHuiLayout* aSourceLayout, TBool aIsFullScreenEffect, TBool aIsExitEffect, TBool aCanDestroyOrHideImmediately)
 {
-__ALFFXLOGSTRING4("CAlfBridge::SetupEffectLayoutContainerL - aHandle: %d, aSourceLayout: 0x%x, aIsExitEffect: % d, CanDestroyOrHideImmediately: %d >>",
+__ALFFXLOGSTRING4("CAlfBridge::SetupEffectLayoutContainerL - aHandle: %d, aSourceLayout: 0x%x, aIsExitEffect: %d, CanDstrOrHideImd.:%d >>",
 aHandle,
 aSourceLayout,
 aIsExitEffect,
 aCanDestroyOrHideImmediately );
 TInt itemsDestroyed(0);
 AddToEffectLayoutContainerL(aHandle, aSourceLayout, NULL, &effectControlGroup, itemsDestroyed, aIsFullScreenEffect, EFalse, aIsExitEffect, aCanDestroyOrHideImmediately);
 if (aIsExitEffect)
 {
-CHuiCanvasVisual* temporaryPresenterVisual = AddEffectItemL(aHandle, aSourceLayout, &effectControlGroupLayout, &effectControlGroup, ETrue, itemsDestroyed, aIsFullScreenEffect, aIsExitEffect, EFalse);
+CHuiCanvasVisual* temporaryPresenterVisual = AddFxItemL(aHandle, aSourceLayout, &effectControlGroupLayout, &effectControlGroup, ETrue, itemsDestroyed, aIsFullScreenEffect, aIsExitEffect, EFalse);
 aSourceLayout->SetFlag(EHuiVisualFlagDrawOnlyAsExternalContent);
 __ALFFXLOGSTRING3("CAlfBridge::SetupEffectLayoutContainerL - adding handle: %d, 0x%x (source layout)-> 0x%x (presenter layout) to iEffectCleanupStack", aHandle, aSourceLayout, temporaryPresenterVisual);
 }
 else
 {
-AddEffectItemL(aHandle, aSourceLayout, NULL, &effectControlGroup, EFalse, itemsDestroyed, aIsFullScreenEffect, EFalse, EFalse);
+AddFxItemL(aHandle, aSourceLayout, NULL, &effectControlGroup, EFalse, itemsDestroyed, aIsFullScreenEffect, EFalse, EFalse);
 __ALFFXLOGSTRING2("CAlfBridge::SetupEffectLayoutContainerL - adding handle: %d, 0x%x (source layout), NO presenter layout) to iEffectCleanupStack", aHandle, aSourceLayout);
 }
 iAlfScreens[0]->iVisualTreeVisibilityChanged = ETrue;
 iAlfScreens[0]->iDisplay->SetDirty();
 if (itemsDestroyed)
 RecursiveStoreRenderBufferL(aCanvasVisual);
 }
 // clear out old effect if this visual has one
 __ALFFXLOGSTRING2("HandleGfxControlEffectsL - loading effect %S on visual 0x%x", aEvent.iEffectName, aCanvasVisual );
-__ALFFXLOGSTRING1("HandleGfxControlEffectsL - loading control effect, handle %d", aEvent.iHandle );
+__ALFFXLOGSTRING2("HandleGfxControlEffectsL - loading control effect, handle %d, Action: %d", aEvent.iHandle, aEvent.iAction );
 if (aCanvasVisual->Effect())
 {
 __ALFFXLOGSTRING1("HandleGfxControlEffectsL - 0x%x has active effect. Requesting removal.", aCanvasVisual);
 // another effect coming to already effected visual. E.g. close options menu, while opening effect still ongoing
-RemoveTemporaryPresenterVisual(aCanvasVisual);
+CleanFxVisual(aCanvasVisual);
 }
 TBool layoutEffectable(EFalse);
 if (aEvent.iAction == KGfxControlDisappearAction)
-{ // TODO: revise
+{
-// The control stays visible because the inactive flag is not set
+if (aCanvasVisual->Flags() & EHuiVisualFlagInactive)
-// if the window is reserved.
+{
-/*if (aCanvasVisual->iOpacity.Target() == 0.0f)
+__ALFFXLOGSTRING1("HandleGfxControlEffectsL - 0x%x is inactive. Skipping effect.", aCanvasVisual);
-{
+return;
-// this visual was hidden, before the effect arrived. sounds like trouble.
+}
-// Lets make it visible again, and ask it to be hidden in the end of the effect
-// this enables at least the notes disappear effects
-aCanvasVisual->iOpacity.Set(KAlfVisualDefaultOpacity);
-// visual->SetFlag(EHuiVisualFlagShouldBeHidden);
-}*/
 layoutEffectable = SetupEffectLayoutContainerL(aEvent.iHandle, aCanvasVisual, EFalse, ETrue, EFalse);
 }
 else
 {
 layoutEffectable = SetupEffectLayoutContainerL(aEvent.iHandle, aCanvasVisual, EFalse, EFalse, EFalse);
 {
 err = KErrNotFound;
 }
 //            RDebug::Print(_L("HandleGfxControlEffectsL - loading effect returned %d"), err );
 // only use the effect if the effect file was correctly parsed
+aCanvasVisual->SetFreezeState(EFalse);
 if (err == KErrNone)
 {
 #ifdef HUI_DEBUG_TRACK_DRAWING
 visual->SetTracking(ETrue);
 #endif
 // destruction in any order
 }
 else
 {
 // visuals added to "active effect visual" stack, but they wont be used, because effect loading has failed. cleanup.
-RemoveTemporaryPresenterVisual(NULL, aEvent.iHandle);
+CleanFxVisual(NULL, aEvent.iHandle);
 }
 effect = NULL; // HuiVisual has taken ownership
 }
 }
-TBool CAlfBridge::RemoveTemporaryPresenterItem(TEffectCleanupStruct& aEffectItem)
+TBool CAlfBridge::CleanFxItem(TEffectCleanupStruct& aEffectItem)
 {
 CHuiVisual* sourceViz = aEffectItem.iEffectedVisual;
 CHuiCanvasVisual* sourceViz2 = dynamic_cast<CHuiCanvasVisual*> (aEffectItem.iEffectedVisual);
 // wserv has already hidden this window. Effect has finished, so lets do what
 // was asked. Also hide, if this is supposed to be destroyed by now.
 sourceViz2->FreeRenderBuffer();
 }
 sourceViz->ClearFlag(EHuiVisualFlagDrawOnlyAsExternalContent);
 TBool hideVisual = EFalse;
 TBool showVisual = ETrue;
+// Effect request flow:
+// 1. Effect request
+	// 2. If component is found, effect started immediately.
+	// 	   If component is not found, effect request is cached and applied when window is created.
+	//	     NOTE: Only one effect request can be cached at time. Possible TODO, if this causes
+	//       issues.
+// 3. Possible change of component visibility (hide / show)
+// 4. At the end of the effect the requested visiblity is applied to the visual (hidden / shown)
+// Exceptions 1: If it was disappear effect (aEffectItem.iHideWhenFinished is ETrue), the
+//              component is hidden. This is to guaranteen that e.g. options menu would not popup
+//              after disappear effect, if visual destruction / hiding request did not come in time.
+//
+// Exception 2: If disapper effect was requested, and component was requested to be hidden,
+//              and then component was requested to be visible DURING the effect, the
+//              component will be shown at the end of the effect. Use case: the same component shows
+//              two sequentive notes and each note dismissal has disappear effect and no appear
+	//              effect between.
 if(!aEffectItem.iIsFullScreenEffect)
 {
-hideVisual = (sourceViz->Flags() & EHuiVisualFlagShouldBeHidden) || aEffectItem.iHideWhenFinished;
+hideVisual = (sourceViz->Flags() & EHuiVisualFlagShouldBeHidden) || (aEffectItem.iHideWhenFinished && !(sourceViz->Flags() & EHuiVisualFlagShouldBeShown));
-showVisual = (sourceViz->Flags() & EHuiVisualFlagShouldBeShown) && !aEffectItem.iHideWhenFinished;
+showVisual = (sourceViz->Flags() & EHuiVisualFlagShouldBeShown) && (!aEffectItem.iHideWhenFinished || !hideVisual);
 }
 else
 {
 hideVisual = (sourceViz->Flags() & EHuiVisualFlagShouldBeHidden);
 showVisual = (sourceViz->Flags() & EHuiVisualFlagShouldBeShown);
 }
+__ALFFXLOGSTRING4("CAlfBridge::RemoveTemporaryPresenterItem - iIsFullScreenEffect: %d, iHideWhenFinished: %d, Hide: %d, Show: %d", aEffectItem.iIsFullScreenEffect, aEffectItem.iHideWhenFinished, hideVisual, showVisual);
 TBool destroyVisual = sourceViz->Flags() & EHuiVisualFlagShouldDestroy;
 TBool shouldInactivate = sourceViz->Flags() & EHuiVisualFlagShouldBeInactive;
 TBool shouldBeUnderOpaqueHint = sourceViz->Flags() & EHuiVisualFlagShouldBeUnderOpaqueHint;
 __ALFFXLOGSTRING3("CAlfBridge::RemoveTemporaryPresenterItem - cleaning handle: %d, 0x%x -> 0x%x", aEffectItem.iHandle, aEffectItem.iEffectedVisual, aEffectItem.iTemporaryPresenterVisual);
 __ALFFXLOGSTRING3("CAlfBridge::RemoveTemporaryPresenterItem - hide %d, destroy %d, should inactivate: %d", TBool(hideVisual), TBool(destroyVisual), TBool(shouldInactivate));
 }
 }
 return TBool(destroyVisual);
 }
-// RemoveTemporaryPresenterVisual removes the temporary presenter visual, and unbinds it from the source.
+// CleanFxVisual removes the temporary presenter visual, and unbinds it from the source.
-TBool CAlfBridge::RemoveTemporaryPresenterVisual(CHuiVisual* aVisual,
+TBool CAlfBridge::CleanFxVisual(CHuiVisual* aVisual,
 TInt aHandle)
 {
 __ALFFXLOGSTRING2("CAlfBridge::RemoveTemporaryPresenterVisual - 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 ||
 		    aHandle == effectItem.iHandle)
 {
-if (RemoveTemporaryPresenterItem(effectItem))
+if (CleanFxItem(effectItem))
 {
 visualsRemoved++;
 }
 // must remove from finished effects to keep it in sync
 for(TInt k = 0; k < iFinishedCleanupStackEffects.Count(); k++)
 }
 return NULL;
 }
-TBool CAlfBridge::RemoveTemporaryPresenterVisuals()
+TBool CAlfBridge::CleanFxVisuals()
 {
 if (!iFinishedCleanupStackEffects.Count())
 {
 return 0;
 }
 __ALFFXLOGSTRING2("CAlfBridge::RemoveTemporaryPresenterVisuals - looping, finished count: %d, index in active effecs: %d", iFinishedCleanupStackEffects.Count(), i );
 TEffectCleanupStruct& effectItem = iEffectCleanupStack[i];
 if (iFinishedCleanupStackEffects[0] == effectItem.iHandle)
 {
-if (RemoveTemporaryPresenterItem(effectItem))
+if (CleanFxItem(effectItem))
 {
 itemsRemoved++;
 }
 if (iEffectCleanupStack.Count() > i)
 {
 iAlfScreens[0]->iDisplay->SetDirty();
 	__ALFFXLOGSTRING1("CAlfBridge::RemoveTemporaryPresenterVisuals - END - effects in layout %d", effectControlGroupLayout->Count());
 return itemsRemoved;
 }
-void CAlfBridge::RemoveAllTemporaryPresenterVisuals()
+void CAlfBridge::CleanAllFxVisuals()
 {
 CHuiControl& effectControlGroup =  iAlfScreens[0]->iFullscreenEffectControlGroup->Control(0);
 CHuiLayout* effectControlGroupLayout = (CHuiLayout*) &effectControlGroup.Visual(0);
 __ALFFXLOGSTRING1("CAlfBridge::RemoveAllTemporaryPresenterVisuals - BEGIN - effects in layout %d", effectControlGroupLayout->Count());
 while(iEffectCleanupStack.Count())
 {
 TEffectCleanupStruct& effectItem = iEffectCleanupStack[0];
-RemoveTemporaryPresenterItem(effectItem);
+CleanFxItem(effectItem);
 iEffectCleanupStack.Remove(0);
 }
 while(iFinishedCleanupStackEffects.Count())
 {
 // around will be cleared when HandleGfxStopEffectsL is called
 // iFinishedCleanupStackEffects.Append(aHandle);
 	// check if the first part of application start effect finished
-if (iFullScreenEffectData
+if (iFSFxData
-&& iFullScreenEffectData->iHandle == aHandle
+&& iFSFxData->iHandle == aHandle
-&& iFullScreenEffectData->iLongAppStartTimeout && iSecondaryFullScreenEffectData)
+&& iFSFxData->iLongAppStartTimeout && iFSFXDataPart2)
 {
-delete iFullScreenEffectData;
+delete iFSFxData;
-iFullScreenEffectData = iSecondaryFullScreenEffectData;
+iFSFxData = iFSFXDataPart2;
-iSecondaryFullScreenEffectData = NULL;
+iFSFXDataPart2 = NULL;
-iFullScreenEffectData->iTwoPhaseEffect = CFullScreenEffectState::ESecondPartActive;
+iFSFxData->iTwoPhaseEffect = CFullScreenEffectState::ESecondPartActive;
-if (iFullScreenEffectData->State() == EEndFullscreenReceived)
+if (iFSFxData->State() == EEndFullscreenReceived)
 {
 // Client notified of the EndFullScreen during the effect. Trigger the end part immediately.
 __ALFFXLOGSTRING("CAlfBridge::AlfGfxEffectEndCallBack - End was received. Trigger second part.");
-iFullScreenEffectData->SetState(ESecondPhaseSetupActive); // effect setup will be skipped in HandleGfxEvent
+GfxTriggerEndFullScreen(iFSFxData);
-GfxTriggerEndFullScreen(iFullScreenEffectData);
+iFSFxData->SetState(EFinalEffectActive);
-iFullScreenEffectData->SetState(EFinalEffectActive);
 			// skip cleanup. It will be run, when this effect finishes
 return;
 }
 else
 {
-iFullScreenEffectData->SetState(EWaitEndFullScreen);
+iFSFxData->SetState(EWaitEndFullScreen);
 }
-iFullScreenEffectData->iEffectType = CFullScreenEffectState::EStartEffect;
+iFSFxData->iEffectType = CFullScreenEffectState::EStartEffect;
 CHuiControlGroup* toGroup = FindControlGroupByFullScreenToEffect();
 GfxTriggerEffectWhenFullScreenDrawn(toGroup);
 return;
 }
 if ( aHandle == KErrNotFound )
 {
 __ALFFXLOGSTRING("invalid handle");
 }
 // alftranstion plugin may cancel end timers connected to this effect
-TBool fsEffectDone = iFullScreenEffectData && aHandle == iFullScreenEffectData->iHandle;
+TBool fsEffectDone = iFSFxData && aHandle == iFSFxData->iHandle;
 if ( fsEffectDone )
 {
-aHandle = iFullScreenEffectData->iCompletionHandle;
+aHandle = iFSFxData->iCompletionHandle;
 }
 RProperty::Set( KPSAlfDomain, KAlfTransitionStatus, aHandle );
 // Effect finished
 if ( fsEffectDone )
 {
-delete iFullScreenEffectData;
+delete iFSFxData;
-iFullScreenEffectData = NULL;
+iFSFxData = NULL;
-delete iSecondaryFullScreenEffectData;
+delete iFSFXDataPart2;
-iSecondaryFullScreenEffectData = NULL;
+iFSFXDataPart2 = NULL;
 }
 }
 void CAlfBridge::PrintAllocMem()
 TBool CAlfBridge::IsAlfOriginatedWindow(CHuiCanvasVisual& aVisual)
 {
 return (aVisual.Owner().ControlGroup()->ResourceId() == iAlfWindowGroupNodeId);
 }
-// experimental
-TBool CAlfBridge::IsFullScreenDrawn( TInt aOrientation)
+// ---------------------------------------------------------------------------
-{
+// Checks if layout switch is ready. The aDuration parameter is the duration
+// since layout switch started. So this allows heuristics to loosen as there
+// may be applications that do not behave as expected. aDuration is meant
+// to be given in units of 50ms.
+// ---------------------------------------------------------------------------
+//
+TBool CAlfBridge::IsLayoutSwitchReady( TInt aDuration )
+{
+TBool visualTreeReady = ETrue;
 if (!iAlfScreens.Count())
 return EFalse;
-aOrientation = iAlfScreens[0]->iDisplay->Orientation();
 iTempRegion.Clear();
+iTempRegion2.Clear();
 CAlfScreen* screen = iAlfScreens[0];
 TRect fullscreen = TRect(TPoint(0,0), screen->Size());
-__ALFFXLOGSTRING3("CAlfBridge::IsFullScreenDrawn - new orientation %d, screen size: (%d,%d)", aOrientation, fullscreen.iBr.iX, fullscreen.iBr.iY );
+TInt orientation = screen->iDisplay->Orientation();
+__ALFLOGSTRING2("CAlfBridge::IsLayoutSwitchReady begin o:%d d:%d", orientation, aDuration);
 TBool fullscreenCovered = EFalse;
+	TBool alfClientWindowGroupVisible = EFalse;
-// Check if effect group has an effect with opaque hint.
-CHuiControlGroup& fxcontrolgroup = *(iAlfScreens[0]->iFullscreenEffectControlGroup);
+	TInt coverageModifiedGroupCount = 0;
-CHuiControl& fxcontrol = fxcontrolgroup.Control(0);
-CHuiCanvasVisual* fxlayout = (CHuiCanvasVisual*)&fxcontrol.Visual(0);
+// Skip the topmost (effect) layer, start from floating sprite group
-CHuiVisual* fxExternalContent = fxlayout->ExternalContent();
-if (fxlayout && IsOpaqueEffect(fxlayout->Effect()))
-{
-fullscreenCovered = ETrue;
-}
-else if (fxExternalContent && IsOpaqueEffect(fxExternalContent->Effect()))
-{
-fullscreenCovered = ETrue;
-}
-TBool alfClientWindowGroupVisible = 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--)
 {
-CHuiControlGroup& controlgroup = iAlfScreens[0]->iDisplay->Roster().ControlGroup(j);
+CHuiControlGroup& controlgroup = screen->iDisplay->Roster().ControlGroup(j);
 CHuiControl& control = controlgroup.Control(0);
-		__ALFFXLOGSTRING1("CAlfBridge::IsFullScreenDrawn : Group owner 0x%x", controlgroup.SecureId());
 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)
+}
-{
-return ETrue;
+if (fullscreenCovered)
-}
+{
-for(TInt ii=0;ii< iTempRegion.Count(); ii++)
+break;
-{
+}
-__ALFFXLOGSTRING4("CAlfBridge::IsFullScreenDrawn (%d,%d)-(%d,%d)", iTempRegion[ii].iTl.iX, iTempRegion[ii].iTl.iY , iTempRegion[ii].iBr.iX, iTempRegion[ii].iBr.iY );
-}
+// ALF applications are handled by checking if their visuals cover the whole screen.
-}
-// Dont mess with alf control group visuals, alf session handling does it for us
 if (control.Role() == EHuiSessionContainer)
 {
 CHuiLayout* hostContainer = control.ContainerLayout( NULL );
 TInt flags = hostContainer->Flags();
 if (alfClientWindowGroupVisible)
 }
 }
 continue;
 }
-__ALFLOGSTRING1("CAlfBridge::IsFullScreenDraw - fullscreen covered %d", fullscreenCovered)
+TBool hasActiveVisualsInVisualTree(EFalse);
-TBool subTreeCovered = EFalse;
+TBool coverageRegionModified(EFalse);
-TBool hasActiveVisualsInVisualTree =
-IsFullScreenDrawnRecursive( layout, controlgroup, control, fullscreenCovered, fullscreen, screen,subTreeCovered, IsVisualOpaque(*layout), aOrientation );
+if (alfClientWindowGroupVisible && (controlgroup.ResourceId() == iAlfWindowGroupNodeId))
-// If root visuals effect is marked as opaque, then add whole screen area as covered.
+{
-/*
+visualTreeReady =
-if (!fullscreenCovered)
+IsLayoutSwitchReadyRecursive( layout, controlgroup, control,
-{
+hasActiveVisualsInVisualTree, fullscreen, screen,
-fullscreenCovered = IsOpaqueEffect(layout->Effect());
+IsVisualOpaque(*layout), alfClientWindowGroupVisible,
-}
+orientation, aDuration, coverageRegionModified );
-*/
+}
+else
-if(controlgroup.iAlfApp && layout->iOpacity.Now() > 0.0f )
+{
+visualTreeReady =
+IsLayoutSwitchReadyRecursive( layout, controlgroup, control,
+fullscreenCovered, fullscreen, screen,
+IsVisualOpaque(*layout), EFalse, orientation,
+aDuration, coverageRegionModified );
+}
+if (!visualTreeReady)
+{
+// Problem found in IsLayoutSwitchReadyRecursive
+visualTreeReady = EFalse;
+break;
+}
+if (coverageRegionModified)
+{
+coverageModifiedGroupCount++;
+}
+// Heuristic: If coverage region is modified by multiple apps, then it's possible that
+// foreground application hasn't had time to update its layout. So give little time to do that.
+if (aDuration <= KAlfCheckCoverageFromMultipleGroups && coverageRegionModified > 1)
+{
+__ALFLOGSTRING("CAlfBridge::IsLayoutSwitchReady not ready - multiple groups");
+visualTreeReady = EFalse;
+break;
+}
+if( controlgroup.iAlfApp && layout->iOpacity.Now() > 0.0f )
 {
 alfClientWindowGroupVisible = ETrue;
 }
+}
-if (fullscreenCovered)
-{
+__ALFLOGSTRING2("CAlfBridge::IsLayoutSwitchReady done %d (groups %d)", visualTreeReady, coverageModifiedGroupCount);
-return ETrue;
+iTempRegion2.Clear();
-}
-}
+// Heuristic: Check that visual drawing covers the whole screen.
-return fullscreenCovered;
+if ( visualTreeReady && ( aDuration <= KAlfCheckFullscreenCoveredByVisualDrawing ) )
+{
+if ( !IsRectCoveredByRegion( fullscreen, iTempRegion ) )
+{
+__ALFLOGSTRING("CAlfBridge::IsLayoutSwitchReady not ready - screen not covered");
+visualTreeReady = EFalse;
+}
+}
+return visualTreeReady;
+}
+// ---------------------------------------------------------------------------
+// Checks if rect is inside fullscreen area.
+// ---------------------------------------------------------------------------
+//
+static TBool CheckVisualRect(const TRect aRect, const TRect& aFullScreen)
+{
+if (aRect.IsEmpty())
+{
+return EFalse;
+}
+if (!aFullScreen.Contains(aRect.iTl))
+{
+return EFalse;
+}
+TPoint br = aRect.iBr;
+br.iX--;
+br.iY--;
+if (!aFullScreen.Contains(br))
+{
+return EFalse;
+}
+return ETrue;
+}
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+//
+TBool CAlfBridge::IsLayoutSwitchReadyRecursive(
+CHuiLayout* aLayout,
+CHuiControlGroup& aControlGroup,
+CHuiControl& aControl,
+TBool& aFullscreenCovered,
+const TRect& aFullscreen,
+CAlfScreen* aScreen,
+TBool aChildCanBeOpaque,
+TBool aOnlyForEmbeddedAlfApp,
+TInt aOrientation,
+TInt aDuration,
+TBool& aCoverageRegionModified )
+{
+TBool visualTreeReady = ETrue;
+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)
+{
+TBool ready = IsLayoutSwitchReadyRecursive( canvasVisual, aControlGroup, aControl,
+aFullscreenCovered, aFullscreen, aScreen,
+visualIsOpaque, EFalse, aOrientation,
+aDuration, aCoverageRegionModified );
+if (!ready)
+{
+visualTreeReady = EFalse;
+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);
+}
+}
+// Heuristic: Check that visual display rect is ok (not empty, inside screen)
+if ( aDuration <= KAlfCheckVisualDisplayRect && !visualRectIsCovered &&
+!CheckVisualRect(visualDisplayRect, aFullscreen) )
+{
+__ALFLOGSTRING("CAlfBridge::IsLayoutSwitchReady not ready - display rect not ok");
+visualTreeReady = EFalse;
+break;
+}
+	    // 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 )
+{
+TRect displayRect = visualDisplayRect;
+visualDisplayRect = canvasVisual->CommandBufferCoverage(aOrientation);
+// Heuristic: Check that visual drawing isn't completely empty.
+if ( aDuration <= KAlfCheckVisualDrawingNotEmpty && !visualRectIsCovered &&
+visualIsVisible && visualDisplayRect.IsEmpty() )
+{
+__ALFLOGSTRING("CAlfBridge::IsLayoutSwitchReady not ready - no drawing");
+visualTreeReady = EFalse;
+break;
+}
+// Heuristic: Check that visual drawing isn't outside the screen.
+if ( aDuration <= KAlfCheckVisualDrawRect && !visualRectIsCovered &&
+visualIsVisible && !CheckVisualRect(visualDisplayRect, aFullscreen) )
+{
+__ALFLOGSTRING("CAlfBridge::IsLayoutSwitchReady not ready - bad drawing");
+visualTreeReady = EFalse;
+break;
+}
+// Heuristic: Check that visual drawing is complete.
+if ( aDuration <= KAlfCheckVisualDrawingComplete && !visualRectIsCovered &&
+visualIsVisible && displayRect != visualDisplayRect )
+{
+__ALFLOGSTRING("CAlfBridge::IsLayoutSwitchReady not ready - incomplete drawing");
+visualTreeReady = EFalse;
+break;
+}
+// Make sure we clip visual rect to visible screen area
+ClipVisualRect(visualDisplayRect, aFullscreen);
+// Heuristic: Union of opaque visual drawing regions should cover the whole screen.
+// Note - coverage is checked at the end of IsLayoutSwitchReady.
+if (visualIsOpaque && visualIsVisible && !visualRectIsCovered)
+{
+iTempRegion2.AddRect( visualDisplayRect );
+iTempRegion2.Tidy();
+}
+}
+if (visualIsActive && visualIsOpaque && !visualRectIsCovered)
+{
+// New visibility system takes only window shape into account.
+if ( canvasVisual->CanvasFlags() & EHuiCanvasFlagIncludeToVisibilityCalculation )
+{
+if ( !canvasVisual->HasCustomShape() )
+{
+aCoverageRegionModified = ETrue;
+TRect displayRect(canvasVisual->DisplayRect());
+ClipVisualRect(displayRect, aLayout->DisplayRect());
+ClipVisualRect(displayRect, aFullscreen);
+iTempRegion.AddRect(displayRect);
+iTempRegion.Tidy();
+}
+else
+{
+aCoverageRegionModified = ETrue;
+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 visualTreeReady;
 }
 TBool CAlfBridge::IsFullScreenDrawnRecursiveAlfContent(CHuiVisual* aVisual, TRect& aFullScreen)
 {
 if(aVisual)
 iLayoutSwitchInProgress = EFalse;
 if ( iHuiEnv )
 {
 iIdForLayoutSwitchFrameSync = iIdForEAlfDSSynchronizeOp - KPreventingCollisionOfIdsInSynchDrawRequests;
 iHuiEnv->Synchronize( iIdForLayoutSwitchFrameSync, this );
+AsynchRefresh(); // In SW mode, device is in manual refresh mode - enforce refresh in order to get synchronize done.
 }
 }
 TAlfBridgeDrawerWrapper::TAlfBridgeDrawerWrapper(CAlfBridge& aBridge)
 : iBridge( aBridge )

changeset 31	1b6909418757
parent 29	ac3859d43844
child 38	69409653e863