// Copyright (c) 2000-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:
// Direct Screen Access class, to allow the client to draw directly to the screen
// 
//

#include <e32base.h>
#include "Direct.H"
#include "server.h"
#include "rootwin.h"
#include "wstop.h"
#include "panics.h"
#include <e32msgqueue.h>

const TInt KMsgQueueLength = 1;

CDsaMsgQueue* CDsaMsgQueue::NewL(CWsDirectScreenAccess* aDirect)
	{
	CDsaMsgQueue* self = new(ELeave)CDsaMsgQueue;
	CleanupStack::PushL(self);
	self->ConstructL(aDirect);
	CleanupStack::Pop(self);
	return self;
	}

CDsaMsgQueue::CDsaMsgQueue()
{}

CDsaMsgQueue::~CDsaMsgQueue()
	{
	delete iAborted;
	iSendQueue.Close();
	iRecQueue.Close();
	}

void CDsaMsgQueue::ConstructL(CWsDirectScreenAccess* aDirect)
	{
	iAborted=new(ELeave) CWsAbortDirect(aDirect,this);	
	}

void CDsaMsgQueue::Cancel()
	{
	//purge the queue of data
	TInt ret = KErrNone;
	do
		{
		TInt data = 0;
		ret = iRecQueue.Receive(&data,sizeof(TInt));
		}while(ret == KErrNone);
	iAborted->Cancel();
	}

TInt CDsaMsgQueue::Send(TInt aData)
	{
	return iSendQueue.Send(&aData,sizeof(TInt));
	}

TInt CDsaMsgQueue::CreateSendQueue()
	{
	if(iSendQueue.Handle() == 0)
		{
		return iSendQueue.CreateGlobal(KNullDesC,KMsgQueueLength,sizeof(TInt), EOwnerProcess);
		}
	else
		{
		return 0;
		}
	}

TInt CDsaMsgQueue::CreateRecQueue()
	{
	if(iRecQueue.Handle() == 0)
		{
		return iRecQueue.CreateGlobal(KNullDesC,KMsgQueueLength,sizeof(TInt), EOwnerProcess);
		}
	else
		{
		return 0;
		}
	}

RMsgQueueBase* CDsaMsgQueue::SendQueue()
	{
	return &iSendQueue;
	}

RMsgQueueBase* CDsaMsgQueue::RecQueue()
	{
	return &iRecQueue;
	}

void CDsaMsgQueue::Started()
	{
	iAborted->Started();
	}
	
void CDsaMsgQueue::Complete()
	{
	iAborted->Complete(RDirectScreenAccess::ETerminateCancel);	
	}

void CDsaMsgQueue::CompleteAbort()
	{
	iAborted->Complete(KErrNone);	
	}

TInt CDsaMsgQueue::ReceiveData()
	{
	TInt data = 0;
	iRecQueue.Receive(&data,sizeof(TInt));
	return data;
	}

/*CWsAbortDirect*/

CWsAbortDirect::CWsAbortDirect(CWsDirectScreenAccess* aDirect,CDsaMsgQueue* aParent) : CActive(EDirectAbort), iDirect(aDirect),iParent(aParent)
	{
	CActiveScheduler::Add(this);
	}

CWsAbortDirect::~CWsAbortDirect()
	{
	Cancel();
	}

void CWsAbortDirect::Started()
	{
	iStatus=KRequestPending;
	TRequestStatus& status = iStatus;	
	iParent->RecQueue()->NotifyDataAvailable(status);
	SetActive();
	}

void CWsAbortDirect::RunL()
	{
	iParent->ReceiveData();
	iParent->RecQueue()->CancelDataAvailable();
	iDirect->Aborted();
	}

void CWsAbortDirect::DoCancel()
	{
	iParent->RecQueue()->CancelDataAvailable();
	if (iStatus==KRequestPending)
		{
		Complete(KErrNone);
		}
	}

void CWsAbortDirect::Complete(TInt aReason)
	{
	if(IsActive())
		{
		TRequestStatus* status=&iStatus;
		iParent->RecQueue()->CancelDataAvailable();
		RThread().RequestComplete(status,aReason);
		}
	}


/*CWsDirectScreenAccess*/

CWsDirectScreenAccess* CWsDirectScreenAccess::NewL(CWsClient* aOwner,TBool aRegionTrackingOnly)
	{
	CWsDirectScreenAccess* self = new(ELeave) CWsDirectScreenAccess(aOwner);
	CleanupStack::PushL(self);
	self->ConstructL(aRegionTrackingOnly);
	CleanupStack::Pop(self);
	return self;
	}

CWsDirectScreenAccess::~CWsDirectScreenAccess()
	{
	iVisible.Close();
	if (iStatus!=EDirectStatusTimeNotCreated)
		{
		if (iStatus==EDirectStatusRunning)
			AbortNow();
		if (iStatus>=EDirectStatusAborted)
			CorrectScreen();
		}
	WS_ASSERT_DEBUG(!OnQueue(), EWsPanicDirectScreenAccess);
	if(!iRegionTrackingOnly)
		{
		CScreen* screen = Screen();
		__ASSERT_DEBUG(screen,Panic(EWsPanicNoScreen));
		screen->ReleaseDsaScreenDevice();
		}
	delete iMsgQueue;
	}

void CWsDirectScreenAccess::ConstructL(TBool aRegionTrackingOnly)
	{
	NewObjL();
	iMsgQueue = CDsaMsgQueue::NewL(this);
	iStatus=EDirectStatusNone;
	iRegionTrackingOnly = aRegionTrackingOnly;
	if(!iRegionTrackingOnly)
		{
		//The Direct Screen Access object is going to be used to draw to the screen so we need to:
		//1)allocate the buffer
		//2)initialize the DSA device and surface
		CScreen* screen = Screen();
		__ASSERT_DEBUG(screen,Panic(EWsPanicNoScreen));
		screen->AcquireDsaScreenDeviceL();	
		}
	}

void CWsDirectScreenAccess::Request(TInt handle)
	{
	if (iStatus!=EDirectStatusNone)
		{
		if (iStatus==EDirectStatusCompleted)
			{
			iMsgQueue->Cancel();
			}
		else
			{
			iWsOwner->PPanic(EWservPanicDirectMisuse);
			}
		}
	iWsOwner->HandleToClientWindow(handle,&iWin);
	STACK_REGION region;
	iWin->GenerateTopRegion(region);
	
	//clip the draw region with DSA buffer
	TRect dsaBuffer(TPoint(0,0), iScreen->DSASizeInPixels());
	MWsDisplayMapping *dispMap = iScreen->DisplayMapping();
	TRect dsaBufferInAppSpace;
	if(dispMap)
		{
		dispMap->MapCoordinates(EDirectScreenAccessSpace,dsaBuffer,EApplicationSpace,dsaBufferInAppSpace);
		}
	else
		{
		dsaBufferInAppSpace = dsaBuffer;
		}
	region.ClipRect(dsaBufferInAppSpace);
	const TInt regionCount=region.Count();
	region.Close();
	SetReply(regionCount);
	iStatus=EDirectStatusInitialising;
	}

void CWsDirectScreenAccess::GetRegion(TInt aNumRects)
	{
#if defined(_DEBUG)
	if (iStatus!=EDirectStatusInitialising)
		iWsOwner->PPanic(EWservPanicDirectMisuse);
#endif
	STACK_REGION winVisibleRegion, region;
	iWin->GenerateTopRegion(winVisibleRegion);
	//clip the draw region with DSA buffer
	TRect dsaBuffer(TPoint(0,0), iScreen->DSASizeInPixels());
	MWsDisplayMapping *dispMap = iScreen->DisplayMapping();
	TRect dsaBufferInAppSpace;
	if(dispMap)
		{
		dispMap->MapCoordinates(EDirectScreenAccessSpace,dsaBuffer,EApplicationSpace,dsaBufferInAppSpace);
		}
	else
		{
		dsaBufferInAppSpace = dsaBuffer;
		}
	region.Copy(winVisibleRegion);
	region.ClipRect(dsaBufferInAppSpace);
	
	const TInt regionCount=region.Count();
	if (region.Count()==aNumRects)
		{
		iVisible.Copy(winVisibleRegion);
		if (iVisible.CheckError())
			{
			iStatus=EDirectStatusNone;
			SetReply(KErrNotReady);
			}
		else
			{
			TInt error = Initiate();
			
			if (!error)
				{
				TPtrC8 rectList(REINTERPRET_CAST(const TUint8*,region.RectangleList()),region.Count()*sizeof(TRect));
				CWsClient::ReplyBuf(rectList);
				iStatus=EDirectStatusRunning;
				iMsgQueue->Started();
				SetReply(KMaxTInt);
				}
			else
				{
				iStatus=EDirectStatusNone;
				SetReply(error);
				}
			}
		}
	else
		{
		SetReply(region.Count());
		}
	region.Close();
	winVisibleRegion.Close();
	}

void CWsDirectScreenAccess::Cancel()
	{
	TInt ret = 0;
	switch (iStatus)
		{
#if defined(_DEBUG)
	case EDirectStatusInitialising:
		iWsOwner->PPanic(EWservPanicDirectMisuse);
#endif
	case EDirectStatusNone:
		break;
	case EDirectStatusRunning:
		Terminate1();
		Terminate2(); 
		/*Fall through*/
	case EDirectStatusCanceling:
		ret = 1;
		iMsgQueue->Send(RDirectScreenAccess::ETerminateCancel);	
		break;
	case EDirectStatusAbortedWindow:
	case EDirectStatusAbortedGlobal:
		CorrectScreen();
		break;
	case EDirectStatusCompleted:
		break;
	default:
			{
			}
		}
	SetReply(ret);
	iStatus=EDirectStatusNone;
	}

void CWsDirectScreenAccess::Aborted()
	{
	switch (iStatus)
		{
	case EDirectStatusRunning:
		Terminate1();
		Terminate2();
		iStatus=EDirectStatusCanceling;
		break;
	case EDirectStatusAbortedWindow:
	case EDirectStatusAbortedGlobal:
		CorrectScreen(); 
		/*Fall Through*/ 
	case EDirectStatusCompleted:
		iStatus=EDirectStatusNone;
		break;
	default:
		iWsOwner->PPanic(EWservPanicDirectMisuse);
		}
	}

void CWsDirectScreenAccess::AbortNow()
	{
	if (iStatus!=EDirectStatusRunning)
		{
		iWsOwner->PPanic(EWservPanicDirectMisuse);
		}
	SignalAbort(RDirectScreenAccess::ETerminateRegion);
	TRequestStatus timerStatus;
	RTimer& timer=CWsTop::Timer();
	timer.After(timerStatus,400000);		//0.4secs
	User::WaitForRequest(iMsgQueue->Status(),timerStatus);
	if (timerStatus!=KRequestPending)
		{
		Abort();
		}
	else
		{
		CancelAbortObject();
		timer.Cancel();
		User::WaitForRequest(timerStatus);
		}
	}

void CWsDirectScreenAccess::SignalAbort(RDirectScreenAccess::TTerminationReasons aReason)
	{
	iAbortReason=aReason;
	if (iStatus==EDirectStatusAbortedWindow)
		{
		WS_ASSERT_DEBUG(iAbortReason>RDirectScreenAccess::ETerminateRegion, EWsPanicDirectScreenAccess);
		Terminate2();
		return;
		}
	if (iStatus!=EDirectStatusRunning)
		{
		iWsOwner->PPanic(EWservPanicDirectMisuse);
		}
	iMsgQueue->Send(aReason);
	}

void CWsDirectScreenAccess::CancelAbortObject()
	{
	iMsgQueue->Complete();
	iMsgQueue->Cancel();
	iStatus=EDirectStatusNone;
	Terminate1();
	Terminate2();
	}

void CWsDirectScreenAccess::Abort()
	{
	if ( iStatus == EDirectStatusRunning ) 	
		{
		Terminate1();
		if (iMsgQueue->Status()==KRequestPending)
			iStatus=(iAbortReason<=RDirectScreenAccess::ETerminateRegion ? EDirectStatusAbortedWindow:EDirectStatusAbortedGlobal);
		else
			iStatus=EDirectStatusCompleted;
		if (iStatus!=EDirectStatusAbortedWindow)
			Terminate2();
		}
	}

TInt CWsDirectScreenAccess::GetSendQueue()
	{
	TInt ret = iMsgQueue->CreateSendQueue();
	if(ret == KErrNone)
		{
		iWsOwner->SetResponseHandle(iMsgQueue->SendQueue());	
		}
	return ret;
	}

TInt CWsDirectScreenAccess::GetRecQueue()
	{
	TInt ret = iMsgQueue->CreateRecQueue();
	if(ret == KErrNone)
		{
		iWsOwner->SetResponseHandle(iMsgQueue->RecQueue());	
		}
	return ret;
	}

void CWsDirectScreenAccess::CommandL(TInt aOpcode,const TAny* aCmdData)
	{
	TWsDirectCmdUnion pData;
	pData.any=aCmdData;
	switch(aOpcode)
		{
		case EWsDirectOpFree:
			delete this;
			break;
		case EWsDirectOpRequest:
			Request(*pData.Int);
			break;
		case EWsDirectOpInitFailed:
	#if defined(_DEBUG)
			if (iStatus!=EDirectStatusInitialising)
				{
				iWsOwner->PPanic(EWservPanicDirectMisuse);
				}
	#endif
			iStatus=EDirectStatusNone;
			break;
		case EWsDirectOpGetRegion:
			GetRegion(*pData.Int);
			break;
		case EWsDirectOpCancel:
			Cancel();
			break;
		case EWsDirectOpGetSendQueue:
			GetSendQueue();
			break;
		case EWsDirectOpGetRecQueue:
			GetRecQueue();
			break;
		default:
			OwnerPanic(EWservPanicOpcode);
			break;
		}
	}

TInt CWsDirectScreenAccess::Initiate()
	{
	const TInt err = iWin->AddDSA(*this);
	if(err)
		return err;

	iScreen->AddDirect(*this);
	return KErrNone;
	}

static TBool RegionsMatch(const TRegion & aOne, const TRegion & aTwo)
	{
	// Check if the regions have equal areas.
	const TRect* rect1 = aOne.RectangleList();
	TUint area1 = 0;
	for(TInt i = 0; i < aOne.Count(); ++i)
		{
		area1 += (rect1->Width() * rect1->Height());
		rect1++;
		}

	const TRect* rect2 = aTwo.RectangleList();
	TUint area2 = 0;
	for(TInt i = 0; i < aTwo.Count(); ++i)
		{
		area2 += (rect2->Width() * rect2->Height());
		rect2++;
		}
	
	if(area1 != area2)
		{
		return EFalse;
		}

	// Check if one region is completely contained within the other.
	STACK_REGION tempRegion;
	tempRegion.Copy(aOne);	
	tempRegion.SubRegion(aTwo);

	const TBool ret(tempRegion.IsEmpty());
	tempRegion.Close();

	return ret;
	}

TBool CWsDirectScreenAccess::IsAbortRequired(const TRegion& aTopVisibleRegion) const
	{
	return ( iStatus == EDirectStatusRunning ) && !RegionsMatch(aTopVisibleRegion, iVisible);
	}

void CWsDirectScreenAccess::Terminate1()
	{
	WS_ASSERT_DEBUG(!iWin->DSAs().IsEmpty(), EWsPanicDirectScreenAccess);
	iWin->RemoveDSA(*this);
	}

void CWsDirectScreenAccess::Terminate2()
	{
	iScreen->RemoveDirect(*this);
	WS_ASSERT_DEBUG(!OnQueue(), EWsPanicDirectScreenAccess);
	}

void CWsDirectScreenAccess::CorrectScreen()
	{
	if (iAbortReason<=RDirectScreenAccess::ETerminateRegion)
		{
		Terminate2();
		RootWindow()->Invalidate(&iVisible);
		}
	else
		RootWindow()->InvalidateWholeScreen();

	WS_ASSERT_DEBUG(!OnQueue(), EWsPanicDirectScreenAccess);
	iScreen->UpdateDsa();
	}

#if defined(_DEBUG)
TBool CWsDirectScreenAccess::OnQueue()
	{
	return iScreen->IsDirectOnQueue(this);
	}
#endif