diff -r 57c618273d5c -r bbf46f59e123 windowing/windowserver/test/tauto/TMulTran.CPP --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/windowing/windowserver/test/tauto/TMulTran.CPP Tue Aug 31 16:31:06 2010 +0300 @@ -0,0 +1,1111 @@ +// 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 multiple level transparent window +// +// + +/** + @file + @test + @internalComponent - Internal Symbian test code +*/ + +#include "TMulTran.H" + + +LOCAL_D TDisplayMode DisplayMode=EColor64K; +LOCAL_D TSize WinSize; + +static const TRgb KRed=TRgb(255, 0, 0, 128); +static const TRgb KGreen=TRgb(0, 255, 0, 128); +static const TRgb KYellow=TRgb(255, 255, 0, 128); +static const TRgb KBlue=TRgb(0, 0, 255, 128); +static const TRgb KCyan=TRgb(0, 255, 255, 128); + +/*CTransWindow*/ + +CTransWindow* CTransWindow::NewL(RPointerArray& aWindows,TRgb aColor,TRect aPos) + { + CTransWindow* self=NewL(TheClient->iGroup,aColor,aPos,&DisplayMode); + aWindows.Insert(self,0); + return self; + } + +CTransWindow* CTransWindow::NewL(CTWinBase* aParent,TRgb aColor,TRect aPos, TDisplayMode* aDisplayMode) + { + CTransWindow* self=new(ELeave) CTransWindow(aColor); + CleanupStack::PushL(self); + self->SetUpL(aPos.iTl,aPos.Size(),aParent,*TheClient->iGc,aDisplayMode); + User::LeaveIfError(self->iError); + CleanupStack::Pop(self); + return self; + } + +//the following function doesn't activate a window +CTransWindow* CTransWindow::NewL(CTWinBase* aParent,TRgb aColor,TDisplayMode* aDisplayMode) + { + CTransWindow* self=new(ELeave) CTransWindow(aColor); + CleanupStack::PushL(self); + self->ConstructL(*aParent); + if (aDisplayMode) + { + self->BaseWin()->SetRequiredDisplayMode(*aDisplayMode); + } + User::LeaveIfError((self->iError) && (self->iError != KErrNotSupported)); + CleanupStack::Pop(self); + return self; + } + +void CTransWindow::InitWin() + { + AdjustShadow(-1); + iShadowHight=0; + iWin.SetShadowDisabled(ETrue); + iShadowing=EFalse; + iError = iWin.SetTransparencyAlphaChannel(); + iWin.SetBackgroundColor(iCol); + iDrawOpaque=EFalse; + } + +void CTransWindow::ToggleVisibility() + { + iVisible=!iVisible; + SetVisible(iVisible); + } + +void CTransWindow::SetOrdinal(RPointerArray& aWindows,TInt aOldPos,TInt aNewPos) + { + CTransWindow* win=aWindows[aOldPos]; + aWindows.Remove(aOldPos); + aWindows.Insert(win,aNewPos); + win->iWin.SetOrdinalPosition(aNewPos); + } + +void CTransWindow::SetShadowDisabled(TBool aState) + { + iWin.SetShadowDisabled(aState); + iShadowing=!aState; + } + +void CTransWindow::AdjustShadow(TInt aAdjust) + { + CBlankWindow::AdjustShadow(aAdjust); + iShadowHight+=aAdjust; + } + +TPoint CTransWindow::Position() const + { + return CBlankWindow::Position()+iPosOffset; + } + +void CTransWindow::Draw() + { + //don't call CBlankWindow::Draw() since the background is already drawn + + if(iDrawOpaque) + { + iGc->SetPenStyle(CGraphicsContext::ESolidPen); + iGc->SetPenSize(TSize(4,4)); + iGc->SetBrushStyle(CGraphicsContext::ENullBrush); + iGc->SetPenColor(~iCol); + iGc->SetOpaque(ETrue); + iGc->DrawLine(TPoint(0,0),TPoint(1000,1000)); + iGc->SetOpaque(EFalse); + } + } + +/*CTMultipleTrans*/ + +CTMultipleTrans::CTMultipleTrans(CTestStep* aStep) : CTWsGraphicsBase(aStep), iWindows(5), iShadows(EFalse) + { + } + +CTMultipleTrans::~CTMultipleTrans() + { + ((CTMultipleTransStep*)iStep)->CloseTMSGraphicsStep(); + delete iBackgroundWin; + delete iCheckWin; + delete iCheckBitmap; + iWindows.ResetAndDestroy(); + iBlankWin.Close(); + } + +void CTMultipleTrans::ConstructL() + { + if(TransparencySupportedL() == KErrNotSupported) + return; + iMajorTest=0; + const TSize scrSize(TheClient->iScreen->SizeInPixels()); + WinSize.SetSize(scrSize.iWidth/2,scrSize.iHeight); + iBackgroundWin=new(ELeave) CTBlankWindow(); + iBackgroundWin->SetUpL(TPoint(),WinSize,TheClient->iGroup,*TheClient->iGc); + TheClient->WaitForRedrawsToFinish(); + CTBackedUpWin* checkWin=new(ELeave) CTBackedUpWin(DisplayMode); + checkWin->ConstructExtLD(*TheClient->iGroup,TPoint(WinSize.iWidth,0),WinSize); + iCheckWin=checkWin; + RBackedUpWindow& backWin=*iCheckWin->BackedUpWin(); + backWin.SetShadowHeight(0); + iCheckWin->Activate(); + backWin.MaintainBackup(); + iCheckBitmap=CBitmap::NewL(backWin.BitmapHandle()); + iCheckBitmap->Gc().SetPenStyle(CGraphicsContext::ENullPen); + iCheckBitmap->Gc().SetBrushStyle(CGraphicsContext::ESolidBrush); + TheClient->Flush(); + TheClient->WaitForRedrawsToFinish(); + RecreateWindowsL(); + iBlankWin=RBlankWindow(TheClient->iWs); + User::LeaveIfError(iBlankWin.Construct(*TheClient->iGroup->WinTreeNode(),ENullWsHandle)); + iBlankWinVis=EFalse; + iBlankWin.SetVisible(iBlankWinVis); + User::LeaveIfError(iBlankWin.SetRequiredDisplayMode(EColor256)); + iBlankWinCol=TRgb(170,170,170); //Grey + iBlankWin.SetColor(iBlankWinCol); + iBlankWin.SetOrdinalPosition(0,1); //Set the priority to 1 so that the 4 main windows are the first 4 with priory 0 + iBlankWin.Activate(); + iOpacitySupported=EFalse; + } + +void CTMultipleTrans::ShadowRegion(TRegion& aRegion,TInt aWin) + { + TRect rect; + TInt height; + TInt window; + aRegion.Clear(); + RRegion single; + RRegion noShadow1; + RRegion noShadow2; + RRegion temp; + RRegion temp2; + for (window=0;windowGc(); + gc.SetBrushColor(KRgbWhite); + gc.DrawRect(TRect(WinSize)); + TInt windows=iWindows.Count(); + if (iShadows) + { + ShadowRegion(shadowRegion,windows); + gc.ShadowArea(&shadowRegion); + } + TInt window; + for (window=windows;window>0;) + { + CTransWindow& win=*iWindows[--window]; + if (win.IsVisible()) + { + gc.SetBrushColor(win.Color()); + const TPoint& winTopLeft=win.Position(); + gc.DrawRect(TRect(winTopLeft, win.Size())); + + if(win.DrawOpaque()) + { + gc.SetPenColor(~(win.Color())); + gc.SetPenSize(TSize(4,4)); + gc.SetPenStyle(CGraphicsContext::ESolidPen); + gc.SetClippingRect(TRect(TPoint(winTopLeft.iX,winTopLeft.iY),TPoint(winTopLeft.iX + win.Size().iWidth, winTopLeft.iY + win.Size().iHeight))); + gc.DrawLine(TPoint(winTopLeft.iX,winTopLeft.iY),TPoint(winTopLeft.iX+1000, winTopLeft.iY+1000)); + gc.SetPenStyle(CGraphicsContext::ENullPen); + gc.SetClippingRect(TRect(WinSize)); + } + + if (iShadows) + { + ShadowRegion(shadowRegion,window); + gc.ShadowArea(&shadowRegion); + } + } + } + iCheckWin->BackedUpWin()->UpdateScreen(); + TheClient->Flush(); + if (windows>=4) + { + AdvancedCheckRect(); + } + _LIT(KTest,"Multiple Transparent Test, SubTest %d, OpacityOn=%d"); + TBuf<128> buf; + buf.Format(KTest,iTest->iState,iMajorTest); + CheckRect(iBackgroundWin,iCheckWin,TRect(WinSize),buf); + shadowRegion.Close(); + } + +#define OFFSET 2 +void CTMultipleTrans::AdvancedCheckRect() + { + const TSize compareSize(5,5); + const TInt OFFSET2=OFFSET+compareSize.iWidth; + TPoint comparePos=iCheckWin->Position(); + TPoint checkPos; + //Check Single Level for Top Left Win + checkPos=iTopLeft->Position()+TPoint(OFFSET,OFFSET); + CheckRect(checkPos,checkPos+comparePos,compareSize); + //Check Single Level for Top Right Win + checkPos=iTopRight->Position()+TPoint(iTopRight->Size().iWidth-OFFSET2,OFFSET); + CheckRect(checkPos,checkPos+comparePos,compareSize); + //Check Single Level for Bottom Left Win + checkPos=iBotLeft->Position()+TPoint(OFFSET,iBotLeft->Size().iHeight-OFFSET2); + CheckRect(checkPos,checkPos+comparePos,compareSize); + //Check Single Level for Bottom Right Win + checkPos=iBotRight->Position()+TPoint(iBotRight->Size().iWidth-OFFSET2,iBotRight->Size().iHeight-OFFSET2); + CheckRect(checkPos,checkPos+comparePos,compareSize); + //Double level top 2 windows + checkPos=iTopRight->Position()+TPoint(OFFSET,OFFSET); + CheckRect(checkPos,checkPos+comparePos,compareSize); + //Double level left 2 windows + checkPos=iBotLeft->Position()+TPoint(OFFSET,OFFSET); + CheckRect(checkPos,checkPos+comparePos,compareSize); + //Double level bot 2 windows + checkPos=iBotRight->Position()+TPoint(OFFSET,iBotRight->Size().iHeight-OFFSET2); + CheckRect(checkPos,checkPos+comparePos,compareSize); + //Double level right 2 windows + checkPos=iBotRight->Position()+TPoint(iBotRight->Size().iWidth-OFFSET2,OFFSET); + CheckRect(checkPos,checkPos+comparePos,compareSize); + //Triple level all but bot right + checkPos=iTopRight->Position()+TPoint(OFFSET,iTopRight->Size().iHeight-OFFSET2); + CheckRect(checkPos,checkPos+comparePos,compareSize); + //Triple level all but bot left + checkPos=iBotRight->Position()+TPoint(OFFSET,OFFSET); + CheckRect(checkPos,checkPos+comparePos,compareSize); + //Triple level all but top right + checkPos=iTopLeft->Position()+TPoint(iTopLeft->Size().iWidth-OFFSET2,iTopLeft->Size().iHeight-OFFSET2); + CheckRect(checkPos,checkPos+comparePos,compareSize); + //Triple level all but top left + checkPos=iBotLeft->Position()+TPoint(iBotLeft->Size().iWidth-OFFSET2,OFFSET); + CheckRect(checkPos,checkPos+comparePos,compareSize); + //Quad level + checkPos=TPoint(iBotRight->Position().iX,iBotLeft->Position().iY)+TPoint(OFFSET,OFFSET); + CheckRect(checkPos,checkPos+comparePos,compareSize); + } + +void CTMultipleTrans::SimpleTest() + { + CheckDisplay(); + } + +void CTMultipleTrans::ChangeVisibility() + { + TUint toggle; + TUint toggle2; + TInt win; + TInt ii=0; + for (ii=2;ii>0;--ii) + { + for (toggle=1;toggle<16;++toggle) + { + win=0; + toggle2=toggle; + while ((toggle2&0x1)==0) + { + ++win; + toggle2/=2; + } + iWindows[win]->ToggleVisibility(); + CheckDisplay(); + } + } + } + +void CTMultipleTrans::ChangeVisibility2() + { + iBlankWin.SetOrdinalPosition(0,0); + iBlankWin.SetVisible(ETrue); + iBlankWin.SetVisible(EFalse); + CheckDisplay(); + const TInt xSteps=4; + const TInt ySteps=3; + iBlankWinSize.SetSize(WinSize.iWidth/xSteps,WinSize.iHeight/ySteps); + iBlankWin.SetSize(iBlankWinSize); + TInt ordPos,xx,yy; + for (ordPos=0;ordPos<=4;++ordPos) + { + iBlankWin.SetOrdinalPosition(ordPos); + for (xx=0;xx=0;--kk) + { + for (jj=3;jj>kk;--jj) + { + for (ii=jj;ii>=kk;--ii) + { + CTransWindow::SetOrdinal(iWindows,jj,kk); + CheckDisplay(); + } + } + } + for (kk=2;kk>=0;--kk) + { + for (jj=3;jj>kk;--jj) + { + for (ii=jj;ii>=kk;--ii) + { + CTransWindow::SetOrdinal(iWindows,kk,jj); + CheckDisplay(); + } + } + } + } + +TSize CTMultipleTrans::GetSize(TInt aPos) + { //Comments show values for 640x240 screen + const TInt halfSize=40; + const TPoint topLeft=iTopLeft->Position(); //10,10 + const TInt xLeft=WinSize.iWidth/2-topLeft.iX-halfSize; //110 + const TInt xRight=xLeft+2*halfSize; //190 + const TInt yTop=WinSize.iHeight/2-topLeft.iY-halfSize; //70 + const TInt yBot=yTop+2*halfSize; //150 + if (aPos<6) + return TSize(xLeft+16*aPos-8,yTop); //1->118, 5->182 + if (aPos<11) + return TSize(xRight,yTop+16*aPos-88); //6->78, 10->142 + if (aPos<16) + return TSize(xRight-16*aPos+168,yBot); //11->182, 15->118 + return TSize(xLeft,yBot-16*aPos+248); //16->142, 20->78 + } + +void CTMultipleTrans::SizeChange(TInt aJump) + { + TInt ii=aJump; + TSize size; + while (ii<20) + { + size=GetSize(ii); + iTopLeft->SetSize(size); + if(iTopLeft->DrawOpaque()) + { + iTopLeft->CTWin::DrawNow(); + TheClient->Flush(); + } + CheckDisplay(); + ii+=aJump; + if (ii>20) + ii-=20; + } + } + +void CTMultipleTrans::SizeChange() + { + CTransWindow::SetOrdinal(iWindows,2,1); + TSize size=iBotLeft->Size(); + TInt change; + for (change=70;change>=0;change-=14) + { + iBotLeft->SetSize(TSize(size.iWidth-change,size.iHeight)); + if(iBotLeft->DrawOpaque()) + { + iBotLeft->CTWin::DrawNow(); + TheClient->Flush(); + } + CheckDisplay(); + } + size=iTopRight->Size(); + for (change=25;change>-50;change-=14) + { + iTopRight->SetSize(TSize(size.iWidth,size.iHeight+change)); + if(iTopRight->DrawOpaque()) + { + iTopRight->CTWin::DrawNow(); + TheClient->Flush(); + } + CheckDisplay(); + } + iTopRight->SetSize(size); + if(iTopRight->DrawOpaque()) + { + iTopRight->CTWin::DrawNow(); + TheClient->Flush(); + } + CTransWindow::SetOrdinal(iWindows,1,0); + CheckDisplay(); + size=iTopLeft->Size(); + SizeChange(3); + iTopLeft->SetSize(size); + if(iTopLeft->DrawOpaque()) + { + iTopLeft->CTWin::DrawNow(); + TheClient->Flush(); + } + CheckDisplay(); + CTransWindow::SetOrdinal(iWindows,0,2); + CheckDisplay(); + SizeChange(7); + iTopLeft->SetSize(size); + if(iTopLeft->DrawOpaque()) + { + iTopLeft->CTWin::DrawNow(); + TheClient->Flush(); + } + CheckDisplay(); + } + +void CTMultipleTrans::MoveWin() + { + const TPoint topLeftPos=iTopLeft->Position(); + const TPoint topRightPos=iTopRight->Position(); + const TPoint botLeftPos=iBotLeft->Position(); + const TPoint botRightPos=iBotRight->Position(); + const TInt maxMove=Min(topRightPos.iX,botRightPos.iY)-10; + TInt steps,move; + for (steps=2;steps>=0;--steps) + { + move=maxMove*(3-steps)/3; + iTopLeft->SetPos(TPoint(topLeftPos.iX+move,topLeftPos.iY+move)); + CheckDisplay(); + iTopRight->SetPos(TPoint(topRightPos.iX-move,topRightPos.iY+move)); + CheckDisplay(); + iBotRight->SetPos(TPoint(botRightPos.iX-move,botRightPos.iY-move)); + CheckDisplay(); + iBotLeft->SetPos(TPoint(botLeftPos.iX+move,botLeftPos.iY-move)); + CheckDisplay(); + } + for (steps=4;steps>=0;--steps) + { + move=maxMove*steps/5; + iBotLeft->SetPos(TPoint(botLeftPos.iX+move,botLeftPos.iY-move)); + CheckDisplay(); + iTopLeft->SetPos(TPoint(topLeftPos.iX+move,topLeftPos.iY+move)); + CheckDisplay(); + iBotRight->SetPos(TPoint(botRightPos.iX-move,botRightPos.iY-move)); + CheckDisplay(); + iTopRight->SetPos(TPoint(topRightPos.iX-move,topRightPos.iY+move)); + CheckDisplay(); + } + } + +void CTMultipleTrans::GroupWinL() + { + CTWindowGroup* group=new(ELeave) CTWindowGroup(TheClient); + CleanupStack::PushL(group); + group->ConstructL(); + CTransWindow* win=CTransWindow::NewL(group,KCyan,TRect(40,40,WinSize.iWidth-40,WinSize.iHeight-40),&DisplayMode); + win->CTWin::DrawNow(); + if(iMajorTest==1) + { + win->SetDrawOpaque(ETrue); + win->Invalidate(); + TheClient->WaitForRedrawsToFinish(); + } + iWindows.Insert(win,0); + CheckDisplay(); + group->GroupWin()->SetOrdinalPosition(1); + iWindows.Remove(0); + CheckDisplay(); + group->GroupWin()->SetOrdinalPosition(0); + iWindows.Insert(win,0); + CheckDisplay(); + iWindows.Remove(0); + delete win; //Would be better to delete this after the group window but the test window don't support this behaviour currently. + CleanupStack::PopAndDestroy(group); + CheckDisplay(); + } + +void CTMultipleTrans::FadeTranWin() + { + // system fade on + TheClient->iWs.SetSystemFaded(ETrue); + // system fade off + TheClient->iWs.SetSystemFaded(EFalse); + CheckDisplay(); + } + +void CTMultipleTrans::StartShadows() + { + iShadows=ETrue; + iTopLeft->SetShadowDisabled(EFalse); + iTopLeft->AdjustShadow(1); + iTopRight->SetShadowDisabled(EFalse); + iTopRight->AdjustShadow(1); + iBotLeft->SetShadowDisabled(EFalse); + iBotLeft->AdjustShadow(1); + iBotRight->SetShadowDisabled(EFalse); + iBotRight->AdjustShadow(1); + if(!iOpacitySupported) + { + iTopRight->ToggleVisibility(); // In 8.1 this isn't needed. + iTopRight->ToggleVisibility(); + } + CheckDisplay(); + } + +void CTMultipleTrans::ShadowsOnOff() + { + if(!iOpacitySupported) + return; // In 8.1 this isn't needed. + iBotRight->SetShadowDisabled(EFalse); + iBotRight->AdjustShadow(1); + CheckDisplay(); + iBotRight->SetShadowDisabled(ETrue); + CheckDisplay(); + iTopLeft->SetShadowDisabled(EFalse); + iTopLeft->AdjustShadow(1); + CheckDisplay(); + iTopLeft->SetShadowDisabled(ETrue); + CheckDisplay(); + iTopRight->SetShadowDisabled(ETrue); + CheckDisplay(); + iBotLeft->SetShadowDisabled(EFalse); + iBotLeft->AdjustShadow(1); + CheckDisplay(); + iBotLeft->SetShadowDisabled(ETrue); + CheckDisplay(); + iTopLeft->SetShadowDisabled(EFalse); + iTopRight->SetShadowDisabled(EFalse); + iBotLeft->SetShadowDisabled(EFalse); + iBotRight->SetShadowDisabled(EFalse); + iTopLeft->ToggleVisibility(); + CheckDisplay(); + iTopLeft->ToggleVisibility(); + CheckDisplay(); + iTopRight->ToggleVisibility(); + CheckDisplay(); + iTopRight->ToggleVisibility(); + CheckDisplay(); + iBotLeft->ToggleVisibility(); + CheckDisplay(); + iBotLeft->ToggleVisibility(); + CheckDisplay(); + iBotRight->ToggleVisibility(); + CheckDisplay(); + iBotRight->ToggleVisibility(); + CheckDisplay(); + } + +void CTMultipleTrans::StartChildL() + { + CTransWindow* win; + TInt windows=iWindows.Count(); + TInt window; + //Delete the first 4 windows from the array, could use ResetAndDestroy but would be broken by other uses of the array + for (window=windows;window>0;--window) + { + win=iWindows[0]; + iWindows.Remove(0); + delete win; + } + RecreateWindowsL(iBackgroundWin); + CheckDisplay(); + } + +void CTMultipleTrans::StartChild2L() + { + CTransWindow* win; + TInt windows=iWindows.Count(); + TInt window; + //Delete the first 4 windows from the array, could use ResetAndDestroy but would be broken by other uses of the array + for (window=windows;window>0;--window) + { + win=iWindows[0]; + iWindows.Remove(0); + delete win; + } + iShadows=EFalse; + TRect rect=WinSize; + rect.Shrink(10,10); + iBotRight=CTransWindow::NewL(iBackgroundWin,KBlue,rect,&DisplayMode); + iBotRight->CTWin::DrawNow(); + iWindows.Insert(iBotRight,0); + CheckDisplay(); + rect.Resize(-20,-20); + iTopLeft=CTransWindow::NewL(iBotRight,KRed,rect,&DisplayMode); + iTopLeft->CTWin::DrawNow(); + iTopLeft->SetPosOffset(TPoint(10,10)); + iWindows.Insert(iTopLeft,0); + CheckDisplay(); + rect.Resize(-20,-20); + iTopRight=CTransWindow::NewL(iTopLeft,KGreen,rect,&DisplayMode); + iTopRight->CTWin::DrawNow(); + iTopRight->SetPosOffset(TPoint(20,20)); + iWindows.Insert(iTopRight,0); + CheckDisplay(); + rect.Resize(-20,-20); + iBotLeft=CTransWindow::NewL(iTopRight,KYellow,rect,&DisplayMode); + iBotLeft->CTWin::DrawNow(); + iBotLeft->SetPosOffset(TPoint(30,30)); + iWindows.Insert(iBotLeft,0); + if(iMajorTest==1) + { + for (TInt window = 0; window < iWindows.Count(); ++window) + { + iWindows[window]->SetDrawOpaque(ETrue); + iWindows[window]->Invalidate(); + } + TheClient->WaitForRedrawsToFinish(); + } + CheckDisplay(); + } + +void CTMultipleTrans::RecreateWindowsL(CTWinBase *aParent) + { + CTransWindow* win; + TInt windows=iWindows.Count(); + TInt window; + //Delete existing windows: + for (window=windows;window>0;--window) + { + win=iWindows[0]; + iWindows.Remove(0); + delete win; + } + + if(!aParent) + aParent = TheClient->iGroup; + + iBotRight=CTransWindow::NewL(aParent,KBlue,TRect(WinSize.iWidth/2-10,WinSize.iHeight/2-30,WinSize.iWidth-20,WinSize.iHeight-20),&DisplayMode); + iBotRight->CTWin::DrawNow(); + iWindows.Insert(iBotRight,0); + iTopLeft=CTransWindow::NewL(aParent,KRed,TRect(10,10,WinSize.iWidth/2+10,WinSize.iHeight/2+30),&DisplayMode); + iTopLeft->CTWin::DrawNow(); + iWindows.Insert(iTopLeft,0); + iTopRight=CTransWindow::NewL(aParent,KGreen,TRect(WinSize.iWidth/2-30,20,WinSize.iWidth-10,WinSize.iHeight/2+10),&DisplayMode); + iTopRight->CTWin::DrawNow(); + iWindows.Insert(iTopRight,0); + iBotLeft=CTransWindow::NewL(aParent,KYellow,TRect(20,WinSize.iHeight/2-10,WinSize.iWidth/2+30,WinSize.iHeight-10),&DisplayMode); + iBotLeft->CTWin::DrawNow(); + iWindows.Insert(iBotLeft,0); + iShadows=EFalse; + + if(iMajorTest==1) + { + for (TInt window=0;windowSetDrawOpaque(ETrue); + iWindows[window]->Invalidate(); + } + TheClient->WaitForRedrawsToFinish(); + } + } + +void CTMultipleTrans::RunTestCaseL(TInt /*aCurTestCase*/) + { + _LIT(KCheck,"Check"); + _LIT(KSimple,"Simple Test"); + _LIT(KVisibility,"Change Visibility"); + _LIT(KVisibility2,"Change Visibility 2"); + _LIT(KOrdinal,"Ordinal Position"); + _LIT(KSizeChange,"Size Change"); + _LIT(KMoveWin,"Move Window"); + _LIT(KGroupWin,"Group Window Ordinal"); + _LIT(KBackground,"Background Color Changes"); + _LIT(KShadowsOnOff,"Shadows On Off"); + _LIT(KChild1,"Child 1"); + _LIT(KChild2,"Child 2"); + _LIT(KOpacity,"Opaque Drawing"); + _LIT(KTranWinFade,"Fading Transparent Windows"); + ((CTMultipleTransStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName); + + switch(iTest->iState) + { + case 0: +/** +@SYMTestCaseID GRAPHICS-WSERV-0500 +*/ + ((CTMultipleTransStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0500")); + // Check to see if Transparency is enabled before running tests + iTest->LogSubTest(KCheck); + if (TransparencySupportedL()==KErrNotSupported) + { + LOG_MESSAGE(_L("Transparency is not supported\n")); + TestComplete(); + return; + } + ++iTest->iState; //Fall Through +/** +@SYMTestCaseID GRAPHICS-WSERV-0111 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc Simple transparent windows test. + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Four overlapping transparent windows (RWindow) are created before the test on the screen's left side. + The test draws the windows on the screen's right side using FBS bitmaps direcly. + The test does nothing if transparency is not enabled on the screen. + +@SYMTestExpectedResults Expects that left and rightside bitmaps are identical +*/ + case 1: + ((CTMultipleTransStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0111")); + iTest->LogSubTest(KSimple); + SimpleTest(); + break; +/** +@SYMTestCaseID GRAPHICS-WSERV-0112 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc On/off switching of visibility of transparent windows + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Four overlapping transparent windows (RWindow) are created before the test on the screen's left side. + The test toggles visibility of those four windows going through all + combinations. For each combination it draws visible windows on the screen's right side using FBS bitmaps direcly. + The test does nothing if transparency is not enabled on the screen. + +@SYMTestExpectedResults Expects that left and rightside bitmaps are identical +*/ + case 2: + case 23: + case 42: + ((CTMultipleTransStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0112")); + iTest->LogSubTest(KVisibility); + ChangeVisibility(); + break; +/** +@SYMTestCaseID GRAPHICS-WSERV-0113 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc On/off switching of visibility of a small transparent window on top of existing transparent windows + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Four overlapping transparent windows (RWindow) are created before the test on the screen's left side. + Toggles visibility of 5th blank little window making this appear in different places + with different ordinal position. Draws visible windows on the screen's right side using FBS bitmaps direcly + each time when the 5th window becomes invisible. + The test does nothing if transparency is not enabled on the screen. + +@SYMTestExpectedResults Expects that left and rightside bitmaps are identical +*/ + case 3: + ((CTMultipleTransStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0113")); + iTest->LogSubTest(KVisibility2); + ChangeVisibility2(); + break; +/** +@SYMTestCaseID GRAPHICS-WSERV-0114 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc Ordinal positions' switches of intersecting transparent windows + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Four overlapping transparent windows (RWindow) are created before the test on the screen's left side. + Switches ordinal positions of the four windows trying all combinations. Draws visible windows on the screen's right side + using FBS bitmaps direcly each time when a new combination is applied. + The test does nothing if transparency is not enabled on the screen. + + +@SYMTestExpectedResults Expects that left and rightside bitmaps are identical +*/ + case 4: + case 43: + ((CTMultipleTransStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0114")); + iTest->LogSubTest(KOrdinal); + OrdinalPos(); + break; +/** +@SYMTestCaseID GRAPHICS-WSERV-0115 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc Changing sizes of intersecting transparent windows + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Four overlapping transparent windows (RWindow) are created before the test on the screen's left side. + Plays with sizes of each of the four windows to affect overlapping. + Draws visible windows on the screen's right side using FBS bitmaps direcly + each time when a new size for a particular window is applied. + The test does nothing if transparency is not enabled on the screen. + + +@SYMTestExpectedResults Expects that left and rightside bitmaps are identical +*/ + case 5: + case 24: + ((CTMultipleTransStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0115")); + iTest->LogSubTest(KSizeChange); + SizeChange(); + break; +/** +@SYMTestCaseID GRAPHICS-WSERV-0116 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc Moving intersecting transparent windows + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Four overlapping transparent windows (RWindow) are created before the test on the screen's left side. + Performs moves of those windows one by one making little steps in direction of the center of intersection and backwards. + Draws visible windows on the screen's right side using FBS bitmaps direcly + each time when a position of a particular window changes. + The test does nothing if transparency is not enabled on the screen. + +@SYMTestExpectedResults Expects that left and rightside bitmaps are identical +*/ + case 6: + ((CTMultipleTransStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0116")); + iTest->LogSubTest(KMoveWin); + MoveWin(); + break; +/** +@SYMTestCaseID GRAPHICS-WSERV-0117 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc Test with a second window group + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Four overlapping transparent windows (RWindow, within the same group) are created before the test on the screen's left side. + Creates a 5th transparent window in a separate window group + on top of existing windows which covers the intersection area of initial 4 windows. + Changes the ordinal position of the group to 1, changes ordinal position + back to 0, removes the new group. + Redraws visible windows on the screen's right side using FBS bitmaps direcly + each time when any change on the screen's left side is performed. + The test does nothing if transparency is not enabled on the screen. + +@SYMTestExpectedResults Expects that left and rightside bitmaps are identical +*/ + case 7: + ((CTMultipleTransStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0117")); + iTest->LogSubTest(KGroupWin); + GroupWinL(); + break; + case 8: + ((CTMultipleTransStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName); + iTest->LogSubTest(KBackground); + //Change the background color of the 4 test windows and the window behind them + break; +/** +@SYMTestCaseID GRAPHICS-WSERV-0118 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc On/off switching of fading + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Four overlapping transparent windows (RWindow) are created before the test on the screen's left side. + Switches system fading on and right after that back to off. + Draws visible windows on the screen's right side using FBS bitmaps direcly + after that. + The test does nothing if transparency is not enabled on the screen. + +@SYMTestExpectedResults Expects that left and rightside bitmaps are identical +*/ + case 9: + ((CTMultipleTransStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0118")); + iTest->LogSubTest(KTranWinFade); + FadeTranWin(); + break; + case 10: + ((CTMultipleTransStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName); + iTest->iState=21-1; + break; +/** +@SYMTestCaseID GRAPHICS-WSERV-0120 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc Shadows' on/off test. + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Four overlapping transparent windows (RWindow) with shadowing enabled are created before the test on the screen's left side. + The test plays with on/off-switching of shadowing and visibility for the windows. + The test redraws visible windows on the screen's right side using FBS bitmaps direcly + each time when state of ony window changes. + The test does nothing if transparency is not enabled on the screen. + The test also repeats GRAPHICS-WSERV-0111 - GRAPHICS-WSERV-015 foor the shadowed windows. + +@SYMTestExpectedResults Expects that left and rightside bitmaps are identical +*/ + case 22: + ((CTMultipleTransStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0120")); + iTest->LogSubTest(KShadowsOnOff); + ShadowsOnOff(); + break; + case 25: + ((CTMultipleTransStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName); + iTest->iState=41-1; + break; +/** +@SYMTestCaseID GRAPHICS-WSERV-0121 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc Transparent child-windows of a bacground window + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Four overlapping transparent windows (RWindow) with shadowing enabled are created before the test on the screen's left side. + The test removes those windows and creates new four overlapping transparent windows + but as children of existing background window. After that the test redraws visible windows on the screen's right side using FBS bitmaps direcly. + The test does nothing if transparency is not enabled on the screen. + The test also repeats GRAPHICS-WSERV-0111 - GRAPHICS-WSERV-014 foor the shadowed windows. + +@SYMTestExpectedResults Expects that left and rightside bitmaps are identical +*/ + case 41: + ((CTMultipleTransStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0121")); + iTest->LogSubTest(KChild1); + StartChildL(); + break; + case 44: + ((CTMultipleTransStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName); + iTest->iState=61-1; + break; +/** +@SYMTestCaseID GRAPHICS-WSERV-0122 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Four overlapping transparent windows (RWindow) with shadowing enabled are created before the test on the screen's left side. + The test removes those windows and creates new four transparent windows + so that each one (except first) is a child of prevoiusly created window. + The test redraws visible windows on the screen's right side using FBS bitmaps direcly + after each window's creation. + The test does nothing if transparency is not enabled on the screen. + +@SYMTestExpectedResults Expects that left and rightside bitmaps are identical +*/ + case 61: + ((CTMultipleTransStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0122")); + iTest->LogSubTest(KChild2); + StartChild2L(); + break; + default: + ((CTMultipleTransStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0123")); +/** +@SYMTestCaseID GRAPHICS-WSERV-0123 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions The test draws four overlapping transparent windows (RWindow) on the screen's left side. + Each window has an opaque diagonal line (\) which goes from the top-left corner of each window. + The test repeats all tests from GRAPHICS-WSERV-0111 to GRAPHICS-WSERV-0122 + with those four windows and diagonaly lines on them. + +@SYMTestExpectedResults Expects that all tests will obtain results they expected. +*/ + if (iMajorTest==1 || !iOpacitySupported) + { + if (!iOpacitySupported) + { + _LIT(KNoOpacity,"Opacity is not supported"); + LOG_MESSAGE(KNoOpacity); + } + ((CTMultipleTransStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName); + TestComplete(); + return; + } + LOG_MESSAGE(KOpacity); + iTest->iState=0; + iMajorTest=1; + RecreateWindowsL(); + break; + } + ((CTMultipleTransStep*)iStep)->RecordTestResultL(); + ++iTest->iState; + } + + +__WS_CONSTRUCT_STEP__(MultipleTrans)