diff -r bf7481649c98 -r 7f25ef56562d windowing/windowserver/test/tauto/TSCREENMODEPOSITIONING.CPP --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/windowing/windowserver/test/tauto/TSCREENMODEPOSITIONING.CPP Wed Jun 23 19:41:15 2010 +0300 @@ -0,0 +1,1164 @@ +// 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 code for screen mode positioning CR +// GT 0164 Uikon: A3.26. IM 9. +// Test code for the positioning part of Change Request PHAR-5SJGAM +// ("Enable screen mode positioning and scaling"). +// Note this feature is also in GT0199 as PREQ673"Screen Positioning". +// Tests screen position being configurable for a screen mode - +// eg it is now possible to set in wsini.ini the position on the +// physical screen where the origin of the screen mode's screen will appear. +// +// + +/** + @file + @test + @internalComponent - Internal Symbian test code +*/ + +#include "TSCREENMODEPOSITIONING.H" +#include + +//#define LOGGING on //Uncomment this line to get extra logging useful when there is a tests that fails + +LOCAL_D TSize FullScreenModeSize; +LOCAL_D TDisplayMode ScreenDisplayMode; +LOCAL_D TInt Copy2ndHalfOfScreen; + + +void CBasicWin::Draw() + { + iGc->SetBrushStyle(CGraphicsContext::ESolidBrush); + iGc->SetPenStyle(CGraphicsContext::ENullPen); + iGc->SetBrushColor(TRgb(255,0,0)); + TSize winSize=Size(); + iGc->DrawRect(TRect(winSize)); + iGc->SetBrushColor(TRgb(0,221,221)); + iGc->DrawEllipse(TRect(TPoint(winSize.iWidth/2,winSize.iHeight/2),winSize)); + iGc->DrawEllipse(TRect(TPoint(-winSize.iWidth/2,-winSize.iHeight/2),winSize)); + iDrawn=ETrue; + } + +void CSpriteWin::UpdateState(TInt aState) + { + SetState(aState); + DrawNow(); + } + +TPoint CheckSpritePos(233,60); +TPoint CheckSpritePos2(18,60); + +void CSpriteWin::Draw() + { + switch(iState) + { + case 0: + iGc->BitBlt(CheckSpritePos,&iSpriteBitmap); + break; + case 1: + iGc->BitBlt(CheckSpritePos+TPoint(30,30),&iSpriteBitmap); + iGc->BitBlt(CheckSpritePos,&iSpriteBitmap); + break; + case 2: + iGc->BitBlt(CheckSpritePos2+TPoint(-10,40),&iSpriteBitmap); + iGc->BitBlt(CheckSpritePos2+TPoint(-10,20),&iSpriteBitmap); + break; + case 3: + iGc->BitBlt(TPoint(),&iSpriteBitmap); + break; + default: + break; + } + } + +CSpriteWin::~CSpriteWin() + { + } + +void CBmpWin::Draw() + { + iGc->BitBlt(TPoint(),&iScreenBmp); + } + +CConnection2::~CConnection2() + { + delete iScreenBitmap; + delete iBitmapWin; + delete iSpriteWin; + iGroup->GroupWin()->EnableReceiptOfFocus(EFalse); + delete iGroup; + delete iClient; + } + +void CConnection2::ConstructL(CTestBase *aTest,CFbsBitmap& aBitmap) + { + iClient=new(ELeave) CTClient; + iClient->SetScreenNumber(aTest->ScreenNumber()); + iClient->ConstructL(); + iGroup=new(ELeave) CConnection2Group(iClient,this,aTest); + iGroup->ConstructL(); + iGroup->GroupWin()->EnableScreenChangeEvents(); + iClient->Flush(); + iSpriteWin=new(ELeave) CSpriteWin(aBitmap); + iSpriteWin->ConstructExtLD(*iGroup,TPoint(),TSize(433,240)); + User::LeaveIfError(iSpriteWin->BaseWin()->SetRequiredDisplayMode(EColor256)); + iSpriteWin->AssignGC(*iClient->iGc); + iSpriteWin->Activate(); + iSpriteWin->SetVisible(EFalse); + iSpriteWin->BaseWin()->SetShadowDisabled(ETrue); + iSpriteWin->BaseWin()->SetShadowHeight(0); + iScreenBitmap=new(ELeave) CFbsBitmap(); + User::LeaveIfError(iScreenBitmap->Create(TSize(FullScreenModeSize.iWidth/2,FullScreenModeSize.iHeight), ScreenDisplayMode)); + iBitmapWin=new(ELeave) CBmpWin(*iScreenBitmap); + iBitmapWin->ConstructExtLD(*iGroup,TPoint(FullScreenModeSize.iWidth/2,0),iScreenBitmap->SizeInPixels()); + User::LeaveIfError(iBitmapWin->BaseWin()->SetRequiredDisplayMode(EColor256)); + iBitmapWin->AssignGC(*iClient->iGc); + iBitmapWin->Activate(); + iBitmapWin->SetVisible(EFalse); + iBitmapWin->BaseWin()->SetShadowDisabled(ETrue); + iBitmapWin->BaseWin()->SetShadowHeight(0); + } + +void CConnection2::DrawBitmapWin() + { + TPoint pos=(Copy2ndHalfOfScreen? TPoint() : TPoint(FullScreenModeSize.iWidth/2,0)); + iBitmapWin->SetPos(pos); + iBitmapWin->SetVisible(ETrue); + iBitmapWin->DrawNow(); + iClient->Flush(); + } + +CConnection2Group::CConnection2Group(CTClient *aClient, CConnection2 *aSecondConnection, CTestBase *aTest) : CTWindowGroup(aClient), iTest(aTest), iConnection2(aSecondConnection) + {} + + + + +//CTScreenModePositioning +CTScreenModePositioning::CTScreenModePositioning(CTestStep* aStep) : CTWsGraphicsBase(aStep) + { + } + + +CTScreenModePositioning::~CTScreenModePositioning() + { + delete iTestWin; + delete iConnection2; + delete iBlankWin; + delete iBackedUpWin; + delete iTestChildWin; + } + +void CTScreenModePositioning::ConstructL() + { + User::LeaveIfError(iSpriteBitmap.Load(TEST_BITMAP_NAME,0)); + iScalingSupported=CheckScalingSupportedOrNot(); + TheClient->iScreen->SetScreenMode(TheClient->iScreenModes[0]); + FullScreenModeSize=TheClient->iScreen->SizeInPixels(); + ScreenDisplayMode=TheClient->iScreen->DisplayMode(); + iConnection2=new(ELeave) CConnection2; + iConnection2->ConstructL(iTest,iSpriteBitmap); + iBlankWin=new(ELeave) CTBlankWindow(); + iBlankWin->ConstructL(*TheClient->iGroup); + User::LeaveIfError(iBlankWin->BaseWin()->SetRequiredDisplayMode(EColor256)); + iBlankWin->SetExt(TPoint(),FullScreenModeSize); + iBlankWin->SetVisible(EFalse); + iBlankWin->Activate(); + iTestWin=new(ELeave) CBasicWin; + iTestWin->ConstructExtLD(*TheClient->iGroup,TPoint(),FullScreenModeSize); + User::LeaveIfError(iTestWin->BaseWin()->SetRequiredDisplayMode(EColor256)); + iTestWin->AssignGC(*TheClient->iGc); + iTestWin->BaseWin()->SetShadowDisabled(ETrue); + iTestWin->BaseWin()->SetShadowHeight(0); + iTestWin->SetVisible(EFalse); + iTestWin->Activate(); + iBackedUpWin=new(ELeave) CTBackedUpWin(EColor256); + iBackedUpWin->ConstructExtLD(*iTestWin,TPoint(),FullScreenModeSize); + iBackedUpWin->SetVisible(EFalse); + iBackedUpWin->Activate(); + iTestChildWin=new(ELeave) CTBlankWindow(); + iTestChildWin->ConstructL(*iTestWin); + User::LeaveIfError(iTestChildWin->BaseWin()->SetRequiredDisplayMode(EColor256)); + iTestChildWin->BaseWin()->SetShadowDisabled(ETrue); + iTestChildWin->SetColor(KRgbGreen); + iTestChildWin->BaseWin()->SetVisible(EFalse); + iTestChildWin->Activate(); + //The Cursor appearing on screen will affect the result of RectCompare function. + //Set it to the position out of the screen + TheClient->iWs.SetPointerCursorPosition(TPoint(-1,-1)); + } + +void CTScreenModePositioning::ChangeScreenMode(CTClient* aClient,TPixelsAndRotation aPixelsAndRotation,TInt aMode) + { + ChangeScreenMode(aClient,aPixelsAndRotation,ESizeEnforcementNone,aMode); + } + +void CTScreenModePositioning::ChangeScreenMode(CTClient* aClient,TPixelsAndRotation aPixelsAndRotation,TScreenModeEnforcement aScreenModeEnforcement,TInt aMode) + { + aClient->iScreen->SetScreenSizeAndRotation(aPixelsAndRotation); + aClient->iScreen->SetScreenModeEnforcement(aScreenModeEnforcement); + aClient->iScreen->SetScreenMode(aMode); + } + +void CTScreenModePositioning::SetScreenMode(CTClient* aClient,TInt aMode,TScreenModeEnforcement aScreenModeEnforcement) + { + TPixelsAndRotation pixelsAndRotation; + aClient->iScreen->SetScreenModeEnforcement(aScreenModeEnforcement); + aClient->iScreen->SetScreenMode(aMode); + aClient->iScreen->GetDefaultScreenSizeAndRotation(pixelsAndRotation); + aClient->iScreen->SetScreenSizeAndRotation(pixelsAndRotation); + aClient->Flush(); + } + +void CTScreenModePositioning::SetUpSpriteLC(RWsSprite &aSprite, RWsSession &aSession, RWindowTreeNode &aWindow,TInt aFlags) + { + aSprite=RWsSprite(aSession); + User::LeaveIfError(aSprite.Construct(aWindow,TPoint(),aFlags)); + CleanupClosePushL(aSprite); + TSpriteMember member; + iTest->SetUpMember(member); + member.iBitmap=&iSpriteBitmap; + User::LeaveIfError(aSprite.AppendMember(member)); + User::LeaveIfError(aSprite.Activate()); + } + +/** +@SYMTestCaseID GRAPHICS-WSERV-0098 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc Window Tests. Please see test cases GRAPHICS-WSERV-(0099-0103) which are a subset of this test case. + REQUIREMENT: CR PHAR-5SJGAM, PREQ673 + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Tests on windows in different screen modes each with differing screen mode origin's defined in the + wsini file. This test case only tests screen modes with 0 orientation. + Goes through each screen mode defined in the wsini file and exercises test cases GRAPHICS-WSERV-(0099-0103) for each mode. + For more details see test cases GRAPHICS-WSERV-(0099-0103) which are a subset of this test case. + +@SYMTestExpectedResults + +*/ +void CTScreenModePositioning::WindowTestsL() + { + TheClient->iGroup->GroupWin()->EnableScreenChangeEvents(); + TInt numOfModes=TheClient->iScreenModes.Count(); + TInt ii; + for (ii=0; iiiScreenModes[ii]; + TPixelsAndRotation pixelsAndRotation; + iCurrentScreenModeOrigin=TheClient->iScreen->GetScreenModeScaledOrigin(iCurrentMode); + iCurrentScreenModeScale=TheClient->iScreen->GetScreenModeScale(iCurrentMode); + TheClient->iScreen->GetScreenModeSizeAndRotation(iCurrentMode,pixelsAndRotation); + iCurrentScreenModeSize=pixelsAndRotation.iPixelSize; + if (iCurrentScreenModeOrigin.iX<=FullScreenModeSize.iWidth/2-10 /*&& iCurrentScreenModeOrigin!=TPoint() */&& pixelsAndRotation.iRotation==CFbsBitGc::EGraphicsOrientationNormal) + { + #if defined(LOGGING) + _LIT(KLog,"Test mode %d"); + LOG_MESSAGE2(KLog,ii); + #endif + TRAPD(ret,DoWindowTestsL()); + if (ret==KErrNone) + continue; + RestoreScreenMode(); + if (retSetVisible(ETrue); + Copy2ndHalfOfScreen=(iCurrentScreenModeOrigin.iX>FullScreenModeSize.iWidth/2? 1 : 0); + TInt testWinWidth=Max(FullScreenModeSize.iWidth/2-iCurrentScreenModeOrigin.iX,iCurrentScreenModeOrigin.iX-FullScreenModeSize.iWidth/2); + iTestWinSize=TSize(testWinWidth,FullScreenModeSize.iHeight-iCurrentScreenModeOrigin.iY-60); + iTestWinSize.iWidth/=(iCurrentScreenModeScale.iWidth > 1 ? iCurrentScreenModeScale.iWidth*2 : iCurrentScreenModeScale.iWidth); + iTestWinSize.iHeight/=(iCurrentScreenModeScale.iHeight > 1 ? iCurrentScreenModeScale.iHeight*2 : iCurrentScreenModeScale.iHeight); +#if defined(LOGGING) + _LIT(KLog1," PosTest1"); + LOG_MESSAGE(KLog1); +#endif + PositionTest1L(TPoint()); +#if defined(LOGGING) + _LIT(KLog2," PosTest2"); + LOG_MESSAGE(KLog2); +#endif + PositionTest1L(TPoint(25,35)); +#if defined(LOGGING) + _LIT(KLog3," PosTest3"); + LOG_MESSAGE(KLog3); +#endif + PositionTest2L(TPoint(10,10)); +#if defined(LOGGING) + _LIT(KLog4," GetInvalidRegion"); + LOG_MESSAGE(KLog4); +#endif + GetInvalidRegionTestL(TPoint(10,10)); +#if defined(LOGGING) + _LIT(KLog5," CreateWin1"); + LOG_MESSAGE(KLog5); +#endif + CreateWindowsTestL(TPoint()); +#if defined(LOGGING) + _LIT(KLog6," CreateWin2"); + LOG_MESSAGE(KLog6); +#endif + CreateWindowsTestL(TPoint(33,15)); +#if defined(LOGGING) + _LIT(KLog7," NextMode"); + LOG_MESSAGE(KLog7); +#endif + NextScreenModeTestL(TPoint(12,6)); + } + +/** +@SYMTestCaseID GRAPHICS-WSERV-0099 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc Position Test 1 + REQUIREMENT: CR PHAR-5SJGAM, PREQ673 + API: RWindowBase::InquireOffset(), RWindowBase::AbsPosition(),RWindowBase::Position() + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Sets the new screen mode on the main client's screen device. Checks that an window whose group window + has this screen device is in the correct position and for the origin of the new screen mode. + (Does this by copying the window to a bitmap, switching back to screen mode 0 and then setting the position + of the window to be the expected position. Then the bitmap is blitted to the other half of the screen and the + 2 halves of the screen compared) + +@SYMTestExpectedResults Checks the window is positioned correctly for the origin of the new screen mode. + +*/ +void CTScreenModePositioning::PositionTest1L(TPoint aPos) + { + ((CTScreenModePositioningStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0099")); + SetScreenMode(TheClient,iCurrentMode,ESizeEnforcementPixelsAndRotation); + iTestWin->SetExt(aPos,iTestWinSize); + iTestWin->SetVisible(ETrue); + iTestWin->Invalidate(); + TheClient->Flush(); + TestTopClientWindowPositionAPIs(aPos,iTestWin->BaseWin()); + TheClient->WaitForRedrawsToFinish(); + CopyAndCompareL(aPos); + ((CTScreenModePositioningStep*)iStep)->RecordTestResultL(); + } + +template +class TCleanupSetVisible:public TCleanupItem + { + static void Cleanup(void*v) + { + ((CTWinBase*)v)[0].SetVisible(newstate); + } + public: + TCleanupSetVisible(CTWinBase* v): + TCleanupItem(Cleanup,v) + {} + }; + + +/** +@SYMTestCaseID GRAPHICS-WSERV-0100 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc Position Test 2 + REQUIREMENT: CR PHAR-5SJGAM, PREQ673 + API: RWindowBase::SetPosition(),RWindowBase::InquireOffset(), RWindowBase::AbsPosition(),RWindowBase::Position() + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions As in test case GRAPHICS-WSERV-0099 but also tests moving and resizing the window and also does these tests on a backed up child window. + +@SYMTestExpectedResults Checks both the windows are positioned correctly for the origin of the new screen mode. + +*/ +void CTScreenModePositioning::PositionTest2L(TPoint aPos) + { + ((CTScreenModePositioningStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0100")); + SetScreenMode(TheClient,iCurrentMode,ESizeEnforcementPixelsAndRotation); + iTestWin->SetPos(aPos); + + CleanupStack::PushL(TCleanupSetVisible(iBackedUpWin)); + iTestWin->SetVisible(ETrue); + TestTopClientWindowPositionAPIs(aPos,iTestWin->BaseWin()); + TPoint backedUpWinPt=TPoint(iTestWinSize.iWidth/3,iTestWinSize.iHeight/4); + iBackedUpWin->SetExtL(backedUpWinPt,TSize(iTestWinSize.iWidth/6,iTestWinSize.iHeight/6)); + iBackedUpWin->SetVisible(ETrue); + TestChildWindowPositionAPIs(backedUpWinPt,aPos,iBackedUpWin->BaseWin(),iTestWin->BaseWin()); + aPos+=TPoint(20,20); + iTestWin->SetPos(aPos); + TestTopClientWindowPositionAPIs(aPos,iTestWin->BaseWin()); + TestChildWindowPositionAPIs(backedUpWinPt,aPos,iBackedUpWin->BaseWin(),iTestWin->BaseWin()); + iTestWin->Invalidate(); + TheClient->Flush(); + TheClient->WaitForRedrawsToFinish(); + TestTopClientWindowPositionAPIs(aPos,iTestWin->BaseWin()); + TestChildWindowPositionAPIs(backedUpWinPt,aPos,iBackedUpWin->BaseWin(),iTestWin->BaseWin()); + CopyAndCompareL(aPos); + CleanupStack::PopAndDestroy(iBackedUpWin); //TCleanupSetVisible + ((CTScreenModePositioningStep*)iStep)->RecordTestResultL(); + } + +/** +@SYMTestCaseID GRAPHICS-WSERV-0101 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc Invalid Region Test + REQUIREMENT: CR PHAR-5SJGAM, PREQ673 + API: RWindow::GetInvalidRegion() + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Sets the new screen mode, then invalidates different parts of the test window. Checks that the above API gets + the correct invalid area from the server. Also tests moving the invalid area. + +@SYMTestExpectedResults Checks the invalid region is correct for the origin of the new screen mode. + +*/ +void CTScreenModePositioning::GetInvalidRegionTestL(TPoint aPos) + { + ((CTScreenModePositioningStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0101")); + SetScreenMode(TheClient,iCurrentMode,ESizeEnforcementPixelsAndRotation); + iTestWin->SetExt(aPos,iTestWinSize); + iTestWin->SetVisible(ETrue); + iTestChildWin->SetExt(TPoint(iTestWinSize.iWidth>>2,iTestWinSize.iHeight>>2),TSize(iTestWinSize.iWidth>>1,iTestWinSize.iHeight>>1)); + iTestChildWin->SetVisible(ETrue); + iTestWin->Win()->BeginRedraw(); + iTestWin->Win()->EndRedraw(); + const TInt KNumRects=3; + TRect rects[KNumRects]; + rects[0]=TRect(1,1,5,2); + rects[1]=TRect(TPoint(iTest->StdTestWindowSize().iWidth>>1,iTest->StdTestWindowSize().iHeight>>1),iTest->StdTestWindowSize()); + rects[2]=TRect(2,0,4,5); + RRegion region; + CleanupClosePushL(region); + for (TInt index=0;indexInvalidate(rects[index]); + region.AddRect(rects[index]); + } + //PeterI original wserv assumes a region hidden beneath a child is not invalid + //Mk3 doesn't make this assumption + //TRect subRect; + //subRect.iTl=iTestChildWin->BaseWin()->InquireOffset(*iTestWin->BaseWin()); + //subRect.SetSize(iTestChildWin->Size()); + //region.Tidy(); + //region.SubRect(subRect); + //region.ClipRect(TRect(iTestWin->Size())); + RRegion invalidRegion; + CleanupClosePushL(invalidRegion); + iTestWin->Win()->GetInvalidRegion(invalidRegion); + CompareRegionsL(region,invalidRegion); + CleanupStack::PopAndDestroy(2,®ion); + TheClient->Flush(); + TheClient->WaitForRedrawsToFinish(); + iTestChildWin->SetVisible(EFalse); + TRect rect1(TPoint(0,0),iTestWinSize); + TestGetInvalidRegionL(rect1); + TInt width=iTestWinSize.iWidth; + TInt height=iTestWinSize.iHeight; + TRect rect2(TPoint(width/6,height/6),TSize(width/3,height/3)); + TestGetInvalidRegionL(rect2); + iTestWin->Invalidate(); + iTestWin->SetPos(TPoint(15,15)); + iTestWin->SetPos(TPoint()); + iTestWin->SetPos(TPoint(-15,-15)); + iTestWin->SetPos(aPos); + RRegion invalid; + RRegion testRegion(rect1); + CleanupClosePushL(invalid); + CleanupClosePushL(testRegion); + iTestWin->Win()->GetInvalidRegion(invalid); + TBool err=invalid.CheckError(); + TEST(!err); + if (err) + { + _LIT(KLog,"Returned Invalid Region has an error"); + LOG_MESSAGE(KLog); + } + + TEST(invalid.BoundingRect().iBr.iX<=iTestWinSize.iWidth); + if (invalid.BoundingRect().iBr.iX>iTestWinSize.iWidth) + { + _LIT(KLog,"Invalid Region extends beyond right edge of window"); + LOG_MESSAGE(KLog); + } + + CompareRegionsL(testRegion,invalid); + CleanupStack::PopAndDestroy(2,&invalid); + iTestWin->DrawNow(); + TheClient->Flush(); + CopyAndCompareL(aPos); + ((CTScreenModePositioningStep*)iStep)->RecordTestResultL(); + } + +void CTScreenModePositioning::CopyAndCompareL(TPoint aPos) + { + CopyScreenAndChangeBackToDefScrModeL(); + iTestWin->SetPos(iCurrentScreenModeOrigin+aPos); + iConnection2->DrawBitmapWin(); + TheClient->WaitForRedrawsToFinish(); + TestRect(); + iConnection2->BitmapWin()->SetVisible(EFalse); + iTestWin->SetVisible(EFalse); + } + +void CTScreenModePositioning::TestGetInvalidRegionL(TRect& aRect) + { + RRegion testRegion; + RRegion invalid; + iTestWin->Invalidate(aRect); + testRegion.AddRect(aRect); + iTestWin->Win()->GetInvalidRegion(invalid); + CompareRegionsL(testRegion,invalid); + invalid.Close(); + testRegion.Close(); + TheClient->Flush(); + TheClient->WaitForRedrawsToFinish(); + } + +void CTScreenModePositioning::CompareRegionsL(const TRegion &aRegion1,const TRegion &aRegion2) + { + _LIT(KLog,"Regions do not contain same area."); + RRegion tmp; + tmp.Copy(aRegion1); + tmp.SubRegion(aRegion2); + if (tmp.CheckError()) + User::Leave(KErrNoMemory); + TBool retVal1=tmp.IsEmpty(); + TEST(retVal1); + if (!retVal1) + LOG_MESSAGE(KLog); + + tmp.Copy(aRegion2); + tmp.SubRegion(aRegion1); + if (tmp.CheckError()) + User::Leave(KErrNoMemory); + TBool retVal2=tmp.IsEmpty(); + TEST(retVal2); + if (!retVal2 && retVal1) + LOG_MESSAGE(KLog); + + tmp.Close(); + } + +void CTScreenModePositioning::TestTopClientWindowPositionAPIs(TPoint aPos,RWindowBase* aWin) + { + TEST(aWin->AbsPosition()==aPos); + TEST(aWin->Position()==aPos); + TEST(aWin->InquireOffset(*TheClient->iGroup->GroupWin())==aPos); + } + +void CTScreenModePositioning::TestChildWindowPositionAPIs(TPoint aPos,TPoint aParentPos,RWindowBase* aWin,RWindowBase* aParentWin) + { + TEST(aWin->AbsPosition()==aParentPos+aPos); + TEST(aWin->Position()==aPos); + TEST(aWin->InquireOffset(*TheClient->iGroup->GroupWin())==aParentPos+aPos); + TEST(aWin->InquireOffset(*aParentWin)==aPos); + } + +void CTScreenModePositioning::RestoreScreenMode() + { + TPixelsAndRotation pixelsAndRotation; + pixelsAndRotation.iPixelSize=FullScreenModeSize; + TheClient->iScreen->GetDefaultScreenSizeAndRotation(pixelsAndRotation); + ChangeScreenMode(TheClient,pixelsAndRotation,ESizeEnforcementNone,TheClient->iScreenModes[0]); + } + +/** +@SYMTestCaseID GRAPHICS-WSERV-0102 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc Create Windows Test + REQUIREMENT: CR PHAR-5SJGAM, PREQ673 + API: RWindowBase::SetPosition(),RWindowBase::InquireOffset(), RWindowBase::AbsPosition(),RWindowBase::Position() + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions As in test case GRAPHICS-WSERV-0100 but tests windows that are created in the new screen mode. Also tests moving and resizing these windows + +@SYMTestExpectedResults Checks both the windows are positioned correctly for the origin of the new screen mode. + +*/ +void CTScreenModePositioning::CreateWindowsTestL(TPoint aPos) + { + ((CTScreenModePositioningStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0102")); + SetScreenMode(TheClient,iCurrentMode,ESizeEnforcementPixelsAndRotation); + CBasicWin* basicWin=new(ELeave) CBasicWin; + basicWin->ConstructExtLD(*TheClient->iGroup,aPos,iTestWinSize); + CleanupStack::PushL(basicWin); + TInt mode=basicWin->BaseWin()->SetRequiredDisplayMode(EColor256); + basicWin->AssignGC(*TheClient->iGc); + basicWin->BaseWin()->SetShadowDisabled(ETrue); + basicWin->BaseWin()->SetShadowHeight(0); + basicWin->Activate(); + TheClient->Flush(); + TheClient->WaitForRedrawsToFinish(); + TestTopClientWindowPositionAPIs(aPos,basicWin->BaseWin()); + CTBlankWindow* blankChildWin=new(ELeave) CTBlankWindow ; + CleanupStack::PushL(blankChildWin); + blankChildWin->ConstructL(*basicWin); + blankChildWin->BaseWin()->SetRequiredDisplayMode(EColor256); + blankChildWin->BaseWin()->SetShadowDisabled(ETrue); + blankChildWin->SetColor(KRgbYellow); + TPoint childPos(iTestWinSize.iWidth/4,iTestWinSize.iHeight/4); + blankChildWin->SetExtL(childPos,TSize(iTestWinSize.iWidth/2,iTestWinSize.iHeight/2)); + blankChildWin->Activate(); + TheClient->Flush(); + TheClient->WaitForRedrawsToFinish(); + TestChildWindowPositionAPIs(childPos,aPos,blankChildWin->BaseWin(),basicWin->BaseWin()); + blankChildWin->SetPos(TPoint(-15,-20)); + TheClient->Flush(); + basicWin->DrawNow(); + TestChildWindowPositionAPIs(TPoint(-15,-20),aPos,blankChildWin->BaseWin(),basicWin->BaseWin()); + CopyScreenAndChangeBackToDefScrModeL(); + basicWin->SetPos(iCurrentScreenModeOrigin+aPos); + iConnection2->DrawBitmapWin(); + TheClient->WaitForRedrawsToFinish(); + TestRect(); + iConnection2->BitmapWin()->SetVisible(EFalse); + iTestWin->SetVisible(EFalse); + CleanupStack::PopAndDestroy(blankChildWin); + CleanupStack::PopAndDestroy(basicWin); + ((CTScreenModePositioningStep*)iStep)->RecordTestResultL(); + } + +/** +@SYMTestCaseID GRAPHICS-WSERV-0103 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc Changing to next screen mode + REQUIREMENT: CR PHAR-5SJGAM, PREQ673 + API: RWindowBase::SetPosition(),RWindowBase::InquireOffset(), RWindowBase::AbsPosition(),RWindowBase::Position() + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Sets the new screen mode, creates a new child window and then changes to the next screen mode with non-zero origin, + checks windows are in the expected position for the origin of the new screen mode. + +@SYMTestExpectedResults Checks both the windows are positioned correctly for the origin of the new screen mode. + +*/ +void CTScreenModePositioning::NextScreenModeTestL(TPoint aPos) + { + ((CTScreenModePositioningStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0103")); + if (iCurrentScreenModeOrigin==TPoint()) + { + return; + } + TInt numOfModes=TheClient->iScreenModes.Count(); + TInt defaultMode=TheClient->iScreenModes[0]; + TInt lastMode=TheClient->iScreenModes[numOfModes-1]; + TInt mode=(iCurrentModeiScreenModes[ii]) + { + modeIdx=ii; + break; + } + } + TPoint screenModeOrigin(0,0); + TPixelsAndRotation pixelsAndRotation; + while (screenModeOrigin==TPoint()||(pixelsAndRotation.iRotation!=CFbsBitGc::EGraphicsOrientationNormal)) + { + mode=(mode==lastMode? defaultMode : TheClient->iScreenModes[++modeIdx]); + if (mode==iCurrentMode) + { + return; + } + else if (mode==lastMode) + { + modeIdx=0; + } + screenModeOrigin=TheClient->iScreen->GetScreenModeOrigin(mode); + TheClient->iScreen->GetScreenModeSizeAndRotation(mode,pixelsAndRotation); + } + SetScreenMode(TheClient,iCurrentMode,ESizeEnforcementPixelsAndRotation); + iTestWin->SetExt(aPos,iTestWinSize); + iTestWin->SetVisible(ETrue); + TheClient->Flush(); + CBasicWin* basicWin=new(ELeave) CBasicWin; + CleanupStack::PushL(basicWin); + basicWin->ConstructExtLD(*iTestWin,TPoint(),TSize(iTestWinSize.iWidth/5,iTestWinSize.iHeight/5)); + User::LeaveIfError(basicWin->BaseWin()->SetRequiredDisplayMode(EColor256)); + basicWin->AssignGC(*TheClient->iGc); + basicWin->BaseWin()->SetShadowDisabled(ETrue); + basicWin->BaseWin()->SetShadowHeight(0); + basicWin->Activate(); + TPoint pos(iTestWinSize.iWidth/3,iTestWinSize.iWidth/4); + basicWin->SetPos(pos); + TheClient->Flush(); + TheClient->WaitForRedrawsToFinish(); + TestChildWindowPositionAPIs(pos,aPos,basicWin->BaseWin(),iTestWin->BaseWin()); + iCurrentScreenModeScale=TheClient->iScreen->GetScreenModeScale(mode); + iCurrentScreenModeOrigin=TheClient->iScreen->GetScreenModeOrigin(mode); + iTestWinSize.iWidth/=(iCurrentScreenModeScale.iWidth > 1 ? iCurrentScreenModeScale.iWidth*2 : iCurrentScreenModeScale.iWidth); + iTestWinSize.iHeight/=(iCurrentScreenModeScale.iHeight > 1 ? iCurrentScreenModeScale.iHeight*2 : iCurrentScreenModeScale.iHeight); + iTestWin->SetExt(aPos,iTestWinSize); + SetScreenMode(TheClient,mode,ESizeEnforcementPixelsAndRotation); + CopyScreenAndChangeBackToDefScrModeL(); + iTestWin->SetPos(aPos+iCurrentScreenModeOrigin); + basicWin->SetPos(pos); + iConnection2->DrawBitmapWin(); + TestRect(); + iConnection2->BitmapWin()->SetVisible(EFalse); + iTestWin->SetVisible(EFalse); + CleanupStack::PopAndDestroy(basicWin); + iCurrentScreenModeOrigin=TheClient->iScreen->GetScreenModeOrigin(iCurrentMode); + ((CTScreenModePositioningStep*)iStep)->RecordTestResultL(); + } + +void CTScreenModePositioning::CopyScreenAndChangeBackToDefScrModeL() + { + // clear the content of bitmap before it is used for copying + ClearBitmap(iConnection2->iScreenBitmap); + + // Copy the current content of the screen before moving to screen sizemode 0. + if (!iScalingSupported) + { + TPoint pt=(Copy2ndHalfOfScreen? TPoint(FullScreenModeSize.iWidth/2,0) : TPoint()); + User::LeaveIfError(iConnection2->iClient->iScreen->CopyScreenToBitmap(iConnection2->iScreenBitmap,TRect(pt,TSize(FullScreenModeSize.iWidth/2,FullScreenModeSize.iHeight)))); + } + else + { + TPoint pt=(Copy2ndHalfOfScreen? TPoint((iCurrentScreenModeSize.iWidth+iCurrentScreenModeOrigin.iX)/2,0) : -iCurrentScreenModeOrigin); + TPoint ptBottom(FullScreenModeSize.iWidth/2,FullScreenModeSize.iHeight); + ptBottom-=iCurrentScreenModeOrigin; + ptBottom.iX=(ptBottom.iX>=0 ? ptBottom.iX/iCurrentScreenModeScale.iWidth : ((-ptBottom.iX)*iCurrentScreenModeScale.iWidth+ptBottom.iX)/iCurrentScreenModeScale.iWidth+ptBottom.iX); + ptBottom.iY=(ptBottom.iY>=0 ? ptBottom.iY/iCurrentScreenModeScale.iHeight : ((-ptBottom.iY)*iCurrentScreenModeScale.iHeight+ptBottom.iY)/iCurrentScreenModeScale.iHeight+ptBottom.iY); + User::LeaveIfError(iConnection2->iClient->iScreen->CopyScreenToBitmap(iConnection2->iScreenBitmap,TRect(pt,ptBottom))); + } + TheClient->Flush(); + SetScreenMode(TheClient,TheClient->iScreenModes[0],ESizeEnforcementPixelsAndRotation); + TPixelsAndRotation dummySize; + dummySize.iPixelSize=TSize(0,0); + iConnection2->iClient->iScreen->SetScreenSizeAndRotation(dummySize); //to force an update in the server when we do the next line + TPixelsAndRotation pixelsAndRotation; + TheClient->iScreen->GetDefaultScreenSizeAndRotation(pixelsAndRotation); + iConnection2->iClient->iScreen->SetScreenSizeAndRotation(pixelsAndRotation); + iConnection2->iClient->iScreen->SetScreenModeEnforcement(ESizeEnforcementPixelsAndRotation); + iConnection2->iClient->iScreen->SetScreenMode(TheClient->iScreenModes[0]); + } + +TBool CTScreenModePositioning::TestRect() + { + TSize size(FullScreenModeSize.iWidth/2,FullScreenModeSize.iHeight); + TRect right(TPoint(FullScreenModeSize.iWidth/2,0),size); + TBool retVal=TheClient->iScreen->RectCompare(TRect(size),right); +// User::After(2000000); + //Let the pixels cool down for a bit + User::After(10); + TEST(retVal); + if(!retVal) + { + _LIT(KLog,"Left and Right halves of display don't match. RightHalf=(%d,%d,%d,%d)"); + LOG_MESSAGE5(KLog,right.iTl.iX,right.iTl.iY,right.iBr.iX,right.iBr.iY); + } + return retVal; + } + +/** +@SYMTestCaseID GRAPHICS-WSERV-0104 + +@SYMDEF DEF081259, DEF111847 + +@SYMTestCaseDesc Sprite Tests + REQUIREMENT: CR PHAR-5SJGAM, PREQ673 + API: RWsSprite::SetPosition() + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Test sprites associated with group windows in screen modes with non-zero origin: + Sets such a new screen mode and creates 2 sprites. + compares these sprites with some blitted onto the screen in the expected position. + Sets the rotation of screen mode to be 180 deg, sets the position of the sprites + and does the same as above to compare expected position. + Then changes back to screen mode 0 and sets a new positions of the sprites,changes to the new + screen mode and checks the sprites have been moved to the correct position. + Additionally, as part of defect fix DEF111847, this also loops through all display modes above and including Color256, + and if possible tests each with the above described method. Previously, it use to only test Color256. + Display modes lower than EColor256 are not tested as they are not supported for origin change. + +@SYMTestExpectedResults Checks the sprites are positioned correctly according to the origin + of the new screen mode. + +*/ +void CTScreenModePositioning::SpriteTestL() + { + +#if defined(__WINS__) + TBool retVal; + if (iScalingSupported) + { + TDisplayMode curDispMode; // Holds the current display mode being tested + + for(curDispMode = EColor256; curDispMode < EColorLast; curDispMode = TDisplayMode(curDispMode+1)) + { + if (curDispMode == ERgb) + { + continue; + } + // Set screen mode to 3 + iCurrentMode=3; + SetScreenMode(TheClient,iCurrentMode,ESizeEnforcementPixelsAndRotation); + TPoint topLeft(-TheClient->iScreen->GetScreenModeOrigin(iCurrentMode)); + TPoint botRight(TheClient->iScreen->SizeInPixels().AsPoint()); + + // Create a sprite at position (0,0) from current origin + RWsSprite sprite; + TSize spriteSize=iSpriteBitmap.SizeInPixels(); + SetUpSpriteLC(sprite,TheClient->iWs,*iBlankWin->BaseWin()); + TPoint winPos; + if (botRight.iXBaseWin()->SetPosition(winPos); + } + + // Now create a spritewin at top left of the visible screen + CSpriteWin* spriteWin=new(ELeave) CSpriteWin(iSpriteBitmap); + CleanupStack::PushL(spriteWin); + spriteWin->ConstructExtLD(*TheClient->iGroup,topLeft,spriteSize); + + // Set the display mode of the base window + TInt setBlankWinDispMode = iBlankWin->BaseWin()->SetRequiredDisplayMode(curDispMode); + // Set the display mode of the sprite window + TInt setSpriteWinDispMode = spriteWin->BaseWin()->SetRequiredDisplayMode(curDispMode); + + //Only do the tests if the requested mode was actually set on both windows + if(curDispMode == setBlankWinDispMode && curDispMode == setSpriteWinDispMode) + { + //Create and show DisplayMode details message + _LIT(KModeDetails, "Display Mode: "); + TBuf<30> modeDetailsMessage(KModeDetails); + modeDetailsMessage.Append(DisplayModeAsString(curDispMode)); + LOG_MESSAGE(modeDetailsMessage); + + spriteWin->AssignGC(*TheClient->iGc); + spriteWin->SetState(3); + spriteWin->Activate(); + spriteWin->DrawNow(); + TheClient->WaitForRedrawsToFinish(); + retVal=TheClient->iScreen->RectCompare(TRect(topLeft,spriteSize),TRect(winPos,spriteSize),CWsScreenDevice::EIncludeSprite); + TEST(retVal); + if(!retVal) + { + _LIT(KLog,"Initial Drawing of sprite fails - does not compare to same bitmap drawn in window."); + LOG_MESSAGE(KLog); + } + + // Move position of the window and sprite and then test + TPoint spritePos(Min(20,botRight.iX-spriteSize.iWidth-winPos.iX),20); + spriteWin->SetExt(topLeft+spritePos,spriteSize); + sprite.SetPosition(spritePos); + spriteWin->DrawNow(); + TheClient->WaitForRedrawsToFinish(); + retVal=TheClient->iScreen->RectCompare(TRect(topLeft+spritePos,spriteSize),TRect(winPos+spritePos,spriteSize),CWsScreenDevice::EIncludeSprite); + TEST(retVal); + if(!retVal) + { + _LIT(KLog,"Second position of sprite fails - does not compare to same bitmap drawn in window."); + LOG_MESSAGE(KLog); + } + iBlankWin->BaseWin()->SetPosition(TPoint()); + + // Now test the same by moving into other screen mode + iCurrentMode=4; + SetScreenMode(TheClient,iCurrentMode,ESizeEnforcementNone); + spritePos.SetXY(0,160); + sprite.SetPosition(spritePos); + spriteWin->SetExt(TPoint(),spriteSize); + spriteWin->DrawNow(); + TheClient->WaitForRedrawsToFinish(); + retVal=TheClient->iScreen->RectCompare(TRect(TPoint(),spriteSize),TRect(spritePos,spriteSize),CWsScreenDevice::EIncludeSprite); + TEST(retVal); + if(!retVal) + { + _LIT(KLog,"Third position of sprite fails - does not compare to same bitmap drawn in window."); + LOG_MESSAGE(KLog); + } + } + + CleanupStack::PopAndDestroy(spriteWin); + CleanupStack::PopAndDestroy(&sprite); + RestoreScreenMode(); + } + } + else + { + const TInt KScreenModeWithOffset = 2; + TheClient->iGroup->GroupWin()->EnableScreenChangeEvents(); + iTestWin->SetVisible(EFalse); + TheClient->Flush(); + iConnection2->iClient->Flush(); + TheClient->WaitForRedrawsToFinish(); + TPixelsAndRotation pixelsAndRotation1; + TheClient->iScreen->GetScreenModeSizeAndRotation(KScreenModeWithOffset,pixelsAndRotation1); + ChangeScreenMode(TheClient,pixelsAndRotation1,KScreenModeWithOffset); + RWsSprite sprite[2]; + for (TInt ii=0;ii<2;ii++) + { + SetUpSpriteLC(sprite[ii],TheClient->iWs,*TheClient->iGroup->WinTreeNode()); + } + TheClient->Flush(); + TheClient->WaitForRedrawsToFinish(); + TPixelsAndRotation pixelsAndRotation2; + TheClient->iScreen->GetScreenModeSizeAndRotation(0,pixelsAndRotation2); + iConnection2->iSpriteWin->UpdateState(0); + iConnection2->iSpriteWin->SetVisible(ETrue); + iConnection2->iClient->Flush(); + TSize spriteSize=iSpriteBitmap.SizeInPixels(); + TPoint screenMode2Origin; + screenMode2Origin=TheClient->iScreen->GetScreenModeOrigin(KScreenModeWithOffset); + //Check all reference bitmaps can be drawn inside the screen + MDisplayControl* interface = static_cast + (TheClient->iScreen->GetInterface(MDisplayControl::ETypeId)); + if(interface) + { + TDisplayConfiguration config; + interface->GetConfiguration(config); + TSize screenSize; + config.GetResolution(screenSize); + TEST(screenSize.iWidth > screenMode2Origin.iX+CheckSpritePos.iX+spriteSize.iWidth+30 + && screenSize.iHeight > screenMode2Origin.iY+CheckSpritePos.iY + spriteSize.iHeight+30); + } + + retVal = iConnection2->iClient->iScreen->RectCompare(TRect(screenMode2Origin+CheckSpritePos,spriteSize),TRect(screenMode2Origin,spriteSize),CWsScreenDevice::EIncludeSprite); + TEST(retVal); + if(!retVal) + INFO_PRINTF3(_L("iConnection2->iClient->iScreen->RectCompare() return value - Expected: %d, Actual: %d"), ETrue, retVal); + + TheClient->iScreen->SetCurrentRotations(KScreenModeWithOffset,CFbsBitGc::EGraphicsOrientationRotated180); + ChangeScreenMode(TheClient,pixelsAndRotation1,KScreenModeWithOffset); + TheClient->Flush(); + sprite[0].SetPosition(TPoint(0,0)); + sprite[1].SetPosition(TPoint(30,30)); + TheClient->Flush(); + TheClient->WaitForRedrawsToFinish(); + iConnection2->iSpriteWin->UpdateState(1); + iConnection2->iClient->Flush(); + retVal = iConnection2->iClient->iScreen->RectCompare(TRect(screenMode2Origin+CheckSpritePos,spriteSize+TPoint(30,30)),TRect(screenMode2Origin,spriteSize+TPoint(30,30)),CWsScreenDevice::EIncludeSprite); + TEST(retVal); + if(!retVal) + INFO_PRINTF3(_L("iConnection2->iClient->iScreen->RectCompare() return value - Expected: %d, Actual: %d"), ETrue, retVal); + + TheClient->iScreen->SetCurrentRotations(KScreenModeWithOffset,CFbsBitGc::EGraphicsOrientationNormal); + ChangeScreenMode(TheClient,pixelsAndRotation2,0); + iConnection2->iSpriteWin->SetExt(TPoint(215,0),TSize(218,240)); + TheClient->Flush(); + TheClient->WaitForRedrawsToFinish(); + sprite[0].SetPosition(TPoint(-10,20)); + sprite[1].SetPosition(TPoint(-10,40)); + TheClient->Flush(); + TheClient->WaitForRedrawsToFinish(); + ChangeScreenMode(TheClient,pixelsAndRotation1,ESizeEnforcementPixelsAndRotation,KScreenModeWithOffset); + TheClient->Flush(); + TheClient->WaitForRedrawsToFinish(); + iConnection2->iSpriteWin->UpdateState(2); + iConnection2->iClient->Flush(); + retVal = iConnection2->iClient->iScreen->RectCompare(TRect(screenMode2Origin+CheckSpritePos+TPoint(0,20),spriteSize+TPoint(-10,20)),TRect(screenMode2Origin+TPoint(0,20),spriteSize+TPoint(-10,20)),CWsScreenDevice::EIncludeSprite); + TEST(retVal); + if(!retVal) + INFO_PRINTF3(_L("iConnection2->iClient->iScreen->RectCompare() return value - Expected: %d, Actual: %d"), ETrue, retVal); + + CleanupStack::PopAndDestroy(2,&sprite[0]); + iConnection2->iSpriteWin->SetVisible(EFalse); + ChangeScreenMode(TheClient,pixelsAndRotation2,ESizeEnforcementPixelsAndRotation,0); + TheClient->Flush(); + TheClient->WaitForRedrawsToFinish(); + } +#endif + } + +/** +@SYMTestCaseID GRAPHICS-WSERV-0105 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc Rotation Tests + REQUIREMENT: CR PHAR-5SJGAM, PREQ673 + API: RWindowBase::InquireOffset(), RWindowBase::AbsPosition(),RWindowBase::Position() + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Goes through all the screen modes defined in the wsini file and all the rotations in + each screen mode. For each case sets the new screen mode and the the rotation on the current + client's screen device. Then sets a suitable size and position of 2 windows (an RWindow + and a child RBackedUpWindow) whose group window has the above screen device. + +@SYMTestExpectedResults Checks the windows are positioned correctly according to the origin and rotation + of the new screen mode. + +*/ +void CTScreenModePositioning::RotationTestsL() + { + RBlankWindow color256(TheClient->iWs); + User::LeaveIfError(color256.Construct(*TheClient->iGroup->GroupWin(),ENullWsHandle)); + CleanupClosePushL(color256); + color256.SetRequiredDisplayMode(EColor256); + color256.SetOrdinalPosition(2); + color256.Activate(); + TInt ii; + for (ii=0;iiiScreenModes.Count();) + { + iCurrentMode=TheClient->iScreenModes[ii]; + SetScreenMode(TheClient,iCurrentMode,ESizeEnforcementPixelsAndRotation); + TPixelsAndRotation pixelsAndRotation; + TheClient->iScreen->GetDefaultScreenSizeAndRotation(pixelsAndRotation); + TInt oldCurrentMode=iCurrentMode; + CArrayFixFlat* rotations=new(ELeave) CArrayFixFlat(1); + CleanupStack::PushL(rotations); + User::LeaveIfError(TheClient->iScreen->GetRotationsList(iCurrentMode,rotations)); + TInt count=rotations->Count(); + TInt jj=0; + if (count>1) + { + for (jj=0;jjiScreen->SetCurrentRotations(oldCurrentMode,REINTERPRET_CAST(CFbsBitGc::TGraphicsOrientation&,currentRotation)); + CleanupStack::PopAndDestroy(rotations); + iCurrentScreenModeOrigin=TheClient->iScreen->GetScreenModeOrigin(oldCurrentMode); + iCurrentScreenModeOrigin=TheClient->iScreen->GetScreenModeScaledOrigin(oldCurrentMode); + TPoint point1(iCurrentScreenModeOrigin.iX,iCurrentScreenModeOrigin.iY+(iCurrentScreenModeOrigin.iY+pixelsAndRotation.iPixelSize.iHeight)/2); + TPoint point2(iCurrentScreenModeOrigin.iX+(iCurrentScreenModeOrigin.iX+pixelsAndRotation.iPixelSize.iWidth)/2,pixelsAndRotation.iPixelSize.iHeight+iCurrentScreenModeOrigin.iY); + TRect rect0(point1,point2); + iTestWin->SetExtL(TPoint(),rect0.Size()); + iTestWin->Invalidate(); + + iTestWin->SetVisible(ETrue); + TheClient->Flush(); + TheClient->WaitForRedrawsToFinish(); + TestTopClientWindowPositionAPIs(TPoint(),iTestWin->BaseWin()); + TPoint backedUpWinPt=TPoint(rect0.Width()/3,rect0.Height()/4); + iBackedUpWin->SetVisible(ETrue); + + CleanupStack::PushL(TCleanupSetVisible(iBackedUpWin)); + CleanupStack::PushL(TCleanupSetVisible(iTestWin)); + + + iBackedUpWin->SetExtL(backedUpWinPt,TSize(rect0.Width()/6,rect0.Height()/6)); + TestChildWindowPositionAPIs(backedUpWinPt,TPoint(),iBackedUpWin->BaseWin(),iTestWin->BaseWin()); + + CleanupStack::PopAndDestroy(2,iBackedUpWin); //TCleanupSetVisible + } + CleanupStack::PopAndDestroy(&color256); + } + +TBool CTScreenModePositioning::ScalingSupportedByDisplayMode() + { + //PeterI Standard ScreenDriver only supports scaling in EColor256 and EColor64k + //see CDrawBitmap::CanBeScaled(), as mk3 is always in 16mu the tests will not pass. + TBool ret=EFalse; + TDisplayMode mode=TheClient->iScreen->DisplayMode(); + if (mode==EColor64K || mode==EColor256) + { + ret=ETrue; + } + return ret; + } +void CTScreenModePositioning::RunTestCaseL(TInt /*aCurTestCase*/) + { + _LIT(KWindowTests,"Window Tests"); + _LIT(KSpriteTest,"Sprite Test"); + _LIT(KRotationTests,"Rotation Tests"); + ((CTScreenModePositioningStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName); + switch(iTest->iState) + { + case 0: + ((CTScreenModePositioningStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName); + if (!CheckNonZeroOriginsSupportedOrNot()) + { + _LIT(KLog,"Non Zero Origins not supported"); + LOG_MESSAGE(KLog); + TestComplete(); + return; + } + break; + case 1: + iTest->LogSubTest(KWindowTests); + if(ScalingSupportedByDisplayMode()) + WindowTestsL(); + ((CTScreenModePositioningStep*)iStep)->SetOverallTestStepID(_L("GRAPHICS-WSERV-0098")); + break; + case 2: + ((CTScreenModePositioningStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0104")); + iTest->LogSubTest(KSpriteTest); + if(ScalingSupportedByDisplayMode()) + SpriteTestL(); + break; + case 3: + ((CTScreenModePositioningStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0105")); + iTest->LogSubTest(KRotationTests); + RotationTestsL(); + break; + default: + ((CTScreenModePositioningStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName); + ((CTScreenModePositioningStep*)iStep)->CloseTMSGraphicsStep(); + RestoreScreenMode(); + TestComplete(); + return; + } + ((CTScreenModePositioningStep*)iStep)->RecordTestResultL(); + ++iTest->iState; // still used in the remaining code + } + +__WS_CONSTRUCT_STEP__(ScreenModePositioning)