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

equal deleted inserted replaced

-:7c5dd702d6d3
+:f93c875b566e
 TInt aWindowNodeId,
 TInt aClientSideId,
 TInt aClientSideGroupId,
 CHuiCanvasVisual* aVisual )
 {
-__ALFFXLOGSTRING1("CAlfBridge::AddVisual 0x%x", aWindowNodeId);
+__ALFFXLOGSTRING4("CAlfBridge::AddVisual id: %d (%d,%d), visual: 0x%x", aWindowNodeId, aClientSideId, aClientSideGroupId, aVisual);
 THashVisualStruct visualStruct( aVisual, aClientSideId, aClientSideGroupId);
 iWindowHashArray.Insert( aWindowNodeId, visualStruct );
 iPreviouslySearchedVisualId = aWindowNodeId;
 iPreviouslySearchedVisual = aVisual;
 {
 iPreviouslySearchedVisualId = aWindowNodeId;
 iPreviouslySearchedVisual = visualStruct->iVisual;
 return iPreviouslySearchedVisual;
 }
-__ALFFXLOGSTRING1("CAlfBridge::FindVisual - Visual 0x%x not found", aWindowNodeId);
+__ALFLOGSTRING1("CAlfBridge::FindVisual - Visual 0x%x not found", aWindowNodeId);
 return NULL;
 }
 // ---------------------------------------------------------------------------
 // FindVisualByClientSideId
 RPointerArray<CHuiLayout> familyTree;
 ListFamilyTreeL(familyTree, layout); // recursively dig the family tree
 TBool anyVisualHasEffect(EFalse);
 TInt familyIndex(0);
 TInt familySize = familyTree.Count();
+TInt activeEffectIndex = KErrNotFound;
 while(familyIndex < familySize && !anyVisualHasEffect)
 {
-anyVisualHasEffect = HasActiveEffect(familyTree[familyIndex++]);
+anyVisualHasEffect = HasActiveEffect(familyTree[familyIndex++], activeEffectIndex);
 }
 if (anyVisualHasEffect)
 {
+TInt activeEffectHandle = iEffectCleanupStack[activeEffectIndex].iHandle;
 __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.
 CHuiControl& control = iAlfScreens[aScreenNumber]->iControlGroups[i].iControlGroup->Control(0);
 CHuiLayout* effectControlGroupLayout = (CHuiLayout*) &effectControlGroup.Visual(0);
 // Transfers ownership of visuals.
 effectControlGroup.AppendL(layout, effectControlGroupLayout); // this will remove it from the previous layout
 layout->SetOwner(effectControlGroup);
-for(TInt familyIndex = 0; familyIndex < familyTree.Count();familyIndex++)
+for(TInt familyIndex = familyTree.Count() - 1; familyIndex >= 0; --familyIndex)
 {
 familyTree[familyIndex]->SetOwner(effectControlGroup);
-}
+if (!HasActiveEffect(familyTree[familyIndex]))
+{
+TInt dummy;
+AddEffectItemL(activeEffectHandle, familyTree[familyIndex], NULL, NULL, EFalse, dummy, ETrue, EFalse);
+}
+}
 }
 else
 {
 // check once more, that the windows in this group are not having effects.
 // the layout is not have effect, but some child window might.
 RemoveTemporaryPresenterVisual(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);
 					         if ( removedVisual->Layout() == layout )
 					             {
 					             iOrphanStorage->AppendL( removedVisual );
 					             }
 					         else
 CHuiLayout* layout = NULL;
 cntrl->ConstructL();
 group->AppendL(cntrl);
 CleanupStack::Pop(cntrl);
-cntrl->SetRole(EAlfWindowGroupContainer);
+cntrl->SetRole(EHuiWindowGroupContainer);
 layout = CHuiCanvasVisual::AddNewL(*cntrl);
 layout->SetTagL(KAlfWindowGroupContainerControlTag);
 layout->ClearFlag(EHuiVisualFlagClipping); // No need to clip, should be faster without clipping
 // IsVisualOpaque should return true if there is no effect.
 __ALFFXLOGSTRING1("CAlfBridge::CreateControlGroupL - effect failed on layout 0x%x", layout);
 HandleGfxStopEvent( EFalse ); // destroys iFullScreenEffectData
 }
 }
 entry.iScreenNumber = aScreenNumber;
-//        entry.iRole = EAlfWindowGroupContainer;
+//        entry.iRole = EHuiWindowGroupContainer;
 iAlfScreens[aScreenNumber]->iControlGroups.Append(entry);
 CleanupStack::Pop(group);
 if (iAlfScreens[aScreenNumber]->iDisplay)
 // when an application exits, it must be shown on top util the effect has run its course.
 // But this tends to mess up the order of other groups, and application menu softkeys will
 // disappear.
 if ( aGroup.Control(0).Visual(0).Effect() )
 {
-if ( aGroup.Control(0).Role() != EAlfWindowGroupContainer )
+if ( aGroup.Control(0).Role() != EHuiWindowGroupContainer )
 {
 // 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() - screen->FixedControlGroupCount();
 }
 }
-if (aGroup.Control(0).Role() == EAlfWindowGroupContainer)
+if (aGroup.Control(0).Role() == EHuiWindowGroupContainer)
 {
 // Window group control groups
 ShowWindowGroupControlGroupL(aRoster, aGroup, aWhere, aScreenNumber);
 aGroup.SetAcceptInput(EFalse);
 }
-else if (aGroup.Control(0).Role() == EAlfSessionContainer)
+else if (aGroup.Control(0).Role() == EHuiSessionContainer)
 {
 // ALF application control groups
 ShowSessionContainerControlGroupL(aRoster, aGroup, aWhere, aScreenNumber);
 }
 else
 if( &aRoster.ControlGroup(i) == &aGroup )
 {
 move = ETrue;
 }
-if (aRoster.ControlGroup(i).Control(0).Role() == EAlfSessionContainer)
+if (aRoster.ControlGroup(i).Control(0).Role() == EHuiSessionContainer)
 {
 index++;
 }
 }
 }
 break;
 }
-if (aRoster.ControlGroup(i).Control(0).Role() == EAlfWindowGroupContainer &&
+if (aRoster.ControlGroup(i).Control(0).Role() == EHuiWindowGroupContainer &&
 &aRoster.ControlGroup(i) != &aGroup)
 {
 index++;
 }
 }
 if (!added)
 {
 // Topmost
 for (TInt i=aRoster.Count() - screen->FixedControlGroupCount(); i >= 0; i--)
 {
-if (aRoster.ControlGroup(i).Control(0).Role() == EAlfWindowGroupContainer)
+if (aRoster.ControlGroup(i).Control(0).Role() == EHuiWindowGroupContainer)
 {
 // increasing the count, assuming that WindowControlGroup is not in the Roster
 i++;
 aRoster.ShowL(aGroup, i);
 break;
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 //
 void CAlfBridge::SetAlfWindowGroupId(TInt aAlfWindowGroupId)
 {
 iAlfWindowGroupId = aAlfWindowGroupId;
 // check if hithcock window group was already there
 TInt secureId = RThread().SecureId();
 if (iAlfScreens.Count())
 {
 for ( TInt i = 0; i < iAlfScreens[0]->iControlGroups.Count(); i++ )
 {
 if ( iAlfScreens[0]->iControlGroups[i].iSecureId == secureId &&
 iAlfScreens[0]->iControlGroups[i].iClientWindowGroupId != CHuiStatic::RootWin(0)->Identifier())
 {
 iAlfWindowGroupNodeId = iAlfScreens[0]->iControlGroups[i].iWindowGroupNodeId;
+CHuiControlGroup* controlGroup = FindControlGroup(iAlfWindowGroupNodeId, 0);
+CHuiControl& control = controlGroup->Control(0);
+CHuiVisual* layout = &control.Visual(0);
+iAlfScreens[0]->iDisplay->Roster().SetAlfEventWindow(layout);
 return;
 }
 }
 }
 }
 RPointerArray<CHuiControlGroup> controlGroupOrder;
 CHuiRoster& roster = iAlfScreens[aScreenNumber]->iDisplay->Roster();
 for (TInt j=0; j<roster.Count();j++)
 {
 CHuiControlGroup& controlGroup = roster.ControlGroup(j);
-if (controlGroup.Control(0).Role() == EAlfSessionContainer)
+if (controlGroup.Control(0).Role() == EHuiSessionContainer)
 {
 controlGroupOrder.Append(&controlGroup);
 roster.Hide(controlGroup);
 j--; // roster.Hide does remove controlGroup from the roster
 }
 if (iAlfScreens[aScreenNumber]->iDisplay)
 {
 CHuiRoster& roster = iAlfScreens[aScreenNumber]->iDisplay->Roster();
 for (TInt j=0; j<roster.Count();j++)
 {
-if( roster.ControlGroup(j).Control(0).Role() == EAlfSessionContainer
+if( roster.ControlGroup(j).Control(0).Role() == EHuiSessionContainer
 || roster.ControlGroup(j).ResourceId() == iAlfWindowGroupNodeId )
 {
 return j; // Alf groups positioned just above alf servers window group
 }
 }
 #endif
 CHuiControlGroup& controlgroup = iAlfScreens[aScreenNumber]->iDisplay->Roster().ControlGroup(j);
 CHuiControl& control = controlgroup.Control(0);
-if (control.Role() == EAlfFpsIndicatorContainer)
+if (control.Role() == EHuiFpsIndicatorContainer)
 {
 // FPS container doesn't contain canvas visuals
 continue;
 }
 #endif
 }
 // Dont mess with alf control group visuals, alf session handling does it for us
-if (control.Role() == EAlfSessionContainer)
+if (control.Role() == EHuiSessionContainer)
 {
 CHuiLayout* hostContainer = control.ContainerLayout( NULL );
 TInt flags = hostContainer->Flags();
-if (!fullscreenCovered || alfClientWindowGroupVisible)
+CAlfAppSrvSessionBase* activeSession = NULL;
+if (iAppUi)
+{
+activeSession = iAppUi->ActiveSession();
+}
+// !fullscreenCovered need to be checked because for fullscreen
+// alf applications alf event window group could be on top of alf client windowgroup
+if ( (alfClientWindowGroupVisible || !fullscreenCovered)  && activeSession)
 {
 // clear inactive flag if client has not made this controlgroup hidden
 if(!(flags&EHuiVisualFlagUnderOpaqueHint))
 {
 if(iAppUi)
 TBool isLayoutActive = !(layout->Flags() & EHuiVisualFlagInactive);
 if (isLayoutActive && !hasActiveVisualsInVisualTree)
 {
 // Setting also the root visual (layout) as inactive, if it had none
-						// active children. This is because otherwise the Inactive checks won't
+			// active children. This is because otherwise the Inactive checks won't
-						// work correctly within RosterImpl ScanDirty & ClearChanged phases.
+			// work correctly within RosterImpl ScanDirty & ClearChanged phases.
 layout->SetFlag(EHuiVisualFlagInactive);
 }
 else if(!isLayoutActive && hasActiveVisualsInVisualTree)
 {
 layout->ClearFlag(EHuiVisualFlagInactive);
 {
 RProperty::Set( KPSSysCategory, KAlfPSKeyHSVisible, value );
 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.
 if (checkFadeEffectInScreen)
 {
 layout->Effect()->SetEffectFlags(flags);
 }
 if ((controlgroup.ResourceId() == iAlfWindowGroupNodeId))
 {
-// Special handling for ALF fading...fading happens via empty alf originated event window group
+					// no special actions needed currently for alf content.
-TInt flags = layout->Effect()->EffectFlags();
-flags |= KHuiFxEnableBackgroundInAllLayers; // This forces effect to happen to background pixels that are read from surface.
-flags |= KHuiFxFrozenBackground; // To get optimal UI performance, we ignore changes in ALF scene when it is faded.
-layout->Effect()->SetEffectFlags(flags);
 }
 firstFadedWindowGroupFound = ETrue;
 }
 }
 }
 visualIsActive = !(canvasVisual->Flags() & EHuiVisualFlagInactive);
 // Sprites and effects as we consider them always as transparent and also
 // if controlgroup is transformed somehow
-if (aControl.Role() == EAlfFullScreenEffectContainer
+if (aControl.Role() == EHuiFullScreenEffectContainer
-|| aControl.Role() == EAlfWindowFloatingSpriteContainer ||
+|| aControl.Role() == EHuiWindowFloatingSpriteContainer ||
 aControlGroup.IsTransformed())
 {
 visualIsOpaque = EFalse;
 }
 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() == EHuiSessionContainer ||
-control.Role() == EAlfFpsIndicatorContainer )
+control.Role() == EHuiFpsIndicatorContainer )
 {
 continue;
 }
 CHuiVisual* layout = &control.Visual(0);
 for (TInt familyIndex = 1; familyIndex < familyTree.Count();familyIndex++)
 {
 CHuiLayout* lVisual = familyTree[familyIndex];
 lVisual->Owner().Remove(lVisual);
 iOrphanStorage->AppendL( lVisual );
+RemoveTemporaryPresenterVisual(lVisual);
+__ALFLOGSTRING1("CAlfBridge::DestroyWindow - orphons: %d", iOrphanStorage->VisualCount());
 }
 familyTree.Close();
 __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
 			// Window server nodes are in inverted Z-order, we switch it here.
 			iAlfScreens[screenNumber]->iDisplay->Roster().Hide(*controlGroup);
 			TInt wsWindowGroupCount = 0;
 			for (TInt i=0; i<iAlfScreens[screenNumber]->iDisplay->Roster().Count();i++)
 				{
-if (iAlfScreens[screenNumber]->iDisplay->Roster().ControlGroup(i).Control(0).Role()==EAlfWindowGroupContainer)
+if (iAlfScreens[screenNumber]->iDisplay->Roster().ControlGroup(i).Control(0).Role()==EHuiWindowGroupContainer)
 					{
 					wsWindowGroupCount++;
 					}
 				}
 			ordinalPosition = wsWindowGroupCount - windowAttributes->iOrdinalPosition;
 			__ALFLOGSTRING("CAlfBridge::HandleReorderWindowL: Unknown window node type received !");
 			break;
 			}
 		}
 	iAlfScreens[screenNumber]->SetVisualTreeVisibilityChanged(ETrue); // TODO: Check if really changed
+	AMT_MAP_BRIDGE_SET_ORDINAL_POSITION();
 	}
 // ---------------------------------------------------------------------------
 // HandlePostCanvasBufferL
 // ---------------------------------------------------------------------------
 		TPtrC8 commands((TUint8*)bufferAttributes->iBuffer, bufferAttributes->iBufferLength);
 		if ( bufferAttributes->iEmptyThisBuffer )
 			{
 			viz->ClearCommandSet();
 			}
+#ifdef USE_MODULE_TEST_HOOKS_FOR_ALF
+		if (!(viz->Flags() & EHuiVisualFlagInactive))
+		    {
+TInt secureId = viz->Owner().ControlGroup()->SecureId();
+TInt64 temp(KErrNotFound);
+TBool effects(EFalse);
+AMT_GET_TIME(temp, secureId, 0, effects);
+if (temp != KErrNotFound && effects == EFalse)
+{
+TTime time;
+time.UniversalTime();
+TTime startTime(temp);
+TInt64 reactionTime = time.MicroSecondsFrom(startTime).Int64();
+RDebug::Printf("CAlfBridge::HandlePostCanvasBufferL - Reaction time \t0x%x\t%f", secureId, (TReal)reactionTime / 1000000.0f );
+AMT_RESET_TIME(secureId);
+}
+		    }
+#endif
 		// If tracking has been enabled for this CHuiCanvasVisual object, the buffers will be marked for tracking aswell in CHuiCanvasVisual
 		switch( bufferAttributes->iPartStatus )
 			{
 			case TAlfWindowCommandBufferAttributes::EPartComplete:
 				{
 for (TInt j=screen->iDisplay->Roster().Count() - screen->FixedControlGroupCount(); j>=0; j--)
 {
 CHuiControlGroup& controlgroup = screen->iDisplay->Roster().ControlGroup(j);
 CHuiControl& control = controlgroup.Control(0);
-if( control.Role() == EAlfWindowGroupContainer)
+if( control.Role() == EHuiWindowGroupContainer)
 {
 // Only update layout which are made to correspond window groups.
 // Layouts that fullscreen effects are applied to
 CHuiCanvasVisual* layout = (CHuiCanvasVisual*)&control.Visual(0);
 layout->SetPos(fullscreen.iTl);
 {
 // All children in the tree are not faded, do not apply effect on children.
 effectFlags |= KHuiFxEffectExcludeChildrenFlag;
 //RDebug::Print(_L("CAlfBridge::SetupFadeEffectL - no children faded by parent"));
 }
+__ALFFXLOGSTRING1("CAlfBridge::SetupFadeEffectL - insert fade 0x%x", &aVisual);
 TRAP( err, engine->LoadEffectL(*iFadeEffectFile, effect, aVisual.Effectable(), NULL, NULL, 0, effectFlags ) );
 didFadeEffectLoad = ETrue;
 		}
 	}
 }
 {
 // remove only an old fade effect, leave any others intact
 if (alreadyFaded)
 {
 aVisual.SetEffect( NULL );
+__ALFFXLOGSTRING1("CAlfBridge::SetupFadeEffectL - remove fade: 0x%x", &aVisual);
 alreadyFaded = EFalse;
 }
 }
 // If we did load and fade children we must re-prepare the flags again
 }
 }
 else
 {
 __ALFLOGSTRING("CAlfBridge::HandleMoveWindowToNewGroupL cannot find new group! orphaning the visual");
-iOrphanStorage->AppendL( viz );
+RemoveTemporaryPresenterVisual(viz);
+iOrphanStorage->AppendL( viz );
 }
 }
 else
 {
 __ALFLOGSTRING("CAlfBridge::HandleMoveWindowToNewGroupL cannot find moving visual!");
 {
 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, EFalse);
+	AddEffectItemL(aEvent.iHandle, aToLayout, NULL, NULL, EFalse, dummy, ETrue, EFalse);
 						}
 }
 				// Screenshot was requested, but it could not be taken. Lets cancel the effect.
 				if (!success)
 					{
 __ALFFXLOGSTRING1("CAlfBridge::HandleGfxEventL - Removing the layout 0x%x with screenshot from iEffectCleanupStack", aToLayout);
 iEffectCleanupStack.Remove(index);
 }
 // this will tag the visual, that they cannot be hidden by HandleVisualVisibility
 // Initialize layout for the exit effect
-iLayoutInitializedForExitEffect = SetupEffectLayoutContainerL(aEvent.iHandle, aToLayout, ETrue, aEvent.iCanDestroyOrHideImmediately);
+iLayoutInitializedForExitEffect = SetupEffectLayoutContainerL(aEvent.iHandle, aToLayout, ETrue, ETrue, aEvent.iCanDestroyOrHideImmediately);
 __ALFFXLOGSTRING1("CAlfBridge::HandleGfxEventL - EBeginFullscreen - iLayoutInitializedForExitEffect: %d", iLayoutInitializedForExitEffect);
 aEvent.iSetupDone = iLayoutInitializedForExitEffect;
 }
 else
 {
 	                        // for cleaning. SetupEffectLayoutContainerL will add the same layout
 	                    // to the cleanupstack, but double cleaning is not a good idea. Thus it is removed here.
 __ALFFXLOGSTRING1("CAlfBridge::HandleGfxEventL - Removing the layout 0x%x with screenshot from iEffectCleanupStack", aToLayout);
 iEffectCleanupStack.Remove(index);
 }
-layoutEffectable = SetupEffectLayoutContainerL(aEvent.iHandle,aToLayout, EFalse, aEvent.iCanDestroyOrHideImmediately);
+layoutEffectable = SetupEffectLayoutContainerL(aEvent.iHandle,aToLayout, ETrue, EFalse, aEvent.iCanDestroyOrHideImmediately);
 aEvent.iSetupDone = layoutEffectable;
 aToLayout->SetStoredRenderBufferModificationsEnabled(ETrue);
 }
 if (layoutEffectable)
 		if (err == KErrNone)
 			{
 // Freeze only, if buffer was reserved succesfully
 aLayout->SetFreezeState(ETrue);
 	TBool itemsDestroyed;
-	    AddEffectItemL(aHandle, aLayout, NULL, NULL, EFalse, itemsDestroyed, EFalse);
+	    AddEffectItemL(aHandle, aLayout, NULL, NULL, EFalse, itemsDestroyed, ETrue, EFalse);
 	        iFullScreenEffectData->iAppStartScreenshotItemHandle = aHandle;
 			}
 }
 }
 return ;
 }
 }
 else // MAlfGfxEffectPlugin::EEndFullscreen
 {
-stream.Release();
 // End fullscreen signal received. We proceed only if there is really
 // effect ongoing and "end fullscreen" hasn't already been processed.
 if ( !iFullScreenEffectData || iFullScreenEffectData->iEndFullScreen )
 {
 __ALFFXLOGSTRING("CAlfBridge::HandleGfxEffectsL - END: fx ready");
 return;
 }
+			// Load the whole structure. If timeout was triggered then request effect name
+			// is updated.
+CFullScreenEffectState* fxData = new (ELeave) CFullScreenEffectState;
+CleanupStack::PushL( fxData );
+fxData->ConstructL( action, stream );
+iFullScreenEffectData->iTimeoutTriggered = fxData->iTimeoutTriggered;
+if (fxData->iTimeoutTriggered)
+{
+delete iFullScreenEffectData->iEffectName;
+iFullScreenEffectData->iEffectName = NULL;
+iFullScreenEffectData->iEffectName = fxData->iEffectName->AllocL();
+}
+CleanupStack::PopAndDestroy( fxData );
+fxData = NULL;
 __ALFFXLOGSTRING("HandleGfxEffectsL - process end");
 iFullScreenEffectData->iEndFullScreen = ETrue;
 #ifdef USE_APPLICATION_ENDFULLSCREEN_TIMEOUT
 if (iFullScreenEffectData->iDrawingCompleteTimer)
 {
 iFullScreenEffectData->iDrawingCompleteTimer->Cancel();
 }
 #endif
+stream.Release();
 }
 CFullScreenEffectState* fxData = iFullScreenEffectData;
 fxData->iOperation = operation;
 fxData->iWaitingWindowGroup = EFalse;
 {
 HandleGfxControlEventL(*iControlEffectData, visual);
 }
 else
 {
-__ALFFXLOGSTRING2("CAlfBridge::HandleGfxControlEffectsL - Control not found. iClientHandle %d, iClientGroupHandle %d",
+__ALFFXLOGSTRING2("CAlfBridge::HandleSetDistractionWindowL - Control not found. iClientHandle %d, iClientGroupHandle %d. Cache request.",
 fxData->iClientHandle,
 fxData->iClientGroupHandle);
 return;
 }
 delete iControlEffectData;
 CHuiVisual* aSourceVisual,
 CHuiLayout* aTargetLayout,
 CHuiControl* aEffectControl,
 TBool aInsertTemporaryVisual,
 TInt& aItemDestroyed,
+TBool aIsFullScreenEffect,
 TBool aIsExitEffect,
-TBool aCanDestroyOrHideImmediately)
+TBool aCanDestroyOrHideImmediately
+)
 {
 CHuiCanvasVisual* temporaryPresenterVisual = NULL;
 TInt enableEffect = ETrue;
 if (aSourceVisual->iOpacity.Now() >= 0.01 && !(aSourceVisual->Flags() & EHuiVisualFlagShouldBeHidden))
 aEffectHandle,
 aSourceVisual,
 temporaryPresenterVisual,
 ETrue,
 aIsExitEffect,
-aCanDestroyOrHideImmediately);
+aCanDestroyOrHideImmediately,
+aIsFullScreenEffect);
 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,
 aIsExitEffect,
-aCanDestroyOrHideImmediately);
+aCanDestroyOrHideImmediately,
+aIsFullScreenEffect);
 iEffectCleanupStack.AppendL(item);
 }
 }
 return temporaryPresenterVisual;
 }
 TInt aEffectHandle,
 CHuiLayout* aSourceLayout,
 CHuiLayout* aTargetLayout,
 CHuiControl* aEffectControl,
 TInt& aItemsDestroyed,
+TBool aIsFullScreenEffect,
 TBool aAddLayout,
 TBool aIsExitEffect,
 TBool aCanDestroyOrHideImmediately)
 {
 __ALFFXLOGSTRING2("CAlfBridge::AddToEffectLayoutContainerL 0x%x is having %d children", aSourceLayout, aSourceLayout->Count());
 if (aAddLayout)
 {
-AddEffectItemL(aEffectHandle, aSourceLayout, aTargetLayout, aEffectControl, EFalse, aItemsDestroyed, aIsExitEffect, aCanDestroyOrHideImmediately);
+AddEffectItemL(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));
 if (sourceVisual.Count())
 {
 CHuiLayout& layout = static_cast<CHuiLayout&> (aSourceLayout->Visual(i));
-AddToEffectLayoutContainerL(aEffectHandle, &layout, NULL, aEffectControl, aItemsDestroyed, EFalse,aIsExitEffect, aCanDestroyOrHideImmediately );
+AddToEffectLayoutContainerL(aEffectHandle, &layout, NULL, aEffectControl, aItemsDestroyed, aIsFullScreenEffect,  EFalse, aIsExitEffect, aCanDestroyOrHideImmediately );
 }
 TInt oldItemsDestroyed = aItemsDestroyed;
-AddEffectItemL(aEffectHandle, &sourceVisual, aTargetLayout, aEffectControl, EFalse, aItemsDestroyed, aIsExitEffect, aCanDestroyOrHideImmediately);
+AddEffectItemL(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 aIsExitEffect, TBool aCanDestroyOrHideImmediately)
+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 >>",
 aHandle,
 aSourceLayout,
 aIsExitEffect,
 CHuiLayout& effectControlGroupLayout = (CHuiLayout&) effectControlGroup.Visual(0);
 // CHuiCanvasVisual* temporaryPresenterLayout = CHuiCanvasVisual::AddNewL( effectControlGroup, &effectControlGroupLayout);
 // create presenter visual and set bindings
 TInt itemsDestroyed(0);
-AddToEffectLayoutContainerL(aHandle, aSourceLayout, NULL, &effectControlGroup, itemsDestroyed, EFalse, aIsExitEffect, aCanDestroyOrHideImmediately);
+AddToEffectLayoutContainerL(aHandle, aSourceLayout, NULL, &effectControlGroup, itemsDestroyed, aIsFullScreenEffect, EFalse, aIsExitEffect, aCanDestroyOrHideImmediately);
 if (aIsExitEffect)
 {
-CHuiCanvasVisual* temporaryPresenterVisual = AddEffectItemL(aHandle, aSourceLayout, &effectControlGroupLayout, &effectControlGroup, ETrue, itemsDestroyed, aIsExitEffect, EFalse);
+CHuiCanvasVisual* temporaryPresenterVisual = AddEffectItemL(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, EFalse, EFalse);
+AddEffectItemL(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)
 // Check if there is an effects engine in HuiEnv
 CHuiFxEffect* effect = NULL;
 CHuiFxEngine* engine = NULL;
 // engine is not owned by us, it is a member of HuiEnv
 engine = iHuiEnv->EffectsEngine();
-if (engine)
+if (engine && aCanvasVisual)
 {
 if (NeedsStoredBuffers(engine, *aEvent.iEffectName))
 {
 RecursiveStoreRenderBufferL(aCanvasVisual);
 }
 // 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, ETrue, EFalse);
+layoutEffectable = SetupEffectLayoutContainerL(aEvent.iHandle, aCanvasVisual, EFalse, ETrue, EFalse);
 }
 else
 {
-layoutEffectable = SetupEffectLayoutContainerL(aEvent.iHandle, aCanvasVisual, EFalse, EFalse);
+layoutEffectable = SetupEffectLayoutContainerL(aEvent.iHandle, aCanvasVisual, EFalse, EFalse, EFalse);
 }
 if (layoutEffectable)
 {
 TInt effectFlags = 0;
 if (sourceViz2 && sourceViz2->Layout())
 {
 sourceViz2->FreeRenderBuffer();
 }
 sourceViz->ClearFlag(EHuiVisualFlagDrawOnlyAsExternalContent);
-TBool hideVisual = sourceViz->Flags() & EHuiVisualFlagShouldBeHidden;
+TBool hideVisual = EFalse;
-TBool showVisual = sourceViz->Flags() & EHuiVisualFlagShouldBeShown;
+TBool showVisual = ETrue;
+if(!aEffectItem.iIsFullScreenEffect)
+{
+hideVisual = (sourceViz->Flags() & EHuiVisualFlagShouldBeHidden) || aEffectItem.iHideWhenFinished;
+showVisual = (sourceViz->Flags() & EHuiVisualFlagShouldBeShown) && !aEffectItem.iHideWhenFinished;
+}
+else
+{
+hideVisual = (sourceViz->Flags() & EHuiVisualFlagShouldBeHidden);
+showVisual = (sourceViz->Flags() & EHuiVisualFlagShouldBeShown);
+}
 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));
 #ifdef  HUI_DEBUG_TRACK_DRAWING
 TInt clientWindowGroupId = FindClientWindowGroupId( aScreen.iScreenNum, indexedGroup );
 TFileName processName = iCommandDebug->WServClientFileName( clientWindowGroupId, CHuiStatic::WsSession() );
 #endif
-if (indexedGroup.Control(0).Role() == EAlfWindowGroupContainer)
+if (indexedGroup.Control(0).Role() == EHuiWindowGroupContainer)
 {
 if (aRoster.ControlGroup(i).ResourceId() == iAlfWindowGroupNodeId)
 {
 #ifdef  HUI_DEBUG_TRACK_DRAWING
 __ALFLOGSTRING2(">> %d WINDOW GROUP (ALF), %d", i, clientWindowGroupId);
 #else
 __ALFLOGSTRING1(">> %d WINDOW GROUP", i);
 #endif
 }
 }
-else if (indexedGroup.Control(0).Role() == EAlfSessionContainer)
+else if (indexedGroup.Control(0).Role() == EHuiSessionContainer)
 {
 #ifdef  HUI_DEBUG_TRACK_DRAWING
 __ALFLOGSTRING2(">> %d ALF GROUP, %d", i, clientWindowGroupId);
 #else
 __ALFLOGSTRING1(">> %d ALF GROUP", i);
 #endif
 }
-else if (indexedGroup.Control(0).Role() == EAlfWindowFloatingSpriteContainer)
+else if (indexedGroup.Control(0).Role() == EHuiWindowFloatingSpriteContainer)
 {
 #ifdef  HUI_DEBUG_TRACK_DRAWING
 __ALFLOGSTRING3(">> %d FLOATING SPRITE GROUP %S, %d", i, &processName, clientWindowGroupId);
 #else
 __ALFLOGSTRING1(">> %d FLOATING SPRITE GROUP", i);
 #endif
 }
-else if (indexedGroup.Control(0).Role() == EAlfFullScreenEffectContainer)
+else if (indexedGroup.Control(0).Role() == EHuiFullScreenEffectContainer)
 {
 #ifdef  HUI_DEBUG_TRACK_DRAWING
 __ALFLOGSTRING3(">> %d EFFECT GROUP %S, %d", i, &processName, clientWindowGroupId );
 #else
 __ALFLOGSTRING1(">> %d EFFECT GROUP", i);
 #endif
 }
-else if (indexedGroup.Control(0).Role() == EAlfFpsIndicatorContainer)
+else if (indexedGroup.Control(0).Role() == EHuiFpsIndicatorContainer)
 {
 #ifdef  HUI_DEBUG_TRACK_DRAWING
 __ALFLOGSTRING3(">> %d FPS GROUP %S, %d", i, &processName, clientWindowGroupId );
 #else
 __ALFLOGSTRING1(">> %d FPS GROUP", i);
 {
 return;
 }
 iSwRenderingEnabled = aEnable;
+AMT_MAP_SET_VALUE(
+iBoolMap,
+AMT_MAP_SW_ENABLED_HANDLE,
+iSwRenderingEnabled,
+EAlfModuleTestTypeBridgeGoom );
 for (TInt i=0; i<iAlfScreens.Count();i++)
 {
 PrepareSwRenderingTarget(iAlfScreens[i]);
 if (iSwRenderingEnabled)
 // ---------------------------------------------------------------------------
 //
 void CAlfBridge::SetLowMemory(TBool aEnabled)
 {
 iLowMemoryMode = aEnabled;
+AMT_MAP_SET_VALUE(
+iBoolMap,
+AMT_MAP_LOW_MEMORY_MODE_HANDLE,
+iLowMemoryMode,
+EAlfModuleTestTypeBridgeGoom );
 DoUpdateMemoryLevel();
 }
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 //
 TInt CAlfBridge::ForceSwRendering(TBool aEnabled)
 {
 iForcedSwRendering = aEnabled;
+AMT_MAP_SET_VALUE(
+iBoolMap,
+AMT_MAP_FORCE_SW_HANDLE,
+iForcedSwRendering,
+EAlfModuleTestTypeBridgeGoom );
 DoUpdateMemoryLevel();
 return KErrNone;
 }
 // ---------------------------------------------------------------------------
 CHuiControlGroup& controlgroup = iAlfScreens[0]->iDisplay->Roster().ControlGroup(j);
 CHuiControl& control = controlgroup.Control(0);
 		__ALFFXLOGSTRING1("CAlfBridge::IsFullScreenDrawn : Group owner 0x%x", controlgroup.SecureId());
-if (control.Role() == EAlfFpsIndicatorContainer)
+if (control.Role() == EHuiFpsIndicatorContainer)
 {
 // FPS container doesn't contain canvas visuals
 continue;
 }
 __ALFFXLOGSTRING4("CAlfBridge::IsFullScreenDrawn (%d,%d)-(%d,%d)", iTempRegion[ii].iTl.iX, iTempRegion[ii].iTl.iY , iTempRegion[ii].iBr.iX, iTempRegion[ii].iBr.iY );
 }
 }
 // Dont mess with alf control group visuals, alf session handling does it for us
-if (control.Role() == EAlfSessionContainer)
+if (control.Role() == EHuiSessionContainer)
 {
 CHuiLayout* hostContainer = control.ContainerLayout( NULL );
 TInt flags = hostContainer->Flags();
 if (alfClientWindowGroupVisible)
 {
 visualIsActive = canvasVisual->iOpacity.Now() > 0.01; // in fact this does not mean that visual should be drawn, but this atleast prevents disabled "on top" windows to be considered as visible.
 // Sprites and effects as we consider them always as transparent and also
 // if controlgroup is transformed somehow
-if (aControl.Role() == EAlfFullScreenEffectContainer
+if (aControl.Role() == EHuiFullScreenEffectContainer
-|| aControl.Role() == EAlfWindowFloatingSpriteContainer ||
+|| aControl.Role() == EHuiWindowFloatingSpriteContainer ||
 aControlGroup.IsTransformed())
 {
 visualIsOpaque = EFalse;
 }
 for (TInt j=screen->iDisplay->Roster().Count() - screen->FixedControlGroupCount(); j>=0; j--)
 {
 CHuiControlGroup& controlgroup = screen->iDisplay->Roster().ControlGroup(j);
 CHuiControl& control = controlgroup.Control(0);
-if (control.Role() == EAlfFpsIndicatorContainer || control.Role() == EAlfSessionContainer)
+if (control.Role() == EHuiFpsIndicatorContainer || control.Role() == EHuiSessionContainer)
 {
 // FPS container doesn't contain canvas visuals and alfsession containers cannot have surfaces
 continue;
 }

branch	RCL_3
changeset 24	f93c875b566e
parent 22	7c5dd702d6d3
child 34	3a60ebea00d0