diff -r 000000000000 -r 15bf7259bb7c uiaccelerator_plat/alf_visual_api/inc/alf/alfcompositionclient.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/uiaccelerator_plat/alf_visual_api/inc/alf/alfcompositionclient.h Tue Feb 02 07:56:43 2010 +0200 @@ -0,0 +1,344 @@ +/* +* 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: +* +*/ +#ifndef __ALFCOMPOSITIONCLIENT_H__ +#define __ALFCOMPOSITIONCLIENT_H__ + +#include +#include + +const TInt KAlfCompositionControllerIfUid(0x2002bcfc); + +/** Interface for class that actually controls the composition singleton **/ +class MAlfCompositionController: public MAlfCompositionControl + { +public: + virtual TInt CreateTargetL(TInt aTarget, TInt aClientHandle, TInt aGrpHandle ) = 0; + virtual void SetTargetL(TInt aTarget) = 0; + virtual void SetExtentSurfaceId(const TSurfaceId& aSurfaceId) = 0; + virtual TInt SetOrder(TInt aTarget, TInt aTop, TBool aAbove, TBool aCombineTargets) =0; + virtual void DeleteTarget(TInt aTarget)=0; + virtual void LowOnGraphicsMemory()=0; + virtual void GraphicsMemoryGood(){} + + virtual void AlfBridgeCallback(TInt, TAny*){}; + }; + +/** Wrapper class IPC <-> MAlfCompositionController **/ +NONSHARABLE_CLASS(CAlfCompositionCntrlClient): public CAlfCompositionClientBase + { +public: + CAlfCompositionCntrlClient(MAlfCompositionController* aController):iController(aController){} + IMPORT_C static CAlfCompositionCntrlClient* NewL(RAlfBridgerClient* aClient, MAlfCompositionController* aController); + IMPORT_C ~CAlfCompositionCntrlClient(); + + // From base + void HandleEventL(TInt aEventType, TAny* aEventData); + // from CActive + TInt RunError(TInt aError); +private: + MAlfCompositionController* iController; + + RHashMap iHostBindingsHash; + RHashMap iHostPermittedOpsHash; + + }; + + +/** +Example1: +* // to set target from other app semitransparent +* CAlfCompositionHost* me = CAlfCompositionHost::NewL(tokenFromSource, myCompositionKey); +* me->EnableAlpha(); +* me->SetOpacity(0.5f); +* //... +**/ +class CAlfCompositionHost: public CAlfCompositionSource + { +public: + /** + * Constructor for application that wishes modify + * composition information for some other process, see CreatePermissionToken() + * + * Leaves using KErrNotFound, if token is not valid + * + * If the binded target layer is destroyed by its owner, any Set operations + * will have no effect. + */ + IMPORT_C static CAlfCompositionHost* NewL(TInt aToken, TInt aKey); + + void ConstructL(TInt aToken, TInt aKey); + +//private: // data +// class CAlfCompositionHostData; +// CAlfCompositionHostData* iData; + }; + + +// ================ Posting like SW interface ============================================ +// +// ======================================================================================= + +/** Inferface for the pixel buffer provider to provide information, frames and get events concerning context events **/ +class MAlfBufferProvider + { +public: + + enum TBufferFormat + { + ESourceFormatRGB_565 = 0, + ESourceFormatXRGB_8888 = 1, + ESourceFormatARGB_8888 = 2, + ESourceFormatARGB_8888_PRE = 3 + }; + + struct TBufferCreationAttributes + { + /* + * Buffer size + */ + TInt iWidth; + TInt iHeight; + /** + * iStride should be at least bytes * width. + * iStride may still be adjusted by CAlfCompositionPixelSource for the target HW driver implementation + * Client should always use iStride value available after CAlfCompositionPixelSource::ActivateL call. + **/ + TInt iStride; + + TInt iAlignment; + TBufferFormat iFormat; + }; + + /** + * Called by framework when the next buffer is ready and available for the client to draw. + * @param aVisibleRegion is currently visible surface region + * + * @return ETrue to continue drawing of frames. EFalse to pause drawing. + * After pausing drawing client needs to call CAlfCompositionPixelSource::ActivateL to + * continue drawing of frames + **/ + virtual TBool ProduceNewFrameL(const TRegion& aVisibleRegion, TUint8*& aBuffer) = 0; + + /** + * Called by framework when new buffer is been created. Client should provide desired creation attributes. + **/ + virtual TBufferCreationAttributes& BufferAttributes() = 0; + + /** + * Notification from FW + **/ + virtual void ContextAboutToSuspend() =0; + virtual void OnActivation() = 0; + }; + +/** +* Example1: +* // to draw frames with CAlfCompositionPixelSource API +* class CMyClass: public CBase, public MAlfBufferProvider +* { +* private: +* CAlfCompositionPixelSource* iAlfCompositionPixelSource; +* MAlfBufferProvider::TBufferCreationAttributes iAttributes; +* public: +* +* CMyClass() {} +* +* ConstructL() +* { +* // ... +* iAttributes.iWidth = width; +* iAttributes.iHeight = height; +* iAttributes.iFormat = MAlfBufferProvider::ESourceFormatARGB_8888; +* iAttributes.iStride = iAttributes.iWidth * 4; +* iAttributes.iAlignment = 32; +* +* iAlfCompositionPixelSource = CAlfCompositionPixelSource::NewL(*this, iMyDrawableWindow); +* iAlfCompositionPixelSource->iActivateL() +* } +* +* TBool ProduceNewFrameL(const TRegion& aVisibleRegion, TUint8*& aBuffer) +* { +* // ... +* // copy pixel data to aBuffer +* TUint8* from = (TUint8*)bitmap->DataAddress(); +* TUint bytes = bitmap->SizeInPixels()*4; +* for (TInt y = bitmap->SizeInPixels().iHeight; y > 0; y--) +* { +* Mem::Copy(aBuffer, from, bytes); +* aBuffer += iAttributes.iStride; +* from += bitmap->DataStride(); +* } +* // ... +* return ETrue; // to continue getting ProduceNewFrameL callbacks +* }; +* +* MAlfBufferProvider::TBufferCreationAttributes& BufferAttributes() { return iAttributes }; +* +* void ContextAboutToSuspend() {}; +* void OnActivation() {}; +* // ... +* } +* +* Example2: +* // client may want or need to adjust ProduceNewFrameL-callbacks inverval +* class CMyClass: public CActive, public MAlfBufferProvider +* { +* private: +* CAlfCompositionPixelSource* iAlfCompositionPixelSource; +* MAlfBufferProvider::TBufferCreationAttributes iAttributes; +* TBool iDrawNext; +* TTimeIntervalMicroSeconds32 iWaitTime; +* RTimer iTimer; +* public: +* +* CMyClass() {} +* +* ConstructL() +* { +* // ... +* iDrawNext = ETrue; +* iWaitTime = 25*1000; +* // ... +* } +* +* void RunL() +* { +* if( iStatus.Int() != KErrNone ) +* { +* iDrawNext = ETrue; +* iAlfCompositionPixelSource->ActivateL(); +* } +* } +* // ... +* TBool ProduceNewFrameL(const TRegion& aVisibleRegion, TUint8*& aBuffer) +* { +* if( iDrawNext ) +* { +* iDrawNext = EFalse; +* } +* else +* { +* iTimer.After( iStatus, iWaitTime ); +* return EFalse; +* } +* // ... +* // copy pixel data to aBuffer +* // ... +* return ETrue; // to continue getting ProduceNewFrameL callbacks +* }; +* // ... +* } +* +* Example3: +* // API can be used withou the actual window +* class CMyClass: public CBase, public MAlfBufferProvider +* { +* private: +* CAlfCompositionPixelSource* iAlfCompositionPixelSource; +* MAlfBufferProvider::TBufferCreationAttributes iAttributes; +* public: +* +* CMyClass() {} +* +* ConstructL() +* { +* // ... +* iAttributes.iWidth = width; +* iAttributes.iHeight = height; +* iAttributes.iFormat = MAlfBufferProvider::ESourceFormatARGB_8888; +* iAttributes.iStride = iAttributes.iWidth * 4; +* iAttributes.iAlignment = 32; +* +* iAlfCompositionPixelSource = CAlfCompositionPixelSource::NewL(*this, NULL); +* iAlfCompositionPixelSource->SetExtent(TRect(0,0,600,300),0,1); +* iAlfCompositionPixelSource->iActivateL(); +* } +* // ... +* TBool ProduceNewFrameL(const TRegion& aVisibleRegion, TUint8*& aBuffer) +* { +* // ... +* // copy pixel data to aBuffer +* // ... +* return ETrue; // to continue getting ProduceNewFrameL callbacks +* }; +* // ... +* +* // Notice: When activating Composition pixel source after being suspended, SetExtent needs to be called again. +* void ContinueAfterSuspendL() +* { +* iAlfCompositionPixelSource->SetExtent(TRect(0,0,600,300),0,1); +* iAlfCompositionPixelSource->iActivateL(); +* } +* } +**/ +class CAlfCompositionPixelSource: public CAlfCompositionSource + { +public: + /** + * Constructor + **/ + IMPORT_C static CAlfCompositionPixelSource* NewL(MAlfBufferProvider& aProvider, RWindow* aWindow = NULL); + + /** + * Activate drawing for the first time or continue drawing if it is being paused or suspended + **/ + IMPORT_C void ActivateL(); + + /** + * Suspend drawing + **/ + IMPORT_C void Suspend(); + + IMPORT_C ~CAlfCompositionPixelSource(); + + /** + * From base class + * Defines extent of the composition target on a defined screen + * Does not affect on hit testing, keyboard focus etc. but is just additional information for composition + **/ + IMPORT_C TInt SetExtent(const TRect& aRect, TInt aScreen); + + /** + * Internal + * For drawing one frame + **/ + TBool DrawFrameL(TRequestStatus& aStatus, TInt aBufferNumber = 0); + +protected: + + /** + * Internal + * From base class + **/ + void HandleEventL(TInt aEventType, TAny* aEventData); + +private: // Internal / utils + + void ConstructL(MAlfBufferProvider& aProvider, RWindow* aWindow); + void ConstructSurfaceL(MAlfBufferProvider::TBufferCreationAttributes& aCreationAttributes); + void FreeSurface(); + TUint8* Buffer(TInt aBufferNumber); + + +private: // data + + class CAlfCompositionPixelSourceData; + CAlfCompositionPixelSourceData* iData; + }; + + +#endif // #define __ALFCOMPOSITIONCLIENT_H__