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