// 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 screen mode switching
//
//
/**
@file
@test
@internalComponent - Internal Symbian test code
*/
#include "TSCRMODE.H"
const TInt KBlankWinPosX=10;
const TInt KBlankWinPosY=20;
const TInt KBlankWinSizeX=30;
const TInt KBlankWinSizeY=25;
const TInt KScreenMode0=0;
const TInt KScreenMode1=1;
_LIT(KScreenModeDisplayMode,"GetScreenModeDisplayMode");
CTScrMode::CTScrMode(CTestStep* aStep) : CTWsGraphicsBase(aStep)
{
}
//
// Static func to check windows
//
LOCAL_C TInt DoPanicTest(TInt aInt, TAny *aScreenNumber)
{
RWsSession ws;
CWsScreenDevice *screen=NULL;
if (ws.Connect()==KErrNone)
{
screen = new (ELeave) CWsScreenDevice(ws);
if (screen && screen->Construct((TInt)aScreenNumber)==KErrNone)
{
TPixelsTwipsAndRotation sar;
CFbsBitGc::TGraphicsOrientation rot=CFbsBitGc::EGraphicsOrientationNormal;
TInt mode=0;
switch(aInt)
{
case 0:
case 1:
screen->SetScreenMode(aInt==0?1000:-1);
break;
case 2:
case 3:
screen->GetScreenModeSizeAndRotation(aInt==2?screen->NumScreenModes():-100000, sar);
break;
case 4:
case 5:
screen->GetScreenModeSizeAndRotation(aInt==4?screen->NumScreenModes()+100:-10, sar);
break;
case 6:
mode=screen->NumScreenModes();
goto SetRot;
case 7:
mode=-55;
goto SetRot;
case 8:
mode=234;
goto SetRot;
case 9:
mode=screen->NumScreenModes()+2;
rot=CFbsBitGc::EGraphicsOrientationRotated270;
SetRot:
screen->SetCurrentRotations(mode,rot);
break;
case 10:
case 11:
ws.SetPointerCursorArea(aInt==10?1000:-1,TRect());
break;
case 12:
case 13:
ws.PointerCursorArea(aInt==12?1003:-2);
break;
case 14:
case 15:
{
CArrayFixFlat<TInt> *rotations=new(ELeave) CArrayFixFlat<TInt>(1);
screen->GetRotationsList(aInt==12?1003:-2,rotations);
}
break;
case 100:
rot=CFbsBitGc::EGraphicsOrientationRotated90;
goto SetRot;
case 101:
rot=CFbsBitGc::EGraphicsOrientationRotated270;
goto SetRot;
case 102:
mode=1;
rot=CFbsBitGc::EGraphicsOrientationRotated270;
goto SetRot;
case 103:
mode=1;
#if defined(__EPOC32__)
rot=CFbsBitGc::EGraphicsOrientationRotated180;
#else
rot=CFbsBitGc::EGraphicsOrientationNormal;
#endif
goto SetRot;
}
ws.Flush();
}
}
return(EWsExitReasonBad);
}
void SetupTestRWindowLC(RWindow& aWindow, const TPoint& aPos, const TSize& aSize, TDisplayMode aDisplayMode)
{
CleanupClosePushL(aWindow);
User::LeaveIfError(aWindow.Construct(*TheClient->iGroup->GroupWin(), (TUint)&aWindow));
aWindow.SetExtent(aPos, aSize);
User::LeaveIfError(aWindow.SetRequiredDisplayMode(aDisplayMode));
aWindow.Activate();
}
void CTScrMode::TestPanicsL()
{
TInt ii;
for (ii=0;ii<16;++ii)
TEST(iTest->TestWsPanicL(DoPanicTest,EWservPanicScreenModeNumber,ii,(TAny*)iTest->iScreenNumber));
for (ii=100;ii<104;++ii)
TEST(iTest->TestWsPanicL(DoPanicTest,EWservPanicRotation,ii,(TAny*)iTest->iScreenNumber));
iTest->CloseAllPanicWindows();
}
CTScrMode::~CTScrMode()
{
((CTScrModeStep*)iStep)->CloseTMSGraphicsStep();
delete iSecondConnection;
TheClient->iGroup->GroupWin()->DisableScreenChangeEvents();
SetScreenModeEnforcement(iOldEnfMode);
}
void CTScrMode::ConstructL()
{
//Remove next line when bitmaps are stored correctly
TestWin->Win()->EnableRedrawStore(EFalse);
BaseWin->Win()->EnableRedrawStore(EFalse);
//
TheClient->iGroup->GroupWin()->EnableScreenChangeEvents();
//
//TheClient->iWs.SetAutoFlush(ETrue);
ValidateWin(BaseWin,TRgb::Gray256(204));
ValidateWin(TestWin,TRgb::Gray256(204));
//
iWinState=0;
iWinPos=TPoint(2*TheClient->iGroup->Size().iWidth/3,0);
//
iSecondConnection=new(ELeave) CSecondConnection;
iSecondConnection->ConstructL(iTest->iScreenNumber, TRect(KBlankWinPosX,KBlankWinPosY,KBlankWinPosX+KBlankWinSizeX,KBlankWinPosY+KBlankWinSizeY),iTest,iStep);
//
iOldEnfMode=TheClient->iScreen->ScreenModeEnforcement();
if (TheClient->iScreenModes.Count()<2)
{
iTest->iState=1000; // Miss all tests
_LIT(KLog,"Skipping all tests as less that 2 screen size modes");
LOG_MESSAGE(KLog);
}
else
{
SetScreenModeEnforcement(ESizeEnforcementNone);
TheClient->iScreen->SetScreenMode(TheClient->iScreenModes[0]);
}
}
void CTScrMode::SetScreenModeEnforcement(TScreenModeEnforcement aMode)
{
iCurEnforcement=aMode;
TheClient->iScreen->SetScreenModeEnforcement(iCurEnforcement);
}
void CTScrMode::ScaledDrawingL()
{
const TInt KLineXPos=10;
const TInt KLineYPos=30;
const TInt KLineLength=10;
const TInt KXScaleFactor=4;
const TInt KYScaleFactor=3;
//
// Draw rectangle onto TestWin
CWindowGc *gc=TheClient->iGc;
gc->Activate(*(TestWin->Win()));
gc->SetBrushColor(KRgbBlack);
gc->SetBrushStyle(CGraphicsContext::ESolidBrush);
gc->DrawRect(TRect(TPoint(KLineXPos,KLineYPos),TSize(KLineLength*KXScaleFactor,KYScaleFactor)));
gc->Deactivate();
//
// Draw scaled bitmap onto BaseWin
TSize bitSize(KLineLength,1);
TSize bitTwipSize(TheClient->iScreen->HorizontalPixelsToTwips(bitSize.iWidth*KXScaleFactor),
TheClient->iScreen->VerticalPixelsToTwips(bitSize.iHeight*KYScaleFactor));
CFbsBitGc *bitGc=NULL;
CFbsBitmapDevice *device=NULL;
CFbsBitmap *bitmap=NULL;
bitmap=new(ELeave) CFbsBitmap();
CleanupStack::PushL(bitmap);
User::LeaveIfError(bitmap->Create(bitSize,EGray16));
bitmap->SetSizeInTwips(bitTwipSize);
device=CFbsBitmapDevice::NewL(bitmap);
CleanupStack::PushL(device);
User::LeaveIfError(device->CreateContext(bitGc));
bitGc->SetBrushColor(KRgbBlack);
bitGc->Clear();
delete bitGc;
//
gc->Activate(*(BaseWin->Win()));
gc->DrawBitmap(TPoint(KLineXPos,KLineYPos),bitmap);
gc->Deactivate();
//
TheClient->iWs.Flush();
CleanupStack::PopAndDestroy(2); // bitmap,device
CompareWindows(_L("CTScrMode::ScaledDrawingL() CompareWindows() failed"));
}
void CTScrMode::ValidateWin(TestWindow *aWin, TRgb aColor)
{
aWin->Win()->Invalidate();
RedrawWin(*aWin->Win(),aColor);
}
void CTScrMode::RedrawWin(RWindow &aWin, TRgb aColor)
{
aWin.BeginRedraw();
TheClient->iGc->Activate(aWin);
TheClient->iGc->SetBrushColor(aColor);
TheClient->iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
TheClient->iGc->SetPenStyle(CGraphicsContext::ENullPen);
TheClient->iGc->Clear();
TheClient->iGc->Deactivate();
aWin.EndRedraw();
}
void CTScrMode::CheckWindows(TBool aWinIsVis)
{
iSecondConnection->SetWindow2Visibility(aWinIsVis);
TheClient->WaitForRedrawsToFinish();
TheClient->iWs.Finish();
CompareWindows(_L("CTScrMode::CheckWindows() CompareWindows() failed"));
}
void CTScrMode::ScreenRotationsL()
{
CWsScreenDevice *screen=TheClient->iScreen;
CArrayFixFlat<TInt> *rotations=new(ELeave) CArrayFixFlat<TInt>(1);
CFbsBitGc::TGraphicsOrientation currentRotation;
TPixelsAndRotation sizeAndRotation;
TPixelsTwipsAndRotation sizeAndRotation2;
TBool found;
TInt numModes=TheClient->iScreenModes.Count();
TInt count;
TInt ii,jj;
CleanupStack::PushL(rotations);
for (ii=0;ii<numModes;++ii)
{
TInt mode=TheClient->iScreenModes[ii];
User::LeaveIfError(screen->GetRotationsList(mode,rotations));
screen->GetScreenModeSizeAndRotation(mode,sizeAndRotation);
screen->GetScreenModeSizeAndRotation(mode,sizeAndRotation2);
TEST(sizeAndRotation.iPixelSize.iWidth==sizeAndRotation2.iPixelSize.iWidth);
if (sizeAndRotation.iPixelSize.iWidth!=sizeAndRotation2.iPixelSize.iWidth)
INFO_PRINTF3(_L("sizeAndRotation.iPixelSize.iWidth==sizeAndRotation2.iPixelSize.iWidth - Expected: %d, Actual: %d"), sizeAndRotation.iPixelSize.iWidth, sizeAndRotation2.iPixelSize.iWidth);
TEST(sizeAndRotation.iPixelSize.iHeight==sizeAndRotation2.iPixelSize.iHeight);
if (sizeAndRotation.iPixelSize.iHeight!=sizeAndRotation2.iPixelSize.iHeight)
INFO_PRINTF3(_L("sizeAndRotation.iPixelSize.iHeight==sizeAndRotation2.iPixelSize.iHeight - Expected: %d, Actual: %d"), sizeAndRotation.iPixelSize.iHeight, sizeAndRotation2.iPixelSize.iHeight);
count=rotations->Count();
TEST(count>=1);
if (count<1)
INFO_PRINTF3(_L("rotations->Count() return value - Expected: %d or more, Actual: %d"), 1, count);
TBool retVal;
if (sizeAndRotation.iPixelSize.iWidth!=sizeAndRotation.iPixelSize.iHeight)
{
TEST(count<=2);
if (count>2)
INFO_PRINTF3(_L("rotations->Count() return value - Expected: %d or less, Actual: %d"), 2, count);
if (count==2)
{
retVal = (*rotations)[0]+2==(*rotations)[1];
TEST(retVal); //Must only have rotations 180 degrees apart
if (!retVal)
INFO_PRINTF3(_L("(*rotations)[0]+2==(*rotations)[1] - Expected: %d, Actual: %d"), ETrue, retVal);
}
}
found=EFalse;
for (jj=0;jj<count;++jj)
{
if ((*rotations)[jj]==sizeAndRotation.iRotation)
{
retVal = (*rotations)[jj]==sizeAndRotation2.iRotation;
TEST(retVal);
if (!retVal)
INFO_PRINTF3(_L("(*rotations)[jj]==sizeAndRotation2.iRotation - Expected: %d, Actual: %d"), ETrue, retVal);
found=ETrue;
break;
}
}
TEST(found);
if (!found)
INFO_PRINTF3(_L("found - Expected: %d, Actual: %d"), ETrue, found);
if (count>1)
{
currentRotation=sizeAndRotation.iRotation;
for (jj=0;jj<count;++jj)
{
screen->SetCurrentRotations(mode,REINTERPRET_CAST(CFbsBitGc::TGraphicsOrientation&,(*rotations)[jj]));
screen->GetScreenModeSizeAndRotation(mode,sizeAndRotation);
screen->GetScreenModeSizeAndRotation(mode,sizeAndRotation2);
retVal = (*rotations)[jj]==sizeAndRotation.iRotation;
TEST(retVal);
if (!retVal)
INFO_PRINTF3(_L("(*rotations)[jj]==sizeAndRotation.iRotation - Expected: %d, Actual: %d"), ETrue, retVal);
retVal = (*rotations)[jj]==sizeAndRotation2.iRotation;
TEST(retVal);
if (!retVal)
INFO_PRINTF3(_L("(*rotations)[jj]==sizeAndRotation2.iRotation - Expected: %d, Actual: %d"), ETrue, retVal);
}
screen->SetCurrentRotations(mode,REINTERPRET_CAST(CFbsBitGc::TGraphicsOrientation&,currentRotation));
screen->GetScreenModeSizeAndRotation(mode,sizeAndRotation);
screen->GetScreenModeSizeAndRotation(mode,sizeAndRotation2);
retVal = currentRotation==sizeAndRotation.iRotation;
TEST(retVal);
if (!retVal)
INFO_PRINTF3(_L("currentRotation==sizeAndRotation.iRotation - Expected: %d, Actual: %d"), ETrue, retVal);
retVal = currentRotation==sizeAndRotation2.iRotation;
TEST(retVal);
if (!retVal)
INFO_PRINTF3(_L("currentRotation==sizeAndRotation2.iRotation - Expected: %d, Actual: %d"), ETrue, retVal);
}
}
CleanupStack::PopAndDestroy();
}
void CTScrMode::MoreScreenRotationsL()
{
RWindow shield4Gray(TheClient->iWs);
// The default display mode needs to be updated to EColor64K for Oghma integ
SetupTestRWindowLC(shield4Gray,TPoint(),TSize(100000,100000),EColor64K);
//
CWsScreenDevice *screen=TheClient->iScreen;
//CFbsBitGc::TGraphicsOrientation currentRotation;
TPixelsAndRotation sizeAndRotation;
TInt currentRotation;
TInt currentMode=FindCurrentMode();
TInt numModes=TheClient->iScreenModes.Count();
TInt currentScreenMode;
TInt count;
TInt ii,jj;
CArrayFixFlat<TInt> *currentRotations=new(ELeave) CArrayFixFlat<TInt>(1);
CleanupStack::PushL(currentRotations);
currentRotations->ResizeL(numModes);
CArrayFixFlat<TInt> *originalRotation=new(ELeave) CArrayFixFlat<TInt>(1);
CleanupStack::PushL(originalRotation);
originalRotation->ResizeL(numModes);
CArrayFixFlat<TInt> *rotations=new(ELeave) CArrayFixFlat<TInt>(1);
CleanupStack::PushL(rotations);
for (ii=0;ii<numModes;++ii)
{
TInt mode=TheClient->iScreenModes[ii];
screen->GetScreenModeSizeAndRotation(mode,sizeAndRotation);
(*currentRotations)[ii]=sizeAndRotation.iRotation;
(*originalRotation)[ii]=sizeAndRotation.iRotation;
}
for (ii=0;ii<numModes;++ii)
{
TInt mode=TheClient->iScreenModes[ii];
screen->SetScreenMode(mode);
currentScreenMode = screen->CurrentScreenMode();
TEST(currentScreenMode == mode);
if (currentScreenMode != mode)
INFO_PRINTF3(_L("screen->CurrentScreenMode() return value - Expected: %d, Actual: %d"), mode, currentScreenMode);
screen->GetDefaultScreenSizeAndRotation(sizeAndRotation);
currentRotation=(*currentRotations)[ii];
TEST(sizeAndRotation.iRotation==currentRotation);
screen->GetScreenModeSizeAndRotation(mode,sizeAndRotation);
TEST(sizeAndRotation.iRotation==currentRotation);
User::LeaveIfError(screen->GetRotationsList(mode,rotations));
count=rotations->Count();
if (count>1)
{
for (jj=0;jj<count;)
{
if ((*rotations)[jj++]==currentRotation)
break;
}
if (jj==count)
jj=0;
currentRotation=(*rotations)[jj];
screen->SetCurrentRotations(mode,REINTERPRET_CAST(CFbsBitGc::TGraphicsOrientation&,currentRotation));
(*currentRotations)[ii]=currentRotation;
}
}
for (ii=0;ii<numModes;++ii)
{
TInt mode=TheClient->iScreenModes[ii];
screen->SetScreenMode(mode);
currentScreenMode = screen->CurrentScreenMode();
TEST(currentScreenMode == mode);
if (currentScreenMode != mode)
INFO_PRINTF3(_L("(screen->CurrentScreenMode() return value - Expected: %d, Actual: %d"), mode, currentScreenMode);
screen->GetDefaultScreenSizeAndRotation(sizeAndRotation);
currentRotation=(*currentRotations)[ii];
TEST(sizeAndRotation.iRotation==currentRotation);
if (sizeAndRotation.iRotation != currentRotation)
INFO_PRINTF3(_L("(screen->GetDefaultScreenSizeAndRotation() return value - Expected: %d, Actual: %d"), currentRotation, sizeAndRotation.iRotation);
screen->GetScreenModeSizeAndRotation(mode,sizeAndRotation);
TEST(sizeAndRotation.iRotation==currentRotation);
if (sizeAndRotation.iRotation != currentRotation)
INFO_PRINTF3(_L("(screen->GetDefaultScreenSizeAndRotation() return value - Expected: %d, Actual: %d"), currentRotation, sizeAndRotation.iRotation);
if (currentRotation!=(*originalRotation)[ii])
screen->SetCurrentRotations(mode,REINTERPRET_CAST(CFbsBitGc::TGraphicsOrientation&,(*originalRotation)[ii]));
}
screen->SetScreenMode(currentMode);
currentScreenMode = screen->CurrentScreenMode();
TEST(currentScreenMode == currentMode);
if (currentScreenMode != currentMode)
INFO_PRINTF3(_L("(screen->CurrentScreenMode() return value - Expected: %d, Actual: %d"), currentMode, currentScreenMode);
CleanupStack::PopAndDestroy(4,&shield4Gray);
}
TInt CTScrMode::FindCurrentMode()
{
CWsScreenDevice *screen=TheClient->iScreen;
TPixelsTwipsAndRotation sizeAndRotation;
TPixelsTwipsAndRotation sizeAndRotation2;
TInt numModes=TheClient->iScreenModes.Count();
TInt ii;
screen->GetDefaultScreenSizeAndRotation(sizeAndRotation);
for (ii=0;ii<numModes;++ii)
{
TInt mode=TheClient->iScreenModes[ii];
screen->GetScreenModeSizeAndRotation(mode,sizeAndRotation2);
if (Equal(sizeAndRotation,sizeAndRotation2))
return mode;
}
TEST(EFalse);
return -1;
}
TBool CTScrMode::Equal(const TPixelsTwipsAndRotation& aLeft,const TPixelsTwipsAndRotation& aRight)
{
if (aLeft.iPixelSize!=aRight.iPixelSize)
return EFalse;
if (aLeft.iRotation!=aRight.iRotation)
return EFalse;
if (aLeft.iTwipsSize!=aRight.iTwipsSize)
return EFalse;
return ETrue;
}
TBool CTScrMode::RectClearBugL()
{
CWsScreenDevice *screen=TheClient->iScreen;
TPixelsTwipsAndRotation sizeAndRotation1;
TPixelsTwipsAndRotation sizeAndRotation2;
TInt screenMode=FindCurrentMode();
TInt largeMode=0;
TInt smallMode=1;
INFO_PRINTF1(_L("Rotation 1"));
screen->GetScreenModeSizeAndRotation(0,sizeAndRotation1);
INFO_PRINTF1(_L("Rotation 2"));
screen->GetScreenModeSizeAndRotation(1,sizeAndRotation2);
TSize winSize=TSize(Max(sizeAndRotation1.iPixelSize.iWidth,sizeAndRotation2.iPixelSize.iWidth)
,Max(sizeAndRotation1.iPixelSize.iHeight,sizeAndRotation2.iPixelSize.iHeight));
if (sizeAndRotation1.iPixelSize.iWidth<=sizeAndRotation2.iPixelSize.iWidth
&& sizeAndRotation1.iPixelSize.iHeight<=sizeAndRotation2.iPixelSize.iHeight)
{
largeMode=1;
smallMode=0;
}
if (screenMode!=largeMode)
{
INFO_PRINTF2(_L("Large Mode %d\r\n"),largeMode);
screen->SetScreenMode(largeMode);
}
CBlankWindow *blankWin=new(ELeave) CBlankWindow(TRgb::Gray256(204));
CleanupStack::PushL(blankWin);
blankWin->SetUpL(TPoint(),winSize,TheClient->iGroup,*TheClient->iGc);
TheClient->iGc->Activate(*blankWin->Win()); //blankWin->Win()->Invalidate();
blankWin->Draw();
TheClient->iWs.Flush();
blankWin->Win()->SetRequiredDisplayMode(EGray4);
INFO_PRINTF2(_L("Small Mode %d\r\n"),smallMode);
screen->SetScreenMode(smallMode);
TheClient->iWs.Flush();
TheClient->iGc->Deactivate();
CleanupStack::PopAndDestroy();
if (screenMode!=smallMode)
{
INFO_PRINTF2(_L("Screen Mode %d\r\n"),screenMode);
screen->SetScreenMode(screenMode);
}
return ETrue;
}
void CTScrMode::ScreenModeChange1L()
{
CTWin* color64win;
color64win=new(ELeave) CTWin();
CleanupStack::PushL(color64win);
color64win->ConstructL(*TheClient->iGroup);
color64win->BaseWin()->SetRequiredDisplayMode(EColor64K);
//color64win->SetBackgroundColor(TRgb(0,0,255));
color64win->Win()->SetBackgroundColor();
color64win->Activate();
TheClient->Flush();
CTWin* color4win;
color4win=new(ELeave) CTWin();
CleanupStack::PushL(color4win);
color4win->ConstructL(*TheClient->iGroup);
color4win->BaseWin()->SetRequiredDisplayMode(EColor4K);
//color4win->SetBackgroundColor(TRgb(255,0,0));
color4win->Win()->SetBackgroundColor();
color4win->SetSize(TSize(600,200));
color4win->Activate();
TheClient->Flush();
color4win->SetSize(TSize(640,240));
TheClient->Flush();
color64win->SetSize(TSize(20,20));
color64win->WinTreeNode()->SetOrdinalPosition(0);
TheClient->Flush();
CleanupStack::Pop(2,color64win);
delete color64win;
TheClient->Flush();
delete color4win;
//CleanupStack::PopAndDestroy(2,color64win);
}
void CTScrMode::ScreenModeChange2L()
{
CTBlankWindow* color64win;
color64win=new(ELeave) CTBlankWindow();
CleanupStack::PushL(color64win);
color64win->ConstructL(*TheClient->iGroup);
color64win->BaseWin()->SetRequiredDisplayMode(EColor64K);
color64win->SetColor(TRgb(0,0,255));
//color64win->SetColor();
color64win->Activate();
TheClient->Flush();
CTBlankWindow* color4win;
color4win=new(ELeave) CTBlankWindow();
CleanupStack::PushL(color4win);
color4win->ConstructL(*TheClient->iGroup);
color4win->BaseWin()->SetRequiredDisplayMode(EColor4K);
color4win->SetColor(TRgb(255,0,0));
//color4win->SetColor();
color4win->SetSize(TSize(600,200));
color4win->Activate();
TheClient->Flush();
color4win->SetSize(TSize(640,240));
TheClient->Flush();
color64win->SetSize(TSize(20,20));
color64win->WinTreeNode()->SetOrdinalPosition(0);
TheClient->Flush();
CleanupStack::Pop(2,color64win);
delete color64win;
TheClient->Flush();
delete color4win;
//CleanupStack::PopAndDestroy(2,color64win);
}
LOCAL_C void ResetAndDestroyWindows(TAny* aPointerArray)
{
static_cast<RPointerArray<CBlankWindow>*>(aPointerArray)->ResetAndDestroy();
}
LOCAL_C TBool WalkThroughTree(RPointerArray<CBlankWindow> aListOfWindows)
{
TBool ret=ETrue;
TInt count = aListOfWindows.Count();
while (--count>=0 && ret)
{
RRegion region;
((aListOfWindows)[count])->Win()->GetInvalidRegion(region);
ret=region.IsEmpty();
}
return ret;
}
void CTScrMode::InvisibleWndAndInfiniteRedrawBugL()
{
// Current Test client state
CTClient* clientA=TheClient;
CWsScreenDevice* screenClientA=clientA->iScreen;
const TScreenModeEnforcement screenModeEnforcement = screenClientA->ScreenModeEnforcement();
const TInt currentScreenMode=FindCurrentMode();
TPixelsTwipsAndRotation sizeAndRotation;
screenClientA->GetScreenModeSizeAndRotation(currentScreenMode,sizeAndRotation);
SecondClientConnection* clientB = new(ELeave) SecondClientConnection();
CleanupStack::PushL(clientB);
clientB->SetScreenNumber(iTest->iScreenNumber);
clientB->ConstructL(currentScreenMode, sizeAndRotation);
// Start test
CWindowGc& gc=*clientB->iGc;
RWsSession ws=clientB->iWs;
CTWindowGroup* group=clientB->iGroup;
const TInt shrinkFactor = 5;
TRect parentRect(0,0, sizeAndRotation.iPixelSize.iWidth, sizeAndRotation.iPixelSize.iHeight);
RPointerArray<CBlankWindow> windows;
CleanupStack::PushL(TCleanupItem(ResetAndDestroyWindows, &windows));
// create several children
const TInt count = (iTest->iTestLevel==iTest->ELevelQuick ? 5 : 7);
CBlankWindow* blankWin=NULL;
CTWinBase* parent=group;
for (TInt childNum=0; childNum<count; ++childNum)
{
blankWin=new(ELeave) CBlankWindow();
CleanupStack::PushL(blankWin);
User::LeaveIfError(windows.Append(blankWin));
CleanupStack::Pop(blankWin);
blankWin->SetUpL(parentRect.iTl, parentRect.Size(), parent, gc);
// make it visible and draw it
blankWin->Win()->Invalidate();
gc.Activate(*blankWin->Win());
blankWin->Draw();
ws.Flush();
gc.Deactivate();
// prepare for next window
parent=blankWin;
parentRect.Shrink(shrinkFactor, shrinkFactor);
}
// change screen mode and check visibility of all windows
const TInt newScreenMode = (currentScreenMode==KScreenMode0?KScreenMode1:KScreenMode0);
TPixelsTwipsAndRotation sizeAndRotationForDifferentScreenMode;
screenClientA->GetScreenModeSizeAndRotation(newScreenMode, sizeAndRotationForDifferentScreenMode);
screenClientA->SetScreenSizeAndRotation(sizeAndRotationForDifferentScreenMode);
screenClientA->SetScreenMode(newScreenMode);
TheClient->WaitForRedrawsToFinish();
TBool retVal = WalkThroughTree(windows);
TEST(retVal);
if (!retVal)
INFO_PRINTF3(_L("WalkThroughTree(windows) return value - Expected: %d, Actual: %d"), ETrue, retVal);
screenClientA->SetScreenModeEnforcement(screenModeEnforcement);
screenClientA->SetScreenMode(currentScreenMode);
screenClientA->SetScreenSizeAndRotation(sizeAndRotation);
// destroy all windows
CleanupStack::PopAndDestroy(2, clientB); // ResetAndDestroyWindows and client
// Needed to get system back into a good state as this test can leave the shell in front of the test app
TheClient->iGroup->GroupWin()->SetOrdinalPosition(0);
}
//To test the APIs GetScreenModeDisplayMode() & GetDefModeMaxNumColors()
void CTScrMode::GetScreenDisplayMode()
{
TInt color,gray;
CWsScreenDevice *screen=TheClient->iScreen;
TInt currentScreenMode=screen->CurrentScreenMode(); //finding the current screen mode
screen->SetScreenMode(KScreenMode1); //changing the current screen mode to 1
//testing the display mode of Screen Mode using the API GetScreenModeDisplayMode()
TDisplayMode displayMode=screen->GetScreenModeDisplayMode(KScreenMode1);
TEST(displayMode!=ENone);
TEST(displayMode!=ERgb);
//testing the default mode of Screen Mode using the API GetDefModeMaxNumColors()
TDisplayMode defaultMode=TheClient->iWs.GetDefModeMaxNumColors(color,gray);
TDisplayMode defaultModeForScreen=TheClient->iWs.GetDefModeMaxNumColors(screen->GetScreenNumber(),color,gray);
TEST(defaultMode==defaultModeForScreen);
TEST(defaultMode!=ENone);
TEST(defaultMode!=ERgb);
TEST(color == 16777216 || color == 0 || color == 16 || color == 256 || color == 4096 || color == 65536);
TEST(gray == 0 || gray == 2 || gray == 4 || gray == 16 || gray == 256);
screen->SetScreenMode(currentScreenMode);
CArrayFixFlat<TInt>* modeList=new CArrayFixFlat<TInt>(15);
TEST(modeList != NULL);
if(!modeList)
{
return;
}
TInt res = TheClient->iWs.GetColorModeList(modeList);
TEST(res == KErrNone);
TDisplayMode modeMax = ENone;
for(TInt index = 0; index < modeList->Count(); index++)
{
TDisplayMode mode = (TDisplayMode) ((*modeList)[index]);
if(mode > modeMax)
{
modeMax = mode;
}
}
modeList->Reset();
delete modeList;
TInt realColor = 0;
TInt realGray = 0;
switch(modeMax)
{
case EGray2:
realColor = 2;
realGray = 2;
break;
case EGray4:
realColor = 4;
realGray = 4;
break;
case EGray16:
realColor = 16;
realGray = 16;
break;
case EGray256:
realColor = 256;
realGray = 256;
break;
case EColor16:
realColor = 16;
break;
case EColor256:
realColor = 256;
break;
case EColor4K:
realColor = 4096;
break;
case EColor64K:
realColor = 65536;
break;
case EColor16M:
case EColor16MU:
case EColor16MA:
case EColor16MAP:
realColor = 16777216;
break;
default:
break;
}
if (realColor > 0)
TEST(realColor == color);
if (realGray > 0)
TEST(gray == realGray);
}
void CTScrMode::SetScreenModeAfterScreenDeviceDeletedL()
{
// A separate session is needed, because this test will delete the primary screen device
RWsSession ws;
User::LeaveIfError(ws.Connect());
// Push the secondary screen device first onto the cleanup stack
// so that we can pop and destroy the primary screen device first
CWsScreenDevice* secondaryScreenDevice = new (ELeave) CWsScreenDevice(ws);
CleanupStack::PushL(secondaryScreenDevice);
CWsScreenDevice* primaryScreenDevice = new (ELeave) CWsScreenDevice(ws);
CleanupStack::PushL(primaryScreenDevice);
// Construct the primary screen device first to ensure that it is
// used by the group window
User::LeaveIfError(primaryScreenDevice->Construct(iTest->iScreenNumber));
User::LeaveIfError(secondaryScreenDevice->Construct(iTest->iScreenNumber));
RWindowGroup group(ws);
User::LeaveIfError(group.Construct(888));
group.EnableReceiptOfFocus(EFalse); // Stop auto group switching on close
RArray<TInt> screenModes;
primaryScreenDevice->GetScreenSizeModeList(&screenModes);
primaryScreenDevice->SetScreenMode(screenModes[0]);
// Prematurely destroy the primary screen device used by the group window
CleanupStack::PopAndDestroy(primaryScreenDevice);
// Simulate screen rotation - call SetScreenMode()
// This would trigger the defective behaviour and wserv would panic if broken
secondaryScreenDevice->SetScreenMode(screenModes[0]);
// Tidy up
screenModes.Close();
group.Close();
CleanupStack::PopAndDestroy(secondaryScreenDevice);
ws.Flush();
ws.Close();
}
void CTScrMode::DrawTestBmpL(CFbsBitmap* aTestBitmap)
{
CFbsBitmapDevice* device=CFbsBitmapDevice::NewL(aTestBitmap);
CleanupStack::PushL(device);
CGraphicsContext* bmpgc;
User::LeaveIfError(device->CreateContext(bmpgc));
CleanupStack::PushL(bmpgc);
bmpgc->SetPenColor(KRgbDarkRed);
bmpgc->SetBrushColor(KRgbYellow);
bmpgc->SetBrushStyle(CGraphicsContext::ESolidBrush);
bmpgc->SetPenStyle(CGraphicsContext::ESolidPen);
bmpgc->DrawRect(TRect(aTestBitmap->SizeInPixels()));
CleanupStack::PopAndDestroy(2,device);
}
void CTScrMode::TestDrawingToWindows(CWindowGc* aWinGc1, CWindowGc* aWinGc2, RWindow& aWindow1,RWindow& aWindow2,CFbsBitmap* aBitmap64K,CFbsBitmap* aBitmap16M,CFbsFont* aFont, TBool aAllInRedraw, TBool aUseSystemGc, TBool aUseBmp16M)
{
CFbsBitmap* bitmap=aUseBmp16M?aBitmap16M:aBitmap64K;
TInt ascent=aFont->AscentInPixels();
for(TInt win=0;win<2;win++)
{
RWindow* winPtr=(win==0)?&aWindow1:&aWindow2;
winPtr->Invalidate();
winPtr->BeginRedraw();
CWindowGc* winGc;
if (aUseSystemGc)
{
winGc=TheClient->iGc;
winGc->Activate(*winPtr);
}
else
{
winGc=(win==0)?aWinGc1:aWinGc2;
winGc->Reset();
}
winGc->SetBrushColor(KRgbBlue);
winGc->Clear();
if (!aAllInRedraw)
winPtr->EndRedraw();
//
winGc->BitBlt(TPoint(0,0),bitmap);
winGc->UseFont(aFont);
_LIT(KTestText123,"Test text 123");
winGc->DrawText(KTestText123,TPoint(0,ascent));
if (aAllInRedraw)
winPtr->EndRedraw();
if (aUseSystemGc)
winGc->Deactivate();
}
TBool winCheck=DoCheckRectRWin(aWindow1,aWindow2,TRect(aWindow1.Size()));
if (!winCheck)
{
TBuf<256> errBuf(_L("Rot-mode test failed"));
if (aAllInRedraw)
errBuf.Append(_L(", All in Redraw"));
if (aUseSystemGc)
errBuf.Append(_L(", System Gc"));
if (aUseBmp16M)
errBuf.Append(_L(", 16M bmp"));
else
errBuf.Append(_L(", 64K bmp"));
INFO_PRINTF1(errBuf);
}
TEST(winCheck);
}
void SetWsAndAppScreenModes(TInt aMode)
{
TheClient->iScreen->SetScreenMode(aMode);
TheClient->iScreen->SetAppScreenMode(aMode);
}
TDisplayMode HighestMatch(CArrayFixFlat<TInt>* aModeList,TInt &aMaxBpp)
{
TDisplayMode highMode=ENone;
TInt highBpp=0;
for(TInt loop=aModeList->Count()-1;loop>=0;loop--)
{
TDisplayMode mode=(TDisplayMode)(*aModeList)[loop];
TInt bpp;
switch(mode)
{
case EGray2:
bpp=1;
break;
case EGray4:
bpp=2;
break;
case EGray16:
case EColor16:
bpp=4;
break;
case EColor256:
case EGray256:
bpp=8;
break;
case EColor64K:
bpp=16;
break;
case EColor4K:
bpp=12;
break;
case EColor16M:
case EColor16MU:
case EColor16MA:
case EColor16MAP:
bpp=32;
break;
default:
bpp=0;
break;
}
if (bpp>highBpp && bpp<aMaxBpp)
{
highBpp=bpp;
highMode=mode;
}
}
aMaxBpp=highBpp;
return(highMode);
}
void CTScrMode::TestRotateAndScreenModeL()
{
TheClient->iGroup->GroupWin()->SetOrdinalPosition(0);
// When switching colour modes Wserv takes into account the full device size, not the clipped size
// associated with any specific screen mode. Therefore any windows designed to influence the screen
// mode must use the appropriately rotated device base screen size, not any cutdown screen mode sizes.
TSize baseScreenSize=TheClient->iScreen->SizeInPixels();
TSize rotatedBaseSize(baseScreenSize.iHeight,baseScreenSize.iWidth);
TInt maxScreenDimension=Max(baseScreenSize.iHeight,baseScreenSize.iWidth);
//
CArrayFixFlat<TInt>* modeList=new(ELeave) CArrayFixFlat<TInt>(15);
CleanupStack::PushL(modeList);
User::LeaveIfError(TheClient->iWs.GetColorModeList(modeList));
TInt maxBpp=KMaxTInt;
TDisplayMode testDispModeHigh=HighestMatch(modeList,maxBpp);
TDisplayMode testDispModeLow=HighestMatch(modeList,maxBpp);
CleanupStack::PopAndDestroy(modeList);
// If only one available display mode skip tests
if (testDispModeLow==ENone)
return;
//
CFbsFont* font;
TFontSpec fspec;
fspec.iHeight=240;
User::LeaveIfError(TheClient->iScreen->GetNearestFontToDesignHeightInTwips((CFont*&)font,fspec));
// Create a massive 16M window to make sure 16M is the fallback mode when any area of the screen is exposed
RWindow shield16M(TheClient->iWs);
SetupTestRWindowLC(shield16M,TPoint(),TSize(100000,100000),testDispModeHigh);
RedrawWin(shield16M,KRgbBlack);
//
TInt numModes=TheClient->iScreenModes.Count();
for(TInt modeIndex=0;modeIndex<numModes;modeIndex++)
{
TInt screenMode=TheClient->iScreenModes[modeIndex];
TPoint origin=TheClient->iScreen->GetScreenModeScaledOrigin(screenMode);
if (origin.iX!=0 || origin.iY!=0)
continue;
TPixelsTwipsAndRotation sar;
TheClient->iScreen->GetScreenModeSizeAndRotation(screenMode,sar);
TSize screenSize=sar.iPixelSize;
if (screenSize.iWidth>baseScreenSize.iWidth || screenSize.iHeight>baseScreenSize.iHeight)
continue;
TSize rotatedScreenDeviceSize(sar.iRotation==CFbsBitGc::EGraphicsOrientationRotated90 || sar.iRotation==CFbsBitGc::EGraphicsOrientationRotated270?
rotatedBaseSize:baseScreenSize);
//
TheClient->iScreen->SetScreenMode(screenMode);
//
TSize screenSize1 = screenSize;
screenSize1.iWidth = Min(screenSize1.iWidth, rotatedScreenDeviceSize.iWidth); //this is to guarantee we won't compare beyond screen size
TSize testSize(screenSize1.iWidth/2,screenSize1.iHeight);
TSize testBmpSize(testSize.iWidth,testSize.iHeight/4);
//
CFbsBitmap* testBitmap64=new(ELeave) CFbsBitmap;
CleanupStack::PushL(testBitmap64);
User::LeaveIfError(testBitmap64->Create(testBmpSize,testDispModeLow));
DrawTestBmpL(testBitmap64);
//
CFbsBitmap* testBitmap16M=new(ELeave) CFbsBitmap;
CleanupStack::PushL(testBitmap16M);
User::LeaveIfError(testBitmap16M->Create(testBmpSize,testDispModeHigh));
DrawTestBmpL(testBitmap16M);
//
RWindow window(TheClient->iWs);
SetupTestRWindowLC(window,TPoint(0,0), testSize,testDispModeHigh);
RWindow window2(TheClient->iWs);
SetupTestRWindowLC(window2,TPoint(testSize.iWidth,0),testSize,testDispModeHigh);
//
CWindowGc* winGc1=new(ELeave) CWindowGc(TheClient->iScreen);
CleanupStack::PushL(winGc1);
User::LeaveIfError(winGc1->Construct());
winGc1->Activate(window);
CWindowGc* winGc2=new(ELeave) CWindowGc(TheClient->iScreen);
CleanupStack::PushL(winGc2);
User::LeaveIfError(winGc2->Construct());
winGc2->Activate(window2);
//
for(TInt modeIndex2=0;modeIndex2<numModes;modeIndex2++)
{
if (modeIndex==modeIndex2)
continue;
TInt screenMode2=TheClient->iScreenModes[modeIndex2];
TPoint origin2=TheClient->iScreen->GetScreenModeScaledOrigin(screenMode2);
if (origin2.iX!=0 || origin2.iY!=0)
continue;
TDisplayMode baseDisplayMode=TheClient->iScreen->DisplayMode();
INFO_PRINTF5(_L("Testing with screen modes %d/%d, display modes %d/%d"),modeIndex,modeIndex2,testDispModeLow,testDispModeHigh);
SetWsAndAppScreenModes(screenMode2);
TDisplayMode dispMode11 = TheClient->iScreen->DisplayMode();
TPixelsTwipsAndRotation sar1;
TheClient->iScreen->GetScreenModeSizeAndRotation(screenMode2, sar1);
if(sar1.iRotation == sar.iRotation)
{
continue;
}
//
RWindow window64K(TheClient->iWs);
SetupTestRWindowLC(window64K,TPoint(),TSize(maxScreenDimension,maxScreenDimension),testDispModeLow);
RedrawWin(window64K,KRgbGreen);
// Should now have switched Wserv to 64K mode
TEST(TheClient->iScreen->DisplayMode()==testDispModeLow);
//
RWindow window16M(TheClient->iWs);
SetupTestRWindowLC(window16M,TPoint(),TSize(maxScreenDimension/2,maxScreenDimension/2),testDispModeHigh);
RedrawWin(window16M,KRgbCyan);
// Should switch Wserv back to 16M mode
TEST(TheClient->iScreen->DisplayMode()==testDispModeHigh);
//
window64K.SetOrdinalPosition(-1);
window16M.SetOrdinalPosition(-1);
SetWsAndAppScreenModes(screenMode);
TEST(TheClient->iScreen->DisplayMode()==baseDisplayMode);
//
const TInt KNumTestFlags=3;
const TInt KMaxTestFlags=1<<KNumTestFlags;
for(TUint testFlags=0;testFlags<KMaxTestFlags;testFlags++)
{
TestDrawingToWindows(winGc1,winGc2,window,window2,testBitmap64,testBitmap16M,font,testFlags&0x1,testFlags&0x2,testFlags&0x4);
}
// Test various functions change the display mode appropriately
window64K.SetOrdinalPosition(0);
TEST(TheClient->iScreen->DisplayMode()==testDispModeLow);
window64K.SetVisible(EFalse);
TEST(TheClient->iScreen->DisplayMode()==baseDisplayMode);
window64K.SetVisible(ETrue);
TEST(TheClient->iScreen->DisplayMode()==testDispModeLow);
window64K.SetSize(rotatedScreenDeviceSize);
TEST(TheClient->iScreen->DisplayMode()==testDispModeLow);
// Changing screen mode now should expose the 16M window
SetWsAndAppScreenModes(screenMode2);
TEST(TheClient->iScreen->DisplayMode()==testDispModeHigh);
SetWsAndAppScreenModes(screenMode);
// And back to the 64K win covering the screen
TEST(TheClient->iScreen->DisplayMode()==testDispModeLow);
// Create a new group with a 16M window and switching ordinal pos to back and back to front
RWindowGroup testGroup(TheClient->iWs);
CleanupClosePushL(testGroup);
User::LeaveIfError(testGroup.Construct(111,EFalse));
RWindow testGroupWin(TheClient->iWs);
CleanupClosePushL(testGroupWin);
User::LeaveIfError(testGroupWin.Construct(testGroup, 112));
testGroupWin.SetExtent(TPoint(), TSize(1,1)); // Just enough to change mode
testGroupWin.SetRequiredDisplayMode(testDispModeHigh);
testGroupWin.Activate();
TEST(TheClient->iScreen->DisplayMode()==testDispModeHigh);
TInt oldPos=testGroup.OrdinalPosition();
testGroup.SetOrdinalPosition(oldPos+1);
TEST(TheClient->iScreen->DisplayMode()==testDispModeLow);
testGroup.SetOrdinalPosition(oldPos);
TEST(TheClient->iScreen->DisplayMode()==testDispModeHigh);
CleanupStack::PopAndDestroy(2,&testGroup);
TEST(TheClient->iScreen->DisplayMode()==testDispModeLow);
//
CleanupStack::PopAndDestroy(2,&window64K);
}
CleanupStack::PopAndDestroy(2,winGc1);
CleanupStack::PopAndDestroy(2,&window);
CleanupStack::PopAndDestroy(2,testBitmap64);
}
CleanupStack::PopAndDestroy(&shield16M);
TheClient->iScreen->ReleaseFont(font);
SetWsAndAppScreenModes(TheClient->iScreenModes[0]);
}
void CTScrMode::RunTestCaseL(TInt /*aCurTestCase*/)
{
TBuf<32> buf;
TBool checkWindowParam=EFalse;
TInt count=0;
TInt mode=0;
TBool enable=EFalse;
TBool disable=EFalse;
TInt retVal;
((CTScrModeStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);
switch(++iTest->iState)
{
/**
@SYMTestCaseID GRAPHICS-WSERV-0296
@SYMDEF DEF081259
@SYMTestCaseDesc Test screen modes can be set while the screen is rotated
through 180 degrees.
@SYMTestPriority High
@SYMTestStatus Implemented
@SYMTestActions Rotate the screen through 180 degrees while setting each
of the screen modes available
@SYMTestExpectedResults The screen is rotated and screen modes set correctly
*/
case 1:
((CTScrModeStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0296"));
iTest->LogSubTest(_L("Orientation1"));
ScreenRotationsL();
break;
/**
@SYMTestCaseID GRAPHICS-WSERV-0297
@SYMDEF DEF081259
@SYMTestCaseDesc Change the screen orientation then test screen modes can
be set while the screen is rotated through 180 degrees.
@SYMTestPriority High
@SYMTestStatus Implemented
@SYMTestActions Rotate the screen through 180 degrees while setting each
of the screen modes available
@SYMTestExpectedResults The screen is rotated and screen modes set correctly
*/
case 2:
((CTScrModeStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0297"));
iTest->LogSubTest(_L("Orientation2"));
MoreScreenRotationsL();
iSubState=0;
break;
/**
@SYMTestCaseID GRAPHICS-WSERV-0298
@SYMDEF DEF081259
@SYMTestCaseDesc Test for the rect clear defect while setting screen mode
@SYMTestPriority High
@SYMTestStatus Implemented
@SYMTestActions Change the screen mode and check the rect clear defect is
not present
@SYMTestExpectedResults The defect is not present
*/
case 3:
((CTScrModeStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0298"));
iTest->LogSubTest(_L("Rect Clear Defect"));
RectClearBugL();
break;
case 4:
/**
@SYMTestCaseID GRAPHICS-WSERV-0299
@SYMDEF DEF081259
@SYMTestCaseDesc Test display mode can be set for test windows and
that the windows then function correctly
@SYMTestPriority High
@SYMTestStatus Implemented
@SYMTestActions Set the display mode in two test windows and then call
methods on the windows
@SYMTestExpectedResults The windows function correctly
*/
((CTScrModeStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0299"));
iTest->LogSubTest(_L("ScreenModeChange"));
ScreenModeChange1L();
ScreenModeChange2L();
break;
/**
@SYMTestCaseID GRAPHICS-WSERV-0300
@SYMDEF DEF081259
@SYMTestCaseDesc Test display mode can be set and retrieved
@SYMTestPriority High
@SYMTestStatus Implemented
@SYMTestActions Set the display mode in a window and the retrieve it
@SYMTestExpectedResults The display mode retrieved is the same as the
one set.
*/
case 5:
((CTScrModeStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0300"));
iTest->LogSubTest(KScreenModeDisplayMode);
GetScreenDisplayMode();
break;
#if defined(SCREEN_MODE_TESTING)
/**
@SYMTestCaseID GRAPHICS-WSERV-0301
@SYMDEF DEF081259
@SYMTestCaseDesc Case 101 to 105 tests that the screen is drawn correctly
as different screen modes and screen orientation are
set for the screen
@SYMTestPriority High
@SYMTestStatus Implemented
@SYMTestActions Set different screen modes and orientations for the screen and
redraw the screen
@SYMTestExpectedResults The screen is drawn correctly for each setting
*/
case 101:
((CTScrModeStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0301"));
iSubState = 0;
buf.Format(TRefByValue<const TDesC>(_L("Screen mode %d:%d")),101,iSubState);
INFO_PRINTF1(buf);
checkWindowParam=ETrue;
mode=1;
if (iCurEnforcement==ESizeEnforcementPixelsAndRotation)
count+=3;
else if (iCurEnforcement==ESizeEnforcementPixelsTwipsAndRotation)
count+=6;
if (iSecondConnection->DeviceMessageCount()!=count)
{
TLogMessageText buf;
_LIT(KFailCount,"Event Mismatch, Exp=%d, Act=%d");
buf.Format(KFailCount,count,iSecondConnection->DeviceMessageCount());
TheClient->iWs.LogMessage(buf);
TheClient->iWs.Flush();
}
retVal = iSecondConnection->DeviceMessageCount();
TEST(retVal==count);
if (retVal!=count)
INFO_PRINTF3(_L("(iSecondConnection->DeviceMessageCount() return value - Expected: %d, Actual: %d"),count ,retVal);
CheckWindows(iCurEnforcement==ESizeEnforcementNone?ETrue:checkWindowParam);
if (enable)
iSecondConnection->EnableMessages();
if (disable)
iSecondConnection->DisableMessages();
TheClient->iScreen->SetScreenMode(mode);
TheClient->iWs.Flush();
iSubState++;
break;
case 102:
/**
@SYMTestCaseID GRAPHICS-WSERV-0521
*/
((CTScrModeStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0521"));
buf.Format(TRefByValue<const TDesC>(_L("Screen mode %d:%d")),101,iSubState);
INFO_PRINTF1(buf);
checkWindowParam=EFalse;
enable=ETrue;
if (iCurEnforcement==ESizeEnforcementPixelsAndRotation)
count+=3;
else if (iCurEnforcement==ESizeEnforcementPixelsTwipsAndRotation)
count+=6;
if (iSecondConnection->DeviceMessageCount()!=count)
{
TLogMessageText buf;
_LIT(KFailCount,"Event Mismatch, Exp=%d, Act=%d");
buf.Format(KFailCount,count,iSecondConnection->DeviceMessageCount());
TheClient->iWs.LogMessage(buf);
TheClient->iWs.Flush();
}
retVal = iSecondConnection->DeviceMessageCount();
TEST(retVal==count);
if (retVal!=count)
INFO_PRINTF3(_L("(iSecondConnection->DeviceMessageCount() return value - Expected: %d, Actual: %d"),count ,retVal);
if (enable)
iSecondConnection->EnableMessages();
if (disable)
iSecondConnection->DisableMessages();
TheClient->iScreen->SetScreenMode(mode);
TheClient->iWs.Flush();
iSubState++;
break;
case 103:
/**
@SYMTestCaseID GRAPHICS-WSERV-0522
*/
((CTScrModeStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0522"));
buf.Format(TRefByValue<const TDesC>(_L("Screen mode %d:%d")),101,iSubState);
INFO_PRINTF1(buf);
count=1;
mode=1;
checkWindowParam=ETrue;
if (iCurEnforcement==ESizeEnforcementPixelsAndRotation)
count+=3;
else if (iCurEnforcement==ESizeEnforcementPixelsTwipsAndRotation)
count+=6;
if (iSecondConnection->DeviceMessageCount()!=count)
{
TLogMessageText buf;
_LIT(KFailCount,"Event Mismatch, Exp=%d, Act=%d");
buf.Format(KFailCount,count,iSecondConnection->DeviceMessageCount());
TheClient->iWs.LogMessage(buf);
TheClient->iWs.Flush();
}
retVal = iSecondConnection->DeviceMessageCount();
TEST(retVal==count);
if (retVal!=count)
INFO_PRINTF3(_L("(iSecondConnection->DeviceMessageCount() return value - Expected: %d, Actual: %d"),count ,retVal);
CheckWindows(iCurEnforcement==ESizeEnforcementNone?ETrue:checkWindowParam);
if (enable)
iSecondConnection->EnableMessages();
if (disable)
iSecondConnection->DisableMessages();
TheClient->iScreen->SetScreenMode(mode);
TheClient->iWs.Flush();
iSubState++;
break;
case 104:
/**
@SYMTestCaseID GRAPHICS-WSERV-0523
*/
((CTScrModeStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0523"));
buf.Format(TRefByValue<const TDesC>(_L("Screen mode %d:%d")),101,iSubState);
INFO_PRINTF1(buf);
checkWindowParam=ETrue;
count=2;
disable=ETrue;
if (iCurEnforcement==ESizeEnforcementPixelsAndRotation)
count+=3;
else if (iCurEnforcement==ESizeEnforcementPixelsTwipsAndRotation)
count+=6;
if (iSecondConnection->DeviceMessageCount()!=count)
{
TLogMessageText buf;
_LIT(KFailCount,"Event Mismatch, Exp=%d, Act=%d");
buf.Format(KFailCount,count,iSecondConnection->DeviceMessageCount());
TheClient->iWs.LogMessage(buf);
TheClient->iWs.Flush();
}
retVal = iSecondConnection->DeviceMessageCount();
TEST(retVal==count);
if (retVal!=count)
INFO_PRINTF3(_L("(iSecondConnection->DeviceMessageCount() return value - Expected: %d, Actual: %d"),count ,retVal);
if (enable)
iSecondConnection->EnableMessages();
if (disable)
iSecondConnection->DisableMessages();
TheClient->iScreen->SetScreenMode(mode);
TheClient->iWs.Flush();
iSubState++;
break;
case 105:
/**
@SYMTestCaseID GRAPHICS-WSERV-0524
*/
((CTScrModeStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0524"));
buf.Format(TRefByValue<const TDesC>(_L("Screen mode %d:%d")),101,iSubState);
INFO_PRINTF1(buf);
checkWindowParam=EFalse;
count=2;
enable=ETrue;
if (iCurEnforcement==ESizeEnforcementPixelsAndRotation)
count+=3;
else if (iCurEnforcement==ESizeEnforcementPixelsTwipsAndRotation)
count+=6;
if (iSecondConnection->DeviceMessageCount()!=count)
{
TLogMessageText buf;
_LIT(KFailCount,"Event Mismatch, Exp=%d, Act=%d");
buf.Format(KFailCount,count,iSecondConnection->DeviceMessageCount());
TheClient->iWs.LogMessage(buf);
TheClient->iWs.Flush();
}
retVal = iSecondConnection->DeviceMessageCount();
TEST(retVal==count);
if (retVal!=count)
INFO_PRINTF3(_L("(iSecondConnection->DeviceMessageCount() return value - Expected: %d, Actual: %d"),count ,retVal);
CheckWindows(iCurEnforcement==ESizeEnforcementNone?ETrue:checkWindowParam);
if (enable)
iSecondConnection->EnableMessages();
if (disable)
iSecondConnection->DisableMessages();
TheClient->iScreen->SetScreenMode(mode);
TheClient->iWs.Flush();
iSecondConnection->DisableMessages();
if (iCurEnforcement==ESizeEnforcementNone)
{ // Do it again with different enforcement mode
SetScreenModeEnforcement(ESizeEnforcementPixelsAndRotation);
ResetCounter(100);
}
else if (iCurEnforcement==ESizeEnforcementPixelsAndRotation)
{ // Do it again with different enforcement mode
SetScreenModeEnforcement(ESizeEnforcementPixelsTwipsAndRotation);
ResetCounter(100);
}
else
{
SetScreenModeEnforcement(ESizeEnforcementNone);
delete iSecondConnection;
iSecondConnection=NULL;
}
TheClient->iWs.Flush();
break;
/**
@SYMTestCaseID GRAPHICS-WSERV-0302
@SYMDEF DEF099638
@SYMTestCaseDesc Test that a drawing can be scaled while different screen
modes are set
@SYMTestPriority High
@SYMTestStatus Implemented
@SYMTestActions Set different screen modes and scale a drawing
@SYMTestExpectedResults The drawing is redrawn to scale
*/
case 110:
{
((CTScrModeStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0302"));
// Ensure that the TestWin and BaseWin will be drawn properly in all screen modes
SetScreenModeEnforcement(ESizeEnforcementPixelsAndRotation);
TheClient->SetTestClientScreenMode(0);
INFO_PRINTF1(_L("Scaled drawing - screen mode 0"));
ScaledDrawingL();
TheClient->SetTestClientScreenMode(1);
INFO_PRINTF1(_L("Scaled drawing - screen mode 1"));
ScaledDrawingL();
// Restore screen mode and enforcement mode
TheClient->SetTestClientScreenMode(0);
SetScreenModeEnforcement(iOldEnfMode);
break;
}
/**
@SYMTestCaseID GRAPHICS-WSERV-0303
@SYMDEF DEF081259
@SYMTestCaseDesc Test screen mode and rotation panic messages
@SYMTestPriority High
@SYMTestStatus Implemented
@SYMTestActions Test the panics fro screen mode and rotation respond as
expected
@SYMTestExpectedResults Panics respond as expected
*/
case 111:
((CTScrModeStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0303"));
INFO_PRINTF1(_L("Panic"));
TestPanicsL();
break;
#endif
/**
@SYMTestCaseID GRAPHICS-WSERV-0304
@SYMDEF DEF081259
@SYMTestCaseDesc Test that if there are invisible windows and then the
screen mode is changed, the windows are redrawn correctly
@SYMTestPriority High
@SYMTestStatus Implemented
@SYMTestActions Create some windows, make some invisible, change the screen
mode and redraw the windows
@SYMTestExpectedResults The windows are redrawn without error
*/
case 112:
((CTScrModeStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0304"));
INFO_PRINTF1(_L("Invisible Wnds And Infinite Redraw Bugs")); // two defects one problem
InvisibleWndAndInfiniteRedrawBugL();
break;
/**
@SYMTestCaseID GRAPHICS-WSERV-0358
@SYMDEF PDEF096151
@SYMTestCaseDesc Ensure that wserv does not panic when calling CWsScreenDevice::SetScreenMode()
after a client has deleted a screen device used by an active group window
@SYMTestPriority Critical
@SYMTestStatus Implemented
@SYMTestActions Creates a RWsSession
Creates a primary screen device
Creates another screen device
Creates a group window
Gets all the valid screen modes
Deletes the primary screen device
Calls SetScreenMode on the second screen device
(this step triggered the defect - panicking wserv)
Cleans up the above
@SYMTestExpectedResults The call to SetScreenMode should not cause wserv to panic
*/
case 113:
((CTScrModeStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0358"));
INFO_PRINTF1(_L("Set screen mode after a client has deleted the screen device"));
SetScreenModeAfterScreenDeviceDeletedL();
break;
case 114:
INFO_PRINTF1(_L("Rotate/screen mode test"));
/**
@SYMTestCaseID GRAPHICS-WSERV-0525
*/
((CTScrModeStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0525"));
TestRotateAndScreenModeL();
break;
default:
((CTScrModeStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);
if (iTest->iState==115 || iTest->iState>1000)
TestComplete();
break;
}
((CTScrModeStep*)iStep)->RecordTestResultL();
}
//
// CSecondConnection
//
CSecondConnection::~CSecondConnection()
{
delete iWindow;
delete iWindow2;
iGroup->GroupWin()->EnableReceiptOfFocus(EFalse); // Stop auto group switching on close
delete iGroup;
delete iClient;
}
void CSecondConnection::ConstructL(TInt aScreenNumber,const TRect &aWinRect, CTestBase *aTest, CTestStep* aTestStep)
{
iClient=new(ELeave) CTClient;
iClient->SetScreenNumber(aScreenNumber);
iClient->ConstructL();
iGroup=new(ELeave) CSecondConnectionGroup(iClient,this,aTest,aTestStep);
iGroup->ConstructL();
//
iWindow=new(ELeave) CTBlankWindow;
iWindow->ConstructL(*iGroup);
iWindow->BaseWin()->SetShadowDisabled(ETrue);
iWindow->SetColor(TRgb::Gray4(1));
TPoint offset=BaseWin->BaseWin()->InquireOffset((*iGroup->GroupWin()));
iWindow->SetExtL(offset+aWinRect.iTl,aWinRect.Size());
iWindow->Activate();
//
iWindow2=new(ELeave) CTBlankWindow;
iWindow2->ConstructL(*iGroup);
iWindow2->BaseWin()->SetShadowDisabled(ETrue);
iWindow2->SetColor(TRgb::Gray4(1));
TPoint offset2=TestWin->BaseWin()->InquireOffset((*iGroup->GroupWin()));
iWindow2->SetExtL(offset2+aWinRect.iTl,aWinRect.Size());
iWindow2->BaseWin()->SetVisible(EFalse);
iWindow2->Activate();
}
void CSecondConnection::SetWindow2Visibility(TBool aVisible)
{
iWindow2->BaseWin()->SetVisible(aVisible);
iClient->iWs.Flush();
iClient->iWs.Finish();
}
void CSecondConnection::EnableMessages()
{
iGroup->GroupWin()->EnableScreenChangeEvents();
iClient->iWs.Flush();
}
void CSecondConnection::DisableMessages()
{
iGroup->GroupWin()->DisableScreenChangeEvents();
iClient->iWs.Flush();
}
TInt CSecondConnection::DeviceMessageCount() const
{
return(iMessageCount);
}
void CSecondConnection::ScreenDeviceChanged()
{
iMessageCount++;
}
//
// CSecondConnectionGroup
//
CSecondConnectionGroup::CSecondConnectionGroup(CTClient *aClient, CSecondConnection *aSecondConnection, CTestBase *aTest, CTestStep* aTestStep) : CTWindowGroup(aClient), iTest(aTest), iSecondConnection(aSecondConnection), iTestStep(aTestStep)
{}
void CSecondConnectionGroup::ScreenDeviceChanged()
{
iSecondConnection->ScreenDeviceChanged();
TPixelsTwipsAndRotation sar;
Client()->iScreen->GetDefaultScreenSizeAndRotation(sar);
Client()->iScreen->SetScreenSizeAndRotation(sar);
//
iTestStep->TEST(Client()->iScreen->SizeInPixels()==sar.iPixelSize);
iTestStep->TEST(Client()->iScreen->SizeInTwips()==sar.iTwipsSize);
TSize pixelConv;
pixelConv.iWidth=Client()->iScreen->HorizontalTwipsToPixels(sar.iTwipsSize.iWidth);
pixelConv.iHeight=Client()->iScreen->VerticalTwipsToPixels(sar.iTwipsSize.iHeight);
iTestStep->TEST(pixelConv==sar.iPixelSize);
}
//
// SecondClientConnection
//
SecondClientConnection::SecondClientConnection()
{
}
SecondClientConnection::~SecondClientConnection()
{
}
void SecondClientConnection::ConstructL(TInt aScreenMode, const TPixelsTwipsAndRotation& aSizeAndRotation)
{
CTClient::ConstructL();
iGroup=new(ELeave) TestWindowGroup(this);
iGroup->ConstructL();
iScreen->SetScreenModeEnforcement(ESizeEnforcementPixelsAndRotation);
iScreen->SetScreenSizeAndRotation(aSizeAndRotation);
iScreen->SetScreenMode(aScreenMode);
}
__WS_CONSTRUCT_STEP__(ScrMode)