--- /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 <e32hashtab.h>
+#include <alf/alfcompositionutility.h>
+
+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<TInt, TInt> iHostBindingsHash;
+ RHashMap<TInt, TInt32> 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__