// 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:

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

 // 

 //

 #ifndef __WSGRAPHICDRAWER_H__

 #define __WSGRAPHICDRAWER_H__

 #include <e32base.h>

 #include <e32std.h>

 #include <graphics/wsgraphicdrawerinterface.h>

 class CFbsBitGc;

 class TSurfaceId;

 NONSHARABLE_STRUCT(TGraphicDrawerId)

 /** Represents a graphic drawer on the window-server side

 A much-abridged version of TWsGraphicId, with trivial constructor

 @publishedPartner

 @released

 */	{

 	TInt iId;

 	TBool iIsUid;

 	IMPORT_C TInt Compare(const TGraphicDrawerId& aOther) const;

 	IMPORT_C static TInt Compare(const TGraphicDrawerId& aFirst,const TGraphicDrawerId& aSecond);

 	};

 /** Wserv event representation to plugin side

 @publishedPartner

 @released

 */

 NONSHARABLE_STRUCT(TWservCrEvent)

 	{

 public:

 	/** Type of wserv events which plugin can listen to. It is a mask that can be combined

 	when subscribing to notification. */

 	enum

 		{

 		EScreenSizeModeChanged		= 0x00000001,

 		EWindowVisibilityChanged 	= 0x00000002,

 		EDsaDrawingBegin			= 0x00000004,

 		EDsaDrawingEnd				= 0x00000008,

 		EScreenSizeModeAboutToChange= 0x00000010,

 		EScreenUpdated				= 0x00000020,

 		EScreenDrawing				= 0x00000040,

 		EWindowGroupChanged			= 0x00000080,

 		EScreenOrientationChanged	= 0x00000100,

 		EDeviceOrientationChanged	= 0x00000200,

 		EWindowClosing              = 0x00000400,

 		ESurfaceUnreferenced		= 0x00000800,

 		};

 public:

 	IMPORT_C TWservCrEvent(TUint32 aType);

 	IMPORT_C TWservCrEvent(TUint32 aType, TUint32 aInfo);

 	IMPORT_C TWservCrEvent(TUint32 aType, TUint32 aInfo, TAny* aData);

 	IMPORT_C TWservCrEvent(TUint32 aType, TUint32 aInfo, TAny* aData, MWsWindow* aWindow);

 	/** Returns wserv event type */

 	IMPORT_C TUint32 Type() const;

 	/** Returns current wserv screen size mode as the result of event EScreenSizeModeChanged.

 	Screen mode is 0,1,2,...

 	*/

 	IMPORT_C TInt SizeMode() const;

 	/** Returns visibile region as the result of event EWindowVisibilityChanged, this region represents

 	full or some part of window which is changing visibility. NULL if window is becoming not visible

 	completely.

 	*/

 	IMPORT_C const RRegion* VisibleRegion() const;

 	/** Returns screen number where a DSA, screen updated or window group changed event occurs

 	*/

 	IMPORT_C TInt ScreenNumber() const;

 	/** Returns the drawing region which is referred to by an EScreenDrawing

 	*/

 	IMPORT_C const TRegion* DrawingRegion() const;

 	/** Returns the new window group identifier where a window group changed event occurs

 	*/

 	IMPORT_C TInt WindowGroupIdentifier() const;

 	/** Returns the new window server display oriention

 	*/

 	IMPORT_C CFbsBitGc::TGraphicsOrientation Orientation() const;

 	/** Returns whether or not a window was already visible before a visibility event occurred

 	*/

 	IMPORT_C TBool WasVisible() const;

 	/** Returns the window this event is for.  This may be null.

 	@prototype

 	*/

 	IMPORT_C MWsWindow* Window() const;	

 	/** Returns the released surface ID

 	*/

 	IMPORT_C const TSurfaceId* SurfaceId() const;

 private:

 	TWservCrEvent() {}

 private:

 	TUint32 iType;

 	TUint32 iInfo;

 	TAny* iData;

 	MWsWindow* iWindow;

 	TInt iReserved[7];

 	};

 /** Event notification callback. Need to be implemented to allow CWsGraphicDrawer to listen to

 wserv events.

 @publishedPartner

 @released

 */

 class MWsEventHandler

 	{

 public:

 	/** Plugin event handler, will be called once for each event.

 	*/

 	virtual void DoHandleEvent(const TWservCrEvent& aEvent) = 0;

 	};

 /**

 Implementing this interface will give a callback notification wheater a

 graphic message which was sent has either failed or succeded.

 @publishedPartner

 @prototype

 */

 class MWsGraphicMessageCallback : public MWsObjectProvider

  	{

 public:

  	DECLARE_WS_TYPE_ID(KWsGraphicMessageCallbackInterfaceId)

 public:

  	/**

  	Called with unique ID of the message, aError will be set to KErrNone if message delivery is

  	successful, otherwise one of the system-wide error code.

  	*/

  	virtual void HandleMessageDelivery(TInt aMessageId, TInt aError) = 0;

  	};

 /**

 Implementing this interface will give you the possibility to send synchron messages with a returnvalue to the client.

 @publishedPartner

 @prototype

 */

 class MWsGraphicHandleSynchronMessage: public MWsObjectProvider

  	{

 public:

  	DECLARE_WS_TYPE_ID(KWsGraphicHandleSynchronMessageId)

 public:

  	/**

 	Synchron handlemessage method.

 	*/

 	virtual TInt HandleSynchronMessage(const TDesC8& aData) = 0;

 	};

 class CWsGraphicDrawer: public CBase, public MWsObjectProvider

 /** A window-server-side peer to a CWsGraphic

 @publishedPartner

 @released

 */	{

 public:

 	/** This function should be overriden by all derived classes.  The first call the implementation of this function

 		should make is to BaseConstructL().

 		@param aEnv the environment this drawer exists in

 		@param aId the ID of this drawer

 		@param aOwner the client session that owns this drawer

 		@param aData arbitrary data for constructing this instance, sent from the client.

 	*/

 	virtual void ConstructL(MWsGraphicDrawerEnvironment& aEnv,const TGraphicDrawerId& aId,MWsClient& aOwner,const TDesC8& aData) = 0;

 	IMPORT_C ~CWsGraphicDrawer();

 	IMPORT_C const TGraphicDrawerId& Id() const;

 	IMPORT_C const MWsClient& Owner() const;

 	IMPORT_C TBool IsSharedWith(TSecureId aClientId) const;

 	IMPORT_C TInt ShareGlobally();

 	IMPORT_C TInt UnShareGlobally();

 	IMPORT_C TInt Share(TSecureId aClientId);

 	IMPORT_C TInt UnShare(TSecureId aClientId);

 	IMPORT_C void Draw(MWsGc& aGc,const TRect& aRect,const TDesC8& aData) const;

 	IMPORT_C TBool Contains(const TArray<TGraphicDrawerId>& aIds) const;

 	virtual void HandleMessage(const TDesC8& aData) = 0;

 	IMPORT_C void HandleEvent(const TWservCrEvent& aEvent);

 	IMPORT_C void SetEventHandler(MWsEventHandler* aHandler);

 	IMPORT_C TBool HasEventHandler() const;

 protected:

 	IMPORT_C CWsGraphicDrawer();

 	IMPORT_C void BaseConstructL(MWsGraphicDrawerEnvironment& aEnv,const TGraphicDrawerId& aId,MWsClient& aOwner);

 	IMPORT_C MWsGraphicDrawerEnvironment& Env();

 	IMPORT_C const MWsGraphicDrawerEnvironment& Env() const;

 	IMPORT_C TInt SendMessage(const TDesC8& aData);

 	IMPORT_C TInt SendMessage(CWsMessageData& aData);

 	IMPORT_C void Invalidate();

 private:

 	IMPORT_C virtual TBool HasAsChild(const TArray<TGraphicDrawerId>& aIds) const;

 	virtual void DoDraw(MWsGc& aGc,const TRect& aRect,const TDesC8& aData) const = 0;

 private:

 	class CPimpl;

 	friend class CPimpl;

 	CPimpl* iPimpl;

 	TInt iWsGraphicDrawerSpare[3];

 private:

 	friend class WsGraphicDrawer;

 	TUid iDtor_ID_Key;

 	};

 #endif //#ifndef __WSGRAPHICDRAWER_H__