diff -r 000000000000 -r 2f259fa3e83a lafagnosticuifoundation/graphicseffects/ClientSrc/transitionparticipant.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lafagnosticuifoundation/graphicseffects/ClientSrc/transitionparticipant.cpp Tue Feb 02 01:00:49 2010 +0200 @@ -0,0 +1,396 @@ +// Copyright (c) 2006-2009 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: +// GFXTRANSEFFECT.CPP +// +// + +#include "TransitionParticipant.h" +#include + +//---------------- +// Utility function +//---------------- +//#define RECURSIVE_GC_SETTING + +#ifdef RECURSIVE_GC_SETTING + +void DrawControl(const CCoeControl *aControl, CTransitionParticipant::TCaptureType aCaptureType, CRemoteGc* aGc) + { + const TRect rect = aControl->Rect(); + if(aControl->Background()) + { + aControl->DrawBackground(rect); + } + aControl->DrawForeground(rect); + if(aCaptureType == CTransitionParticipant::EDeep) + { + + TInt count = aControl->CountComponentControls(); + for(TInt i = 0 ; i < count; i++) + { + CCoeControl *child = aControl->ComponentControl(i); + if(child->OwnsWindow()) + child->SetGc(aGc); //Set gc for each WO child control. + //Is it correct to check if windowowning? maybe not... :) + if(child->IsVisible()/* && !child->OwnsWindow()*/) + { + DrawControl(child, aCaptureType, aGc); + } + } + } + } + +#else +void DrawControl(const CCoeControl *aControl, CTransitionParticipant::TCaptureType aCaptureType) + { + const TRect rect = aControl->Rect(); + if(aControl->Background()) + { + aControl->DrawBackground(rect); + } + aControl->DrawForeground(rect); + if(aCaptureType == CTransitionParticipant::EDeep) + { + + TInt count = aControl->CountComponentControls(); + for(TInt i = 0 ; i < count; i++) + { + CCoeControl *child = aControl->ComponentControl(i); + //Is it correct to check if windowowning? + if(child->IsVisible() && !child->OwnsWindow()) + { + DrawControl(child, aCaptureType); + } + } + } + } +#endif + +void ResetRemoteGc(const CCoeControl* aControl) + { + aControl->SetGc(NULL); +#ifdef RECURSIVE_GC_SETTING + for(TInt i = aControl->CountComponentControls() - 1; i >= 0; i--) + { + ResetRemoteGc(aControl->ComponentControl(i)); + } +#endif + } + + + +TInt DrawUptoControlRec(CWindowGc& aGc, const CCoeControl* aCurrent, const TRect& aRect,const CCoeControl* aUpto) + { + TInt err = KErrNone; + if(aCurrent != aUpto) + { + CWindowGc* oldGc = aCurrent->GetGc(); + err = aCurrent->SetGc(&aGc); + if(!err) + { + if(aCurrent->Background()) + { + //if we have a background, draw it + aCurrent->DrawBackground(aRect); + } + else if(aCurrent->OwnsWindow()) + { + // try to find background + const CCoeControl* bgOwningParent = aCurrent; + do + { + if(const MCoeControlBackground* bg = bgOwningParent->Background()) + { + bg->Draw(aGc,*aCurrent,aRect); + break; // mission complete + } + bgOwningParent = bgOwningParent->Parent(); + } while(bgOwningParent); + } + //draw foreground + aCurrent->DrawForeground(aRect); + + // draw component controls + for(TInt i=0; (i < aCurrent->CountComponentControls()) && !err; i++) + { + const CCoeControl* child = aCurrent->ComponentControl(i); + if(child->IsVisible() && !child->OwnsWindow()) + { + TRect childRect = child->Rect(); + if(childRect.Intersects(aRect)) + { + childRect.Intersection(aRect); + err = DrawUptoControlRec(aGc,child,childRect,aUpto); + } + } + } + //set back the old gc + err = const_cast(aCurrent)->SetGc(oldGc); + } + } + return err; + } + +TInt DrawUptoControl(CWindowGc& aGc,const CCoeControl* aControl) + { + const CCoeControl* aWindowOwningParent = aControl; + //find the windowowing parent + while(!aWindowOwningParent->OwnsWindow() && aWindowOwningParent->Parent()) + { + aWindowOwningParent = aWindowOwningParent->Parent(); + } + return DrawUptoControlRec(aGc, aWindowOwningParent, aControl->Rect(), aControl); + } + + + +//---------------- +// Construct/Destruct +//---------------- +CTransitionParticipant *CTransitionParticipant::New(const CCoeControl *aKey, + CTransitionControl *aTransControl, + TUint aFlags) + { + CTransitionParticipant *participant = new CTransitionParticipant(aTransControl); + if(!participant) + { + return NULL; + } + if(NULL == (participant->iData = new CParticipantData())) + { + delete participant; + return NULL; + } + participant->iData->iKey = aKey; + participant->iData->iBeginZ = -1; + participant->iData->iEndZ = -1; + participant->iData->iBeginCapture = 0; + participant->iData->iEndCapture = 0; + participant->iData->iLayerType = TUid::Uid(0); + participant->iData->iFlags = aFlags; + //create remote gc + TRAPD(err, participant->iRemoteGc = CRemoteGc::NewL(aTransControl->ScreenDevice())); + if(err < KErrNone || !(participant->iRemoteGc)) + { + delete participant; + return NULL; + } + participant->iRemoteGc->SetCommandBufferObserver(participant); + + return participant; + } + +CTransitionParticipant::CTransitionParticipant(CTransitionControl *aTransControl) + { + iTransControl = aTransControl; + iInvalidated = EFalse; + iCaptureState = ENoCapture; + iCaptureEndCalled = EFalse; + iCoordRefBegin = CTransitionParticipant::EWindowOwning; + iCoordRefEnd = CTransitionParticipant::EWindowOwning; + } + +CTransitionParticipant::~CTransitionParticipant() + { + if(iData) + { + ResetRemoteGc(Control()); + delete iData; + } + + if(iRemoteGc) + { + delete iRemoteGc; + } + } + + +//---------------- +// Capture +//---------------- +TInt CTransitionParticipant::CaptureBegin(const CCoeControl *aControl, TCaptureType aCaptureType, TInt aZDepth) + { + if(iTransControl->Policy() == ESupported) + { + //capture begin + iRemoteGc->ResetCommandBuffer(); + if(KErrNone != aControl->SetGc(iRemoteGc)) + { + return KErrAbort; + } + iCapturedGc = ETrue; + iInCapture = ETrue; + iRemoteGc->BeginDraw(aControl->Rect()); +#ifdef RECURSIVE_GC_SETTING + DrawControl(aControl, aCaptureType, iRemoteGc); +#else + DrawControl(aControl, aCaptureType); +#endif + iRemoteGc->EndDraw(); + iInCapture = EFalse; + if(NULL == (iData->iBeginCapture = new RWsGraphicMsgBuf())) + { + ResetRemoteGc(Control()); + return KErrAbort; + } + + TRAPD(err, iRemoteGc->ExternalizeL(*(iData->iBeginCapture), ETrue)); + if(err < KErrNone) + { + ResetRemoteGc(Control()); + return err; + } + + iRemoteGc->ResetCommandBuffer(); + + } + + //capture begin rect + iData->iBeginRect = aControl->Rect(); + iCaptureState = (TCaptureState)(iCaptureState | EBeginCapture); + //set z depth + iData->iBeginZ = aZDepth; + return KErrNone; + } + +TInt CTransitionParticipant::CaptureEnd(const CCoeControl *aControl, TCaptureType aCaptureType, TInt aZDepth) + { + if(iTransControl->Policy() == ESupported) + { + // check if we need to capture image + if(!HaveImageCapture() || Invalidated()) + { + // Capture End image + iRemoteGc->ResetCommandBuffer(); + if(KErrNone != aControl->SetGc(iRemoteGc)) + { + return KErrAbort; + } + iCapturedGc = ETrue; + iInCapture = ETrue; + iRemoteGc->BeginDraw(aControl->Rect()); +#ifdef RECURSIVE_GC_SETTING + DrawControl(aControl, aCaptureType, iRemoteGc); +#else + DrawControl(aControl, aCaptureType); +#endif + iRemoteGc->EndDraw(); + iInCapture = EFalse; + if(NULL == (iData->iEndCapture = new RWsGraphicMsgBuf())) + { + ResetRemoteGc(Control()); + return KErrNoMemory; + } + + TRAPD(err, iRemoteGc->ExternalizeL(*(iData->iEndCapture), ETrue)); + if(err < KErrNone) + { + ResetRemoteGc(Control()); + return err; + } + } + else if(iCommandsReceived) + { + // Draw commands received between begin and end. + if(NULL == (iData->iEndCapture = new RWsGraphicMsgBuf())) + { + ResetRemoteGc(Control()); + return KErrNoMemory; + } + + TRAPD(err, iRemoteGc->ExternalizeL(*(iData->iEndCapture), ETrue)); + if(err < KErrNone) + { + ResetRemoteGc(Control()); + return err; + } + } + else + { + iData->iEndCapture = iData->iBeginCapture; + } + + iRemoteGc->ResetCommandBuffer(); + } + //check if we need to capture end rect + if(!(iCaptureState & EEndCapture)) + { + iData->iEndRect = aControl->Rect(); + iCaptureState = (TCaptureState) (iCaptureState | EEndCapture); + } + iData->iEndZ = aZDepth; + iCaptureEndCalled = ETrue; + return KErrNone; + } + +//---------------- +// Demarcations +//---------------- + +void CTransitionParticipant::SetBeginDemarcation(TRect& aBeginRect, TCoordinateRef aCoordRef) + { + iCoordRefBegin = aCoordRef; + iData->iBeginRect = aBeginRect; + iCaptureState = (TCaptureState)(iCaptureState | EBeginCapture); + } + +void CTransitionParticipant::SetEndDemarcation(TRect& aEndRect, TCoordinateRef aCoordRef) + { + iCoordRefEnd = aCoordRef; + iData->iEndRect = aEndRect; + iCaptureState = (TCaptureState)(iCaptureState | EEndCapture); + } + +void CTransitionParticipant::ModifyCoordinates(TPoint& aBeginRef, TPoint& aEndRef) + { + if(iCoordRefBegin == CTransitionParticipant::EScreen) + { + iData->iBeginRect.iTl-=aBeginRef; + iData->iBeginRect.iBr-=aBeginRef; + } + if(iCoordRefEnd == CTransitionParticipant::EScreen) + { + iData->iEndRect.iTl-=aEndRef; + iData->iEndRect.iBr-=aEndRef; + } + } + +//---------------- +// MCommandBufferObserver functions +//---------------- + +void CTransitionParticipant::CommandBufferUpdated(const TRect& aDrawRect, const TRect& aBoundingRect) + { + if(!iInCapture) + { + if(!iCaptureEndCalled) + { + iCommandsReceived = ETrue; + } + else if(iListensForUpdates) + { + RWsGraphicMsgBuf* commandbuffer = new RWsGraphicMsgBuf; + if(commandbuffer) + { + TRAPD(err, iRemoteGc->ExternalizeL(*(commandbuffer), ETrue)); + if(err == KErrNone) + { + iTransControl->ParticipantUpdated(this, commandbuffer, aDrawRect, aBoundingRect); + } + commandbuffer->Close(); + delete commandbuffer; + } + } + } + }