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

equal deleted inserted replaced

-:15bf7259bb7c
+:d8a3531bc6b8
 #include <akntranseffect.h>
 #include "HuiRenderPlugin.h"
 #include "huicanvasgc.h"
 #include "huicanvasrenderbuffer.h"
+#include "alfrenderstageutils.h" // for KAlfPSUidSynchronizer & KAlfPSKeySynchronizer
 #ifdef HUI_DEBUG_TRACK_DRAWING
 #include <alfcommanddebug.h>
 #endif
 #ifdef _ALF_FXLOGGING
 const TReal32 KAlfVisualDefaultOpacity = 1.0f;
 //const TReal32 KAlfVisualDefaultOpacity = 0.5f;
 _LIT8(KAlfWindowGroupContainerControlTag, "WGROUP");
-const TInt KAlfNumberOfFixedControlGroups = 2;
 // This debug option prints window group order with __ALFLOGSTRING
 //#define ALF_DEBUG_PRINT_WINDOWGROUP_ORDER
 // This debug option shows window groups in a grid
 	for( TInt i = 0; i< iAlfRegisteredEffects.Count(); i++ )
 	    {
 	    delete iAlfRegisteredEffects[i].iEffectFile;
 	    }
 	iAlfRegisteredEffects.Close();
-iFinishedEffects.Close();
 delete iEffectEndTimer;
 iDeadControlGroups.Close();
 iEffectWindowGroups.Close();
 delete iFullScreenEffectData;
 CleanupStack::Pop(screen);
 	ShowControlGroupL(screen->iDisplay->Roster(), *(screen->iFloatingSpriteControlGroup), KHuiRosterShowAtTop, screenNumber);
 	ShowControlGroupL(screen->iDisplay->Roster(), *(screen->iFullscreenEffectControlGroup), KHuiRosterShowAtTop, screenNumber);
 	screen->iFloatingSpriteControlGroup->SetAcceptInput(EFalse);
 	screen->iFullscreenEffectControlGroup->SetAcceptInput(EFalse);
+	if ( screen->iFpsControlGroup )
+	    {
+	    ShowControlGroupL(screen->iDisplay->Roster(), *(screen->iFpsControlGroup), KHuiRosterShowAtTop, screenNumber);
+	    screen->iFpsControlGroup->SetAcceptInput(EFalse);
+	    }
 }
 //------------------------------------------------------------------------------
 // Dumdidumdidum..
 //------------------------------------------------------------------------------
 	ShowControlGroupL(screen->iDisplay->Roster(), *(screen->iFloatingSpriteControlGroup), KHuiRosterShowAtTop, screenNumber);
 	ShowControlGroupL(screen->iDisplay->Roster(), *(screen->iFullscreenEffectControlGroup), KHuiRosterShowAtTop, screenNumber);
 screen->iFloatingSpriteControlGroup->SetAcceptInput(EFalse);
 screen->iFullscreenEffectControlGroup->SetAcceptInput(EFalse);
+if ( screen->iFpsControlGroup )
+	    {
+	    ShowControlGroupL(screen->iDisplay->Roster(), *(screen->iFpsControlGroup), KHuiRosterShowAtTop, screenNumber);
+	    screen->iFpsControlGroup->SetAcceptInput(EFalse);
+	    }
 }
 // ---------------------------------------------------------------------------
 // have effect on the layout itself or layout is being drawn as external content. This indicates that
 // we should not delete the control group at this point, but add it to iDeadControlGroup list, which
 // is cleared when effect has finished.
 RPointerArray<CHuiLayout> familyTree;
 ListFamilyTreeL(familyTree, layout); // recursively dig the family tree
+TBool anyVisualHasEffect(EFalse);
+TInt familyIndex(0);
+TInt familySize = familyTree.Count();
+while(familyIndex < familySize && !anyVisualHasEffect)
+{
+anyVisualHasEffect = HasActiveEffect(familyTree[familyIndex++]);
+}
-if (HasActiveEffect(layout))
+if (anyVisualHasEffect)
 {
 __ALFFXLOGSTRING1("Layout 0x%x has external content", layout);
 // EHuiVisualFlagShouldDestroy destroy flag should have come for the windows in this layout already
 layout->SetFlags(EHuiVisualFlagShouldDestroy);
 // move this layout to effect control group, where it can still be shown. this control group may be deleted.
 {
 // The case where the application control group is deleted by window server
 // has been solved by deleting the tag when window server wants to delete
 // the group. Window server no longer has it, but we keep it alive for a while
 // to show the effect. The group will be deleted when the effect ends.
-aWhere = aRoster.Count() - KAlfNumberOfFixedControlGroups;
+aWhere = aRoster.Count() - screen->FixedControlGroupCount();
 }
 }
 if (aGroup.Control(0).Role() == EAlfWindowGroupContainer)
 {
 #ifdef ALF_DEBUG_PRINT_WINDOWGROUP_ORDER
 DebugPrintControlGroupOrder(*screen, aRoster, aGroup);
 #endif
 #ifdef ALF_DEBUG_VISUALIZE_WINDOWGROUP_ORDER
-VisualizeControlGroupOrderL(aRoster, aGroup);
+VisualizeControlGroupOrderL(*screen, aRoster, aGroup);
 #endif
 }
 // ---------------------------------------------------------------------------
 aRoster.ShowL(aGroup, KHuiRosterShowAtBottom);
 }
 else if (aWhere == KHuiRosterShowAtTop)
 {
 // Topmost
-aRoster.ShowL(aGroup, aRoster.Count() - KAlfNumberOfFixedControlGroups);
+aRoster.ShowL(aGroup, aRoster.Count() - screen->FixedControlGroupCount());
 }
 else
 {
 TInt index = 0; // Index for Window group control groups
 TBool added = EFalse;
-for (TInt i=0; i<aRoster.Count() - KAlfNumberOfFixedControlGroups; i++)
+for (TInt i=0; i<aRoster.Count() - screen->FixedControlGroupCount(); i++)
 {
 if (index == aWhere)
 {
 aRoster.ShowL(aGroup, i);
 added = ETrue;
 // Too large index was given, just add it to topmost
 if (!added)
 {
 // Topmost
-for (TInt i=aRoster.Count()-KAlfNumberOfFixedControlGroups; i >= 0; i--)
+for (TInt i=aRoster.Count() - screen->FixedControlGroupCount(); i >= 0; i--)
 {
 if (aRoster.ControlGroup(i).Control(0).Role() == EAlfWindowGroupContainer)
 {
 aRoster.ShowL(aGroup, i);
 break;
 {
 return aEffect && !(aEffect->EffectFlags() & KHuiFadeEffectFlag);
 }
 // ---------------------------------------------------------------------------
+// Check if effect has been flagged as opaque
+// ---------------------------------------------------------------------------
+//
+static TBool IsOpaqueEffect(CHuiFxEffect* aEffect)
+{
+return aEffect && (aEffect->EffectFlags() & KHuiFxOpaqueHint);
+}
+// ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 //
 TBool CAlfBridge::IsVisualOpaque(CHuiVisual& aVisual)
 {
+// Effect with opaque hint overrides everything else.
+if (IsOpaqueEffect( aVisual.Effect() ))
+{
+return ETrue; // Opaque
+}
 TBool transparent = EFalse;
 // TODO: We should check transformation too and perhaps parent transformations as well ?
 //transparent |= aVisual.IsTransformed();
 TBool fullscreenCovered = EFalse;
 //iActiveVisualCount = 0;
 iBgSurfaceFound = EFalse;
 //iPaintedArea = 0;
+// Check if effect group has an effect with opaque hint.
+CHuiControlGroup& fxcontrolgroup = *(iAlfScreens[aScreenNumber]->iFullscreenEffectControlGroup);
+CHuiControl& fxcontrol = fxcontrolgroup.Control(0);
+CHuiCanvasVisual* fxlayout = (CHuiCanvasVisual*)&fxcontrol.Visual(0);
+CHuiVisual* fxExternalContent = fxlayout->ExternalContent();
+if (fxlayout && IsOpaqueEffect(fxlayout->Effect()))
+{
+fullscreenCovered = ETrue;
+}
+else if (fxExternalContent && IsOpaqueEffect(fxExternalContent->Effect()))
+{
+fullscreenCovered = ETrue;
+}
+#ifdef USE_MODULE_TEST_HOOKS_FOR_ALF
+iTempTotalActiveVisualCount = 0;
+iTempTotalPassiveVisualCount = 0;
+#endif
 // skip the topmost (effect) layer, start from floating sprite group
-for (TInt j=screen->iDisplay->Roster().Count() - 2; j>=0; j--)
+for (TInt j=screen->iDisplay->Roster().Count() - screen->FixedControlGroupCount(); j>=0; j--)
 {
 #ifdef ALF_DEBUG_PRINT_WINDOWGROUP_ORDER
 TInt activevisualcount = 0;
 TInt passivevisualcount = 0;
 #endif
 CHuiControlGroup& controlgroup = iAlfScreens[aScreenNumber]->iDisplay->Roster().ControlGroup(j);
 CHuiControl& control = controlgroup.Control(0);
+if (control.Role() == EAlfFpsIndicatorContainer)
+{
+// FPS container doesn't contain canvas visuals
+continue;
+}
 CHuiCanvasVisual* layout = (CHuiCanvasVisual*)&control.Visual(0);
 #ifdef HUI_DEBUG_TRACK_DRAWING
 if ( layout->Tracking() )
 {
 RDebug::Print(_L("CAlfBridge::HandleVisualVisibility: tracked visual 0x%x"), canvasVisual);
 }
 #endif
 // Dont mess with alf control group visuals, alf session handling does it for us
 // just add the rect to covered region because alf draws solid background.
 if (control.Role() == EAlfSessionContainer)
 {
 iTempRegion.AddRect(fullscreen);
 }
 TBool subTreeCovered = EFalse;
 TBool hasActiveVisualsInVisualTree = HandleLayoutVisualVisibility( layout, controlgroup, control, fullscreenCovered, fullscreen, screen, subTreeCovered, IsVisualOpaque(*layout)  );
 TBool hasFadeEffectsInVisualTree = (layout->CanvasFlags() & EHuiCanvasFlagExternalFadeExistsInsideVisualTree);
+// If root visuals effect is marked as opaque, then add whole screen area as covered.
+if (!fullscreenCovered)
+{
+fullscreenCovered = IsOpaqueEffect(layout->Effect());
+}
 		// 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))
 // blend itself, but other windowgroups do blend. Otherwise windowgrouops above others
 // would clear the screen areas where they do not really draw.
 if (fadeEffectInScreen)
 {
 TBool firstFadedWindowGroupFound = EFalse;
-for (TInt j=0; j<screen->iDisplay->Roster().Count() - 2; j++) // skip the topmost (effect) layer
+for (TInt j=0; j<screen->iDisplay->Roster().Count() - screen->FixedControlGroupCount(); j++) // skip the topmost (effect) layer
 {
 CHuiControlGroup& controlgroup = iAlfScreens[aScreenNumber]->iDisplay->Roster().ControlGroup(j);
 CHuiControl& control = controlgroup.Control(0);
-CHuiCanvasVisual* layout = (CHuiCanvasVisual*)&control.Visual(0);
+CHuiVisual* layout = &control.Visual(0);
 if (layout->Effect() && (layout->Effect()->EffectFlags() & KHuiFadeEffectFlag))
 {
 if (firstFadedWindowGroupFound)
 {
 TInt flags = layout->Effect()->EffectFlags();
 }
 firstFadedWindowGroupFound = ETrue;
 }
 }
 }
+AMT_FUNC_EXC(AMT_DATA()->iActiveVisualCount = iTempTotalActiveVisualCount;
+AMT_DATA()->iPassiveVisualCount = iTempTotalPassiveVisualCount;
+AMT_DATA()->PrintState()
+);
 }
 TBool CAlfBridge::HandleLayoutVisualVisibility(
 CHuiLayout* aLayout,
 CHuiControlGroup& aControlGroup,
 if (!wasInactive)
 {
 aScreen->iDisplay->SetDirty();
 }
+#ifdef USE_MODULE_TEST_HOOKS_FOR_ALF
+iTempTotalPassiveVisualCount++;
+#endif
 #ifdef ALF_DEBUG_PRINT_WINDOWGROUP_ORDER
 passivevisualcount++;
 #endif
 }
 #endif
 iTempRegion.AddRect(coveredRect);
 iTempRegion.Tidy();
 }
 }
+// If effect is marked as opaque, then add whole visual area as covered.
+if (IsOpaqueEffect(canvasVisual->Effect()))
+{
+iTempRegion.AddRect(visualDisplayRect);
+iTempRegion.Tidy();
+}
 }
-}
+visualTreeActive |= visualIsActive;
+} // for loop end : children checking loop
-visualTreeActive |= visualIsActive;
 return visualTreeActive;
 }
 // ---------------------------------------------------------------------------
 {
 if (!iAlfScreens.Count())
 return;
 CAlfScreen* screen = iAlfScreens[0]; // TODO
-for (TInt j=screen->iDisplay->Roster().Count() - 2; j>=0; j--) // skip the topmost (effect) layer
+for (TInt j=screen->iDisplay->Roster().Count() - screen->FixedControlGroupCount(); j>=0; j--) // skip the topmost (effect) layer
 {
 CHuiControlGroup& controlgroup = iAlfScreens[0]->iDisplay->Roster().ControlGroup(j);
 CHuiControl& control = controlgroup.Control(0);
-if ( control.Role() == EAlfSessionContainer )
+if ( control.Role() == EAlfSessionContainer ||
+control.Role() == EAlfFpsIndicatorContainer )
 {
 continue;
 }
-CHuiLayout* layout = (CHuiLayout*)&control.Visual(0);
+CHuiVisual* layout = &control.Visual(0);
 for (TInt i=layout->Count()-1; i >= 0; i--)
 {
 CHuiCanvasVisual* canvasVisual = (CHuiCanvasVisual*)(&layout->Visual(i));
 if (!aInactiveOnly)
 {
 // dispatch
 __ALFLOGSTRING1( "CAlfBridge::DoDispatchL: %d",data.iOp );
 switch (data.iOp)
 {
+case EAlfDSSynchronize:
+{
+TInt id = data.iInt1;
+if ( iHuiEnv )
+{
+iHuiEnv->Synchronize( id, this );
+}
+}
+break;
 case EAlfDSCreateNewDisplay:
 {
 AddNewScreenL(NULL);
 break;
 }
 // TODO: Following delete iAlfScreens[aScreenNumber] crashes when display is trying to delete roster.
 // RosterEntry is trying to refer to display, which is appareantly alrady destroyed. The roster should have no iRootVisual when display is removed.
 iAlfScreens[aScreenNumber]->iDisplay->Roster().Hide(*(iAlfScreens[aScreenNumber]->iFloatingSpriteControlGroup));
 iAlfScreens[aScreenNumber]->iDisplay->Roster().Hide(*(iAlfScreens[aScreenNumber]->iFullscreenEffectControlGroup));
+if ( iAlfScreens[aScreenNumber]->iFpsControlGroup )
+{
+iAlfScreens[aScreenNumber]->iDisplay->Roster().Hide(*(iAlfScreens[aScreenNumber]->iFpsControlGroup));
+}
 delete iAlfScreens[aScreenNumber];
 iAlfScreens.Remove( aScreenNumber );
 }
 // ---------------------------------------------------------------------------
 // HandleDestroyWindow
 // ---------------------------------------------------------------------------
 //
 void CAlfBridge::DestroyWindow(CHuiVisual* aVisual, TBool aUseForce)
 {
-if ( !aUseForce && HasActiveEffect(aVisual) )
+TInt index;
+TBool visualParticipatingInEffect = HasActiveEffect(aVisual, index);
+TBool effectIsExitEffect(ETrue);
+if (index != KErrNotFound)
+{
+effectIsExitEffect = iEffectCleanupStack[index].iHideWhenFinished;
+}
+// effects inside application may need to destroy window to get the new content visible.
+// Even when there is effect on the layout, destruction of a child window must be allowed.
+if ( !aUseForce && visualParticipatingInEffect && effectIsExitEffect )
 {
 // this visual will be destroyed on the effect call back.
 __ALFFXLOGSTRING1("CAlfBridge::DestroyWindow - not destroying 0x%x", aVisual);
 aVisual->SetFlag(EHuiVisualFlagShouldDestroy);
 // TODO: Revise
 aVisual->Owner().Remove(aVisual);
 __ALFLOGSTRING1("CAlfBridge::HandleDestroyWindow - destroying visual 0x%x", aVisual);
 // check if visual is having an effect at the moment. This could occur, if options menu is exited (with effect) and then
 // application is exited. EHuiVisualFlagDrawOnlyAsExternalContent is indication that
 // 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
+for (TInt i = 0; i < iEffectCleanupStack.Count(); i++)
+{
+TEffectCleanupStruct& effectItem = iEffectCleanupStack[i];
+if (aVisual == effectItem.iEffectedVisual)
+{
+iEffectCleanupStack.Remove(i);
+AMT_DEC_COUNTER(iAlfBridgeEffectCleanupStackCount);
+break;
+}
+}
+}
 delete aVisual;
 }
 // ---------------------------------------------------------------------------
 // HandleDestroyWindowL
 // ---------------------------------------------------------------------------
 // SetWindowActiveL
 // ---------------------------------------------------------------------------
 //
 void CAlfBridge::SetWindowActiveL(CHuiVisual* aVisual, TBool aActive)
 {
-if (!HasActiveEffect(aVisual))
+TInt effectIndex;
+if (!HasActiveEffect(aVisual, effectIndex))
 {
 // Does not have effect
 if (aActive)
 {
 aVisual->ClearFlags(EHuiVisualFlagShouldBeHidden | EHuiVisualFlagShouldBeShown);
 // Has effect
 		// these flags are put to action in RemoveTemporaryPresenterItem
 if (aActive)
 {
 			// this prevents windows appearing before their "effected" time
-aVisual->SetFlag(EHuiVisualFlagShouldBeShown);
+if (!iEffectCleanupStack[effectIndex].iHideWhenFinished)
+{
+// this is appear effect. Lets show it
+aVisual->iOpacity.Set(KAlfVisualDefaultOpacity);
+}
+else
+{
+aVisual->SetFlag(EHuiVisualFlagShouldBeShown);
+}
 aVisual->ClearFlag(EHuiVisualFlagShouldBeHidden);
 }
 else
 {
 			// this prevents windows disappearing before their effect has finished
 //
 void CAlfBridge::HandleSetFadeEffectL( TAlfBridgerData& aData )
 {
 TInt windowNodeId = aData.iInt1;
 TBool faded = aData.iInt2;
+MWsWindowTreeNode::TType type = (MWsWindowTreeNode::TType)(TInt)aData.iPtr;
-CHuiVisual* viz = (CHuiVisual*)FindVisual(windowNodeId);
+CHuiVisual* viz = NULL;
-if (!viz)
+if (type != MWsWindowTreeNode::EWinTreeNodeGroup)
 {
-// Visual not found, it could be window group. It must be searched with other method.
+viz = (CHuiVisual*)FindVisual(windowNodeId);
+}
+else
+{
 CHuiControlGroup* cg = FindControlGroup(windowNodeId, 0); // TODO: Screen
 if (cg)
 {
 CHuiControl& control = cg->Control(0);
 viz = &control.Visual(0);
 if (aEvent.iAction != 5000)
 {
 if ( aEvent.iAction != AknTransEffect::EApplicationExit && aToLayout->Flags() & EHuiVisualFlagInactive)
 {
 aToLayout->iOpacity.Set(1.0f);
-failed = ETrue;
-return failed;
 }
 if (aToLayout)
 {
 aToLayout->iOpacity.Set(1.0f);
 if (layoutEffectable)
 {
 if (aEvent.iRect != TRect())
 {
-TRAP( err, engine->LoadGroupEffectL( *aEvent.iEffectName, effect, aToLayout->Effectable(), engine->ActiveGroupEffect(), &aEvent.iRect, this, aEvent.iHandle ) );
+TRAP( err, engine->LoadGroupEffectL( *aEvent.iEffectName, effect, aToLayout->Effectable(), engine->ActiveGroupEffect(), &aEvent.iRect, this, aEvent.iHandle, KHuiFxDelayRunUntilFirstFrameHasBeenDrawn ));
 }
 else
 {
-TRAP( err, engine->LoadGroupEffectL( *aEvent.iEffectName, effect, aToLayout->Effectable(), engine->ActiveGroupEffect(), NULL, this, aEvent.iHandle ) );
+TRAP( err, engine->LoadGroupEffectL( *aEvent.iEffectName, effect, aToLayout->Effectable(), engine->ActiveGroupEffect(), NULL, this, aEvent.iHandle, KHuiFxDelayRunUntilFirstFrameHasBeenDrawn ) );
 }
 effect = NULL;
 // only use the effect if the effect file was correctly parsed
 if (err != KErrNone)
 {
 TBool aIsExitEffect)
 {
 CHuiCanvasVisual* temporaryPresenterVisual = NULL;
 TInt enableEffect = ETrue;
+if (aSourceVisual->iOpacity.Now() >= 0.01)
+{
+aSourceVisual->SetFlag(EHuiVisualFlagShouldBeShown);
+}
 aSourceVisual->ClearFlags(EHuiVisualFlagShouldBeInactive | EHuiVisualFlagShouldBeUnderOpaqueHint);
 if (aIsExitEffect)
 {
 aSourceVisual->SetFlag(EHuiVisualFlagAlwaysDraw);   // forces drawing during exit effect. handlevisualvisibility will set the EShouldbeInactive flag, if visual is determined inactive while this flag is set
 }
 TEffectCleanupStruct item = TEffectCleanupStruct(
 aEffectHandle,
 aSourceVisual,
 temporaryPresenterVisual,
 ETrue,
-EFalse);
+aIsExitEffect);
 iEffectCleanupStack.AppendL(item);
 }
 else
 {
 // this will be a child of another visual, and draw by its parent external content visual
 // aSourceVisual->SetFlag(EHuiVisualFlagDrawOnlyAsExternalContent);
 TEffectCleanupStruct item = TEffectCleanupStruct(aEffectHandle,
 aSourceVisual, NULL, EFalse,
-EFalse);
+aIsExitEffect);
 iEffectCleanupStack.AppendL(item);
 }
 }
 return temporaryPresenterVisual;
 }
 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, ETrue, itemsDestroyed, EFalse);
+AddEffectItemL(aHandle, aSourceLayout, NULL, &effectControlGroup, EFalse, itemsDestroyed, 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)
 __ALFFXLOGSTRING3("CAlfBridge::SetupEffectContainerL - adding handle: %d, 0x%x (source visual)-> 0x%x (presenter visual)", aHandle, aSourceVisual, temporaryPresenterVisual);
 }
 void CAlfBridge::HandleGfxControlEffectsL( TAlfBridgerData data )
 {
-TInt err = KErrNone;
 TInt action = data.iInt1;
 TInt length = data.iInt2;
 __ALFFXLOGSTRING1("HandleGfxControlEffectsL - Reading bridge data %d", (TInt)data.iPtr);
 void* bridgeBuffer = (void*) (*iHost)->GetEffectsDataL((TInt) data.iPtr);
 RMemReadStream stream(bridgeBuffer, length);
 iControlEffectData->iClientHandle,
 iControlEffectData->iClientGroupHandle);
 return;
 }
 iAlfScreens[0]->iDisplay->SetDirty();
 iHuiEnv->ContinueRefresh();
-if (visual && err != KErrNone)
-{
-// if the effect loading failed too soon, we must call our callback ourselves
-//        RDebug::Print(_L("HandleGfxControlEffectsL - effect not set - going directly to callback"));
-AlfGfxEffectEndCallBack(fxData->iHandle);
-}
 delete iControlEffectData;
 iControlEffectData = NULL;
 __ALFFXLOGSTRING("HandleGfxControlEffectsL - end");
 {
 layoutEffectable = SetupEffectLayoutContainerL(aEvent.iHandle, aCanvasVisual, EFalse);
 }
 if (layoutEffectable)
 {
-TRAP( err, engine->LoadGroupEffectL(*aEvent.iEffectName, effect, aCanvasVisual->Effectable(), engine->ActiveGroupEffect(), NULL, this, aEvent.iHandle ) );
+TRAP( err, engine->LoadGroupEffectL(*aEvent.iEffectName, effect, aCanvasVisual->Effectable(), engine->ActiveGroupEffect(), NULL, this, aEvent.iHandle, KHuiFxDelayRunUntilFirstFrameHasBeenDrawn ) );
 }
 else
 {
 err = KErrNotFound;
 }
 {
 // this was exit effect, and window was not really destroyed.
 sourceViz->iOpacity.Set(0.0f);
 sourceViz->ClearFlag(EHuiVisualFlagShouldBeHidden); // it is now hidden
 }
-	else
-		{
-// visual may be transparent after manipulation of the effect
-	   	sourceViz->iOpacity.Set(KAlfVisualDefaultOpacity);
-		}
 if (showVisual)
 {
 sourceViz->iOpacity.Set(KAlfVisualDefaultOpacity);
 sourceViz->ClearFlag(EHuiVisualFlagShouldBeShown); // it is now hidden
 }
 return NULL;
 }
 TBool CAlfBridge::HasActiveEffect(CHuiVisual* aVisual)
 {
+TInt dummy;
+return HasActiveEffect(aVisual, dummy);
+}
+TBool CAlfBridge::HasActiveEffect(CHuiVisual* aVisual, TInt& aIndex)
+{
+aIndex = KErrNotFound;
 for (TInt i = 0; i < iEffectCleanupStack.Count(); i++)
 {
 if (aVisual == iEffectCleanupStack[i].iEffectedVisual)
 {
+aIndex = i;
 return ETrue;
 }
 }
 return EFalse;
 }
 {
 if (RemoveTemporaryPresenterItem(effectItem))
 {
 itemsRemoved++;
 }
-iEffectCleanupStack.Remove(i);
+if (iEffectCleanupStack.Count() > i)
+{
+iEffectCleanupStack.Remove(i);
+}
 iFinishedCleanupStackEffects.Remove(0);
 i--;
 }
 }
 }
 void CAlfBridge::AlfGfxEffectEndCallBack(TInt aHandle)
 {
 // We need a delay to prevent the refresh from being messed up
 // We try a short delay before clearing everything up.
-__ALFFXLOGSTRING1("AlfGfxEffectEndCallBack, append handle %d", aHandle );
+__ALFFXLOGSTRING1("AlfGfxEffectEndCallBack, handle %d", aHandle );
 //    RDebug::Print(_L("AlfGfxEffectEndCallBack, append handle %d"), aHandle );
 // If the handle cannot be appended, the function returns an error.
 // However, if the memory is low, there is nothing we can do about it.
 // We try to handle the transition finish anyway.
 // If there are already other handles in the queue, the handler will not
 // be called for this handle, but all handles that have been left hanging
 // around will be cleared when HandleGfxStopEffectsL is called
-iFinishedEffects.Append(aHandle);
 // iFinishedCleanupStackEffects.Append(aHandle);
 if (!iEffectEndTimer->IsActive())
 {
 iEffectEndTimer->Start( 10000, aHandle );
 }
 __ALFLOGSTRING3(">> %d EFFECT GROUP %S, %d", i, &processName, clientWindowGroupId );
 #else
 __ALFLOGSTRING1(">> %d EFFECT GROUP", i);
 #endif
 }
+else if (indexedGroup.Control(0).Role() == EAlfFpsIndicatorContainer)
+{
+#ifdef  HUI_DEBUG_TRACK_DRAWING
+__ALFLOGSTRING3(">> %d FPS GROUP %S, %d", i, &processName, clientWindowGroupId );
+#else
+__ALFLOGSTRING1(">> %d FPS GROUP", i);
+#endif
+}
 else
 {
 #ifdef  HUI_DEBUG_TRACK_DRAWING
 __ALFLOGSTRING3(">> %d UNKNOWN GROUP ?!!? %S, %d", i, &processName, clientWindowGroupId );
 #endif
 {
 }
 #endif
 #ifdef ALF_DEBUG_VISUALIZE_WINDOWGROUP_ORDER
-void CAlfBridge::VisualizeControlGroupOrderL(CHuiRoster& aRoster, CHuiControlGroup& /*aGroup*/)
+void CAlfBridge::VisualizeControlGroupOrderL(CAlfScreen& aScreen, CHuiRoster& aRoster, CHuiControlGroup& /*aGroup*/)
 {
 TInt nbrofcolums = 3;
 TInt nbrofrows = 3;
 TInt gridIndex = 0;
 TBool skipEmpty = EFalse;
-if (aRoster.Count() > 3)
+TInt skipCount = aScreen.FixedControlGroupCount() + 1;
-{
+if (aRoster.Count() > skipCount)
-for (TInt i=aRoster.Count() - 3; i>0; i--)
+{
+for (TInt i=aRoster.Count() - skipCount; i>0; i--)
 {
 CHuiControl& control = aRoster.ControlGroup(i).Control(0);
 if (skipEmpty)
 {
 TBool empty = ETrue;
 }
 }
 iAlfScreens[0]->iDisplay->SetClearBackgroundL(CHuiDisplay::EClearWithSkinBackground);
 }
 #else
-void CAlfBridge::VisualizeControlGroupOrderL(CHuiRoster& /*aRoster*/, CHuiControlGroup& /*aGroup*/)
+void CAlfBridge::VisualizeControlGroupOrderL(CAlfScreen& /*aScreen*/, CHuiRoster& /*aRoster*/, CHuiControlGroup& /*aGroup*/)
 {
 }
 #endif
 // ---------------------------------------------------------------------------
 {
 // screen owns this bitmap
 aScreen->iSwRenderingTarget = new CFbsBitmap;
 if (aScreen->iSwRenderingTarget)
 {
-aScreen->iSwRenderingTarget->Create(aScreen->Size(), EColor16MA);
+aScreen->iSwRenderingTarget->Create(aScreen->Size(), EColor16MAP);
 modified = ETrue;
 }
 }
 if (aScreen->iSwRenderingTarget)
 {
 TInt screenNumber = ResolveScreenNumber(aDisplay);
 TRAP_IGNORE(UploadSwRenderingTargetL(iAlfScreens[screenNumber]));
 }
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+//
+void CAlfBridge::Synchronized(TInt aId)
+{
+// Use P&S for now.
+RProperty::Set( KAlfPSUidSynchronizer, KAlfPSKeySynchronizer, aId );
+}
 // end of file

branch	RCL_3
changeset 3	d8a3531bc6b8
parent 0	15bf7259bb7c
child 5	433cbbb6a04b