--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/windowing/windowserver/tauto/TREDRSTR.CPP Tue Feb 02 01:47:50 2010 +0200
@@ -0,0 +1,3947 @@
+// 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 redraw storing
+// Tests Storing the Redraw command mechanism in the window server.
+// The first time a window is redrawn its commands are stored. When
+// the window needs to be redrawn, the stored commands will be used
+// rather than issue a redraw request to the client.
+// The principle behind this test is to do lots of different types of drawing to a window,
+// invalidate the window and test that no redrawing occurred, instead the stored commands
+// should be used to generate the content of the window.
+//
+//
+
+/**
+ @file
+ @test
+ @internalComponent - Internal Symbian test code
+*/
+
+#include "TREDRSTR.H"
+#include "colorblender.h"
+
+//#define LOGGING on
+
+_LIT(KColorUnmatchedFormat, "Check failed, expected color value: 0x%08x, got: 0x%08x");
+#define TEST_COLOR_MATCH(aExpected, aActual) \
+ TEST(aExpected == aActual); \
+ if(aExpected != aActual) \
+ LOG_MESSAGE3(KColorUnmatchedFormat, aExpected.Value(), aActual.Value())
+
+/*CPartialRedrawWin*/
+void CPartialRedrawWin::Init()
+ {
+ iClientDrawn = EFalse;
+ iClientCanDraw = ETrue;
+ Win()->SetRequiredDisplayMode(EColor16MA);
+ Win()->SetTransparencyAlphaChannel();
+ Win()->SetBackgroundColor(TRgb(127,127,127,0));
+ }
+
+void CPartialRedrawWin::Draw()
+ {
+ DoDraw(*iGc);
+ }
+
+void CPartialRedrawWin::DrawToBmp(CGraphicsContext& aGc)
+ {
+ DoDraw(aGc);
+ }
+
+void CPartialRedrawWin::DoDraw(CGraphicsContext& aGc)
+ {
+ if(!iClientCanDraw) return;
+ iClientDrawn = ETrue;
+ CPartialRedrawWin::DrawRects(aGc, iSize, TPoint(0,0), ETrue, EPartialRedraw_Unknown);
+ }
+
+/*static*/
+void CPartialRedrawWin::DrawRects(CGraphicsContext& aGc, TSize aSize, TPoint aPosition,
+ TBool aIsFullRedraw, TPartialRedrawType aPartialRedrawType)
+ {
+ aGc.SetPenStyle(CGraphicsContext::ESolidPen);
+ aGc.SetPenColor(TRgb::Gray256(0));
+ aGc.SetBrushStyle(CGraphicsContext::ESolidBrush);
+ if(aIsFullRedraw)
+ {
+ aGc.SetBrushColor(TRgb(200,200,200,127));
+ aGc.DrawRect(TRect(aPosition, aSize));
+ }
+ else if (aPartialRedrawType!=EPartialRedraw_PreserveStoredCmds)
+ {
+ aGc.SetBrushColor(TRgb(200,200,200,127)); // same color as original background.
+ aGc.SetPenStyle(CGraphicsContext::ENullPen);
+ aGc.DrawRect(TRect(TPoint(10,10) + aPosition, aSize - TSize(20,20)));
+ aGc.SetPenStyle(CGraphicsContext::ESolidPen);
+ aGc.SetPenColor(TRgb::Gray256(0));
+ }
+ TSize r1 = TSize(aSize.iWidth/3, aSize.iHeight/5);
+ TSize r2 = TSize(aSize.iWidth/9, 2*aSize.iHeight/3);
+ aGc.SetBrushColor(TRgb(255, 0, 0, 127));
+ aGc.DrawEllipse(TRect(TPoint(aSize.iWidth/3, aSize.iHeight/5)+aPosition, r1));
+ aGc.SetBrushColor(TRgb(0, 255, 0, 127));
+ aGc.DrawEllipse(TRect(TPoint(aSize.iWidth/3, 3*aSize.iHeight/5)+aPosition, r1));
+ aGc.SetBrushColor(TRgb(0, 0, 255, 127));
+ aGc.DrawEllipse(TRect(TPoint(4*aSize.iWidth/9, aSize.iHeight/6)+aPosition, r2));
+ }
+
+void CPartialRedrawWin::DrawPartial(TPartialRedrawType aPartialRedrawType)
+ {
+ TRect rect = TRect(TPoint(10,10), iSize - TSize(20,20));
+ Invalidate(rect);
+ Win()->BeginRedraw(rect);
+ iGc->Activate(*Win());
+ CPartialRedrawWin::DrawRects(*iGc, iSize, TPoint(0,0), EFalse, aPartialRedrawType);
+ iGc->Deactivate();
+ Win()->EndRedraw();
+ }
+void CPartialRedrawWin::RedrawSubRectWithBitmapL(TRgb aBitmapColour)
+ {
+ TInt bitmapWidth = Win()->Size().iWidth - 20;
+ TInt bitmapHeight = Win()->Size().iHeight - 20;
+ TSize bitmapSize(bitmapWidth, bitmapHeight);
+
+ CFbsBitmap* fbsBitmap = new(ELeave) CFbsBitmap();
+ CleanupStack::PushL(fbsBitmap);
+ User::LeaveIfError(fbsBitmap->Create(bitmapSize, EColor16MU));
+
+ // ensure colour is opaque
+ aBitmapColour.SetAlpha(255);
+
+ // draw on the bitmap
+ TBitmapUtil bmpUtil(fbsBitmap);
+ bmpUtil.Begin(TPoint(0, 0));
+ TInt row, col;
+ for(row = 0; row < bitmapWidth; ++row)
+ {
+ bmpUtil.SetPos(TPoint(row, 0));
+ for(col = 0; col < bitmapHeight; ++col)
+ { // diagonal stripes
+ if ( ((col + row) % 8) < 4 )
+ { // colour
+ bmpUtil.SetPixel(aBitmapColour.Color16M());
+ }
+ else
+ { // semi-transparent white
+ TRgb white(255, 255, 255, 128);
+ bmpUtil.SetPixel(white.Color16M());
+ }
+ bmpUtil.IncYPos();
+ }
+ }
+ bmpUtil.End();
+
+ // send bitmap to screen
+ TRect rect = TRect(TPoint(10,10), bitmapSize);
+ Invalidate(rect);
+ Win()->BeginRedraw(rect);
+ iGc->Activate(*Win());
+ iGc->DrawBitmap(rect, fbsBitmap);
+ iGc->Deactivate();
+ Win()->EndRedraw();
+ CleanupStack::PopAndDestroy(fbsBitmap);
+ }
+
+/* CResetRedrawStoreWin */
+
+const TInt KResetRedrawMaxAnimState=4;
+
+void CResetRedrawStoreWin::PreSetSize(const TSize &aSize)
+// Sets the size variable so draw code using it will use the new size
+// before the window has actually been resized
+ {
+ iSize=aSize;
+ }
+
+void CResetRedrawStoreWin::Draw()
+ {
+ DoDraw(*iGc);
+ }
+
+void CResetRedrawStoreWin::DoDraw(CGraphicsContext& aGc) const
+ {
+ aGc.SetPenStyle(CGraphicsContext::ESolidPen);
+ aGc.SetPenColor(KRgbBlack);
+ aGc.SetBrushStyle(CGraphicsContext::ESolidBrush);
+ aGc.SetBrushColor(TRgb(200,200,200,127));
+ aGc.DrawRect(TRect(iSize));
+ TSize r1(iSize.iWidth/3, iSize.iHeight/5);
+ TSize r2(iSize.iWidth/9, 2*iSize.iHeight/3);
+ aGc.SetBrushColor(TRgb(255, 0, 0, 127));
+ aGc.DrawEllipse(TRect(TPoint(iSize.iWidth/3, iSize.iHeight/5), r1));
+ aGc.SetBrushColor(TRgb(0, 255, 0, 127));
+ aGc.DrawEllipse(TRect(TPoint(iSize.iWidth/3, 3*iSize.iHeight/5), r1));
+ aGc.SetBrushColor(TRgb(0, 0, 255, 127));
+ aGc.DrawEllipse(TRect(TPoint(4*iSize.iWidth/9, iSize.iHeight/6), r2));
+ DoDrawAnim(aGc);
+ }
+
+TRect CResetRedrawStoreWin::AnimRect() const
+ {
+ if (iUpdateInRedraw)
+ {
+ TInt row=iAnimState/iSize.iWidth;
+ TInt col=iAnimState-row*iSize.iWidth;
+ return(TRect(col,row,col+4,row+4));
+ }
+ return(TRect(iSize.iWidth/6,iSize.iHeight/4,iSize.iWidth*5/6,iSize.iHeight*3/4));
+ }
+
+void CResetRedrawStoreWin::DoDrawAnim(CGraphicsContext& aGc) const
+ {
+ if (iAnimState>0)
+ {
+ aGc.SetBrushColor(KRgbBlue);
+ aGc.SetPenStyle(CGraphicsContext::ENullPen);
+ aGc.SetBrushStyle(CGraphicsContext::ESolidBrush);
+ TInt animColState=iAnimState%KResetRedrawMaxAnimState;
+ TRgb animCol(255*animColState/KResetRedrawMaxAnimState,0,255*(KResetRedrawMaxAnimState-animColState)/KResetRedrawMaxAnimState);
+ aGc.SetBrushColor(animCol);
+ aGc.DrawRect(AnimRect());
+ }
+ }
+
+CResetRedrawStoreWin::~CResetRedrawStoreWin()
+ {
+ delete iExtraGc;
+ }
+
+void CResetRedrawStoreWin::SetUpdateInRedraw(TBool aUpdateInRedraw)
+ {
+ iUpdateInRedraw=aUpdateInRedraw;
+ }
+
+void CResetRedrawStoreWin::SetKeepGcActive(TBool aState)
+ {
+ if (iKeepGcActive!=aState)
+ {
+ iKeepGcActive=aState;
+ if (iKeepGcActive)
+ {
+ iExtraGc=new(ELeave) CWindowGc(TheClient->iScreen);
+ iExtraGc->Construct();
+ iExtraGc->Activate(*Win());
+ }
+ else
+ {
+ iExtraGc->Deactivate();
+ delete iExtraGc;
+ iExtraGc=NULL;
+ }
+ }
+ }
+
+TBool CResetRedrawStoreWin::Failed() const
+ {
+ return iFailed;
+ }
+
+void CResetRedrawStoreWin::UpdateAnim(TInt aSteps)
+ {
+ TRect oldAnimRect(AnimRect());
+ iAnimState+=aSteps;
+ if (iUpdateInRedraw)
+ {
+ if (iAnimState>=(iSize.iWidth*iSize.iHeight))
+ {
+ iFailed=ETrue;
+ }
+ }
+ else if (iAnimState>KResetRedrawMaxAnimState)
+ {
+ iAnimState-=KResetRedrawMaxAnimState;
+ }
+ CWindowGc *gc=Gc();
+ if (iUpdateInRedraw)
+ {
+ Win()->Invalidate(oldAnimRect);
+ Win()->BeginRedraw(oldAnimRect);
+ if (iKeepGcActive)
+ {
+ DoDraw(*iExtraGc);
+ }
+ else
+ {
+ gc->Activate(*Win());
+ DoDraw(*gc);
+ gc->Deactivate();
+ }
+ Win()->EndRedraw();
+ TRect animRect=AnimRect();
+ Win()->Invalidate(animRect);
+ Win()->BeginRedraw(animRect);
+ }
+ if (iKeepGcActive)
+ DoDrawAnim(*iExtraGc);
+ else
+ {
+ gc->Activate(*Win());
+ DoDrawAnim(*gc);
+ gc->Deactivate();
+ }
+ if (iUpdateInRedraw)
+ Win()->EndRedraw();
+ }
+
+void CTRedrawStoring::GetTestWinSizeAndPos(TInt aWinIndex, TPoint& aPos, TSize& aSize) const
+ {
+ switch(aWinIndex)
+ {
+ case 0:
+ // Centered window half the width of the parent window
+ aSize.iWidth=iWinSize.iWidth/2;
+ aSize.iHeight=iWinSize.iHeight/2;
+ aPos.iX=iWinSize.iWidth/4;
+ aPos.iY=iWinSize.iHeight/4;
+ break;
+ case 1:
+ // 1/3rd parent window size window positioned 1/3rd spare size in from the bottom right
+ aSize.iWidth=iWinSize.iWidth/3;
+ aSize.iHeight=iWinSize.iHeight/3;
+ aPos.iX=(iWinSize.iWidth-aSize.iWidth)*2/3;
+ aPos.iY=(iWinSize.iHeight-aSize.iHeight)*2/3;
+ break;
+ }
+ }
+
+/*CRedrawStoreWin*/
+
+void CRedrawStoreWin::Draw()
+ {
+ if (iTest->iQueueTest)
+ iDrawOrder=iTest->iDrawOrder++;
+ iTest->DoDrawingL(iGc);
+ }
+
+
+/*CNoDrawWin*/
+
+void CNoDrawWin::Draw()
+ {
+ //Deliberately have no drawing
+ }
+
+/*CBitmapMaskedWin*/
+CBitmapMaskedWin* CBitmapMaskedWin::NewL(CFbsBitmap* aFbsBitmap,CFbsBitmap* aFbsMaskBitmap,
+ CWsBitmap* aWsBitmap,CWsBitmap* aWsMaskBitmap,
+ TRgb aBackground,TRect aRect,TBool aInvertMask,TBool aWsFbs)
+ {
+ CBitmapMaskedWin* self=new(ELeave) CBitmapMaskedWin(aFbsBitmap,aFbsMaskBitmap,aWsBitmap,
+ aWsMaskBitmap,aRect,aInvertMask,aWsFbs);
+ CleanupStack::PushL(self);
+ self->ConstructL(*TheClient->iGroup);
+ self->AssignGC(*TheClient->iGc);
+ self->BaseWin()->SetRequiredDisplayMode(EColor16MU);
+ self->Win()->SetBackgroundColor(aBackground);
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+CBitmapMaskedWin::~CBitmapMaskedWin()
+ {
+ delete iFbsBitmap;
+ delete iFbsMaskBitmap;
+ delete iWsBitmap;
+ if (!iWsFbs)
+ {
+ delete iWsMaskBitmap;
+ }
+ }
+
+void CBitmapMaskedWin::SetDestRectSize(const TSize aSize)
+ {
+ iRect.SetSize(aSize);
+ }
+
+void CBitmapMaskedWin::Draw()
+ {
+ if (iWsFbs)
+ {
+ TheClient->iGc->DrawBitmapMasked(iRect,iWsBitmap,TRect(iWsBitmap->SizeInPixels()),iWsMaskBitmap,iInvertMask);
+ }
+ else
+ {
+ TheClient->iGc->DrawBitmapMasked(iRect,iFbsBitmap,TRect(iFbsBitmap->SizeInPixels()),iFbsMaskBitmap,iInvertMask);
+ }
+ }
+
+
+/* TESTCASE: DEF095130
+ * TITLE: Redraw store for Alpha Channel Transparency.
+ * IMPORTANCE: 1
+ *
+ * ACTION: a. Creates a window disable the redrawstore. Set the Alpha channel
+ * Transparency.
+ *
+ * RESULT: Redraw store should be enabled and should redraw correctly.
+ */
+void CTRedrawStoring::DoRedrawStoreAlphaChannelTransTest()
+ {
+ // Create testwin and disable the redraw store
+ // Set alpha transparency and check if redraw store is enabled
+ RWindow win(TheClient->iWs);
+ CleanupClosePushL(win);
+ User::LeaveIfError(win.Construct(*TheClient->iGroup->GroupWin(), ENullWsHandle));
+ win.SetExtent(iWinPos, iWinSize);
+ win.SetRequiredDisplayMode(EColor256);
+ win.EnableRedrawStore(EFalse);
+ win.SetTransparencyAlphaChannel();
+ TEST(win.IsRedrawStoreEnabled());
+ CleanupStack::PopAndDestroy(&win);
+
+ // Create a window and disable the redraw store
+ // Set alpha transparency and check if redraw store is enabled
+ // and check if redraw storing is done correctly
+ RWindow wint(TheClient->iWs);
+ CleanupClosePushL(wint);
+ User::LeaveIfError(wint.Construct(*TheClient->iGroup->GroupWin(), ENullWsHandle));
+ wint.SetExtent(iWinPos, iWinSize);
+ wint.SetRequiredDisplayMode(iTestDisplayMode);
+ wint.SetBackgroundColor(TRgb(255,255,255));
+ wint.SetShadowDisabled(ETrue);
+ wint.EnableRedrawStore(EFalse);
+ wint.SetTransparencyAlphaChannel();
+ wint.Activate();
+ wint.BeginRedraw();
+ TheClient->iGc->Activate(wint);
+ DoDrawingL(23,TheClient->iGc,ETrue);
+ TheClient->iGc->Deactivate();
+ wint.EndRedraw();
+
+ DoDrawingL(23,iCheckGc,EFalse);
+ iCheckWin->BackedUpWin()->UpdateScreen();
+
+ iBlankWin.SetOrdinalPosition(0);
+ iBlankWin.SetVisible(ETrue);
+ iBlankWin.SetVisible(EFalse);
+
+ TheClient->Flush();
+ TheClient->WaitForRedrawsToFinish();
+ TInt gap = 5;
+ const TSize scrSize(TheClient->iScreen->SizeInPixels());
+ TEST(TheClient->iScreen->RectCompare(TRect(TPoint(scrSize.iWidth-2*iWinSize.iWidth-gap,0),iWinSize),TRect(TPoint(scrSize.iWidth-iWinSize.iWidth,0),iWinSize)));
+ CleanupStack::PopAndDestroy(&wint);
+ }
+
+/* TESTCASE: PDEF091091
+ * TITLE: Redraw in between begin and end redraw.
+ * IMPORTANCE: 1
+ *
+ * ACTION: Draws some content to test window in its redraw. Then starts drawing
+ * to test window by using BeginRedraw and EndRedraw methods. A blank window in
+ * front of test wndow is made visible and invisible in between BeginRedraw and
+ * EndRedraw.
+ *
+ *
+ * RESULT: When the window is made visible again redraw should ot happen.
+ */
+void CTRedrawStoring::DoBeginEndRedraw()
+ {
+ // Check whether redrawstoring is working
+ RedrawWindows();
+ iBlankWin.SetVisible(ETrue);
+ iBlankWin.SetVisible(EFalse);
+ iClientDidDraw = EFalse;
+ CheckWindowsMatch();
+ TEST(!iClientDidDraw);
+ if(iClientDidDraw != 0)
+ INFO_PRINTF3(_L("iClientDidDraw Expected value %d Actual value %d"), 0, iClientDidDraw);
+
+ // Change the size and make the blank window visible
+ // Then start drawing by BeginRedraw and Activating its gc
+ // Now make the blank window visible
+ iTestWin->Win()->Invalidate();
+ iBlankWin.SetSize(TSize(40,40));
+ iBlankWin.SetVisible(ETrue);
+
+ CWindowGc* gc = iTestWin->Gc();
+ RWindow* win = iTestWin->Win();
+ win->BeginRedraw();
+ gc->Activate(*win);
+ gc->SetPenStyle(CGraphicsContext::ESolidPen);
+ gc->SetPenColor(TRgb(0,0,0));
+ gc->SetPenSize(TSize(1,1));
+ gc->DrawLine(TPoint(iWinSize.iWidth,0), TPoint(0, iWinSize.iHeight));
+ iBlankWin.SetVisible(EFalse);
+ gc->DrawLine(TPoint(0,0), TPoint(iWinSize.iWidth, iWinSize.iHeight));
+ iBlankWin.SetVisible(ETrue);
+ gc->DrawLine(TPoint(iWinSize.iWidth/2,0), TPoint(iWinSize.iWidth/2, iWinSize.iHeight));
+ gc->DrawLine(TPoint(0,iWinSize.iHeight/2), TPoint(iWinSize.iWidth, iWinSize.iHeight/2));
+
+ iCheckGc->Clear();
+ iCheckGc->SetPenStyle(CGraphicsContext::ESolidPen);
+ iCheckGc->SetPenColor(TRgb(0,0,0));
+ iCheckGc->SetPenSize(TSize(1,1));
+ iCheckGc->DrawLine(TPoint(iWinSize.iWidth/2,0), TPoint(iWinSize.iWidth/2, iWinSize.iHeight));
+ iCheckGc->DrawLine(TPoint(0,iWinSize.iHeight/2), TPoint(iWinSize.iWidth, iWinSize.iHeight/2));
+ iCheckGc->DrawLine(TPoint(0,0), TPoint(iWinSize.iWidth, iWinSize.iHeight));
+ iCheckGc->DrawLine(TPoint(iWinSize.iWidth,0), TPoint(0, iWinSize.iHeight));
+ iCheckWin->BackedUpWin()->UpdateScreen();
+
+ iBlankWin.SetVisible(EFalse);
+
+ // This is to check if any redraw happened in between Begin and EndRedraw
+ /* Andy commented this out. I'm not entirely sure what it's doing. We just redrew a window
+ while part of it was hidden, and then revealed the hidden part before calling EndRedraw, and
+ this is testing that the new draw commands for the region revealed are not processed, or are not
+ processed correctly. In the new window server they are processed and the region checked matches
+ the test bitmap. */
+// TInt gap = 5;
+// const TSize scrSize(TheClient->iScreen->SizeInPixels());
+// TBool failed=DoCheckRect(TPoint(scrSize.iWidth-2*iWinSize.iWidth-gap,0),TPoint(scrSize.iWidth-iWinSize.iWidth,0),TSize(40,40));
+ gc->Deactivate();
+ win->EndRedraw();
+/* if (failed)
+ {
+ TEST(EFalse);
+ return;
+ } */
+
+ // This is to check redraw is done after EndRedraw has called.
+ iBlankWin.SetVisible(ETrue);
+ iBlankWin.SetVisible(EFalse);
+ CheckRect(iTestWin,iCheckWin,TRect(TSize(40,40)),_L("CTRedrawStoring::DoBeginEndRedraw"));
+ // Finally bring every thing to normal
+ RedrawWindows();
+ CheckWindowsMatch();
+ iBlankWin.SetSize(iWinSize);
+ }
+/**
+@SYMTestCaseID GRAPHICS-WSERV-00XX-0006
+
+@SYMDEF INC087721
+
+@SYMTestCaseDesc Invisible Redraw Storing Test
+ Tests the non-redraw storing commands are stored/executed properly,
+ in presence of partial redraw commands.
+ When a semi-transparent window ST0 sits on top of an opaque window OW1,
+ you want the screen to be drawn as OW1, then alpha-blend ST0 once.
+ When ST0 is set to invisible, you want the screen to be drawn as OW1,
+ i.e. window server to not issue redraw requests for ST0.
+ When an opaque window OW2 sites on top of an opaque window OW1,
+ you want the screen to be drawn as OW1, then over-print OW2 once.
+ When OW2 is set invisible, you want the screen to be drawn as OW1,
+ i.e. window server to not issue redraw requests for OW2.
+ The reference document specifies that invisible windows do not receive
+ any window server events, i.e. no redraw requests.
+
+@SYMTestPriority High
+
+@SYMTestStatus Implemented
+
+@SYMTestActions Makes invisible a window with an invalid area
+
+@SYMTestExpectedResults When the window is made visible again it should display correctly
+ */
+void CTRedrawStoring::DoInvisibleRedrawStoreTestL( TBool aUseTransparency )
+ {
+ /*
+ * Obtain the color of a particular reference pixel which will be used for
+ * comparison later on when the blue test window is added covering it.
+ */
+ const TPoint referencePixel(iWinPos+TPoint(50,50));
+ TRgb backgroundReferenceColor;
+ TheClient->Flush();
+ TheClient->WaitForRedrawsToFinish();
+ TheClient->iWs.Finish();
+ TheClient->iScreen->GetPixel(backgroundReferenceColor, referencePixel);
+ /*
+ * Add a blue test window: transparent or opaque given parameter aUseTransparency
+ */
+ CInvisibleRedrawWin* testWin=new(ELeave) CInvisibleRedrawWin;
+ CleanupStack::PushL(testWin);
+ testWin->ConstructL(*TheClient->iGroup);
+ testWin->AssignGC(*TheClient->iGc);
+ testWin->SetExt(iWinPos+TPoint(25,25),TSize(300,200));
+ testWin->Win()->SetRequiredDisplayMode(iTestDisplayMode);
+ testWin->Win()->SetShadowDisabled(ETrue);
+ if (aUseTransparency)
+ {
+ const TInt err = testWin->MakeTransparent();
+ if (err)
+ {
+ TEST(EFalse);
+ _LIT(KLog,"Failed to make the window transparent!");
+ LOG_MESSAGE(KLog);
+ }
+ }
+ /*
+ * Make the blue testWin window appear on top of the window at iWinPos
+ */
+ testWin->Win()->Activate();
+ testWin->Win()->Invalidate();
+ TheClient->iWs.Finish();
+ TheClient->WaitForRedrawsToFinish();
+ /*
+ * By making the blue window invisible and then visible we can check to see if
+ * the window gets re-drawn correctly. Redraws should not come in during the
+ * invisible phase, because "invisible windows do not receive any window server events"
+ * but should come in during the visible phase. The background should have been
+ * drawn first and then the blue window alpha blended exactly once.
+ */
+ testWin->MakeVisible(EFalse);
+ testWin->Win()->Invalidate();
+ testWin->MakeVisible(ETrue);
+ testWin->Win()->Invalidate();
+ /*
+ * Now check the screen has the desired color at the reference pixel.
+ */
+ TRgb actualColor;
+ TheClient->Flush();
+ TheClient->WaitForRedrawsToFinish();
+ TheClient->iWs.Finish();
+ TheClient->iScreen->GetPixel(actualColor, referencePixel);
+ if (aUseTransparency)
+ {
+ CColorBlender* blender = CColorBlender::NewLC(iTestDisplayMode);
+ blender->SetInitialColor(backgroundReferenceColor);
+ blender->Blend(TRgb(0, 0, 255, 127)); //the blue background of the window
+ const TRgb expectedColor(blender->Color());
+ TEST_COLOR_MATCH(expectedColor, actualColor);
+ CleanupStack::PopAndDestroy(blender);
+ }
+ else
+ {
+ TEST_COLOR_MATCH(KRgbBlue, actualColor);
+ }
+ CleanupStack::PopAndDestroy(testWin);
+ }
+
+/*CInvisibleRedrawWin*/
+CInvisibleRedrawWin::CInvisibleRedrawWin()
+ : iVisible( ETrue )
+ {}
+
+TInt CInvisibleRedrawWin::MakeTransparent()
+ {
+ const TInt err = Win()->SetTransparencyAlphaChannel();
+ if(!err)
+ {
+ Win()->SetBackgroundColor(TRgb(0, 0, 0, 0));
+ iTransparent = ETrue;
+ }
+ return err;
+ }
+
+void CInvisibleRedrawWin::MakeVisible( TBool aVisible )
+ {
+ iVisible = aVisible;
+ SetVisible( aVisible );
+ }
+
+void CInvisibleRedrawWin::Redraw()
+ {
+ iWin.BeginRedraw();
+ DrawIfVisible();
+ iWin.EndRedraw();
+ }
+
+void CInvisibleRedrawWin::Redraw( const TRect &aRect )
+ {
+ iWin.BeginRedraw( aRect );
+ DrawIfVisible();
+ iWin.EndRedraw();
+ }
+
+void CInvisibleRedrawWin::DrawIfVisible()
+ {
+ if (iVisible)
+ {
+ iGc->Activate( iWin );
+ iGc->SetBrushStyle( CGraphicsContext::ESolidBrush );
+ if(iTransparent)
+ iGc->SetBrushColor( TRgb(0, 0, 255, 127) );
+ else
+ iGc->SetBrushColor( KRgbBlue );
+ iGc->Clear();
+ iGc->Deactivate();
+ }
+ }
+
+/**
+@SYMTestCaseID GRAPHICS-WSERV-0498
+
+@SYMDEF INC135845
+
+@SYMTestCaseDesc UseBrushPattern test
+
+@SYMTestPriority High
+
+@SYMTestStatus Implemented
+
+@SYMTestActions Create a bitmap and use as brush. bitmap deleted immediately to
+ prove that wserv retains the handle
+
+@SYMTestExpectedResults No Panic BITGDI 13
+ */
+
+void CTRedrawStoring::DoBrushDrawTestL()
+ {
+ CBrushDrawWin* testWin=new(ELeave) CBrushDrawWin;
+ CleanupStack::PushL(testWin);
+ testWin->ConstructL(*TheClient->iGroup);
+ testWin->AssignGC(*TheClient->iGc);
+ testWin->SetExt(iWinPos+TPoint(25,25),TSize(300,200));
+ testWin->Win()->SetRequiredDisplayMode(iTestDisplayMode);
+ testWin->Win()->SetShadowDisabled(ETrue);
+ testWin->Activate();
+ testWin->SetVisible(ETrue);
+
+ testWin->DrawNow();
+
+ TheClient->Flush();
+ TheClient->WaitForRedrawsToFinish();
+
+ CleanupStack::PopAndDestroy(testWin);
+ }
+
+/*CBrushDrawWin*/
+CBrushDrawWin::CBrushDrawWin()
+ {}
+
+void CBrushDrawWin::Draw()
+ {
+ Redraw();
+ }
+
+void CBrushDrawWin::Redraw()
+ {
+ CFbsBitmap *bitmap=new(ELeave) CFbsBitmap();
+ User::LeaveIfError(bitmap->Load(TEST_BITMAP_NAME,0));
+ TSize bitSize(bitmap->SizeInPixels());
+ iGc->UseBrushPattern(bitmap);
+ iGc->SetBrushStyle(CGraphicsContext::EPatternedBrush);
+ iGc->DrawRect(TRect(TPoint(0, 0), bitSize));
+ iGc->DiscardBrushPattern();
+ delete bitmap;
+ }
+
+/*CTRedrawStoring*/
+CTRedrawStoring::CTRedrawStoring(CTestStep* aStep) : CTWsGraphicsBase(aStep)
+ {
+ }
+
+CTRedrawStoring::~CTRedrawStoring()
+ {
+ delete iCheckWin;
+ delete iCheckGc;
+ delete iCheckDevice;
+ delete iCheckBitmap;
+ delete iTestWin;
+ for(TInt bmp = 0; bmp < 3; ++bmp)
+ delete iAlphaBitmap[bmp];
+ iBlankWin.Close();
+ iRegion.Close();
+ iWinTestGc.Close();
+ delete iNoDrawWin;
+ delete iTestWinCopy;
+ delete iCheckWinCopy;
+ }
+
+void CTRedrawStoring::ConstructL()
+ {
+ iState = 0;
+ const TInt gap=5;
+ iTestDisplayMode = TheClient->iScreen->DisplayMode();
+ const TSize scrSize(TheClient->iScreen->SizeInPixels());
+ iWinSize=TheClient->iScreen->SizeInPixels();
+ iWinSize.iWidth=(scrSize.iWidth-gap)/3;
+ CTBackedUpWin* checkWin=new(ELeave) CTBackedUpWin(iTestDisplayMode);
+ checkWin->ConstructExtLD(*TheClient->iGroup,TPoint(scrSize.iWidth-iWinSize.iWidth,0),iWinSize);
+ iCheckWin=checkWin;
+ iCheckWin->Activate();
+ RBackedUpWindow& win=*iCheckWin->BackedUpWin();
+ win.MaintainBackup();
+ iCheckBitmap=new(ELeave) CFbsBitmap();
+ iCheckBitmap->Duplicate(win.BitmapHandle());
+ iCheckDevice=CFbsBitmapDevice::NewL(iCheckBitmap);
+ User::LeaveIfError(iCheckDevice->CreateContext(iCheckGc));
+ iCheckGc->SetUserDisplayMode(iTestDisplayMode);
+ CRedrawStoreWin* testWin=new(ELeave) CRedrawStoreWin(this);
+ iWinPos.SetXY(scrSize.iWidth-2*iWinSize.iWidth-gap,0);
+ testWin->ConstructExtLD(*TheClient->iGroup,iWinPos,iWinSize);
+ iTestWin=testWin;
+ iTestWin->AssignGC(*TheClient->iGc);
+ RWindowBase& baseWin=*iTestWin->BaseWin();
+ User::LeaveIfError(baseWin.SetRequiredDisplayMode(iTestDisplayMode));
+ baseWin.SetShadowHeight(0);
+ iTestWin->Activate();
+
+ CNoDrawWin* noDrawWin=new(ELeave) CNoDrawWin();
+ iWinPos.SetXY(scrSize.iWidth-2*iWinSize.iWidth-gap,0);
+ noDrawWin->ConstructExtLD(*TheClient->iGroup,iWinPos,iWinSize);
+ iNoDrawWin=noDrawWin;
+ iNoDrawWin->AssignGC(*TheClient->iGc);
+ RWindowBase& bWin=*iNoDrawWin->BaseWin();
+ User::LeaveIfError(bWin.SetRequiredDisplayMode(EColor256));
+ bWin.SetShadowHeight(0);
+
+ iBlankWin=RBlankWindow(TheClient->iWs);
+ User::LeaveIfError(iBlankWin.Construct(*TheClient->iGroup->WinTreeNode(),ENullWsHandle));
+ iBlankWin.SetVisible(EFalse);
+ User::LeaveIfError(iBlankWin.SetRequiredDisplayMode(EColor256));
+ iBlankWin.SetColor(TRgb(48,240,32));
+ iBlankWin.Activate();
+ iWinTestGc=RWindow(TheClient->iWs);
+ User::LeaveIfError(iWinTestGc.Construct(*TheClient->iGroup->WinTreeNode(),ENullWsHandle));
+ iWinTestGc.SetVisible(EFalse);
+ User::LeaveIfError(iWinTestGc.SetRequiredDisplayMode(EColor256));
+
+ iDrawMode=EClientRedrawsNormal;
+ iDoScrollTest=EFalse;
+ iDrawOrder=0;
+ //PeterI Alpha is supported but opacity is not
+// iAlphaSupported=OpacityAndAlphaSupportedL();
+ iAlphaSupported =TransparencySupportedL();
+ iXPlus = ETrue;
+ iYPlus = EFalse;
+
+ // Used for fading test
+ iTestWinCopy = new (ELeave) CFbsBitmap();
+ iTestWinCopy->Create(iTestWin->Size(),TheClient->iScreen->DisplayMode());
+ iCheckWinCopy = new (ELeave) CFbsBitmap();
+ iCheckWinCopy->Create(iCheckWin->Size(),TheClient->iScreen->DisplayMode());
+ }
+
+void CTRedrawStoring::CheckWindowsMatch()
+ {
+ TheClient->Flush();
+ if (iDrawMode==EClientRedrawsNormal || iDrawMode==EClientRedrawsScrolled)
+ TheClient->WaitForRedrawsToFinish();
+ TheClient->iWs.Finish();
+ if(!iWindowsFaded)
+ {
+ _LIT(KLog,"RedrawStoring SubTest %d");
+ TBuf<32> buf;
+ buf.AppendFormat(KLog,iTest->iState);
+ CheckRect(iTestWin,iCheckWin,TRect(iWinSize),buf);
+ }
+ else
+ {
+ TInt res = LossyCompareWindow(*TheClient->iScreen, *iTestWinCopy, *iCheckWinCopy, TRect(iCheckWin->Position(), iCheckWin->Size()));
+ TEST(res);
+ }
+ }
+
+void CTRedrawStoring::CheckWindowsNotMatch()
+ {
+ TheClient->Flush();
+ TheClient->WaitForRedrawsToFinish();
+ TheClient->iWs.Finish();
+ CheckRectNoMatch(iTestWin,iCheckWin,TRect(iWinSize),_L("CTRedrawStoring::CheckWindowsNotMatch()"));
+ }
+
+void CTRedrawStoring::HideRevealTest()
+ {
+ iBlankWin.SetVisible(ETrue);
+ iBlankWin.SetVisible(EFalse);
+ CheckWindowsMatch();
+ }
+
+void CTRedrawStoring::MultipleHideReveal(TInt aX,TInt aY)
+ {
+ TInt xInc=(iWinSize.iWidth+aX-1)/aX;
+ TInt yInc=(iWinSize.iHeight+aY-1)/aY;
+ TInt xEnd=iWinPos.iX+iWinSize.iWidth;
+ TInt yEnd=iWinPos.iY+iWinSize.iHeight;
+ TInt xx,yy;
+ for(xx=iWinPos.iX;xx<xEnd;xx+=xInc)
+ {
+ for(yy=iWinPos.iY;yy<yEnd;yy+=yInc)
+ {
+ iBlankWin.SetExtent(TPoint(xx,yy),TSize(xInc,yInc));
+ HideRevealTest();
+ }
+ }
+ }
+
+void CTRedrawStoring::RedrawWindows()
+ {
+ iDrawMode=EClientRedrawsNormal;
+ iTestWin->Invalidate();
+ CheckWindowsMatch();
+ iDrawMode=EServerRedraw;
+ }
+
+void CTRedrawStoring::DoDrawingL(CWindowGc* aWinGc)
+ {
+ iClientDidDraw = ETrue;
+ switch (iDrawMode)
+ {
+ case EServerRedraw:
+ TEST(EFalse);
+ break;
+ case EClientRedrawsNormal:
+ if (iState>0)
+ {
+ DoDrawingL(0,aWinGc,ETrue);
+ DoDrawingL(0,iCheckGc,EFalse);
+ aWinGc->Deactivate();
+ aWinGc->Activate(*iTestWin->DrawableWin());
+ }
+ DoDrawingL(iState,aWinGc,ETrue);
+ DoDrawingL(iState,iCheckGc,EFalse);
+ iCheckWin->BackedUpWin()->UpdateScreen();
+ break;
+ case EClientRedrawsScrolled:
+ {
+ DoDrawingL(0,aWinGc,ETrue);
+ TRegionFix<8> region;
+ region.AddRect(TRect(iWinSize));
+ region.SubRect(iScrollTarget);
+ aWinGc->SetClippingRegion(region);
+ DoDrawingL(iState,aWinGc,ETrue);
+ aWinGc->CancelClippingRegion();
+ aWinGc->SetClippingRect(iScrollTarget);
+ aWinGc->SetOrigin(iScrollTarget.iTl-iScrollSource);
+ DoDrawingL(iState,aWinGc,ETrue);
+ aWinGc->CancelClippingRect();
+ break;
+ }
+ }
+ TheClient->Flush();
+ }
+
+#define KLastDrawingCase 24 //This should always be the same as the value of last case number in the switch statement of the next function
+void CTRedrawStoring::DoDrawingL(TInt aDraw,CBitmapContext* aGc,TBool aWinGc)
+ {
+ switch (aDraw)
+ {
+ case 0:
+ case 1:
+ aGc->SetBrushColor(TRgb(255,(aDraw==0?255:0),255));
+ aGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
+ aGc->SetPenStyle(CGraphicsContext::ENullPen);
+ aGc->DrawRect(iWinSize);
+ iDoScrollTest=EFalse;
+ break;
+ case 2:
+ aGc->SetPenStyle(CGraphicsContext::ESolidPen);
+ aGc->SetPenSize(TSize(1,1));
+ aGc->SetPenColor(TRgb(0,0,0));
+ aGc->DrawLine(TPoint(0,10),TPoint(iWinSize.iWidth,10));
+ aGc->SetPenColor(TRgb(128,0,0));
+ aGc->DrawLine(TPoint(0,iWinSize.iHeight-10),TPoint(iWinSize.iWidth,iWinSize.iHeight-10));
+ aGc->SetPenColor(TRgb(0,128,0));
+ aGc->DrawLine(TPoint(10,0),TPoint(10,iWinSize.iHeight));
+ aGc->SetPenColor(TRgb(0,0,128));
+ aGc->DrawLine(TPoint(iWinSize.iWidth-10,0),TPoint(iWinSize.iWidth-10,iWinSize.iHeight));
+ iDoScrollTest=EFalse;
+ break;
+ case 3:
+ //Do various drawing using: MoveTo, MoveBy, Plot, DrawLineTo, DrawLineBy
+ aGc->SetPenStyle(CGraphicsContext::ESolidPen);
+ aGc->SetPenColor(TRgb(0,0,0));
+ aGc->MoveTo(TPoint(iWinSize.iWidth, iWinSize.iHeight));
+ aGc->DrawLineTo(TPoint(0, 0));
+ aGc->MoveBy(TPoint(iWinSize.iWidth, 0));
+ aGc->DrawLineTo(TPoint(0, iWinSize.iHeight));
+ aGc->MoveTo(TPoint(0, iWinSize.iHeight/2));
+ aGc->DrawLineBy(TPoint(iWinSize.iWidth, 0));
+ aGc->SetPenSize(TSize(5,5));
+ aGc->Plot(TPoint(iWinSize.iWidth/2, 20));
+ aGc->Plot(TPoint(iWinSize.iWidth/2, iWinSize.iHeight/2));
+ aGc->Plot(TPoint(iWinSize.iWidth/2, iWinSize.iHeight-20));
+ aGc->SetPenSize(TSize(1,1));
+ iDoScrollTest=EFalse;
+ break;
+ case 4:
+ //Do various drawing with lines of different widths
+ {
+ TInt inc=iWinSize.iHeight/8;
+ TInt penSize=2;
+ TInt yy;
+ aGc->SetPenStyle(CGraphicsContext::ESolidPen);
+ aGc->SetPenColor(TRgb(0,0,0));
+ for (yy=0;yy<iWinSize.iHeight;yy+=inc)
+ {
+#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA
+ if (yy%3==0)
+ aGc->SetPenSize(TSize(penSize,penSize));
+ else if (yy%3==1)
+ aGc->SetPenSize(TSize(penSize,7*penSize/5));
+ else
+ aGc->SetPenSize(TSize(7*penSize/5,penSize));
+#else
+ aGc->SetPenSize(TSize(penSize,penSize));
+#endif
+ aGc->DrawLine(TPoint(2,yy),TPoint(iWinSize.iWidth-3,yy));
+ penSize+=2;
+ }
+ aGc->SetPenSize(TSize(1,1));
+ }
+ iDoScrollTest=ETrue;
+ break;
+ case 5:
+ //Some drawing using fading on the gc
+ aGc->SetPenStyle(CGraphicsContext::ESolidPen);
+ aGc->SetPenColor(TRgb(0,0,255));
+#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA
+ aGc->SetFaded(ETrue);
+#endif
+ aGc->SetPenSize(TSize(10,10));
+ aGc->DrawLine(TPoint(0,iWinSize.iHeight/2-5),TPoint(iWinSize.iWidth,iWinSize.iHeight/2-5));
+#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA
+ aGc->SetFaded(EFalse);
+#endif
+ aGc->DrawLine(TPoint(0,iWinSize.iHeight/2+5),TPoint(iWinSize.iWidth, iWinSize.iHeight/2+5));
+ aGc->SetPenStyle(CGraphicsContext::ESolidPen);
+ aGc->SetPenColor(TRgb(0,0,255));
+#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA
+ aGc->SetFaded(ETrue);
+ aGc->SetFadingParameters(0,127);
+#endif
+ aGc->SetPenSize(TSize(10,10));
+ aGc->DrawLine(TPoint(iWinSize.iWidth/2-5,0),TPoint(iWinSize.iWidth/2-5,iWinSize.iHeight));
+#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA
+ aGc->SetFaded(EFalse);
+ // default params
+ aGc->SetFadingParameters(128,255);
+#endif
+ aGc->DrawLine(TPoint(iWinSize.iWidth/2+5,0),TPoint(iWinSize.iWidth/2+5,iWinSize.iHeight));
+#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA
+ aGc->SetFaded(EFalse);
+#endif
+ iDoScrollTest=ETrue;
+ break;
+ case 6:
+ // Fading on window
+ aGc->SetPenStyle(CGraphicsContext::ESolidPen);
+ aGc->SetPenColor(TRgb(0,255,0));
+ aGc->SetPenSize(TSize(10,10));
+ aGc->DrawLine(TPoint(0,iWinSize.iHeight/2),TPoint(iWinSize.iWidth,iWinSize.iHeight/2));
+ aGc->DrawLine(TPoint(iWinSize.iWidth/2,0),TPoint(iWinSize.iWidth/2,iWinSize.iHeight));
+ iDoScrollTest=EFalse;
+ break;
+ case 7:
+ //Some drawing with text - create and destroy the font as soon as used
+ {
+ CFbsFont *font;
+ TFontSpec fspec(_L("Swiss"),190);
+ User::LeaveIfError(TheClient->iScreen->GetNearestFontToDesignHeightInTwips((CFont *&)font,fspec));
+ aGc->SetPenColor(TRgb(0,0,0));
+ aGc->UseFont(font);
+ aGc->DrawText(_L("Hello"), TPoint(20,20));
+ aGc->DiscardFont();
+ TheClient->iScreen->ReleaseFont(font);
+
+ CFbsFont *font2;
+ TInt fontSize = 100;
+ TInt inc = 10;
+ for (TInt i=0; i<20; i++)
+ {
+ TFontSpec fspec2(_L("Ariel"), fontSize);
+ User::LeaveIfError(TheClient->iScreen->GetNearestFontToDesignHeightInTwips((CFont *&)font2,fspec2));
+ aGc->SetPenColor(TRgb(0,0,0));
+ aGc->UseFont(font2);
+ aGc->DrawText(_L("Hello"), TPoint(20,100));
+ aGc->DiscardFont();
+ TheClient->iScreen->ReleaseFont(font2);
+ fontSize+=inc;
+ }
+ iDoScrollTest=ETrue;
+ }
+ break;
+ case 8:
+ //Some drawing with bitmaps - create and destroy the bitmap as soon as used
+ {
+ CFbsBitmap* testBitmap;
+ testBitmap=new(ELeave) CFbsBitmap();
+ User::LeaveIfError(testBitmap->Load(TEST_BITMAP_NAME,0));
+ aGc->DrawBitmap(TRect(TPoint(10,10), TPoint(150,150)), testBitmap);
+ delete testBitmap;
+ iDoScrollTest=ETrue;
+ }
+ break;
+ case 9:
+ //Some drawing with clipping regions and rects
+
+ //clipping rect
+
+ aGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
+ aGc->SetPenStyle(CGraphicsContext::ENullPen);
+ aGc->SetClippingRect(TRect(TPoint(50,0), TSize(iWinSize.iWidth/2,100)));
+ aGc->SetBrushColor(TRgb(255,255,0));
+ aGc->DrawRect(TRect(TPoint(0,0), TPoint(100,100)));
+ aGc->SetBrushColor(TRgb(0,128,128));
+ aGc->DrawRect(TRect(TPoint(iWinSize.iWidth/2,0), TSize(iWinSize.iWidth/2,100)));
+ aGc->CancelClippingRect();
+
+
+ //regions
+
+ iRegion.AddRect(TRect(TPoint(0,30), TSize(3*iWinSize.iWidth/4,150)));
+ iRegion.AddRect(TRect(TPoint(iWinSize.iWidth/2-20, 0), TSize(70,70)));
+
+ aGc->SetClippingRegion(iRegion);
+
+ aGc->SetBrushColor(TRgb(0,200,0));
+ aGc->DrawRect(TRect(TPoint(5,5), TPoint(iWinSize.iWidth-50,200)));
+ aGc->SetBrushColor(TRgb(200,0,0));
+ aGc->DrawRect(TRect(TPoint(50,50), TPoint(iWinSize.iWidth/2,150)));
+ aGc->SetBrushColor(TRgb(0,0,200));
+ aGc->DrawRect(TRect(TPoint(20,10), TPoint(100,100)));
+
+ aGc->CancelClippingRegion();
+
+ iDoScrollTest=EFalse;
+ break;
+ case 10:
+ //Some drawing with deactivating and reactivating the gc on the window (if it is indeed it is window gc)
+
+ aGc->SetBrushColor(TRgb(0,0,255));
+ aGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
+ aGc->SetPenStyle(CGraphicsContext::ENullPen);
+ aGc->DrawRect(TRect(TPoint(20,20), TSize(50,50)));
+
+ if (aWinGc)
+ {
+ static_cast<CWindowGc*>(aGc)->Deactivate();
+
+ // Associate gc with another window and change attributes
+ static_cast<CWindowGc*>(aGc)->Activate(iWinTestGc);
+ aGc->SetPenStyle(CGraphicsContext::ESolidPen);
+ aGc->SetPenColor(TRgb(0,0,255));
+ static_cast<CWindowGc*>(aGc)->Deactivate();
+ static_cast<CWindowGc*>(aGc)->Activate(*iTestWin->DrawableWin());
+ }
+
+ aGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
+ aGc->SetPenStyle(CGraphicsContext::ENullPen);
+ aGc->SetBrushColor(TRgb(200,0,0));
+ aGc->DrawRect(TRect(TPoint(70,70), TSize(50,50)));
+ iDoScrollTest=EFalse;
+ break;
+ case 11:
+ // Some drawing with polygons
+ {
+ aGc->SetBrushColor(TRgb(0,221,0));
+ aGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
+ aGc->SetPenStyle(CGraphicsContext::ENullPen);
+
+ TPoint point1(iWinSize.iWidth/3,iWinSize.iHeight/4*3);
+ TPoint point2(iWinSize.iWidth/2,iWinSize.iHeight/5*4);
+ TPoint point3(iWinSize.iWidth/3,iWinSize.iHeight-20);
+ TPoint point4(iWinSize.iWidth/4,iWinSize.iHeight-20);
+ TPoint point5(iWinSize.iWidth/6,iWinSize.iHeight-60);
+
+ CArrayFix<TPoint>* points;
+ points = new CArrayFixFlat<TPoint>(5);
+ points->AppendL(point1);
+ points->AppendL(point2);
+ points->AppendL(point3);
+ points->AppendL(point4);
+ points->AppendL(point5);
+ aGc->DrawPolygon(points);
+ delete points;
+
+ TPoint points2[5];
+ points2[0].SetXY(iWinSize.iWidth/2,50);
+ points2[1].SetXY(iWinSize.iWidth-50,iWinSize.iHeight/2);
+ points2[2].SetXY(iWinSize.iWidth-70,iWinSize.iHeight/2+30);
+ points2[3].SetXY(iWinSize.iWidth/3,iWinSize.iHeight/3);
+ points2[4].SetXY(iWinSize.iWidth/4,iWinSize.iHeight/4);
+ aGc->SetBrushColor(TRgb(221,0,0));
+ aGc->DrawPolygon(points2,5);
+ iDoScrollTest=ETrue;
+ }
+ break;
+ case 12:
+ {
+ // Another Fading on Window Test
+ aGc->SetPenStyle(CGraphicsContext::ENullPen);
+ aGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
+ aGc->SetBrushColor(TRgb(51,204,204));
+#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA
+ if (!iWindowsFaded || aWinGc)
+ {
+ aGc->SetFaded(ETrue);
+ }
+#endif
+ aGc->DrawRect(TRect(iWinSize.iWidth/4-1,iWinSize.iHeight/4-1,3*iWinSize.iWidth/4+1,3*iWinSize.iHeight/4+1));
+#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA
+ aGc->SetFaded(EFalse);
+#endif
+ aGc->SetBrushStyle(CGraphicsContext::ENullBrush);
+ aGc->SetPenStyle(CGraphicsContext::ESolidPen);
+ aGc->SetPenColor(TRgb(34,204,34));
+ aGc->SetPenSize(TSize(8,8));
+ aGc->DrawLine(TPoint(2,iWinSize.iHeight/2+5),TPoint(iWinSize.iWidth-2,iWinSize.iHeight/2-5));
+ aGc->DrawLine(TPoint(iWinSize.iWidth/2+5,2),TPoint(iWinSize.iWidth/2-5,iWinSize.iHeight-2));
+#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA
+ if (!iWindowsFaded || aWinGc)
+ {
+ aGc->SetFaded(ETrue);
+ }
+#endif
+ aGc->SetPenColor(TRgb(51,221,51));
+ aGc->SetPenSize(TSize(3,3));
+ aGc->SetBrushColor(TRgb(238,34,238));
+ aGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
+ aGc->DrawRect(TRect(3*iWinSize.iWidth/8-1,3*iWinSize.iHeight/8-1,5*iWinSize.iWidth/8+1,5*iWinSize.iHeight/8+1));
+#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA
+ aGc->SetFaded(EFalse);
+#endif
+ aGc->SetBrushStyle(CGraphicsContext::ENullBrush);
+ aGc->SetPenColor(TRgb(238,34,238));
+#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA
+ aGc->SetPenSize(TSize(8,9));
+#else
+ aGc->SetPenSize(TSize(8,8));
+#endif
+ aGc->DrawRect(TRect(iWinSize.iWidth/8-1,iWinSize.iHeight/8-1,7*iWinSize.iWidth/8+1,7*iWinSize.iHeight/8+1));
+ iDoScrollTest=ETrue;
+ }
+ break;
+ case 15:
+ //Some masked drawing with FBS bitmaps - create and destroy the bitmaps as soon as used
+ {
+ CFbsBitmap* testBitmap;
+ CFbsBitmap* maskBitmap;
+ testBitmap=new(ELeave) CFbsBitmap();
+ CleanupStack::PushL(testBitmap);
+ maskBitmap=new(ELeave) CFbsBitmap();
+ CleanupStack::PushL(maskBitmap);
+ User::LeaveIfError(testBitmap->Load(TEST_BITMAP_NAME,2));
+ User::LeaveIfError(maskBitmap->Load(TEST_BITMAP_NAME,4));
+ aGc->BitBltMasked(TPoint(10,10), testBitmap, TRect(TPoint(0, 0), testBitmap->SizeInPixels()), maskBitmap, EFalse);
+ CleanupStack::PopAndDestroy(2, testBitmap);
+ iDoScrollTest=ETrue;
+ }
+ break;
+ case 16:
+ //As above, except using Ws bitmaps
+ {
+ CWsBitmap* testBitmap;
+ CWsBitmap* maskBitmap;
+ testBitmap=new(ELeave) CWsBitmap(TheClient->iWs);
+ CleanupStack::PushL(testBitmap);
+ maskBitmap=new(ELeave) CWsBitmap(TheClient->iWs);
+ CleanupStack::PushL(maskBitmap);
+ User::LeaveIfError(testBitmap->Load(TEST_BITMAP_NAME,3));
+ User::LeaveIfError(maskBitmap->Load(TEST_BITMAP_NAME,4));
+ // If we don't cast to the window gc we don't see the WS version of the BitBltMasked function:
+ if(aWinGc)
+ ((CWindowGc*)aGc)->BitBltMasked(TPoint(20,20), testBitmap, TRect(TPoint(0, 0), testBitmap->SizeInPixels()), maskBitmap, EFalse);
+ else
+ aGc->BitBltMasked(TPoint(20,20), testBitmap, TRect(TPoint(0, 0), testBitmap->SizeInPixels()), maskBitmap, EFalse);
+ CleanupStack::PopAndDestroy(2, testBitmap);
+ iDoScrollTest=ETrue;
+ }
+ break;
+ case 19:
+ //Some drawing with WS bitmaps
+ {
+ if(!iAlphaBitmap[0])
+ {
+ for(TInt bmp = 0; bmp < 3; ++bmp)
+ {
+ iAlphaBitmap[bmp] = new(ELeave) CWsBitmap(TheClient->iWs);
+ User::LeaveIfError(iAlphaBitmap[bmp]->Load(TEST_BITMAP_NAME,2 + bmp));
+ }
+ }
+ if(aWinGc)
+ ((CWindowGc*)aGc)->BitBlt(TPoint(20,20), iAlphaBitmap[0]);
+ else
+ aGc->BitBlt(TPoint(20,20), iAlphaBitmap[0]);
+ iDoScrollTest=ETrue;
+ }
+ break;
+ case 20:
+ //Some drawing with alpha blended bitmaps
+ if (iAlphaSupported)
+ {
+ aGc->SetFaded(EFalse);
+ TPoint start(0,0);
+ TSize size = iAlphaBitmap[0]->SizeInPixels();
+ TPoint alphastart((start.iX + size.iWidth / 4), (start.iY + size.iHeight / 4));
+
+ aGc->BitBlt(start, iAlphaBitmap[0], TRect(start, size));
+ aGc->AlphaBlendBitmaps(start, iAlphaBitmap[1], TRect(start, size), iAlphaBitmap[2], alphastart);
+ iDoScrollTest=ETrue;
+ }
+ break;
+ case 21:
+ // As in previous case, except using FBS bitmaps.
+ if (iAlphaSupported)
+ {
+ aGc->SetFaded(EFalse);
+ CFbsBitmap* baseBitmap;
+ CFbsBitmap* testBitmap;
+ CFbsBitmap* alphaBitmap;
+ baseBitmap=new(ELeave) CFbsBitmap();
+ CleanupStack::PushL(baseBitmap);
+ testBitmap=new(ELeave) CFbsBitmap();
+ CleanupStack::PushL(testBitmap);
+ alphaBitmap=new(ELeave) CFbsBitmap();
+ CleanupStack::PushL(alphaBitmap);
+ User::LeaveIfError(baseBitmap->Load(TEST_BITMAP_NAME,2));
+ User::LeaveIfError(testBitmap->Load(TEST_BITMAP_NAME,3));
+ User::LeaveIfError(alphaBitmap->Load(TEST_BITMAP_NAME,4));
+ TPoint start(0,0);
+ TSize size = baseBitmap->SizeInPixels();
+ TPoint alphastart((start.iX + size.iWidth / 4), (start.iY + size.iHeight / 4));
+
+ aGc->BitBlt(start, baseBitmap, TRect(start, size));
+ aGc->AlphaBlendBitmaps(start, testBitmap, TRect(start, size), alphaBitmap, alphastart);
+
+ CleanupStack::PopAndDestroy(3, baseBitmap);
+ iDoScrollTest=ETrue;
+ }
+ break;
+ case 22:
+ // Some default drawing for Begin EndRedraw test
+ aGc->SetPenStyle(CGraphicsContext::ESolidPen);
+ aGc->SetPenSize(TSize(2,2));
+ aGc->SetPenColor(TRgb(128,0,0));
+ aGc->DrawLine(TPoint(10,10),TPoint(20,10));
+ aGc->DrawLine(TPoint(20,10),TPoint(20,20));
+ aGc->DrawLine(TPoint(20,20),TPoint(10,20));
+ aGc->DrawLine(TPoint(10,20),TPoint(10,10));
+
+ aGc->SetPenSize(TSize(4,4));
+ aGc->SetPenColor(TRgb(0,0,128));
+ aGc->DrawLine(TPoint(50,50),TPoint(150,50));
+ aGc->DrawLine(TPoint(150,50),TPoint(150,150));
+ aGc->DrawLine(TPoint(150,150),TPoint(50,150));
+ aGc->DrawLine(TPoint(50,150),TPoint(50,50));
+ iDoScrollTest=EFalse;
+ break;
+ case 23:
+ aGc->SetBrushColor(TRgb(244,196,48));
+ aGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
+ aGc->SetPenStyle(CGraphicsContext::ENullPen);
+ aGc->DrawRect(TRect(0,0,iWinSize.iWidth,iWinSize.iHeight/3));
+ aGc->SetBrushColor(TRgb(255,255,255));
+ aGc->DrawRect(TRect(0,iWinSize.iHeight/3,iWinSize.iWidth,iWinSize.iHeight*2/3));
+ aGc->SetBrushColor(TRgb(3,192,60));
+ aGc->DrawRect(TRect(0,iWinSize.iHeight*2/3,iWinSize.iWidth,iWinSize.iHeight));
+ iDoScrollTest=EFalse;
+ break;
+ case 24:
+ iClientDidDraw=ETrue;
+ //Draw some rects to screen
+ aGc->Reset();
+ aGc->Clear();
+ aGc->SetPenStyle(CGraphicsContext::ESolidPen);
+ aGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
+ aGc->SetBrushColor(TRgb(98,72,172));
+ aGc->DrawRect(TRect(20,iYPoz,250,280+iYPoz));
+ aGc->SetBrushColor(TRgb(255,0,0));
+ aGc->DrawRect(TRect(0,iYPoz,200,200+iYPoz));
+ aGc->SetBrushColor(TRgb(0,255,255));
+ aGc->DrawRect(TRect(10,15+iYPoz,250,115+iYPoz));
+ aGc->SetBrushColor(TRgb(0,255,0));
+ aGc->DrawRect(TRect(0,50+iYPoz,100,250+iYPoz));
+ aGc->SetBrushColor(TRgb(255,255,0));
+ aGc->DrawRect(TRect(50,50+iYPoz,150,150+iYPoz));
+ aGc->SetBrushColor(TRgb(5,25,20));
+ aGc->DrawRect(TRect(120,170+iYPoz,220,250+iYPoz));
+ break;
+ }
+ }
+
+/**
+@SYMTestCaseID GRAPHICS-WSERV-0085
+
+@SYMDEF DEF081259
+
+@SYMTestCaseDesc Do Draw Test
+ REQUIREMENT: REQ2123
+ GT0164/Delta/ 1450, 1460, 1470, 1490, 1500, 1510, 1520, 1530
+
+@SYMTestPriority High
+
+@SYMTestStatus Implemented
+
+@SYMTestActions Lots of different type of drawing is done to the test window.
+ (Including: normal drawing, fonts, bitmaps, fading on the GC,
+ clipping regions and rects).
+ A blank window is made visible then invisible above the test window
+ The blank window's size and position is also changed many times.
+
+@SYMTestExpectedResults After the initial drawing of the test window, all the draw commands
+ should be stored by the window server. When the blank window is made
+ visible/invisible above the test window a redraw message will be sent
+ to the test window. The window will be redrawn using the draw commands
+ stored in the server. Once all the redrawing is complete, the test window
+ will be compared with a bitmap that has had the same draw commands applied
+ to it.
+ The test will fail if the bitmaps don't match or if the test window was
+ redrawn not using the stored server side draw commands.
+ */
+
+void CTRedrawStoring::DoDrawTest()
+ {
+ RedrawWindows();
+ HideRevealTest();
+ iTestWin->SetVisible(EFalse);
+ iTestWin->SetVisible(ETrue);
+ CheckWindowsMatch();
+ MultipleHideReveal(2,3);
+ MultipleHideReveal(5,4);
+ iBlankWin.SetExtent(iWinPos,iWinSize);
+ HideRevealTest();
+ CheckWindowsMatch();
+ }
+
+/**
+@SYMTestCaseID GRAPHICS-WSERV-0086
+
+@SYMDEF DEF081259
+
+@SYMTestCaseDesc Fade Window Test
+ REQUIREMENT: REQ2123
+ GT0164/Delta/ 1480
+
+@SYMTestPriority High
+
+@SYMTestStatus Implemented
+
+@SYMTestActions The test window is faded and the GC associated with the bitmap used
+ to check the test window is faded. The Draw Test in TestCase 1 is then
+ applied.
+
+@SYMTestExpectedResults The test window and the check bitmap should both be faded and contain
+ the same drawing. The test will fail if the bitmaps don't match or if the
+ test window was redrawn not using the stored server side draw commands.
+
+ */
+void CTRedrawStoring::FadeWindowTest()
+ {
+ iWindowsFaded = ETrue;
+ iTestWin->Win()->SetFaded(ETrue,RWindowTreeNode::EFadeWindowOnly);
+ iCheckGc->SetFaded(ETrue);
+ DoDrawTest();
+ iDrawMode=EClientRedrawsNormal;
+ iTestWin->Win()->SetFaded(EFalse,RWindowTreeNode::EFadeWindowOnly);
+ iCheckGc->SetFaded(EFalse);
+ TheClient->Flush();
+ TheClient->WaitForRedrawsToFinish();
+ iWindowsFaded = EFalse;
+ }
+
+/**
+@SYMTestCaseID GRAPHICS-WSERV-0087
+
+@SYMDEF DEF081259
+
+@SYMTestCaseDesc Fade Window Test 2
+ REQUIREMENT: REQ2123
+ GT0164/Delta/ 1480
+
+@SYMTestPriority High
+
+@SYMTestStatus Implemented
+
+@SYMTestActions The test window is faded and the check window that uses the check bitmap
+ is faded. A blank window is made visbible/invisible above the test window.
+ Fading is switched off on both windows, they are redrawn and then compared.
+
+@SYMTestExpectedResults The test window and the check bitmap should both be faded. After showing
+ the blank window the test window will contain a couple of rectangles faded due to
+ Gc fade apart from the overall window fade (will look similar to double fading), whereas
+ check window will have simply the overall window fade. Once both windows have been
+ redrawn with the fading switched off, they should not look the same for the same
+ reason explained above.
+
+ */
+void CTRedrawStoring::FadeWindowTest2L()
+ {
+ DoDrawTest();
+ iWindowsFaded=ETrue;
+ iTestWin->BaseWin()->SetFaded(ETrue,RWindowTreeNode::EFadeWindowOnly);
+ iCheckWin->BaseWin()->SetFaded(ETrue,RWindowTreeNode::EFadeWindowOnly);
+ CheckWindowsMatch();
+
+#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA
+ //perform RedrawWindows() with CheckWindowsNotMatch()
+ iDrawMode=EClientRedrawsNormal;
+ iTestWin->Invalidate();
+ CheckWindowsNotMatch();
+ iDrawMode=EServerRedraw;
+
+ //perform HideRevealTest() with CheckWindowsNotMatch()
+ iBlankWin.SetVisible(ETrue);
+ iBlankWin.SetVisible(EFalse);
+ CheckWindowsNotMatch();
+#endif
+
+ iWindowsFaded=EFalse;
+ iTestWin->BaseWin()->SetFaded(EFalse,RWindowTreeNode::EFadeWindowOnly);
+ iCheckWin->BaseWin()->SetFaded(EFalse,RWindowTreeNode::EFadeWindowOnly);
+ iDrawMode=EClientRedrawsNormal;
+ DoDrawingL(0,iCheckGc,EFalse);
+ DoDrawingL(iState,iCheckGc,EFalse);
+ iCheckWin->BackedUpWin()->UpdateScreen();
+ iDrawMode=EServerRedraw;
+ CheckWindowsMatch();
+ HideRevealTest();
+ }
+
+/**
+@SYMTestCaseID GRAPHICS-WSERV-0088
+
+@SYMDEF DEF081259
+
+@SYMTestCaseDesc Scroll Test
+ REQUIREMENT: REQ2123
+ GT0164/Delta/ 1540
+
+@SYMTestPriority High
+
+@SYMTestStatus Implemented
+
+@SYMTestActions Different areas of the test window are scrolled, the check bitmap
+ window is also adjusted to reflect this scrolling. The blank window is
+ then made visible/invisible above the test window
+
+@SYMTestExpectedResults The test will fail if the bitmaps don't match or if the test window was
+ redrawn not using the stored server side draw commands.
+
+ */
+void CTRedrawStoring::ScrollTest()
+ {
+ CheckWindowsMatch();
+ TInt x=iWinSize.iWidth/3;
+ TInt w=iWinSize.iWidth/4;
+ SetScrolling(TPoint(10,20),TRect(x,100,x+w,160));
+ DoScrollTest();
+ x=iWinSize.iWidth/2;
+ w=iWinSize.iWidth/3;
+ SetScrolling(TPoint(48,100),TRect(x,10,x+w,80));
+ DoScrollTest();
+ x=iWinSize.iWidth/10;
+ w=iWinSize.iWidth/5;
+ SetScrolling(TPoint(iWinSize.iWidth/2,20),TRect(x,100,x+w,150));
+ DoScrollTest();
+ }
+
+void CTRedrawStoring::DoScrollTest()
+ {
+ TheClient->Flush();
+ iDrawMode=EClientRedrawsScrolled;
+ CheckWindowsMatch();
+ iDrawMode=EServerRedraw;
+ HideRevealTest();
+ RedrawWindows();
+ CheckWindowsMatch();
+ }
+
+void CTRedrawStoring::SetScrolling(TPoint aScrollSource, TRect aScrollTarget)
+ {
+ iScrollSource=aScrollSource;
+ iScrollTarget=aScrollTarget;
+ iTestWin->DrawableWin()->Scroll(iScrollTarget.iTl-iScrollSource,TRect(iScrollSource,iScrollTarget.Size()));
+ iCheckWin->DrawableWin()->Scroll(iScrollTarget.iTl-iScrollSource,TRect(iScrollSource,iScrollTarget.Size()));
+ }
+
+/**
+@SYMTestCaseID GRAPHICS-WSERV-0090
+
+@SYMDEF DEF081259
+
+@SYMTestCaseDesc Do Nothing in Redraw Test
+ REQUIREMENT: REQ2123
+ GT0164/Delta/ 1570
+
+@SYMTestPriority High
+
+@SYMTestStatus Implemented
+
+@SYMTestActions A window is created that contains no drawing code. A blank window is
+ made visible/invisible above this window.
+
+@SYMTestExpectedResults No buffer will be created server side because there are no draw commands
+ to store. The server should be able to cope with an empty buffer when the
+ redraw is issued, caused by the blank win.
+
+ */
+void CTRedrawStoring::DoNothingInRedrawTest()
+ {
+ // iNoDrawWin contains no drawing code, therefore no server side
+ // redraw store buffer will be created in a redraw.
+ // When a redraw occurs because the blank win is made visible/invisible,
+ // the server will try and access the non existant buffer, all being well
+ // nothing should happen because the server can cope with an empty redraw
+ // buffer.
+
+ iTestWin->SetVisible(EFalse);
+ iNoDrawWin->Activate();
+ TheClient->Flush();
+ TheClient->WaitForRedrawsToFinish();
+ iDrawMode=EServerRedraw;
+ iBlankWin.SetOrdinalPosition(0);
+ iBlankWin.SetVisible(ETrue);
+ iBlankWin.SetVisible(EFalse);
+ TheClient->Flush();
+
+ //return to normal testing state
+ iNoDrawWin->SetVisible(EFalse);
+ iTestWin->SetVisible(ETrue);
+ RedrawWindows();
+ }
+
+/**
+@SYMTestCaseID GRAPHICS-WSERV-0091
+
+@SYMDEF DEF081259
+
+@SYMTestCaseDesc Disable Redraw Store Test
+
+@SYMTestPriority High
+
+@SYMTestStatus Implemented
+
+@SYMTestActions A windows redraw store is disabled and enabled, and the window is exposed.
+
+@SYMTestExpectedResults When the redraw store is disabled, a client redraw should occur when the window
+ is exposed. When it is enabled, no client redraw should occur. However, the
+ first time it is exposed after enabling the store it will need a client redraw
+ in order to fill the store.
+
+ */
+void CTRedrawStoring::DoDisableRedrawStoreTest()
+ {
+ _LIT(KLog1,"Redraw storing not enabled when expected to be");
+ _LIT(KLog2,"No client redraw was done when it was expected");
+ RedrawWindows();
+ CheckWindowsMatch();
+
+ iDrawMode=EServerRedraw;
+ HideRevealTest();
+
+ iClientDidDraw=EFalse;
+ TBool isEnabled=iTestWin->Win()->IsRedrawStoreEnabled();
+ TEST(isEnabled);
+ if (!isEnabled)
+ LOG_MESSAGE(KLog1);
+
+ /*iTestWin->Win()->EnableRedrawStore(EFalse);
+ isEnabled=iTestWin->Win()->IsRedrawStoreEnabled();
+ TEST(!isEnabled);
+ if (isEnabled)
+ {
+ _LIT(KLog,"Redraw storing enabled when expected not to be");
+ LOG_MESSAGE(KLog);
+ }
+
+ iDrawMode=EClientRedrawsNormal;
+ HideRevealTest();
+ TEST(iClientDidDraw);
+ if (!iClientDidDraw)
+ {
+ LOG_MESSAGE(KLog2);
+ TheClient->WaitForRedrawsToFinish();
+ if (iClientDidDraw)
+ {
+ _LIT(KLog,"After Waiting Redraws had taken place");
+ LOG_MESSAGE(KLog);
+ }
+ }*/
+
+ iTestWin->Win()->EnableRedrawStore(ETrue);
+ isEnabled=iTestWin->Win()->IsRedrawStoreEnabled();
+ TEST(isEnabled);
+ if (!isEnabled)
+ LOG_MESSAGE(KLog1);
+
+ HideRevealTest();
+ iDrawMode=EServerRedraw;
+ HideRevealTest();
+
+ iClientDidDraw=EFalse;
+ TheClient->iWs.ClearAllRedrawStores();
+ iDrawMode=EClientRedrawsNormal;
+ HideRevealTest();
+ TEST(iClientDidDraw);
+ if (!iClientDidDraw)
+ {
+ LOG_MESSAGE(KLog2);
+ TheClient->WaitForRedrawsToFinish();
+ if (iClientDidDraw)
+ {
+ _LIT(KLog,"After Waiting Redraws had taken place");
+ LOG_MESSAGE(KLog);
+ }
+ }
+
+ HideRevealTest();
+ iDrawMode=EServerRedraw;
+ HideRevealTest();
+ }
+
+/**
+@SYMTestCaseID GRAPHICS-WSERV-0092
+
+@SYMDEF DEF081259
+
+@SYMTestCaseDesc Resize Redraws
+
+@SYMTestPriority High
+
+@SYMTestStatus Implemented
+
+@SYMTestActions A window is resized.
+
+@SYMTestExpectedResults When the window decreases in size, the server should be able to
+ redraw it from the store. When it increases in size, a client redraw
+ should occur.
+
+ */
+void CTRedrawStoring::DoResizeTest()
+ {
+ RedrawWindows();
+
+ TSize oldsize = iTestWin->Win()->Size();
+
+ iDrawMode=EServerRedraw;
+ iTestWin->Win()->SetSize(TSize(8, 8));
+ TheClient->Flush();
+ TheClient->WaitForRedrawsToFinish();
+
+ iClientDidDraw=EFalse;
+ iDrawMode=EClientRedrawsNormal;
+ iTestWin->Win()->SetSize(oldsize);
+ TheClient->Flush();
+ TheClient->WaitForRedrawsToFinish();
+ TEST(iClientDidDraw);
+ if (!iClientDidDraw)
+ INFO_PRINTF3(_L("iClientDidDraw - Expected: %d, Actual: %d"), ETrue, iClientDidDraw);
+
+ }
+
+/* TESTCASE: 9
+ * TITLE: Font Cache Overflow
+ * IMPORTANCE: 1
+ * REQUIREMENT: DEF065463
+ *
+ *
+ * API:
+ * #
+ *
+ * ACTION:
+ * The Font Cache is overflowed
+ *
+ * RESULT:
+ * If the font cache overflows or under out of memory conditions,
+ * there should be no leaves, panics or incorrect behaviour of the
+ * local array of font handles.
+ */
+
+ void CTRedrawStoring::DoFontCacheOverflowTestL()
+ {
+ RWindow window(TheClient->iWs);
+ User::LeaveIfError(window.Construct(*TheClient->iGroup->WinTreeNode(), ENullWsHandle));
+ CleanupClosePushL(window);
+ window.Activate();
+ // Display mode is set after window.Activate() purposely to check that drawing
+ // is done in the right mode, in order to test fix for DEF083327
+ User::LeaveIfError(window.SetRequiredDisplayMode(EColor256));
+
+ // run test using a single gc
+ FontCacheOverflowDrawingTestL(EFalse, window);
+ // reset for next test
+ window.Invalidate();
+ iXPlus = ETrue;
+ iYPlus = EFalse;
+ // run test using multiple gcs
+ FontCacheOverflowDrawingTestL(ETrue, window);
+
+ CleanupStack::PopAndDestroy(&window);
+ }
+
+/* TESTCASE: 22
+* TITLE: Scroll Window
+* IMPORTANCE:
+* REQUIREMENT:
+*
+*
+* API:
+* #
+*
+* ACTION:
+* A window is scrolled then a blank window is popped up, made visible and then
+* invisible in order to test that partial redraw storing is drawing window
+* contents properly after hiding the blank window.
+*
+* Before the fix, the contents used to disappear as partial redraw storing was
+* not storing the commands to draw areas outside the defined clipping rect, in
+* this case the area covered by the popped window. Now, the fix makes sure that
+* full redraw to the window is applied when there are atored commands but the
+* changes are performed only in the covered area.
+*
+* RESULT:
+* When the blank window is hidden, the covered area will be redrawn and will
+* contain the original contents before poping the blank window.
+*
+*/
+void CTRedrawStoring::ScrollWinTest()
+ {
+ iDrawMode=EClientRedrawsNormal;
+
+ // Drawing the contents first before scrolling
+ iTestWin->DrawNow();
+
+ // Scrolling the test window and updating its y position
+ iTestWin->DrawableWin()->Scroll(TPoint(0, 25));
+ iYPoz += 25;
+
+ // Invalidating and redrawing the area that should be updated
+ TRect invalidRect(0,25, iWinSize.iWidth, 25*2);
+ iTestWin->Invalidate(invalidRect);
+ iTestWin->Redraw(invalidRect); // Redraw is used instead of DrawNow becuase the later calls Invalidate on the whole window
+
+ // Displaying and then hiding the popup blank window
+ iBlankWin.SetExtent(TPoint(iWinSize.iWidth+40,30), TSize(120, 100));
+ iBlankWin.SetVisible(ETrue);
+ iBlankWin.SetVisible(EFalse);
+ TheClient->Flush();
+ TheClient->WaitForRedrawsToFinish();
+
+ // Resetting iBlankWin to its original size and position for future use
+ // by other test cases
+ iBlankWin.SetExtent(iWinPos, iWinSize);
+ CheckWindowsMatch();
+ iYPoz=0;
+ }
+
+
+TPoint CTRedrawStoring::ComputeTextPosition(TPoint aPoint)
+ {
+ // Bounces text around the screen
+ const TInt KSpacing = 30;
+
+ if(iXPlus)
+ {
+ aPoint.iX += KSpacing;
+ }
+ else
+ {
+ aPoint.iX -= KSpacing;
+ }
+ if(aPoint.iX > iWinSize.iWidth)
+ {
+ aPoint.iX = iWinSize.iWidth - (aPoint.iX - iWinSize.iWidth);
+ iXPlus = EFalse;
+ }
+ else if(aPoint.iX < 0)
+ {
+ aPoint.iX = -1*aPoint.iX;
+ iXPlus = ETrue;
+ }
+
+ if(iYPlus)
+ {
+ aPoint.iY += KSpacing;
+ }
+ else
+ {
+ aPoint.iY -= KSpacing;
+ }
+ if(aPoint.iY > iWinSize.iHeight)
+ {
+ aPoint.iY = iWinSize.iHeight - (aPoint.iY - iWinSize.iHeight);
+ iYPlus = EFalse;
+ }
+ else if(aPoint.iY < 0)
+ {
+ aPoint.iY = -1*aPoint.iY;
+ iYPlus = ETrue;
+ }
+ return aPoint;
+ }
+
+void CTRedrawStoring::FontCacheOverflowDrawingTestL(TBool aDiffGc, RWindow& aWindow)
+ {
+ const TInt KNumFonts = 250;
+ const TInt KNumFontTypes = TheClient->iScreen->NumTypefaces();
+ const TInt KMaxFontSize = 21; // font sizes to be tested in range 1 to 21
+ const TInt KNumTestStyles = 4;
+ const TInt KNumSizes = KNumFonts/(KNumFontTypes * KNumTestStyles) + 1; // chooses a number of font sizes to overflow cache, rounded up
+ TInt textStyle = 0; //determines whether text is not changed (0), bold (1), bold and italic (2) or italic (3)
+ TInt fontType = 0; //increment for different font types
+ TInt currentSize = 1; // start with a font size of 1
+ TInt fontSizeIncrement = KMaxFontSize - currentSize; //defaults to 20
+ if(KNumSizes>2)
+ {
+ fontSizeIncrement = KMaxFontSize/(KNumSizes-1);
+ }
+ TInt numGcs = 1;
+ if(aDiffGc)
+ {
+ numGcs = KNumFonts;
+ }
+ _LIT(KTestText,"b8-/+.,*:");
+ const TSize KScrSize(TheClient->iScreen->SizeInPixels());
+ TSize fontCacheWinSize(KScrSize.iWidth/2,KScrSize.iHeight);
+ iTestWinPoint.SetXY(fontCacheWinSize.iWidth/2, fontCacheWinSize.iHeight/2); //draw initially near the middle of the screen
+
+ CWindowGc* winGc = NULL;
+ RArray<CWindowGc*> winGcList;
+ CleanupClosePushL(winGcList);
+
+ aWindow.BeginRedraw();
+
+ // fill an array with fonts of different styles (see textStyle comment), types, and sizes
+ RArray<CFont*> fontArray;
+ CleanupClosePushL(fontArray);
+ for(TInt ii = 0; ii < KNumFonts; ii++)
+ {
+ if(ii && !(ii % (KNumTestStyles * KNumSizes)))
+ {
+ fontType++;
+ textStyle = 0;
+ currentSize = 1;
+ }
+ else if(ii && !(ii % KNumTestStyles))
+ {
+ currentSize += fontSizeIncrement;
+ textStyle = 0;
+ }
+ TTypefaceSupport support;
+ TheClient->iScreen->TypefaceSupport(support, fontType);
+ TFontSpec fspec(support.iTypeface.iName.Des(), currentSize);
+ switch(textStyle++)
+ {
+ case 0:
+ fspec.iFontStyle.SetPosture(EPostureUpright);
+ break;
+ case 1:
+ fspec.iFontStyle.SetStrokeWeight(EStrokeWeightBold);
+ break;
+ case 2:
+ fspec.iFontStyle.SetPosture(EPostureItalic);
+ break;
+ case 3:
+ fspec.iFontStyle.SetStrokeWeight(EStrokeWeightNormal);
+ break;
+ }
+ CFont* font = NULL;
+ User::LeaveIfError(TheClient->iScreen->GetNearestFontToDesignHeightInPixels(font, fspec));
+ User::LeaveIfError(fontArray.Append(font));
+ font = NULL;
+
+ // Draw to left half of screen using either one gc for all fonts, or using a font per gc, dependent on value of aDiffGc
+ if(ii<numGcs)
+ {
+ winGc = new(ELeave) CWindowGc(TheClient->iScreen);
+ CleanupStack::PushL(winGc);
+ User::LeaveIfError(winGc->Construct());
+ winGc->Activate(aWindow);
+ User::LeaveIfError(winGcList.Append(winGc));
+ }
+ winGc->UseFont(fontArray[ii]);
+ winGc->SetPenColor(TRgb::Color256(ii));
+ winGc->DrawText(KTestText, iTestWinPoint = ComputeTextPosition(iTestWinPoint));
+ }
+
+ aWindow.EndRedraw();
+ TheClient->Flush();
+
+ // Copy the drawing to a bitmap and redraw to the right half of the screen
+ CFbsBitmap* bitmap = new (ELeave) CFbsBitmap;
+ CleanupStack::PushL(bitmap);
+ bitmap->Create(TSize(fontCacheWinSize.iWidth, fontCacheWinSize.iHeight), EColor256);
+ User::LeaveIfError(TheClient->iScreen->CopyScreenToBitmap(bitmap, TRect(fontCacheWinSize)));
+ TPoint copiedBitmapOrigin(fontCacheWinSize.iWidth, 0);
+ TRect bitmapArea(copiedBitmapOrigin, bitmap->SizeInPixels());
+ aWindow.Invalidate(bitmapArea);
+ aWindow.BeginRedraw(bitmapArea);
+ winGc->BitBlt(copiedBitmapOrigin, bitmap);
+ aWindow.EndRedraw();
+ CleanupStack::PopAndDestroy(bitmap);
+
+ // Trigger a redraw (left half of screen)
+ RBlankWindow blankWindow(TheClient->iWs);
+ CleanupClosePushL(blankWindow);
+ User::LeaveIfError(blankWindow.Construct(*TheClient->iGroup->WinTreeNode(), ENullWsHandle));
+ blankWindow.SetSize(TSize(fontCacheWinSize.iWidth, fontCacheWinSize.iHeight));
+ blankWindow.Activate();
+ TheClient->Flush();
+ blankWindow.SetVisible(EFalse);
+ TheClient->Flush();
+ CleanupStack::PopAndDestroy(&blankWindow);
+ TheClient->WaitForRedrawsToFinish();
+ // Compare what is redrawn with copy of original drawing
+ TEST(TheClient->iScreen->RectCompare(TRect(fontCacheWinSize),TRect(copiedBitmapOrigin,fontCacheWinSize)));
+ // Clean up all memory
+ for(TInt kk = 0; kk < KNumFonts; kk++)
+ {
+ if(kk < numGcs)
+ {
+ winGcList[kk]->Deactivate();
+ }
+ TheClient->iScreen->ReleaseFont(fontArray[kk]);
+ }
+ CleanupStack::PopAndDestroy(2+numGcs, &winGcList);
+ }
+
+// As a full fledged test code is written for this implementation.
+// so this test code checks whether this defect is fixed.
+void CTRedrawStoring::DoTestDrawBitmapMaskedL(TInt aWsBitmap/*=EFalse*/)
+ {
+ // Create a source bitmap with display mode EColor16MU and Fill RGB lines successively
+ TInt bitmapWidth=iWinSize.iWidth-40;
+ TInt bitmapHeight=80;
+ TSize bitmapSize(bitmapWidth,bitmapHeight);
+ CFbsBitmap* fbsBitmap=NULL;
+ CWsBitmap* wsBitmap=NULL;
+ if (aWsBitmap)
+ {
+ wsBitmap=new(ELeave) CWsBitmap(TheClient->iWs);
+ CleanupStack::PushL(wsBitmap);
+ User::LeaveIfError(wsBitmap->Create(bitmapSize,EColor16MU));
+ }
+ else
+ {
+ fbsBitmap=new(ELeave) CFbsBitmap();
+ CleanupStack::PushL(fbsBitmap);
+ User::LeaveIfError(fbsBitmap->Create(bitmapSize,EColor16MU));
+ }
+
+ TBitmapUtil bmpUtil(aWsBitmap ? wsBitmap : fbsBitmap);
+ bmpUtil.Begin(TPoint(0,0));
+ TInt row,col;
+ for(row=0;row<bitmapWidth;++row)
+ {
+ bmpUtil.SetPos(TPoint(row,0));
+ for(col=0;col<bitmapHeight;++col)
+ {
+ if (row%3==0)
+ {
+ TRgb rgb(255,0,0);
+ bmpUtil.SetPixel(rgb.Color16M());
+ }
+ else if (row%3==1)
+ {
+ TRgb rgb(0,255,0);
+ bmpUtil.SetPixel(rgb.Color16M());
+ }
+ else
+ {
+ TRgb rgb(0,0,255);
+ bmpUtil.SetPixel(rgb.Color16M());
+ }
+ bmpUtil.IncYPos();
+ }
+ }
+ bmpUtil.End();
+
+ // Create mask bitmap with display mode EGray256 and Fill white and black lines successively
+ CFbsBitmap* fbsBitmapMask=NULL;
+ CWsBitmap* wsBitmapMask=NULL;
+ if (aWsBitmap)
+ {
+ wsBitmapMask=new(ELeave) CWsBitmap(TheClient->iWs);
+ CleanupStack::PushL(wsBitmapMask);
+ User::LeaveIfError(wsBitmapMask->Create(bitmapSize,EGray256));
+ }
+ else
+ {
+ fbsBitmapMask=new(ELeave) CFbsBitmap();
+ CleanupStack::PushL(fbsBitmapMask);
+ User::LeaveIfError(fbsBitmapMask->Create(bitmapSize,EGray256));
+ }
+
+ TBitmapUtil bmpUtilMask(aWsBitmap ? wsBitmapMask : fbsBitmapMask);
+ bmpUtilMask.Begin(TPoint(0,0));
+ for(row=0;row<bitmapWidth;++row)
+ {
+ bmpUtilMask.SetPos(TPoint(row,0));
+ for(col=0;col<bitmapHeight;++col)
+ {
+ if (row%2==0)
+ {
+ bmpUtilMask.SetPixel(0xff000000);
+ }
+ else
+ {
+ bmpUtilMask.SetPixel(0xffffffff);
+ }
+ bmpUtilMask.IncYPos();
+ }
+ }
+ bmpUtilMask.End();
+ CleanupStack::Pop(2); // wsBitmap or fbsBitmap and fbsBitmapMask or wsBitmapMask
+
+ // Create window and draw the content of it by using DrawBitmapMasked
+ // Background to be red
+ TSize screenSize=TheClient->iScreen->SizeInPixels();
+ iWinRect.SetRect(screenSize.iWidth/3,0,2*screenSize.iWidth/3,screenSize.iHeight);
+ iBitmapMaskedWin=CBitmapMaskedWin::NewL(fbsBitmap,fbsBitmapMask,wsBitmap,wsBitmapMask,KRgbRed,bitmapSize,EFalse,aWsBitmap);
+ CleanupStack::PushL(iBitmapMaskedWin);
+ iBitmapMaskedWin->SetExt(TPoint(screenSize.iWidth/3,0),iWinRect.Size());
+ iBitmapMaskedWin->Activate();
+ TheClient->Flush();
+ TheClient->WaitForRedrawsToFinish();
+
+ // Create a bitmap window which in its draw function it just bitblts its content
+ // First fill that bitmap with red color
+ iTestWinPoint.SetXY(2*screenSize.iWidth/3,0);
+ iTestBitmap=CBitmap::NewL(iWinRect.Size(),EColor16MU);
+ CleanupStack::PushL(iTestBitmap);
+ iTestBitmap->Gc().SetBrushColor(TRgb(255,0,0));
+ iTestBitmap->Gc().SetBrushStyle(CGraphicsContext::ESolidBrush);
+ iTestBitmap->Gc().SetPenStyle(CGraphicsContext::ENullPen);
+ iTestBitmap->Gc().DrawRect(iWinRect.Size());
+ iTestBitmap->Gc().Reset();
+ iTestBitmapWin=new(ELeave) CBitMapWin(iTestBitmap);
+ CleanupStack::PushL(iTestBitmapWin);
+ iTestBitmapWin->ConstructExtLD(*TheClient->iGroup,iTestWinPoint,iWinRect.Size());
+ iTestBitmapWin->BaseWin()->SetRequiredDisplayMode(EColor16MU);
+ iTestBitmapWin->BaseWin()->SetShadowDisabled(ETrue);
+ iTestBitmapWin->BaseWin()->SetShadowHeight(0);
+ iTestBitmapWin->AssignGC(*TheClient->iGc);
+ iTestBitmapWin->Activate();
+
+ // This if for testing with Invertmask as EFalse
+ TSize tempSize=bitmapSize;
+ DrawBitmapAndCheckL(tempSize,EColor16MU,(aWsBitmap ? wsBitmap : fbsBitmap),(aWsBitmap ? wsBitmapMask : fbsBitmapMask),EFalse);
+
+ tempSize.SetSize(bitmapSize.iWidth*11/10,bitmapSize.iHeight*11/10);
+ iBitmapMaskedWin->SetDestRectSize(tempSize);
+ iBitmapMaskedWin->DrawNow();
+ TheClient->WaitForRedrawsToFinish();
+ DrawBitmapAndCheckL(tempSize,EColor16MU,(aWsBitmap ? wsBitmap : fbsBitmap),(aWsBitmap ? wsBitmapMask : fbsBitmapMask),EFalse);
+
+ tempSize.SetSize(bitmapSize.iWidth*2/3,bitmapSize.iHeight*2/3);
+ iBitmapMaskedWin->SetDestRectSize(tempSize);
+ iBitmapMaskedWin->DrawNow();
+ TheClient->WaitForRedrawsToFinish();
+ DrawBitmapAndCheckL(tempSize,EColor16MU,(aWsBitmap ? wsBitmap : fbsBitmap),(aWsBitmap ? wsBitmapMask : fbsBitmapMask),EFalse);
+
+ // This if for testing with Invertmask as ETrue
+ tempSize=bitmapSize;
+ iBitmapMaskedWin->SetInvertMask(ETrue);
+ iBitmapMaskedWin->SetDestRectSize(tempSize);
+ iBitmapMaskedWin->DrawNow();
+ TheClient->WaitForRedrawsToFinish();
+ DrawBitmapAndCheckL(tempSize,EColor16MU,(aWsBitmap ? wsBitmap : fbsBitmap),(aWsBitmap ? wsBitmapMask : fbsBitmapMask),ETrue);
+
+ tempSize.SetSize(bitmapSize.iWidth*11/10,bitmapSize.iHeight*11/10);
+ iBitmapMaskedWin->SetDestRectSize(tempSize);
+ iBitmapMaskedWin->DrawNow();
+ TheClient->WaitForRedrawsToFinish();
+ DrawBitmapAndCheckL(tempSize,EColor16MU,(aWsBitmap ? wsBitmap : fbsBitmap),(aWsBitmap ? wsBitmapMask : fbsBitmapMask),ETrue);
+
+ tempSize.SetSize(bitmapSize.iWidth*2/3,bitmapSize.iHeight*2/3);
+ iBitmapMaskedWin->SetDestRectSize(tempSize);
+ iBitmapMaskedWin->DrawNow();
+ TheClient->WaitForRedrawsToFinish();
+ DrawBitmapAndCheckL(tempSize,EColor16MU,(aWsBitmap ? wsBitmap : fbsBitmap),(aWsBitmap ? wsBitmapMask : fbsBitmapMask),ETrue);
+
+ // With bitmap's display mode as EColor256 and invertmask EFalse
+ if (aWsBitmap)
+ {
+ wsBitmap->SetDisplayMode(EColor256);
+ }
+ else
+ {
+ fbsBitmap->SetDisplayMode(EColor256);
+ }
+ iBitmapMaskedWin->BaseWin()->SetRequiredDisplayMode(EColor256);
+ TheClient->Flush();
+ TheClient->WaitForRedrawsToFinish();
+
+ // Delete the tempbitmap and tempbitmapwin and recreate once again.
+ CleanupStack::PopAndDestroy(2); // iTestBitmap, iTestBitmapWin
+ iTestBitmap=NULL;
+ iTestBitmapWin=NULL;
+ iTestBitmap=CBitmap::NewL(iWinRect.Size(),EColor256);
+ CleanupStack::PushL(iTestBitmap);
+ iTestBitmap->Gc().SetBrushColor(TRgb(255,0,0));
+ iTestBitmap->Gc().SetBrushStyle(CGraphicsContext::ESolidBrush);
+ iTestBitmap->Gc().SetPenStyle(CGraphicsContext::ENullPen);
+ iTestBitmap->Gc().DrawRect(iWinRect.Size());
+ iTestBitmap->Gc().Reset();
+ iTestBitmapWin=new(ELeave) CBitMapWin(iTestBitmap);
+ CleanupStack::PushL(iTestBitmapWin);
+ iTestBitmapWin->ConstructExtLD(*TheClient->iGroup,iTestWinPoint,iWinRect.Size());
+ iTestBitmapWin->BaseWin()->SetRequiredDisplayMode(EColor256);
+ iTestBitmapWin->BaseWin()->SetShadowDisabled(ETrue);
+ iTestBitmapWin->BaseWin()->SetShadowHeight(0);
+ iTestBitmapWin->AssignGC(*TheClient->iGc);
+ iTestBitmapWin->Activate();
+ TheClient->Flush();
+ TheClient->WaitForRedrawsToFinish();
+
+ tempSize=bitmapSize;
+ iBitmapMaskedWin->SetInvertMask(EFalse);
+ iBitmapMaskedWin->SetDestRectSize(tempSize);
+ iBitmapMaskedWin->DrawNow();
+ TheClient->WaitForRedrawsToFinish();
+ DrawBitmapAndCheckL(tempSize,EColor256,(aWsBitmap ? wsBitmap : fbsBitmap),(aWsBitmap ? wsBitmapMask : fbsBitmapMask),EFalse);
+
+ tempSize.SetSize(bitmapSize.iWidth*11/10,bitmapSize.iHeight*11/10);
+ iBitmapMaskedWin->SetDestRectSize(tempSize);
+ iBitmapMaskedWin->DrawNow();
+ TheClient->WaitForRedrawsToFinish();
+ DrawBitmapAndCheckL(tempSize,EColor256,(aWsBitmap ? wsBitmap : fbsBitmap),(aWsBitmap ? wsBitmapMask : fbsBitmapMask),EFalse);
+
+ tempSize.SetSize(bitmapSize.iWidth*2/3,bitmapSize.iHeight*2/3);
+ iBitmapMaskedWin->SetDestRectSize(tempSize);
+ iBitmapMaskedWin->DrawNow();
+ TheClient->WaitForRedrawsToFinish();
+ DrawBitmapAndCheckL(tempSize,EColor256,(aWsBitmap ? wsBitmap : fbsBitmap),(aWsBitmap ? wsBitmapMask : fbsBitmapMask),EFalse);
+
+ // With bitmap's display mode as EColor256 and invertmask ETrue
+ tempSize=bitmapSize;
+ iBitmapMaskedWin->SetInvertMask(ETrue);
+ iBitmapMaskedWin->SetDestRectSize(tempSize);
+ iBitmapMaskedWin->DrawNow();
+ TheClient->WaitForRedrawsToFinish();
+ DrawBitmapAndCheckL(tempSize,EColor256,(aWsBitmap ? wsBitmap : fbsBitmap),(aWsBitmap ? wsBitmapMask : fbsBitmapMask),ETrue);
+
+ tempSize.SetSize(bitmapSize.iWidth*11/10,bitmapSize.iHeight*11/10);
+ iBitmapMaskedWin->SetDestRectSize(tempSize);
+ iBitmapMaskedWin->DrawNow();
+ TheClient->WaitForRedrawsToFinish();
+ DrawBitmapAndCheckL(tempSize,EColor256,(aWsBitmap ? wsBitmap : fbsBitmap),(aWsBitmap ? wsBitmapMask : fbsBitmapMask),ETrue);
+
+ tempSize.SetSize(bitmapSize.iWidth*2/3,bitmapSize.iHeight*2/3);
+ iBitmapMaskedWin->SetDestRectSize(tempSize);
+ iBitmapMaskedWin->DrawNow();
+ TheClient->WaitForRedrawsToFinish();
+ DrawBitmapAndCheckL(tempSize,EColor256,(aWsBitmap ? wsBitmap : fbsBitmap),(aWsBitmap ? wsBitmapMask : fbsBitmapMask),ETrue);
+
+ //To test if DrawBitmapMask uses stored commands when called to redraw the bitmap.
+ if (aWsBitmap)
+ {
+ delete wsBitmapMask; //deleting the bitmap
+ wsBitmapMask=NULL;
+ DrawBitmapAndCheckL(tempSize,EColor256,(aWsBitmap ? wsBitmap : fbsBitmap),(aWsBitmap ? wsBitmapMask : fbsBitmapMask),ETrue);
+ }
+ CleanupStack::PopAndDestroy(3,iBitmapMaskedWin); // iBitmapMaskedWin,iTestBitmap,iTestBitmapWin
+ }
+
+void CTRedrawStoring::DrawBitmapAndCheckL(const TSize aSize,TDisplayMode aDisplayMode,CFbsBitmap* aSrceBitmap,CFbsBitmap* aMaskBitmap,TBool aInvertMask)
+ {
+ TBool retVal;
+ if (aMaskBitmap)
+ {
+ TRect srceRect(aSrceBitmap->SizeInPixels());
+ TRect destRect(aSize);
+ CBitmap* srcTempBitmap=CBitmap::NewL(aSize,aDisplayMode);
+ CleanupStack::PushL(srcTempBitmap);
+ srcTempBitmap->Gc().DrawBitmap(destRect,aSrceBitmap,srceRect);
+ CBitmap* maskTempBitmap=CBitmap::NewL(aSize,EGray256);
+ CleanupStack::PushL(maskTempBitmap);
+ maskTempBitmap->Gc().DrawBitmap(destRect,aMaskBitmap,srceRect);
+ iTestBitmap->Gc().SetPenStyle(CGraphicsContext::ENullPen);
+ iTestBitmap->Gc().SetBrushColor(TRgb(255,0,0));
+ iTestBitmap->Gc().SetBrushStyle(CGraphicsContext::ESolidBrush);
+ iTestBitmap->Gc().DrawRect(iWinRect.Size());
+ iTestBitmap->Gc().BitBltMasked(TPoint(),&srcTempBitmap->Bitmap(),destRect,&maskTempBitmap->Bitmap(),aInvertMask);
+ iTestBitmap->Gc().Reset();
+ iTestBitmapWin->DrawNow();
+ TheClient->iWs.Finish();
+ TheClient->WaitForRedrawsToFinish();
+ retVal = TheClient->iScreen->RectCompare(TRect(iWinRect.iTl,aSize),TRect(iTestWinPoint,aSize));
+ TEST(retVal);
+ if (!retVal)
+ INFO_PRINTF3(_L("TheClient->iScreen->RectCompare() return value - Expected: %d, Actual: %d"), ETrue, retVal);
+ CleanupStack::PopAndDestroy(2,srcTempBitmap);
+ }
+ else
+ //To test if DrawBitmapMask uses stored commands, when called to redraw the bitmap.
+ //After the bitmap "wsBitmapMask" is being deleted, the window "iBitmapMaskWin" is first made invisible
+ //and then visible on the screen. This operation invokes draw function which redraws the bitmap by using the stored commands.
+ {
+ iBitmapMaskedWin->SetVisible(EFalse);
+ iBitmapMaskedWin->SetVisible(ETrue);
+ retVal = TheClient->iScreen->RectCompare(TRect(iWinRect.iTl,aSize),TRect(iTestWinPoint,aSize));
+ TEST(retVal);
+ if (!retVal)
+ INFO_PRINTF3(_L("TheClient->iScreen->RectCompare() return value - Expected: %d, Actual: %d"), ETrue, retVal);
+ }
+ }
+
+
+/**
+ @SYMTestCaseID GRAPHICS-CODEBASE-WSERV-0052-0001
+ @SYMPREQ PGM027
+
+ @SYMTestCaseDesc Tests CWsBitmap::BitBltMasked and CFbsBitmap::BitBltMasked API's with \n
+ By passing Null and unexpected values.
+
+ @SYMTestPriority 1
+
+ @SYMTestStatus Implemented
+
+ @SYMTestActions Call BitBltMasked with different ways
+ Source Bitpmap as NULL and MaskBitmap
+ Source Bitmap and MaskBitmap as NULL (For both CFbsBitmap, CWsBitmap)
+
+ @SYMTestExpectedResults Should not panic even if the passed bitmaps are NULL.
+
+ */
+void CTRedrawStoring::DoBitBltAndMaskedNegTestsL()
+ {
+ CWsBitmap* testBitmap=NULL;
+ CWsBitmap* maskBitmap=NULL;
+ // Passing null Masked bitmap
+ (TheClient->iGc)->BitBltMasked(TPoint(20,20), testBitmap, TRect(TPoint(0, 0), TSize(20,20)), maskBitmap, EFalse);
+ testBitmap=new(ELeave) CWsBitmap(TheClient->iWs);
+ CleanupStack::PushL(testBitmap);
+ User::LeaveIfError(testBitmap->Load(TEST_BITMAP_NAME,3));
+ (TheClient->iGc)->BitBltMasked(TPoint(20,20), testBitmap, TRect(TPoint(0, 0), TSize(20,20)), maskBitmap, EFalse);
+ CleanupStack::PopAndDestroy(testBitmap);
+ testBitmap=NULL;
+ maskBitmap=new(ELeave) CWsBitmap(TheClient->iWs);
+ CleanupStack::PushL(maskBitmap);
+ User::LeaveIfError(maskBitmap->Load(TEST_BITMAP_NAME,4));
+ // Passing null source bitmap
+ (TheClient->iGc)->BitBltMasked(TPoint(20,20), testBitmap, TRect(TPoint(0, 0), TSize(20,20)), maskBitmap, EFalse);
+ CleanupStack::PopAndDestroy(maskBitmap);
+ CFbsBitmap* samBitmap=NULL;
+ CFbsBitmap* mskBitmap=NULL;
+ // Passing null Masked bitmap
+ (TheClient->iGc)->BitBltMasked(TPoint(20,20), samBitmap, TRect(TPoint(0, 0), TSize(20,20)), mskBitmap, EFalse);
+ samBitmap=new(ELeave) CWsBitmap(TheClient->iWs);
+ CleanupStack::PushL(samBitmap);
+ User::LeaveIfError(samBitmap->Load(TEST_BITMAP_NAME,3));
+ (TheClient->iGc)->BitBltMasked(TPoint(20,20), samBitmap, TRect(TPoint(0, 0), TSize(20,20)), mskBitmap, EFalse);
+ CleanupStack::PopAndDestroy(samBitmap);
+ samBitmap=NULL;
+ mskBitmap=new(ELeave) CWsBitmap(TheClient->iWs);
+ CleanupStack::PushL(mskBitmap);
+ User::LeaveIfError(mskBitmap->Load(TEST_BITMAP_NAME,4));
+ // Passing null source bitmap
+ (TheClient->iGc)->BitBltMasked(TPoint(20,20), testBitmap, TRect(TPoint(0, 0), TSize(20,20)), mskBitmap, EFalse);
+ CleanupStack::PopAndDestroy(mskBitmap);
+ CWsBitmap* cwBitmap=NULL;
+ TPoint pos(0,0);
+ // Passing null CWsBitmap
+ TheClient->iGc->BitBlt(pos,cwBitmap);
+ TheClient->iGc->BitBlt(pos,cwBitmap,TRect(0,0,10,10));
+ // Passing null CFbsBitmap
+ CFbsBitmap* fbsBitmap=NULL;
+ TheClient->iGc->BitBlt(pos,fbsBitmap);
+ TheClient->iGc->BitBlt(pos,fbsBitmap,TRect(0,0,10,10));
+ }
+
+/* TESTCASE: INC095798
+ * TITLE: Partial Draw Now Test
+ * IMPORTANCE: 1
+ *
+ * ACTION: Changes the color of a rectangle inside a window to simulate CCoeControl::DrawNow()
+ * for an embedded control that does not own a window.
+ *
+ * RESULT: The rectangle should change color immediately, without waiting for a redraw event
+ * from the Window Server, and this should work with or without partial redraw storing and
+ * with or without transparency.
+ */
+void CTRedrawStoring::DoPartialDrawNowTestL( TBool aUseTransparency )
+ {
+ /*
+ * Obtain the color of a particular reference pixel which will be used for
+ * comparison later on when the test window is added covering it.
+ */
+ const TPoint referencePixel(iWinPos+TPoint(50,50));
+ TRgb backgroundReferenceColor;
+ TheClient->Flush();
+ TheClient->WaitForRedrawsToFinish();
+ TheClient->iWs.Finish();
+ TheClient->iScreen->GetPixel(backgroundReferenceColor, referencePixel);
+ /*
+ * Add a test window which emulates a CONE control with a lodger.
+ * The window is transparent according to parameter aUseTransparency
+ */
+ CPartialDrawNowWin* testWin=new(ELeave) CPartialDrawNowWin;
+ CleanupStack::PushL(testWin);
+ testWin->ConstructL(*TheClient->iGroup);
+ testWin->AssignGC(*TheClient->iGc);
+ testWin->SetExt(iWinPos+TPoint(25,25),TSize(300,200));
+ testWin->Win()->SetRequiredDisplayMode(iTestDisplayMode);
+ testWin->Win()->SetShadowDisabled(ETrue);
+ if (aUseTransparency)
+ TEST(testWin->MakeTransparent() == KErrNone);
+ testWin->Win()->Activate();
+ testWin->Redraw();
+ testWin->SetLodger(TRect(20,20,30,30));
+ TheClient->Flush();
+ TheClient->WaitForRedrawsToFinish();
+ TheClient->iWs.Finish();
+ TRgb actualColor;
+ TheClient->iScreen->GetPixel(actualColor,iWinPos+TPoint(50,50));
+ if (aUseTransparency)
+ {
+ CColorBlender* blender = CColorBlender::NewLC(iTestDisplayMode);
+ blender->SetInitialColor(backgroundReferenceColor);
+ blender->Blend(TRgb(0, 0, 255, 127)); //the blue background of the window
+ blender->Blend(TRgb(0, 255, 0, 127)); //the green color of the lodger
+ const TRgb expectedColor = blender->Color();
+ TEST_COLOR_MATCH(expectedColor, actualColor);
+ CleanupStack::PopAndDestroy(blender);
+ }
+ else
+ {
+ TEST_COLOR_MATCH(KRgbGreen, actualColor);
+ }
+ CleanupStack::PopAndDestroy(testWin);
+ }
+
+/*CPartialDrawNowWin*/
+CPartialDrawNowWin::CPartialDrawNowWin()
+ : iLodger( 0, 0, 0, 0 )
+ {}
+
+TInt CPartialDrawNowWin::MakeTransparent()
+ {
+ const TInt err = iWin.SetTransparencyAlphaChannel();
+ if(!err)
+ {
+ iWin.SetBackgroundColor(TRgb(0, 0, 0, 0));
+ iTransparent = ETrue;
+ }
+ return err;
+ }
+
+void CPartialDrawNowWin::SetLodger( const TRect &aLodger )
+ {
+ iLodger = aLodger;
+ iWin.Invalidate( aLodger );
+ Redraw( aLodger );
+ }
+
+void CPartialDrawNowWin::Redraw()
+ {
+ iWin.BeginRedraw();
+ DrawWindowAndLodger();
+ iWin.EndRedraw();
+ }
+
+void CPartialDrawNowWin::Redraw( const TRect &aRect )
+ {
+ iWin.BeginRedraw( aRect );
+ DrawWindowAndLodger();
+ iWin.EndRedraw();
+ }
+
+void CPartialDrawNowWin::DrawWindowAndLodger()
+ {
+ iGc->Activate( iWin );
+ iGc->SetPenStyle( CGraphicsContext::ENullPen );
+ iGc->SetBrushStyle( CGraphicsContext::ESolidBrush );
+ iGc->SetBrushColor( iTransparent ? TRgb(0, 0, 255, 127) : KRgbBlue );
+ iGc->Clear();
+ if (!iLodger.IsEmpty())
+ {
+ iGc->SetBrushColor( iTransparent ? TRgb(0, 255, 0, 127) : KRgbGreen );
+ iGc->DrawRect( iLodger );
+ }
+ iGc->Deactivate();
+ }
+
+
+
+/* TESTCASE: PDEF101789
+ TITLE: Expose Window Test for PDEF101789: WServ does not perform well in 9.2 release.
+
+ ACTION: Draws a base window followed by a top window that completly covers the base window.
+ The base window has an area invalidated and the top window is then moved out of the
+ way to expose the bottom window. The invalid are is then drawn to within a begin/end redraw
+
+ RESULT: The invalid area on the base window should be redrawn correctly betweeen the begin/end
+ redraw pair after the base window has been exposed. The invalid area is drawn in a different
+ colour to the base window.
+ */
+void CTRedrawStoring::DoExposeTestL(TInt aIteration)
+ {
+ _LIT(KErrorMessage,"Expected colour value does not match actual value : Windows not drawn correctly");
+
+ TPartialRedrawType type = iTest->RedrawStoreTypeL();
+ if(type==EPartialRedraw_FullRedrawSupport)
+ {
+ //draw a green coloured base window
+ CPartialRedrawBottomWin* bottomWin = new (ELeave) CPartialRedrawBottomWin();
+ CleanupStack::PushL(bottomWin);
+ bottomWin->ConstructL(*TheClient->iGroup);
+ bottomWin->Init();
+ bottomWin->AssignGC(*TheClient->iGc);
+ bottomWin->BaseWin()->SetShadowDisabled(ETrue);
+ bottomWin->BaseWin()->SetShadowHeight(0);
+ bottomWin->SetExt(iWinPos+TPoint(10,10), iTest->StdTestWindowSize());
+ bottomWin->Win()->Activate();
+ bottomWin->DrawPartial(TRect(TPoint(0,0), iTest->StdTestWindowSize()));
+ TheClient->Flush();
+
+ //draw a red coloured top window that completely covers the base window
+ CPartialRedrawTopWin* topWin = new (ELeave) CPartialRedrawTopWin();
+ CleanupStack::PushL(topWin);
+ topWin->ConstructL(*TheClient->iGroup);
+ topWin->Init();
+ topWin->AssignGC(*TheClient->iGc);
+ topWin->BaseWin()->SetShadowDisabled(ETrue);
+ topWin->BaseWin()->SetShadowHeight(0);
+ topWin->SetExt(iWinPos+TPoint(10,10),iTest->StdTestWindowSize());
+ topWin->Win()->Activate();
+ topWin->DrawPartial(TRect(TPoint(0,0), iTest->StdTestWindowSize()));
+ TheClient->Flush();
+
+ //Invalidate the an area on the bottom window.
+ TRect rect(TPoint(10,10), TSize(iTest->StdTestWindowSize().iWidth/4, iTest->StdTestWindowSize().iHeight/4));
+ bottomWin->Win()->Invalidate(rect);
+
+ //Now expose the bottom window by moving the top window out of the way
+ //using one of the methods below
+ switch(aIteration)
+ {
+ case 0:
+ topWin->Win()->SetOrdinalPosition(-10);
+ break;
+ case 1:
+ topWin->SetPos(iWinPos + TPoint(150,150));
+ break;
+ case 2:
+ topWin->SetVisible(EFalse);
+ break;
+ }
+
+ //now do a begin/end redraw to draw a blue rect to the invalid area on the bottom window
+ bottomWin->Win()->BeginRedraw(rect);
+ bottomWin->Gc()->Activate(*bottomWin->Win());
+ bottomWin->Gc()->SetBrushStyle(CGraphicsContext::ESolidBrush);
+ bottomWin->Gc()->SetBrushColor(TRgb(0,0,255,255));
+ bottomWin->Gc()->SetPenStyle(CGraphicsContext::ESolidPen);
+ bottomWin->Gc()->SetPenColor(0);
+ bottomWin->Gc()->DrawRect(rect);
+ bottomWin->Gc()->Deactivate();
+ bottomWin->Win()->EndRedraw();
+ TheClient->Flush();
+
+ //get the color of a pixel within the invalid area that should be coloured
+ //blue if the window is redrawn correctly. In the defect this blue area is NOT drawn
+ TPoint point =iWinPos + TPoint(30,30);
+ TRgb colour;
+ TheClient->iScreen->GetPixel(colour,point);
+ TRgb expectedColour=TRgb(0,0,255,255);
+ TEST(colour == expectedColour);
+ if (colour!=expectedColour)
+ INFO_PRINTF1(KErrorMessage);
+
+ CleanupStack::PopAndDestroy(2, bottomWin);
+ }
+ }
+/*CPartialRedrawTopWin*/
+void CPartialRedrawTopWin::Init()
+ {
+ Win()->SetRequiredDisplayMode(EColor16MA);
+ Win()->SetTransparencyAlphaChannel();
+ Win()->SetBackgroundColor(TRgb(255,255,255,255));
+ }
+
+void CPartialRedrawTopWin::Draw()
+ {
+ DoDraw();
+ }
+
+void CPartialRedrawTopWin::DoDraw()
+ {
+ DrawFullWindowRect();
+ }
+
+void CPartialRedrawTopWin::DrawFullWindowRect()
+ {
+ TRect rect = TRect(TPoint(0,0),iSize);
+ iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
+ iGc->SetBrushColor(TRgb(255,0,0,255));
+ iGc->DrawRect(rect);
+ }
+
+void CPartialRedrawTopWin::DrawPartial(TRect aRect)
+ {
+ Invalidate(aRect);
+ Win()->BeginRedraw(aRect);
+ iGc->Activate(*Win());
+ DrawFullWindowRect();
+ iGc->Deactivate();
+ Win()->EndRedraw();
+ }
+
+/*CPartialRedrawBottomWin*/
+void CPartialRedrawBottomWin::Init()
+ {
+ Win()->SetRequiredDisplayMode(EColor16MA);
+ Win()->SetTransparencyAlphaChannel();
+ Win()->SetBackgroundColor(TRgb(255,255,255,255));
+ }
+
+void CPartialRedrawBottomWin::Draw()
+ {
+ DoDraw();
+ }
+
+void CPartialRedrawBottomWin::DoDraw()
+ {
+ DrawFullWindowRect();
+ }
+
+void CPartialRedrawBottomWin::DrawFullWindowRect()
+ {
+ TRect rect = TRect(TPoint(0,0),iSize);
+ iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
+ iGc->SetBrushColor(TRgb(0,255,0,255));
+ iGc->DrawRect(rect);
+ }
+
+void CPartialRedrawBottomWin::DrawPartial(TRect aRect)
+ {
+ Invalidate(aRect);
+ Win()->BeginRedraw(aRect);
+ iGc->Activate(*Win());
+ DrawFullWindowRect();
+ iGc->Deactivate();
+ Win()->EndRedraw();
+ }
+
+//CPartialRedrawTiledWin
+
+void CPartialRedrawTiledWin::Init(TRgb aColour,TBool aTransparent)
+ {
+ iColour=aColour;
+ Win()->SetRequiredDisplayMode(EColor16MA);
+ if(aTransparent)
+ {
+ Win()->SetTransparencyAlphaChannel();
+ }
+ Win()->SetBackgroundColor(iColour);
+ }
+
+void CPartialRedrawTiledWin::Draw()
+ {
+ DoDraw();
+ }
+
+void CPartialRedrawTiledWin::DoDraw()
+ {
+ DrawFullWindowRect();
+ }
+
+void CPartialRedrawTiledWin::DrawFullWindowRect()
+ {
+ TRect rect = TRect(TPoint(0,0),iSize);
+ iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
+ iGc->SetBrushColor(iColour);
+ iGc->DrawRect(rect);
+ }
+
+void CPartialRedrawTiledWin::DrawPartial(TRect aRect)
+ {
+ Invalidate(aRect);
+ Win()->BeginRedraw(aRect);
+ iGc->Activate(*Win());
+ DrawFullWindowRect();
+ iGc->Deactivate();
+ Win()->EndRedraw();
+ }
+
+/* TESTCASE: DEF101889
+ TITLE: Expose Window Test for DEF101889 Windows tiled by opaque children do not redraw correctly
+ under certain use cases
+
+ ACTION: Draws a base window then a further window over it that is tiled by opaque children.
+ This window is then, either completely or partially, covered by a transparent window.
+ The tiled window is then set invisible. Drawing is then performed to the base window.
+
+ RESULT: The windows should be correctly drawn. More specifically the transparent top window should draw
+ the correct window underneath it. i.e. after the setinvisible command the base window should be
+ drawn
+ */
+void CTRedrawStoring::DoExposeTest2L(TInt aIteration)
+ {
+ //This test reproduces problems found during the fixing of DEF096874: WServ does not perform well in 9.2 release.
+ //The issues (described later) only exhbit themselves when there are no shadows present in the system.
+ //Unfortunatly there is no direct way of disabling shadows from the test code so under normal running the
+ //following tests will never hit the defect and always pass.
+ //To disable shadows the WSERV source code has to be manually altered by editing the CWsClientWindow::CommandL
+ //method in clwin.cpp. In the EWsWinOpSetShadowHeight case alter the SetHeightDiff(*pData.Int); function call
+ //to read SetHeightDiff(0);
+ //The use cases are related to DEF096874 in that the problem occurs when we have 2 windows overlaying each other
+ //where the top window is completely tiled by child windows. DEF096874 occurs when the window that is tiled is made
+ //invisible, with the result that the windows are not redrawn correctly.
+ //The use cases reproduced by this test are when the two windows are either fully or partially obscured by a
+ //further transparent window laid over the both of them. When the tiled window is made invisible then
+ //the windows are not updated properly resulting in either transparency problems or the windows not being drawn
+ //correctly.
+ //There are further use cases not addressed here i.e. tiled windows becoming visible underneath a transparent window
+ //that relate to the same fundamental problem but are correctlly addressed by the defect fix.
+
+ TPartialRedrawType type=iTest->RedrawStoreTypeL();
+ if(type!=EPartialRedraw_FullRedrawSupport)
+ return;
+
+ _LIT(KErrorMessage,"Pixel expected to have colour 0x%x has color 0x%x");
+ const TSize winSize=iTest->StdTestWindowSize();
+ const TInt offset=winSize.iWidth/2;
+
+ //draw a green coloured base window
+ CPartialRedrawBottomWin* underWin = new(ELeave) CPartialRedrawBottomWin();
+ CleanupStack::PushL(underWin);
+ underWin->ConstructL(*TheClient->iGroup);
+ underWin->Init();
+ underWin->AssignGC(*TheClient->iGc);
+ underWin->BaseWin()->SetShadowDisabled(ETrue);
+ underWin->SetExt(iWinPos+TPoint(10,10),winSize);
+ underWin->Win()->Activate();
+ underWin->DrawPartial(TRect(winSize));
+ if (TDisplayModeUtils::NumDisplayModeColors(underWin->BaseWin()->DisplayMode())<=4096)
+ {
+ CleanupStack::PopAndDestroy(underWin);
+ _LIT(KLog,"Cannot run test without more than 4K colors");
+ LOG_MESSAGE(KLog);
+ return;
+ }
+
+ //draw a red coloured top window that completly covers the base window
+ CPartialRedrawTopWin* overWin = new (ELeave) CPartialRedrawTopWin();
+ CleanupStack::PushL(overWin);
+ overWin->ConstructL(*TheClient->iGroup);
+ overWin->Init();
+ overWin->AssignGC(*TheClient->iGc);
+ overWin->BaseWin()->SetShadowDisabled(ETrue);
+ overWin->SetExt(iWinPos+TPoint(10,10),winSize);
+ overWin->Win()->Activate();
+ overWin->DrawPartial(TRect(winSize));
+
+ //create the two tiles to attach to the top window
+ CPartialRedrawTiledWin* tile = new (ELeave) CPartialRedrawTiledWin();
+ CleanupStack::PushL(tile);
+ tile->ConstructL(*overWin);
+ tile->Init(TRgb(255,255,0,255),EFalse);
+ tile->AssignGC(*TheClient->iGc);
+ tile->BaseWin()->SetShadowDisabled(ETrue);
+ tile->SetSize(winSize);
+ tile->Win()->Activate();
+ tile->DrawPartial(TRect(winSize));
+
+ //create a transparent window overlaying the whole arrangement
+ CPartialRedrawTiledWin* transparentWin = new (ELeave) CPartialRedrawTiledWin();
+ CleanupStack::PushL(transparentWin);
+ transparentWin->ConstructL(*TheClient->iGroup);
+ transparentWin->Init(TRgb(255,255,255,0),ETrue);
+ transparentWin->AssignGC(*TheClient->iGc);
+ transparentWin->BaseWin()->SetShadowDisabled(ETrue);
+ //for the first iteration have the transparent window fully covering the other windows
+ //for the second iteration have the tansparent window partially covering the other windows.
+ transparentWin->SetExt(iWinPos+TPoint(10+(aIteration==0?0:offset),10),winSize);
+ transparentWin->Win()->Activate();
+ transparentWin->DrawPartial(TRect(winSize));
+
+ //Now expose the bottom window (underWin) by setting the top window (overWin) invisible
+ //the opaque child window (tile) should also go invisible
+ overWin->SetVisible(EFalse);
+ TheClient->Flush();
+ TheClient->WaitForRedrawsToFinish();
+ //get the color of a pixel within the window. If everything has been drawn correctly the
+ //pixel should be green ( the colour of the base window, underWin)
+ TPoint point =iWinPos + TPoint(30,30);
+ TRgb colour;
+ TheClient->iScreen->GetPixel(colour,point);
+ TRgb expectedColour=TRgb(0,255,0,255);
+ TEST(colour == expectedColour);
+ if (colour!=expectedColour)
+ LOG_MESSAGE3(KErrorMessage,expectedColour.Value(),colour.Value());
+ //for partially covered windows the above code tests the uncovered region so an additional test
+ //is needed on a pixel in the covered region.
+ if (aIteration!=0)
+ {
+ point+=TPoint(offset,0);
+ TheClient->iScreen->GetPixel(colour,point);
+ TEST(colour==expectedColour);
+ if (colour!=expectedColour)
+ LOG_MESSAGE3(KErrorMessage,expectedColour.Value(),colour.Value());
+ }
+ CleanupStack::PopAndDestroy(4, underWin); //tile,topWin,transparentWin
+ }
+
+/* Test automatically purging the redraw store */
+
+CResetRedrawStoreWin* CTRedrawStoring::CreatePartialRedrawWinLC(const TPoint &aPos, const TSize &aSize, CTWin *aParent)
+ {
+ CResetRedrawStoreWin* testWin = new (ELeave) CResetRedrawStoreWin();
+ CleanupStack::PushL(testWin);
+ if (aParent)
+ testWin->ConstructL(*aParent);
+ else
+ testWin->ConstructL(*TheClient->iGroup);
+ testWin->Init();
+ testWin->AssignGC(*TheClient->iGc);
+ testWin->BaseWin()->SetShadowDisabled(ETrue);
+ testWin->BaseWin()->SetShadowHeight(0);
+ testWin->Win()->SetVisible(EFalse);
+ testWin->Win()->Activate();
+ testWin->SetExt(aPos,aSize);
+ testWin->SetVisible(ETrue);
+ return(testWin);
+ }
+
+CNoDrawWin* CTRedrawStoring::CreateNoDrawWinLC(const TPoint &aPos, const TSize &aSize)
+ {
+ CNoDrawWin* noDrawWin=new (ELeave) CNoDrawWin();
+ CleanupStack::PushL(noDrawWin);
+ noDrawWin->ConstructExtLD(*TheClient->iGroup, aPos, aSize);
+ noDrawWin->AssignGC(*TheClient->iGc);
+ noDrawWin->Win()->SetRequiredDisplayMode(iTestDisplayMode);
+ noDrawWin->Win()->SetTransparencyAlphaChannel();
+ noDrawWin->Win()->SetBackgroundColor(TRgb(127,127,127,127));
+ noDrawWin->BaseWin()->SetShadowDisabled(ETrue);
+ noDrawWin->BaseWin()->SetShadowHeight(0);
+ noDrawWin->Win()->SetVisible(ETrue);
+ noDrawWin->Activate();
+ noDrawWin->Win()->BeginRedraw();
+ noDrawWin->Gc()->Activate(*noDrawWin->Win());
+ CPartialRedrawWin::DrawRects(*noDrawWin->Gc(), aSize,
+ TPoint(0,0), ETrue, EPartialRedraw_Unknown);
+ noDrawWin->Gc()->Deactivate();
+ noDrawWin->Win()->EndRedraw();
+ return(noDrawWin);
+ }
+
+void CTRedrawStoring::AutoResetRedrawStoreTestsL()
+ {
+ //PeterI This tests redraw store resetting by monitoring the wserv heap.
+ //It currently fails as it performs too many iterations of the test i.e. it doesn't reset as frequently
+ //as the orignal werv. Needs investigation to determine what the expected number of resets should be for
+ //the Mk3 wserv.
+ /*
+ if (iPartialRedrawType==EPartialRedraw_FullRedrawSupport)
+ {
+ const TInt startWsHeapCount=TheClient->iWs.HeapCount();
+ const TInt KNumFlagsToTest=4;
+ const TInt KNumFlagStatesToTest=1<<KNumFlagsToTest;
+ for(TUint flags=0;flags<KNumFlagStatesToTest;flags++)
+ {
+ #if defined(LOGGING)
+ _LIT(KLog,"AutoResetRedrawStoreTestsL, running test with flags 0x%x");
+ LOG_MESSAGE2(KLog,flags);
+ #endif
+ DoAutoResetRedrawStoreTestL(flags&0x01,flags&0x02,flags&0x04,flags&0x08);
+ }
+ // Granularity of buffers can leave odd extra cells, hard to specify an exact amount
+ // This may need tweaking again future, should hand verify any gains are not cumulative
+ // by running this test multiple times and making sure the total does not keep
+ // rising everytime around.
+ const TInt KHeapTotalSafetyMargin=16;
+ const TInt endHeapCount=TheClient->iWs.HeapCount();
+ TEST((startWsHeapCount+KHeapTotalSafetyMargin)>=endHeapCount);
+ }
+ */
+ }
+
+void CTRedrawStoring::DoAutoResetRedrawStoreTestL(TBool aTwoWins, TBool aAnimateBothWins, TBool aKeepGcActive, TBool aUpdateInRedraw)
+ {
+ TRect testRect1(iTestWin->BaseWin()->InquireOffset(*TheClient->iGroup->WinTreeNode()),iWinSize);
+ TRect testRect2(iCheckWin->BaseWin()->InquireOffset(*TheClient->iGroup->WinTreeNode()),iWinSize);
+//
+ TSize testWinSize1(iWinSize.iWidth/3,iWinSize.iHeight/3);
+ TSize testWinSize2(iWinSize.iWidth/2,iWinSize.iHeight/2);
+ TPoint topLeft=iWinPos+TPoint(100,100);
+ TInt tooBig=topLeft.iX+testWinSize1.iWidth-testRect1.iBr.iX;
+ if (tooBig>0)
+ topLeft.iX-=tooBig;
+
+ CResetRedrawStoreWin* testWin1=CreatePartialRedrawWinLC(topLeft,testWinSize1);
+ CResetRedrawStoreWin* testWin2=CreatePartialRedrawWinLC(topLeft-TPoint(50,50),testWinSize2);
+ testWin1->SetUpdateInRedraw(aUpdateInRedraw);
+ testWin2->SetUpdateInRedraw(aUpdateInRedraw);
+//
+ topLeft+=iCheckWin->Position()-iWinPos;
+ CResetRedrawStoreWin* tW1=CreatePartialRedrawWinLC(topLeft,testWinSize1);
+ CResetRedrawStoreWin* tW2=CreatePartialRedrawWinLC(topLeft-TPoint(50,50),testWinSize2);
+ tW1->SetUpdateInRedraw(aUpdateInRedraw);
+ tW2->SetUpdateInRedraw(aUpdateInRedraw);
+//
+ TheClient->Flush();
+ TheClient->WaitForRedrawsToFinish();
+//
+ const TInt KNumTestResets1=5;
+ const TInt KNumTestResets2=15;
+ const TInt KMaxIterationsPerReset=20;
+ const TInt numTestResets=aTwoWins?KNumTestResets2:KNumTestResets1;
+ const TInt maxTotalIterations=numTestResets*KMaxIterationsPerReset;
+ TInt resets=0;
+//
+ const TInt startWsHeapCount=TheClient->iWs.HeapCount();
+ TInt baseWsHeapCount=startWsHeapCount;
+ TInt prevWsHeapCount=0;
+ TInt totalIterations=0;
+ testWin1->SetKeepGcActive(aKeepGcActive);
+ if (aAnimateBothWins)
+ testWin2->SetKeepGcActive(aKeepGcActive);
+ do
+ {
+ testWin1->UpdateAnim(1);
+ testWin1->UpdateAnim(1);
+ testWin1->UpdateAnim(1);
+ if (aAnimateBothWins)
+ testWin2->UpdateAnim(3);
+ if (aTwoWins)
+ {
+ tW1->UpdateAnim(1);
+ tW1->UpdateAnim(2);
+ if (aAnimateBothWins)
+ {
+ tW2->UpdateAnim(1);
+ tW2->UpdateAnim(1);
+ tW2->UpdateAnim(1);
+ }
+ }
+ TBool failed=testWin1->Failed();
+ TEST(!failed);
+ if (failed)
+ {
+ _LIT(KLog,"Window had fail flag set");
+ LOG_MESSAGE(KLog);
+ }
+//
+ TheClient->Flush();
+ TheClient->WaitForRedrawsToFinish();
+ if (aTwoWins && !aUpdateInRedraw)
+ {
+ TBool match=TheClient->iScreen->RectCompare(testRect1,testRect2);
+ TEST(match);
+ if (!match)
+ {
+ _LIT(KLog,"Rectangle Area doesn't match, resets=%d (TwoWins=%d,AnimateBoth=%d,KeepActive=%d,InRedraw=%d)");
+ LOG_MESSAGE6(KLog,resets,aTwoWins,aAnimateBothWins,aKeepGcActive,aUpdateInRedraw);
+ }
+ }
+ const TInt wsHeapCount=TheClient->iWs.HeapCount();
+ TInt lowGap=wsHeapCount-baseWsHeapCount;
+ TInt highGap=prevWsHeapCount-wsHeapCount;
+ if (prevWsHeapCount>0 && ((aAnimateBothWins || aTwoWins)?highGap>0:lowGap<highGap))
+ {
+ baseWsHeapCount=wsHeapCount;
+ resets++;
+ }
+ totalIterations++;
+ if (totalIterations>=maxTotalIterations)
+ {
+ TEST(EFalse);
+ _LIT(KLog,"Too many iterations, number %d, max expect %d");
+ LOG_MESSAGE3(KLog,totalIterations,maxTotalIterations);
+ break;
+ }
+ prevWsHeapCount=wsHeapCount;
+ } while(resets<numTestResets);
+ if (!aTwoWins && !aAnimateBothWins)
+ { // With two wins resetting of the redraw store will be out of sync, so heap won't be reset
+ if (aTwoWins || aAnimateBothWins || aKeepGcActive || !aUpdateInRedraw)
+ { // First time around with aUpdateInRedraw causes extra redraw store buffer allocation
+ const TInt endHeapCount=TheClient->iWs.HeapCount();
+ const TInt KHeapSafetyMargin=4; // Granularity of buffers can leave odd extra cells, hard to specify an exact amount
+ TBool heapUsageError=(startWsHeapCount+KHeapSafetyMargin>=endHeapCount);
+ TEST(heapUsageError);
+ if (!heapUsageError)
+ {
+ _LIT(KLog,"Memory Allocation Error, Before=%d, After=%d (Allowable Margin=%d)");
+ LOG_MESSAGE4(KLog,startWsHeapCount,endHeapCount,KHeapSafetyMargin);
+ }
+ }
+ }
+//
+ CleanupStack::PopAndDestroy(4, testWin1);
+ }
+
+void CTRedrawStoring::RedrawStoreWithSetExtentL()
+/* Test how the redraw store deals with windows changing their extent
+*/
+ {
+ TSize testSize(4*iWinSize.iWidth/7, iWinSize.iHeight);
+ TRect testRect1(iTestWin->BaseWin()->InquireOffset(*TheClient->iGroup->WinTreeNode()),testSize);
+ TRect testRect2(iCheckWin->BaseWin()->InquireOffset(*TheClient->iGroup->WinTreeNode()),testSize);
+ TSize testWinSize1a;
+ TSize testWinSize2;
+ TPoint winOffset1;
+ TPoint winOffset2;
+ GetTestWinSizeAndPos(1,winOffset1,testWinSize1a);
+ GetTestWinSizeAndPos(0,winOffset2,testWinSize2);
+ TPoint winPos1(iWinPos + winOffset1);
+ enum TSetExtentTestMode {ESetExtentTestModeExpandXY,ESetExtentTestModeExpandY,ESetExtentTestModeShrinkXY,ESetExtentTestModeShrinkY,ESetExtentTestModeShrinkXExpandY,ESetExtentTestModeCount};
+ for(TInt extMode=ESetExtentTestModeExpandXY;extMode<ESetExtentTestModeCount;extMode++)
+ {
+ enum TSetExtentInvalidateTestMode {ESetExtentInvalidateTestModeBefore,ESetExtentInvalidateTestModeAfter,ESetExtentInvalidateTestModeBeforeWithRedraw,ESetExtentInvalidateTestModeCount};
+ for(TInt invalidateMode=ESetExtentInvalidateTestModeBefore;invalidateMode<ESetExtentInvalidateTestModeCount;invalidateMode++)
+ {
+ TSize testWinSize1b(testWinSize1a);
+ switch(extMode)
+ {
+ case ESetExtentTestModeExpandXY:
+ testWinSize1b.iWidth=iWinSize.iWidth/4;
+ testWinSize1b.iHeight=iWinSize.iHeight/4;
+ break;
+ case ESetExtentTestModeExpandY:
+ testWinSize1b.iHeight=iWinSize.iHeight/4;
+ break;
+ case ESetExtentTestModeShrinkXY:
+ testWinSize1b.iWidth=iWinSize.iWidth/2;
+ testWinSize1b.iHeight=iWinSize.iHeight/2;
+ break;
+ case ESetExtentTestModeShrinkY:
+ testWinSize1b.iHeight=iWinSize.iHeight/2;
+ break;
+ case ESetExtentTestModeShrinkXExpandY:
+ testWinSize1b.iWidth=iWinSize.iWidth/2;
+ testWinSize1b.iHeight=iWinSize.iHeight/4;
+ break;
+ }
+
+ CResetRedrawStoreWin* testWin1=CreatePartialRedrawWinLC(winPos1, testWinSize1b);
+ CResetRedrawStoreWin* testWin2=CreatePartialRedrawWinLC(iWinPos + winOffset2, testWinSize2);
+ CResetRedrawStoreWin* tW1=CreatePartialRedrawWinLC(iCheckWin->Position() + winOffset1, testWinSize1a);
+ CResetRedrawStoreWin* tW2=CreatePartialRedrawWinLC(iCheckWin->Position() + winOffset2, testWinSize2);
+ TheClient->Flush();
+ TheClient->WaitForRedrawsToFinish();
+//
+ if (invalidateMode==ESetExtentInvalidateTestModeBeforeWithRedraw)
+ {
+ testWin1->PreSetSize(testWinSize1a);
+ testWin1->DrawNow();
+ }
+ if (invalidateMode==ESetExtentInvalidateTestModeBefore)
+ testWin1->Invalidate();
+ testWin1->SetExt(winPos1,testWinSize1a);
+ if (invalidateMode==ESetExtentInvalidateTestModeAfter)
+ testWin1->Invalidate();
+ TheClient->Flush();
+ TBool redrawWaiting=TheClient->WaitUntilRedrawPending();
+ TheClient->WaitForRedrawsToFinish();
+ TInt testRet=TheClient->iScreen->RectCompare(testRect1,testRect2);
+ if (!testRet)
+ {
+ TEST(EFalse);
+ _LIT(KRedrawStoreSetExtentFail,"Fade Regions fail: extMode=%d, invalidateMode=%d");
+ LOG_MESSAGE3(KRedrawStoreSetExtentFail,extMode,invalidateMode);
+ }
+//
+ CleanupStack::PopAndDestroy(4, testWin1);
+ }
+ }
+ }
+
+void CTRedrawStoring::PartialRedrawWithEmptyRedrawStoreL()
+ {
+ for(TInt numWins=1;numWins<4;numWins++)
+ {
+ const TInt KNumTestFlags=3;
+ for(TUint flags=0;flags<(1<<KNumTestFlags);flags++)
+ DoPartialRedrawWithEmptyRedrawStoreL(numWins,flags&0x1,flags&0x2,flags&0x4);
+ }
+ }
+
+void CTRedrawStoring::DoPartialRedrawWithEmptyRedrawStoreL(TInt aNumWins, TBool aDoWinOnTop, TBool aRedrawWindow, TBool aChildWindows)
+/* This code has been written to verify how the partial redraw store deals with the
+case where it gets a partial redraw at a time when the redraw store is empty and awaiting
+a replacement set of commands using low priority redraws.
+*/
+ {
+ if (aChildWindows && aNumWins<2)
+ return; // No point in this one, same as without flag set
+ TSize testWinSize1(iWinSize.iWidth/3, iWinSize.iHeight/3);
+ TSize testWinSize2(iWinSize.iWidth/2, iWinSize.iHeight/2);
+ TSize testWinSize3(iWinSize.iWidth*2/3, iWinSize.iHeight/4);
+ TPoint winOffset1(iWinSize.iWidth/2,iWinSize.iHeight/2);
+ TPoint nullPos;
+ if (aChildWindows)
+ {
+ testWinSize1.iWidth*=2;
+ testWinSize1.iHeight*=2;
+ winOffset1.iX=Min(50,iWinSize.iWidth-testWinSize1.iWidth);
+ winOffset1.iY=50;
+ }
+ CResetRedrawStoreWin* testWin1=CreatePartialRedrawWinLC(iWinPos + winOffset1, testWinSize1);
+ CResetRedrawStoreWin* tW1=CreatePartialRedrawWinLC(iCheckWin->Position() + winOffset1, testWinSize1);
+ CResetRedrawStoreWin* testWin2=NULL;
+ CResetRedrawStoreWin* testWin3=NULL;
+ if (aChildWindows)
+ {
+ TPoint winOffset2(TPoint(testWinSize1.iWidth/4,testWinSize1.iHeight/3));
+ testWin2=CreatePartialRedrawWinLC(winOffset2, testWinSize2, aChildWindows?testWin1:NULL);
+ CreatePartialRedrawWinLC(winOffset2, testWinSize2, aChildWindows?tW1:NULL);
+ if (aNumWins>2)
+ {
+ TPoint winOffset3(TPoint(testWinSize1.iWidth/2,testWinSize1.iHeight*2/3));
+ testWin3=CreatePartialRedrawWinLC(winOffset3, testWinSize3, aChildWindows?testWin1:NULL);
+ CreatePartialRedrawWinLC(winOffset3, testWinSize3, aChildWindows?tW1:NULL);
+ }
+ }
+ else
+ {
+ if (aNumWins>1)
+ {
+ TPoint winOffset2(TPoint(50,50));
+ testWin2=CreatePartialRedrawWinLC(iWinPos + winOffset2, testWinSize2, aChildWindows?testWin1:NULL);
+ CreatePartialRedrawWinLC(iCheckWin->Position() + winOffset2, testWinSize2, aChildWindows?tW1:NULL);
+ if (aNumWins>2)
+ {
+ TPoint winOffset3(TPoint(iWinSize.iWidth/6,iWinSize.iHeight/3));
+ testWin3=CreatePartialRedrawWinLC(iWinPos + winOffset3, testWinSize3, aChildWindows?testWin1:NULL);
+ CreatePartialRedrawWinLC(iCheckWin->Position() + winOffset3, testWinSize3, aChildWindows?tW1:NULL);
+ }
+ }
+ }
+ TheClient->Flush();
+ TheClient->WaitForRedrawsToFinish();
+ iDrawMode=EClientRedrawsNormal;
+//
+ TSize testSize(4*iWinSize.iWidth/7, iWinSize.iHeight);
+ TRect testRect1(iTestWin->BaseWin()->InquireOffset(*TheClient->iGroup->WinTreeNode()),testSize);
+ TRect testRect2(iCheckWin->BaseWin()->InquireOffset(*TheClient->iGroup->WinTreeNode()),testSize);
+ TRect partialRedrawRect1(0,testWinSize1.iHeight/4,testWinSize1.iWidth,testWinSize1.iHeight*3/4);
+ TRect partialRedrawRect2(0,testWinSize2.iHeight/4,testWinSize1.iWidth,testWinSize2.iHeight*3/4);
+ TRect partialRedrawRect3(testWinSize3.iWidth/4,0,testWinSize3.iWidth*3/4,testWinSize3.iHeight);
+ iBlankWin.SetExtent(iWinPos+winOffset1+partialRedrawRect1.iTl, partialRedrawRect1.Size());
+ const TInt KDoWindow1=0x01;
+ const TInt KDoWindow2=0x02;
+ const TInt KDoWindow3=0x04;
+ TInt numWinModes=1<<aNumWins;
+ for(TInt invalidateWindowFlags=0;invalidateWindowFlags<numWinModes;invalidateWindowFlags++)
+ {
+ TheClient->iWs.ClearAllRedrawStores();
+ if (invalidateWindowFlags&KDoWindow1)
+ testWin1->Invalidate(partialRedrawRect1);
+ if (invalidateWindowFlags&KDoWindow2)
+ testWin2->Invalidate(partialRedrawRect2);
+ if (invalidateWindowFlags&KDoWindow3)
+ testWin3->Invalidate(partialRedrawRect3);
+ if (aRedrawWindow)
+ {
+ if (invalidateWindowFlags&KDoWindow1)
+ testWin1->Redraw(partialRedrawRect1);
+ if (invalidateWindowFlags&KDoWindow2)
+ testWin1->Redraw(partialRedrawRect2);
+ if (invalidateWindowFlags&KDoWindow3)
+ testWin1->Redraw(partialRedrawRect3);
+ }
+ if (aDoWinOnTop)
+ {
+ iBlankWin.SetOrdinalPosition(0);
+ iBlankWin.SetVisible(ETrue);
+ iBlankWin.SetVisible(EFalse);
+ }
+ TheClient->Flush();
+ TheClient->WaitForRedrawsToFinish();
+ //
+ TBool match=TheClient->iScreen->RectCompare(testRect1,testRect2);
+ TEST(match);
+ if (!match)
+ {
+ _LIT(KLog,"Rectangle area doesn't match, windows=%d, flags=%d,%d,%d");
+ LOG_MESSAGE5(KLog,aNumWins,aDoWinOnTop,aRedrawWindow,aChildWindows);
+ }
+ }
+ // Resetting iBlankWin to its original size and position for future use
+ // by other test cases
+ iBlankWin.SetExtent(iWinPos,iWinSize);
+ // window handles which are pushed onto cleanup stack, shall be deleted here
+ CleanupStack::PopAndDestroy(aNumWins*2,testWin1);
+ }
+
+/**
+@SYMTestCaseID GRAPHICS-WSERV-103713-0001
+
+@SYMDEF PDEF106998
+
+@SYMTestCaseDesc Empty Draw Test
+
+@SYMTestPriority
+
+@SYMTestStatus Implemented
+
+@SYMTestActions Draws an empty base window followed by an empty top window.
+ The top window is drawn in one of two cases:
+ completely covering the bottom window or
+ only covering the area that will be drawn to
+
+ A red rectangle is drawn to the bottom window and the top window is made invisible.
+
+@SYMTestExpectedResults The tested pixel colour should be red. Test will fail if the red rectangle
+ is not drawn or if an infinite loop is detected.
+
+*/
+void CTRedrawStoring::DoEmptyDrawTestL(TInt aTestMode)
+ {
+ _LIT(KErrorMessage,"Infinite Loop");
+
+ TPartialRedrawType type = iTest->RedrawStoreTypeL();
+ if(type==EPartialRedraw_FullRedrawSupport)
+ {
+ TBool testStatus = EFalse;
+
+ //draw an empty, green base window
+ CPartialRedrawEmptyWin* bottomWin = new (ELeave) CPartialRedrawEmptyWin();
+ CleanupStack::PushL(bottomWin);
+ bottomWin->ConstructL(*TheClient->iGroup);
+ bottomWin->Init(KRgbGreen);
+ bottomWin->AssignGC(*TheClient->iGc);
+ bottomWin->BaseWin()->SetShadowDisabled(ETrue);
+ bottomWin->BaseWin()->SetShadowHeight(0);
+ bottomWin->SetExt(iWinPos+TPoint(10,10), iWinSize);
+ bottomWin->Win()->Activate();
+ bottomWin->DrawPartial(TRect(TPoint(0,0), iWinSize));
+ TheClient->Flush();
+
+ //draw an empty, blue top window
+ CPartialRedrawEmptyWin* topWin = new (ELeave) CPartialRedrawEmptyWin();
+ CleanupStack::PushL(topWin);
+ topWin->ConstructL(*TheClient->iGroup);
+ topWin->Init(KRgbBlue);
+ topWin->AssignGC(*TheClient->iGc);
+ topWin->BaseWin()->SetShadowDisabled(ETrue);
+ topWin->BaseWin()->SetShadowHeight(0);
+
+ switch(aTestMode)
+ {
+ case 0:
+ // top window is completely covering the base window
+ topWin->SetExt(iWinPos+TPoint(10,10), iWinSize);
+ break;
+ case 1:
+ // top window only covers the upper left hand corner,
+ // over where the red rectangle will be drawn
+ topWin->SetExt(iWinPos+TPoint(-5,-5), iWinSize);
+ break;
+ }
+
+ topWin->Win()->Activate();
+ topWin->DrawPartial(TRect(TPoint(0,0), iWinSize));
+ TheClient->Flush();
+
+ //Invalidate the an area on the top window.
+ TRect smallrect(TPoint(10,10), TSize(iWinSize.iWidth/4, iWinSize.iHeight/4));
+ topWin->Win()->Invalidate(smallrect);
+
+ //draw a small red rectangle on the bottom window
+ bottomWin->Win()->BeginRedraw(smallrect);
+ bottomWin->Gc()->Activate(*bottomWin->Win());
+ bottomWin->Gc()->SetBrushStyle(CGraphicsContext::ESolidBrush);
+ bottomWin->Gc()->SetBrushColor(KRgbRed);
+ bottomWin->Gc()->SetPenStyle(CGraphicsContext::ESolidPen);
+ bottomWin->Gc()->SetPenColor(0);
+ bottomWin->Gc()->DrawRect(smallrect);
+ bottomWin->Gc()->Deactivate();
+ bottomWin->Win()->EndRedraw();
+ TheClient->Flush();
+ TheClient->WaitForRedrawsToFinish();
+
+ // hide the top window, so that the bottom window will be redrawn
+ topWin->SetVisible(EFalse);
+ TheClient->Flush();
+ TheClient->WaitForRedrawsToFinish();
+
+ // check to see if an 'infinite' loop occured
+ if ((topWin->ReturnCount() > KEmptyLoopThreshold) || (bottomWin->ReturnCount() > KEmptyLoopThreshold))
+ INFO_PRINTF1(KErrorMessage);
+
+ //get the color of a pixel within the invalid area that should be coloured
+ //red if the window is redrawn correctly.
+ TPoint point =iWinPos + TPoint(30,30);
+ TRgb colour;
+ TheClient->iScreen->GetPixel(colour,point);
+ TRgb expectedColour = KRgbRed;
+
+ if ((colour == expectedColour) && (topWin->ReturnCount() < KEmptyLoopThreshold) && (bottomWin->ReturnCount() < KEmptyLoopThreshold))
+ testStatus = ETrue;
+
+ TEST(testStatus);
+
+ CleanupStack::PopAndDestroy(2, bottomWin);
+ }
+ }
+
+void CTRedrawStoring::DoPolygonRedrawTestSetL()
+ {
+ _LIT(KRedrawStoringPolygon0,"Test polygon redraw in opaque window");
+ _LIT(KRedrawStoringPolygon1,"Test polygon low priority redraw in opaque window");
+ _LIT(KRedrawStoringPolygon2,"Test polygon redraw in transparent window");
+ _LIT(KRedrawStoringPolygon3,"Test polygon low priority redraw in transparent window");
+ INFO_PRINTF1(KRedrawStoringPolygon0);
+ DoPolygonRedrawTestL(0,0); // Polygon redraw in opaque window
+ INFO_PRINTF1(KRedrawStoringPolygon1);
+ DoPolygonRedrawTestL(0,1); // Polygon low priority redraw in opaque window
+ INFO_PRINTF1(KRedrawStoringPolygon2);
+ DoPolygonRedrawTestL(1,0); // Polygon redraw in transparent window
+ INFO_PRINTF1(KRedrawStoringPolygon3);
+ DoPolygonRedrawTestL(1,1); // Polygon low priority redraw in transparent window
+ }
+
+void CTRedrawStoring::DoPolygonRedrawTestL(TInt aWindowMode, TInt aTestMode)
+ {
+ //Used to place windows.
+ TInt gap = 5;
+ const TSize scrSize(TheClient->iScreen->SizeInPixels());
+ TheClient->iWs.SetBufferSizeL(640);
+
+ CPartialRedrawPolygonWin* polyTestWin = NULL;
+ if (aTestMode == 0) //If polygon redraw test.
+ {
+ //Draw a green test window with a polygon in it.
+ polyTestWin = new (ELeave) CPartialRedrawPolygonWin();
+ CleanupStack::PushL(polyTestWin);
+ polyTestWin->ConstructL(*TheClient->iGroup);
+ polyTestWin->Init(aWindowMode, KRgbGreen); //aWindowMode 0=opaque 1=transparent
+ polyTestWin->AssignGC(*TheClient->iGc);
+ polyTestWin->BaseWin()->SetShadowDisabled(ETrue);
+ polyTestWin->BaseWin()->SetShadowHeight(0);
+ polyTestWin->SetExt(TPoint(scrSize.iWidth-iWinSize.iWidth,0), iWinSize);
+ polyTestWin->Win()->Activate();
+ polyTestWin->DrawPartial();
+ TheClient->Flush();
+ }
+
+ //Draw a green base window with a polygon in it.
+ CPartialRedrawPolygonWin* bottomWin = new (ELeave) CPartialRedrawPolygonWin();
+ CleanupStack::PushL(bottomWin);
+ bottomWin->ConstructL(*TheClient->iGroup);
+ bottomWin->Init(aWindowMode, KRgbGreen); //aWindowMode 0=opaque 1=transparent
+ bottomWin->AssignGC(*TheClient->iGc);
+ bottomWin->BaseWin()->SetShadowDisabled(ETrue);
+ bottomWin->BaseWin()->SetShadowHeight(0);
+ bottomWin->SetExt(TPoint(scrSize.iWidth-(2*iWinSize.iWidth)-gap,0), iWinSize);
+ bottomWin->Win()->Activate();
+ bottomWin->DrawPartial();
+ TheClient->Flush();
+
+ //Draw an empty, blue transparent top window.
+ CPartialRedrawEmptyWin* topWin = new (ELeave) CPartialRedrawEmptyWin();
+ CleanupStack::PushL(topWin);
+ topWin->ConstructL(*TheClient->iGroup);
+ topWin->Init(KRgbBlue);
+ topWin->AssignGC(*TheClient->iGc);
+ topWin->BaseWin()->SetShadowDisabled(ETrue);
+ topWin->BaseWin()->SetShadowHeight(0);
+ topWin->SetExt(TPoint(scrSize.iWidth-(2*iWinSize.iWidth)-gap,0), iWinSize);
+ topWin->Win()->Activate();
+ topWin->DrawPartial(TRect(TPoint(0,0), iWinSize));
+ TheClient->Flush();
+
+ if (aTestMode == 1) //If polygon low priority redraw test.
+ {
+ //Clear all redraw stores.
+ TheClient->iWs.ClearAllRedrawStores();
+ TheClient->Flush();
+ TheClient->WaitForRedrawsToFinish();
+ }
+
+ //Hide the top window, so the bottom window will be redrawn.
+ topWin->SetVisible(EFalse);
+ TheClient->Flush();
+ TheClient->WaitForRedrawsToFinish();
+
+ if (aTestMode==0) //If polygon redraw test.
+ {
+ //Compare bottomWin against polyTestWin.
+ TEST(TheClient->iScreen->RectCompare(TRect(TPoint(scrSize.iWidth-2*iWinSize.iWidth-gap,0),iWinSize),TRect(TPoint(scrSize.iWidth-iWinSize.iWidth,0),iWinSize)));
+ CleanupStack::PopAndDestroy(3,polyTestWin);
+ }
+ else //If polygon low priority redraw test.
+ {
+ //Test bottomWin has only called DoDraw once.
+ TEST(bottomWin->ReturnCount()==1);
+ if (bottomWin->ReturnCount()!=1)
+ {
+ _LIT(KLog,"Number of redraws of bottom window %d, 1 expected (windowMode %d)");
+ LOG_MESSAGE3(KLog,bottomWin->ReturnCount(),aWindowMode);
+ }
+ CleanupStack::PopAndDestroy(2,bottomWin);
+ }
+ }
+
+void CTRedrawStoring::DoRedrawOOMTestL()
+ {
+ _LIT(KFailedTestInfo,"Failure information: redrawCount=%d failRate=%d");
+ _LIT(KCompletedTest,"OOM test started succeeding at failRate = %d");
+ const TInt KConsecutiveSuccessfulRedraws = 20;
+
+ //draw a white test window
+ CRedrawRectWin* testWin = new (ELeave) CRedrawRectWin();
+ CleanupStack::PushL(testWin);
+ testWin->ConstructL(*TheClient->iGroup);
+ testWin->Init();
+ testWin->AssignGC(*TheClient->iGc);
+ testWin->BaseWin()->SetShadowDisabled(ETrue);
+ testWin->BaseWin()->SetShadowHeight(0);
+ testWin->SetExt(iWinPos+TPoint(0,0), iWinSize);
+ testWin->Win()->Activate();
+ testWin->DrawNow();
+ TheClient->Flush();
+ TheClient->WaitForRedrawsToFinish();
+
+ TPoint pointTest = iWinPos + TPoint(30,30);
+ TRgb colourTest;
+ TRgb expectedColour = KRgbGreen;
+ TInt numberOfSuccessfulRedraws = 0;
+ TInt failRate = 1;
+ do
+ {
+ expectedColour=((expectedColour==KRgbGreen)?KRgbRed:KRgbGreen);
+ testWin->ResetWindow(expectedColour);
+ testWin->SetLogging(failRate<3?this:NULL);
+ testWin->Win()->Invalidate();
+ TheClient->iWs.HeapSetFail(RHeap::EDeterministic,failRate);
+ TheClient->WaitForRedrawsToFinish();
+ TheClient->iWs.HeapSetFail(RHeap::ENone,0);
+ TheClient->iScreen->GetPixel(colourTest,pointTest);
+ const TInt redrawCount = testWin->RedrawCount();
+
+ if (redrawCount>2) //If DoDraw called too often:
+ {
+ TBool passed=(failRate<3 && redrawCount<9); //For a failrate of 2 allow upto 8 redraws
+ TEST(passed); //Fail.
+ LOG_MESSAGE3(KFailedTestInfo,redrawCount,failRate);
+ if (!passed)
+ {
+ CleanupStack::PopAndDestroy(testWin);
+ return;
+ }
+ }
+ else if (colourTest==expectedColour && redrawCount==1) //If drawn correctly.
+ {
+ #if defined(LOGGING)
+ _LIT(KLog,"FailRate %d Drawing Corect RedrawCount %d");
+ LOG_MESSAGE3(KLog,failRate,redrawCount);
+ #endif
+ numberOfSuccessfulRedraws++;
+ }
+ else //If not drawn.
+ {
+ #if defined(LOGGING)
+ _LIT(KLog,"FailRate %d Drawing Wrong RedrawCount %d");
+ LOG_MESSAGE3(KLog,failRate,redrawCount);
+ #endif
+ numberOfSuccessfulRedraws=0;
+ }
+ failRate++;
+ } while (numberOfSuccessfulRedraws<KConsecutiveSuccessfulRedraws);
+ LOG_MESSAGE2(KCompletedTest,(failRate-KConsecutiveSuccessfulRedraws-1));
+ CleanupStack::PopAndDestroy(testWin);
+ }
+
+void CTRedrawStoring::RedrawStoreWithBadRectL()
+ {
+ RWindow win(TheClient->iWs);
+ CleanupClosePushL(win);
+ User::LeaveIfError(win.Construct(*TheClient->iGroup->GroupWin(),ENullWsHandle));
+ win.SetRequiredDisplayMode(EColor64K);
+ TPoint winPos(270,70);
+ win.SetExtent(winPos, TSize(100,100));
+ win.SetBackgroundColor( KRgbRed );
+ win.Activate();
+
+ TheGc->Activate(win);
+ win.BeginRedraw();
+ TheGc->SetBrushColor(KRgbGreen);
+ TheGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
+ TheGc->DrawRect(TRect(0,0,100,40));
+ win.EndRedraw();
+
+ win.BeginRedraw(TRect(10,20,20,0));
+ TheGc->SetBrushColor(KRgbBlue);
+ TheGc->DrawRect(TRect(0,0,40,100));
+ win.EndRedraw();
+
+ win.SetVisible(EFalse);
+ win.SetVisible(ETrue);
+ TheGc->Deactivate();
+ TheClient->Flush();
+
+ TRgb color;
+ TheClient->iScreen->GetPixel(color,winPos+TPoint(20,20));
+ TBool passed=(color==KRgbGreen);
+ TEST(passed);
+
+ CleanupStack::Pop(&win);
+ win.Close();
+ }
+
+
+/*CPartialRedrawEmptyWin*/
+
+void CPartialRedrawEmptyWin::Init(TRgb aColor)
+ {
+ Win()->SetRequiredDisplayMode(EColor16MA);
+ Win()->SetTransparencyAlphaChannel();
+ Win()->SetBackgroundColor(aColor);
+ iCount = 0;
+ }
+
+void CPartialRedrawEmptyWin::Draw()
+ {
+ DoDraw();
+ iCount++;
+ }
+
+void CPartialRedrawEmptyWin::DoDraw()
+ {
+ DrawFullWindowRect();
+ }
+
+void CPartialRedrawEmptyWin::DrawFullWindowRect()
+ {
+ // Only draw when we've looped too many times
+ if (ReturnCount() > KEmptyLoopThreshold)
+ {
+ TRect rect = TRect(TPoint(0,0),iSize);
+ iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
+ iGc->SetBrushColor(KRgbBlack);
+ iGc->DrawRect(rect);
+ }
+ }
+
+void CPartialRedrawEmptyWin::DrawPartial(TRect aRect)
+ {
+ Invalidate(aRect);
+ Win()->BeginRedraw(aRect);
+ iGc->Activate(*Win());
+ DrawFullWindowRect();
+ iGc->Deactivate();
+ Win()->EndRedraw();
+ }
+
+inline TInt CPartialRedrawEmptyWin::ReturnCount()
+ {
+ return iCount;
+ }
+
+
+/*CPartialRedrawPolygonWin*/
+
+void CPartialRedrawPolygonWin::Init(TInt aWindowMode, TRgb aColor)
+ {
+ Win()->SetRequiredDisplayMode(EColor16MA);
+ if (aWindowMode == 1)
+ {
+ Win()->SetTransparencyAlphaChannel();
+ }
+ Win()->SetBackgroundColor(aColor);
+ iCount = 0;
+ }
+
+void CPartialRedrawPolygonWin::Draw()
+ {
+ DoDraw();
+ iCount++;
+ }
+
+void CPartialRedrawPolygonWin::DoDraw()
+ {
+ DrawFullWindowPolygonL();
+ }
+
+void CPartialRedrawPolygonWin::DrawFullWindowPolygonL()
+ {
+ iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
+ iGc->SetBrushColor(KRgbBlack);
+ CArrayFixFlat<TPoint>* longPolygon = new CArrayFixFlat<TPoint>(84);
+ CleanupStack::PushL(longPolygon);
+ TInt forLoop = 0, loopValue = 0;
+ TInt tempX=18, tempY=49;
+ TPoint polygonPoint(tempX, tempY);
+
+ //Create jagged line for the polygon
+ for (forLoop=0; forLoop<81; forLoop++)
+ {
+ tempX += 2;
+ if (loopValue==0)
+ {
+ tempY +=2;
+ loopValue = 1;
+ }
+ else
+ {
+ tempY -=2;
+ loopValue = 0;
+ }
+ polygonPoint.SetXY(tempX, tempY);
+ longPolygon->AppendL(polygonPoint);
+ }
+ polygonPoint.SetXY(tempX,70);
+ longPolygon->AppendL(polygonPoint);
+ polygonPoint.SetXY(20,70);
+ longPolygon->AppendL(polygonPoint);
+ iGc->DrawPolygon(longPolygon);
+ CleanupStack::PopAndDestroy(longPolygon);
+ }
+
+void CPartialRedrawPolygonWin::DrawPartial()
+ {
+ Invalidate();
+ Win()->BeginRedraw();
+ iGc->Activate(*Win());
+ DrawFullWindowPolygonL();
+ iGc->Deactivate();
+ Win()->EndRedraw();
+ }
+
+inline TInt CPartialRedrawPolygonWin::ReturnCount()
+ {
+ return iCount;
+ }
+
+
+/*CRedrawRectWin*/
+
+void CRedrawRectWin::Init()
+ {
+ Win()->SetRequiredDisplayMode(EColor16MA);
+ Win()->SetTransparencyAlphaChannel();
+ Win()->SetBackgroundColor(KRgbWhite);
+ iRedrawCount = 0;
+ iRectColour = KRgbGreen;
+ }
+
+void CRedrawRectWin::Draw()
+ {
+ DoDraw();
+ iRedrawCount++;
+ }
+
+void CRedrawRectWin::DoDraw()
+ {
+ DrawFullWindowRect();
+ }
+
+void CRedrawRectWin::DrawFullWindowRect()
+ {
+ TRect Rect(TPoint(10,10), TSize(30, 30));
+ Gc()->SetBrushStyle(CGraphicsContext::ESolidBrush);
+ Gc()->SetBrushColor(iRectColour);
+ Gc()->SetPenStyle(CGraphicsContext::ESolidPen);
+ Gc()->SetPenColor(0);
+ Gc()->DrawRect(Rect);
+ }
+
+void CRedrawRectWin::DrawNow()
+ {
+ Win()->Invalidate();
+ Win()->BeginRedraw();
+ Gc()->Activate(*Win());
+ DrawFullWindowRect();
+ Gc()->Deactivate();
+ Win()->EndRedraw();
+ }
+
+inline TInt CRedrawRectWin::RedrawCount()
+ {
+ return iRedrawCount;
+ }
+
+void CRedrawRectWin::ResetWindow(TRgb aColour)
+ {
+ iRectColour = aColour;
+ iRedrawCount = 0;
+ }
+
+inline void CRedrawRectWin::SetLogging(CTWsGraphicsBase* aTest)
+ {
+ iLog=aTest;
+ }
+
+void CRedrawRectWin::Redraw(const TRect& aRect)
+ {
+ if (iLog)
+ {
+ _LIT(KLog,"Redraw Count %d Rect=(%d,%d,%d,%d)");
+ iLog->LOG_MESSAGE6(KLog,RedrawCount(),aRect.iTl.iX,aRect.iTl.iY,aRect.iBr.iX,aRect.iBr.iY);
+ }
+ CTWin::Redraw(aRect);
+ }
+
+
+//
+
+void CTRedrawStoring::RunTestCaseL(TInt /*aCurTestCase*/)
+ {
+ _LIT(KNormalDrawing,"Normal Draw Test");
+ _LIT(KFadeWindow1,"Fade Window1");
+ _LIT(KFadeWindow2,"Fade Window2");
+ _LIT(KRedrawQueue2,"Empty Redraw Queue");
+ _LIT(KDisableRedrawStore,"Disable redraw store");
+ _LIT(KResizeRedraws,"Redraw on Resize event");
+ _LIT(KFontCacheOverflow,"Font Cache Overflow test");
+ _LIT(KDrawBitmapMask,"Test DrawBitmapMasked");
+ _LIT(KInvisibleRedrawStore,"Test invisible window redraw storing");
+ _LIT(KBrushDraw,"Test UseBrushPattern storing");
+ _LIT(KInvisibleRedrawStoreTransparent,"Test invisible transparent window redraw storing");
+ _LIT(KPartialDrawNow,"Test partial DrawNow");
+ _LIT(KPartialDrawNowTransparent,"Test partial transparent DrawNow");
+ _LIT(KBeginEndRedraw,"Redraw in between Begin and EndRedraw");
+ _LIT(KRedrawStoreAlphaChannelTransparency,"Redraw store for Alpha Channel Transparency");
+ _LIT(KDrawBitBltAndMaskedNegTestsL,"Test BitBltMasked by passing Neg,UnExpected Values");
+ _LIT(KRedrawStoringExposeWindow,"Redraw Storing Window Exposed");
+ _LIT(KRedrawStoringExposeWindow2,"Redraw Storing Window behind Transparent Exposed");
+ _LIT(KAutoResetRedrawStore,"Test automatic redraw store reset");
+ _LIT(KRedrawStoreWithSetExtent,"Redraw store with set extent");
+ _LIT(KPartialRedrawWithEmptyRedrawStore,"Partial redraw with empty redraw store");
+ _LIT(KScrollingWin,"Test scrolling when partial redraw is enabled");
+ _LIT(KRedrawStoringEmptyDrawWindow0,"Empty window under redraw storing - full case");
+ _LIT(KRedrawStoringEmptyDrawWindow1,"Empty window under redraw storing - corner case");
+ _LIT(KRedrawOOMTest,"Testing OOM redraw");
+ _LIT(KRedrawWithBadRect, "Redraw storing when BeginRedraw with bad rect");
+ if (iState==0)
+ {
+ // Check to see if Transparency is enabled before running tests
+ if (TransparencySupportedL()==KErrNotSupported)
+ {
+ _LIT(KLog,"Transparency is not enabled");
+ LOG_MESSAGE(KLog);
+ TestComplete();
+ return;
+ }
+ }
+ TInt err=KErrNone;
+ //if (iTest->iState==1) iTest->iState=KLastDrawingCase+2; //Set one less that the test you want to run
+ iState=++iTest->iState;
+ ((CTRedrawStoringStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);
+ switch(iTest->iState)
+ {
+ case 6:
+ ((CTRedrawStoringStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0086"));
+ // Special case handled seperately because unfading the
+ // window requires a redraw
+ iTest->LogSubTest(KFadeWindow1);
+ FadeWindowTest();
+ break;
+ case 12:
+ ((CTRedrawStoringStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0087"));
+ iTest->LogSubTest(KFadeWindow2);
+ FadeWindowTest2L();
+ break;
+ case 14:
+ ((CTRedrawStoringStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0090"));
+ iTest->LogSubTest(KRedrawQueue2);
+ DoNothingInRedrawTest();
+ break;
+ case 17:
+ ((CTRedrawStoringStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0091"));
+ iTest->LogSubTest(KDisableRedrawStore);
+ DoDisableRedrawStoreTest();
+ break;
+ case 18:
+ ((CTRedrawStoringStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0092"));
+ iTest->LogSubTest(KResizeRedraws);
+ DoResizeTest();
+ break;
+ case 22:
+/**
+ @SYMTestCaseID GRAPHICS-WSERV-0508
+*/
+ ((CTRedrawStoringStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0508"));
+ iTest->LogSubTest(KBeginEndRedraw);
+ DoBeginEndRedraw();
+ break;
+ case 23:
+/**
+ @SYMTestCaseID GRAPHICS-WSERV-0509
+*/
+ ((CTRedrawStoringStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0509"));
+ iTest->LogSubTest(KRedrawStoreAlphaChannelTransparency);
+ DoRedrawStoreAlphaChannelTransTest();
+ break;
+ case 24:
+/**
+ @SYMTestCaseID GRAPHICS-WSERV-0510
+*/
+ ((CTRedrawStoringStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0510"));
+ iTest->LogSubTest(KScrollingWin);
+ ScrollWinTest();
+ break;
+ case KLastDrawingCase + 1:
+/**
+ @SYMTestCaseID GRAPHICS-WSERV-0511
+*/
+ ((CTRedrawStoringStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0511"));
+ iTest->LogSubTest(KDrawBitmapMask);
+ TRAP(err,DoTestDrawBitmapMaskedL());
+ break;
+ case KLastDrawingCase + 2:
+
+ ((CTRedrawStoringStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0511"));
+ iTest->LogSubTest(KDrawBitmapMask);
+ TRAP(err,DoTestDrawBitmapMaskedL(ETrue));
+ break;
+ case KLastDrawingCase + 3:
+/**
+ @SYMTestCaseID GRAPHICS-WSERV-0512
+*/
+ ((CTRedrawStoringStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0512"));
+ iTest->LogSubTest(KFontCacheOverflow);
+ DoFontCacheOverflowTestL();
+ break;
+ case KLastDrawingCase + 4:
+ ((CTRedrawStoringStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-00XX-0006"));
+ iTest->LogSubTest(KInvisibleRedrawStore);
+ TRAP(err,DoInvisibleRedrawStoreTestL( EFalse ));
+ break;
+ case KLastDrawingCase + 5:
+ ((CTRedrawStoringStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-00XX-0006"));
+ iTest->LogSubTest(KInvisibleRedrawStoreTransparent);
+ TRAP(err,DoInvisibleRedrawStoreTestL( ETrue ));
+ break;
+ case KLastDrawingCase + 6:
+ ((CTRedrawStoringStep*)iStep)->SetTestStepID(_L("GRAPHICS-CODEBASE-WSERV-0052-0001"));
+ iTest->LogSubTest(KDrawBitBltAndMaskedNegTestsL);
+ TRAP(err,DoBitBltAndMaskedNegTestsL());
+ break;
+ case KLastDrawingCase + 7:
+/**
+ @SYMTestCaseID GRAPHICS-WSERV-0513
+*/
+ ((CTRedrawStoringStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0513"));
+ iTest->LogSubTest(KPartialDrawNow);
+ TRAP(err,DoPartialDrawNowTestL(EFalse));
+ break;
+ case KLastDrawingCase + 8:
+/**
+ @SYMTestCaseID GRAPHICS-WSERV-0514
+*/
+ ((CTRedrawStoringStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0514"));
+ iTest->LogSubTest(KPartialDrawNowTransparent);
+ TRAP(err,DoPartialDrawNowTestL(ETrue));
+ break;
+ case KLastDrawingCase + 9:
+/**
+ @SYMTestCaseID GRAPHICS-WSERV-0515
+*/
+ ((CTRedrawStoringStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0515"));
+ TInt iteration;
+ for(iteration=0;iteration<3 && err==KErrNone;iteration++)
+ {
+ iTest->LogSubTest(KRedrawStoringExposeWindow);
+ TRAP(err,DoExposeTestL(iteration));
+ }
+ break;
+ case KLastDrawingCase + 10:
+ {
+/**
+ @SYMTestCaseID GRAPHICS-WSERV-0516
+*/
+ ((CTRedrawStoringStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0516"));
+ TInt iteration;
+ for(iteration=0;iteration<2 && err==KErrNone;iteration++)
+ {
+ iTest->LogSubTest(KRedrawStoringExposeWindow2);
+ TRAP(err,DoExposeTest2L(iteration));
+ }
+ break;
+ }
+ case KLastDrawingCase + 11:
+ ((CTRedrawStoringStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);
+ iTest->LogSubTest(KAutoResetRedrawStore);
+ AutoResetRedrawStoreTestsL();
+ break;
+ case KLastDrawingCase + 12:
+/**
+ @SYMTestCaseID GRAPHICS-WSERV-0517
+*/
+ ((CTRedrawStoringStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0517"));
+ iTest->LogSubTest(KRedrawStoreWithSetExtent);
+ RedrawStoreWithSetExtentL();
+ break;
+ case KLastDrawingCase + 13:
+/**
+ @SYMTestCaseID GRAPHICS-WSERV-0518
+*/
+ ((CTRedrawStoringStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0518"));
+ iTest->LogSubTest(KPartialRedrawWithEmptyRedrawStore);
+ PartialRedrawWithEmptyRedrawStoreL();
+ break;
+ case KLastDrawingCase + 14:
+ ((CTRedrawStoringStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-103713-0001"));
+ iTest->LogSubTest(KRedrawStoringEmptyDrawWindow0);
+ TRAP(err,DoEmptyDrawTestL(0)); // Completely covered case
+ if (err!=KErrNone)
+ break;
+ iTest->LogSubTest(KRedrawStoringEmptyDrawWindow1);
+ TRAP(err,DoEmptyDrawTestL(1)); // Quarter covered case
+ break;
+
+/**
+@SYMTestCaseID GRAPHICS-WSERV-0439
+
+@SYMDEF DEF107817
+
+@SYMTestCaseDesc Drawing polygons with many points panics WServ (redraw store enabled)
+
+@SYMTestPriority Normal
+
+@SYMTestStatus Implemented
+
+@SYMTestActions Draw a polygon in opaque and transparent windows testing redraw and low priority redraw
+
+@SYMTestExpectedResults Redraw tests display correctly, low priority redraw tests call DoDraw only once
+*/
+ case KLastDrawingCase + 15:
+ ((CTRedrawStoringStep*)iStep)->SetTestStepID(_L(" GRAPHICS-WSERV-0439"));
+ TRAP(err,DoPolygonRedrawTestSetL());
+ break;
+
+/**
+@SYMTestCaseID GRAPHICS-WSERV-0442
+
+@SYMDEF DEF107984
+
+@SYMTestCaseDesc OOM causing infinite redraw loop
+
+@SYMTestPriority Normal
+
+@SYMTestStatus Implemented
+
+@SYMTestActions Redraw rectangles in OOM situations
+
+@SYMTestExpectedResults There are no extended redraw loops
+*/
+ case KLastDrawingCase + 16:
+ ((CTRedrawStoringStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0442"));
+ iTest->LogSubTest(KRedrawOOMTest);
+ TRAP(err,DoRedrawOOMTestL());
+ break;
+ case KLastDrawingCase + 17:
+/**
+ @SYMTestCaseID GRAPHICS-WSERV-0519
+*/
+ ((CTRedrawStoringStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0519"));
+ iTest->LogSubTest(KRedrawWithBadRect);
+ TRAP(err,RedrawStoreWithBadRectL());
+ break;
+ case KLastDrawingCase + 18:
+ ((CTRedrawStoringStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0498"));
+ iTest->LogSubTest(KBrushDraw);
+ TRAP(err,DoBrushDrawTestL());
+ break;
+ case KLastDrawingCase + 19:
+ ((CTRedrawStoringStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);
+ ((CTRedrawStoringStep*)iStep)->CloseTMSGraphicsStep();
+ TestComplete();
+ break;
+ default:
+ iTest->LogSubTest(KNormalDrawing);
+ ((CTRedrawStoringStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0085"));
+ DoDrawTest();
+ if (iDoScrollTest)
+ ScrollTest();
+ }
+ ((CTRedrawStoringStep*)iStep)->RecordTestResultL();
+ if (err!=KErrNone)
+ {
+ TEST(EFalse);
+ _LIT(KLog,"Sub-Test[%d] left with error code %d");
+ LOG_MESSAGE3(KLog,iState,err);
+ }
+ }
+
+
+__WS_CONSTRUCT_STEP__(RedrawStoring)