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

// Window scroll tests

// 

//

/**

 @file

 @test

 @internalComponent - Internal Symbian test code

*/

#include "TSCROLL.H"

#pragma warning(disable : 4710)

//

// Scroll window, used to test the Scroll() command

//

void DrawScrollWin(CBitmapContext *aGc, const TPoint &aOffset, const TSize &aSize)

	{

	aGc->Clear();

	TPoint drawBase(-10,-20);

	TSize drawSize(aSize.iWidth-2*drawBase.iX,aSize.iHeight-2*drawBase.iY);

	aGc->DrawRect(TRect(drawBase,drawBase+drawSize));

	TPoint offset=drawBase+aOffset;

	aGc->SetPenColor(TRgb::Gray4(2));

//	aGc->SetDrawMode(CGraphicsContext::EDrawModeXOR);

	aGc->DrawRect(TRect(offset+TPoint(13,23),offset+TPoint(22,32)));

	TInt xpos,xplus;

	for(xpos=0,xplus=2;xpos<drawSize.iWidth;xplus+=2,xpos+=xplus)

		aGc->DrawLine(TPoint(xpos,0)+offset,TPoint(xpos,drawSize.iHeight)+offset);

	for(TInt ypos=0,yplus=2;ypos<drawSize.iHeight;yplus+=2,ypos+=yplus)

		aGc->DrawLine(TPoint(0,ypos)+offset,TPoint(drawSize.iWidth,ypos)+offset);

//

	aGc->SetPenColor(TRgb(0,0,0));

	aGc->SetDrawMode(CGraphicsContext::EDrawModePEN);

	TheClient->iWs.Flush();

	for(xpos=0;xpos<drawSize.iWidth;xpos+=16)

		{

		aGc->DrawLine(TPoint(xpos,0)+offset,TPoint(drawSize.iWidth,xpos*drawSize.iHeight/drawSize.iWidth)+offset);

		aGc->DrawLine(TPoint(xpos,0)+offset,TPoint(0,drawSize.iHeight-xpos*drawSize.iHeight/drawSize.iWidth)+offset);

		aGc->DrawLine(TPoint(xpos,drawSize.iHeight)+offset,TPoint(drawSize.iWidth,drawSize.iHeight-xpos*drawSize.iHeight/drawSize.iWidth)+offset);

		aGc->DrawLine(TPoint(xpos,drawSize.iHeight)+offset,TPoint(0,xpos*drawSize.iHeight/drawSize.iWidth)+offset);

		}

	}

CScrollWindowNorm::CScrollWindowNorm() : CTWin()

	{

	}

void DrawScrollWin(const TPoint &aOffset, const TSize &aSize)

	{

	::DrawScrollWin(TheClient->iGc, aOffset, aSize);

	}

void CScrollWindowNorm::Draw()

	{

	DrawScrollWin(iScrollTest->Offset(), Size());

	}

void CScrollWindowNorm::SetScrollTest(CScrollTestBase *aScrollTest)

	{

	iScrollTest=aScrollTest;

	}

//

// CScrollWindowBackedUp

//

CScrollWindowBackedUp::CScrollWindowBackedUp(TDisplayMode aDisplayMode) : CTBackedUpWin(aDisplayMode)

	{

	}

void CScrollWindowBackedUp::Draw()

	{

	DrawScrollWin(iScrollTest->Offset(), Size());

	}

void CScrollWindowBackedUp::SetScrollTest(CScrollTestBase *aScrollTest)

	{

	iScrollTest=aScrollTest;

	}

//

// CScrollTestBase

//

void CScrollTestBase::Reset()

	{

	iOffset=TPoint(0,0);

	iInvalid.Clear();

	}

void CScrollTestBase::DoInvalidate()

	{

	}

TPoint CScrollTestBase::Offset() const

	{

	return(iOffset);

	}

CScrollTestBase::~CScrollTestBase()

	{

	delete iBlankWin;

	iInvalid.Close();

	}

void CScrollTestBaseNorm::ConstructL(const TPoint &aPos, const TSize &aSize)

	{

	iScrollWin=new(ELeave) CScrollWindowNorm();

	iScrollWin->SetUpL(aPos, aSize, TheClient->iGroup, *TheClient->iGc);

	iScrollWin->SetScrollTest(this);

	iSize=iScrollWin->Size();

	}

CScrollTestBaseNorm::~CScrollTestBaseNorm()

	{

	delete iScrollWin;

	}

void CScrollTestBaseNorm::Redraw()

	{

	iScrollWin->Redraw();

	}

void CScrollTestBaseNorm::Reset()

	{

	iScrollWin->Win()->Invalidate();

	iScrollWin->Redraw();

	CScrollTestBase::Reset();

	}

CTDrawableWin *CScrollTestBaseNorm::ScrollWin() const

	{

	return(iScrollWin);

	}

void CScrollTestBaseNorm::AdjustTestScrollRegion(const TRect &aClipRect, const TPoint &aOffset, const TRect &aRect)

	{

	RRegion clipped_visible;

	VisibleRegion(clipped_visible);

	clipped_visible.ClipRect(aClipRect);

//

//

	RRegion invalidate(aRect);

	invalidate.SubRegion(clipped_visible);

	invalidate.Offset(aOffset);

	invalidate.ClipRect(aClipRect);

//

	RRegion invalidate2(aRect);

	invalidate2.ClipRect(aClipRect);

	invalidate2.Intersect(iInvalid);

	invalidate2.Offset(aOffset);

	invalidate2.ClipRect(aClipRect);

//

	RRegion validate(aRect);

	validate.Intersect(clipped_visible);

	validate.SubRegion(iInvalid);

	validate.Offset(aOffset);

	validate.ClipRect(aClipRect);

//

	iInvalid.SubRegion(validate);

	iInvalid.Union(invalidate);

	iInvalid.Union(invalidate2);

	RRegion visible;

	VisibleRegion(visible);

	iInvalid.Intersect(visible);

	iInvalid.Tidy();

//

	invalidate2.Close();

	invalidate.Close();

	validate.Close();

	visible.Close();

	clipped_visible.Close();

	iOffset+=aOffset;

	}

void CScrollTestBaseNorm::VisibleRegion(RRegion &aRegion)

	{

	aRegion.Clear();

	aRegion.AddRect(TRect(iSize));

	TRect child;

	child.iTl=iBlankWin->BaseWin()->InquireOffset(*ScrollWin()->BaseWin());

	child.iBr=child.iTl+iBlankWin->BaseWin()->Size();

	aRegion.SubRect(child);

	}

void CScrollWindow1::DoTestScroll(const TRect &aClipRect, const TPoint &aOffset, const TRect &aRect)

	{

	TheGc->Activate(*iScrollWin->DrawableWin());

	RRegion region(aRect);

	RRegion visible;

	VisibleRegion(visible);

	visible.ClipRect(aClipRect);

	region.Intersect(visible);

	visible.Close();

	region.SubRegion(iInvalid);

	region.Offset(aOffset);

	region.ClipRect(aClipRect);

	TheGc->SetClippingRegion(region);

	TheGc->CopyRect(aOffset,aRect);

	TheGc->Deactivate();

	AdjustTestScrollRegion(aClipRect, aOffset,aRect);

	iInvalid.Union(TRegionFix<1>(TRect(aClipRect)));

	region.Close();

	}

void CScrollWindow1::DoTestScroll(const TPoint &aOffset)

	{

	DoTestScroll(TRect(TPoint(0,0),iSize), aOffset,TRect(-aOffset,iSize));

	}

void CScrollWindow1::DoTestScroll(const TPoint &aOffset, const TRect &aRect)

	{

	DoTestScroll(TRect(TPoint(0,0),iSize), aOffset, aRect);

	}

void CScrollWindow1::DoTestScroll(const TRect &aClipRect, const TPoint &aOffset)

	{

	DoTestScroll(aClipRect, aOffset, TRect(-aOffset.iX,-aOffset.iY,iSize.iWidth-aOffset.iX, iSize.iHeight-aOffset.iY));

	}

void CScrollWindow1::DoInvalidate()

	{

	for(TInt index=0;index<iInvalid.Count();index++)

		iScrollWin->Invalidate(iInvalid[index]);

	}

void CScrollWindow2::Reset()

	{

	CScrollTestBaseNorm::Reset();

	iClipped=EFalse;

	}

CScrollWindow2::CScrollWindow2(CTScroll *aTest) : iTest(aTest)

	{

	}

void CScrollWindow2::Draw()

	{

	if (iClipped)

		TheClient->iGc->SetClippingRegion(iInvalid);

	iScrollWin->Draw();

	if (iClipped)

		TheClient->iGc->CancelClippingRegion();

	}

void CScrollWindow2::DoTestScroll(const TPoint &aOffset)

	{

	AdjustTestScrollRegion(TRect(iSize), aOffset, TRect(-aOffset.iX,-aOffset.iY,iSize.iWidth-aOffset.iX, iSize.iHeight-aOffset.iY));

	iClipped=ETrue;

	iScrollWin->DrawableWin()->Scroll(aOffset);

	}

void CScrollWindow2::DoTestScroll(const TRect &aClipRect, const TPoint &aOffset)

	{

	AdjustTestScrollRegion(aClipRect, aOffset, TRect(-aOffset.iX,-aOffset.iY,iSize.iWidth-aOffset.iX, iSize.iHeight-aOffset.iY));

	iClipped=ETrue;

	iScrollWin->DrawableWin()->Scroll(aClipRect, aOffset);

	}

void CScrollWindow2::DoTestScroll(const TPoint &aOffset, const TRect &aRect)

	{

	AdjustTestScrollRegion(TRect(iSize), aOffset, aRect);

	iClipped=ETrue;

	iScrollWin->DrawableWin()->Scroll(aOffset, aRect);

	}

void CScrollWindow2::DoTestScroll(const TRect &aClipRect, const TPoint &aOffset, const TRect &aRect)

	{

	AdjustTestScrollRegion(aClipRect, aOffset, aRect);

	iClipped=ETrue;

	iScrollWin->DrawableWin()->Scroll(aClipRect, aOffset, aRect);

	}

void CScrollWindow3::DrawScrollBit()

	{

	::DrawScrollWin(iBitmapGc, iOffset, iSize);

	}

void CScrollWindow3::Reset()

	{

	CScrollTestBase::Reset();

	iBitmapGc->Clear(TRect(iSize));

	DrawScrollBit();

	DoInvalidate();

	}

CScrollWindow3::~CScrollWindow3()

	{

	delete iBitmapGc;

	delete iBitmapDevice;

	delete iBitmap;

	}

void CScrollWindow3::ConstructL(const TPoint &aPos, const TSize &aSize)

	{

	CScrollTestBaseNorm::ConstructL(aPos,aSize);

	iBitmap=new(ELeave) CFbsBitmap();

	User::LeaveIfError(iBitmap->Create(iSize,EGray4));

	iBitmapDevice=CFbsBitmapDevice::NewL(iBitmap);

	User::LeaveIfError(iBitmapDevice->CreateContext(iBitmapGc));

	DrawScrollBit();

	}

void CScrollWindow3::DoTestScroll(const TRect &aClipRect, const TPoint &aOffset, const TRect &aRect)

	{

	iOffset+=aOffset;

	RRegion blank(aRect);

	TRect clipRect(aClipRect);

	clipRect.Intersection(TRect(iSize));

	blank.SubRect(clipRect);

	blank.Offset(aOffset);

	blank.ClipRect(clipRect);

	TRect rect(aRect);

	rect.Intersection(clipRect);		

	TRect rect2(clipRect);

	rect2.Move(-aOffset);

	rect.Intersection(rect2);			

	iBitmapGc->CopyRect(aOffset,rect);

	iBitmapGc->SetClippingRegion(&blank);

	iBitmapGc->Clear(TRect(iSize));

	iBitmapGc->SetClippingRegion(NULL);

	blank.Close();

	}

void CScrollWindow3::DoTestScroll(const TPoint &aOffset)

	{

	DoTestScroll(TRect(iSize), aOffset,TRect(-aOffset.iX,-aOffset.iY,iSize.iWidth-aOffset.iX, iSize.iHeight-aOffset.iY));

	}

void CScrollWindow3::DoTestScroll(const TPoint &aOffset, const TRect &aRect)

	{

	DoTestScroll(TRect(iSize), aOffset, aRect);

	}

void CScrollWindow3::DoTestScroll(const TRect &aClipRect, const TPoint &aOffset)

	{

	DoTestScroll(aClipRect, aOffset, TRect(-aOffset.iX,-aOffset.iY,iSize.iWidth-aOffset.iX, iSize.iHeight-aOffset.iY));

	}

void CScrollWindow3::Draw()

	{

	TheGc->BitBlt(TPoint(),iBitmap);

	}

void CScrollWindow3::DoInvalidate()

	{

	RWindow win=*iScrollWin->Win();

	win.Invalidate();

	win.BeginRedraw();

	TheGc->Activate(win);

	Draw();

	TheGc->Deactivate();

	win.EndRedraw();

	}

void CScrollWindow4::ConstructL(const TPoint &aPos, const TSize &aSize)

	{

	iScrollWin=new(ELeave) CScrollWindowBackedUp(EGray4);

	iScrollWin->SetUpL(aPos, aSize, TheClient->iGroup, *TheClient->iGc);

	iScrollWin->SetScrollTest(this);

	iSize=iScrollWin->Size();

	TheClient->iGc->Activate(*iScrollWin->DrawableWin());

	TheClient->iGc->Clear();

	DrawScrollWin(TPoint(), iSize);

	TheClient->iGc->Deactivate();

	}

CScrollWindow4::~CScrollWindow4()

	{

	delete iScrollWin;

	}

void CScrollWindow4::Redraw()

	{

	}

void CScrollWindow4::Reset()

	{

	TheClient->iGc->Activate(*iScrollWin->DrawableWin());

	TheClient->iGc->Clear();

	DrawScrollWin(TPoint(), iSize);

	TheClient->iGc->Deactivate();

	CScrollTestBase::Reset();

	}

void CScrollWindow4::DoTestScroll(const TPoint &aOffset)

	{

	iScrollWin->DrawableWin()->Scroll(aOffset);

	iOffset+=aOffset;

	}

void CScrollWindow4::DoTestScroll(const TPoint &aOffset, const TRect &aRect)

	{

	iScrollWin->DrawableWin()->Scroll(aOffset, aRect);

	iOffset+=aOffset;

	}

void CScrollWindow4::DoTestScroll(const TRect &aClipRect, const TPoint &aOffset)

	{

	iScrollWin->DrawableWin()->Scroll(aClipRect, aOffset);

	iOffset+=aOffset;

	}

void CScrollWindow4::DoTestScroll(const TRect &aClipRect, const TPoint &aOffset, const TRect &aRect)

	{

	iScrollWin->DrawableWin()->Scroll(aClipRect, aOffset, aRect);

	iOffset+=aOffset;

	}

CTDrawableWin *CScrollWindow4::ScrollWin() const

	{

	return(iScrollWin);

	}

//

CTScroll::CTScroll(CTestStep* aStep):

	CTWsGraphicsBase(aStep)

	{

	}

CTScroll::~CTScroll()

	{

	BaseWin->SetVisible(ETrue);

	TestWin->SetVisible(ETrue);

	delete iBaseScrollWin;

	delete iTestScrollWin;

	}

void CTScroll::ConstructL()

	{

	BaseWin->SetVisible(EFalse);

	TestWin->SetVisible(EFalse);

//

	iTest->iState=1;

	TSize screenSize=TheClient->iGroup->Size();

	TInt winWidth=(screenSize.iWidth/3)-10;

	TInt winHeight=screenSize.iHeight-10;

	TInt winBaseX=(screenSize.iWidth/3);

	if (iMode==0)

		{

		iBaseScrollWin=new(ELeave) CScrollWindow1();

		iTestScrollWin=new(ELeave) CScrollWindow2(this);

		}

	else

		{

		iBaseScrollWin=new(ELeave) CScrollWindow3();

		iTestScrollWin=new(ELeave) CScrollWindow4();

		}

	iWinSize=TSize(winWidth,winHeight);

	iBaseScrollWin->ConstructL(TPoint(winBaseX+5,5),iWinSize);

	iTestScrollWin->ConstructL(TPoint(winBaseX+winWidth+15,5),iWinSize);

	iBaseScrollWin->iBlankWin=new(ELeave) CTBlankWindow();

	iBaseScrollWin->iBlankWin->SetUpL(iBaseScrollWin->ScrollWin()->BaseWin()->InquireOffset(*TheClient->iGroup->GroupWin())+TPoint(winWidth>>2,winHeight>>2),TSize(winWidth>>2,winHeight>>1),TheClient->iGroup,*TheClient->iGc);

	iBaseScrollWin->iBlankWin->BlankWin()->SetShadowHeight(2);

	iTestScrollWin->iBlankWin=new(ELeave) CTBlankWindow();

	iTestScrollWin->iBlankWin->SetUpL(iTestScrollWin->ScrollWin()->BaseWin()->InquireOffset(*TheClient->iGroup->GroupWin())+TPoint(winWidth>>2,winHeight>>2),TSize(winWidth>>2,winHeight>>1),TheClient->iGroup,*TheClient->iGc);

	}

void CTScroll::CheckScrollWindows()

	{

	CheckRect(iBaseScrollWin->ScrollWin(),iTestScrollWin->ScrollWin(),TRect(iBaseScrollWin->ScrollWin()->Size()),_L("CTScroll::CheckScrollWindows()"));

	}

void CTScroll::DoTestScroll(const TPoint &aOffset)

	{

	iTestScrollWin->DoTestScroll(aOffset);

	iBaseScrollWin->DoTestScroll(aOffset);

	}

void CTScroll::DoTestScroll(const TRect &aClipRect, const TPoint &aOffset)

	{

	iTestScrollWin->DoTestScroll(aClipRect,aOffset);

	iBaseScrollWin->DoTestScroll(aClipRect,aOffset);

	}

void CTScroll::DoTestScroll(const TPoint &aOffset, const TRect &aRect)

	{

	iTestScrollWin->DoTestScroll(aOffset,aRect);

	iBaseScrollWin->DoTestScroll(aOffset,aRect);

	}

void CTScroll::DoTestScroll(const TRect &aClipRect, const TPoint &aOffset, const TRect &aRect)

	{

	iTestScrollWin->DoTestScroll(aClipRect,aOffset,aRect);

	iBaseScrollWin->DoTestScroll(aClipRect,aOffset,aRect);

	}

void CTScroll::FinishedRectScrolls()

	{

	iBaseScrollWin->DoInvalidate();

	}

void CTScroll::CheckOomScroll()

	{

	TheClient->iWs.HeapSetFail(RHeap::ENone,0);

	FinishedRectScrolls();

	iTestScrollWin->Redraw();

	iBaseScrollWin->Redraw();

//	if (iMode!=1)				// Out of memory scrolling of backed up windows can not work 100% when out of memory

//		CheckScrollWindows();	// Redraw window code can't check these cases properly yet

	}

void CTScroll::OomScrolling()

	{

	iTestScrollWin->iBlankWin->BaseWin()->SetShadowHeight(0);

	iBaseScrollWin->iBlankWin->BaseWin()->SetShadowHeight(0);

	iTestScrollWin->ScrollWin()->BaseWin()->SetShadowHeight(0);