diff -r 000000000000 -r 15bf7259bb7c uiacceltk/hitchcock/plugins/alftranseffect/alftranseffectplugin/src/alfgfxeffects.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/uiacceltk/hitchcock/plugins/alftranseffect/alftranseffectplugin/src/alfgfxeffects.cpp Tue Feb 02 07:56:43 2010 +0200 @@ -0,0 +1,973 @@ +/* +* Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Alf system effects +* +*/ + + + + +// INCLUDE FILES +#include +#include +#include +#include +#include +#include //RMemReadStream + +#include "alftfxplugincommon.hrh" +#include "alfgfxeffects.h" +#include "alf/alfsrveffectenv.h" +#include "alfstreamerbridge.h" +#include "alfwindowmanager.h" +#include "alfserverdrawer.h" +#include "repositoryhandler.h" +#include "alftfxserverdef.h" +#include "alfpolicyhandler.h" +#include "alflogger.h" + +#include "uiacceltk/HuiDisplay.h" +#include "uiacceltk/HuiLayout.h" +#include "uiacceltk/HuiControlGroup.h" +#include "uiacceltk/HuiControl.h" +#include "uiacceltk/HuiRoster.h" +#include "uiacceltk/HuiCommand.h" +#include "uiacceltk/HuiEnv.h" +#include "uiacceltk/HuiTransformation.h" + +#include "wsserverdrawercontroller.h" + +// Constants +//const TInt KAlfDefaultFocusGainedEffectDuration = 500; +//const TInt KAlfDefaultFocusLostEffectDuration = 500; + +// ============================ MEMBER FUNCTIONS =============================== + + +// ----------------------------------------------------------------------------- +// CAlfGfxEffects::CAlfGfxEffects +// C++ constuctor. +// ----------------------------------------------------------------------------- +// +CAlfGfxEffects::CAlfGfxEffects( ) + { + __ALFFXLOGSTRING("CAlfGfxEffects::CAlfGfxEffects"); + } + + +// ----------------------------------------------------------------------------- +// CAlfGfxEffects::EndExpired +// Timeout for grouped effects, that have not received EndGroup or have received +// EndGroup with non-existing group id. +// ----------------------------------------------------------------------------- +// +void CAlfGfxEffects::EndExpired( ) + { + TInt count; + while((count = iActiveSyncronizedGroups.Count() - 1 ) >= 0) + { + iEngine->EndSyncronizedGroup(iActiveSyncronizedGroups[count], ETrue /* force removal, running effect should be skipped */); + iActiveSyncronizedGroups.Remove(count); + } + __ALFFXLOGSTRING("CAlfGfxEffects::EndExpired - release all syncronized groups"); + } + +// ----------------------------------------------------------------------------- +// CAlfGfxEffects::NewExtensionL +// Two-phased constructor. +// ----------------------------------------------------------------------------- +// +CAlfWindowFxPlugin* CAlfGfxEffects::NewFxPluginL() + { + __ALFFXLOGSTRING("CAlfGfxEffects::NewFxPluginL >>"); + CAlfGfxEffects* self = new(ELeave) CAlfGfxEffects(); +// do not call constructor here, base class constructor gets called later + __ALFFXLOGSTRING("CAlfGfxEffects::NewFxPluginL <<"); + return ( self ); + } + + +// ----------------------------------------------------------------------------- +// CAlfGfxEffects::ConstructL +// +// ----------------------------------------------------------------------------- +// +void CAlfGfxEffects::ConstructL(const CAlfWindowManager& aMgr, TInt aAlfBufferFormat) + { + __ALFFXLOGSTRING("CAlfGfxEffects::ConstructL >>"); + CAlfWindowFxPlugin::ConstructL(aMgr, aAlfBufferFormat); + + // create a policy handler for registering the effect files. + iPolicyHandler = CPolicyHandler::NewL(); + + // create controller and engine + iEngine = CAlfServerDrawer::NewL( CAlfWindowFxPlugin::WindowManager(), *iPolicyHandler ); + iSysDisable = CRepositoryHandler::NewL(EPriorityHigh + KTfxServerRepositoryHandler, + KCRUidThemes, + KThemesTransitionEffects); + + iSyncronizedGroupDefitionEndChecker = CEndCheck::NewL(*this); + __ALFFXLOGSTRING("CAlfGfxEffects::ConstructL <<"); + } + + +// ----------------------------------------------------------------------------- +// CAlfGfxEffects::~CAlfGfxEffects +// C++ destructor. +// ----------------------------------------------------------------------------- +// +CAlfGfxEffects::~CAlfGfxEffects() + { + __ALFFXLOGSTRING("CAlfGfxEffects::~CAlfGfxEffects >>"); + delete iPolicyHandler; + delete iSysDisable; + delete iEngine; + __ALFFXLOGSTRING("CAlfGfxEffects::~CAlfGfxEffects <<"); + } + +// ----------------------------------------------------------------------------- +// +// ----------------------------------------------------------------------------- +// +void CAlfGfxEffects::HandleMessageL( const TDesC8& aInBuf, TPtr8& aOutBuf ) + { + __ALFFXLOGSTRING("CAlfGfxEffects::HandleMessageL >>"); + // synchronous messages are completed by server + + RDesReadStream inStream; + inStream.Open( aInBuf ); + + TInt err = KErrNone; + TInt op = inStream.ReadInt32L(); + TUint action = 0; + TUid uid1( KNullUid ); + TUid uid2( KNullUid ); + HBufC* resourceDir = NULL; + HBufC* fileName = NULL; + HBufC* backgroundFileName = NULL; + TInt wantedTime = 0; + TInt minTime = 0; + + TThreadId clientThreadId( 0 ); + // These are needed to read the 64 bit thread id from the stream + TUint64 id = 0; + TUint8* ptr = reinterpret_cast( &id ); + + CAlfTransitionServerClient::TListBoxType listBoxType = CAlfTransitionServerClient::EListTypeAny; + + TInt value = 0; + TInt error = iSysDisable->GetValue(value); + RMemWriteStream outStream; // for return values + TBool fillOutStream = ETrue; // most functions put the error into outbuffer + + // The engine reservers the windows if needed, it first runs all the checks + // to see if the effects are allowed (effects are not done for some combinations) + + __ALFFXLOGSTRING2("CAlfGfxEffects::HandleMessageL - Operation: %d, Action: %d", op, action ); + __ALFFXLOGSTRING2("CAlfGfxEffects::HandleMessageL - Dir: %S, File: %S", &resourceDir, &fileName ); + switch ( op ) + { + // full screen transitions + case MAlfGfxEffectPlugin::EBeginFullscreen: + if((error != KErrNone) || (value & AknTransEffect::EFullScreenTransitionsOff)) + { + // fullscreen effects are turned off + // Should we return the error in aOutBuf? + // We should not get end full screen if the effect has not been even started + // (could return KErrAbort in aOutBuf) + err = KErrAbort; + break; + } + else + { + action = inStream.ReadUint32L(); +#ifdef _DEBUG + PrintRequestInfo( op, action); +#endif + TRect effectRect( inStream.ReadInt32L(), + inStream.ReadInt32L(), inStream.ReadInt32L(), inStream.ReadInt32L() ); + TInt type = inStream.ReadInt32L(); + // Depending on type, the rest of the parameters have different meaning + uid1 = TUid::Uid( inStream.ReadInt32L() ); + uid2 = TUid::Uid( inStream.ReadInt32L() ); + TInt data = inStream.ReadInt32L(); + iEngine->BeginFullscreen( action, effectRect, type, + uid1, uid2, data ); + } + break; + case MAlfGfxEffectPlugin::EEndFullscreen: +#ifdef _DEBUG + PrintRequestInfo( op, action); +#endif + iEngine->EndFullscreen(); + break; + case MAlfGfxEffectPlugin::EAbortFullscreen: +#ifdef _DEBUG + PrintRequestInfo( op, action); +#endif + + iEngine->AbortFullscreen(); + break; + // component transitions + case MAlfGfxEffectPlugin::EBeginComponentTransition: + if((error != KErrNone) || (value & AknTransEffect::EComponentTransitionsOff)) + { + err = KErrAbort; + break; + } + else + { + // We may not need all of this, but it is here now just to make sure + // we have enough information. + { + action = inStream.ReadUint32L(); +#ifdef _DEBUG + PrintRequestInfo( op, action); +#endif + + uid1 = TUid::Uid( inStream.ReadInt32L() ); + TInt windowGroup = inStream.ReadInt32L(); + TInt windowHandle = inStream.ReadInt32L(); + TBool nLayered = inStream.ReadInt32L(); + uid2 = TUid::Uid( inStream.ReadInt32L() ); // layer type uid + TInt flags = inStream.ReadInt32L(); // hints + iEngine->BeginControlTransition( action, uid1, windowGroup, windowHandle ); + } + break; + } + // These are the effect registrations + case MAlfGfxEffectPlugin::ETfxServerOpAddFullscreenKML: + case MAlfGfxEffectPlugin::ETfxServerOpAddFullscreenKMLEx: + { + action = inStream.ReadUint32L(); +#ifdef _DEBUG + PrintRequestInfo( op, action); +#endif + + uid1 = TUid::Uid( inStream.ReadInt32L() ); + inStream.ReadL( ptr, 8 ); + clientThreadId = id; + resourceDir = HBufC::NewL( inStream, 256 ); + CleanupStack::PushL( resourceDir ); + fileName = HBufC::NewL( inStream, 256 ); + CleanupStack::PushL( fileName ); + // If the operation is ETfxServerOpAddFullscreenKMLEx, there are some more parameters + TInt cachePriority = -1; + wantedTime = -1; + minTime = -1; + if ( op == ETfxServerOpAddFullscreenKMLEx ) + { + cachePriority = inStream.ReadInt32L(); + wantedTime = inStream.ReadInt32L(); + minTime = inStream.ReadInt32L(); + } + err = VerifyResourceLocation( resourceDir->Des() ); + /* + // Needed to be able to see the filename in carbide + TPtrC filePtr = fileName->Des(); + RDebug::Print(_L("register file %S"), &filePtr ); + */ + if ( err == KErrNone ) + { + // register the effect definition file + if ( uid1.iUid != KAlfAppServerInterfaceUid3 ) + { + TRAP( err, iPolicyHandler->RegisterFullscreenKmlL( + action, uid1, clientThreadId, *resourceDir, *fileName, + cachePriority, wantedTime, minTime) ); + iEngine->RegisterAlfFullScreenEffect( action, resourceDir->Des(), fileName->Des() ); + } + else + { + // effects for KAlfAppServerInterfaceUid3 go directly to Alf Bridge + iEngine->RegisterAlfFullScreenEffect( action, resourceDir->Des(), fileName->Des() ); + } + } + + CleanupStack::PopAndDestroy( fileName ); + CleanupStack::PopAndDestroy( resourceDir ); + break; + } + case MAlfGfxEffectPlugin::ETfxServerOpRemoveFullscreenKML: + action = inStream.ReadUint32L(); + uid1 = TUid::Uid( inStream.ReadInt32L() ); + // We don't keep the registration status the files that go directly to alf + if ( uid1.iUid != KAlfAppServerInterfaceUid3 ) + { + err = iPolicyHandler->UnregisterFullscreenKml( action, uid1 ); + } + else + { + // effects for KAlfAppServerInterfaceUid3 go directly to Alf Bridge + } + iEngine->UnregisterAlfFullScreenEffect( action ); + break; + case MAlfGfxEffectPlugin::ETfxServerOpListBoxRegisterKML: + uid1 = TUid::Uid( inStream.ReadInt32L() ); + inStream.ReadL( ptr, 8 ); + clientThreadId = id; + listBoxType = (CAlfTransitionServerClient::TListBoxType) inStream.ReadInt32L(); + resourceDir = HBufC::NewL( inStream, 256 ); + CleanupStack::PushL( resourceDir ); + backgroundFileName = HBufC::NewL( inStream, 256 ); + CleanupStack::PushL( backgroundFileName ); + fileName = HBufC::NewL( inStream, 256 ); + CleanupStack::PushL( fileName ); + err = VerifyResourceLocation( resourceDir->Des() ); + if ( err == KErrNone ) + { + iPolicyHandler->RegisterListBoxKmlL( uid1, clientThreadId, listBoxType, + *resourceDir, *backgroundFileName, *fileName ); + } + CleanupStack::PopAndDestroy( fileName ); + CleanupStack::PopAndDestroy( backgroundFileName ); + CleanupStack::PopAndDestroy( resourceDir ); + break; + case MAlfGfxEffectPlugin::ETfxServerOpListBoxUnregisterKML: + uid1 = TUid::Uid( inStream.ReadInt32L() ); + listBoxType = (CAlfTransitionServerClient::TListBoxType) inStream.ReadInt32L(); + err = iPolicyHandler->UnregisterListBoxKml( uid1, listBoxType ); + break; + case MAlfGfxEffectPlugin::ETfxServerOpListBoxSetFrameTime: + iListBoxFrameTime = inStream.ReadInt32L(); + // this must be sent forward somewhere (list controller?) + break; + case MAlfGfxEffectPlugin::ETfxServerOpListBoxSetMinFrameTime: + iListBoxMinFrameTime = inStream.ReadInt32L(); + // this must be sent forward somewhere (list controller?) + break; + case MAlfGfxEffectPlugin::ETfxServerOpControlSetFrameTime: + iControlFrameTime = inStream.ReadInt32L(); + // this must be sent forward somewhere (list controller?) + break; + case MAlfGfxEffectPlugin::ETfxServerOpControlSetMinFrameTime: + iControlMinFrameTime = inStream.ReadInt32L(); + // this must be sent forward somewhere (list controller?) + break; + case MAlfGfxEffectPlugin::ETfxServerOpBlockFullscreenUid: + { + uid1 = TUid::Uid( inStream.ReadInt32L() ); + TBool blockFrom = inStream.ReadInt32L(); + TBool blockTo = inStream.ReadInt32L(); + err = iPolicyHandler->BlockFullScreenUid( uid1, blockFrom, blockTo ); + break; + } + case MAlfGfxEffectPlugin::ETfxServerOpControlPolicyUpdate: + { + uid1 = TUid::Uid( inStream.ReadInt32L() ); + TUint actionId = inStream.ReadUint32L(); + HBufC* actionString = HBufC::NewL( inStream, 256 ); + CleanupStack::PushL( actionString ); + iPolicyHandler->RegisterControlAction( uid1, actionId, *actionString ); + CleanupStack::PopAndDestroy( actionString ); + break; + } + case MAlfGfxEffectPlugin::ETfxServerOpControlPolicyRemove: + { + uid1 = TUid::Uid( inStream.ReadInt32L() ); + TUint actionId = inStream.ReadUint32L(); + iPolicyHandler->UnregisterControlAction( uid1, actionId ); + break; + } + case MAlfGfxEffectPlugin::ETfxServerOpRegisterControlKml: + case MAlfGfxEffectPlugin::ETfxServerOpRegisterControlKmlEx: + uid1 = TUid::Uid( inStream.ReadInt32L() ); + inStream.ReadL( ptr, 8 ); + clientThreadId = id; + resourceDir = HBufC::NewL( inStream, 256 ); + CleanupStack::PushL( resourceDir ); + fileName = HBufC::NewL( inStream, 256 ); + CleanupStack::PushL( fileName ); + // If the operation is ETfxServerOpRegisterControlKmlEx, there are some more parameters + wantedTime = -1; + minTime = -1; + if ( op == ETfxServerOpRegisterControlKmlEx ) + { + wantedTime = inStream.ReadInt32L(); + minTime = inStream.ReadInt32L(); + } + err = VerifyResourceLocation( resourceDir->Des() ); + if ( err == KErrNone ) + { + // register the effect definition file + TRAP( err, iPolicyHandler->RegisterControlKmlL( + uid1, clientThreadId, *resourceDir, *fileName, + wantedTime, minTime) ); + iEngine->RegisterAlfFullScreenEffect( action, resourceDir->Des(), fileName->Des() ); + } + CleanupStack::PopAndDestroy( fileName ); + CleanupStack::PopAndDestroy( resourceDir ); + break; + case MAlfGfxEffectPlugin::ETfxServerOpRemoveAllKml: + inStream.ReadL( ptr, 8 ); + clientThreadId = id; + if ( uid1.iUid != KAlfAppServerInterfaceUid3 ) + { + err = iPolicyHandler->UnregisterAllKml( clientThreadId ); + } + else + { + // effects for KAlfAppServerInterfaceUid3 go directly to Alf Bridge + } + iEngine->UnregisterAllAlfFullScreenEffect( ); + break; + case MAlfGfxEffectPlugin::ETfxServerOpRemoveControlKml: + uid1 = TUid::Uid( inStream.ReadInt32L() ); + err = iPolicyHandler->RemoveControlKml( uid1 ); + break; + case MAlfGfxEffectPlugin::ETfxServerOpSetWantedTime: + iTransitionTime = inStream.ReadInt32L(); + break; + case MAlfGfxEffectPlugin::ETfxServerOpSetMinTime: + iTransitionMinTime = inStream.ReadInt32L(); + break; + case MAlfGfxEffectPlugin::ETfxServerVerifyConnection: + // If we get this far, it should prove that we have a good connection + break; + case MAlfGfxEffectPlugin::ETfxServerOpFreeRam: + // here we should return something + break; + case MAlfGfxEffectPlugin::ETfxServerOpMemoryGood: + // here we should return something + break; + case MAlfGfxEffectPlugin::ETfxServerOpControlPolicyGet: + // get the policy structures from the policy handler + // client id (we don't get the whole message because this is asynchronous + + // We fill the outbuffer with policies, do not add an error afterwards + { + + fillOutStream = EFalse; + inStream.ReadL( ptr, 8 ); + clientThreadId = id; + // number of policy structures the return buffer can hold + TInt count = inStream.ReadInt32L(); + iPolicyHandler->GetPolicyL( clientThreadId, count, aOutBuf ); + break; + } + case MAlfGfxEffectPlugin::ETfxServerOpControlCancelPolicyUpdate: + // cancel any pending policy requests + inStream.ReadL( ptr, 8 ); + clientThreadId = id; + iPolicyHandler->RemoveClient( clientThreadId ); + break; + + case MAlfGfxEffectPlugin::ETfxServerOpBeginGroup: + { + TInt groupId= inStream.ReadUint32L(); + iEngine->BeginSyncronizedGroup(groupId); + iActiveSyncronizedGroups.Append(groupId); + iSyncronizedGroupDefitionEndChecker->Start(4); + break; + } + + case MAlfGfxEffectPlugin::ETfxServerOpEndGroup: + { + // if all groups have been released, then we can kill the timer. + if (iActiveSyncronizedGroups.Count() - 1 == 0) + { + iSyncronizedGroupDefitionEndChecker->Cancel(); + } + TInt groupId= inStream.ReadUint32L(); + TInt index = iActiveSyncronizedGroups.Find(groupId); + if (index!=KErrNotFound) + { + iEngine->EndSyncronizedGroup(groupId); + iActiveSyncronizedGroups.Remove(index); + } + if (iActiveSyncronizedGroups.Count()) + { + // if there is still groups out there not closed, then this will create timeout for them + iSyncronizedGroupDefitionEndChecker->Start(4); + } + break; + } + + default: + break; + } + + inStream.Release(); + inStream.Close(); + + if ( aOutBuf.MaxSize() >= sizeof(TInt32) && fillOutStream ) + { + // The write will not leave as we have checked the length of the buffer beforeahdn + unsigned char buffer[sizeof(TInt32)]; + outStream.Open( buffer, sizeof(TInt32) ); + outStream.WriteInt32L( err ); + outStream.CommitL(); + outStream.Release(); + outStream.Close(); + aOutBuf.Copy( &buffer[0], sizeof(TInt32) ); + } + __ALFFXLOGSTRING("CAlfGfxEffects::HandleMessageL <<"); + } + +// ----------------------------------------------------------------------------- +// +// ----------------------------------------------------------------------------- +// +void CAlfGfxEffects::HandleMessageL( const TDesC8& aInBuf, const RMessage2& aClientMessage ) + { + // make sure that there are no pending asynch calls left here + __ALFFXLOGSTRING1("CAlfGfxEffects::HandleMessageL - : %S", &aInBuf ); + RDesReadStream inStream; + inStream.Open( aInBuf ); + + TInt op = inStream.ReadInt32L(); + inStream.Release(); + inStream.Close(); + switch ( op ) + { + case MAlfGfxEffectPlugin::ETfxServerOpControlPolicyRequest: + // This message is completed when a new policy exists. + // All clients get the same policies + User::LeaveIfError( iPolicyHandler->RequestPolicy( aClientMessage ) ); + break; + default: + break; + } + __ALFFXLOGSTRING("CAlfGfxEffects::HandleMessageL <<"); + } + +// ----------------------------------------------------------------------------- +// +// ----------------------------------------------------------------------------- +// +void CAlfGfxEffects::CancelMessage(TInt /*aMessageId*/) + { + __ALFFXLOGSTRING("CAlfGfxEffects::CancelMessage - not implemented"); + // default implementation does not have pending messages + } + +// ----------------------------------------------------------------------------- +// +// ----------------------------------------------------------------------------- +// +void CAlfGfxEffects::PrepareFrameL(TUint /*aEstimatedFrameInterval*/) + { + // __ALFFXLOGSTRING("CAlfGfxEffects::PrepareFrameL - not implemented"); + // not implemented + } + +// ----------------------------------------------------------------------------- +// +// ----------------------------------------------------------------------------- +// +void CAlfGfxEffects::WindowUpdated(TInt /*aWindowId*/, TInt /*aEventType*/) + { + __ALFFXLOGSTRING("CAlfGfxEffects::WindowUpdated - not implemented"); + // not implemented + } + +// ----------------------------------------------------------------------------- +// CAlfGfxEffects::GetSupportedEffects +// ----------------------------------------------------------------------------- +// +TInt CAlfGfxEffects::GetSupportedEffects( RArray& /*aSupportedEffectIds*/ ) + { + /* + // Add effect ids which are supported by this plugin + aSupportedEffectIds.Append( MAlfTransEffectPlugin::EContextFocusGained ); + aSupportedEffectIds.Append( MAlfTransEffectPlugin::EContextFocusLost ); + aSupportedEffectIds.Append( MAlfTransEffectPlugin::EContextEmbeddedStart ); + aSupportedEffectIds.Append( MAlfTransEffectPlugin::EContextEmbeddedExit ); + */ + __ALFFXLOGSTRING("CAlfGfxEffects::GetSupportedEffects"); + return KErrNone; + } + + +// ----------------------------------------------------------------------------- +// CAlfGfxEffects::StartPhase +// ----------------------------------------------------------------------------- +// +TInt CAlfGfxEffects::StartPhase( TInt /*aPhaseId*/, TInt /*aEffectId*/, + CAlfSrvEffectEnv& /*aEffectEnv*/, const TDesC8* /*aParams*/ ) + { + /* + TRAP_IGNORE( DoStartPhaseL( aPhaseId, aEffectId, aEffectEnv, aParams )); + */ + __ALFFXLOGSTRING("CAlfGfxEffects::StartPhase"); + return KErrNone; + } + + +// ----------------------------------------------------------------------------- +// CAlfGfxEffects::DoStartPhaseL +// ----------------------------------------------------------------------------- +// +TInt CAlfGfxEffects::DoStartPhaseL( TInt /*aPhaseId*/, TInt /*aEffectId*/, + CAlfSrvEffectEnv& /*aEffectEnv*/, const TDesC8* /*aParams*/ ) + { + __ALFFXLOGSTRING("CAlfGfxEffects::DoStartPhaseL >>"); +/* + // Start effect here! + switch (aEffectId) + { + case MAlfTransEffectPlugin::EContextFocusGained: + { + ShowVisibleGroupsAndMakeNonTransparentL( aEffectEnv ); + break; + } + + case MAlfTransEffectPlugin::EContextFocusLost: + { + HideGroupsAndMakeTransparentL( aEffectEnv ); + break; + } + + case MAlfTransEffectPlugin::EContextEmbeddedStart: + { + // do a normal show + ShowVisibleGroupsAndMakeNonTransparentL( aEffectEnv ); + + // in addition, do a expand effect for the visible groups + TInt controlGroupCount = aEffectEnv.VisibleControlGroupCountL(); + for ( TInt g = 0 ; g < controlGroupCount ; g++ ) + { + CHuiControlGroup* group = aEffectEnv.VisibleControlGroupL(g); + if (group) + { + // Perhaps we should show controlgroup in other displays too...? + CHuiDisplay* defaultDisplay = aEffectEnv.DisplayL(0); + if (defaultDisplay) + { + CHuiLayout* hostContainer = group->Control(0).ContainerLayout( NULL ); + + // Cancel the previous 'disable transformation' commands. + aEffectEnv.SharedEnv()->CancelCommands( hostContainer, EHuiOpDisableTransformation ); + + hostContainer->EnableTransformationL(); + CHuiTransformation& xf = hostContainer->Transformation(); + + THuiTimedValue scale(0); + scale.Set(1, KAlfDefaultFocusGainedEffectDuration); + + // Clear previously created transformation steps. + xf.LoadIdentity(); + + xf.Scale(scale,scale); + + // Disable transformations after effect + THuiVisualCommand disableTransformationCommand( *hostContainer, EHuiOpDisableTransformation ); + aEffectEnv.SharedEnv()->Send( disableTransformationCommand, KAlfDefaultFocusGainedEffectDuration ); + } + } + } + break; + } + case MAlfTransEffectPlugin::EContextEmbeddedExit: + { + // do normal hide + HideGroupsAndMakeTransparentL( aEffectEnv ); + + // in addition, do a shrink effect for the visible groups + TInt controlGroupCount = aEffectEnv.VisibleControlGroupCountL(); + for ( TInt g = 0 ; g < controlGroupCount ; g++ ) + { + CHuiControlGroup* group = aEffectEnv.VisibleControlGroupL(g); + if (group) + { + // Perhaps we should show controlgroup in other displays too...? + CHuiDisplay* defaultDisplay = aEffectEnv.DisplayL(0); + if (defaultDisplay) + { + // Do a little pop out effect + CHuiLayout* hostContainer = group->Control(0).ContainerLayout( NULL ); + + // Cancel the previous 'disable transformation' commands. + aEffectEnv.SharedEnv()->CancelCommands( hostContainer, EHuiOpDisableTransformation ); + + hostContainer->EnableTransformationL(); + CHuiTransformation& xf = hostContainer->Transformation(); + + THuiTimedValue scale(1); + scale.Set(0, KAlfDefaultFocusLostEffectDuration); + + // Clear previously created transformation steps. + xf.LoadIdentity(); + + xf.Scale(scale,scale); + + // Disable transformations after effect + THuiVisualCommand disableTransformationCommand( *hostContainer, EHuiOpDisableTransformation ); + aEffectEnv.SharedEnv()->Send( disableTransformationCommand, KAlfDefaultFocusLostEffectDuration ); + } + } + } + break; + } + default: + { + + break; + } + } +*/ + __ALFFXLOGSTRING("CAlfGfxEffects::DoStartPhaseL <<"); + return KErrNone; + }; + +void CAlfGfxEffects::ShowVisibleGroupsAndMakeNonTransparentL(CAlfSrvEffectEnv& /*aEffectEnv*/) + { + __ALFFXLOGSTRING("CAlfGfxEffects::ShowVisibleGroupsAndMakeNonTransparentL >>"); + // Set opacity of every control group to 1, even if it is not shown because + // application may want to show it later and it cannot control the + // opacity. +/* + TInt controlGroupCount = aEffectEnv.ControlGroupCountL(); + for ( TInt g = 0 ; g < controlGroupCount ; g++ ) + { + CHuiControlGroup* group = aEffectEnv.ControlGroupL(g); + if (group) + { + // Perhaps we should show controlgroup in other displays too...? + CHuiDisplay* defaultDisplay = aEffectEnv.DisplayL(0); + if (defaultDisplay) + { + // Set the root visual opacity to 1 which affects all the visuals in the group + CHuiLayout* hostContainer = group->Control(0).ContainerLayout( NULL ); + hostContainer->iOpacity.Set(1.f, KAlfDefaultFocusGainedEffectDuration); + + // Disable also previous transformations. + hostContainer->EnableTransformationL(EFalse); + } + } + } + + // Check how many control groups are shown (set visible by the application) + + // todo: the visible control group should be shown in the same order as they were + // set into the roster originally. + TInt visibleControlGroupCount = aEffectEnv.VisibleControlGroupCountL(); + for ( TInt g = 0 ; g < visibleControlGroupCount ; g++ ) + { + CHuiControlGroup* group = aEffectEnv.VisibleControlGroupL(g); + if (group) + { + CHuiDisplay* defaultDisplay = aEffectEnv.DisplayL(0); + if (defaultDisplay) + { + // Cancel the previous hide commands. + aEffectEnv.SharedEnv()->CancelCommands( group, EHuiOpHide ); + + // Show control group ! + defaultDisplay->Roster().ShowL(*group); + } + } + } +*/ + __ALFFXLOGSTRING("CAlfGfxEffects::ShowVisibleGroupsAndMakeNonTransparentL <<"); + } + +void CAlfGfxEffects::HideGroupsAndMakeTransparentL(CAlfSrvEffectEnv& /*aEffectEnv*/) + { + __ALFFXLOGSTRING("CAlfGfxEffects::HideGroupsAndMakeTransparentL >>"); +/* + TInt controlGroupCount = aEffectEnv.ControlGroupCountL(); + for ( TInt g = 0 ; g < controlGroupCount ; g++ ) + { + CHuiControlGroup* group = aEffectEnv.ControlGroupL(g); + if (group) + { + // Perhaps we should show controlgroup in other displays too...? + CHuiDisplay* defaultDisplay = aEffectEnv.DisplayL(0); + if (defaultDisplay) + { + // Set the root visual opacity to 0 which affects all the visuals in the group + CHuiLayout* hostContainer = group->Control(0).ContainerLayout( NULL ); + hostContainer->iOpacity.Set(0.f, KAlfDefaultFocusGainedEffectDuration); + + if (defaultDisplay->DisplayType() != CHuiDisplay::EDisplayOffScreenBuffer) + { + // Hide the group so that it does not use resources when we dont have focus + THuiGroupCommand command( *group, EHuiOpHide, defaultDisplay ); + aEffectEnv.SharedEnv()->Send(command, KAlfDefaultFocusLostEffectDuration); + } + } + } + } +*/ + __ALFFXLOGSTRING("CAlfGfxEffects::HideGroupsAndMakeTransparentL <<"); + } + +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// +TInt CAlfGfxEffects::VerifyResourceLocation(const TDesC& aResourceDir) + { + __ALFFXLOGSTRING("CAlfGfxEffects::VerifyResourceLocation >>"); + // For starters anything goes (we want to be able to test effect files on C drive if needed) + if (aResourceDir.Length() > 1) + { + __ALFFXLOGSTRING("CAlfGfxEffects::VerifyResourceLocation - return KErrNone"); + return KErrNone; + } +/* + if(aResourceDir.Length() > 1 && + (aResourceDir[0] == 'Z' || aResourceDir[0] == 'z') ) + { + return KErrNone; + } +*/ + __ALFFXLOGSTRING("CAlfGfxEffects::VerifyResourceLocation - return KErrNotSupported <<"); + return KErrNotSupported; + } +#ifdef _DEBUG +void CAlfGfxEffects::PrintRequestInfo(TInt aOperation, TInt aAction ) + { + HBufC16* buffer = HBufC16::NewL(256); + TPtr debugText = buffer->Des(); + debugText.Format( _L("Effect request: Operation ")); + + switch(aOperation) + { + case MAlfGfxEffectPlugin::EBeginFullscreen: + { + debugText.AppendFormat(_L("EBeginFullscreen")); + break; + } + case MAlfGfxEffectPlugin::EEndFullscreen: + { + debugText.AppendFormat(_L("EEndFullscreen")); + break; + } + case MAlfGfxEffectPlugin::EAbortFullscreen: + { + debugText.AppendFormat(_L("EAbortFullscreen")); + break; + } + case MAlfGfxEffectPlugin::EBeginComponentTransition: + { + debugText.AppendFormat(_L("EBeginComponentTransition")); + break; + } + case MAlfGfxEffectPlugin::EAbortComponentTransition: + { + debugText.AppendFormat(_L("EAbortComponentTransition")); + break; + } + case MAlfGfxEffectPlugin::ERegisterFullScreenEffectFile: + { + debugText.AppendFormat(_L("ERegisterFullScreenEffectFile")); + break; + } + case MAlfGfxEffectPlugin::EUnregisterFullScreenEffectFile: + { + debugText.AppendFormat(_L("EUnregisterFullScreenEffectFile")); + break; + } + case MAlfGfxEffectPlugin::EBlockFullScreenUid: + { + debugText.AppendFormat(_L("EBlockFullScreenUid")); + break; + } + case MAlfGfxEffectPlugin::EUnregisterAllEffects: + { + debugText.AppendFormat(_L("EUnregisterAllEffects")); + break; + } + } + + debugText.Format( _L(", Action: ")); + + switch(aAction) + { + case AknTransEffect::ENone: + { + debugText.AppendFormat(_L("ENone")); + break; + } + case AknTransEffect::EApplicationActivate: + { + debugText.AppendFormat(_L("EApplicationActivate")); + break; + } + case AknTransEffect::EApplicationStart: + { + debugText.AppendFormat(_L("EApplicationStart")); + break; + } + case AknTransEffect::EEmbeddedApplicationStart: + { + debugText.AppendFormat(_L("EEmbeddedApplicationStart")); + break; + } + case AknTransEffect::EApplicationExit: + { + debugText.AppendFormat(_L("EApplicationExit")); + break; + } + case AknTransEffect::EApplicationStartRect: + { + debugText.AppendFormat(_L("EApplicationStartRect")); + break; + } + case AknTransEffect::EApplicationStartSwitch: + { + debugText.AppendFormat(_L("EApplicationStartSwitch")); + break; + } + case AknTransEffect::EApplicationStartSwitchRect: + { + debugText.AppendFormat(_L("EApplicationStartSwitch")); + break; + } + case AknTransEffect::EEmbeddedApplicationExit: + { + debugText.AppendFormat(_L("EEmbeddedApplicationExit")); + break; + } + case AknTransEffect::EAppStartComplete: +#ifdef RD_UI_TRANSITION_EFFECTS_LAYOUT_SWITCH + { + debugText.AppendFormat(_L("EAppStartComplete")); + break; + } + case AknTransEffect::ELayoutSwitch: // default : swap to portrait. + { + debugText.AppendFormat(_L("ELayoutSwitch")); + break; + } + case AknTransEffect::ELayoutSwitchExit: + { + debugText.AppendFormat(_L("ELayoutSwitchExit")); + break; + } + case AknTransEffect::ELayoutSwitchStart: +#endif //RD_UI_TRANSITION_EFFECTS_LAYOUT_SWITCH + case AknTransEffect::EAppSpesificEvent: + { + debugText.AppendFormat(_L("ELayoutSwitchStart")); + break; + } + case AknTransEffect::EAppStartupBackground: + { + debugText.AppendFormat(_L("EAppStartupBackground")); + break; + } + default: + { + debugText.AppendFormat(_L("UNKNOWN")); + break; + } + } + + __ALFFXLOGSTRING1("CAlfGfxEffects::PrintInfo %S", &debugText); + delete buffer; + } +#endif +// End of File