diff -r 000000000000 -r 15bf7259bb7c uiacceltk/hitchcock/plugins/alftranseffect/alfgfxtransadapter/src/gfxtransenginetfx.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/uiacceltk/hitchcock/plugins/alftranseffect/alfgfxtransadapter/src/gfxtransenginetfx.cpp Tue Feb 02 07:56:43 2010 +0200 @@ -0,0 +1,1440 @@ +/* +* 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: Adapter to the GfxTransEffect client. This is the entry point into +* the Nokia specific parts of the KML transition sollution, from the +* GfxTransEffect client. +* +*/ + + + +#include //RMemReadStream +#include +#include + +#include +#include +#include +#include +#include // list box types +#include +#include +#include +#include + +#include "gfxtransenginetfx.h" +#include "e32property.h" +//#include "wstranscontrolgraphic.h" +//#include "wsadaptergraphic.h" + +//#include "tfxserverdef.h" +//#include "subwocon.h" + +#include + +#include +#include +#include + +//maximum number of ongoing component effects +//No restrictions at the moment. Anything goes. +//const TInt KMaxOngoing = 10; + +enum TNoteSequenceState + { + ENoSequence = 0, + EFirst = 1, + EMid = 2, + ELast = 3 + }; + +// ======== LOCAL CLASS ======== + +NONSHARABLE_CLASS(CTransControlDrawerInfo) : public CBase + { + CTransControlDrawerInfo(TInt aHandle); +public: + static CTransControlDrawerInfo* NewL(TInt aHandle, TRect& aRect); + ~CTransControlDrawerInfo(); + inline TInt Handle(); + inline CWsTransControlGraphic* Drawer(); + void DeleteDrawer(); + void SetHasWOParticipants(TBool aHasWOParticipant); + TBool HasWOParticipants(); +private: + TInt iHandle; + TBool iHasWOParticipant; +// CWsTransControlGraphic* iDrawer; + }; + +CTransControlDrawerInfo::CTransControlDrawerInfo(TInt aHandle) : + iHandle(aHandle) + { + } + +CTransControlDrawerInfo* CTransControlDrawerInfo::NewL(TInt aHandle, TRect& /*aRect*/) + { + RThread t; //To get id of current thread to use as client handle. + CTransControlDrawerInfo* self = new (ELeave) CTransControlDrawerInfo(aHandle); + CleanupStack::PushL(self); +// self->iDrawer = CWsTransControlGraphic::NewL(aRect, aHandle, t.Id()); + CleanupStack::Pop(self); + return self; + } + +void CTransControlDrawerInfo::SetHasWOParticipants(TBool aHasWOParticipant) + { + iHasWOParticipant = aHasWOParticipant; + } + +TBool CTransControlDrawerInfo::HasWOParticipants() + { + return iHasWOParticipant; + } + +CTransControlDrawerInfo::~CTransControlDrawerInfo() + { +// delete iDrawer; + } + +void CTransControlDrawerInfo::DeleteDrawer() + { +// delete iDrawer; +// iDrawer = NULL; + } + +//Inline functions kept here, since they are only used within this file + +inline TInt CTransControlDrawerInfo::Handle() + { + return iHandle; + } + +/* +inline CWsTransControlGraphic* CTransControlDrawerInfo::Drawer() + { + return iDrawer; + } +*/ + +/** + * Helper class, handles requests to the transition plugin + */ +NONSHARABLE_CLASS(CAlfTransitionRequest): public CActive +{ +public: + enum TType + { + ETransFinish, + EPolicyUpdate + }; + + CAlfTransitionRequest(CGfxTransAdapterTfx* aParent, MTfxServerObserver* aOwner, TType aType); + ~CAlfTransitionRequest(); + + void IssueReq(); + inline TType Type(); +private: + void RunL(); + void DoCancel(); + TInt RunError(TInt aError); + + MTfxServerObserver* iOwner; + CGfxTransAdapterTfx* iParent; + TType iType; + +}; + +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// +CAlfTransitionRequest::CAlfTransitionRequest(CGfxTransAdapterTfx* aParent, MTfxServerObserver* aOwner, TType aType) : + CActive(CActive::EPriorityHigh), + iOwner(aOwner), + iParent(aParent), + iType(aType) + { + CActiveScheduler::Add(this); + } + +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// +CAlfTransitionRequest::~CAlfTransitionRequest() + { + __ALFFXLOGSTRING("CAlfTransitionRequest - cancelling and deleting policy request" ); + Cancel(); + } + +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// +void CAlfTransitionRequest::RunL() + { + if ( iStatus.Int() == KErrCancel ) + { + // If the request was cancelled, we are done + __ALFFXLOGSTRING("CAlfTransitionRequest: Policy request cancelled" ); + return; + } + + switch( iType ) + { +/* +// not supported at the time being - all transaction finishing is handled in alf + case ETransFinish: + iOwner->TransitionFinished(iStatus.Int()); + __ALFFXLOGSTRING1("Client::CActive.iOwner->TransitionFinished status = %d", iStatus.Int()); + break; +*/ + case EPolicyUpdate: + { +#ifdef _DEBUG + RThread me; + TInt ap = me.Id(); + me.Close(); + __ALFFXLOGSTRING2("CAlfTransitionRequest: Policy received. Cli: %d, status %d",ap,iStatus.Int()); +#endif + User::LeaveIfError( iStatus.Int() ); + iParent->GetNewPoliciesL( iStatus.Int() ); + User::LeaveIfError( iParent->RequestPolicyUpdates() ); + } + break; + default: + break; + } + } + +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// +TInt CAlfTransitionRequest::RunError(TInt aError) + { + //The idea here is that on failure (wich should be OOM), we clear all our policies + //clientside. + //We must also inform server of this, so it can resend all policies the next time we request. + //Next time a transition is tried, policies will be re-requested. +#ifdef _DEBUG + RThread me; + TInt meid = me.Id(); + TInt tmp = aError; //remove warning when debug prints and turned off + aError = tmp; + __ALFFXLOGSTRING2("--->> Policy error <<--. Cli: %d, status: %d",meid,aError); + me.Close(); +#endif + + iOwner->ClearAllPolicies(); //clear all policies clientside + iParent->CancelPolicyUpdates(); //cancel requests on server. + + return 0; + } + +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// +void CAlfTransitionRequest::DoCancel() + { + //nothing to do here. requests are cancelled elsewhere. + } + +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// +void CAlfTransitionRequest::IssueReq() + { + SetActive(); + } + +// --------------------------------------------------------------------------- +// We keep it here, even though its inline, since it is never used outside this +// file anyway. +// The idea with .inl files is to keep the header file clean. +// --------------------------------------------------------------------------- +// +inline CAlfTransitionRequest::TType CAlfTransitionRequest::Type() + { + return iType; + } + + +// ======== MEMBER FUNCTIONS ======== + +CGfxTransAdapterTfx::CGfxTransAdapterTfx(MGfxTransClient* aClient) : + iClient(aClient), + iConnected(EFalse), + iHasPlugin(EFalse) + { + } + +CGfxTransAdapterTfx::~CGfxTransAdapterTfx() + { + + __ALFFXLOGSTRING("CGfxTransAdapterTfx for HWA transitionn effects, destructor "); +// iIgnoredWOChildControls.Close(); + //iControlInfo.ResetAndDestroy(); + if ( iConnected ) + { + if ( iHasPlugin ) + { + __ALFFXLOGSTRING("CGfxTransAdapterTfx, canceling policy updates in destructor "); + CancelPolicyUpdates(); + // should we wait here until the cancellation has returned? + __ALFFXLOGSTRING("CGfxTransAdapterTfx, unloading plugin "); + iTfxServer.UnloadTfxPlugin( iPluginImplementation ); + } + } + delete iPolicyReq; + iTfxServer.Close(); + iConnected = EFalse; + iHasPlugin = EFalse; + delete iTransferBuffer; + delete iReturnBuffer; + delete iAsyncTransferBuffer; + delete iAsyncReturnBuffer; + } + +void CGfxTransAdapterTfx::ConstructL() + { + + __ALFFXLOGSTRING("CGfxTransAdapterTfx for HWA transitionn effects, ConstructL"); + + RThread me; + iClientId = me.Id(); + me.Close(); + + iPluginImplementation = TUid::Null(); + ConnectToServer(); + + // We need to save various 32 bit integers. The exact number depends on the function. + // We reserve a bit extra here, should check if the size is big enough for all cases. + iTransferBuffer = HBufC8::NewL( 25 * sizeof(TInt32) ); + // If we get return values, we'll need a bigger buffer + iReturnBuffer = HBufC8::NewL( sizeof( TInt ) ); + + // We need to save various 32 bit integers. The exact number depends on the function. + // We reserve a bit extra here, should check if the size is big enough for all cases. + iAsyncTransferBuffer = HBufC8::NewL( 25 * sizeof(TInt32) ); + // If we get return values, we'll need a bigger buffer + iAsyncReturnBuffer = HBufC8::NewL( sizeof( TInt ) ); + + iPolicyReq = new( ELeave )CAlfTransitionRequest(this, + this, + CAlfTransitionRequest::EPolicyUpdate); + + } + +void CGfxTransAdapterTfx::ConnectToServer() + { + // We need to resolve the plugin id for starters, + // use default parameters, we take the first one we find. + + TInt err = KErrNone; + + if ( !iConnected ) + { + err = iTfxServer.Open(); + if ( err == KErrNone ) + { + iConnected = ETrue; + } + else + { + // could not connect to server - cannot continue. + return; + } + } + + if ( iHasPlugin ) + { + // already connected + return; + } + + if ( iPluginImplementation == TUid::Null()) + { + RImplInfoPtrArray pluginArray; + TRAP( err, REComSession::ListImplementationsL( KAlfGfxPluginInterfaceUId, pluginArray ) ); + + if ( pluginArray.Count() > 0 ) + { + iPluginImplementation = pluginArray[0]->ImplementationUid(); + } + // Clear the data in plugin array, it is not going to be used any more. + TInt i = 0; + for ( i = pluginArray.Count() - 1; i >= 0; i-- ) + { + // destroy + delete pluginArray[i]; + pluginArray.Remove( i ); + } + pluginArray.Close(); + } + + if ( err == KErrNone && iPluginImplementation != TUid::Null() ) + { + err = iTfxServer.LoadTfxPlugin( iPluginImplementation ); + if ( err == KErrNone || err == KErrAlreadyExists ) + { + // We have successfully loaded the plugin and saved + // the implementation uid to be used later. + iHasPlugin = ETrue; + __ALFFXLOGSTRING("HWA TransEffect Plugin loaded"); + } + } + + } + + +// --------------------------------------------------------------------------- +// tests if adapter is active (trying to make it active if needed) +// --------------------------------------------------------------------------- +// +TBool CGfxTransAdapterTfx::IsActive() + { + TInt ap = iClientId.Id(); + __ALFFXLOGSTRING1("IsActive() cli: %d",ap); + + TInt err = KErrNone; + if( !iHasPlugin ) + { + ConnectToServer(); + if (!iHasPlugin ) + { + return EFalse; + } + } + + if( err == KErrNone ) + { + //Make sure policy request handling is on. + err = RequestPolicyUpdates(); + } + else + { + //Failed to connect, remove all policies from client. + iClient->ClearAllPolicies(); + } + + return (err == KErrNone); + } + +// --------------------------------------------------------------------------- +// Handles the different states of the client. +// --------------------------------------------------------------------------- +// +TInt CGfxTransAdapterTfx::HandleClientState( TClientState aState, const CCoeControl* aKey, TInt aHandle ) + { + if( !iHasPlugin ) + { + return KErrNone; + } + + TInt err = KErrNone; + TInt action = 0; + const CTransitionData* transdata; + err = iClient->GetTransitionData( aHandle, transdata ); + if ( err == KErrNone ) + { + action = transdata->iAction; + } + + switch(aState) + { + case EFallback: + break; + case EPreBeginCapture: + break; + case EPostBeginCapture: + // If we get KGfxControlAppearAction, it is followed by StartTransition, + // but disappear action is not. Therefore we must handle it byself + // We use begin capture as trigger, as we assume that the control is still present + // at that time. After EPostBeginCapture it will probably be already gone. + // If we don't have plugin yet, there will be no transitions. + if ( action == KGfxControlDisappearAction && iHasPlugin && aKey && aKey->DrawableWindow()) + { + // We must generate our own transition as we won't be sending + // iClient->TransitionFinished back. + // (Client did not ask for transition to be started, and won't be + // interested in the end.) + TRAP( err, GenerateTransitionL( aKey, transdata ) ); + } + break; + case EPreEndCapture: + break; + case EPostEndCapture: + break; + case EAbort: + // Abort component transition, handle given. + break; + case EGlobalAbort: + // abort component transition, no handle. + break; + case EBeginGroup: + { + __ALFFXLOGSTRING1("-- BeginGroup: New transition group for groupid: %d)",aHandle); + SendGroupCommand(aHandle, EFalse); + break; + } + case EEndGroup: + { + __ALFFXLOGSTRING1("-- EndGroup: closing transition group: %d)",aHandle); + SendGroupCommand(aHandle, ETrue); + break; + } + default: + break; + } + return err; + } + +// --------------------------------------------------------------------------- +// Called by client when a participant of a transition updates in mid transition. +// --------------------------------------------------------------------------- +// +void CGfxTransAdapterTfx::HandleParticpantUpdate(TInt /*aHandle*/, const CParticipantData* /*aParticipant*/, + RWsGraphicMsgBuf* /*aCommandBuffer*/, + const TRect& /*aDrawRect*/, const TRect& /*aBoundingRect*/) + { +/* + if(aCommandBuffer->Count() == 0) + { + return; + } + + const CTransitionData* transdata; + TInt err = iClient->GetTransitionData(aHandle,transdata); + if(err != KErrNone) + { + return; + } + + CTransControlDrawerInfo* drawinfo = FindControl(aHandle); + if(drawinfo && drawinfo->HasWOParticipants()) + { + return; + } + + + TInt participantid = -1; + if(aParticipant == transdata->iBaseControl) + { + participantid = 0; + } + else + { + TBool found = EFalse; + for(TInt i = transdata->iSubControls.Count() - 1; (i >= 0) && !found; i--) + { + if(transdata->iSubControls[i] == aParticipant) + { + participantid = i + 1; + found = ETrue; + } + } + } + + if(participantid >= 0) + { + //Find control drawer for this handle, send updated participant to it. + CWsTransControlGraphic* drawer = FindDrawer(aHandle); + if(drawer) + { + RThread t; + __ALFFXLOGSTRING2("Sending participant update for client:%d, handle:%d",t.Id().Id(),aHandle); + drawer->SendParticipantUpdate(participantid, aCommandBuffer, aDrawRect, aBoundingRect); + } + } +*/ + } + + +// --------------------------------------------------------------------------- +// returns an array of supported control transitions +// --------------------------------------------------------------------------- +// +TControlPolicy* CGfxTransAdapterTfx::GetTransitionPolicies(TInt &aCount) + { + if( !iHasPlugin ) + { + ConnectToServer(); + if ( !iHasPlugin ) + { + return NULL; + } + } + //Start requesting policies + RequestPolicyUpdates(); + + //No policies at this point, all will be pushed. + aCount = 0; + return NULL; + } + +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// +void CGfxTransAdapterTfx::SubConBegin( const CCoeControl* /*aControl*/ ) + { +/* + if ( aControl ) + { + for ( TInt i = 0; i < aControl->CountComponentControls(); i++ ) + { + const CCoeControl* subcon = aControl->ComponentControl( i ); + if ( subcon && subcon->OwnsWindow() && subcon->Size() != TSize( 0, 0 ) && !GfxTransEffect::IsRegistered(subcon)) + { + if ( iIgnoredWOChildControls.Find( subcon ) == KErrNotFound ) + { + iSubCons++; + GfxTransEffect::Register( subcon, iActiveUid ); + GfxTransEffect::Begin( subcon, iActiveAction ); + } + } + iCurrZ++; + SubConBegin( subcon ); + iCurrZ--; + } + } +*/ + } + +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// +void CGfxTransAdapterTfx::SubConEnd(const CCoeControl* /*aControl*/) + { +/* + if ( aControl ) + { + for ( TInt i = aControl->CountComponentControls() - 1; i >= 0 ; i-- ) + { + CCoeControl* subcon = aControl->ComponentControl(i); + SubConEnd( subcon ); + if ( subcon && subcon->OwnsWindow() && + GfxTransEffect::IsRegistered( subcon ) ) + { + if (subcon->IsVisible()) + { + GfxTransEffect::SetBeginDemarcation(subcon, TRect(0, 0, 0, 0)); + } + else + { + GfxTransEffect::SetEndDemarcation(subcon, TRect(0, 0, 0, 0)); + } + GfxTransEffect::Invalidate(subcon); + GfxTransEffect::End(subcon); + if(subcon->IsVisible()) + { + // make subcon temporarily invisible to avoid redrawing when deregistering + // redrawing will go to the remotegc of the main control but is bad for performance + // and causes Begin/End Redraw on the window which can cause flicker. + subcon->MakeVisible(EFalse); + GfxTransEffect::Deregister(subcon); + subcon->MakeVisible(ETrue); + } + else + { + GfxTransEffect::Deregister(subcon); + } + iSubCons--; + } + } + } +*/ + } + +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// +void CGfxTransAdapterTfx::SubConAbort( const CCoeControl* /*aControl*/ ) + { +/* + if ( aControl ) + { + for ( TInt i = aControl->CountComponentControls() - 1; i >= 0; --i ) + { + CCoeControl* subcon = aControl->ComponentControl( i ); + SubConAbort( subcon ); + if ( subcon && subcon->OwnsWindow() && + GfxTransEffect::IsRegistered( subcon ) ) + { + GfxTransEffect::Abort( subcon ); + } + } + } +*/ + } + +// --------------------------------------------------------------------------- +// calls to GfxTransEffect::NotifyExternalState comes through here. +// --------------------------------------------------------------------------- +// +void CGfxTransAdapterTfx::NotifyExternalState( TInt aState, const TDesC8* /*aArg*/ ) + { + switch(aState) + { + case ECaptureComponentsBegin: + if( !IsActive() ) + { + return; //dont do anything if server is not running + } + break; + case ECaptureComponentsEnd: + if( !IsActive() ) + { + return; //dont do anything if server is not running + } + break; + case ECaptureComponentsAbort: + if( !IsActive() ) + { + return; //dont do anything if server is not running + } +// iTfxServer.AbortControlTransition(); + return; + case ENotifyGlobalAbort: +// iTfxServer.AbortControlTransition(); + return; + case EBeginPopupSequence: + case ELastPopupInSequence: + case EEndPopupSequence: + case EInternalHandleSequence: + case EGetRegistrationType: + case EAddIgnoreWOChildComponent: + case ERemoveIgnoreWOChildComponent: + default: + //ignored + break; + } + } + +// --------------------------------------------------------------------------- +// called by client to start the specific transition +// --------------------------------------------------------------------------- +// +void CGfxTransAdapterTfx::StartTransition(TInt aHandle) + { + if( !iHasPlugin ) + { + iClient->TransitionFinished( aHandle ); + return; + } + + const CTransitionData* transdata; + TInt err = iClient->GetTransitionData( aHandle, transdata ); + + if( err == KErrNone ) + { + if ( transdata->iAction != KGfxControlDisappearAction ) + { + // Disappear action was started by EPostBeginCapture event + TRAP( err, DoStartTransitionL( aHandle, transdata ) ); + } + else + { + __ALFFXLOGSTRING( "CGfxTransAdapterTfx::StartTransition called for disappear action" ); + } + } + + // always finish the caller + iClient->TransitionFinished( aHandle ); + } + +// --------------------------------------------------------------------------- +// GfxTransEffect::BeginFullscreen gets passed here. +// --------------------------------------------------------------------------- +// +void CGfxTransAdapterTfx::BeginFullScreen(TUint /*aAction*/, const TRect& /*aEffectArea*/) + { + //This function will not be used. + } + +// --------------------------------------------------------------------------- +// GfxTransEffect::BeginFullscreen gets passed here. +// --------------------------------------------------------------------------- +// +void CGfxTransAdapterTfx::BeginFullScreen(TUint aAction, const TRect& aEffectArea, + TUint aType, const TDesC8& aParams) + { + __ALFFXLOGSTRING1( "CGfxTransAdapterTfx::BeginFullScreen - %S >>", &RThread().Name()); + __ALFFXLOGSTRING1( "CGfxTransAdapterTfx::BeginFullScreen - iHasPlugin %d >>", iHasPlugin); + if( !iHasPlugin ) + { + ConnectToServer(); + if ( !iHasPlugin ) + { + return; + } + } + + TInt op = MAlfGfxEffectPlugin::EBeginFullscreen; + + TPtr8 inPtr = iTransferBuffer->Des(); + inPtr.Zero(); + TPtr8 outPtr = iReturnBuffer->Des(); + outPtr.Zero(); + RDesWriteStream inBuf( inPtr ); + + // We won't leave here because our buffer is long enough + // The buffer has been allocated in the constructor + // If you add parameters, check the length of the buffer + TRAP_IGNORE( + { + inBuf.WriteInt32L( op ); + inBuf.WriteUint32L( aAction ); + inBuf.WriteInt32L( aEffectArea.iTl.iX ); + inBuf.WriteInt32L( aEffectArea.iTl.iY ); + inBuf.WriteInt32L( aEffectArea.iBr.iX ); + inBuf.WriteInt32L( aEffectArea.iBr.iY ); + inBuf.WriteInt32L( aType ); + + AknTransEffect::TParameter tmp; + TPckgC params( tmp ); + params.Set( aParams ); + if ( aType == AknTransEffect::EParameterType ) + { + __ALFFXLOGSTRING3("CGfxTransAdapterTfx::BeginFullScreen - EParameterType, iNext.iUid: 0x%x, iPrev.iUid: 0x%x, iFlags: %d", params().iNext.iUid, params().iPrev.iUid, params().iFlags ); + inBuf.WriteInt32L( params().iNext.iUid ); + inBuf.WriteInt32L( params().iPrev.iUid ); + inBuf.WriteInt32L( params().iFlags ); + + } + else if ( aType == AknTransEffect::EParameterAvkonInternal ) + { + const TUint* data = reinterpret_cast( aParams.Ptr() ); + inBuf.WriteUint32L( data[0] ); + inBuf.WriteUint32L( data[1] ); + inBuf.WriteUint32L( data[2] ); + __ALFFXLOGSTRING3("CGfxTransAdapterTfx::BeginFullScreen - EParameterAvkonInternal, data[0-2] = [%d, %d, %d]", data[0], data[1], data[2]); + } + else + { + inBuf.WriteUint32L( 0 ); + inBuf.WriteUint32L( 0 ); + inBuf.WriteUint32L( 0 ); + } + + inBuf.CommitL(); + }); + + inBuf.Release(); + inBuf.Close(); + + + // we ignore any returned error as we are just doing our best... + iTfxServer.SendSynchronousData( iPluginImplementation, inPtr, outPtr ); + + // clear out used data + inPtr.Zero(); + outPtr.Zero(); + __ALFFXLOGSTRING("CGfxTransAdapterTfx::BeginFullScreen <<"); + } + +// --------------------------------------------------------------------------- +// GfxTransEffect::EndFullscreen gets passed here. +// --------------------------------------------------------------------------- +// +void CGfxTransAdapterTfx::EndFullScreen() + { + __ALFFXLOGSTRING1( "CGfxTransAdapterTfx::EndFullScreen() - %S >>", &RThread().Name()); + if( !iHasPlugin ) + { + return; + } + + TPtr8 inPtr = iTransferBuffer->Des(); + inPtr.Zero(); + TPtr8 outPtr = iReturnBuffer->Des(); + outPtr.Zero(); + RDesWriteStream inBuf( inPtr ); + TInt op = MAlfGfxEffectPlugin::EEndFullscreen; + // We won't leave here because our buffer is long enough + TRAP_IGNORE( + { + // no other parameters used + inBuf.WriteInt32L( op ); + inBuf.CommitL(); + }); + inBuf.Release(); + inBuf.Close(); + + __ALFFXLOGSTRING( "CGfxTransAdapterTfx::EndFullScreen" ); + // we ignore any returned error as we are just doing our best... + iTfxServer.SendSynchronousData( iPluginImplementation, inPtr, outPtr ); + // clear out used data + inPtr.Zero(); + outPtr.Zero(); + + } + +// --------------------------------------------------------------------------- +// GfxTransEffect::AbortFullscreen gets passed here. +// --------------------------------------------------------------------------- +// +void CGfxTransAdapterTfx::AbortFullScreen() + { + __ALFFXLOGSTRING1( "CGfxTransAdapterTfx::AbortFullScreen() - %S >>", &RThread().Name()); + if ( !iHasPlugin ) + { + return; + } + + TPtr8 inPtr = iTransferBuffer->Des(); + inPtr.Zero(); + TPtr8 outPtr = iReturnBuffer->Des(); + outPtr.Zero(); + RDesWriteStream inBuf( inPtr ); + TInt op = MAlfGfxEffectPlugin::EAbortFullscreen; + // We won't leave here because our buffer is long enough + TRAP_IGNORE( + { + // no other parameters used + inBuf.WriteInt32L( op ); + inBuf.CommitL(); + }); + inBuf.Release(); + inBuf.Close(); + + // we ignore any returned error as we are just doing our best... + iTfxServer.SendSynchronousData( iPluginImplementation, inPtr, outPtr ); + // clear out used data + inPtr.Zero(); + outPtr.Zero(); + __ALFFXLOGSTRING("CGfxTransAdapterTfx::AbortFullScreen <<"); + } + + +// --------------------------------------------------------------------------- +// implementation, handling transition startup +// --------------------------------------------------------------------------- +// +void CGfxTransAdapterTfx::DoStartTransitionL( TInt /*aHandle*/, const CTransitionData* aTransData ) + { + // send the transition request to Alf Plugin + __ALFFXLOGSTRING("CGfxTransAdapterTfx::DoStartTransitionL >>"); + if ( !aTransData->iKey->DrawableWindow() ) + { + // If we don't have a window, we cannot do transition + return; + } + + TPtr8 inPtr = iTransferBuffer->Des(); + inPtr.Zero(); + TPtr8 outPtr = iReturnBuffer->Des(); + outPtr.Zero(); + RDesWriteStream inBuf( inPtr ); + TInt op = MAlfGfxEffectPlugin::EBeginComponentTransition; + TInt windowGroup = aTransData->iKey->DrawableWindow()->WindowGroupId(); + TInt windowHandle = aTransData->iKey->DrawableWindow()->ClientHandle(); + + // We don't send all the position information as we will do no screen capture + // based on position, and the visuals know their own positions anyway. + // If we find out that we need to specify some starting or ending positions, + // we can add the information later. + + inBuf.WriteInt32L( op ); + inBuf.WriteUint32L( aTransData->iAction ); + inBuf.WriteInt32L( aTransData->iUid.iUid ); + inBuf.WriteInt32L( windowGroup ); // window group id of the control + inBuf.WriteInt32L( windowHandle ); // server side window handle for the control + inBuf.WriteInt32L( aTransData->iNLayered ); + // Participant data for the main layer. Other layers not handled separately. + const CParticipantData* baseControl = aTransData->iBaseControl; + inBuf.WriteInt32L( baseControl->iLayerType.iUid ); // uid for this participant + inBuf.WriteInt32L( baseControl->iFlags ); // hints + // Possible component control data missing - we assume handling of the whole control as one + + inBuf.CommitL(); + inBuf.Release(); + inBuf.Close(); + + __ALFFXLOGSTRING( "CGfxTransAdapterTfx::DoStartTransitionL" ); + iTfxServer.SendSynchronousData( iPluginImplementation, inPtr, outPtr ); + // clear out used data + inPtr.Zero(); + outPtr.Zero(); + + /* + if ( iSubCons ) //Note: "normal" nesting wont work, but is not used in this platform. + { + if(iMainControl) + { + //Collecting window owning sub controls, add to list. + __ALFFXLOGSTRING2("Adding subcon %x, handle: %d",aTransData->iKey, aHandle); + CSubWOControl* subcon = CSubWOControl::NewL( aHandle, *aTransData ); + iSubWOControls.AppendL(subcon); + return; + } + else + { + //Subcon Mismatch, abort transition and clean up. + iClient->TransitionFinished(aHandle); + return; + } + } + + if(iControlInfo.Count() >= KMaxOngoing) + { + __ALFFXLOGSTRING("CGfxTransAdapterTfx::DoStartTransitionL maxongoing"); + iClient->TransitionFinished(aHandle); + return; + } + + TInt ap = iClientId.Id(); + __ALFFXLOGSTRING2("Adapter: Transition Started: %d, cli: %d",aHandle,ap); + TRect boundingrect = TRect(aTransData->iBeginWOPos + aTransData->iBaseControl->iBeginRect.iTl, + aTransData->iBeginWOPos + aTransData->iBaseControl->iBeginRect.iBr); + boundingrect.BoundingRect(TRect(aTransData->iEndWOPos + aTransData->iBaseControl->iEndRect.iTl, + aTransData->iEndWOPos + aTransData->iBaseControl->iEndRect.iBr)); + CTransControlDrawerInfo* drawinfo = CTransControlDrawerInfo::NewL(aHandle, boundingrect); + CleanupStack::PushL(drawinfo); + User::LeaveIfError(iControlInfo.Append(drawinfo)); + CleanupStack::Pop(drawinfo); + CWsTransControlGraphic* drawer = drawinfo->Drawer(); + + __ALFFXLOGSTRING("Adapter: Sending participant 0"); + drawer->SendParticipant(aTransData->iBaseControl,0); + TInt count = aTransData->iSubControls.Count(); + for(TInt i = 0; i < count; i++) + { + __ALFFXLOGSTRING1("Adapter: Sending participant %d",i+1); + drawer->SendParticipant(aTransData->iSubControls[i],i + 1); + } + + TInt wocount = iSubWOControls.Count(); + if(wocount) + { + drawinfo->SetHasWOParticipants(ETrue); + } + for(TInt i = wocount - 1; i >= 0; i--) + { + drawer->SendWOParticipant(*iSubWOControls[i]); + } + for(TInt i = 0; i < wocount; i++) + { + iClient->TransitionFinished(iSubWOControls[i]->Handle()); + } + iSubWOControls.ResetAndDestroy(); + + __ALFFXLOGSTRING("Adapter: Sending Transition Data"); + + TBool drawerstart = EFalse; + if(iIsWO && !aTransData->iKey->IsVisible()) + { + drawerstart = ETrue; + } + + drawer->SendTransitionData(aTransData, aHandle, drawerstart); + drawer->Flush(); + + if(iIsWO && !aTransData->iKey->Parent()) + { + // aTransData->iKey->DrawNow(); + if ( aTransData->iKey->IsVisible() && !aTransData->iKey->IsBackedUp() ) + { + RWindow* window = ( RWindow* ) aTransData->iKey->DrawableWindow(); + window->BeginRedraw(); + window->EndRedraw(); + } + } + else + { + const CCoeControl* parent = aTransData->iKey->Parent(); + if(parent) + { +// TRect rect; +// if(iIsWO) +// { +// rect = TRect(aTransData->iKey->PositionRelativeToScreen(),aTransData->iKey->Size()); +// rect.Move(-parent->PositionRelativeToScreen()); +// } +// else +// { +// rect = aTransData->iBaseControl->iBeginRect; +// } + + //Drawing problems with listboxes in component if + //particle systems is used. We disable this rect for now + //to resolve this. Shouldn't affect performance much. + + if ( !aTransData->iKey->IsVisible() ) + { + parent->DrawNow(); + } + } + } + //// + iCoeEnv->WsSession().Flush(); + + __ALFFXLOGSTRING("Adapter: Requesting finished event"); + if(KErrNone != iTfxServer.RequestFinishedEvent(aHandle)) + { + iCurrHandle = 0; + TransitionFinished(aHandle); + return; + } + + if(!drawerstart) + { + if(KErrNone != iTfxServer.SendStartTick(iClientId,aHandle)) + { + TransitionFinished(aHandle); + } + } + iCurrHandle = 0; +*/ + __ALFFXLOGSTRING("CGfxTransAdapterTfx::DoStartTransitionL <<"); + } + +void CGfxTransAdapterTfx::GenerateTransitionL( const CCoeControl* aKey, const CTransitionData* aTransData) + { + __ALFFXLOGSTRING("CGfxTransAdapterTfx::GenerateTransitionL >>"); + // We generate a transition call from begin capture for control exit transitions + TPtr8 inPtr = iTransferBuffer->Des(); + inPtr.Zero(); + TPtr8 outPtr = iReturnBuffer->Des(); + outPtr.Zero(); + RDesWriteStream inBuf( inPtr ); + TInt op = MAlfGfxEffectPlugin::EBeginComponentTransition; + TInt windowGroup = aKey->DrawableWindow()->WindowGroupId(); + TInt windowHandle = aKey->DrawableWindow()->ClientHandle(); + + inBuf.WriteInt32L( op ); + inBuf.WriteUint32L( aTransData->iAction ); + inBuf.WriteInt32L( aTransData->iUid.iUid ); + inBuf.WriteInt32L( windowGroup ); // window group id of the control + inBuf.WriteInt32L( windowHandle ); // server side window handle for the control + inBuf.WriteInt32L( aTransData->iNLayered ); + // Participant data not present in exit + inBuf.WriteInt32L( 0 ); + inBuf.WriteInt32L( 0 ); // no hints + + inBuf.CommitL(); + inBuf.Release(); + inBuf.Close(); + + __ALFFXLOGSTRING( "CGfxTransAdapterTfx::GenerateTransitionL" ); + iTfxServer.SendSynchronousData( iPluginImplementation, inPtr, outPtr ); + // clear out used data + inPtr.Zero(); + outPtr.Zero(); + + // Don't signal client because client did not request the transition to start + __ALFFXLOGSTRING("CGfxTransAdapterTfx::GenerateTransitionL <<"); + } + + +// --------------------------------------------------------------------------- +// finds a control +// --------------------------------------------------------------------------- +// +//CTransControlDrawerInfo* CGfxTransAdapterTfx::FindControl(TInt /*aHandle*/) +/* + { + for(TInt i = iControlInfo.Count() - 1; i >= 0; i--) + { + if(iControlInfo[i]->Handle() == aHandle) + { + return iControlInfo[i]; + } + } + return NULL; + } +*/ + +// --------------------------------------------------------------------------- +// finds a control drawer. +// --------------------------------------------------------------------------- +// +//CWsTransControlGraphic* CGfxTransAdapterTfx::FindDrawer(TInt /*aHandle*/) +/* + { + for(TInt i = iControlInfo.Count() - 1; i >= 0; i--) + { + if(iControlInfo[i]->Handle() == aHandle) + { + return iControlInfo[i]->Drawer(); + } + } + return NULL; + } +*/ + +// --------------------------------------------------------------------------- +// callback called by server when a policy updates. +// --------------------------------------------------------------------------- +// +void CGfxTransAdapterTfx::PolicyUpdate(TControlPolicy* aPolicy) + { + iClient->TransitionPolicyUpdate(aPolicy); + } + + +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// +void CGfxTransAdapterTfx::ClearAllPolicies() + { + iClient->ClearAllPolicies(); + } + +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// +TInt CGfxTransAdapterTfx::RequestPolicyUpdates() + { + __ALFFXLOGSTRING("CGfxTransAdapterTfx::RequestPolicyUpdates >>"); + if( iPolicyReq->IsActive() ) + { + // request already ongoing + return KErrNone; + } + + if ( !iHasPlugin ) + { + return KErrDisconnected; + } + + // send a request to plugin to start sending us policy updates + // This is an asynchronous request + + TPtr8 inPtr = iAsyncTransferBuffer->Des(); + inPtr.Zero(); + TPtr8 outPtr = iAsyncReturnBuffer->Des(); + outPtr.Zero(); + RDesWriteStream inBuf( inPtr ); + TInt op = MAlfGfxEffectPlugin::ETfxServerOpControlPolicyRequest; + // We won't leave here because our buffer is long enough + TRAP_IGNORE( + { + // no other parameters used + inBuf.WriteInt32L( op ); + inBuf.CommitL(); + }); + inBuf.Release(); + inBuf.Close(); + + __ALFFXLOGSTRING( "CGfxTransAdapterTfx::RequestPolicyUpdates" ); + iTfxServer.SendAsynchronousData( iPluginImplementation, inPtr, outPtr, iPolicyReq->iStatus ); + iPolicyReq->IssueReq(); + // clear out used data + inPtr.Zero(); + outPtr.Zero(); + __ALFFXLOGSTRING("CGfxTransAdapterTfx::RequestPolicyUpdates <<"); + return KErrNone; + + } + +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// +void CGfxTransAdapterTfx::GetNewPoliciesL( TUint aCount ) + { + __ALFFXLOGSTRING1("CGfxTransAdapterTfx::GetNewPoliciesL %d >>", aCount); + if ( !iHasPlugin ) + { + User::Leave( KErrDisconnected ); + } + // Send request to plugin + + TInt err = KErrNone; + + TPtr8 inPtr = iTransferBuffer->Des(); + inPtr.Zero(); + + TInt bufferSize = sizeof( TUint32 ) + ( sizeof( TInt32 ) * 2 + sizeof( TUint8 ) ) * aCount ; + if ( iReturnBuffer->Des().MaxSize() < bufferSize ) + { + delete iReturnBuffer; + iReturnBuffer = NULL; + iReturnBuffer = HBufC8::NewL( bufferSize ); + } + + TPtr8 outPtr = iReturnBuffer->Des(); + outPtr.Zero(); + RDesWriteStream inBuf( inPtr ); + TInt op = MAlfGfxEffectPlugin::ETfxServerOpControlPolicyGet; + RThread me; + + inBuf.WriteInt32L( op ); + TUint64 id = me.Id(); + TUint8* ptr = reinterpret_cast( &id ); + inBuf.WriteL( ptr, 8 ); + inBuf.WriteInt32L( aCount ); + + inBuf.CommitL(); + inBuf.Release(); + inBuf.Close(); + me.Close(); + + if ( iHasPlugin ) + { + __ALFFXLOGSTRING( "CGfxTransAdapterTfx::GetNewPoliciesL" ); + err = iTfxServer.SendSynchronousData( iPluginImplementation, inPtr, outPtr ); + } + // This is a case where we are supposed to get data back + if ( err == KErrNone ) + { + RDesReadStream instream( outPtr ); + CleanupClosePushL( instream ); + TUint count = instream.ReadUint32L(); + while ( count-- > 0 ) + { + TInt uid = instream.ReadInt32L(); + TUint action = instream.ReadUint32L(); + TPolicy policyId = ( TPolicy ) instream.ReadUint8L(); + TControlPolicy* policy = new ( ELeave ) TControlPolicy(); + policy->iId.iUid = uid; + policy->iAction = action; + policy->iPolicy = policyId; + iClient->TransitionPolicyUpdate( policy ); + } + CleanupStack::PopAndDestroy(); // instream + } + + // clear out used data + inPtr.Zero(); + outPtr.Zero(); + __ALFFXLOGSTRING("CGfxTransAdapterTfx::GetNewPoliciesL <<"); + } + +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// +void CGfxTransAdapterTfx::CancelPolicyUpdates() + { + __ALFFXLOGSTRING("CGfxTransAdapterTfx::CancelPolicyUpdates >>"); + if ( !iHasPlugin ) + { + // nothing to cancel + return; + } + + // send request to plugin + // If the updates have not been subscribed, there is nothing to cancel either + TPtr8 inPtr = iTransferBuffer->Des(); + inPtr.Zero(); + TPtr8 outPtr = iReturnBuffer->Des(); + outPtr.Zero(); + RDesWriteStream inBuf( inPtr ); + TInt op = MAlfGfxEffectPlugin::ETfxServerOpControlCancelPolicyUpdate; + RThread me; + // We won't leave here because our buffer is long enough + TRAP_IGNORE( + { + // no other parameters used + inBuf.WriteInt32L( op ); + TUint64 id = me.Id(); + TUint8* ptr = reinterpret_cast( &id ); + inBuf.WriteL( ptr, 8 ); + inBuf.CommitL(); + }); + inBuf.Release(); + inBuf.Close(); + me.Close(); + + // not waiting for policies, nothing to cancel + if( iPolicyReq->IsActive() ) + { + // The cancel function will complete the request + __ALFFXLOGSTRING( "CGfxTransAdapterTfx::CancelPolicyUpdates" ); + iTfxServer.SendSynchronousData( iPluginImplementation, inPtr, outPtr ); + } + + // clear out used data + inPtr.Zero(); + outPtr.Zero(); + __ALFFXLOGSTRING("CGfxTransAdapterTfx::CancelPolicyUpdates <<"); + } + +// ------------------------------------------------------------ +// SendGroupCommand +//------------------------------------------------------------- +// +void CGfxTransAdapterTfx::SendGroupCommand(TInt aGroupId, TBool aGroupFinished) + { + __ALFFXLOGSTRING("CGfxTransAdapterTfx::SendGroupCommand >>"); + if ( !iHasPlugin ) + { + // nothing to cancel + return; + } + + // send request to plugin + // If the updates have not been subscribed, there is nothing to cancel either + TPtr8 inPtr = iTransferBuffer->Des(); + inPtr.Zero(); + TPtr8 outPtr = iReturnBuffer->Des(); + outPtr.Zero(); + RDesWriteStream inBuf( inPtr ); + + TInt op; + if ( aGroupFinished ) + { + op = MAlfGfxEffectPlugin::ETfxServerOpEndGroup; + } + else + { + op = MAlfGfxEffectPlugin::ETfxServerOpBeginGroup; + } + RThread me; + // We won't leave here because our buffer is long enough + TRAP_IGNORE( + { + // no other parameters used + inBuf.WriteInt32L( op ); + inBuf.WriteInt32L( aGroupId ); + TUint64 id = me.Id(); + TUint8* ptr = reinterpret_cast( &id ); + inBuf.WriteL( ptr, 8 ); + inBuf.CommitL(); + }); + inBuf.Release(); + inBuf.Close(); + me.Close(); + + iTfxServer.SendSynchronousData( iPluginImplementation, inPtr, outPtr ); + + // clear out used data + inPtr.Zero(); + outPtr.Zero(); + __ALFFXLOGSTRING("CGfxTransAdapterTfx::SendGroupCommand <<"); + } + + +// ======== GLOBAL FUNCTIONS ======== + +// --------------------------------------------------------------------------- +// DLL interface. used by the client to create the adapter +// --------------------------------------------------------------------------- +// +EXPORT_C MGfxTransAdapter* MGfxTransAdapter::CreateL(MGfxTransClient* aClient) + { + __ALFFXLOGSTRING("MGfxTransAdapter::CreateL >>"); + CGfxTransAdapterTfx* adapter = new (ELeave) CGfxTransAdapterTfx(aClient); + CleanupStack::PushL(adapter); + adapter->ConstructL(); + CleanupStack::Pop(adapter); + __ALFFXLOGSTRING("MGfxTransAdapter::CreateL <<"); + return adapter; + } + +// --------------------------------------------------------------------------- +// DLL interface. used by the client to destroy the adapter +// --------------------------------------------------------------------------- +// +EXPORT_C void MGfxTransAdapter::Destroy(MGfxTransAdapter* aEngine) + { + delete static_cast(aEngine); + }