sl@0: // Copyright (c) 1996-2009 Nokia Corporation and/or its subsidiary(-ies).
sl@0: // All rights reserved.
sl@0: // This component and the accompanying materials are made available
sl@0: // under the terms of "Eclipse Public License v1.0"
sl@0: // which accompanies this distribution, and is available
sl@0: // at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0: //
sl@0: // Initial Contributors:
sl@0: // Nokia Corporation - initial contribution.
sl@0: //
sl@0: // Contributors:
sl@0: //
sl@0: // Description:
sl@0: // Test code for screen mode scaling CR
sl@0: // Test code for the Scaling part of Change Request PHAR-5SJGAM 
sl@0: // ("Enable screen mode positioning and scaling").
sl@0: // Tests screen scale being configurable for a screen mode -  
sl@0: // eg it is now possible to set in wsini.ini amount by which a screen 
sl@0: // mode's screen will be scaled when drawn on the physical screen. 
sl@0: // 
sl@0: //
sl@0: 
sl@0: /**
sl@0:  @file
sl@0:  @test
sl@0:  @internalComponent - Internal Symbian test code
sl@0: */
sl@0: 
sl@0: #include "TScreenModeScaling.h"
sl@0: 
sl@0: #define MY_TEST_BITMAP _L("Z:\\WSTEST\\MYTEST.MBM")
sl@0: 
sl@0: LOCAL_D TSize FullScreenModeSize;
sl@0: LOCAL_D TInt Copy2ndHalfOfScreen;
sl@0: 
sl@0: void ClearBitmap(CFbsBitmap* aBitMap)
sl@0: 	{
sl@0: 	// clear the content of bitmap before it is used for copying
sl@0: 	CFbsBitmapDevice *device=CFbsBitmapDevice::NewL(aBitMap);
sl@0: 	CleanupStack::PushL(device);
sl@0: 	CFbsBitGc *gc=NULL;
sl@0: 	User::LeaveIfError(device->CreateContext(gc));
sl@0: 	CleanupStack::PushL(gc);
sl@0: 	gc->Clear();
sl@0: 	CleanupStack::PopAndDestroy(2,device);
sl@0: 	}
sl@0: 
sl@0: /*CBitMapWin*/
sl@0: 
sl@0: void CBitMapWin::Draw()
sl@0: 	{
sl@0: 	iGc->BitBlt(TPoint(),&iBackup->Bitmap());
sl@0: 	}
sl@0: 
sl@0: /*CTestSpriteWin*/
sl@0: 
sl@0: CTestSpriteWin::~CTestSpriteWin()
sl@0: 	{
sl@0: 	}
sl@0: 
sl@0: void CTestSpriteWin::UpdateWin(TPoint aOrigin)
sl@0: 	{
sl@0: 	SetOrigin(aOrigin);
sl@0: 	DrawNow();
sl@0: 	}
sl@0: 
sl@0: void CTestSpriteWin::Draw()
sl@0: 	{
sl@0: 	iGc->BitBlt(iOrigin,&iSpriteBitmap);
sl@0: 	}
sl@0: 
sl@0: /*CTScreenModeScaling*/
sl@0: 
sl@0: CTScreenModeScaling::CTScreenModeScaling(CTestStep* aStep) : CTWsGraphicsBase(aStep)
sl@0: 	{
sl@0: 	}
sl@0: 	
sl@0: CTScreenModeScaling::~CTScreenModeScaling()
sl@0: 	{
sl@0: 	delete iTestWin;
sl@0: 	delete iBlankWin;
sl@0: 	delete iBackedUpWin;
sl@0: 	delete iTestChildWin;
sl@0: 	delete iScreenBitmap;
sl@0: 	delete iBitmapWin;
sl@0: 	delete iCheckWin;
sl@0: 	delete iTransWin;
sl@0: 	delete iBackgroundWin;
sl@0: 	delete iCheckBitmap;
sl@0: 	delete iTransparencyBitmap;
sl@0: 	delete iBackgroundBitmap;
sl@0: 	delete iForegroundBitmap;
sl@0: 	}
sl@0: 
sl@0: void CTScreenModeScaling::ConstructL()
sl@0: 	{
sl@0: 	iDisplayMode=TheClient->iScreen->DisplayMode();
sl@0: 	if (iDisplayMode<EColor256)
sl@0: 		iDisplayMode=EColor256;
sl@0: 	User::LeaveIfError(iSpriteBitmap.Load(MY_TEST_BITMAP,0));
sl@0: 
sl@0: 	TheClient->iScreen->SetAppScreenMode(TheClient->iScreenModes[0]);
sl@0: 	FullScreenModeSize=TheClient->iScreen->SizeInPixels();
sl@0: 	iBlankWin=new(ELeave) CTBlankWindow();
sl@0: 	iBlankWin->ConstructL(*TheClient->iGroup);
sl@0: 	User::LeaveIfError(iBlankWin->BaseWin()->SetRequiredDisplayMode(EColor256));
sl@0: 	iBlankWin->SetExt(TPoint(),FullScreenModeSize);
sl@0: 	iBlankWin->Activate();
sl@0: 
sl@0: 	iTestWin=new(ELeave) CBasicWin;
sl@0: 	iTestWin->ConstructExtLD(*TheClient->iGroup,TPoint(),FullScreenModeSize);
sl@0: 	User::LeaveIfError(iTestWin->BaseWin()->SetRequiredDisplayMode(EColor256));
sl@0: 	iTestWin->AssignGC(*TheClient->iGc);
sl@0: 	iTestWin->SetVisible(EFalse);
sl@0: 	iTestWin->Activate();
sl@0: 	iTestWin->BaseWin()->SetShadowDisabled(ETrue);
sl@0: 	iTestWin->BaseWin()->SetShadowHeight(0);
sl@0: 
sl@0: 	iBackedUpWin=new(ELeave) CTBackedUpWin(iDisplayMode);
sl@0: 	iBackedUpWin->ConstructExtLD(*iTestWin,TPoint(),FullScreenModeSize);
sl@0: 	iBackedUpWin->SetVisible(EFalse);
sl@0: 	iBackedUpWin->Activate();
sl@0: 
sl@0: 	iTestChildWin=new(ELeave) CTBlankWindow();
sl@0: 	iTestChildWin->ConstructL(*iTestWin);
sl@0: 	User::LeaveIfError(iTestChildWin->BaseWin()->SetRequiredDisplayMode(EColor256));
sl@0: 	iTestChildWin->BaseWin()->SetShadowDisabled(ETrue);
sl@0: 	iTestChildWin->SetColor(KRgbGreen);
sl@0: 	iTestChildWin->BaseWin()->SetVisible(EFalse);
sl@0: 	iTestChildWin->Activate();
sl@0: 
sl@0: 	iScreenBitmap=new(ELeave) CFbsBitmap();
sl@0: 	User::LeaveIfError(iScreenBitmap->Create(TSize(FullScreenModeSize.iWidth/2,FullScreenModeSize.iHeight),iDisplayMode));
sl@0: 
sl@0: 	iBitmapWin=new(ELeave) CBmpWin(*iScreenBitmap);
sl@0: 	iBitmapWin->ConstructExtLD(*TheClient->iGroup,TPoint(),iScreenBitmap->SizeInPixels());
sl@0: 	User::LeaveIfError(iBitmapWin->BaseWin()->SetRequiredDisplayMode(EColor256));
sl@0: 	iBitmapWin->AssignGC(*TheClient->iGc);
sl@0: 	iBitmapWin->Activate();
sl@0: 	iBitmapWin->SetVisible(EFalse);
sl@0: 	iBitmapWin->BaseWin()->SetShadowDisabled(ETrue);
sl@0: 	iBitmapWin->BaseWin()->SetShadowHeight(0);
sl@0: 
sl@0: 	//.. Create all the bitmaps and transparent windows
sl@0: 	iWinSize.SetSize(20,20);
sl@0: 	iTransparencyBitmap=CBitmap::NewL(iWinSize,EGray256);
sl@0: 	iBackgroundBitmap=CBitmap::NewL(iWinSize,iDisplayMode);
sl@0: 	iForegroundBitmap=CBitmap::NewL(iWinSize,iDisplayMode);
sl@0: 
sl@0: 	CBitMapWin* backgroundWin=new(ELeave) CBitMapWin(iBackgroundBitmap);
sl@0: 	backgroundWin->ConstructExtLD(*TheClient->iGroup,TPoint(),iWinSize);
sl@0: 	iBackgroundWin=backgroundWin;
sl@0: 	User::LeaveIfError(iBackgroundWin->BaseWin()->SetRequiredDisplayMode(EColor256));
sl@0: 	iBackgroundWin->SetVisible(EFalse);
sl@0: 	iBackgroundWin->BaseWin()->SetShadowDisabled(ETrue);
sl@0: 	iBackgroundWin->BaseWin()->SetShadowHeight(0);
sl@0: 	iBackgroundWin->AssignGC(*TheClient->iGc);
sl@0: 	iBackgroundWin->Activate();
sl@0: 
sl@0: 	CBitMapWin* transWin=new(ELeave) CBitMapWin(iForegroundBitmap);
sl@0: 	transWin->ConstructExtLD(*TheClient->iGroup,TPoint(),iWinSize);
sl@0: 	iTransWin=transWin;
sl@0: 	RWindowBase& transWinB=*iTransWin->BaseWin();
sl@0: 	User::LeaveIfError(transWinB.SetRequiredDisplayMode(EColor256));
sl@0: 	transWinB.SetShadowDisabled(ETrue);
sl@0: 	transWinB.SetShadowHeight(0);
sl@0: 	iTransWin->SetVisible(EFalse);
sl@0: 	iTransWin->AssignGC(*TheClient->iGc);
sl@0: 	iTransWin->Win()->SetTransparencyBitmap(iTransparencyBitmap->Bitmap());
sl@0: 	iTransWin->Activate();
sl@0: 
sl@0: 	CTBackedUpWin* checkWin=new(ELeave) CTBackedUpWin(iDisplayMode);
sl@0: 	checkWin->ConstructExtLD(*TheClient->iGroup,TPoint(iWinSize.iWidth+1,0),iWinSize);
sl@0: 	iCheckWin=checkWin;
sl@0: 	RBackedUpWindow& win=*iCheckWin->BackedUpWin();
sl@0: 	win.SetShadowHeight(0);
sl@0: 	iCheckWin->Activate();
sl@0: 	win.MaintainBackup();
sl@0: 	iCheckBitmap=CBitmap::NewL(win.BitmapHandle());
sl@0: 	iCheckWin->BaseWin()->SetShadowDisabled(ETrue);
sl@0: 	iCheckWin->BaseWin()->SetShadowHeight(0);
sl@0: 	iCheckWin->BaseWin()->SetVisible(EFalse);
sl@0: 	TheClient->Flush();
sl@0: 	TheClient->WaitForRedrawsToFinish();
sl@0: 	}
sl@0: 
sl@0: void CTScreenModeScaling::TestTopClientWindowPositionAPIs(TPoint aPos,RWindowBase* aWin)
sl@0: 	{
sl@0: 	TEST(aWin->AbsPosition()==aPos);
sl@0: 	TEST(aWin->Position()==aPos);
sl@0: 	TEST(aWin->InquireOffset(*TheClient->iGroup->GroupWin())==aPos);
sl@0: 	}
sl@0: 
sl@0: void CTScreenModeScaling::TestChildWindowPositionAPIs(TPoint aPos,TPoint aParentPos,RWindowBase* aWin,RWindowBase* aParentWin)
sl@0: 	{
sl@0: 	TEST(aWin->AbsPosition()==aParentPos+aPos);
sl@0: 	TEST(aWin->Position()==aPos);
sl@0: 	TEST(aWin->InquireOffset(*TheClient->iGroup->GroupWin())==aParentPos+aPos);
sl@0: 	TEST(aWin->InquireOffset(*aParentWin)==aPos);
sl@0: 	}
sl@0: 
sl@0: void CTScreenModeScaling::TestRect()
sl@0: 	{
sl@0: 	// Here if the width or height of the screen cannot be divided by 2 
sl@0: 	// then make both the rect size same by reducing the first or second which ever is smaller
sl@0: 	// and make sure that top left corner is not disturbed.
sl@0: 	TRect rect1=TRect(PhysicalToLogical(TPoint()-iCurrentScreenModeOrigin,iCurrentScreenModeScale),
sl@0: 					  PhysicalToLogical(TPoint(FullScreenModeSize.iWidth/2,FullScreenModeSize.iHeight)-iCurrentScreenModeOrigin,
sl@0: 										iCurrentScreenModeScale)
sl@0: 					  );
sl@0: 	TRect rect2=TRect(PhysicalToLogical(TPoint(FullScreenModeSize.iWidth/2,0)-iCurrentScreenModeOrigin,
sl@0: 										iCurrentScreenModeScale),
sl@0: 					  PhysicalToLogical(FullScreenModeSize.AsPoint()-iCurrentScreenModeOrigin,
sl@0: 										iCurrentScreenModeScale)
sl@0: 					  );
sl@0: 	if ((Abs(rect1.iBr.iX-rect1.iTl.iX)>Abs(rect2.iBr.iX-rect2.iTl.iX)) || (Abs(rect1.iBr.iY-rect1.iTl.iY)>Abs(rect2.iBr.iY-rect2.iTl.iY)))
sl@0: 		{
sl@0: 		rect1.SetRect(rect1.iTl,rect2.Size());
sl@0: 		}
sl@0: 	if ((Abs(rect1.iBr.iX-rect1.iTl.iX)<Abs(rect2.iBr.iX-rect2.iTl.iX)) || (Abs(rect1.iBr.iY-rect1.iTl.iY)<Abs(rect2.iBr.iY-rect2.iTl.iY)))
sl@0: 		{
sl@0: 		rect2.SetRect(rect2.iTl,rect1.Size());
sl@0: 		}
sl@0: 	TBool retVal = TheClient->iScreen->RectCompare(rect1,rect2);
sl@0: 	TEST(retVal);
sl@0: 	if (!retVal)
sl@0: 		INFO_PRINTF3(_L("TheClient->iScreen->RectCompare(rect1,rect2) return value  - Expected: %d, Actual: %d"), ETrue, retVal);		
sl@0: 	}
sl@0: 
sl@0: void CTScreenModeScaling::CompareRegionsL(const TRegion &aRegion1,const TRegion &aRegion2)
sl@0: 	{
sl@0: 	RRegion tmp;
sl@0: 	tmp.Copy(aRegion1);
sl@0: 	tmp.SubRegion(aRegion2);
sl@0: 	if (tmp.CheckError())
sl@0: 		User::Leave(KErrNoMemory);	
sl@0: 	TBool retVal = tmp.IsEmpty();
sl@0: 	TEST(retVal);
sl@0: 	if (!retVal)
sl@0: 		INFO_PRINTF3(_L("RRegion1.IsEmpty() return value  - Expected: %d, Actual: %d"), ETrue, retVal);		
sl@0: 	tmp.Copy(aRegion2);
sl@0: 	tmp.SubRegion(aRegion1);
sl@0: 	if (tmp.CheckError())
sl@0: 		User::Leave(KErrNoMemory);
sl@0: 	retVal = tmp.IsEmpty();
sl@0: 	TEST(retVal);
sl@0: 	if (!retVal)
sl@0: 		INFO_PRINTF3(_L("RRegion2.IsEmpty() return value  - Expected: %d, Actual: %d"), ETrue, retVal);		
sl@0: 
sl@0: 	tmp.Close();
sl@0: 	}
sl@0: 
sl@0: void CTScreenModeScaling::SetUpSpriteLC(RWsSprite &aSprite, RWsSession &aSession, RWindowTreeNode &aWindow,TInt aFlags)
sl@0: 	{
sl@0: 	aSprite=RWsSprite(aSession);
sl@0: 	User::LeaveIfError(aSprite.Construct(aWindow,TPoint(),aFlags));
sl@0: 	CleanupClosePushL(aSprite);
sl@0: 	TSpriteMember member;
sl@0: 	iTest->SetUpMember(member);
sl@0: 	member.iBitmap=&iSpriteBitmap;
sl@0: 	User::LeaveIfError(aSprite.AppendMember(member));
sl@0: 	User::LeaveIfError(aSprite.Activate());
sl@0: 	}
sl@0: 
sl@0: void CTScreenModeScaling::TestGetInvalidRegionL(TRect& aRect)
sl@0: 	{
sl@0: 	RRegion testRegion;
sl@0: 	RRegion invalid;
sl@0: 	iTestWin->Invalidate(aRect);
sl@0: 	testRegion.AddRect(aRect);
sl@0: 	iTestWin->Win()->GetInvalidRegion(invalid);
sl@0: 	CleanupClosePushL(testRegion);
sl@0: 	CleanupClosePushL(invalid);
sl@0: 	CompareRegionsL(testRegion, invalid);
sl@0: 	CleanupStack::PopAndDestroy(2, &testRegion);
sl@0: 	TheClient->WaitForRedrawsToFinish();
sl@0: 	}
sl@0: 
sl@0: void CTScreenModeScaling::CopyAndCompareL()
sl@0: 	{
sl@0: 	TInt oldOrdinalPriority = TheClient->iGroup->GroupWin()->OrdinalPriority();
sl@0: 	TInt oldOrdinalPosition = TheClient->iGroup->GroupWin()->OrdinalPosition();
sl@0: 	// the following line makes sure that a console object hidden outside of
sl@0: 	// screens range doesn't affect test results ocerlapping the bitmap window
sl@0: 	TheClient->iGroup->GroupWin()->SetOrdinalPosition(0, 65535); 
sl@0: 
sl@0: 	// clear the content of bitmap before it is used for copying
sl@0: 	ClearBitmap(iScreenBitmap);	
sl@0: 
sl@0: 	// Copy first half or second half of the screen to a bitmap then paste it to second or first half of the screen
sl@0: 	TRect testWinRect(PhysicalToLogical(TPoint((Copy2ndHalfOfScreen ? FullScreenModeSize.iWidth/2 : 0),0)-iCurrentScreenModeOrigin,iCurrentScreenModeScale),
sl@0: 					  PhysicalToLogical(TPoint((Copy2ndHalfOfScreen ? FullScreenModeSize.iWidth : FullScreenModeSize.iWidth/2),FullScreenModeSize.iHeight)-iCurrentScreenModeOrigin,iCurrentScreenModeScale)
sl@0: 					  );
sl@0: 	TheClient->iScreen->CopyScreenToBitmap(iScreenBitmap,testWinRect);
sl@0: 	iBitmapWin->SetExt(PhysicalToLogical(TPoint((Copy2ndHalfOfScreen ? 0 : FullScreenModeSize.iWidth/2),0)-iCurrentScreenModeOrigin,iCurrentScreenModeScale),testWinRect.Size());
sl@0: 	iBitmapWin->SetVisible(ETrue);
sl@0: 	iBitmapWin->DrawNow();
sl@0: 	TheClient->Flush();
sl@0: 	TestRect();
sl@0: 	iBitmapWin->SetVisible(EFalse);
sl@0: 	iTestWin->SetVisible(EFalse);
sl@0: 	TheClient->Flush();
sl@0: 
sl@0: 	TheClient->iGroup->GroupWin()->SetOrdinalPosition(oldOrdinalPosition, oldOrdinalPriority); 
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID		GRAPHICS-WSERV-0093
sl@0: 
sl@0: @SYMDEF             DEF081259, DEF111847
sl@0: 
sl@0: @SYMTestCaseDesc    Window tests
sl@0: 					REQUIREMENT: PREQ673 (Screen Scaling)
sl@0: 					API: RWindowBase::InquireOffset(), RWindowBase::AbsPosition(),RWindowBase::Position()
sl@0: 
sl@0: @SYMTestPriority    High
sl@0: 
sl@0: @SYMTestStatus      Implemented
sl@0: 
sl@0: @SYMTestActions     Loops through all the screen modes present in the wsini file, and then moves to the test screen
sl@0: 	mode where it goes on changing the screen scale and origin. In each of the wsini screen modes and test
sl@0: 	screen modes, it checks the test window's API's RWindowBase::InquireOffset(), RWindowBase::AbsPosition()
sl@0: 	RWindowBase::Position(). Then it copies the content from either first or second half to second or first
sl@0: 	half and compares both the regions so that its content are same.
sl@0: 	Additionally, as part of defect fix DEF111847, this also loops through all the display modes, and if possible
sl@0: 	tests each with the above described method. Previously, it use to only test Color256.
sl@0: 
sl@0: @SYMTestExpectedResults The content of both halves of the screen should match.
sl@0: */		
sl@0: void CTScreenModeScaling::WindowTestsL()
sl@0: 	{
sl@0: 	INFO_PRINTF1(_L("AUTO  WindowTests : "));
sl@0: 	
sl@0: 	TDisplayMode curDispMode; // Holds the current display mode being tested 
sl@0: 	
sl@0: 	for(curDispMode = EGray2; curDispMode < EColorLast; curDispMode = TDisplayMode(curDispMode+1))
sl@0: 		{
sl@0: 		if (curDispMode == ERgb)
sl@0: 			{
sl@0: 			continue;
sl@0: 			}
sl@0: 		CTClient* client=new(ELeave) CTClient();
sl@0: 		CleanupStack::PushL(client);
sl@0: 		client->SetScreenNumber(iTest->iScreenNumber);
sl@0: 		client->ConstructL();
sl@0: 		client->iGroup=new(ELeave) TestWindowGroup(client);
sl@0: 		client->iGroup->ConstructL();
sl@0: 		client->iGroup->WinTreeNode()->SetOrdinalPosition(1);
sl@0: 		RBlankWindow testWindow(client->iWs);
sl@0: 		User::LeaveIfError(testWindow.Construct(*TheClient->iGroup->GroupWin(),ENullWsHandle));
sl@0: 		CleanupClosePushL(testWindow);
sl@0: 	
sl@0: 		TInt setDispMode; // Holds the actual display mode that was set
sl@0: 		setDispMode = testWindow.SetRequiredDisplayMode(curDispMode);
sl@0: 		
sl@0: 		//Only do the tests if the requested mode was actually set
sl@0: 		if(curDispMode == setDispMode)
sl@0: 			{
sl@0: 			//Create and show DisplayMode details message
sl@0: 			_LIT(KModeDetails, "Display Mode: ");
sl@0: 			TBuf<30> modeDetailsMessage(KModeDetails);
sl@0: 			modeDetailsMessage.Append(DisplayModeAsString(curDispMode));
sl@0: 			LOG_MESSAGE(modeDetailsMessage);
sl@0: 			
sl@0: 			testWindow.Activate();
sl@0: 			TheClient->iGroup->GroupWin()->EnableScreenChangeEvents();
sl@0: 			TInt numOfModes=TheClient->iScreenModes.Count();
sl@0: 			TInt ii;
sl@0: 			for (ii=0; ii<numOfModes; ++ii)
sl@0: 				{
sl@0: 				INFO_PRINTF1(_L(" Start of Loop"));
sl@0: 				iCurrentMode=TheClient->iScreenModes[ii];
sl@0: 				TPixelsAndRotation pixelsAndRotation;
sl@0: 				iCurrentScreenModeOrigin=TheClient->iScreen->GetScreenModeOrigin(iCurrentMode);
sl@0: 				iCurrentScreenModeScale=TheClient->iScreen->GetScreenModeScale(iCurrentMode);
sl@0: 				TheClient->iScreen->GetScreenModeSizeAndRotation(iCurrentMode,pixelsAndRotation);
sl@0: 				if (pixelsAndRotation.iRotation==CFbsBitGc::EGraphicsOrientationNormal)
sl@0: 					{
sl@0: 					INFO_PRINTF1(_L(" Do Tests"));
sl@0: 					TRAPD(ret,DoWindowTestsL());
sl@0: 					TEST(ret==KErrNone);
sl@0: 					if (ret!=KErrNone)
sl@0: 						{
sl@0: 						INFO_PRINTF3(_L("DoWindowTestsL() return value  - Expected: %d, Actual: %d"), KErrNone, ret);		
sl@0: 						}
sl@0: 
sl@0: 					INFO_PRINTF1(_L(" Window Trees"));
sl@0: 					client->iScreen->SetAppScreenMode(iCurrentMode);
sl@0: 					client->Flush();
sl@0: 					}
sl@0: 				}
sl@0: 				TestDifferentScales(numOfModes-1);
sl@0: 			}
sl@0: 		CleanupStack::PopAndDestroy(2,client);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: void CTScreenModeScaling::TestDifferentScales(TInt aLastModeIdx)
sl@0: 	{
sl@0: 	if (aLastModeIdx<0) return;
sl@0: 	TPixelsAndRotation pixelsAndRotation;
sl@0: 	for (TInt modeCount=aLastModeIdx;modeCount>=0;--modeCount)
sl@0: 		{
sl@0: 		TheClient->iScreen->GetScreenModeSizeAndRotation(TheClient->iScreenModes[modeCount],pixelsAndRotation);
sl@0: 		if (pixelsAndRotation.iRotation==CFbsBitGc::EGraphicsOrientationNormal)
sl@0: 			break;
sl@0: 		}
sl@0: 	iCurrentMode=TheClient->iScreenModes[aLastModeIdx];
sl@0: 	TheClient->iScreen->SetAppScreenMode(iCurrentMode);
sl@0: 	TheClient->iScreen->SetScreenMode(iCurrentMode);
sl@0: 	TSizeMode storeModeData=TheClient->iScreen->GetCurrentScreenModeAttributes();
sl@0: 	TSizeMode testMode=storeModeData;
sl@0: 	for (TInt xScale=1;xScale<4;++xScale)
sl@0: 		{
sl@0: 		for (TInt yScale=1;yScale<4;++yScale)
sl@0: 			{
sl@0: 			testMode.iScreenScale=TSize(xScale,yScale);
sl@0: 			TestDifferentOrigin(testMode,TPoint(20,20));
sl@0: 			TestDifferentOrigin(testMode,TPoint(20,30));
sl@0: 			TestDifferentOrigin(testMode,TPoint(30,20));
sl@0: 			TestDifferentOrigin(testMode,TPoint(FullScreenModeSize.iWidth/2+640/FullScreenModeSize.iWidth*10,60));
sl@0: 			}
sl@0: 		}
sl@0: 	TheClient->iScreen->SetScreenMode(iCurrentMode);
sl@0: 	TheClient->iScreen->SetCurrentScreenModeAttributes(storeModeData);
sl@0: 	TInt defaultMode=TheClient->iScreenModes[0];
sl@0: 	TheClient->iScreen->SetAppScreenMode(defaultMode);
sl@0: 	TheClient->iScreen->SetScreenMode(defaultMode);
sl@0: 	}
sl@0: 
sl@0: void CTScreenModeScaling::TestDifferentOrigin(TSizeMode &aMode,TPoint aOrigin)
sl@0: 	{
sl@0: 	TheClient->iScreen->SetScreenMode(iCurrentMode);//.. this is required because at the end of next screenmode test it will be set to zero screen mode
sl@0: 	aMode.iOrigin=aOrigin;
sl@0: 	TheClient->iScreen->SetCurrentScreenModeAttributes(aMode);
sl@0: 	TheClient->iScreen->SetAppScreenMode(iCurrentMode);
sl@0: 	TheClient->iScreen->SetScreenMode(iCurrentMode);
sl@0: 	iCurrentScreenModeOrigin=TheClient->iScreen->GetScreenModeOrigin(iCurrentMode);
sl@0: 	iCurrentScreenModeScale=TheClient->iScreen->GetScreenModeScale(iCurrentMode);
sl@0: 	TRAPD(ret,DoWindowTestsL());
sl@0: 	TEST(ret==KErrNone);
sl@0: 	if (ret!=KErrNone)
sl@0: 		INFO_PRINTF3(_L("DoWindowTestsL() return value  - Expected: %d, Actual: %d"), KErrNone, ret);		
sl@0: 	}
sl@0: 
sl@0: void CTScreenModeScaling::DoWindowTestsL()
sl@0: 	{
sl@0: 	TheClient->iScreen->SetAppScreenMode(iCurrentMode);
sl@0: 	TheClient->iScreen->SetScreenMode(iCurrentMode);
sl@0: 	Copy2ndHalfOfScreen=(iCurrentScreenModeOrigin.iX>FullScreenModeSize.iWidth/2? 1 : 0);
sl@0: 	TRect testWinRect(PhysicalToLogical(TPoint(),iCurrentScreenModeScale),
sl@0: 					  PhysicalToLogical(TPoint((Copy2ndHalfOfScreen ? FullScreenModeSize.iWidth 
sl@0: 																	: FullScreenModeSize.iWidth/2),
sl@0: 											   FullScreenModeSize.iHeight)-iCurrentScreenModeOrigin,iCurrentScreenModeScale) 
sl@0: 					  );
sl@0: 	testWinRect.Shrink(10,10);
sl@0: 	iTestWinSize=testWinRect.Size();
sl@0: 	PositionTestL(testWinRect.iTl);
sl@0: 	testWinRect.Shrink(10,10);
sl@0: 	iTestWinSize=testWinRect.Size();
sl@0: 	PositionTestL(testWinRect.iTl);
sl@0: 	BackedUpChildWindowTestL(testWinRect.iTl);
sl@0: 	GetInvalidRegionTestL(testWinRect.iTl);
sl@0: 	//NextScreenModeTestL(testWinRect.iTl);		//This test needs a lot more work ###
sl@0: 	}
sl@0: 
sl@0: void CTScreenModeScaling::PositionTestL(TPoint aPostion)
sl@0: 	{
sl@0: 	iTestWin->SetExt(aPostion,iTestWinSize);
sl@0: 	iTestWin->SetVisible(ETrue);
sl@0: 	iTestWin->Invalidate();
sl@0: 	TheClient->Flush();
sl@0: 	TheClient->WaitForRedrawsToFinish();
sl@0: 	TestTopClientWindowPositionAPIs(aPostion,iTestWin->BaseWin());
sl@0: 	CopyAndCompareL();
sl@0: 	}
sl@0: 
sl@0: void CTScreenModeScaling::BackedUpChildWindowTestL(TPoint aPostion)
sl@0: 	{
sl@0: 	iTestWin->SetVisible(ETrue);
sl@0: 	TPoint backedUpWinPt=TPoint(iTestWinSize.iWidth/3,iTestWinSize.iHeight/4);
sl@0: 	iBackedUpWin->SetExtL(backedUpWinPt,TSize(iTestWinSize.iWidth/6,iTestWinSize.iHeight/6));
sl@0: 	iBackedUpWin->SetVisible(ETrue);
sl@0: 	TestChildWindowPositionAPIs(backedUpWinPt,aPostion,iBackedUpWin->BaseWin(),iTestWin->BaseWin());
sl@0: 	aPostion+=TPoint(10,10);
sl@0: 	iTestWin->SetPos(aPostion);
sl@0: 	TestTopClientWindowPositionAPIs(aPostion,iTestWin->BaseWin());
sl@0: 	TestChildWindowPositionAPIs(backedUpWinPt,aPostion,iBackedUpWin->BaseWin(),iTestWin->BaseWin());
sl@0: 	iTestWin->Invalidate();
sl@0: 	TheClient->Flush();
sl@0: 	TheClient->WaitForRedrawsToFinish();
sl@0: 	TestTopClientWindowPositionAPIs(aPostion,iTestWin->BaseWin());
sl@0: 	TestChildWindowPositionAPIs(backedUpWinPt,aPostion,iBackedUpWin->BaseWin(),iTestWin->BaseWin());
sl@0: 	CopyAndCompareL();
sl@0: 	iBackedUpWin->SetVisible(EFalse);
sl@0: 	}
sl@0: 
sl@0: void CTScreenModeScaling::NextScreenModeTestL(TPoint aPos)
sl@0: 	{
sl@0: 	TInt numOfModes=TheClient->iScreenModes.Count();
sl@0: 	TInt defaultMode=TheClient->iScreenModes[0];
sl@0: 	TInt lastMode=TheClient->iScreenModes[numOfModes-1];
sl@0: 	TInt mode=(iCurrentMode<lastMode? iCurrentMode:defaultMode);
sl@0: 	// find current mode index
sl@0: 	TInt ii;
sl@0: 	TInt modeIdx=0;
sl@0: 	for (ii=0; ii<numOfModes; ++ii)
sl@0: 		{
sl@0: 		if (mode==TheClient->iScreenModes[ii])
sl@0: 			{
sl@0: 			modeIdx=ii;
sl@0: 			break;
sl@0: 			}
sl@0: 		}
sl@0: 	TPoint screenModeOrigin(0,0);
sl@0: 	TPixelsAndRotation pixelsAndRotation;
sl@0: 	while (screenModeOrigin==TPoint()||(pixelsAndRotation.iRotation!=CFbsBitGc::EGraphicsOrientationNormal))
sl@0: 		{
sl@0: 		mode=(mode==lastMode? defaultMode : TheClient->iScreenModes[++modeIdx]);
sl@0: 		if (mode==iCurrentMode)
sl@0: 			{
sl@0: 			return;
sl@0: 			}
sl@0: 		screenModeOrigin=TheClient->iScreen->GetScreenModeOrigin(mode);
sl@0: 		TheClient->iScreen->GetScreenModeSizeAndRotation(mode,pixelsAndRotation);
sl@0: 		}
sl@0: 	iTestWin->SetExt(aPos,iTestWinSize);
sl@0: 	iTestWin->SetVisible(ETrue);
sl@0: 	TheClient->Flush();
sl@0: 	CBasicWin* basicWin=new(ELeave) CBasicWin;
sl@0: 	CleanupStack::PushL(basicWin);
sl@0: 	basicWin->ConstructExtLD(*iTestWin,TPoint(),TSize(iTestWinSize.iWidth/5,iTestWinSize.iHeight/5));
sl@0: 	User::LeaveIfError(basicWin->BaseWin()->SetRequiredDisplayMode(EColor256));
sl@0: 	basicWin->AssignGC(*TheClient->iGc);
sl@0: 	basicWin->BaseWin()->SetShadowDisabled(ETrue);
sl@0: 	basicWin->BaseWin()->SetShadowHeight(0);
sl@0: 	basicWin->Activate();
sl@0: 	TPoint pos(iTestWinSize.iWidth/3,iTestWinSize.iWidth/4);
sl@0: 	basicWin->SetPos(pos);
sl@0: 	TheClient->Flush();
sl@0: 	TheClient->WaitForRedrawsToFinish();
sl@0: 	TestChildWindowPositionAPIs(pos,aPos,basicWin->BaseWin(),iTestWin->BaseWin());
sl@0: 	iCurrentScreenModeScale=TheClient->iScreen->GetScreenModeScale(mode);
sl@0: 	iCurrentScreenModeOrigin=TheClient->iScreen->GetScreenModeOrigin(mode);
sl@0: 	Copy2ndHalfOfScreen=(iCurrentScreenModeOrigin.iX>FullScreenModeSize.iWidth/2? 1 : 0);
sl@0: 	TheClient->iScreen->SetAppScreenMode(mode);
sl@0: 	TheClient->iScreen->SetScreenMode(mode);
sl@0: 	iTestWin->SetVisible(ETrue);
sl@0: 	CopyAndCompareL();
sl@0: 	TheClient->iScreen->SetAppScreenMode(defaultMode);
sl@0: 	TheClient->iScreen->SetScreenMode(defaultMode);
sl@0: 	CleanupStack::PopAndDestroy(basicWin);
sl@0: 	}
sl@0: 
sl@0: void CTScreenModeScaling::GetInvalidRegionTestL(TPoint aPos)
sl@0: 	{
sl@0: 	iTestWin->SetExt(aPos,iTestWinSize);
sl@0: 	iTestWin->SetVisible(ETrue);
sl@0: 	iTestChildWin->SetExt(TPoint(iTestWinSize.iWidth>>2,iTestWinSize.iHeight>>2),TSize(iTestWinSize.iWidth>>1,iTestWinSize.iHeight>>1));
sl@0: 	iTestChildWin->SetVisible(ETrue);
sl@0: 	TheClient->Flush(); // ensure testchildwin is on-screen
sl@0: 
sl@0: 	CArrayFixFlat<TRect> *rectList=new(ELeave) CArrayFixFlat<TRect>(3);
sl@0: 	CleanupStack::PushL(rectList);
sl@0: 	rectList->AppendL(TRect(1,1,5,2));
sl@0: 	rectList->AppendL(TRect(iTest->StdTestWindowSize().iWidth>>1,iTest->StdTestWindowSize().iHeight>>1,iTest->StdTestWindowSize().iWidth,iTest->StdTestWindowSize().iHeight));
sl@0: 	rectList->AppendL(TRect(2,0,4,5));
sl@0: 	
sl@0: 	// set iTestWin to a 'clean state' before invalidating rects in the window
sl@0: 	iTestWin->DrawNow();
sl@0: 	TheClient->Flush();
sl@0: 
sl@0: 	// invalidate the various rectangles in iTestWin & then initiate a redraw of the window
sl@0: 	RRegion invalidRegion;
sl@0: 	RRegion region;
sl@0: 	for (TInt index=0;index<rectList->Count();index++)
sl@0: 		{
sl@0: 		const TRect& myRect = (*rectList)[index];
sl@0: 		iTestWin->Invalidate(myRect);
sl@0: 		region.AddRect(myRect);
sl@0: 		}
sl@0: 	CleanupStack::PopAndDestroy(rectList);
sl@0: 	CleanupClosePushL(invalidRegion);
sl@0: 	CleanupClosePushL(region);
sl@0: 	iTestWin->Win()->GetInvalidRegion(invalidRegion);
sl@0: 	CompareRegionsL(region, invalidRegion);
sl@0: 	CleanupStack::PopAndDestroy(2,&invalidRegion);
sl@0: 	iTestChildWin->SetVisible(EFalse);
sl@0: 
sl@0: 	// ensure the test child win is removed
sl@0: 	TheClient->Flush();
sl@0: 	TheClient->WaitForRedrawsToFinish();
sl@0: 
sl@0: 	TRect rect1(iTestWinSize);
sl@0: 	TestGetInvalidRegionL(rect1);
sl@0: 	TInt width=iTestWinSize.iWidth;
sl@0: 	TInt height=iTestWinSize.iHeight;
sl@0: 	TRect rect2(TPoint(width/6,height/6),TSize(width/3,height/3));
sl@0: 	TestGetInvalidRegionL(rect2);
sl@0: 	
sl@0: 	// invalidate the entire test window
sl@0: 	iTestWin->Invalidate();
sl@0: 	TheClient->Flush();
sl@0: 
sl@0: 	iTestWin->SetPos(TPoint(15,15));
sl@0: 	iTestWin->SetPos(TPoint());
sl@0: 	iTestWin->SetPos(TPoint(-15,-15));
sl@0: 	iTestWin->SetPos(aPos);	
sl@0: 	RRegion invalid;
sl@0: 	RRegion testRegion(rect1);
sl@0: 	CleanupClosePushL(invalid);
sl@0: 	CleanupClosePushL(testRegion);
sl@0: 	iTestWin->Win()->GetInvalidRegion(invalid);
sl@0: 	TBool retVal = !invalid.CheckError();
sl@0: 	TEST(retVal);
sl@0: 	if (!retVal)
sl@0: 		INFO_PRINTF3(_L("RRegion.CheckError() return value  - Expected: %d, Actual: %d"), ETrue, retVal);		
sl@0: 	TEST(invalid.BoundingRect().iBr.iX<=iTestWinSize.iWidth);
sl@0: 	if (invalid.BoundingRect().iBr.iX>iTestWinSize.iWidth)
sl@0: 		INFO_PRINTF3(_L("invalid.BoundingRect().iBr.iX<=iTestWinSize.iWidth  - Expected: %d, Actual: %d"), invalid.BoundingRect().iBr.iX, iTestWinSize.iWidth);		
sl@0: 	CompareRegionsL(testRegion,invalid);
sl@0: 	CleanupStack::PopAndDestroy(2,&invalid);
sl@0: 
sl@0: 	// redraw the test window & confirm
sl@0: 	iTestWin->DrawNow();
sl@0: 	TheClient->Flush();
sl@0: 	CopyAndCompareL();
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID		GRAPHICS-WSERV-0094
sl@0: 
sl@0: @SYMDEF             DEF081259
sl@0: 
sl@0: @SYMTestCaseDesc    SpriteTestL
sl@0: 					REQUIREMENT: PREQ673 (Screen Scaling)
sl@0: 					API: RWsSprite::SetPosition()
sl@0: 
sl@0: @SYMTestPriority    High
sl@0: 
sl@0: @SYMTestStatus      Implemented
sl@0: 
sl@0: @SYMTestActions     In the same way as in window tests it shifts the screen modes.
sl@0: 					In each screen modes it creates a sprite window and then it moves slightly
sl@0: 					either side or bottom of the sprite, then it compares both the regions
sl@0: 					to check whether content are same.
sl@0: 
sl@0: @SYMTestExpectedResults The content of both halves of the screen should match.
sl@0: */		
sl@0: void CTScreenModeScaling::SpriteTestL()
sl@0: 	{
sl@0: 	CTClient* client=new(ELeave) CTClient();
sl@0: 	CleanupStack::PushL(client);
sl@0: 	client->SetScreenNumber(iTest->iScreenNumber);
sl@0: 	client->ConstructL();
sl@0: 	client->iGroup=new(ELeave) TestWindowGroup(client);
sl@0: 	client->iGroup->ConstructL();
sl@0: 	client->iGroup->WinTreeNode()->SetOrdinalPosition(1);
sl@0: 	RBlankWindow color256(client->iWs);
sl@0: 	User::LeaveIfError(color256.Construct(*TheClient->iGroup->GroupWin(),ENullWsHandle));
sl@0: 	CleanupClosePushL(color256);
sl@0: 	color256.SetRequiredDisplayMode(EColor256);
sl@0: 	color256.Activate();
sl@0: 	TInt numOfModes=TheClient->iScreenModes.Count();
sl@0: 	TInt flushState=TheClient->iWs.SetAutoFlush(ETrue);
sl@0: 	TInt ii;
sl@0: 	for (ii=0; ii<numOfModes; ++ii)
sl@0: 		{
sl@0: 		iCurrentMode=TheClient->iScreenModes[ii];
sl@0: 		TPixelsAndRotation pixelsAndRotation;
sl@0: 		iCurrentScreenModeOrigin=TheClient->iScreen->GetScreenModeOrigin(iCurrentMode);
sl@0: 		iCurrentScreenModeScale=TheClient->iScreen->GetScreenModeScale(iCurrentMode);
sl@0: 		TheClient->iScreen->GetScreenModeSizeAndRotation(iCurrentMode,pixelsAndRotation);
sl@0: 		DoSpriteTestsL();
sl@0: 		client->iScreen->SetAppScreenMode(iCurrentMode);
sl@0: 		client->Flush();
sl@0: 		}
sl@0: 	iCurrentMode=TheClient->iScreenModes[numOfModes-1];
sl@0: 	TheClient->iScreen->SetAppScreenMode(iCurrentMode);
sl@0: 	TheClient->iScreen->SetScreenMode(iCurrentMode);
sl@0: 	TSizeMode storeModeData=TheClient->iScreen->GetCurrentScreenModeAttributes();
sl@0: 	TSizeMode testMode=storeModeData;
sl@0: 	for (TInt xScale=1;xScale<4;xScale++)
sl@0: 		{
sl@0: 		for (TInt yScale=1;yScale<4;yScale++)
sl@0: 			{
sl@0: 			testMode.iScreenScale=TSize(xScale,yScale);
sl@0: 			TestDifferentOriginAndScaleForSpritesL(testMode,TPoint(20,20));
sl@0: 			TestDifferentOriginAndScaleForSpritesL(testMode,TPoint(20,30));
sl@0: 			TestDifferentOriginAndScaleForSpritesL(testMode,TPoint(30,20));
sl@0: 			TestDifferentOriginAndScaleForSpritesL(testMode,TPoint(FullScreenModeSize.iWidth/2+10,60));
sl@0: 			}
sl@0: 		}
sl@0: 	TheClient->iScreen->SetScreenMode(iCurrentMode);
sl@0: 	TheClient->iScreen->SetCurrentScreenModeAttributes(storeModeData);
sl@0: 	TInt defaultMode=TheClient->iScreenModes[0];
sl@0: 	TheClient->iScreen->SetAppScreenMode(defaultMode);
sl@0: 	TheClient->iScreen->SetScreenMode(defaultMode);
sl@0: 	CleanupStack::PopAndDestroy(2,client);
sl@0: 	TheClient->iWs.SetAutoFlush(flushState);
sl@0: 	}
sl@0: 
sl@0: void CTScreenModeScaling::TestDifferentOriginAndScaleForSpritesL(TSizeMode &aMode, TPoint aOrigin)
sl@0: 	{
sl@0: 	TheClient->iScreen->SetScreenMode(iCurrentMode);
sl@0: 	aMode.iOrigin=aOrigin;
sl@0: 	TheClient->iScreen->SetCurrentScreenModeAttributes(aMode);
sl@0: 	iCurrentScreenModeOrigin=TheClient->iScreen->GetScreenModeOrigin(iCurrentMode);
sl@0: 	iCurrentScreenModeScale=TheClient->iScreen->GetScreenModeScale(iCurrentMode);
sl@0: 	DoSpriteTestsL();
sl@0: 	}
sl@0: 
sl@0: void CTScreenModeScaling::DoSpriteTestsL()
sl@0: 	{
sl@0: 	TheClient->iScreen->SetAppScreenMode(iCurrentMode);
sl@0: 	TheClient->iScreen->SetScreenMode(iCurrentMode);
sl@0: 	TPixelsAndRotation pixelsAndRotation;
sl@0: 	TheClient->iScreen->GetScreenModeSizeAndRotation(iCurrentMode,pixelsAndRotation);
sl@0: 	RWsSprite sprite;
sl@0: 	TSize spriteSize=iSpriteBitmap.SizeInPixels();
sl@0: 	if (spriteSize.iWidth*iCurrentScreenModeScale.iWidth>FullScreenModeSize.iWidth/2)
sl@0: 		spriteSize.iWidth=(FullScreenModeSize.iWidth/2-20)/iCurrentScreenModeScale.iWidth;
sl@0: 	SetUpSpriteLC(sprite,TheClient->iWs,*iBlankWin->BaseWin());
sl@0: 	sprite.SetPosition(TPoint());
sl@0: 	CTestSpriteWin* spriteWin=new(ELeave) CTestSpriteWin(iSpriteBitmap);
sl@0: 	CleanupStack::PushL(spriteWin);
sl@0: 	spriteWin->ConstructExtLD(*TheClient->iGroup,PhysicalToLogical(TPoint()-iCurrentScreenModeOrigin,iCurrentScreenModeScale),spriteSize);
sl@0: 	User::LeaveIfError(spriteWin->BaseWin()->SetRequiredDisplayMode(EColor256));
sl@0: 	spriteWin->AssignGC(*TheClient->iGc);
sl@0: 	spriteWin->SetVisible(ETrue);
sl@0: 	spriteWin->Activate();
sl@0: 	spriteWin->UpdateWin(TPoint());
sl@0: 	spriteWin->BaseWin()->SetShadowDisabled(ETrue);
sl@0: 	spriteWin->BaseWin()->SetShadowHeight(0);
sl@0: 	TheClient->Flush();
sl@0: 	TheClient->WaitForRedrawsToFinish();
sl@0: 	TPoint spritePosition;
sl@0: 	if (iCurrentScreenModeOrigin.iX<=spriteSize.iWidth || iCurrentScreenModeOrigin.iY<=spriteSize.iHeight)
sl@0: 		{
sl@0: 		if (pixelsAndRotation.iRotation==CFbsBitGc::EGraphicsOrientationNormal || pixelsAndRotation.iRotation==CFbsBitGc::EGraphicsOrientationRotated180)
sl@0: 			spritePosition=TPoint(spriteSize.iWidth+1,0);
sl@0: 		else
sl@0: 			spritePosition=TPoint(0,spriteSize.iHeight+1);
sl@0: 		}
sl@0: 	sprite.SetPosition(spritePosition);	
sl@0: 	const TInt KAnimationGrace = 35000; //defined in server.cpp, but can be changed in wsini.ini
sl@0: 	User::After(KAnimationGrace);
sl@0: 	TBool retVal = TheClient->iScreen->RectCompare(TRect(PhysicalToLogical(TPoint()-iCurrentScreenModeOrigin,iCurrentScreenModeScale),spriteSize),TRect(spritePosition,spriteSize),CWsScreenDevice::EIncludeSprite);
sl@0: 	TEST(retVal);
sl@0: 	if (!retVal)
sl@0: 		INFO_PRINTF3(_L("TheClient->iScreen->RectCompare(rect1,rect2) return value  - Expected: %d, Actual: %d"), ETrue, retVal);		
sl@0: 
sl@0: 	sprite.SetPosition(TPoint());	
sl@0: 	CleanupStack::PopAndDestroy(spriteWin);
sl@0: 	CleanupStack::PopAndDestroy(&sprite);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID		GRAPHICS-WSERV-0095
sl@0: 
sl@0: @SYMDEF             DEF081259
sl@0: 
sl@0: @SYMTestCaseDesc    Rotation Tests
sl@0: 					REQUIREMENT: PREQ673 (Screen Scaling)
sl@0: 					API: RWindowBase::InquireOffset(), RWindowBase::AbsPosition(),RWindowBase::Position()
sl@0: 
sl@0: @SYMTestPriority    High
sl@0: 
sl@0: @SYMTestStatus      Implemented
sl@0: 
sl@0: @SYMTestActions     For each of the screen mode with all its rotation it checks whether the window
sl@0: 					is correctly placed in particular screen mode. Then it creates a child window
sl@0: 					and checks whether it s correctly placed.
sl@0: 
sl@0: @SYMTestExpectedResults Checks the windows are positioned correctly according to the origin,scale and rotation 
sl@0: 					of the new screen mode.
sl@0: */		
sl@0: void CTScreenModeScaling::RotationTestsL()
sl@0: 	{
sl@0: 	CTClient* client=new(ELeave) CTClient();
sl@0: 	CleanupStack::PushL(client);
sl@0: 	client->SetScreenNumber(iTest->iScreenNumber);
sl@0: 	client->ConstructL();
sl@0: 	client->iGroup=new(ELeave) TestWindowGroup(client);
sl@0: 	client->iGroup->ConstructL();
sl@0: 	client->iGroup->WinTreeNode()->SetOrdinalPosition(1);
sl@0: 	RBlankWindow color256(client->iWs);
sl@0: 	User::LeaveIfError(color256.Construct(*TheClient->iGroup->GroupWin(),ENullWsHandle));
sl@0: 	CleanupClosePushL(color256);
sl@0: 	color256.SetRequiredDisplayMode(EColor256);
sl@0: 	color256.Activate();
sl@0: 	TInt oldCurrentMode=0;
sl@0: 	TInt ii;
sl@0: 	//TInt screenMode=TheClient->iScreen->CurrentScreenMode();
sl@0: 	for (ii=0;ii<TheClient->iScreenModes.Count();)
sl@0: 		{
sl@0: 		iCurrentMode=TheClient->iScreenModes[ii];
sl@0: 		if (iCurrentMode!=oldCurrentMode)
sl@0: 			{
sl@0: 			client->iScreen->SetAppScreenMode(iCurrentMode);
sl@0: 			TheClient->iScreen->SetScreenMode(iCurrentMode);
sl@0: 			TheClient->iScreen->SetAppScreenMode(iCurrentMode);
sl@0: 			}
sl@0: 		TPixelsAndRotation pixelsAndRotation;
sl@0: 		TheClient->iScreen->GetDefaultScreenSizeAndRotation(pixelsAndRotation);
sl@0: 		oldCurrentMode=iCurrentMode;
sl@0: 		CArrayFixFlat<TInt>* rotations=new(ELeave) CArrayFixFlat<TInt>(1);
sl@0: 		CleanupStack::PushL(rotations);
sl@0: 		User::LeaveIfError(TheClient->iScreen->GetRotationsList(iCurrentMode,rotations));
sl@0: 		TInt count=rotations->Count();
sl@0: 		TInt jj=0;
sl@0: 		if (count>1)
sl@0: 			{
sl@0: 			for (jj=0;jj<count;)
sl@0: 				{
sl@0: 				if ((*rotations)[jj++]==pixelsAndRotation.iRotation)
sl@0: 					{
sl@0: 					break;
sl@0: 					}
sl@0: 				}
sl@0: 			if (jj==count)
sl@0: 				{
sl@0: 				jj=0;
sl@0: 				}
sl@0: 			}
sl@0: 		if (jj==0)
sl@0: 			{
sl@0: 			ii++;
sl@0: 			}
sl@0: 		TInt currentRotation=(*rotations)[jj];
sl@0: 		TheClient->iScreen->SetCurrentRotations(oldCurrentMode,REINTERPRET_CAST(CFbsBitGc::TGraphicsOrientation&,currentRotation));
sl@0: 		CleanupStack::PopAndDestroy(rotations);
sl@0: 		iCurrentScreenModeOrigin=TheClient->iScreen->GetScreenModeOrigin(oldCurrentMode);
sl@0: 		iCurrentScreenModeScale=TheClient->iScreen->GetScreenModeScale(oldCurrentMode);
sl@0: 		TRect testWinRect(PhysicalToLogical(TPoint(),iCurrentScreenModeScale),
sl@0: 						  PhysicalToLogical(TPoint((Copy2ndHalfOfScreen ? FullScreenModeSize.iWidth : FullScreenModeSize.iWidth/2),FullScreenModeSize.iHeight)-iCurrentScreenModeOrigin,iCurrentScreenModeScale) 
sl@0: 						 );
sl@0: 		testWinRect.Shrink(10,10);
sl@0: 		iTestWin->SetExtL(testWinRect.iTl,testWinRect.Size());
sl@0: 		iTestWin->Invalidate();
sl@0: 		iTestWin->SetVisible(ETrue);
sl@0: 		TheClient->Flush();
sl@0: 		TheClient->WaitForRedrawsToFinish();
sl@0: 		TestTopClientWindowPositionAPIs(testWinRect.iTl,iTestWin->BaseWin());
sl@0: 		TPoint backedUpWinPt=TPoint(testWinRect.Width()/3,testWinRect.Height()/4);
sl@0: 		iBackedUpWin->SetVisible(ETrue);
sl@0: 		iBackedUpWin->SetExtL(backedUpWinPt,TSize(testWinRect.Width()/6,testWinRect.Height()/6));
sl@0: 		TestChildWindowPositionAPIs(backedUpWinPt,testWinRect.iTl,iBackedUpWin->BaseWin(),iTestWin->BaseWin());
sl@0: 		iTestWin->SetVisible(EFalse);
sl@0: 		iBackedUpWin->SetVisible(EFalse);
sl@0: 		}
sl@0: 	CleanupStack::PopAndDestroy(2,client);
sl@0: 	}
sl@0: 
sl@0: void CTScreenModeScaling::DrawTransparentWindows()
sl@0: 	{
sl@0: 	//.. First Draw on Backgroundbitmap
sl@0: 	iBackgroundBitmap->Gc().SetBrushColor(TRgb(255,0,255));
sl@0: 	iBackgroundBitmap->Gc().SetBrushStyle(CGraphicsContext::ESolidBrush);
sl@0: 	iBackgroundBitmap->Gc().SetPenStyle(CGraphicsContext::ENullPen);
sl@0: 	iBackgroundBitmap->Gc().DrawRect(iWinSize);
sl@0: 	
sl@0: 	//.. Invalidate the background bitmap and do bitBlt to iCheckBitmap also
sl@0: 	iBackgroundWin->BaseWin()->SetVisible(ETrue);
sl@0: 	iBackgroundWin->DrawNow();
sl@0: 
sl@0: 	//.. Copy to checkbitmap
sl@0: 	iCheckBitmap->Gc().SetFaded(EFalse);
sl@0: 	iCheckBitmap->Gc().BitBlt(TPoint(),&iBackgroundBitmap->Bitmap());
sl@0: 
sl@0: 	//.. Set the grade of transperency
sl@0: 	iTransparencyBitmap->Gc().SetBrushColor(TRgb::Gray256(128));
sl@0: 	iTransparencyBitmap->Gc().SetBrushStyle(CGraphicsContext::ESolidBrush);
sl@0: 	iTransparencyBitmap->Gc().SetPenStyle(CGraphicsContext::ENullPen);
sl@0: 	iTransparencyBitmap->Gc().DrawRect(iWinSize);
sl@0: 
sl@0: 	//.. Then draw to the fore ground bitmap and invalidate the second window
sl@0: 	iForegroundBitmap->Gc().Reset();
sl@0: 	iForegroundBitmap->Gc().SetPenStyle(CGraphicsContext::ESolidPen);
sl@0: 	iForegroundBitmap->Gc().SetPenSize(TSize(1,1));
sl@0: 	iForegroundBitmap->Gc().SetPenColor(TRgb(0,0,0));
sl@0: 	iForegroundBitmap->Gc().DrawLine(TPoint(0,0),TPoint(iWinSize.iWidth,iWinSize.iHeight));
sl@0: 	iForegroundBitmap->Gc().DrawLine(TPoint(iWinSize.iWidth,0),TPoint(0,iWinSize.iHeight));
sl@0: 	iTransWin->BaseWin()->SetVisible(ETrue);
sl@0: 	iTransWin->Invalidate();
sl@0: 	iTransWin->DrawNow();
sl@0: 
sl@0: 	iCheckBitmap->Gc().AlphaBlendBitmaps(TPoint(0,0),&iForegroundBitmap->Bitmap(),&iCheckBitmap->Bitmap()
sl@0: 													,TRect(iWinSize),TPoint(0,0),&iTransparencyBitmap->Bitmap(),TPoint(0,0));
sl@0: 	iCheckWin->BaseWin()->SetVisible(ETrue);
sl@0: 	iCheckWin->BackedUpWin()->UpdateScreen();
sl@0: 	TheClient->Flush();
sl@0: 	TheClient->WaitForRedrawsToFinish();
sl@0: 	CheckRect(iTransWin,iCheckWin,TRect(iWinSize),_L("DrawTransparentWindows() CheckRect failed"));
sl@0: 	}
sl@0: 
sl@0: // !!! THE COMMENT BELOW IS DISABLED BECAUSE TransparentTests() METHOD IS NOT USED !!!
sl@0: //**
sl@0: //@SYMTestCaseID		GRAPHICS-WSERV-0096
sl@0: //
sl@0: //@SYMDEF             DEF081259
sl@0: //
sl@0: //@SYMTestCaseDesc    TransparentTests
sl@0: //					REQUIREMENT: PREQ673 (Screen Scaling)
sl@0: //					API: CWindowGc::AlphaBlendBitmaps()
sl@0: //
sl@0: //@SYMTestPriority    High
sl@0: //
sl@0: //@SYMTestStatus      Implemented
sl@0: //
sl@0: //@SYMTestActions     The main logic behind this test is to copy the content of the background window
sl@0: //					bitmap to checkwindow bitmap and then use the foreground window bitmap and transparency bitmap
sl@0: //					with the function AlphaBlendBitmaps() to get the content present on the combination of 
sl@0: //					foreground(transparent) window and background window. Then compare both the regions of the 
sl@0: //					window to check whether the content is same.
sl@0: //
sl@0: //@SYMTestExpectedResults The content of both halves of the screen should match.
sl@0: //*/		
sl@0: void CTScreenModeScaling::TransparentTestsL()
sl@0: 	{
sl@0: 	TInt flushState=TheClient->iWs.SetAutoFlush(ETrue);
sl@0: 	TInt defaultMode=TheClient->iScreenModes[0];
sl@0: 	TheClient->iScreen->SetAppScreenMode(defaultMode);
sl@0: 	TheClient->iScreen->SetScreenMode(defaultMode);
sl@0: 	CTClient* client=new(ELeave) CTClient();
sl@0: 	CleanupStack::PushL(client);
sl@0: 	client->SetScreenNumber(iTest->iScreenNumber);
sl@0: 	client->ConstructL();
sl@0: 	client->iGroup=new(ELeave) TestWindowGroup(client);
sl@0: 	client->iGroup->ConstructL();
sl@0: 	client->iGroup->WinTreeNode()->SetOrdinalPosition(1);
sl@0: 	RBlankWindow color256(client->iWs);
sl@0: 	User::LeaveIfError(color256.Construct(*TheClient->iGroup->GroupWin(),ENullWsHandle));
sl@0: 	CleanupClosePushL(color256);
sl@0: 	color256.SetRequiredDisplayMode(EColor256);
sl@0: 	color256.Activate();
sl@0: 	client->Flush();
sl@0: 	DrawTransparentWindows();
sl@0: 	iCurrentMode=TheClient->iScreenModes[TheClient->iScreenModes.Count()-1];
sl@0: 	TheClient->iScreen->SetAppScreenMode(iCurrentMode);
sl@0: 	TheClient->iScreen->SetScreenMode(iCurrentMode);
sl@0: 	TSizeMode storeModeData=TheClient->iScreen->GetCurrentScreenModeAttributes();
sl@0: 	TSizeMode testMode=storeModeData;
sl@0: 	for (TInt xScale=1;xScale<4;xScale++)
sl@0: 		{
sl@0: 		for (TInt yScale=1;yScale<4;yScale++)
sl@0: 			{
sl@0: 			testMode.iScreenScale=TSize(xScale,yScale);
sl@0: 			TestDifferentOriginAndScaleForTranspWin(testMode,TPoint(20,20));
sl@0: 			TestDifferentOriginAndScaleForTranspWin(testMode,TPoint(20,30));
sl@0: 			TestDifferentOriginAndScaleForTranspWin(testMode,TPoint(30,20));
sl@0: 			TestDifferentOriginAndScaleForTranspWin(testMode,TPoint(FullScreenModeSize.iWidth/2+1,60));
sl@0: 			}
sl@0: 		}
sl@0: 	TheClient->iScreen->SetScreenMode(iCurrentMode);
sl@0: 	TheClient->iScreen->SetCurrentScreenModeAttributes(storeModeData);
sl@0: 	client->iScreen->SetAppScreenMode(iCurrentMode);
sl@0: 	client->Flush();
sl@0: 	TheClient->iScreen->SetAppScreenMode(defaultMode);
sl@0: 	TheClient->iScreen->SetScreenMode(defaultMode);
sl@0: 	TheClient->iWs.SetAutoFlush(flushState);
sl@0: 	CleanupStack::PopAndDestroy(2,client);
sl@0: 	}
sl@0: 
sl@0: void CTScreenModeScaling::TestDifferentOriginAndScaleForTranspWin(TSizeMode &aMode,TPoint aOrigin)
sl@0: 	{
sl@0: 	TheClient->iScreen->SetScreenMode(iCurrentMode);
sl@0: 	aMode.iOrigin=aOrigin;
sl@0: 	TheClient->iScreen->SetCurrentScreenModeAttributes(aMode);
sl@0: 	TheClient->iScreen->SetAppScreenMode(iCurrentMode);
sl@0: 	TheClient->iScreen->SetScreenMode(iCurrentMode);
sl@0: 	TRAPD(ret,DrawTransparentWindows());
sl@0: 	TEST(ret==KErrNone);
sl@0: 	if (ret!=KErrNone)
sl@0: 		INFO_PRINTF3(_L("DrawTransparentWindows() return value  - Expected: %d, Actual: %d"), KErrNone, ret);		
sl@0: 
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID		GRAPHICS-WSERV-0097
sl@0: 
sl@0: @SYMDEF             DEF081259
sl@0: 
sl@0: @SYMTestCaseDesc    AppScreenModeTest
sl@0: 					REQUIREMENT: PREQ673 (Screen Scaling)
sl@0: 					API: CWsScreenDevice::SetAppScreenMode()
sl@0: 
sl@0: @SYMTestPriority    High
sl@0: 
sl@0: @SYMTestStatus      Implemented
sl@0: 
sl@0: @SYMTestActions     Enable the visibility of Test window, Call SetAppScreenMode() API with different
sl@0: 					screen mode. Check the variable which is set in its draw function. 
sl@0: 
sl@0: @SYMTestExpectedResults The variable should not be set when the application screen mode is different 
sl@0: 					then current screen mode. 
sl@0: */
sl@0: void CTScreenModeScaling::AppScreenModeTestL()
sl@0: 	{
sl@0: 	TheClient->iScreen->SetAppScreenMode(0);
sl@0: 	TheClient->iScreen->SetScreenMode(0);
sl@0: 	iTestWin->iDrawn=EFalse;
sl@0: 	iTestWin->SetExtL(TPoint(),TSize(FullScreenModeSize.iWidth/2,FullScreenModeSize.iHeight));
sl@0: 	iTestWin->SetVisible(ETrue);
sl@0: 	TheClient->Flush();
sl@0: 	TheClient->WaitForRedrawsToFinish();
sl@0: 	TEST(iTestWin->iDrawn);
sl@0: 	if (!iTestWin->iDrawn)
sl@0: 		INFO_PRINTF3(_L("iTestWin->iDrawn  - Expected: %d, Actual: %d"), ETrue, iTestWin->iDrawn);
sl@0: 
sl@0: 	iTestWin->iDrawn=EFalse;
sl@0: 	TheClient->iScreen->SetAppScreenMode(2);
sl@0: 	TheClient->iScreen->SetScreenMode(0);
sl@0: 	iTestWin->Invalidate();
sl@0: 	TheClient->Flush();
sl@0: 	TEST(!iTestWin->iDrawn);
sl@0: 	if (iTestWin->iDrawn)
sl@0: 		INFO_PRINTF3(_L("iTestWin->iDrawn  - Expected: %d, Actual: %d"), EFalse, iTestWin->iDrawn);
sl@0: 
sl@0: 	TheClient->iScreen->SetAppScreenMode(0);
sl@0: 	TheClient->Flush();
sl@0: 	TheClient->WaitForRedrawsToFinish();
sl@0: 	TEST(iTestWin->iDrawn);
sl@0: 	if (!iTestWin->iDrawn)
sl@0: 		INFO_PRINTF3(_L("iTestWin->iDrawn  - Expected: %d, Actual: %d"), ETrue, iTestWin->iDrawn);
sl@0: 
sl@0: 	iTestWin->iDrawn=EFalse;
sl@0: 	TheClient->iScreen->SetScreenMode(1);
sl@0: 	iTestWin->Invalidate();
sl@0: 	TheClient->Flush();
sl@0: 	TEST(!iTestWin->iDrawn);
sl@0: 	if (iTestWin->iDrawn)
sl@0: 		INFO_PRINTF3(_L("iTestWin->iDrawn  - Expected: %d, Actual: %d"), EFalse, iTestWin->iDrawn);
sl@0: 
sl@0: 	iTestWin->SetVisible(EFalse);
sl@0: 	TheClient->iScreen->SetAppScreenMode(0);
sl@0: 	TheClient->iScreen->SetScreenMode(0);
sl@0: 	}
sl@0: 
sl@0: void CTScreenModeScaling::RunTestCaseL(TInt /*aCurTestCase*/)
sl@0: 	{
sl@0: 	_LIT(KWindowTests,"Window Tests");
sl@0: 	_LIT(KSpriteTest,"Sprite Test");
sl@0: 	_LIT(KRotationTests,"Rotation Tests");
sl@0: 	_LIT(KTransparentTests,"Transparent Tests");
sl@0: 	_LIT(KAppScreenModeTest,"AppScreenMode Test");
sl@0: 	_LIT(KScalling,"Scaling not Supported");
sl@0: 	_LIT(KModes,"Only one Screen Size Mode");
sl@0: 	
sl@0: 	((CTScreenModeScalingStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);
sl@0: 	switch(++iTest->iState)
sl@0: 		{
sl@0: 		case 1:
sl@0: 			{
sl@0: 			((CTScreenModeScalingStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0097"));
sl@0: 			TInt numScrModes=TheClient->iScreen->NumScreenModes();
sl@0: 			if (numScrModes<2 || !CheckScalingSupportedOrNot())
sl@0: 				{
sl@0: 				if (numScrModes<2)
sl@0: 					LOG_MESSAGE(KModes);
sl@0: 				else
sl@0: 					LOG_MESSAGE(KScalling);
sl@0: 				TestComplete();
sl@0: 				return;
sl@0: 				}
sl@0: 			iTest->LogSubTest(KAppScreenModeTest);
sl@0: 			AppScreenModeTestL();
sl@0: 			}
sl@0: 			break;
sl@0: 		case 2:
sl@0: 			((CTScreenModeScalingStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0093"));
sl@0: 			iTest->LogSubTest(KWindowTests);
sl@0: 			WindowTestsL();
sl@0: 			break;
sl@0: 		case 3:
sl@0: 			((CTScreenModeScalingStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0094"));
sl@0: 			iTest->LogSubTest(KSpriteTest);
sl@0: 			SpriteTestL();
sl@0: 			break;
sl@0: 		case 4:
sl@0: 			((CTScreenModeScalingStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0095"));
sl@0: 			iTest->LogSubTest(KRotationTests);
sl@0: 			RotationTestsL();
sl@0: 			break;
sl@0: 		case 5:
sl@0: 			((CTScreenModeScalingStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);
sl@0: 			iTest->LogSubTest(KTransparentTests);
sl@0: 			//TransparentTestsL();		//This tests currently fails sometimes for reasons not understood ####
sl@0: 			break;
sl@0: 		default:
sl@0: 			{
sl@0: 			TInt defaultMode=TheClient->iScreenModes[0];
sl@0: 			TheClient->iScreen->SetAppScreenMode(defaultMode);
sl@0: 			TheClient->iScreen->SetScreenMode(defaultMode);
sl@0: 			}
sl@0: 			((CTScreenModeScalingStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);
sl@0: 			((CTScreenModeScalingStep*)iStep)->CloseTMSGraphicsStep();
sl@0: 			TestComplete();
sl@0: 			return;
sl@0: 		}
sl@0: 	((CTScreenModeScalingStep*)iStep)->RecordTestResultL();
sl@0: 	}
sl@0: 
sl@0: __WS_CONSTRUCT_STEP__(ScreenModeScaling)