// Copyright (c) 2005-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:

// WSGRAPHICDRAWERINTEFACE.H

// Server-side base-classes for graphic drawer plugins

// 

//

#ifndef __WSGRAPHICDRAWERINTEFACE_H__

#define __WSGRAPHICDRAWERINTEFACE_H__

#include <e32base.h>

#include <w32std.h>

#include <gdi.h>

#include <bitstd.h>

class CWsGraphicDrawer;

struct TGraphicDrawerId;

class MWsEventHandler;

class CWsGraphicMessageQueue;

class CWsClient;

class CWsWindow;

#if !defined(SYMBIAN_GRAPHICS_GCE)

	class MWsFlickerFreeBufferObserver;

#endif

class MWsScreenRedrawObserver;

class MWsMemoryRelease;

class MEventHandler;

class MWsElement;

class MWsGraphicsContext;

class MWsAnimationScheduler;

/** 

@publishedPartner

@released

*/

enum TWinType

	{

	EWinTypeClient,

	EWinTypeRoot,

	EWinTypeGroup,

	};

/** Declares an object type, ETypeId, for a class, in order to allow the WSERV object

provider mechanism to locate and provide objects from the class.

@publishedPartner

@released

@see MWsObjectProvider */

#define DECLARE_WS_TYPE_ID(id) enum { EWsObjectInterfaceId = id };

class MWsObjectProvider

/** A class for dynamic extension of object instances

	WSERV classes which wish to allow dynamic extension show derive those

	extensions from MWsObjectProvider and use the DECLARE_WS_TYPE_ID macro

	Similiar in principle and operation to CONE's MObjectProvider

	@publishedPartner

	@released

	@see MObjectProvider

*/	{

public:

	template<class T>

	T* ObjectInterface()

	/** Gets an object of the type defined by the template parameter.

	@return A pointer to an object of the type required, or NULL if none can be

	found. */

		{ return (T*)ResolveObjectInterface(T::EWsObjectInterfaceId); }

	/** Gets an object of the type defined by the template parameter.

	@return A pointer to a const object of the type required, or NULL if none can be

	found. */

	template<class T>

	const T* ObjectInterface() const

		{ return (T*)const_cast<MWsObjectProvider*>(this)->ResolveObjectInterface(T::EWsObjectInterfaceId); }

	/** Resolve an instance of an interface

	should be overriden by implementations when they have custom interfaces to provide. */

	IMPORT_C virtual TAny* ResolveObjectInterface(TUint aTypeId);

	};

class MWsScreen: public MWsObjectProvider

/** A destination for a drawing occasion of a CWsGraphicDrawer

	Used by animation schedulers to update screens

	@publishedPartner

	@released

*/	{

public:

	using MWsObjectProvider::ResolveObjectInterface;

private:

	friend class MWsAnimationScheduler;

#if !defined(SYMBIAN_GRAPHICS_GCE)

	/** Called by the MWsAnimationScheduler when scheduled animation is to be serviced

		WARNING: Function for internal use ONLY. Compatibility is not guaranteed in future releases.

		@released */

	virtual void OnAnimation() = 0;

#else

	/** Called by the MWsAnimationScheduler when a scheduled animation is to be serviced.

		@param aFinished If not NULL then this is signalled when the animation has 

		been processed and further animations may be submitted. An animation may be

		submitted prior to signalling, but the render stage pipeline may not be ready

		to process it. 

		WARNING: Function for internal use ONLY. Compatibility is not guaranteed in future releases.

		@released */

	virtual void OnAnimation(TRequestStatus* aFinished) = 0;

#endif

	/** Called by the MWsAnimationScheduler when the screen needs to be redrawn in its entirity

		WARNING: Function for internal use ONLY. Compatibility is not guaranteed in future releases.

		@released */

	virtual void Redraw() = 0;

	/** Called by MWsAnimationScheduler when the any parts of the screen that potentially contain

		commands to draw graphics in the list of IDs passed need to be redrawn

		@param aInvalid the list of IDs that are invalid

		@return whether the screen did any redrawing

		WARNING: Function for internal use ONLY. Compatibility is not guaranteed in future releases.

		@released */

	virtual TBool RedrawInvalid(const TArray<TGraphicDrawerId>& aInvalid) = 0;

	};

/**

@publishedPartner

@prototype

*/

class CWsMessageData : public CBase, public MWsObjectProvider

	{

public:

	virtual TPtrC8 Data() const = 0;

	virtual void Release() = 0;

	IMPORT_C TInt ClientHandle() const;

	IMPORT_C TInt Id() const;

	IMPORT_C const CWsGraphicDrawer* Drawer();

	IMPORT_C void SetClientHandle(TInt aClientHandle);

	IMPORT_C void SetId( TInt aId);

	IMPORT_C void SetDrawer(const CWsGraphicDrawer* aDrawer);

private:

	friend class CWsGraphicMessageQueue;

	friend class CWsClient;

	CWsMessageData* iNext;

	const CWsGraphicDrawer* iDrawer;

	TInt iId;

	TInt iClientHandle;

	TInt iMWsMessageDataSpare[3];

	};

class MWsClient: public MWsObjectProvider

/*** Represents a client session

	@publishedPartner 

	@released  */

	{

public:

	/** Determines if this client has the specified capability */

	virtual TBool HasCapability(TCapability aCapability) const = 0;

	/** Retrieves the Secure ID of the client's process */

	virtual TSecureId SecureId() const = 0;

	/** Retrieves the Vendor ID of the client's process */

	virtual TVendorId VendorId() const = 0;

private:

	friend class CWsGraphicDrawer;

	virtual TInt SendMessage(const CWsGraphicDrawer* aOnBehalfOf,const TDesC8& aData) = 0;

	virtual TInt SendMessage(const CWsGraphicDrawer* aOnBehalfOf,CWsMessageData& aData) = 0;

	};

class MWsGraphicDrawerEnvironment: public MWsObjectProvider

/** The environment for a graphic drawer

@publishedPartner

@released

*/	{

public:

	/** Locate a graphic by ID

	@return the graphic with that ID, else NULL if no such graphic exists */

	virtual const CWsGraphicDrawer* ResolveGraphic(const TGraphicDrawerId& aId) const = 0;

	/** The number of screens the device has; this is constant for a device */

	virtual TInt ScreenCount() const = 0;

	/** Get a particular screen by ordinal

	@return the screen, or NULL if aIndex is out of bounds */

	virtual MWsScreen* Screen(TInt aIndex) = 0;

	/** Get a particular screen by ordinal

	@return the screen, or NULL if aIndex is out of bounds */

	virtual const MWsScreen* Screen(TInt aIndex) const = 0;

	/**  Not supported

	@return success of overriding the default scheduler */

	virtual TBool SetCustomAnimationScheduler(MWsAnimationScheduler* aScheduler) = 0;

	/** Query whether a custom animation scheduler has been set

	@return ETrue if the custom animation scheduler has been set */

	virtual TBool HasCustomAnimationScheduler() const = 0;

	/** Clears a custom animation scheduler

	@return success if the custom scheduler was set, and hence removed */

	virtual TBool ClearCustomAnimationScheduler(MWsAnimationScheduler* aCurrentScheduler) = 0;

protected:

	friend class CWsGraphicDrawer;

	/** Schedules all potentially affected parts of the screen to repaint

	This is called automatically whenever a graphic is added, replaced or removed.

	However, if a graphic which changes representation during runtime must call this

	explicitly.

	Note: this is not a suitable method for animating a graphic.  For animation,

	use MWsGc::Invalidate when the graphic is being drawn to schedule the next

	animation frame instead.

	@param aId the ID of the artwork; the artwork may not exist */

	virtual void Invalidate(const TGraphicDrawerId& aId) = 0;

public:

	/** Register to be notified when some events occur.

	@return KErrNone if successful */

	virtual TInt RegisterEventHandler(CWsGraphicDrawer* aDrawer, MWsEventHandler* aHandler, TUint32 aEventMask) = 0;

	/** Unregister from events notification

	@return KErrNone if successful */

	virtual TInt UnregisterEventHandler(CWsGraphicDrawer* aDrawer) = 0;

	/** Register to be notified when some events occur.

	@return KErrNone if successful

	@prototype */

	virtual TInt RegisterWsEventHandler(MWsEventHandler* aHandler, TUint32 aEventMask) = 0;

	/** Unregister from events notification

	@return KErrNone if successful 

	@prototype */

	virtual TInt UnregisterWsEventHandler(MWsEventHandler* aHandler) = 0;

	/** Logs a message to the wserv logger, if one is loaded

	@param aPriority The priority of the message - low priority is 1, high is 9

	@param aFmt The string to log.  This may contain a single %d, %x or equivalent

	@param aParam An integer parameter corresponding to a %d, if present

	@prototype */

	virtual void Log(TInt aPriority,const TDesC &aFmt,TInt aParam=0) = 0;

	/** Registers an interface for releasing memory in low memory situations.

	The release function may be called as a result of any Alloc or ReAlloc attempts in the window server

	process.

	@param aMemoryRelease a callback interface

	@return KErrNone or a system wide error code

	@prototype */

	virtual TInt RegisterMemoryRelease(MWsMemoryRelease * aMemoryRelease) = 0;

	/** Removes a registration set by RegisterMemoryRelease

	@param aMemoryRelease the registered release object to remove

	@prototype */

	virtual void UnregisterMemoryRelease(MWsMemoryRelease * aMemoryRelease) = 0;

	};

class MWsGc: public MWsObjectProvider

/** A destination for a drawing occasion of a CWsGraphicDrawer

	Used to register invalidation schedules for animation

	@publishedPartner

	@released

*/	{

public:

	/** The Client requesting this drawing occasion

		@return the client

		@publishedPartner 

		@released  */

	virtual MWsClient& Client() = 0;

	/** The screen that is currently being drawn to

		@return the screen

		@publishedPartner 

		@released  */

	virtual MWsScreen& Screen() = 0;

#if !defined(SYMBIAN_GRAPHICS_GCE)

	/** The origin of the GC relative to the screen's origin

		@return the origin

		@publishedPartner

		@released  */

	virtual TPoint GcOrigin() const = 0;

	/** The clipping region currently being used

		@return the clipping region

		@publishedPartner

		@released */

	virtual const TRegion& ClippingRegion() = 0;

	/** The BITGDI graphics context to draw to

		@publishedPartner

		@released */

	virtual CFbsBitGc& BitGc() = 0;

	/** Saves the state of the GC to an internal buffer.  Several GC states can be saved in a FILO.

		Do not restore a GC (using PopBitGcSettings()) that wasn't properly saved!

		@return KErrNone if successful, else one of the system-wide error codes. */

	virtual TInt PushBitGcSettings() = 0;

	/** Restores the last GC state that was saved. */

	virtual void PopBitGcSettings() = 0;

#endif	

	/** The time for the current redraw

		@publishedPartner 

		@released */

	virtual const TTime& Now() const = 0;

	/** Schedule an animation of a rectangle in the future.

	    Scheduled animation doesn't work in low memory conditions or

	    if aRect values fall outside the window area of this animation.

		@param aRect the rectangle to animate, in the GC's coordinates

		@param aFromNow the time in microseconds from Now() that the rectangle will be invalid

		@publishedPartner 

		@released */

	virtual void ScheduleAnimation(const TRect& aRect,const TTimeIntervalMicroSeconds& aFromNow) = 0;

	/** Schedule an animation of a rectangle in the future

		@param aRect the rectangle to animate, in the GC's coordinates

		@param aFromNow the time in microseconds from Now() that the rectangle will be invalid

		@param aFreq microseconds between frames that this rectangle will probably be invalid in the future (0 means no such hint is known)

		@param aStop the duration in microseconds from Now() that the aFreq hint will be valid for (0 means indefinitely)

		@publishedPartner 

		@released */

	virtual void ScheduleAnimation(const TRect& aRect,const TTimeIntervalMicroSeconds& aFromNow,const TTimeIntervalMicroSeconds& aFreq,const TTimeIntervalMicroSeconds& aStop) = 0;

	/** Sets the origin of gc

		@param aOrigin The new origin of the gc

		@publishedPartner 

		@prototype	*/

	virtual void SetGcOrigin(const TPoint& aOrigin) = 0;

	};

/** Interface Extension

*/

enum

	{

	KMWsScreenConfigInterfaceId = 1,

#if !defined(SYMBIAN_GRAPHICS_GCE)

	KMWsBackBufferInterfaceId = 2,

	KMWsFrontBufferInterfaceId = 3,

#endif

	KMWsGraphicDrawerMessageAlloc = 4,

	KMWsGraphicMessageAlloc = 5,

	KWsGraphicHandleSynchronMessageId = 6,

	KWsGraphicMessageCallbackInterfaceId = 7,

	KWsActiveSchedulerDebug = 8,

#if !defined(SYMBIAN_GRAPHICS_GCE)

	KWsFlickerFreeBufferObserver = 9,

#endif

	KMWsWindow = 10,

	KWsScreenRedraw = 11,

	KWsScreenRedrawObserver = 12,

	KCWsRenderStage = 13,

	KMWsRenderStageFactory = 14,

	KMWsMemoryRelease = 15,

#if !defined(SYMBIAN_GRAPHICS_GCE)	

	KMWsGcClipRect = 16,

#endif	

	KMWsFader = 17,

	KMWsPluginManager = 18,

	KMWsIniFile = 19,

	KMWsRawEventServer = 20,

	KMWsPlaceSurfaceId = 21,

#if defined(SYMBIAN_GRAPHICS_GCE)

	KMWsTextCursor = 22,				// CWsRenderStage Object Extension will yield an MWsTextCursor

#endif

	KMWsGraphicsContext = 23,			// CWsRenderStage Object Extension will yield an MWsGraphicsContext

	KMWsCompositionContext = 24,		// CWsRenderStage Object Extension will yield an MWsCompositionContext

										// 		MWsCompositionContext::CreateLayer will yield a MWsLayer

	KMWsEventHandler = 25,				// CWsRenderStage Object Extension will yield an MWsEventHandler

	KMWsScreenDevice = 26,				// CWsRenderStage Object Extension will yield an MWsScreenDevice

	KMWsPalette = 27,					// CWsRenderStage Object Extension will optionally yield an MWsPalette

#if defined(SYMBIAN_GRAPHICS_GCE)

	KMWsUiBufferInterfaceId = 28,		// CWsRenderStage Object Extension will optionally yield an MWsUiBuffer

#endif

	KMWsDebugBar = 29,					// CWsRenderStage Object Extension will optionally yield an MWsDebugBar

	KMWsDrawableSourceProvider = 30,	// CWsRenderStage Object Extension will optionally yield an MWsDrawableSourceProvider

	KMWsScreenConfigListInterfaceId = 31,	//MWsScreen can return this list interface

	KMWsWindowTreeObserver = 32,        // CWsRenderStage Object Extension will optionally yield an MWsWindowTreeObserver

	KMWsDrawAnnotationObserver = 33, 	// CWsRenderStage Object Extension will optionally yield an MWsDrawAnnotationObserver

	KMWsWindowVisibilityNotifier = 34, 	// CWsRenderStage Object Extension will optionally yield an MWsWindowVisibilityNotifier

	KMWsWindowTree = 35,				// Object Extension to be used by render stages for recovery of MWsWindowTree

	KMWsScene = 36,                     // CWsRenderStage Object Extension will yield an MWsScene

	                                    //      MWsScene::CreateSceneElement will yield a MWsElement

	};

class TSurfaceConfiguration;

/** Extension to GC to allow surface placement.

@publishedPartner

@prototype

@deprecated

NOTE: This interface is deprecated. Do not use!

*/

class MWsSurfacePlacement: public MWsObjectProvider

	{

	public:

	DECLARE_WS_TYPE_ID(KMWsPlaceSurfaceId)

	virtual TInt	PlaceSurface(const TSurfaceConfiguration& aConfig)=0;

	};

/** Current screen mode configuration.Values return from this interface shall not be cached as they

can change at anytime when wserv changes its screen mode. Plugin can listen to event EScreenSizeModeChanged

to be notified when it happens.

@publishedPartner

@released

*/

class MWsScreenConfig: public MWsObjectProvider

	{

public:

	DECLARE_WS_TYPE_ID(KMWsScreenConfigInterfaceId)

	/** Get screen display mode */

	virtual TDisplayMode DisplayMode() const = 0;

	/** Get physical screen size in pixels */

	virtual TSize SizeInPixels() const = 0;

	/** Get screen size in pixels for current screen size mode as defined in wsini */

	virtual TSize ScreenModeSizeInPixels() const = 0;

	/** Get frame buffer line pitch */

	virtual TInt Stride() const = 0;

	/** Get screen orientation */

	virtual CFbsBitGc::TGraphicsOrientation Orientation() const = 0;

	/** Get screen size mode */

	virtual TInt SizeMode() const = 0;

	/** Get screen scaling factor */

	virtual TSize ScalingFactor() const = 0;

	/** Get screen origin */

	virtual TPoint Origin() const = 0;

	/** Get screen scaled origin */

	virtual TPoint ScaledOrigin() const = 0;

	};

/**	Available list of screen modes as specified during start-up.

 * 	This interface can generally be enquired from the MWsScreen instance.

 * 	Can be read by render stage to configure its Display Configuration policy.

 * 	

 * 	Note that mode list is not contiguous, so methods may leave if missing index is requested.

 **/

class MWsScreenConfigList: public MWsObjectProvider

	{

public:

	DECLARE_WS_TYPE_ID(KMWsScreenConfigListInterfaceId)

	enum	TModeFlags

		{

		EDynamic=			0x00000001,		//"-1,-1"

		EHighRes=			0x00000002,		//High-res policy mode

		EDisconnected=		0x00000004,		//Mode to use when disconnected

		EHalDefault=		0x00000008,

		ETwipsSpecified=	0x00000010,

		EClientDefinedDigitiserArea=	0x00000020,	

		};

	/** Get  list of valid display modes - may be sparse **/

	virtual TInt	GetScreenSizeModeList(RArray<TInt>&aList) const =0;

	/** Get screen display mode */

	virtual TDisplayMode DisplayModeL(TInt aIndex) const = 0;

	/** Get screen size in pixels for current screen size mode as defined in wsini */

	virtual TSize ScreenModeSizeInPixelsL(TInt aIndex) const = 0;

	/** Get screen size in twips for current screen size mode as defined in wsini */

	virtual TSize ScreenModeSizeInTwipsL(TInt aIndex) const = 0;

	/** Get screen orientation */

	virtual CFbsBitGc::TGraphicsOrientation OrientationL(TInt aIndex) const = 0;

	/** Get screen orientation */

	virtual TInt AvailableOrientationsL(TInt aIndex) const = 0;

	/** Get screen scaling factor - note this is expected to stay at 1:1 */

	virtual TSize ScalingFactorL(TInt aIndex) const = 0;

	/** Get screen origin */

	virtual TPoint OriginL(TInt aIndex) const = 0;

	/** Get screen scaled origin - note this is expected to stay at 1:1  */

	virtual TPoint ScaledOriginL(TInt aIndex) const = 0;

	/** Get the modeflags for specified mode  */

	virtual TInt ModeFlagsL(TInt aIndex) const = 0;

	};

class MWsWindowTree : public MWsObjectProvider

	{

public:	

	DECLARE_WS_TYPE_ID(KMWsWindowTree)

	virtual void SendTree() const = 0;

	};

#if !defined(SYMBIAN_GRAPHICS_GCE)

/** Wserv flickerfree buffer access

@publishedPartner

@released

*/

class MWsBackBuffer: public MWsObjectProvider

	{

public:

	DECLARE_WS_TYPE_ID(KMWsBackBufferInterfaceId)

	/** Get wserv flickerfree buffer bitmap

	*/

	virtual CFbsBitmap* GetBitmap() = 0;

	/** Get default wserv flickerfree buffer drawing context. This will always return the original

	context not the current context (e.g. not the redirecting context when it is redirected).

	*/

	virtual CFbsBitGc* GetBitGc() = 0;

	/** Set wserv flickerfree buffer drawing context to redirect its drawing output. Drawing context must

	have been activated on a device prior calling this function.

	@param aBitGc The context where flickerfree buffer drawing output is redirected to. If it is NULL

	the redirection will be cancelled and default drawing context will be restored.

	@return KErrNone if successful, otherwise one of system-wide error codes.

	*/

	virtual TInt SetBitGc(CFbsBitGc* aBitGc) = 0;

	/** Redirects drawing to another back buffer. Target back buffer must provide bitmap and drawing context

	which has been activated on a bitmap device.

	@param aTarget Target back buffer where drawing is redirected to. If it is NULL

	the redirection will be terminated.

	@return KErrNone if successful, otherwise one of system-wide error codes.

	@prototype

	*/

	virtual TInt RedirectTo(MWsBackBuffer* aTarget) = 0;

	/** Sets the back buffers observer.  The observer will be called just before and just after each

	complete sequence of drawing to the back buffer.

	@param aObserver The observer handling the callbacks

	@prototype

	*/

	virtual void SetObserver(MWsFlickerFreeBufferObserver* aObserver) = 0;

	/** This returns the observer set by SetObserver.

	@return The observer set by SetObserver, or NULL

	@prototype

	*/

	virtual MWsFlickerFreeBufferObserver* Observer() = 0;

	/** Get current wserv flickerfree buffer drawing context. This will return the redirected context 

	when it is set.

	@return The graphics context to use to draw to the flicker buffer directly.

	@prototype

	*/

	virtual CFbsBitGc* GetBitGcCurrent() = 0;

	};

/** Wserv screen buffer access