diff -r 000000000000 -r 5d03bc08d59c windowing/windowserver/tauto/TREDRAW.CPP --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/windowing/windowserver/tauto/TREDRAW.CPP Tue Feb 02 01:47:50 2010 +0200 @@ -0,0 +1,1586 @@ +// Copyright (c) 1996-2009 Nokia Corporation and/or its subsidiary(-ies). +// All rights reserved. +// This component and the accompanying materials are made available +// under the terms of "Eclipse Public License v1.0" +// which accompanies this distribution, and is available +// at the URL "http://www.eclipse.org/legal/epl-v10.html". +// +// Initial Contributors: +// Nokia Corporation - initial contribution. +// +// Contributors: +// +// Description: +// Window redraw/validate/invalidate tests +// +// + +/** + @file + @test + @internalComponent - Internal Symbian test code +*/ + +#include "TREDRAW.H" + +LOCAL_D TSize FullScreenModeSize; + +const TRgb KRed = TRgb(255,0,0); +const TRgb KBlack = TRgb(0,0,0); +const TRgb KWhite = TRgb(255,255,255); +const TRgb KTransBisque = TRgb(255,228,196,128); +const TRgb KTransLightSalmon = TRgb(255,160,122,128); +const TRgb KLightSteelBlue = TRgb(176,196,222); +const TRgb KCadetBlue = TRgb(95,158,160); + +TInt CTRedrawOrderWindow::iRedrawNumber=0; + +#define InvalidRegionLogging +#if defined(InvalidRegionLogging) +#define BLOG_MESSAGE(p) (const_cast(&iGraphicsTest))->LogMessage(((TText8*)__FILE__), __LINE__,(p)) +#endif + +// +// // +// + +CTCheckDefectWin* CTCheckDefectWin::NewL(TPoint aPos,TSize aWinSize) + { + CTCheckDefectWin* win=new(ELeave) CTCheckDefectWin; + win->ConstructExtLD(*TheClient->iGroup,aPos,aWinSize); + win->BaseWin()->SetRequiredDisplayMode(EColor256); + win->AssignGC(*TheClient->iGc); + win->BaseWin()->SetShadowDisabled(ETrue); + win->BaseWin()->SetShadowHeight(0); + TheClient->Flush(); + return win; + } + +CRedrawWindow::CRedrawWindow(CTRedrawTest *aTest) : CTWin(), iTest(aTest) + { + } + +CRedrawWindow::~CRedrawWindow() + { + iInvalid.Close(); + } + +void CRedrawWindow::Draw() + { + ReceivedDrawRequest(); + DrawPattern(iTest->WinContent()); + } + +void CRedrawWindow::ReceivedDrawRequest() + { + iDrawRequests++; + } + +TInt CRedrawWindow::DrawRequests() const + { + return iDrawRequests; + } + +void CRedrawWindow::DrawPattern(TInt aPattern) + { + iGc->Clear(); + TPoint drawBase(-10,-20); + TSize drawSize(iSize.iWidth-2*drawBase.iX,iSize.iHeight-2*drawBase.iY); + TPoint offset=drawBase+iOffset; + switch(aPattern) + { + case EDrawGraphPaperlHatched: + { + iGc->DrawRect(TRect(drawBase,drawBase+drawSize)); + iGc->SetPenColor(TRgb(85,85,85)); + iGc->SetDrawMode(CGraphicsContext::EDrawModeXOR); + TInt xpos; + for(xpos=0;xposDrawLine(TPoint(xpos,0)+offset,TPoint(xpos,drawSize.iHeight)+offset); + TInt ypos; + for(ypos=0;yposDrawLine(TPoint(0,ypos)+offset,TPoint(drawSize.iWidth,ypos)+offset); + break; + } + case EDrawSlantingHatched: + { + iGc->SetPenColor(TRgb(255,255,255)); + iGc->SetDrawMode(CGraphicsContext::EDrawModeXOR); + for(TInt xpos=0;xposDrawLine(TPoint(xpos,0)+offset,TPoint(drawSize.iWidth,xpos*drawSize.iHeight/drawSize.iWidth)+offset); + iGc->DrawLine(TPoint(xpos,0)+offset,TPoint(0,drawSize.iHeight-xpos*drawSize.iHeight/drawSize.iWidth)+offset); + iGc->DrawLine(TPoint(xpos,drawSize.iHeight)+offset,TPoint(drawSize.iWidth,drawSize.iHeight-xpos*drawSize.iHeight/drawSize.iWidth)+offset); + iGc->DrawLine(TPoint(xpos,drawSize.iHeight)+offset,TPoint(0,xpos*drawSize.iHeight/drawSize.iWidth)+offset); + } + } + break; + case EDrawCenteredRectangle: + { + TRect rect(5,iSize.iHeight/4,iSize.iWidth-5,iSize.iHeight/2); + iGc->SetDrawMode(CGraphicsContext::EDrawModeXOR); + iGc->SetPenColor(TRgb(255,255,255)); + iGc->DrawRect(rect); + } + break; + default: + // Other pattern values requested are ignored + break; + } + } + +void CRedrawWindow::Reset() + { + iOffset=TPoint(0,0); + iWin.Invalidate(); + iInvalid.Clear(); + } + +/** + * Calculate the window region minus the region covered by the child + * window; this is the "visible region" + */ +void CRedrawWindow::VisibleRegion(RRegion &aRegion) + { + aRegion.Clear(); + aRegion.AddRect(TRect(Size())); + TRect child; + child.iTl=Child()->BaseWin()->InquireOffset(iWin); + child.iBr=child.iTl+Child()->Size(); + aRegion.SubRect(child); + } + + +void CRedrawWindow::ValidateAndClear() + { + Win()->Invalidate(); + Win()->BeginRedraw(); + iGc->Activate(*Win()); + iGc->Clear(); + iGc->Deactivate(); + Win()->EndRedraw(); + } + +void CRedrawWindow::ActivateAndDraw(TInt aPattern, TRegion *aRegion) + { + iGc->Activate(*Win()); + if (aRegion) + iGc->SetClippingRegion(*aRegion); + DrawPattern(aPattern); + iGc->Deactivate(); + } + +CReferenceComparisonRedrawWindow::CReferenceComparisonRedrawWindow(CTRedrawTest *aTest) : CRedrawWindow(aTest) + {} + +/** + * Prepare the invalid region. + * + * Update the invalid region with a rectangle where such a rectangle is minus + * any area covered by a child window. + * + * @param aRect Rectangle to be added to the invalid region + */ +void CReferenceComparisonRedrawWindow::PrepareInvalidation(const TRect &aRect) + { + RRegion clipped_visible; + VisibleRegion(clipped_visible); + clipped_visible.ClipRect(aRect); + iInvalid.Union(clipped_visible); + clipped_visible.Close(); + iInvalid.Tidy(); + } + +/** + * Mop up all pending invalid regions and simulate a Draw(). + * + * Normally, we would rely on WServ to call this window's Draw() method + * to obtain drawing operations to cover the currently invalid regions + * of the window. + * + * This method does that task by marking all invalid regions as clean and + * then performs the drawing required in the invalid portions of the screen. + * + * The purpose of this is to then allow a comparison to be made against a + * different window which does rely on the WServ framework calling back + * to do a Draw(). + * + * @post the window has no outstanding invalid regions + */ +void CReferenceComparisonRedrawWindow::PerformInvalidation() + { + for(TInt index=0;indexActivate(iWin); + iGc->SetClippingRegion(iInvalid); + DrawPattern(iTest->WinContent()); + iGc->Deactivate(); + iWin.EndRedraw(); + } + +CRedrawWindow2::CRedrawWindow2(CTRedrawTest *aTest) : CRedrawWindow(aTest) + { + } + +void CRedrawWindow2::Draw() + { + ReceivedDrawRequest(); + if (iClipped) + iGc->SetClippingRegion(iInvalid); + DrawPattern(iTest->WinContent()); + if (iClipped) + iGc->CancelClippingRegion(); + } + +/** + * Prepare the invalid region. + * @param aRect rectangle to be added to the invalid region + */ +void CRedrawWindow2::PrepareInvalidation(const TRect &aRect) + { + iInvalid.Clear(); + iInvalid.AddRect(aRect); + } + +/** + * Perform invalidation by setting the window's invalid region. + * + * The purpose of this method is to stimulate a call from WServ to the + * Draw() method of this class. + */ +void CRedrawWindow2::PerformInvalidation() + { + iWin.Invalidate(iInvalid.BoundingRect()); + } + +void CRedrawWindow2::Reset() + { + CRedrawWindow::Reset(); + iClipped=EFalse; + } + +CRedrawWindow3::CRedrawWindow3(CTRedrawTest *aTest) : CRedrawWindow(aTest) + { + } + +void CRedrawWindow3::Draw() + { + ReceivedDrawRequest(); + iGc->Clear(); + iGc->SetPenStyle(CGraphicsContext::ENullPen); + iGc->SetBrushStyle(CGraphicsContext::ESolidBrush); + iGc->SetBrushColor(TRgb(0,255,255)); + iGc->DrawRect(TRect(TPoint(0,0),TSize(50,50))); + } + +void CRedrawWindow3::PrepareInvalidation(const TRect &aRect) + { + iInvalid.Clear(); + iInvalid.AddRect(aRect); + } + +void CRedrawWindow3::PerformInvalidation() + { + iWin.Invalidate(iInvalid.BoundingRect()); + } + +void CRedrawWindow3::SetUp1L(TPoint pos,TSize size,CTWinBase *parent, CWindowGc &aGc) + { + ConstructL(*parent); + SetExtL(pos,size); + AssignGC(aGc); + } + +void CRedrawWindow3::Redraw(const TRect &aRect) + { + if(!isActive) + {//make an empty redraw + iWin.BeginRedraw(aRect); + iWin.EndRedraw(); + } + else + { + CTWin::Redraw(aRect); + } + } + +void CRedrawWindow3::Activate() + { + isActive = ETrue; + Win()->Activate(); + } + +// + +CTRedrawOrderWindow::CTRedrawOrderWindow(TInt aOrder, CTRedrawTest *aTest) : iTest(aTest), iOrder(aOrder) + {} + +CTRedrawOrderWindow* CTRedrawOrderWindow::NewLC(TInt aOrder,CTWinBase* aParent,const TPoint& aPos,const TSize& aSize,CTRedrawTest* aTest) + { + CTRedrawOrderWindow* self=new(ELeave) CTRedrawOrderWindow(aOrder,aTest); + CleanupStack::PushL(self); + self->SetUpL(aPos,aSize,aParent,*TheGc); + return self; + } + +void CTRedrawOrderWindow::Draw() + { + iGc->SetBrushColor(TRgb::Gray16(iOrder*2)); + iGc->Clear(); + } + +void CTRedrawOrderWindow::ResetRedrawNumber() + { + iRedrawNumber=0; + } + +void CTRedrawOrderWindow::Redraw(const TRect &aRect) + { + if (++iRedrawNumber!=iOrder) + iTest->Failed(iOrder); + CTWin::Redraw(aRect); + } + +// + +TInt DestructCallback(TAny *aParam) + { + ((CTRedrawTest *)aParam)->doDestruct(); + return(0); + } + +CTRedrawTest::CTRedrawTest(CTestStep* aStep): + CTWsGraphicsBase(aStep)//, iInvalidRegionChecker(*this) + {} + +void CTRedrawTest::doDestruct() + { + BaseWin->SetVisible(ETrue); + TestWin->SetVisible(ETrue); + delete iBaseRedrawWin; + delete iTestRedrawWin; + delete iBaseChildWin; + delete iTestChildWin; + } + +CTRedrawTest::~CTRedrawTest() + { + TCallBack callBack(DestructCallback,this); + TheClient->SetRedrawCancelFunction(callBack); + delete iInvalidRegionChecker; + } + +void CTRedrawTest::ConstructL() + { +#if defined(InvalidRegionLogging) + LOG_MESSAGE(_L(" CTRedrawTest::ConstructL()")); + LOG_MESSAGE4(_L(" Ex Wins 0x%08x, 0x%08x, 0x%08x"), BaseWin, TestWin, &(TheClient->StdLogWindow())); +#endif + + iInvalidRegionChecker = new(ELeave)CInvalidRegionChecker(*this); + User::LeaveIfError(iInvalidRegionChecker->AddExcludedWindow(BaseWin)); + User::LeaveIfError(iInvalidRegionChecker->AddExcludedWindow(TestWin)); + User::LeaveIfError(iInvalidRegionChecker->AddExcludedWindow(&(TheClient->StdLogWindow()))); + WaitForRedrawsToFinish(ECheckRedrawActiveObjectAndInvalidRegions); + + iWinContent=0; + BaseWin->SetVisible(EFalse); + TestWin->SetVisible(EFalse); + FullScreenModeSize=TheClient->iGroup->Size(); + TInt winWidth=(FullScreenModeSize.iWidth/3)-10; + TInt winHeight=FullScreenModeSize.iHeight-10; + iBaseRedrawWin=new(ELeave) CReferenceComparisonRedrawWindow(this); + iBaseRedrawWin->SetUpL(TPoint(FullScreenModeSize.iWidth/3+5,5),TSize(winWidth,winHeight),TheClient->iGroup,*TheClient->iGc); + iTestRedrawWin=new(ELeave) CRedrawWindow2(this); + iTestRedrawWin->SetUpL(TPoint(FullScreenModeSize.iWidth/3*2+5,5),TSize(winWidth,winHeight),TheClient->iGroup,*TheClient->iGc); + iBaseChildWin=new(ELeave) CBlankWindow(); + iBaseChildWin->SetUpL(TPoint(winWidth>>2,winHeight>>2),TSize(winWidth>>1,winHeight>>1),iBaseRedrawWin,*TheClient->iGc); + iTestChildWin=new(ELeave) CBlankWindow(); + iTestChildWin->SetUpL(TPoint(winWidth>>2,winHeight>>2),TSize(winWidth>>1,winHeight>>1),iTestRedrawWin,*TheClient->iGc); + +#if defined(InvalidRegionLogging) + LOG_MESSAGE5(_L(" In Wins %08x, %08x, %08x, %08x"), iBaseRedrawWin, iBaseChildWin, iTestRedrawWin, iTestChildWin); +#endif + + WaitForRedrawsToFinish(ECheckRedrawActiveObjectAndInvalidRegions); + +#if defined(InvalidRegionLogging) + LOG_MESSAGE(_L(" Done")); +#endif + } + +void CTRedrawTest::CheckRedrawWindows() + { + _LIT(KTest,"Redraw Test, SubTest %d "); + TBuf<64> buf; + buf.Format(KTest,iTest->iState); + CheckRect(iBaseRedrawWin,iTestRedrawWin,TRect(iBaseRedrawWin->Size()),buf); + } + +void CTRedrawTest::InvalidateTestWins(const TRect &aRect) + { + iBaseRedrawWin->PrepareInvalidation(aRect); + iTestRedrawWin->PrepareInvalidation(aRect); + iBaseRedrawWin->PerformInvalidation(); + iTestRedrawWin->PerformInvalidation(); + } + +inline TInt CTRedrawTest::WinContent() + { + return iWinContent; + } + +void CTRedrawTest::SetBackground(const TRgb &aRgb) + { + iBaseRedrawWin->iWin.SetBackgroundColor(aRgb); + iTestRedrawWin->iWin.SetBackgroundColor(aRgb); + } + +void CTRedrawTest::DumpRegion(const TRegion &aRegion) + { + _LIT(KLog,"RegionRect %d: (%d,%d,%d,%d)"); + for (TInt ii=0;iiiWin.Position(); + TSize screenSize=TheClient->iGroup->Size(); + iBaseRedrawWin->iWin.Invalidate(); + iTestRedrawWin->iWin.Invalidate(); + iTestRedrawWin->iWin.SetPosition(TPoint(10,10)); + iTestRedrawWin->iWin.SetPosition(TPoint(0,0)); + iTestRedrawWin->iWin.SetPosition(TPoint(-10,-10)); + iTestRedrawWin->iWin.SetPosition(TPoint(screenSize.iWidth-10,screenSize.iHeight-10)); + iTestRedrawWin->iWin.SetPosition(TPoint(screenSize.iWidth,screenSize.iHeight)); + iTestRedrawWin->iWin.SetPosition(TPoint(screenSize.iWidth+10,screenSize.iHeight+10)); + iTestRedrawWin->iWin.SetPosition(old); + RRegion baseInvalidRegion; + RRegion testInvalidRegion; + iBaseRedrawWin->iWin.GetInvalidRegion(baseInvalidRegion); + iTestRedrawWin->iWin.GetInvalidRegion(testInvalidRegion); + CompareRegionsL(baseInvalidRegion,testInvalidRegion); + baseInvalidRegion.Close(); + testInvalidRegion.Close(); + } + +void CTRedrawTest::GetInvalidRegionTestsL() + { + TSize stdWinSize(iTest->StdTestWindowSize()); + CArrayFixFlat* rectList=new(ELeave) CArrayFixFlat(3); + rectList->AppendL(TRect(1,1,5,2)); + rectList->AppendL(TRect(stdWinSize.iWidth>>1,stdWinSize.iHeight>>1,stdWinSize.iWidth,stdWinSize.iHeight)); + rectList->AppendL(TRect(2,0,4,5)); + TestGetInvalidRegionL(rectList); + rectList->Reset(); + rectList->AppendL(TRect(-1000,-1,10000,5)); + rectList->AppendL(TRect(0,0,stdWinSize.iWidth>>1,stdWinSize.iHeight>>1)); + rectList->AppendL(TRect(2,100,2*stdWinSize.iWidth,105)); + TestGetInvalidRegionL(rectList); + delete rectList; + } + +void CTRedrawTest::TestGetInvalidRegionL(const CArrayFixFlat *aRectList) + { + RRegion invalidRegion; + RRegion region; + iTestRedrawWin->iWin.BeginRedraw(); + iTestRedrawWin->iWin.EndRedraw(); + for (TInt index=0;indexCount();index++) + { + iTestRedrawWin->iWin.Invalidate((*aRectList)[index]); + region.AddRect((*aRectList)[index]); + } + //Currently WSERV includes areas under a child or other window in the invalid region + //This is arguable the incorrect thing to do + /*TRect subRect; + subRect.iTl=iTestChildWin->BaseWin()->InquireOffset(iTestRedrawWin->iWin); + subRect.SetSize(iTestChildWin->Size()); + region.SubRect(subRect);*/ + region.ClipRect(TRect(iTestRedrawWin->Size())); + iTestRedrawWin->iWin.GetInvalidRegion(invalidRegion); + CompareRegionsL(region,invalidRegion); + region.Close(); + invalidRegion.Close(); + } + +void CTRedrawTest::Failed(TInt aOrder) + { + _LIT(KLog,"Redraw Order Error, Window Drawn at Position %d should be drawn at Position %d"); + LOG_MESSAGE3(KLog,CTRedrawOrderWindow::RedrawNumber(),aOrder); + if (iRedrawNo==0) + iRedrawNo=CTRedrawOrderWindow::RedrawNumber(); + } + +void CTRedrawTest::CheckOrderL() + { + _LIT(KLog,"Fail in redraw order test, first position of error is %d"); + iRedrawNo=0; + CTRedrawOrderWindow* order1; + CTRedrawOrderWindow* order2; + CTRedrawOrderWindow* order3; + CTRedrawOrderWindow* order4; + CTRedrawOrderWindow* order5; + CTRedrawOrderWindow* order6; + CTRedrawOrderWindow* order7; + order6=CTRedrawOrderWindow::NewLC(6,TheClient->iGroup,TPoint(100,10),TSize(40,40),this); + order7=CTRedrawOrderWindow::NewLC(7,order6,TPoint(0,0),TSize(20,20),this); + order1=CTRedrawOrderWindow::NewLC(1,TheClient->iGroup,TPoint(10,10),TSize(60,40),this); + order4=CTRedrawOrderWindow::NewLC(4,order1,TPoint(20,0),TSize(20,40),this); + order5=CTRedrawOrderWindow::NewLC(5,order4,TPoint(0,0),TSize(20,20),this); + order2=CTRedrawOrderWindow::NewLC(2,order1,TPoint(0,0),TSize(20,40),this); + order3=CTRedrawOrderWindow::NewLC(3,order2,TPoint(0,0),TSize(20,20),this); + TheClient->iWs.Finish(); // Fix for DEF133199 - Intermittant failure with windows out of order + WaitForRedrawsToFinish(ECheckRedrawActiveObjectAndInvalidRegions); // Check order is correct after initial creation + TEST(order1!=NULL && order2!=NULL && order3!=NULL && order4!=NULL && order5!=NULL && order6!=NULL && order7!=NULL); // redundant check to shut up the compiler + TEST(iRedrawNo==0); + if (iRedrawNo>0) + LOG_MESSAGE2(KLog,iRedrawNo); + + CTRedrawOrderWindow::ResetRedrawNumber(); + iRedrawNo=0; + CTUser::Splat(TheClient,TRect(0,0,200,60),TRgb(0,0,0)); + TheClient->iWs.Flush(); + WaitForRedrawsToFinish(ECheckRedrawActiveObjectAndInvalidRegions); // Check it's still correct on subsequent redraws + TEST(iRedrawNo==0); + if (iRedrawNo>0) + LOG_MESSAGE2(KLog,iRedrawNo); + CTRedrawOrderWindow::ResetRedrawNumber(); + CleanupStack::PopAndDestroy(7,order6); + } + +// For reproducing INC049554 +void CTRedrawTest::CheckDefectINC049554L() + { + if(TransparencySupportedL() == KErrNotSupported) //the defect only happens when transparency enabled + return; + TSize screenSize=TheClient->iScreen->SizeInPixels(); + TPoint winPos(screenSize.iWidth/3,0); + TSize winSize(screenSize.iWidth/3,screenSize.iHeight); + CTCheckDefectWin* lowerWin=CTCheckDefectWin::NewL(winPos,winSize); + CleanupStack::PushL(lowerWin); + lowerWin->Activate(); + TheClient->Flush(); + WaitForRedrawsToFinish(ECheckRedrawActiveObjectAndInvalidRegions); + + winPos.iX+=screenSize.iWidth/12; + + CTCheckDefectWin* upperWin=CTCheckDefectWin::NewL(winPos,winSize); + CleanupStack::PushL(upperWin); + upperWin->Activate(); + TheClient->Flush(); + WaitForRedrawsToFinish(ECheckRedrawActiveObjectAndInvalidRegions); + + // Invalidate the lower win and while drawing its content, move top window + lowerWin->Invalidate(); + lowerWin->Win()->BeginRedraw(); + TheClient->iGc->Activate(*lowerWin->DrawableWin()); + TheClient->iGc->SetPenStyle(CGraphicsContext::ENullPen); + TheClient->iGc->SetBrushStyle(CGraphicsContext::ESolidBrush); + TheClient->iGc->SetBrushColor(TRgb(0,255,0)); + TheClient->iGc->DrawRect(TRect(TPoint(0,0),TSize(50,50))); + + winPos.iX+=screenSize.iWidth/12; + upperWin->SetExt(winPos,winSize); + + TheClient->iGc->SetBrushColor(TRgb(255,0,0)); + TheClient->iGc->DrawRect(TRect(TPoint(0,0),TSize(50,50))); + TheClient->iGc->Deactivate(); + lowerWin->Win()->EndRedraw(); + + TheClient->Flush(); + WaitForRedrawsToFinish(ECheckRedrawActiveObjectAndInvalidRegions); + + CleanupStack::PopAndDestroy(upperWin); + + // Create 2 transaprent windows, slightly over lapping the background window + winPos.iX=screenSize.iWidth/3; + TPoint winPosTop(winPos.iX-screenSize.iWidth/6,0); + TSize winSizeTop(screenSize.iWidth/3+screenSize.iWidth/6,screenSize.iHeight/2); + + CTCheckDefectWin* leftWin=CTCheckDefectWin::NewL(winPosTop,winSizeTop); + CleanupStack::PushL(leftWin); + leftWin->Win()->SetTransparencyAlphaChannel(); + leftWin->Win()->SetBackgroundColor(TRgb(0,0,0, 128)); + leftWin->Activate(); + TheClient->iWs.Finish(); + WaitForRedrawsToFinish(ECheckRedrawActiveObjectAndInvalidRegions); + + CTCheckDefectWin* rightWin=CTCheckDefectWin::NewL(winPos,winSizeTop); + CleanupStack::PushL(rightWin); + rightWin->Win()->SetTransparencyAlphaChannel(); + rightWin->Win()->SetBackgroundColor(TRgb(0,0,0, 128)); + rightWin->Activate(); + TheClient->iWs.Finish(); + WaitForRedrawsToFinish(ECheckRedrawActiveObjectAndInvalidRegions); + + lowerWin->Invalidate(); + lowerWin->Win()->BeginRedraw(); + TheClient->iGc->Activate(*lowerWin->DrawableWin()); + TheClient->iGc->SetPenStyle(CGraphicsContext::ENullPen); + TheClient->iGc->SetBrushStyle(CGraphicsContext::ESolidBrush); + TheClient->iGc->SetBrushColor(TRgb(0,255,0)); + TheClient->iGc->DrawRect(TRect(TPoint(0,0),TSize(50,50))); + + TheClient->iGc->SetBrushColor(TRgb(255,0,0)); + TheClient->iGc->DrawRect(TRect(TPoint(0,0),TSize(50,50))); + TheClient->iGc->Deactivate(); + lowerWin->Win()->EndRedraw(); + + TheClient->iWs.Finish(); + WaitForRedrawsToFinish(ECheckRedrawActiveObjectAndInvalidRegions); + + CleanupStack::PopAndDestroy(3,lowerWin); + } + + +TInt myKK=1; +_LIT(KSnap,"c:\\TestRect%2i.mbm"); +_LIT(KSnapE,"c:\\TestRect%2iErr.mbm"); +void CTRedrawTest::TestRect() + { + + TBuf<50> snapshotFileName; + snapshotFileName.Zero(); + CFbsBitmap *snapshot=new(ELeave) CFbsBitmap(); + CleanupStack::PushL(snapshot); + User::LeaveIfError(snapshot->Create(TheClient->iScreen->SizeInPixels(),TheClient->iScreen->DisplayMode())); + + User::LeaveIfError(TheClient->iScreen->CopyScreenToBitmap(snapshot)); + + TRect rect1=TRect(TPoint(),TSize(FullScreenModeSize.iWidth/2,FullScreenModeSize.iHeight)); + TRect rect2=TRect(TPoint(FullScreenModeSize.iWidth/2,0),TSize(FullScreenModeSize.iWidth/2,FullScreenModeSize.iHeight)); + TBool retVal = TheClient->iScreen->RectCompare(rect1,rect2); + + RDebug::Printf("Picture %i !!!: Rect1: (%i,%i)->(%i,%i) - Rect2: (%i,%i)->(%i,%i)",myKK, + rect1.iTl.iX,rect1.iTl.iY,rect1.iBr.iX,rect1.iBr.iY, + rect2.iTl.iX,rect2.iTl.iY,rect2.iBr.iX,rect2.iBr.iY); + + + if (retVal) + { + snapshotFileName.Format(KSnap,myKK); + } + else + { + snapshotFileName.Format(KSnapE,myKK); + } + snapshot->Save(snapshotFileName); + CleanupStack::PopAndDestroy(snapshot); + myKK++; + + + + TEST(retVal); + if(!retVal) + INFO_PRINTF3(_L("TheClient->iScreen->RectCompare() return value - Expected: %d, Actual: %d"), ETrue, retVal); + } + +void CTRedrawTest::ConstructAndSetBlankWinLC(RBlankWindow& aWindow, TSize aSize, TPoint aPoint/*=TPoint()*/, + TRgb aBackgroundColor/*=TRgb(0,0,0)*/) + { + User::LeaveIfError(aWindow.Construct(*TheClient->iGroup->GroupWin(), ENullWsHandle)); + CleanupClosePushL(aWindow); + aWindow.SetExtent(aPoint, aSize); + aWindow.SetColor(aBackgroundColor); + aWindow.Activate(); + } + +void CTRedrawTest::ConstructWindowLC(RWindow& aWindow, TSize aSize, TPoint aPoint/*=TPoint()*/, + TRgb aBackgroundColor/*=TRgb(255,255,255)*/, TBool aTransparencyByAlpha/*=EFalse*/, + TDisplayMode aDisplayMode/*=EColor64K*/) + { + User::LeaveIfError(aWindow.Construct(*TheClient->iGroup->GroupWin(), ENullWsHandle)); + CleanupClosePushL(aWindow); + aWindow.SetExtent(aPoint,aSize); + aWindow.SetBackgroundColor(aBackgroundColor); + aWindow.SetRequiredDisplayMode(aDisplayMode); + if (aTransparencyByAlpha) + { + aWindow.SetTransparencyAlphaChannel(); + } + aWindow.Activate(); + } + +void CTRedrawTest::ActivateAndSetGc(CWindowGc& aGc, RWindow& aWindow, CGraphicsContext::TBrushStyle aBrushStyle/*=CGraphicsContext::ESolidBrush*/, TRgb aBrushColor/*=TRgb(0,0,0)*/, + CGraphicsContext::TPenStyle aPenStyle/*=CGraphicsContext::ENullPen*/, TRgb aPenColor/*=TRgb(0,0,0)*/) + { + aGc.Activate(aWindow); + aGc.Reset(); + aGc.SetBrushStyle(aBrushStyle); + aGc.SetBrushColor(aBrushColor); + aGc.SetPenStyle(aPenStyle); + aGc.SetPenColor(aPenColor); + } + +void CTRedrawTest::DrawWin(CWindowGc& aGc, RWindow& aWin, TSize aWinSize, TRgb aRectColor1, TRgb aRectColor2, TInt aNewOrdinalPos/*=0*/, RWindow* aWinToMove/*=NULL*/, TBool aDrawAllPixels/*=EFalse*/) + { + const TUint startX = 10; + const TUint endX = aWinSize.iWidth - startX; + const TUint startY = 10; + const TUint sHeight = (aWinSize.iHeight >> 1) - startY; + ActivateAndSetGc(aGc,aWin); + aWin.BeginRedraw(); + if(aDrawAllPixels) + { + aGc.SetBrushColor(KWhite); + aGc.DrawRect(TRect(aWinSize)); + } + aGc.SetBrushColor(aRectColor1); + aGc.DrawRect(TRect(startX, startY, endX, sHeight)); + if (aWinToMove) + { + aWinToMove->SetOrdinalPosition(aNewOrdinalPos); + TheClient->iWs.Finish(); + } + aGc.SetBrushColor(aRectColor2); + aGc.DrawRect(TRect(startX, sHeight + startY, endX, aWinSize.iHeight - startY)); + aWin.EndRedraw(); + aGc.Deactivate(); + } + +void CTRedrawTest::CheckOrdinalPositionDefectL() + { + if(TransparencySupportedL() == KErrNotSupported) //the defect only happens when transparency enabled + { + return; + } + + const TRgb KTransWinColor = TRgb(0,0,255,128); + const TUint hWidth = FullScreenModeSize.iWidth >> 1; + const TSize windowSize = TSize(hWidth,FullScreenModeSize.iHeight); + const TPoint rightWinStartPt = TPoint(hWidth,0); + + // A Blank Window to clear the screen. + // It is required to clear all the pixels on the screen. + RBlankWindow clrWin(TheClient->iWs); + ConstructAndSetBlankWinLC(clrWin, FullScreenModeSize); + + // Transparent window + RWindow winLeftT(TheClient->iWs); + ConstructWindowLC(winLeftT, windowSize, TPoint(), KTransWinColor,ETrue); + + CWindowGc& gc = *(TheClient->iGc); + // Draw the Transparent Window (winLeftT) on the Left side + DrawWin(gc, winLeftT, windowSize, KTransBisque, KTransLightSalmon); + + // Invisible window + RWindow winRightI(TheClient->iWs); + User::LeaveIfError(winRightI.Construct(*TheClient->iGroup->GroupWin(), ENullWsHandle)); + CleanupClosePushL(winRightI); + winRightI.SetExtent(rightWinStartPt, windowSize); + winRightI.SetVisible(EFalse); + winRightI.Activate(); + + // Transparent window + RWindow winRightT(TheClient->iWs); + ConstructWindowLC(winRightT, windowSize, rightWinStartPt, KTransWinColor,ETrue); + + // Draw the Transparent Window (winRightT) on the Right side and change the + // Ordinal Position for Invisible Window (winRightI) to move it front + // to the Transparent Window. + // Invisible window is behind the Transparent Window + + DrawWin(gc, winRightT, windowSize, KTransBisque, KTransLightSalmon, 0, &winRightI); // Move winRightI to Front of winRightT + TestRect(); + + CleanupStack::PopAndDestroy(4, &clrWin); + } + +// For reproducing PDEF099892 +void CTRedrawTest::CheckDefectPDEF099892L() + { + if(TransparencySupportedL() == KErrNotSupported) //the defect only happens when transparency enabled + { + return; + } + + const TRgb KTransWinColor = TRgb(0,0,255,128); + const TUint hWidth = FullScreenModeSize.iWidth >> 1; + const TUint hHeight = FullScreenModeSize.iHeight >> 1; + const TSize windowSize = TSize(hWidth,FullScreenModeSize.iHeight); + const TSize transWinSize = TSize(hWidth,hHeight + 10); + const TPoint rightWinStartPt = TPoint(hWidth,0); + + // A Blank Window to clear the screen. + // It is required to clear all the pixels on the screen. + RBlankWindow clrWin(TheClient->iWs); + ConstructAndSetBlankWinLC(clrWin, FullScreenModeSize); + + // Create an Opaque and a Transparent Window and Draw them on the + // Left Side of the Screen. Opaque Window is Behind the Transparent Window. + + // Opaque Window + RWindow winLeftOpq(TheClient->iWs); + ConstructWindowLC(winLeftOpq, windowSize, TPoint(), KRed); + + // Transparent window + RWindow winLeftT(TheClient->iWs); + ConstructWindowLC(winLeftT, transWinSize, TPoint(), KTransWinColor, ETrue); + + CWindowGc& gc = *(TheClient->iGc); + // Draw the transparent Window (winLeftT) on the Left side + DrawWin(gc, winLeftT, transWinSize, KTransBisque, KTransLightSalmon); + + // Draw the Opaque Window (winLeftOpq) on the Left side + DrawWin(gc, winLeftOpq, windowSize, KLightSteelBlue, KCadetBlue, 0, NULL, ETrue); + + // Create an Invisible, an Opaque and a Transparent Window and Draw them on the + // Right Side of the Screen. Invisible Window is Behind the Opaque Window and + // Opaque Window is Behind the Transparent Window. + // While drawing the Transparent Window, move the Invisible Window to the Front of Opaque Window. + // And while Drawing the Opaque Window move the Invisible Window again Behind the Opaque Window. + + // Invisible window + RWindow winRightI(TheClient->iWs); + User::LeaveIfError(winRightI.Construct(*TheClient->iGroup->GroupWin(), ENullWsHandle)); + CleanupClosePushL(winRightI); + winRightI.SetExtent(rightWinStartPt, windowSize); + winRightI.SetVisible(EFalse); + winRightI.Activate(); + + // Opaque Window + RWindow winRightOpq(TheClient->iWs); + ConstructWindowLC(winRightOpq, windowSize, rightWinStartPt, KRed); + + // Transparent window + RWindow winRightT(TheClient->iWs); + ConstructWindowLC(winRightT, transWinSize, rightWinStartPt, KTransWinColor, ETrue); + + // Draw the transparent Window (winRightT) on the Right side + DrawWin(gc, winRightT, transWinSize, KTransBisque, KTransLightSalmon, 1, &winRightI ); + + // Draw the Opaque Window (winRightOpq) on the Right side + DrawWin(gc, winRightOpq, windowSize, KLightSteelBlue, KCadetBlue, 2, &winRightI, ETrue); + + // Compare the Left and Right side Rectangles + TestRect(); + + CleanupStack::PopAndDestroy(6, &clrWin); + } + +void CTRedrawTest::CheckMMSDefectL(TBool aMoveBlankWindow) + { + if(TransparencySupportedL() == KErrNotSupported) //the defect only happens when transparency enabled + { + return; + } + + const TRgb KTransWinColor = TRgb(0,0,255,128); + const TUint hWidth = FullScreenModeSize.iWidth >> 1; + const TUint hHeight = FullScreenModeSize.iHeight >> 1; + const TSize windowSize = TSize(hWidth,FullScreenModeSize.iHeight); + const TSize transWinSize = TSize(hWidth - 20,hHeight + 10); + const TPoint rightWinStartPt = TPoint(hWidth,0); + + // A Blank Window to clear the screen. + // It is required to clear all the pixels on the screen. + RBlankWindow clrWin(TheClient->iWs); + ConstructAndSetBlankWinLC(clrWin, FullScreenModeSize); + + // Create an Opaque and a Transparent Window and Draw them on the + // Left Side of the Screen. Opaque Window is Behind the Transparent Window. + + // Opaque Window + RWindow winLeftOpq(TheClient->iWs); + ConstructWindowLC(winLeftOpq, windowSize, TPoint(), KRed); + CWindowGc& gc = *(TheClient->iGc); + // Draw the Opaque Window (winLeftOpq) on the Left side + DrawWin(gc, winLeftOpq, windowSize, KLightSteelBlue, KCadetBlue, 0, NULL, ETrue); + + // Another Window - A Blank Window + RBlankWindow winLeftBlank(TheClient->iWs); + ConstructAndSetBlankWinLC(winLeftBlank, TSize(100,100), TPoint(20,20), TRgb(128,128,128)); + + // Transparent window + RWindow winLeftT(TheClient->iWs); + ConstructWindowLC(winLeftT, transWinSize, TPoint(10, 10), KTransWinColor, ETrue); + // Draw the Transparent Window (winLeftT) on the Left side + DrawWin(gc, winLeftT, transWinSize, KTransBisque, KTransLightSalmon); + + // Invisible window + RWindow winRightI(TheClient->iWs); + User::LeaveIfError(winRightI.Construct(*TheClient->iGroup->GroupWin(), ENullWsHandle)); + CleanupClosePushL(winRightI); + winRightI.SetExtent(rightWinStartPt, windowSize); + winRightI.SetVisible(EFalse); + winRightI.Activate(); + + // Opaque Window + RWindow winRightOpq(TheClient->iWs); + ConstructWindowLC(winRightOpq, windowSize, rightWinStartPt, KRed); + + // Draw the Opaque Window (winRightOpq) on the Right side + DrawWin(gc, winRightOpq, windowSize, KLightSteelBlue, KCadetBlue, 0, NULL, ETrue); + + // Another Window - A Blank Window + RBlankWindow winRightBlank(TheClient->iWs); + ConstructAndSetBlankWinLC(winRightBlank, TSize(100,100), rightWinStartPt + TPoint(20,20), TRgb(128,128,128)); + + // Transparent window + RWindow winRightT(TheClient->iWs); + ConstructWindowLC(winRightT, transWinSize, rightWinStartPt + TPoint(10,10), KTransWinColor, ETrue); + + if (aMoveBlankWindow) + { + winRightBlank.SetOrdinalPosition(0); // Move the Blank Window to the front of the Transparent Window + TheClient->iWs.Finish(); + } + // Draw the transparent Window (winRightT) on the Right side + DrawWin(gc, winRightT, transWinSize, KTransBisque, KTransLightSalmon, 2, &winRightI); + if (aMoveBlankWindow) + { + winRightBlank.SetOrdinalPosition(1); // Move the Blank Window back to behind the Transparent Window + TheClient->iWs.Finish(); + } + TestRect(); + + DrawWin(gc, winRightT, transWinSize, KTransBisque, KTransLightSalmon, 0, &winRightI); + TestRect(); // if aMoveBlankWindow is ETrue then this will test the Defect PDEF099892 + + // Rest of the lines are just to check other possibilities. + // But,currently, they are not affecting the result. + // i.e. the DrawWin() functions called after this line will draw the same thing + // as it was drawn for the DrawWin() called just before this line. + DrawWin(gc, winRightT, transWinSize, KTransBisque, KTransLightSalmon, 1, &winRightI); + TestRect(); + + DrawWin(gc, winRightT, transWinSize, KTransBisque, KTransLightSalmon, 0, &winRightI); + TestRect(); + + DrawWin(gc, winRightT, transWinSize, KTransBisque, KTransLightSalmon, 2, &winRightI); + TestRect(); + + DrawWin(gc, winRightT, transWinSize, KTransBisque, KTransLightSalmon, 1, &winRightI); + TestRect(); + + DrawWin(gc, winRightT, transWinSize, KTransBisque, KTransLightSalmon, 3, &winRightI); + TestRect(); + + CleanupStack::PopAndDestroy(8, &clrWin); + } + +/** + +The test window is receiving a draw request before it activates, +doing an empty redraw, then activating itself, and drawing itself properly in +response to the next redraw request. + +Without the fix the next redraw request will not be received and it will be drawn blank. +*/ +void CTRedrawTest::CheckDefectPDEF117784L() + { + TSize winSize = BaseWin->Size(); + + TInt winWidth=(FullScreenModeSize.iWidth/3)-10; + TInt winHeight=FullScreenModeSize.iHeight-10; + + CRedrawWindow3* baseRedrawWin = new(ELeave) CRedrawWindow3(this); + CleanupStack::PushL(baseRedrawWin); + TPoint ptBase = TPoint(FullScreenModeSize.iWidth/3*2+5,5); + baseRedrawWin->SetUp1L(ptBase,TSize(winWidth,winHeight),TheClient->iGroup,*TheClient->iGc); + baseRedrawWin->SetVisible(ETrue); + baseRedrawWin->Activate(); + + CRedrawWindow3* testRedrawWin = new(ELeave) CRedrawWindow3(this); + CleanupStack::PushL(testRedrawWin); + TPoint ptTest = TPoint(FullScreenModeSize.iWidth/3+5,5); + testRedrawWin->SetUp1L(ptTest,TSize(winWidth,winHeight),TheClient->iGroup,*TheClient->iGc); + testRedrawWin->SetVisible(ETrue); + testRedrawWin->Activate(); + + TheClient->iWs.Finish(); + User::LeaveIfError(iInvalidRegionChecker->AddExcludedWindow(testRedrawWin)); + TBool retVal = WaitForRedrawsToFinish(ECheckRedrawActiveObjectAndInvalidRegions); + TEST(retVal == KErrNone); + if(retVal != KErrNone) + { + ERR_PRINTF2(_L("CTRedrawTest::WaitForRedrawsToFinish failed with error: %d"), retVal); + } + iInvalidRegionChecker->RemoveExcludedWindow(testRedrawWin); + + TheClient->iWs.Finish(); + retVal = WaitForRedrawsToFinish(ECheckRedrawActiveObjectAndInvalidRegions); + TEST(retVal == KErrNone); + if(retVal != KErrNone) + { + ERR_PRINTF2(_L("CTRedrawTest::WaitForRedrawsToFinish failed with error: %d"), retVal); + } + + retVal = TheClient->iScreen->RectCompare(TRect(TPoint(ptBase),TSize(winWidth,winHeight)),TRect(TPoint(ptTest),TSize(winWidth,winHeight))); + TEST(retVal); + if(!retVal) + { + ERR_PRINTF1(_L("New activated window has lost redraw request")); + } + + CleanupStack::PopAndDestroy(2, baseRedrawWin); + } + +CInvalidRegionChecker::CInvalidRegionChecker(const CTRedrawTest& aGraphicsTest) + : iGraphicsTest(aGraphicsTest) + {} + +CInvalidRegionChecker::~CInvalidRegionChecker() + { + iExcludedWindowArray.Close(); + } + +TInt CInvalidRegionChecker::AddExcludedWindow(const CTWinBase* aExcludedWindow) + { + TInt error = KErrNone; + const CTWinBase** emptySlot = NULL; + for(TInt win=iExcludedWindowArray.Count()-1; win>=0; win--) + { + if(iExcludedWindowArray[win]==aExcludedWindow) + { + // window is already excluded, we don't want to add it twice + return error; + } + if(!emptySlot && iExcludedWindowArray[win]==NULL) + { + emptySlot = &iExcludedWindowArray[win]; + } + } + + if(emptySlot) + { + // re-use the emptyslot + *emptySlot=aExcludedWindow; // re-use the element + } + else + { + // no empty elements re-used, so add a new one + error = iExcludedWindowArray.Append(aExcludedWindow); + } + return error; + }; + +void CInvalidRegionChecker::RemoveExcludedWindow(const CTWinBase* aExcludedWindow) + { + if(iExcludedWindowArray.Count()) + { + for(TInt win=iExcludedWindowArray.Count()-1; win>=0; win--) + { + if(iExcludedWindowArray[win]==aExcludedWindow) + { + iExcludedWindowArray[win]=NULL; // Not worth deleting the array element, just mark it as NULL + return; + } + } + } + }; + +TBool CInvalidRegionChecker::ExcludedWindow(const CTWinBase* aWin) const + { + for(TInt win=iExcludedWindowArray.Count()-1; win>=0; win--) + { + if(aWin == iExcludedWindowArray[win]) + { +#if defined(InvalidRegionLogging) + { + _LIT(KText, " Excluded Window %08x"); + TLogMessageText buf; + buf.Format(KText, aWin); + BLOG_MESSAGE(buf); + } +#endif + return ETrue; + } + } + return EFalse; + } + +void CInvalidRegionChecker::ProcessWindow(const CTWinBase* aTWinBase) + { +#if defined(InvalidRegionLogging) + { + _LIT(KText, " ProcessWindow %08x %d - Child(%08x), Next(%08x), Prev(%08x)"); + TLogMessageText buf; + buf.Format(KText, aTWinBase, iInvalidRegionCount, aTWinBase->Child(), aTWinBase->NextSibling(), aTWinBase->PrevSibling()); + BLOG_MESSAGE(buf); + } +#endif + + if(aTWinBase && !ExcludedWindow(aTWinBase)) + { + RRegion invalidRegion; + static_cast(aTWinBase)->Win()->GetInvalidRegion(invalidRegion); + iInvalidRegionCount += invalidRegion.Count(); + +#if defined(InvalidRegionLogging) + if(invalidRegion.Count()) + { + _LIT(KText, " IR Found for %08x %d"); + TLogMessageText buf; + buf.Format(KText, aTWinBase, invalidRegion.Count()); + BLOG_MESSAGE(buf); + } +#endif + + invalidRegion.Close(); + + if(0==iInvalidRegionCount) + { + ProcessChildWindow(aTWinBase->Child()); + } + } + } + +void CInvalidRegionChecker::ProcessChildWindow(const CTWinBase* aTWinBase) + { + if(aTWinBase) + { + // get the first sibling window + const CTWinBase *sibling=aTWinBase; + const CTWinBase *prevSibling=sibling->PrevSibling(); + while(prevSibling) + { + sibling=prevSibling; + prevSibling=sibling->PrevSibling(); + } + // process all siblings inc. self + while(sibling && (0==iInvalidRegionCount)) + { + ProcessWindow(sibling); + sibling=sibling->NextSibling(); + } + } + } + + +void CInvalidRegionChecker::ProcessWindowGroup(const CTWinBase* aTWinBase) + { + if(aTWinBase && !ExcludedWindow(aTWinBase)) + { + ProcessChildWindow(aTWinBase->Child()); + } + } + +TInt CInvalidRegionChecker::CheckInvalidRegions(const CTWindowGroup* aGroup) + { + iInvalidRegionCount=0; + ProcessWindowGroup(aGroup); +#if defined(InvalidRegionLogging) + { + _LIT(KText, " CheckInvalidRegions %d"); + TLogMessageText buf; + buf.Format(KText, iInvalidRegionCount); + BLOG_MESSAGE(buf); + } +#endif + return iInvalidRegionCount; + } + +TInt CTRedrawTest::WaitForRedrawsToFinish(TRedrawCheckType aRedrawCheckType) + { + TInt error=KErrNone; +#define EnableCheckInvalidRegions +#if defined(EnableCheckInvalidRegions) + if(aRedrawCheckType == ECheckRedrawActiveObjectAndInvalidRegions) + { + TInt regions = 0; + TInt count = 0; + //We do not want to cycle round forever or too long, a limit of 10 has + //been added but this is arbitrary. If CTClient::WaitForRedrawsToFinish + //fails too many times then possibly something else us wrong. + do + { + count++; + error = TheClient->WaitForRedrawsToFinish(); + if(error != KErrNone) + { + RDebug::Printf("CTRedrawTest::WaitForRedrawsToFinish, error %d", error); + } + regions = iInvalidRegionChecker->CheckInvalidRegions(TheClient->iGroup); + if(regions) + { + // Give the server a chance to do the redraws because + // the Animation Scheduler is an idle priority AO + const TUint KOneSecond = 1000000; // us + User::After(KOneSecond>>2); // 0.25s + } + } while (0 < regions && 10 < count); + } + else // ECheckRedrawActiveObjectOnly +#endif // CheckInvalidRegions + { + error = TheClient->WaitForRedrawsToFinish(); + } + return error; + } + +void CTRedrawTest::RunTestCaseL(TInt /*aCurTestCase*/) + { + _LIT(Redraw0,"Redraw1"); + _LIT(Redraw1,"Redraw2"); + _LIT(Redraw2,"GetInvalid"); + _LIT(Redraw3,"MoveInvalid"); + _LIT(Redraw4,"CheckOrder"); + _LIT(Redraw5,"Defect 49554"); + _LIT(Redraw6,"Check Ordinal Position"); + _LIT(Redraw7,"Defect 99892"); + _LIT(Redraw8,"Check MMS Defect 1"); + _LIT(Redraw9,"Check MMS Defect 2"); + _LIT(Redraw10,"Redraw inactive window"); + ((CTRedrawTestStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName); + + TInt testWindowDraws = -1; // to prevent RVCT 546-D warning + _LIT(KLog,"RunTestCase %d"); + if (++iTest->iState<6) + LOG_MESSAGE2(KLog,iTest->iState); + switch(iTest->iState) + { +/** +@SYMTestCaseID GRAPHICS-WSERV-0265 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc Test invalidation a test window and check it + redraws correctly + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Invalidate a test window causing it to redraw + +@SYMTestExpectedResults The test window redraws correctly +*/ + case 1: + ((CTRedrawTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0265")); + iTest->LogSubTest(Redraw0); + SetBackground(TRgb::Gray256(128)); + iDrawRequestsFromTestWindow=iTestRedrawWin->DrawRequests(); + InvalidateTestWins(TRect(10,10,50,50)); + break; + case 2: + ((CTRedrawTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0265")); + TheClient->iWs.Finish(); + WaitForRedrawsToFinish(ECheckRedrawActiveObjectAndInvalidRegions); + testWindowDraws=iTestRedrawWin->DrawRequests(); + if (iDrawRequestsFromTestWindow+1!=testWindowDraws) + { + LOG_MESSAGE3(_L("wrong number of test window draw requests %d %d"), + iDrawRequestsFromTestWindow, + testWindowDraws); + TEST(EFalse); + } + CheckRedrawWindows(); + ++iWinContent; + iTestRedrawWin->Reset(); + iBaseRedrawWin->Reset(); + TheClient->Flush(); + WaitForRedrawsToFinish(ECheckRedrawActiveObjectAndInvalidRegions); + break; +/** +@SYMTestCaseID GRAPHICS-WSERV-0266 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc Test invalidation a test window and check it + redraws correctly + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Invalidate a test window causing it to redraw + +@SYMTestExpectedResults The test window redraws correctly +*/ + case 3: + ((CTRedrawTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0266")); + iTest->LogSubTest(Redraw1); + InvalidateTestWins(TRect(1,1,150,20)); + TheClient->iWs.Finish(); + WaitForRedrawsToFinish(ECheckRedrawActiveObjectAndInvalidRegions); + break; + case 4: + ((CTRedrawTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0266")); + CheckRedrawWindows(); + ++iWinContent; + iTestRedrawWin->Reset(); + iBaseRedrawWin->Reset(); + TheClient->iWs.Flush(); + break; +/** +@SYMTestCaseID GRAPHICS-WSERV-0267 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc Test invalidation a region of a test window and check it + redraws correctly + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Invalidate a region of a test window causing it to redraw + +@SYMTestExpectedResults The test window redraws correctly +*/ + case 5: + ((CTRedrawTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0267")); + iTest->LogSubTest(Redraw2); + GetInvalidRegionTestsL(); + break; +/** +@SYMTestCaseID GRAPHICS-WSERV-0268 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc Test moving an invalid region of a test window and check it + redraws correctly + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Move an invalid region of a test window causing it to redraw + +@SYMTestExpectedResults The test window redraws correctly +*/ + case 6: + ((CTRedrawTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0268")); + iTest->LogSubTest(Redraw3); + MoveInvalidAreaL(); + break; + +/** +@SYMTestCaseID GRAPHICS-WSERV-0270 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc Test the order redraws occur in a test window + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Set up a number of redraws for a test window and + invalidate it + +@SYMTestExpectedResults The order the test window redraws occur is correct +*/ + + case 7: + ((CTRedrawTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0270")); + iTest->LogSubTest(Redraw4); + CheckOrderL(); + break; +/** +@SYMTestCaseID GRAPHICS-WSERV-0271 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc Test defect INC049554L does not occur + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Check that defect INC049554L does not occur when a test + window is redrawn + +@SYMTestExpectedResults Defect INC049554L does not occur +*/ + case 8: + ((CTRedrawTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0271")); + iTest->LogSubTest(Redraw5); + CheckDefectINC049554L(); + break; +/** + @SYMTestCaseID GRAPHICS-WSERV-0359 + + @SYMDEF PDEF099892 + + @SYMTestCaseDesc Ensure that changing the Ordinal postion of an Invisible Window + does not affect the Transparent Window or Opaque Window redrawing. + + @SYMTestPriority Medium + + @SYMTestStatus Implemented + + @SYMTestActions Create an Invisible Window + Create a Transparent Window + Inside the Begin and End Redraw for the Transparent Window, + change the Ordinal Position for Invisible Window to move it + front to the Transparent Window. + + @SYMTestExpectedResults Changing the Ordinal postion for Invisible Window should not + affect the Transparent Window redrawing. +*/ + case 9: + ((CTRedrawTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0359")); + iTest->LogSubTest(Redraw6); + CheckOrdinalPositionDefectL(); + break; +/** + @SYMTestCaseID GRAPHICS-WSERV-0360 + + @SYMDEF PDEF099892 + + @SYMTestCaseDesc Ensure that changing the Ordinal postion of an Invisible window + does not affect the Transparent Window or Opaque Window redrawing. + + @SYMTestPriority Medium + + @SYMTestStatus Implemented + + @SYMTestActions Create an Invisible Window + Create an Opaque Window + Create a Transparent Window + Invisible Window is Behind the Opaque Window + and Opaque Window is Behind the Transparent Window. + While drawing the Transparent Window, move the Invisible Window + to the Front of Opaque Window. And while Drawing the Opaque Window + move the Invisible Window again Behind the Opaque Window. + + @SYMTestExpectedResults Changing the Ordinal postion for Invisible window should not + affect the Transparent Window or Opaque Window redrawing. +*/ + case 10: + ((CTRedrawTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0360")); + iTest->LogSubTest(Redraw7); + CheckDefectPDEF099892L(); + break; +/** + @SYMTestCaseID GRAPHICS-WSERV-0361 + + @SYMDEF DEF101548 + + @SYMTestCaseDesc Ensure that changing the Ordinal postion of an Invisible window + does not affect the Transparent Window redrawing. + + @SYMTestPriority Low + + @SYMTestStatus Implemented + + @SYMTestActions Create an Invisible Window + Create an Opaque Window + Create a Blank Window + Create a Transparent Window + Invisible Window is Behind the Opaque Window + Opaque Window is Behind the Blank Window + and Blank Window is Behind the Transparent Window. + While drawing the Transparent Window, move the Invisible Window + to the Front/Back to one or all the Other Windows. + Also move the Blank Window Front/Back to the Transparent Window for other scenario. + + @SYMTestExpectedResults Changing the Ordinal postion for Invisible window should not + affect the Transparent Window redrawing. +*/ + case 11: + ((CTRedrawTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0361")); + iTest->LogSubTest(Redraw8); + CheckMMSDefectL(EFalse); + case 12: + ((CTRedrawTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0361")); + iTest->LogSubTest(Redraw9); + CheckMMSDefectL(ETrue);// In this case we will move Blank Window Front/Back to the Transparent Window to Test Defect PDEF099892 + break; + case 13: + iTest->LogSubTest(Redraw10); +/** + @SYMTestCaseID GRAPHICS-WSERV-0362 + + @SYMDEF PDEF117784 + + @SYMTestCaseDesc Ensure that drawing request for non active window will not + impact following redrawings + + @SYMTestPriority High + + @SYMTestStatus Implemented + + + @SYMTestActions Create test window as in active + Create base window in active mode. + + The test window is receiving a draw request before it activates, + doing an empty redraw, + Activate test window + Draw test window properly in response to the next redraw request. + + @SYMTestExpectedResults The next redraw request will be received and it will be drawn correctly. +*/ + ((CTRedrawTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0362")); + CheckDefectPDEF117784L(); + break; + case 14: + ((CTRedrawTestStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName); + ((CTRedrawTestStep*)iStep)->CloseTMSGraphicsStep(); + TestComplete(); + break; + default: + TEST(EFalse); + } + ((CTRedrawTestStep*)iStep)->RecordTestResultL(); + } + +__WS_CONSTRUCT_STEP__(RedrawTest)