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

static TBool RegionsMatch(const TRegion & aOne, const TRegion & aTwo);		


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;
		RThread().RequestComplete(status,aReason);
		}
	}


/*CWsDirectScreenAccess*/

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

CWsDirectScreenAccess::~CWsDirectScreenAccess()
	{
	DeleteRegionSyncWatchcat();
	iFrozenRegion.Close();
	iVisible.Close();
	if (iStatus!=EDirectStatusTimeNotCreated)
		{
		if (iStatus==EDirectStatusRunning)
			AbortNow();
		if (iStatus>=EDirectStatusAborted)
			CorrectScreen();
		}
	WS_ASSERT_DEBUG(!OnQueue(), EWsPanicDirectScreenAccess);
	delete iMsgQueue;
	}

void CWsDirectScreenAccess::ConstructL()
	{
	NewObjL();
	iMsgQueue = CDsaMsgQueue::NewL(this);
	iStatus=EDirectStatusNone;
	}

void CWsDirectScreenAccess::Request(TInt handle)
	{
	if (iStatus!=EDirectStatusNone)
		{
		if (iStatus==EDirectStatusCompleted)
			{
			iMsgQueue->Cancel();
			}
		else
			{
			iWsOwner->PPanic(EWservPanicDirectMisuse);
			}
		}
	iWsOwner->HandleToClientWindow(handle,&iWin);
	iScreen=iWin->Screen();
	STACK_REGION region;
	iWin->GenerateTopRegion(region);
	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 region;
	iWin->GenerateTopRegion(region);
	const TInt regionCount=region.Count();
	if (region.Count()==aNumRects)
		{
		iVisible.Copy(region);
		if (iVisible.CheckError())
			{
			iStatus=EDirectStatusNone;
			SetReply(KErrNotReady);
			}
		else
			{
			TPtrC8 rectList(REINTERPRET_CAST(const TUint8*,region.RectangleList()),region.Count()*sizeof(TRect));
			CWsClient::ReplyBuf(rectList);
			iStatus=EDirectStatusRunning;
			Initiate();
			iMsgQueue->Started();
			SetReply(KMaxTInt);
			}
		}
	else
		{
		SetReply(region.Count());
		}
	region.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)
	{
	DeleteRegionSyncWatchcat();
	
	iAbortReason=aReason;
	if (iStatus==EDirectStatusAbortedWindow)
		{
		WS_ASSERT_DEBUG(iAbortReason>RDirectScreenAccess::ETerminateRegion, EWsPanicDirectScreenAccess);
		Terminate2();
		return;
		}
	if (iStatus!=EDirectStatusRunning)
		{
		iWsOwner->PPanic(EWservPanicDirectMisuse);
		}
	if (RDirectScreenAccess::ETerminateCancel != aReason)
		{
		TInt err;
		TRAP(err, iRegionSync = CWsDirectScreenAccess::CDSARegionSyncTimer::NewL( *this ) );
		if ( KErrNone == err )
			{
			iFrozenRegion.Copy( iVisible );			
			Screen()->DSARegionSyncStart( *this );
			}
		}
	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;
		}
	}

void CWsDirectScreenAccess::Initiate()
	{
	iWin->AddDSA(*this);
	iScreen->AddDirect(*this);
	if ( IsSyncTimeoutPending() )
		{
		Screen()->DSARegionSyncOver( *this );
		
		RRegion deltaRgn;
		deltaRgn.Copy( iFrozenRegion );
		
		deltaRgn.SubRegion( iVisible );
		deltaRgn.Tidy();
		
		if ( !deltaRgn.IsEmpty() )
			{
			Screen()->ScheduleRegionUpdate( &deltaRgn );
			}
		
		deltaRgn.Close();
		iFrozenRegion.Clear();

		DeleteRegionSyncWatchcat();
		}
	}
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);
	}



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


TBool CWsDirectScreenAccess::IsSyncTimeoutPending() const
	{
	TBool res;
	res = ( NULL != iRegionSync ) && ( iRegionSync->IsActive() );
	return res; 
	}

void CWsDirectScreenAccess::CancelFrozenRegion()
	{
	if ( !iFrozenRegion.IsEmpty() )
		{
		Screen()->DSARegionSyncOver( *this );
		Screen()->ScheduleRegionUpdate( &iFrozenRegion );
		iFrozenRegion.Clear();
		}	
	}

void CWsDirectScreenAccess::DeleteRegionSyncWatchcat()
	{
	if ( NULL != iRegionSync )
		{
		if ( iRegionSync->IsActive() )
			{
			iRegionSync->Cancel();			
			}
		delete iRegionSync;
		iRegionSync = NULL;
		}
	CancelFrozenRegion();
	}	

void CWsDirectScreenAccess::RegionSyncTimeout()
	{
	CancelFrozenRegion();
	}

CWsDirectScreenAccess::CDSARegionSyncTimer* CWsDirectScreenAccess::CDSARegionSyncTimer::NewL(CWsDirectScreenAccess& aDSA)
	{
	CWsDirectScreenAccess::CDSARegionSyncTimer* self = new ( ELeave ) CWsDirectScreenAccess::CDSARegionSyncTimer( aDSA );
	
	CleanupStack::PushL( self );
	self->ConstructL();
	CleanupStack::Pop( self );
	
	CActiveScheduler::Add( self );
	self->After( TTimeIntervalMicroSeconds32( KRegionSyncTimeoutMicrosec ) );
	return self;
	}
	
void CWsDirectScreenAccess::CDSARegionSyncTimer::RunL()
	{
	iDSA.RegionSyncTimeout();
	}

CWsDirectScreenAccess::CDSARegionSyncTimer::CDSARegionSyncTimer(CWsDirectScreenAccess& aDSA):
	CTimer( CActive::EPriorityHigh ),
	iDSA( aDSA )
	{ } // empty	


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