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

//

#include "server.h"

#include "WSGRAPHICDRAWERFACTORY.H"

#include "panics.h"

#include <s32mem.h>

#include "wstop.h"

TInt CWsGraphicDrawerObject::TransientSequence=1;

TBool CWsGraphicDrawerObject::RollOver=EFalse;

CWsGraphicDrawerObject* CWsGraphicDrawerObject::NewL(CWsClient* aClient,const TWsClCmdUnion &aParams)

	{

	if(!aClient)

		{

		WS_PANIC_DEBUG(EWsPanicWsGraphic);

		User::Leave(KErrGeneral);

		}

	TGraphicDrawerId id;

	id.iId = aParams.CreateGraphic->iId;

	id.iIsUid = !(EWsGraphicIdTransient & aParams.CreateGraphic->iFlags);

	// check for collision

	const CWsGraphicDrawer* dup = aClient->WindowServer().ResolveGraphic(id);

	// request-specific checks

	if(dup)

		{

		// must be exact same session

		if(&(dup->Owner()) != aClient)

			{

			/*	Someone is squatting on someone else's uid, or trying to,

				but there is no good way to know which. */

			__DEBUG_ONLY(aClient->PPanic(EWservPanicPermissionDenied);)

			User::Leave(KErrAlreadyExists);

			}

		// dupping or otherwise must be explicitly intended by the client

		if(!(EWsGraphicReplace & aParams.CreateGraphic->iFlags))

			{

			aClient->PPanic(EWservPanicPermissionDenied);

			}

		}

	else

		{

		// dupping or otherwise must be explicitly intended by the client

		if(EWsGraphicReplace & aParams.CreateGraphic->iFlags)

			{

			aClient->PPanic(EWservPanicPermissionDenied);

			}

		if(id.iIsUid)

			{

			// police creation of artwork with UIDs

			_LIT_SECURITY_POLICY_C1(KSecurityPolicyCreateWithUid,ECapabilityProtServ);

			if(!KSecurityPolicyCreateWithUid.CheckPolicy(aClient->Client()))

				{

				__DEBUG_ONLY(aClient->PPanic(EWservPanicPermissionDenied);)

				User::Leave(KErrPermissionDenied);

				}

			}

		else

			{

			// allocate a new transient id

			// assumption: that there are more values of a TInt than there are possibly Transient objects

			do

				{

				id.iId = TransientSequence++;

				RollOver |= !TransientSequence;

				}

			while(RollOver && aClient->WindowServer().ResolveGraphic(id)); // until no collision

			}

		}

	// create the drawer object

	TPtrC8 data;

	HBufC8* dataBuf = NULL;

	if(aParams.CreateGraphic->iRemoteReadData)

		{

		const TInt len = aParams.CreateGraphic->iDataLen;

		if ((len >= KMaxTInt/4) || (len < 0))

			aClient->PPanic(EWservPanicBuffer);

		dataBuf = HBufC8::NewLC(len);

		TPtr8 des = dataBuf->Des();

		aClient->RemoteRead(des,0);

		if(des.Size() != len)

			{

			aClient->PPanic(EWservPanicBuffer);

			}

		data.Set(des);

		}

	else

		{

		data.Set(CWsClient::BufferTPtr8((TText8*)(aParams.CreateGraphic+1),aParams.CreateGraphic->iDataLen));

		}

	CWsGraphicDrawerObject* drawer = new(ELeave) CWsGraphicDrawerObject(aClient);

	CleanupStack::PushL(drawer);

	drawer->ConstructL(aParams.CreateGraphic->iType,aClient->WindowServer(),id,data,aParams.CreateGraphic->iClientHandle);

	if(!dup)

		{

		User::LeaveIfError(aClient->WindowServer().AddGraphicDrawer(drawer->Drawer()));

		}

	else

		{

		User::LeaveIfError(aClient->WindowServer().SwapGraphicDrawer(drawer->Drawer()));

		}

	// take off cleanup stack

	CleanupStack::Pop(drawer);

	if(dataBuf)

		{

		CleanupStack::PopAndDestroy(dataBuf);

		}

	// delete dup, which means resolving the object that encapsulates it

	if(dup)

		{

		CWsGraphicDrawerObject* obj = aClient->DrawerObject(dup);

		WS_ASSERT_DEBUG(obj, EWsPanicWsGraphic);

		if(obj)

			{

			obj->CloseObject();

			}

		}

	// trigger redraws if anyone is drawing this graphic before it exists

	if(id.iIsUid)

		{

		aClient->WindowServer().Invalidate(id);

		}

	// done

	return drawer;

	}

CWsGraphicDrawerObject::CWsGraphicDrawerObject(CWsClient* aOwner):

	CWsObject(aOwner,WS_HANDLE_GRAPHIC_DRAWER)

	{

	}

CWsGraphicDrawerObject::~CWsGraphicDrawerObject()

	{

	delete iDrawer;

	}

void CWsGraphicDrawerObject::ConstructL(TUid aType,MWsGraphicDrawerEnvironment& aEnv,const TGraphicDrawerId& aId,const TDesC8& aData,TInt aClientHandle)

	{

	CWsGraphicDrawer* drawer = WsGraphicDrawer::CreateLC(aType,aEnv,aId,*WsOwner(),aData);

	NewObjL();

	iClientHandle = aClientHandle;

	iDrawer=drawer;

	CleanupStack::Pop(iDrawer);

	}

void CWsGraphicDrawerObject::CommandL(TInt aOpcode, const TAny *aCmdData)

	{

	WS_ASSERT_DEBUG(iDrawer, EWsPanicWsGraphic);

	if(iDrawer)

		{

		TWsClCmdUnion pData;

		pData.any = aCmdData;

		switch(aOpcode)

			{

			case EWsGdOpFree:

				WsOwner()->WindowServer().RemoveGraphicDrawer(iDrawer->Id());

				CloseObject();

				return;

			case EWsGdOpSendMsg:

			case EWsGdOpSendSynchronMsg:

				{

				const TWsClCmdGdSendMessage& cmd = *pData.GraphicSendMessage;

				__ASSERT_DEBUG(cmd.iDataLen,WsOwner()->PPanic(EWservPanicPermissionDenied));

				if(cmd.iDataLen)

					{

					if(cmd.iRemoteReadData)

						{

						HBufC8* wsAlloc = NULL;

						TUint8* drawerAlloc = NULL;

						TPtr8 des(NULL,0);

						// try to get the drawer to allocate for us

						MWsGraphicDrawerMessageAlloc* drawerAllocator = iDrawer->ObjectInterface<MWsGraphicDrawerMessageAlloc>();

						if(drawerAllocator)

							{

							drawerAlloc = reinterpret_cast<TUint8*>(drawerAllocator->Alloc(cmd.iDataLen));

							if(drawerAlloc)

								des.Set(drawerAlloc,0,cmd.iDataLen);

							}

						// else use the normal WSERV default heap

						if(!drawerAlloc)

							{

							wsAlloc = HBufC8::NewLC(cmd.iDataLen);

							des.Set(wsAlloc->Des());

							}

						// fetch

   						WsOwner()->RemoteRead(des,0);

						TBool receivedOk = (des.Size() == cmd.iDataLen);

						// dispatch

						if(receivedOk)

							{

							if(aOpcode == EWsGdOpSendMsg)

								{

								iDrawer->HandleMessage(des);

								}

							else

								{

								MWsGraphicHandleSynchronMessage* obj = iDrawer->ObjectInterface<MWsGraphicHandleSynchronMessage>();

								if(obj)

									SetReply(obj->HandleSynchronMessage(des));

								else

									SetReply(KErrNotSupported);

								}

							}

						// dealloc

						if(drawerAlloc)

							{

							drawerAllocator->Free(drawerAlloc);

							}

						else

							{

							CleanupStack::PopAndDestroy(wsAlloc);

							}

						// defer panic until after dealloc

						if(!receivedOk)

							{

							WsOwner()->PPanic(EWservPanicBuffer);

							}

						}

					else

						{

						const TPtrC8 data = CWsClient::BufferTPtr8((TText8*)(pData.GraphicSendMessage+1),cmd.iDataLen);

						if(aOpcode == EWsGdOpSendMsg)

							{

							iDrawer->HandleMessage(data);

							}

						else

							{

							MWsGraphicHandleSynchronMessage* obj = iDrawer->ObjectInterface<MWsGraphicHandleSynchronMessage>();

							if(obj)

								SetReply(obj->HandleSynchronMessage(data));

							else

								SetReply(KErrNotSupported);

							}

						}

					}

				}

				break;

			case EWsGdOpGetGraphicId:

				{

				__ASSERT_COMPILE(sizeof(TWsClCmdGdGetId) == sizeof(TGraphicDrawerId));

				const TGraphicDrawerId id = iDrawer->Id();

				CWsClient::ReplyBuf(&id,sizeof(id));

				}

				break;

			case EWsGdOpShareGlobally:

				SetReply(iDrawer->ShareGlobally());

				break;

			case EWsGdOpUnShareGlobally:

				SetReply(iDrawer->UnShareGlobally());

				break;

			case EWsGdOpShare:

				{

				const TSecureId& secid = *reinterpret_cast<const TSecureId*>(aCmdData);

				SetReply(iDrawer->Share(secid));

				break;

				}

			case EWsGdOpUnShare:

				{

				const TSecureId& secid = *reinterpret_cast<const TSecureId*>(aCmdData);

				SetReply(iDrawer->UnShare(secid));

				break;

				}

			default:

				WsOwner()->PPanic(EWservPanicOpcode);

			}

		}

	}

CWsGraphicDrawer* CWsGraphicDrawerObject::Drawer()

	{

	return iDrawer;

	}

const CWsGraphicDrawer* CWsGraphicDrawerObject::Drawer() const

	{

	return iDrawer;

	}

// CWsGraphicMessageQueue \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\

CWsGraphicMessageQueue::CMessage* CWsGraphicMessageQueue::CMessage::New(const TDesC8& aData)

   	{

	return new(aData.Size()) CMessage(aData);

   	}

CWsGraphicMessageQueue::CMessage::CMessage(const TDesC8& aData):

	iData((reinterpret_cast<TUint8*>(this)+sizeof(*this)),aData.Size())

   	{

	iData = aData;

   	}

TPtrC8 CWsGraphicMessageQueue::CMessage::Data() const

	{

	return iData;

   	}

void CWsGraphicMessageQueue::CMessage::Release()

	{

	delete this;

   	}

CWsGraphicMessageQueue::CMessage::~CMessage()

   	{

   	}

CWsGraphicMessageQueue::CWsGraphicMessageQueue(CWsClient *aOwner):

	CEventBase(aOwner)

	{

	}

CWsGraphicMessageQueue::~CWsGraphicMessageQueue()

	{

	while(iHead)

		{

		CWsMessageData* msg = iHead;

		iHead = iHead->iNext;

		msg->Release();

		}

	}

TInt CWsGraphicMessageQueue::TopClientHandle() const

	{

	if(iHead)

		return iHead->iClientHandle;

	else

		return KErrNotFound;

	}

/** 

same functionality as CEventBase::GetData, but this one also inserts the integer header in the reply.

*/

void CWsGraphicMessageQueue::GetDataWithHeader(TUint aHeader, const TDesC8& aData, TInt aDataLen)

	{

	TPckgBuf<TUint> hdr = aHeader | (EWsGraphMessageTypeUser & 0x03);

	CWsClient::ReplyBuf(hdr.Ptr(), sizeof(TUint));

	GetData((void*)aData.Ptr(), aDataLen);

	}

void CWsGraphicMessageQueue::GetGraphicMessage()

	{

	CWsMessageData* top = Pop();

	WS_ASSERT_DEBUG(top && top->Data().Length(), EWsPanicWsGraphic);

	if(top)

		{

		GetDataWithHeader(top->iClientHandle, top->Data(), top->Data().Size());

		CWsGraphicDrawerObject* obj = iWsOwner->DrawerObject(top->iDrawer);

		if(obj)

			{

			MWsGraphicMessageCallback* messageCallback = obj->Drawer()->ObjectInterface<MWsGraphicMessageCallback>();

			if(messageCallback)

				{

				messageCallback->HandleMessageDelivery(top->iId, KErrNone);

				}

			}

		top->Release();

		}

	}

void CWsGraphicMessageQueue::AbortMessage(TInt aError)

	{

	CWsMessageData* top = Pop();

	WS_ASSERT_DEBUG(top, EWsPanicWsGraphic);

	if(top)

		{

		CWsGraphicDrawerObject* obj = iWsOwner->DrawerObject(top->iDrawer);

		if(obj)

			{

			MWsGraphicMessageCallback* messageCallback = obj->Drawer()->ObjectInterface<MWsGraphicMessageCallback>();

			if(messageCallback)

				{

				messageCallback->HandleMessageDelivery(top->iId, aError);

				}

			}

		top->Release();

		}

	}

void CWsGraphicMessageQueue::EventReady(const RMessagePtr2& aEventMsg)

	{

	CEventBase::EventReady(aEventMsg);

	if(iHead)

		{

		SignalEvent(sizeof(TInt) + iHead->Data().Size());

		}

	}

void CWsGraphicMessageQueue::Queue(CWsMessageData* aMessage)

	{

	WS_ASSERT_DEBUG(aMessage && !aMessage->iNext, EWsPanicWsGraphic);

	if(aMessage)

		{

		if(iHead)

			{

			iTail->iNext = aMessage;

			iTail = aMessage;

			}

		else

			{

			iHead = iTail = aMessage;

			if(!iEventMsg.IsNull())

				SignalEvent(sizeof(TInt) + iHead->Data().Size());

			}

		}

	}

CWsMessageData* CWsGraphicMessageQueue::Pop()

	{

	CWsMessageData* ret = NULL;

	if(iHead)

		{

		ret = iHead;

		iHead = iHead->iNext;

		}

	return ret;

	}