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

// The client-side representation of a WsGraphic artwork

// 

//

#include <w32std.h>

#include "../SERVER/w32cmd.h"

#include "w32comm.h"

#include "CLIENT.H"

#include <s32mem.h>

#include <graphics/WSGRAPHICDRAWERINTERFACE.H>

NONSHARABLE_STRUCT(CWsGraphic::CPimpl): public CBase, public MWsClientClass

/** @internalComponent @released */

	{

	friend class CWsGraphic;

	enum

		{

		/** is registered in the graphic manager's array */

		ERegistered = 0x01,

		/** has a peer CWsGraphicDrawer on the server */

		EHasPeer	= 0x02

		};

	CPimpl(CWsGraphic& aGraphic);

	~CPimpl();

	void ConstructL();		//LeaveScan: Member of macroised structure declaration.

	CManager* iManager;

	TInt WriteCreateGraphic(TWsClCmdCreateGraphic& aCreateGraphic,const TDesC8& aData,TInt aWsHandle) const;

	CWsGraphic& iGraphic;

	TWsGraphicId iId;

	TUint iFlags;

	MWsObjectProvider* iExt;

	};

LOCAL_C void MWsGraphicMessageAllocRelease(TAny* aAny)

	{

	MWsGraphicMessageAlloc::MBuffer* buf = static_cast<MWsGraphicMessageAlloc::MBuffer*>(aAny);

	if(buf)

		{

		buf->Release();

		}

	}

NONSHARABLE_CLASS(CWsGraphic::CManager): private CActive, public RWsSession

/** Client-side manager singleton for marshalling messages for all CWsGraphics owned by a client

@publishedAll

@released

*/	{

public:

	static CManager* StaticL();			  //LeaveScan:  Member of macroised structure declaration.

	// used by CWsGraphic

	void AddL(CWsGraphic* aGraphic);	  //LeaveScan:  Member of macroised structure declaration.

	void Replace(CWsGraphic* aGraphic);

	void Remove(CWsGraphic* aGraphic);

	CWsGraphic* Find(const TWsGraphicId& aId);

	void Inc();

	void Dec();

	RWsBuffer* Buffer();

	void ScheduleFlush();

private:

	CManager();

	~CManager();

	void ConstructL();					 //LeaveScan:  Member of macroised structure declaration.

	void Queue();

	void RunL();						 //LeaveScan:  Member of macroised structure declaration.

	void DoCancel();

	static TInt GraphicCompare(const CWsGraphic& aFirst,const CWsGraphic& aSecond);

	static TInt FlushOnIdle(TAny* aArg);

private:

	TInt iRefCount;

	RPointerArray<CWsGraphic> iArray;

	CIdle* iFlusher;

	TBool iFlushScheduled;

	};

// TWsGraphicId \\\\\\\\\\\\\\\\\\\\\\\\

EXPORT_C TWsGraphicId::TWsGraphicId(TUid aUid):

/** Construct a UID

    @param aUid UID of the graphic artwork.

    @publishedAll @released

*/	iFlags(EWsGraphicIdUid), iId(aUid.iUid)

	{

	}

EXPORT_C TWsGraphicId::TWsGraphicId(TInt aId):

/** Construct a transient Id

	@publishedAll @released

*/	iFlags(EWsGraphicIdTransient), iId(aId)

	{

	}

/** 

Copy constructor.

@param aCopy Graphic artwork Id.

*/

EXPORT_C TWsGraphicId::TWsGraphicId(const TWsGraphicId& aCopy):

	iFlags(aCopy.iFlags), iId(aCopy.iId)

	{

	}

EXPORT_C TUid TWsGraphicId::Uid() const

/** Returns UID.

    @return UID of graphic artwork. KNullUid if graphic artwork is transient.

    @publishedAll @released

*/	{

	if(IsUid())

		{

		return TUid::Uid(iId);

		}

	return KNullUid;

	}

EXPORT_C TBool TWsGraphicId::IsUid() const

/** Identifies whether graphic artwork is non-transient.

    @return ETrue if graphic artwork is non-transient.

    @publishedAll @released

*/	{

	return (iFlags & EWsGraphicIdUid);

	}

EXPORT_C void TWsGraphicId::Set(TUid aUid)

/** Set to be a UID

	@publishedAll @released

*/	{

	iId = aUid.iUid;

	iFlags = EWsGraphicIdUid;

	}

EXPORT_C TInt TWsGraphicId::Id() const

/** Returns the transient Id.

    @return Id of transient graphic artwork. Zero if graphic artwork is non-transient.

	@publishedAll @released

*/	{

	if(IsId())

		{

		return iId;

		}

	return 0;

	}

EXPORT_C TBool TWsGraphicId::IsId() const

/** Identifies whether graphic artwork is transient.

    @return ETrue if graphic artwork is transient.

    @publishedAll @released

*/	{

	return (iFlags & EWsGraphicIdTransient);

	}

EXPORT_C void TWsGraphicId::Set(TInt aId)

/** Set to be a transient Id

	@publishedAll @released

*/	{

	iId = aId;

	iFlags = EWsGraphicIdTransient;

	}

EXPORT_C TInt TWsGraphicId::Compare(const TWsGraphicId& aOther) const

/** Compares another Id with this one.

	@return 0 if the other Id is identical, else -1 if the other Id is to greater than or 1 if the other Id is less than

	@publishedAll @released

*/	{

	if(iId < aOther.iId)

		{

		return -1;

		}

	else if(iId > aOther.iId)

		{

		return 1;

		}

	// else we have to compare the iIsUid flag too; again, expect it to be a match 99.99% of these times

	else if(IsUid() == aOther.IsUid())

		{

		return 0;

		}

	// collisions of id but not iIsUid are going to be really really rare

	else if(IsUid())

		{

		return 1;

		}

	else

		{

		return -1;

		}

	}

// CWsGraphicManager \\\\\\\\\\\\\\\\\\\\\\\\

CWsGraphic::CManager* CWsGraphic::CManager::StaticL()

	{

	CManager* singleton = RWsBuffer::WsGraphicManager();

	if(!singleton)

		{

		singleton = new(ELeave) CManager;

		CleanupStack::PushL(singleton);

		singleton->ConstructL();

		CleanupStack::Pop(singleton);

		__ASSERT_DEBUG(singleton == RWsBuffer::WsGraphicManager(),Panic(EW32PanicGraphicInternal));

		}

	return singleton;

	}

CWsGraphic::CManager::~CManager()

	{

	__ASSERT_DEBUG(!ResourceCount(),Panic(EW32PanicGraphicInternal));

	__ASSERT_DEBUG(!iArray.Count(),Panic(EW32PanicGraphicOrphaned));

	Close();

	__ASSERT_DEBUG(!RWsBuffer::WsGraphicManager(),Panic(EW32PanicGraphicInternal));

	iArray.Close();

	delete iFlusher;

	}

CWsGraphic::CManager::CManager(): CActive(CActive::EPriorityStandard)

	{

	}

void CWsGraphic::CManager::ConstructL()

	{

	User::LeaveIfError(Connect());

	iBuffer->SetWsGraphicManager(this);

	CActiveScheduler::Add(this);

	// coverity[negative_returns]

	iFlusher = CIdle::NewL(CActive::EPriorityIdle);

	}

void CWsGraphic::CManager::Inc()

	{

	iRefCount++;

	}

void CWsGraphic::CManager::Dec()

	{

	if(!--iRefCount)

		{

		delete this;

		}

	}

RWsBuffer* CWsGraphic::CManager::Buffer()

	{

	return iBuffer;

	}

// used by CWsGraphic

void CWsGraphic::CManager::AddL(CWsGraphic* aGraphic)

/** Leaves if the graphic couldn't be added to the list

	@internalComponent @released */

	{

	__ASSERT_ALWAYS(aGraphic && aGraphic->iPimpl,Panic(EW32PanicGraphicInternal));

	__ASSERT_ALWAYS(aGraphic->Id().IsId() || aGraphic->Id().IsUid(),Panic(EW32PanicGraphicInternal));

	__ASSERT_ALWAYS(!(aGraphic->iPimpl->iFlags & CWsGraphic::CPimpl::ERegistered),Panic(EW32PanicGraphicInternal));

	iArray.InsertInOrderL(aGraphic,GraphicCompare);

	__ASSERT_ALWAYS(0 <= iArray.FindInOrder(aGraphic,GraphicCompare),Panic(EW32PanicGraphicInternal));

	aGraphic->iPimpl->iFlags |= CWsGraphic::CPimpl::ERegistered;

	Queue();

	}

void CWsGraphic::CManager::Replace(CWsGraphic* aGraphic)

/** @internalComponent @released */

	{

	__ASSERT_ALWAYS(aGraphic && aGraphic->iPimpl,Panic(EW32PanicGraphicInternal));

	__ASSERT_ALWAYS(!(aGraphic->iPimpl->iFlags & CWsGraphic::CPimpl::ERegistered),Panic(EW32PanicGraphicInternal));

	__ASSERT_ALWAYS(aGraphic->Id().IsId() || aGraphic->Id().IsUid(),Panic(EW32PanicGraphicInternal));

	const TInt idx = iArray.FindInOrder(aGraphic,GraphicCompare);

	__ASSERT_ALWAYS(0 <= idx,Panic(EW32PanicGraphicInternal));

	__ASSERT_ALWAYS(iArray[idx]->iPimpl->iFlags & CWsGraphic::CPimpl::ERegistered,Panic(EW32PanicGraphicInternal));

	iArray[idx]->iPimpl->iFlags &= ~CWsGraphic::CPimpl::ERegistered;

	iArray[idx] = aGraphic;

	iArray[idx]->iPimpl->iFlags |= CWsGraphic::CPimpl::ERegistered;

	Queue();

	}

void CWsGraphic::CManager::Remove(CWsGraphic* aGraphic)

/** @internalComponent @released */

	{

	__ASSERT_ALWAYS(aGraphic && aGraphic->iPimpl,Panic(EW32PanicGraphicInternal));

	__ASSERT_ALWAYS(aGraphic->Id().IsId() || aGraphic->Id().IsUid(),Panic(EW32PanicGraphicInternal));

	__ASSERT_ALWAYS(aGraphic->iPimpl->iFlags & CWsGraphic::CPimpl::ERegistered,Panic(EW32PanicGraphicInternal));

	const TInt idx = iArray.FindInOrder(aGraphic,GraphicCompare);

	__ASSERT_ALWAYS(0 <= idx,Panic(EW32PanicGraphicInternal));

	iArray[idx]->iPimpl->iFlags &= ~CWsGraphic::CPimpl::ERegistered;

	iArray.Remove(idx);

	if(!iArray.Count())

		{

		Cancel();

		}

	}

CWsGraphic* CWsGraphic::CManager::Find(const TWsGraphicId& aId)

/** Find the active artwork identified by the Id

	@return NULL if no active artwork has the Id

	@publishedAll @released */

	{

	/*	RPointerArray can only FindInOrder other T*, which is a needless shame.  Therefore this search is

		dumb sequential */

	const TInt count = iArray.Count();

	for(TInt i=0; i<count; i++)

		{

		CWsGraphic* graphic = iArray[i];

		__ASSERT_ALWAYS(graphic && graphic->iPimpl && (graphic->iPimpl->iFlags & CWsGraphic::CPimpl::ERegistered),Panic(EW32PanicGraphicInternal));

		const TWsGraphicId& candidate = graphic->Id();

		if(0 == candidate.Compare(aId))

			{

			// found

			__ASSERT_DEBUG(i == iArray.FindInOrder(graphic,GraphicCompare),Panic(EW32PanicGraphicInternal));

			return graphic;

			}

		}

	// not found

	return NULL;

	}

void CWsGraphic::CManager::Queue()

	{

	if(!IsActive())

		{

		GraphicMessageReady(&iStatus);

		SetActive();

		}

	}

void CWsGraphic::CManager::RunL()

   	{

   	if(0 < iStatus.Int())

   		{

   		// a message to fetch!

   		const TInt msgLen = iStatus.Int();

 		TPtr8 buf(NULL,0);

 		MWsGraphicMessageAlloc* allocator = NULL;

 		MWsGraphicMessageAlloc::MBuffer* theirBuf = NULL;

 		HBufC8* ourBuf = HBufC8::New(msgLen);

 		if(ourBuf)

 			{

 			CleanupStack::PushL(ourBuf);

 			buf.Set(ourBuf->Des());

 			}

 		else // try to see if the destination CWsGraphic can allocate for us

 			{

			const TInt handle = GraphicFetchHeaderMessage();

			CWsGraphic* dest = reinterpret_cast<CWsGraphic*>(handle & ~0x03);

 			// check if it's valid

 			if(KErrNotFound != iArray.Find(dest) && dest->iPimpl && dest->iPimpl->iExt)

 				{

 				// check if the client is able to alloc memory for us

 				allocator = dest->iPimpl->iExt->ObjectInterface<MWsGraphicMessageAlloc>();

 				if(allocator)

 					{

 					// allocate memory

 					theirBuf = allocator->Alloc(msgLen);

 					if(theirBuf)

 						{

 						CleanupStack::PushL(TCleanupItem(MWsGraphicMessageAllocRelease,theirBuf));

 						buf.Set(theirBuf->Buffer());

 						}

 					}

 				}

 			}

 		if(!ourBuf && !theirBuf)

 			{

 			GraphicMessageCancel();

 			GraphicAbortMessage(KErrNoMemory);

 			}

 		else

 			{

 			GetGraphicMessage(buf);

 			// decode header and body

 			RDesReadStream in(buf);

 			in.PushL();

 			const TInt header = in.ReadInt32L();

 			__ASSERT_COMPILE(sizeof(header) == sizeof(TInt32));

 			const TInt clientHandle = (header & ~0x03);

 			const TInt msgType = (header & 0x03);

 			const TPtr8 body = buf.MidTPtr(sizeof(header));

 			// dispatch

 			CWsGraphic* dest = (CWsGraphic*)clientHandle;

 			if(KErrNotFound != iArray.Find(dest))

 				{

 				switch(msgType)

 					{

 					case EWsGraphMessageTypeUser:

 						dest->HandleMessage(body);

 						break;

 					default:

 						Panic(EW32PanicGraphicInternal);

 					}

 				}

 			// done

 			in.Pop();

 			}

 		if(ourBuf)

 			{

 			CleanupStack::PopAndDestroy(ourBuf);

 			}

 		else if(theirBuf)

 			{

 			CleanupStack::PopAndDestroy(theirBuf);

 			}

 		// done, wait for next message

 		Queue();

 		}

 	}

void CWsGraphic::CManager::DoCancel()

	{

	GraphicMessageCancel();

	}

TInt CWsGraphic::CManager::GraphicCompare(const CWsGraphic& aFirst,const CWsGraphic& aSecond)

/** Compares two graphics for id equality

@internalComponent

@released

*/	{

	return aFirst.Id().Compare(aSecond.Id());

	}

void CWsGraphic::CManager::ScheduleFlush()

/** Request to schedule flush when idle

@internalComponent

@released

*/

	{

	if (iFlushScheduled)

		return;

	iFlushScheduled = ETrue;

	iFlusher->Start(TCallBack(CWsGraphic::CManager::FlushOnIdle,this));

	}

TInt CWsGraphic::CManager::FlushOnIdle(TAny* aArg)

/** Flush buffer when idle and there is outstanding data in it

@internalComponent

@released

*/

	{

	CWsGraphic::CManager* mgr = reinterpret_cast<CWsGraphic::CManager*>(aArg);

	if (mgr)

		{

		mgr->iFlushScheduled = EFalse;

		if (mgr->iBuffer && !mgr->iBuffer->IsEmpty())

			mgr->iBuffer->Flush();

		}

	return 0; // complete

	}

// CWsGraphic::CPimpl \\\\\\\\\\\\\\\\\\\\\\\\

CWsGraphic::CPimpl::CPimpl(CWsGraphic& aGraphic):

	iGraphic(aGraphic), iId(TWsGraphicId::EUninitialized)

	{

	}

CWsGraphic::CPimpl::~CPimpl()

	{

	if(iManager)

		{

		iManager->Dec();

		}

	}

void CWsGraphic::CPimpl::ConstructL()

	{

	iManager = CManager::StaticL();

	iManager->Inc();

	iBuffer = iManager->Buffer();

	}

TInt CWsGraphic::CPimpl::WriteCreateGraphic(TWsClCmdCreateGraphic& aCreateGraphic,const TDesC8& aData,TInt aWsHandle) const

/** Writes the CreateGraphic message to the server.  If the data will not fit in the buffer, uses remote-read

	@internalComponent @released */

	{

	aCreateGraphic.iDataLen = aData.Size();

	aCreateGraphic.iRemoteReadData = ((aData.Size()+sizeof(aCreateGraphic))>(TInt)(iBuffer->BufferSize()-sizeof(TWsCmdHeader)));

	if(aCreateGraphic.iRemoteReadData)

		{

		return iBuffer->WriteReplyByProvidingRemoteReadAccess(aWsHandle,EWsClOpCreateGraphic,&aCreateGraphic,sizeof(aCreateGraphic),&aData);

		}

	else if(aCreateGraphic.iDataLen)

		{

		return iBuffer->WriteReplyWs(&aCreateGraphic,sizeof(aCreateGraphic),aData.Ptr(),aData.Size(),EWsClOpCreateGraphic);

		}

	else

		{

		return iBuffer->WriteReplyWs(&aCreateGraphic,sizeof(aCreateGraphic),EWsClOpCreateGraphic);

		}

	}

// CWsGraphic \\\\\\\\\\\\\\\\\\\\\\\\

/** 

Default Constructor.

*/

EXPORT_C CWsGraphic::CWsGraphic()

	{

	}

/**

Destructor.

*/

EXPORT_C CWsGraphic::~CWsGraphic()

	{

	Destroy();

	delete iPimpl;

	}

/**

Completes construction of the baseclass. All the overloaded BaseConstructL() methods

should invoke this method to complete the construction of the baseclass.

*/

void CWsGraphic::BaseConstructL()

	{

	iPimpl = new(ELeave) CPimpl(*this);

	iPimpl->ConstructL();

	}

EXPORT_C void CWsGraphic::BaseConstructL(TUid aUid,TUid aType,const TDesC8& aData)

/** 

Constructs a piece of non-transient graphic artwork.

@capability ProtServ

@param aUid	Graphic artwork UID.

@param aType Graphic artwork type.

@param aData User specific data.

*/	{

	BaseConstructL();

	TWsClCmdCreateGraphic createGraphic;

	createGraphic.iFlags = EWsGraphicIdUid;

	createGraphic.iId = aUid.iUid;

	createGraphic.iType = aType;

	createGraphic.iClientHandle = (TInt)this;

	TInt ret = iPimpl->WriteCreateGraphic(createGraphic,aData,iPimpl->iManager->WsHandle());

	User::LeaveIfError(ret);

	iPimpl->iWsHandle=ret;

	iPimpl->iId = aUid;

	iPimpl->iFlags = CPimpl::EHasPeer;

	iPimpl->iManager->AddL(this);

	}

EXPORT_C void CWsGraphic::BaseConstructL(TUid aType,const TDesC8& aData)

/** 

Constructs a piece of transient graphic artwork.

@param aType Graphic artwork type.

@param aData User specific data.

*/

	{

	BaseConstructL();

	TWsClCmdCreateGraphic createGraphic;

	createGraphic.iFlags = EWsGraphicIdTransient;

	createGraphic.iId = 0;

	createGraphic.iType = aType;

	createGraphic.iClientHandle = (TInt)this;

	TInt ret = iPimpl->WriteCreateGraphic(createGraphic,aData,iPimpl->iManager->WsHandle());

	User::LeaveIfError(ret);

	iPimpl->iWsHandle = ret;

	// fetch id from server

	TPckgBuf<TWsClCmdGdGetId> cmd;

	User::LeaveIfError(iPimpl->WriteReplyP(TWriteDescriptorType(&cmd),EWsGdOpGetGraphicId));

	if(cmd().iIsUid)

		{

		__DEBUG_ONLY(Panic(EW32PanicGraphicInternal));

		User::Leave(KErrGeneral);

		}

	iPimpl->iId = cmd().iId;

	iPimpl->iFlags = CPimpl::EHasPeer;

	iPimpl->iManager->AddL(this);

	}

EXPORT_C void CWsGraphic::BaseConstructL(const TWsGraphicId& aReplace,TUid aType,const TDesC8& aData)

/** 

Atomically replace the artwork that already exists with this artwork.

If failure to properly construct the replacement artwork occurs, the replacee artwork will remain

@param aReplace Graphic artwork which will be replaced.

@param aType New graphic artwork type.

@param aData User specific data.

*/

	{

	BaseConstructL();

	CWsGraphic* dup = iPimpl->iManager->Find(aReplace);

	if(!dup || !dup->iPimpl)

		{

		Panic(EW32PanicGraphicInternal);

		}

	const TUint flags = aReplace.IsUid()?EWsGraphicIdUid:EWsGraphicIdTransient;

	TWsClCmdCreateGraphic createGraphic;

	createGraphic.iFlags = EWsGraphicReplace|flags;

	createGraphic.iId = aReplace.IsUid()?aReplace.Uid().iUid:aReplace.Id();

	createGraphic.iType = aType;

	createGraphic.iClientHandle = (TInt)this;

	TInt ret = iPimpl->WriteCreateGraphic(createGraphic,aData,iPimpl->iManager->WsHandle());

	if(0 > ret)

		{

		User::Leave(ret);

		}

	iPimpl->iWsHandle = ret;

	iPimpl->iId = aReplace;

	iPimpl->iFlags = CPimpl::EHasPeer;

	iPimpl->iManager->Replace(this);

	// when WriteCreateGraphic succeeds, the replacee drawer has already been destroyed serverside

	// so this cleanup is not quite the same as Destroy(), as it doesn't free server side

	// coverity[var_deref_op]

	dup->iPimpl->iWsHandle = 0;

	dup->OnReplace();

	dup->iPimpl->iFlags &= ~CPimpl::EHasPeer;

	}

/**

Shares the graphic artwork with all the client sessions.

Sharing globally trumps explicit shares.

@return KErrNone if the graphic is globally shared, else one of the system-wide error codes.

*/

EXPORT_C TInt CWsGraphic::ShareGlobally()

	{

	if(!IsActive())

		{

		return KErrNotReady;

		}

	return iPimpl->WriteReply(EWsGdOpShareGlobally);

	}

/**

Prevents this graphic artwork from being shared with all the client sessions.

A graphic artwork that isn't shared explicitly is only available to clients it

has been explicitly shared with using Share().

@return KErrNone if the graphic is not globally shared, else one of the system-wide error codes.

*/

EXPORT_C TInt CWsGraphic::UnShareGlobally()

	{

	if(!IsActive())

		{

		return KErrNotReady;

		}

	return iPimpl->WriteReply(EWsGdOpUnShareGlobally);

	}

/** 

Explicitly shares this graphic artwork with client sessions with the specified Secure ID.

@param aClientId the Secure ID of the client sessions to share with.

@return KErrNone If the graphic artwork was shared, else one of the system-wide error codes.

*/

EXPORT_C TInt CWsGraphic::Share(TSecureId aClientId)

	{

	if(!IsActive())

		{

		return KErrNotReady;

		}

	return iPimpl->WriteReply(&aClientId,sizeof(TSecureId),EWsGdOpShare);

	}

/** 

Stops this graphic artwork from being shared with all client sessions with the specific Secure ID.

ShareGlobally() trumps explicit sharing.

@param aClientId the Secure ID of the client sessions to not share with

@return KErrNone if the graphic artwork is no longer shared, KErrNotFound if the graphic was not shared anyway, else one of the system-wide error codes

*/

EXPORT_C TInt CWsGraphic::UnShare(TSecureId aClientId)

	{

	if(!IsActive())

		{

		return KErrNotReady;

		}

	return iPimpl->WriteReply(&aClientId,sizeof(TSecureId),EWsGdOpUnShare);

	}

/**

Returns graphic artwork Id.

@return Graphic artwork Id. KNullWsGraphicId if graphic artwork is not active.

*/

EXPORT_C const TWsGraphicId& CWsGraphic::Id() const

	{

	if(IsActive())

		{

		return iPimpl->iId;

		}

	else

		{

		// fallback

		static const TInt KNullWsGraphicId[4] = //binary compatible with TWsGraphicId

			{

			0, 0, 0, 0

			};

		__ASSERT_COMPILE(sizeof(KNullWsGraphicId) == sizeof(TWsGraphicId));

		return reinterpret_cast<const TWsGraphicId&>(KNullWsGraphicId);

		}

	}

/** 

Checks whether a peer of this graphic artwork has been fully constructed on the server.

@return ETrue if this graphic artwork has a peer CWsGraphic on the server.

*/

EXPORT_C TBool CWsGraphic::IsActive() const

	{

	return (iPimpl && iPimpl->iWsHandle && (iPimpl->iFlags & CPimpl::EHasPeer));

	}

/**

Derived class can override this method to provide custom operations when the client is closed.

*/

EXPORT_C void CWsGraphic::OnClientClose()

	{

	}

/** 

Sends message to this graphic artwork peer on the server.

@param aData User specific data.

*/

EXPORT_C void CWsGraphic::SendMessage(const TDesC8& aData) const

	{

	TWsClCmdGdSendMessage cmd;

	cmd.iDataLen = aData.Size();

	__ASSERT_DEBUG(cmd.iDataLen, Panic(EW32PanicGraphicNullData));

	cmd.iRemoteReadData = ((aData.Size()+sizeof(cmd))>(TInt)(iPimpl->iBuffer->BufferSize()-sizeof(TWsCmdHeader)));

	if(cmd.iRemoteReadData)

		{

		iPimpl->WriteReplyByProvidingRemoteReadAccess(&cmd,sizeof(cmd),&aData,EWsGdOpSendMsg);

		//ignore return value!

		}

	else

		{

		iPimpl->Write(&cmd,sizeof(cmd),aData.Ptr(),aData.Size(),EWsGdOpSendMsg);

		}

	}

EXPORT_C TInt CWsGraphic::SendSynchronMessage(const TDesC8& aData) const

	 {

	 TWsClCmdGdSendMessage cmd;

	 cmd.iDataLen = aData.Size();

	 __ASSERT_DEBUG(cmd.iDataLen, Panic(EW32PanicGraphicNullData));

	 cmd.iRemoteReadData = ((aData.Size()+sizeof(cmd))>(TInt)(iPimpl->iBuffer->BufferSize()-sizeof(TWsCmdHeader)));

	 if(cmd.iRemoteReadData)

		{

		return iPimpl->WriteReplyByProvidingRemoteReadAccess(&cmd,sizeof(cmd),&aData,EWsGdOpSendSynchronMsg);

		}

	 else

		{

		return iPimpl->WriteReply(&cmd,sizeof(cmd),aData.Ptr(),aData.Size(),EWsGdOpSendSynchronMsg);

		}

	 }

/** 

Flushes window server command buffer

@return One of system-wide error codes.

*/

EXPORT_C TInt CWsGraphic::Flush() const

	{

	return iPimpl->iBuffer->Flush();

	}

EXPORT_C void CWsGraphic::Destroy()

/** Destroys the corresponding CWsGraphicDrawer instance on the server

@released

@publishedAll

*/	{

	if(iPimpl && (iPimpl->iFlags & CPimpl::ERegistered))

		{

		iPimpl->iManager->Remove(this);

		}

	if(IsActive()) // if iPimpl==NULL, IsActive() returns false

		{

		__ASSERT_DEBUG(iPimpl != NULL, Panic(EW32PanicGraphicInternal));

		iPimpl->Write(EWsGdOpFree);

		iPimpl->iWsHandle = 0;

		iPimpl->iFlags &= ~CPimpl::EHasPeer;

		iPimpl->iManager->ScheduleFlush();

		}

	}

EXPORT_C void CWsGraphic::SetGraphicExtension(MWsObjectProvider* aExt)

	{

	iPimpl->iExt = aExt;

	}

EXPORT_C RWsSession&  CWsGraphic::Session()

	{

	return *iPimpl->iManager;

	}

EXPORT_C TInt CWsGraphic::CWsGraphic_Reserved1()

	{

	return KErrNotSupported;

	}

EXPORT_C TInt CWsGraphic::CWsGraphic_Reserved2()

	{

	return KErrNotSupported;

	}

EXPORT_C TInt CWsGraphic::CWsGraphic_Reserved3()

	{

	return KErrNotSupported;

	}

// TWsGraphicMsgFixedBase \\\\\\\\\\\\\\\\\\\\\\\\

EXPORT_C TWsGraphicMsgFixedBase::TWsGraphicMsgFixedBase(TUid aTypeId,TInt aSizeOfDerived):

/** Protected constructor for subclasses to call

@param aTypeId The UID representing this type of data

@param aSizeOf The size of the derived class

Example:

@code

TMyDerivedFixedMsg::TMyDerivedFixedMsg(): TWsGraphicMsgFixedBase(KUidMyDerivedType,sizeof(TMyDerivedFixedMsg)), ...

@endcode

*/	iTypeId(aTypeId), iSize(aSizeOfDerived-sizeof(TWsGraphicMsgFixedBase))

	{

	__ASSERT_COMPILE(sizeof(*this) == (sizeof(TInt32)*2));

	}

EXPORT_C TPtrC8 TWsGraphicMsgFixedBase::Pckg() const

/** @return this fixed message as a descriptor so that it can be passed as draw data in the CWindowGc::DrawWsGraphic command directly if only one such message is to be sent

*/	{

	return TPtrC8(reinterpret_cast<const TUint8*>(this),sizeof(*this) + iSize);

	}

EXPORT_C TUid TWsGraphicMsgFixedBase::TypeId() const

/** @return the UID identifying the type of the data that follows */

	{

	return iTypeId;

	}

EXPORT_C TInt TWsGraphicMsgFixedBase::Size() const

/** @return the size of the derived class (not including this fixed base class size) */

	{

	return iSize;

	}

// RWsGraphicMsgBuf \\\\\\\\\\\\\\\\\\\\\\\\

EXPORT_C RWsGraphicMsgBuf::RWsGraphicMsgBuf()

/** Default Constructor */

	{

	}

TInt RWsGraphicMsgBuf::IntAt(TInt aOfs) const

/** @internalComponent @released */

	{

	if((aOfs < 0) || ((aOfs+sizeof(TInt)) > Length()))

		{

		Panic(EW32PanicGraphicBadBuffer);

		}

	TInt ret;

	memcpy(&ret,Ptr()+aOfs,sizeof(TInt));

	return ret;

	}

EXPORT_C TInt RWsGraphicMsgBuf::Append(TUid aTypeId,const TDesC8& aData)

/** Append a descriptor as data

	@param aTypeId the type of the message to append

	@param aData arbitrary length data consisting of the whole message

	@return KErrNone if successful, else a system-wide error code

*/	{

	TInt err = ExpandForAppend(aData.Length());

	if (err)

		{

		return err;

		}

	WriteHeader(aTypeId,aData.Length());

	// append data

	Insert(Length(),aData);

	return KErrNone;

	}

EXPORT_C TInt RWsGraphicMsgBuf::Append(TUid aTypeId,const TDesC16& aData)

/** Append a descriptor as data

	@param aTypeId the type of the message to append

	@param aData arbitrary length data consisting of the whole message

	@return KErrNone if successful, else a system-wide error code

*/	{

	TPtr8 data(NULL,0);

	TInt err = Append(aTypeId,aData.Size(),data);

	if (err)

		{

		return err;

		}

	// append data

	data.Copy(reinterpret_cast<const TUint8*>(aData.Ptr()),aData.Size());

	return KErrNone;

	}

TInt RWsGraphicMsgBuf::ExpandForAppend(TInt aDataLen)

/** @internalComponent @released */

	{

	__ASSERT_COMPILE(sizeof(TInt) == sizeof(TInt32));

	const TInt required = (sizeof(TUid) + sizeof(TInt) + aDataLen);

	if(MaxLength() < (Length() + required))

		{

		TInt err = ReAlloc(Length()+required);

		if(KErrNone != err)

			{

			return err;

			}

		}

	return KErrNone;

	}

void RWsGraphicMsgBuf::WriteHeader(TUid aTypeId,TInt aLen)

/** @internalComponent @released */

	{

	__ASSERT_COMPILE(sizeof(TInt) == sizeof(TInt32));

	// append header

	TPckgBuf<TInt32> i(aTypeId.iUid);

	Insert(Length(),i);

	i() = aLen;

	Insert(Length(),i);

	}

EXPORT_C TInt RWsGraphicMsgBuf::Append(TUid aTypeId,TInt aLen,TPtr8& aPtr)

/** Append a message of the specified length and type, and return a pointer to

	allow client code to modify the message.

	aPtr is only set if the append succeeds.

	aPtr is only valid until the next message is appended to the buffer.

	@param aTypeId the type of the message to append

	@param aLen the length of the message to be reserved

	@param aPtr a modifiable descriptor to be used by the client code to write into the message body

	@return KErrNone if successful, else a system-wide error code

*/	{

	TInt err = ExpandForAppend(aLen);

	if (err)

		{

		return err;

		}

	WriteHeader(aTypeId,aLen);

	// set aPtr

	TInt usedLen = Length();

	SetLength(usedLen+aLen);

	aPtr.Set(MidTPtr(usedLen,aLen));

	aPtr.Fill('_'); // prettier when debugging, but want consistant behaviour in release builds

	aPtr.Zero();

	return KErrNone;

	}

EXPORT_C void RWsGraphicMsgBuf::Remove(TInt aIndex)

/** Remove a message from the buffer

	@panic if the index is out of bounds

	@param aIndex the ordinal position of message to be removed

*/	{

	if((aIndex < 0) || (aIndex >= Count()))

		{

		Panic(EW32PanicGraphicBadBuffer);

		}

	TPtrC8 ptr = Data(aIndex);

	const TInt ofs = (ptr.Ptr()-(sizeof(TInt)*2)-Ptr());

	Delete(ofs,ptr.Length() + (sizeof(TInt)*2));

	}

EXPORT_C TInt RWsGraphicMsgBuf::Count() const

/** Returns the number of messages in the buffer

	@return the number of messages in the buffer

*/	{

	const TInt length = Length();

	TInt ofs = 0, count = 0;

	while(ofs < length)

		{

		count++;

		ofs += IntAt(ofs+sizeof(TInt)) + (sizeof(TInt)*2);

		}

	if(ofs != length)

		{

		Panic(EW32PanicGraphicBadBuffer);

		}

	return count;

	}

EXPORT_C TUid RWsGraphicMsgBuf::TypeId(TInt aIndex) const

/** Returns the Type ID of a message in the buffer

	@param aIndex the ordinal position of the message

	@return the Type ID of the message