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

// Test Direct Screen Access

// 

//

#include "tdirecta.h"

static TRect WinExt;

static TInt WinCol=0;

static TTimeIntervalMicroSeconds32 MoveInterval;

static TTimeIntervalMicroSeconds32 ModeInterval;

static TTimeIntervalMicroSeconds32 FlipInterval;

static TBool ImmediateModeSwitch;

#if defined(LOGGING)

	LOCAL_D TLogMessageText LogMessageText;

#endif

_LIT(SemControl,"Control");

_LIT(SemNextOp,"TrigerWindow");

_LIT(FontName,"DejaVu Serif Condensed");

_LIT(QueueControl,"Queue");

LOCAL_D TSize FullScreenModeSize;

LOCAL_D TInt Copy2ndHalfOfScreen;

const TBool KRegionTrackingOnly = ETrue;

const TBool KDrawingDsa = EFalse;

const TInt KPanicTestOrdinalPriority=65536;

const TInt KMainTestOrdinalPriority=65535;

const TInt KMainTestBaseWindow=KMainTestOrdinalPriority/3;

const TInt KAboveMainTestBaseWindow = KMainTestBaseWindow +1;

const TInt KMaxIdlingTime = 25; //used for RegionTrackingOnly DSAs, it represents the maximum number of times the Idling function can be called

//Ids of two RegionTrackingOnly DSAs

const TInt KRegionTrackingOnlyDsaWaitingForAbortSignal = 25;

#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA

const TInt KRegionTrackingOnlyDsaNoAbortSignal = 26;

#endif

const TInt KRegionTrackingOnlyDsaExistLast = 0;

const TInt KDrawingDsaExistLast = 1;

const TInt KShortDelay = 5000;

#define SHORT_DELAY	TTimeIntervalMicroSeconds32(KShortDelay)

_LIT(KSem_DefectFix_KAA_5J3BLW_Name, "DefectFix_KAA_5J3BLW");

GLDEF_C TInt ProcDirect(TAny *aScreenNumber)

	{

	CTrapCleanup* cleanupStack = NULL;

	User::LeaveIfNull(cleanupStack = CTrapCleanup::New());

#if defined(LOGGING)

	_LIT(KWindow,"Window Toggle Vis=");

	_LIT(KParams,"%d, Pos=(%d,%d,%d,%d), Col=%d");

#endif

	RSemaphore controlSem;

	RSemaphore windowSem;

	User::LeaveIfError(controlSem.OpenGlobal(SemControl));

	User::LeaveIfError(windowSem.OpenGlobal(SemNextOp));

	RWsSession ws;

	User::LeaveIfError(ws.Connect());

	// assign to the correct screen

	CWsScreenDevice* screen = NULL;

	TInt err;

	TRAP(err, screen = new (ELeave) CWsScreenDevice(ws));

	if (err!=KErrNone)

		return err;

	if ((err=screen->Construct((TInt)aScreenNumber))!=KErrNone)

		{

		delete screen;

		return err;

		}

	RWindowGroup group(ws);

	User::LeaveIfError(group.Construct(898));

	group.EnableReceiptOfFocus(EFalse);

	group.SetOrdinalPosition(0,KAboveMainTestBaseWindow );

	RBlankWindow window(ws);

	User::LeaveIfError(window.Construct(group,899));

	TBool vis=EFalse;

	window.SetVisible(vis);

	window.Activate();

	ws.Flush();

	controlSem.Signal();

	windowSem.Wait();

	RMsgQueueBase queue;

	TInt open = queue.OpenGlobal(QueueControl);

	TInt data;

	while (queue.Receive(&data,sizeof(TInt)) != KErrNone)

		{

		vis=!vis;

		if (vis)

			{

			window.SetColor(TRgb::Gray4(WinCol));

			window.SetExtent(WinExt.iTl,WinExt.Size());

		#if defined(LOGGING)

			LogMessageText.Copy(KWindow);

			LogMessageText.AppendFormat(KParams,vis,WinExt.iTl.iX,WinExt.iTl.iY,WinExt.iBr.iX,WinExt.iBr.iY,WinCol);

			ws.LogMessage(LogMessageText);

		#endif

			}

		window.SetVisible(vis);

		ws.Flush();

		windowSem.Wait();

		}

	queue.Close();

	window.Close();

	group.Close();

	delete screen;

	ws.Close();

	controlSem.Close();

	windowSem.Close();

	delete cleanupStack;

	return(KErrNone);

	}

/*CDirectScreenAccessOld*/

CDirectScreenAccessOld* CDirectScreenAccessOld::NewL(RWsSession& aWs,MAbortDirectScreenAccess& aAborter)

	{

	CDirectScreenAccessOld* self=new(ELeave) CDirectScreenAccessOld(aWs,aAborter);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CDirectScreenAccessOld::~CDirectScreenAccessOld()

	{

	__ASSERT_ALWAYS(!iAborting,AutoPanic(EAutoPanicDirect));

	Cancel();

	iDirectAccess.Close();

	}

void CDirectScreenAccessOld::ConstructL()

	{

	User::LeaveIfError(iDirectAccess.Construct());

	CActiveScheduler::Add(this);

	}

TInt CDirectScreenAccessOld::Request(RRegion*& aRegion, RWindowBase& aWindow)

	{

	TInt ret=iDirectAccess.Request(aRegion,iStatus,aWindow);

	if (ret==KErrNone)

		SetActive();

	return ret;

	}

void CDirectScreenAccessOld::DoCancel()

	{

	iDirectAccess.Cancel();

	}

void CDirectScreenAccessOld::RunL()

	{

	iAborting=ETrue;

	iAborter.AbortNow(REINTERPRET_CAST(RDirectScreenAccess::TTerminationReasons&,iStatus));

	iAborting=EFalse;

	iDirectAccess.Completed();

	}

/*CColorAnimation*/

CColorAnimation* CColorAnimation::NewL(TInt aScreenNumber,TInt aId,MAnimCallBacks& aCallBack,CTWinBase& aParent,TRect aExtent,TBool aStart,TBool aRegionTrackingOnly)

	{

	CColorAnimation* self=new(ELeave) CColorAnimation(aScreenNumber,aId,aCallBack);

	CleanupStack::PushL(self);

	self->ConstructL(aParent,aExtent,aRegionTrackingOnly);

	if (aStart)

		self->StartL();

	CleanupStack::Pop(self);

	return self;

	}

CColorAnimation::~CColorAnimation()

	{

	delete iTimer;

	delete iDrawer;

	delete iWindow;

	delete iWindow2;

	TheClient->Flush();

	}

void CColorAnimation::ConstructL(CTWinBase& aParent,TRect aExtent,TBool aRegionTrackingOnly,TInt aTypeWindow/*=0*/,TInt aSingleWinForMultipleDSA/*=0*/)

	{	

	iRegionTrackingOnly = aRegionTrackingOnly;

	// Make sure that the top right corner is not 0,0

	if (aTypeWindow && aExtent.iTl==TPoint(0,0))

		{

		aExtent.iTl=TPoint(10,10);

		}

	RWindowBase* win=NULL;

	iSingleWinForMultipleDSA=aSingleWinForMultipleDSA;

	if (aSingleWinForMultipleDSA)

		{

		win=iCallBack.iCallBackWin->BaseWin();

		iWinSize=TheClient->iScreen->SizeInPixels();

		}

	else

		{

		iWindow=new(ELeave) CTBlankWindow();

		iWinSize=aExtent.Size();

		iWindow->ConstructExtLD(aParent,aExtent.iTl,iWinSize);

		ChangeModeL(iCallBack.DisplayMode(iId));

		win=iWindow->BaseWin();

		win->SetShadowDisabled(ETrue);

		win->Activate();

		}

	if (!aTypeWindow)

		{

		if(iRegionTrackingOnly)

			{

			iDrawer=CDirectScreenAccess::NewL(TheClient->iWs,*TheClient->iScreen,*win,*this,iRegionTrackingOnly);

			}

		else

			{

			//needed for the non NGA case: only the old API is allowed to be used

			iDrawer=CDirectScreenAccess::NewL(TheClient->iWs,*TheClient->iScreen,*win,*this);

			}

		}

	else

		{

		TRect childRect(0,0,100,100);

		switch(aTypeWindow)

			{

			case 1:

				{

				// Create a Blank Window smaller than it's parent and its top left corner within the parent area and withn the screen area

	 			childRect.Shrink(10,10);

				break;

				}

			case 2:

				{

				// Create a Blank Window with its top left corner being left side of its parent

				childRect.Move(-10,0);

				break;

				}

			}

		iWindow2=new(ELeave) CTBlankWindow();

		iWindow2->ConstructExtLD(*iWindow,childRect.iTl,childRect.Size());

		// Finish constructing the window

	 	RWindowBase& win=*iWindow2->BaseWin();

	 	win.SetShadowDisabled(ETrue);

	 	win.Activate();

		// Create the Direct Screen Access object

	 	if(iRegionTrackingOnly)

	 		{

	 		iDrawer=CDirectScreenAccess::NewL(TheClient->iWs,*TheClient->iScreen,win,*this,iRegionTrackingOnly);

	 		}

	 	else

	 		{

	 		//needed for the non NGA case: only the old API is allowed to be used

	 		iDrawer=CDirectScreenAccess::NewL(TheClient->iWs,*TheClient->iScreen,win,*this);

	 		}

		}

	TheClient->Flush();

	iTimer=CPeriodic::NewL(0);

	}

TPoint CColorAnimation::AbsoluteWindowPosition(TInt aWindowId/*=0*/)

	{

	if (iSingleWinForMultipleDSA)

		{

		return iCallBack.iCallBackWin->BaseWin()->AbsPosition();

		}

	if (!aWindowId)

		{

		// Return the absolute position of iWindow, if Color Animation is not for Position Relative to Screen test.

		return iWindow->BaseWin()->AbsPosition();

		}

	else

		{

		// Return the absolute position of iWindow2, if it is for Position Relative to Screen test.

		return iWindow2->BaseWin()->AbsPosition();

		}

	}

TInt CColorAnimation::DrawColorL(TAny* aAnimation)

	{

	STATIC_CAST(CColorAnimation*,aAnimation)->DrawColorL();

	return(KErrNone);

	}

TInt CColorAnimation::IdlingL(TAny* aAnimation)

	{

	(static_cast<CColorAnimation*>(aAnimation))->IdlingL();

	return(KErrNone);

	}

void CColorAnimation::StartL(TBool aChildWindow/*=EFalse*/)

	{

	iDrawer->StartL();

	TRect bounding=iDrawer->DrawingRegion()->BoundingRect();

	TRect window;

	if (aChildWindow)

		{

		window.SetRect(AbsoluteWindowPosition(1),iWinSize);

		}

	else

		{

		window.SetRect(AbsoluteWindowPosition(),iWinSize);

		}

	// Check that the window contains the bounding area (a bounding rect of (0,0,0,0) shouldn't fail the test)

	if (!(window.Contains(bounding.iTl) && window.Contains(bounding.iBr-TPoint(1,1))) && bounding.Size()!=TSize(0,0))

		{

		iCallBack.Fail();

	//	iDrawer->Cancel();

	//	iDrawer->StartL();

	//	bounding=iDrawer->DrawingRegion()->BoundingRect();

		}

	if(!iRegionTrackingOnly)                                                                                                                                                          

		{

		iTimer->Start(0,iCallBack.TimerInterval(iId),TCallBack(CColorAnimation::DrawColorL,this));

		iDrawer->Gc()->SetPenStyle(CGraphicsContext::ENullPen);

		iDrawer->Gc()->SetBrushStyle(CGraphicsContext::ESolidBrush);

		}                                                                                                                                                                                

	else                                                                                                                                                                              

		{

		iTimer->Start(0,iCallBack.TimerInterval(iId),TCallBack(CColorAnimation::IdlingL,this));

		}

	}

void CColorAnimation::StartOrPanic()

	{

	TRAPD(err,StartL());

	if (err!=KErrNone)

		{

		iCallBack.LogLeave(err);

		iCallBack.Fail();

		}

	}

void CColorAnimation::Stop()

	{

	iTimer->Cancel();

	iDrawer->Cancel();

	}

void CColorAnimation::BringWindowToFront()

	{

	iWindow->WinTreeNode()->SetOrdinalPosition(0);

	}

void CColorAnimation::ChangeModeL(TDisplayMode aMode)

	{

	User::LeaveIfError(iWindow->BaseWin()->SetRequiredDisplayMode(aMode));

	TheClient->Flush();

	}

void CColorAnimation::FinishTest()

	{

	iCallBack.Finished(iId);

	}

inline CDirectScreenAccess* CColorAnimation::GetDrawer()

	{

	return iDrawer;

	}

void CColorAnimation::DrawColorL()

	{

	TBool aFinished;

	iDrawer->Gc()->SetBrushColor(iCallBack.BrushColorL(iId,iColor,aFinished));

	if (iSingleWinForMultipleDSA==1)

		{

		iDrawer->Gc()->DrawRect(iWinSize-TSize(iWinSize.iWidth/2,iWinSize.iHeight/2));

		}

	else if (iSingleWinForMultipleDSA==2)

		{

		iDrawer->Gc()->DrawRect(TRect(TPoint(iWinSize.iWidth/2,iWinSize.iHeight/2),TSize(iWinSize.iWidth/2,iWinSize.iHeight/2)));

		}

	else

		{

		iDrawer->Gc()->DrawRect(iWinSize);

		}

	iDrawer->ScreenDevice()->Update();

	if (aFinished)

		{

		if (iId==1)

			{

			iWindow->SetSize(TSize(48,52));

			TheClient->Flush();

			}

		if (aFinished==1)

			Stop();

		iCallBack.Finished(iId);

		}

	}

void CColorAnimation::IdlingL()

	{

	iIdling++;

	if(iIdling == KMaxIdlingTime)

		{

		Stop();

		iIdling = 0;

		if (iId == KRegionTrackingOnlyDsaWaitingForAbortSignal)

			{

			_LIT(KErrorAbortNotReceived,"DSA didn't get an abort signal even though the window was opened in front");

			CallBack().Log((TText8*)__FILE__,__LINE__, ESevrErr,KErrorAbortNotReceived);

			CallBack().Fail();

			}

		iCallBack.Finished(iId);

		}

	}

void CColorAnimation::AbortNow(RDirectScreenAccess::TTerminationReasons /*aReason*/)

	{

	TInt slow=iCallBack.SlowStopping(iId,iCount);

	switch (slow)

		{

	case eAbortAll:

		iCallBack.Finished(iId);

	case eAbort:

		Stop();

		return;

	case eStopDelayed:

		User::After(750000);		//0.75 secs

		break;

	default:;

		}

	++iCount;

	iTimer->Cancel();

	}

void CColorAnimation::Restart(RDirectScreenAccess::TTerminationReasons /*aReason*/)

	{

	TRAPD(err,StartL());

	if (err!=KErrNone)

		iCallBack.FailedReStart(iId,err);

	}

/*CScrollingTextDrawer*/

CScrollingTextDrawer* CScrollingTextDrawer::NewL(TInt aScreenNumber,CFbsScreenDevice*& aDevice,CFbsBitGc& aGc)

	{

	CScrollingTextDrawer* self=new(ELeave) CScrollingTextDrawer(aDevice,aGc);

	CleanupStack::PushL(self);

	self->ConstructL(aScreenNumber);

	CleanupStack::Pop(self);

	return self;

	}

CScrollingTextDrawer::~CScrollingTextDrawer()

	{

	if(iFontDevice)

		{

		iFontDevice->ReleaseFont(iFont);

		delete iFontDevice;

		}

	}

void CScrollingTextDrawer::ConstructL(TInt aScreenNumber)

	{

	iFontDevice=CFbsScreenDevice::NewL(aScreenNumber,iDevice->DisplayMode());

	_LIT(text,"ABCDEFGHIJKLMNOPQRSTUVWXYZ");

	iText=text;

	CreateFontL();

	//iFirstChar=0;

	iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

#if defined(LOGGING)

	iWs.Connect();

	// point to correct screen

	CWsScreenDevice* screen = new (ELeave) CWsScreenDevice(iWs);

	CleanupStack::PushL(screen);

	User::LeaveIfError(screen->Construct(aScreenNumber));

	CleanupStack::Pop(screen);

	_LIT(KConstTextDrawer,"Constructed Text Drawer");

	LogMessageText.Copy(KConstTextDrawer);

	iWs.LogMessage(LogMessageText);

	iWs.Flush();

	delete screen;

	iWs.Close();

#endif

	}

void CScrollingTextDrawer::CreateFontL()

	{

	TInt screenHeight=iDevice->SizeInPixels().iHeight;

	TFontSpec fontSpec(FontName,screenHeight);

	User::LeaveIfError(iFontDevice->GetNearestFontToDesignHeightInPixels(iFont,fontSpec));

	iGc->UseFont(iFont);

	TInt fontHeight=iFont->HeightInPixels();

	iDrawRect.iTl.iY=(screenHeight-fontHeight)/2;

	iDrawRect.iBr.iY=iDrawRect.iTl.iY+fontHeight;

	iDrawHeight=iFont->AscentInPixels();

	iCharWidth=iFont->CharWidthInPixels(iText[iFirstChar]);

	iDrawRect.iBr.iX=Max(iDevice->SizeInPixels().iWidth,iDevice->SizeInPixels().iHeight);

	iDrawRect.iTl.iX=iDrawRect.iBr.iX-iCharWidth;

	}

void CScrollingTextDrawer::SetBottomOfTest(TInt aBottom)

	{

	if (iDrawRect.iBr.iY>aBottom)

		{

		iDrawRect.iTl.iY-=iDrawRect.iBr.iY-aBottom;

		iDrawRect.iBr.iY=aBottom;

		}

	}

void CScrollingTextDrawer::Scroll()

	{

	iCharWidth=iFont->CharWidthInPixels(iText[iFirstChar]);

	iDrawRect.iTl.iX-=iJump;

	iGc->DrawText(iText.Mid(iFirstChar),iDrawRect,iDrawHeight);