// 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;
	}