// 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 alpha channel transparent windows

// Test that draw operations with non-opaque colours do alpha blending in EColor64K and EColor16MA display modes

// Test that alpha channel transparent windows are drawn correctly when windows move, redraw, change visibility, etc.

// In the draw operation tests, the left window draws opaque pink on white background, the right window blends semi-transparent red on white background,

// and the results are compared.

// In the transparent window tests, the right window contains several transparent windows, which are moved, redrawn, visibility changed, etc,

// the left window contains a single window in which we draw what we expect the right window to look like. The results are compared.

// In each case, the left and right windows should be identical

// 

//

#include "TALPHAWIN.H"

enum

	{

	EOpDrawRect,

	EOpDrawLine,

	EOpDrawEllipse,

	EOpDrawText,

	EOpDrawTextVertical,

	EOpDrawTextAntiAliased,

	EOpBitBlt,

	EOpBitBltMasked,

	ENumDrawOps

	};

enum

	{

	ERed = 0x1,

	EGreen = 0x2,

	EBlue = 0x4,

	EAlphaTransparency = 0x8,

	ETransparencyFactor = 0x10,

	// defaults to non-transparent

	EOpaque = 0x20,

	ETransparent = 0x40,

	// defaults to semi-transparent

	EModeColor64K = 0x80,

	EModeColor16MA = 0x100,

	// defaults to 64k

	EInvisible = 0x200,

	EActive = 0xf000000

	};

TRgb ColourFromDrawState(TInt aDrawState)

	{

	TInt red = (aDrawState & ERed) ? 255 : 0;

	TInt green = (aDrawState & EGreen) ? 255 : 0;

	TInt blue = (aDrawState & EBlue) ? 255 : 0;

	TInt alpha = 128;

	if (aDrawState & EOpaque)

		alpha = 255;

	if (aDrawState & ETransparent)

		alpha = 0;

	return TRgb(red, green, blue, alpha);

	}

//

// CTAlphaWinTest

//

CTAlphaWin::CTAlphaWin(CTestStep* aStep):

	CTWsGraphicsBase(aStep)

	{

	}

CTAlphaWin::~CTAlphaWin()

	{

	iTestWin.DeleteAll();

	delete iRefWin;

	}

void CTAlphaWin::ConstructL()

	{

	if(TransparencySupportedL() == KErrNotSupported)

			return;

	TSize winSize = BaseWin->Size();

	iTestWin[0] = CTAlphaWindow::NewL(this, TestWin, TPoint(0,0), winSize, ERed | EGreen | EBlue | EOpaque);

	iTestWin[1] = CTAlphaWindow::NewL(this, TestWin, TPoint(0,0), TSize(winSize.iWidth/2, winSize.iHeight/2), ERed | EAlphaTransparency);

	iTestWin[2] = CTAlphaWindow::NewL(this, TestWin, TPoint(winSize.iWidth/3,0), TSize(winSize.iWidth/2, winSize.iHeight/2), EGreen | EAlphaTransparency);

	iTestWin[3] = CTAlphaWindow::NewL(this, TestWin, TPoint(winSize.iWidth/6, winSize.iHeight/3), TSize(winSize.iWidth/2, winSize.iHeight/2), EBlue | EAlphaTransparency);

	iTestWin[4] = CTAlphaWindow::NewL(this, TestWin, TPoint(winSize.iWidth/4,winSize.iHeight/6), TSize(winSize.iWidth/3,winSize.iHeight/3), ERed | EGreen | EBlue | EAlphaTransparency | ETransparent);

	iRefWin = CTAlphaRefWin::NewL(BaseWin, TPoint(0,0), winSize, iTestWin);

	//Clearing the windows

	BaseWin->ClearWin();

	TestWin->ClearWin();

	}

void CTAlphaWin::ConfigureDisplayModes(TDisplayMode aRequiredMode = EColor16M)

	{

	TInt i;

	for (i=0; i<5; i++)

		{

		iTestWin[i]->BaseWin()->SetRequiredDisplayMode(aRequiredMode);

		}

	iRefWin->BaseWin()->SetRequiredDisplayMode(aRequiredMode);

	}

void CTAlphaWin::TestSemiTransparentDrawingL()

	{

	TSize winSize = BaseWin->Size();

	// In this window, we draw opaque pink

	CTDrawOpWin* drawWin = CTDrawOpWin::NewL(this, BaseWin, TPoint(0,0), winSize, TRgb(255,127,127,255));

	// In this window, we blend semi-transparent red

	CTDrawOpWin* blendWin = CTDrawOpWin::NewL(this, TestWin, TPoint(0,0), winSize, TRgb(255,0,0,128));

	const TInt tolerance = 9;//8 - wouldn't be enough!! The defect 	DEF112334 was raised

	for (TInt i=EOpDrawRect; i<ENumDrawOps; i++)

		{

	//	User::After(1000000);// helpful when debugging

		drawWin->SetDrawOp(i);

		blendWin->SetDrawOp(i);

		drawWin->DrawNow();

		blendWin->DrawNow();

		TheClient->Flush();

		TheClient->WaitForRedrawsToFinish();

		if((i == EOpDrawTextAntiAliased) && (TheClient->iScreen->DisplayMode() == EColor16MA) || (TheClient->iScreen->DisplayMode() == EColor16MAP))

			{		

			TSize winSize=BaseWin->Size();

			TRect rect1(BaseWin->BaseWin()->InquireOffset(*TheClient->iGroup->WinTreeNode()),winSize);

			TRect rect2(TestWin->BaseWin()->InquireOffset(*TheClient->iGroup->WinTreeNode()),winSize);

			CheckRectL(rect1, rect2, winSize, TheClient->iScreen->DisplayMode(), tolerance, _L("CTAlphaWin::TestSemiTransparentDrawingL()"));

			}

		else

			{

			CheckRect(BaseWin,TestWin,_L("CTAlphaWin::TestSemiTransparentDrawingL()"));

			}	

		}

	delete drawWin;

	delete blendWin;

	}

void CTAlphaWin::TestTransparentDrawingL()

	{

	TSize winSize = BaseWin->Size();

	// In this window, we draw opaque white

	CTDrawOpWin* drawWin = CTDrawOpWin::NewL(this, BaseWin, TPoint(0,0), winSize, TRgb(255,255,255,255));

	// In this window, we blend transparent red

	CTDrawOpWin* blendWin = CTDrawOpWin::NewL(this, TestWin, TPoint(0,0), winSize, TRgb(255,0,0,0));

	for (TInt i=EOpDrawRect; i<ENumDrawOps; i++)

		{

		//User::After(1000000);// helpful when debugging

		drawWin->SetDrawOp(i);

		blendWin->SetDrawOp(i);

		drawWin->DrawNow();

		blendWin->DrawNow();

		TheClient->Flush();

		TheClient->WaitForRedrawsToFinish();

		CheckRect(BaseWin,TestWin,_L("CTAlphaWin::TestTransparentDrawingL()"));

		}

	delete drawWin;

	delete blendWin;

	}

void CTAlphaWin::CheckRectL(const TRect& aRect1, const TRect& aRect2, TSize aSize, TDisplayMode aRequiredMode, TInt aTolerance, const TDesC& aErrorMsg)

	{

	CFbsBitmap *bmp1 = new (ELeave) CFbsBitmap;

	CleanupStack::PushL(bmp1);

	User::LeaveIfError(bmp1->Create(aSize, aRequiredMode));

	CFbsBitmap *bmp2 = new (ELeave) CFbsBitmap;

	CleanupStack::PushL(bmp2);

	User::LeaveIfError(bmp2->Create(aSize, aRequiredMode));

	User::LeaveIfError(TheClient->iScreen->CopyScreenToBitmap(bmp1, aRect1));	

	User::LeaveIfError(TheClient->iScreen->CopyScreenToBitmap(bmp2, aRect2));	

	TRgb *rgbBuf1=(TRgb *)User::AllocL(aSize.iWidth*sizeof(TRgb));	

	TRgb *rgbBuf2=(TRgb *)User::Alloc(aSize.iWidth*sizeof(TRgb));	

	if(!rgbBuf2)

		{

		User::Free(rgbBuf1);

		User::Leave(KErrNoMemory);

		}

	TBool equal = ETrue;

	TInt maxDeviation = 0;

	for(TInt yy = 0; yy < aSize.iHeight && equal; yy++)

		{

		TPtr8 ptr1((TUint8 *)rgbBuf1,aSize.iWidth*sizeof(TRgb));

		bmp1->GetScanLine(ptr1, TPoint(0, yy), aSize.iWidth, ERgb);

		TPtr8 ptr2((TUint8 *)rgbBuf2,aSize.iWidth*sizeof(TRgb));

		bmp2->GetScanLine(ptr2, TPoint(0, yy), aSize.iWidth, ERgb);

		TRgb *rgbBufCur1 = rgbBuf1;

		TRgb *rgbBufCur2 = rgbBuf2;

		for(TInt ii = 0; ii < aSize.iWidth; ii++)

			{

			TInt delta = Abs(rgbBufCur1->Red()-rgbBufCur2->Red());

			TInt delta1 = Abs(rgbBufCur1->Green()-rgbBufCur2->Green());

			TInt delta2 = Abs(rgbBufCur1->Blue()-rgbBufCur2->Blue());

			if((delta > aTolerance) || (delta1 > aTolerance) || (delta2 > aTolerance))

				{

				equal = EFalse;

				}

			TInt maxItermedia = Max(delta1, delta2);

			maxItermedia = Max(maxItermedia, delta);

			maxDeviation = Max(maxItermedia, maxDeviation);

			rgbBufCur1++;	

			rgbBufCur2++;	

			}

		}

	User::Free(rgbBuf1);

	User::Free(rgbBuf2);

	CleanupStack::PopAndDestroy(2,bmp1);

	if (!equal)

		{

		INFO_PRINTF3(_L("%S CheckRectA failed, max deviation %d"), &aErrorMsg, maxDeviation);

		}

	else if(maxDeviation)

		{

		INFO_PRINTF4(_L("%S CheckRectA passed with tolerance %d, max deviation %d"), &aErrorMsg, aTolerance, maxDeviation);

		}

	iStep->TEST(equal);

	}

void CTAlphaWin::TestCondition()

	{

	// User::After(1000000);// helpful when debugging

	iRefWin->DrawNow();

	TheClient->Flush();

	TheClient->WaitForRedrawsToFinish();

	CheckRect(BaseWin,TestWin,_L("CTAlphaWin::TestCondition()"));

	}

void CTAlphaWin::TestConditionL()

	{

	iRefWin->DrawNow();

	TheClient->Flush();

	TheClient->WaitForRedrawsToFinish();

	const TInt tolerance = 9;

	TSize winSize=BaseWin->Size();

	TRect rect1(BaseWin->BaseWin()->InquireOffset(*TheClient->iGroup->WinTreeNode()),winSize);

	TRect rect2(TestWin->BaseWin()->InquireOffset(*TheClient->iGroup->WinTreeNode()),winSize);

	CheckRectL(rect1, rect2, winSize, TheClient->iScreen->DisplayMode(), tolerance, _L("CTAlphaWin::TestCondition()"));

	}

void CTAlphaWin::TestInitialConfiguration()

	{

	if(TheClient->iScreen->DisplayMode() == EColor64K)

		{

		TestConditionL();

		}

	else

		{

		TestCondition();

		}

	}

void CTAlphaWin::TestMove()

	{

	// Test moving windows, both in front and behind

	for (TInt i = 0; i<5; i++)

		{

		TPoint pos = iTestWin[i]->Position();

		pos += TPoint(10,10);

		iTestWin[i]->SetPos(pos);

		TestCondition();

		}

	for (TInt j = 0; j<5; j++)

		{

		TPoint pos = iTestWin[j]->Position();

		pos -= TPoint(10,10);

		iTestWin[j]->SetPos(pos);

		TestCondition();

		}

	}

void CTAlphaWin::TestRedraw()

	{

	// Test redrawing windows, both in front and behind

	for (TInt i=0; i<5; i++)

		{

		iTestWin[i]->DrawNow();

		TestCondition();

		}

	}

void CTAlphaWin::TestInvisible()

	{

	// Test making windows visible and invisible, both in front and behind

	for (TInt i=0; i<5; i++)

		{

		iTestWin[i]->SetVisible(EFalse);

		TestCondition();

		iTestWin[i]->SetVisible(ETrue);

		TestCondition();

		}

	}

void CTAlphaWin::TestChildrenL()

	{

	struct CTAlphaWinChildren: public TCleanupItem

		{

			static void Destroy(TAny* trg)

				{

				static_cast<CTAlphaWindow*>(trg)->DestroyChildren();				

				}

			CTAlphaWinChildren(CTAlphaWindow*trg):	TCleanupItem(Destroy,trg)	

				{}

		};

	CleanupStack::PushL(CTAlphaWinChildren(iTestWin[2]));

	iTestWin[2]->CreateChildrenL(3);

	TestCondition();

	TestMove();

	CleanupStack::PopAndDestroy(iTestWin[2]);

	}

void CTAlphaWin::TestAntiAliasedTextTransparentL()

	{

	//Clear the screen

	for (TInt i=0; i<5; i++)

		{

		iTestWin[i]->SetVisible(EFalse);

		}

	iRefWin->SetVisible(EFalse);

	TheClient->iWs.Flush();

	//Create a new test window on the left

	//Create a transparent window:

	TSize winSize = BaseWin->Size();

	RWindow theWin(TestWin->Client()->iWs);

	User::LeaveIfError(theWin.Construct(*(TestWin->WinTreeNode()),(TUint32)&theWin));

	theWin.SetExtent(TPoint(0,0), winSize);

	theWin.SetBackgroundColor(TRgb(127,0,255,127));

	TDisplayMode mode = EColor16MAP;

	theWin.SetRequiredDisplayMode(mode);

	theWin.SetVisible(ETrue);

	theWin.SetTransparencyAlphaChannel();

	theWin.Activate();

	TheClient->iWs.Flush();

	CleanupClosePushL(theWin);

	//get windows screen device.

	CWsScreenDevice *device;

	device = new (ELeave)CWsScreenDevice(TestWin->Client()->iWs);//(TheClient->iWs);

	User::LeaveIfError(device->Construct(iTest->ScreenNumber()));

	CleanupStack::PushL(device);

	TFontSpec fs1;

	CFont *font1;

	CFont *font2;

	fs1.iTypeface.iName = KTestFontTypefaceName;

	fs1.iHeight = 16;

	fs1.iFontStyle.SetBitmapType(EDefaultGlyphBitmap);

	int error = TheClient->iScreen->GetNearestFontToDesignHeightInPixels((CFont*&)font1,fs1);

	if (error)

		{

		TheClient->iScreen->ReleaseFont(font1);

		User::Panic(_L("font not created"),error);

		}

	fs1.iFontStyle.SetBitmapType(EAntiAliasedGlyphBitmap);

	error = TheClient->iScreen->GetNearestFontToDesignHeightInPixels((CFont*&)font2,fs1);

	if (error)

		{

		TheClient->iScreen->ReleaseFont(font1);

		TheClient->iScreen->ReleaseFont(font2);

		User::Panic(_L("font not created"),error);

		}

	CWindowGc *gc;

	device->CreateContext(gc);

	CleanupStack::PushL(gc);

	theWin.Invalidate();

	theWin.BeginRedraw();

	gc->Activate(theWin);

	gc->SetPenStyle( CGraphicsContext::ESolidPen );

	gc->SetPenColor( TRgb( 0, 0, 0, 127 ) );

	//draw text for anti-aliasing needs an open font (scalable).

	int typefaces = TheClient->iScreen->NumTypefaces();

	gc->UseFont(font1);

	gc->SetBrushStyle( CGraphicsContext::ENullBrush );

	gc->DrawText(_L("Test"),TPoint(10,20));

	gc->DiscardFont();

	gc->UseFont(font2);

	gc->DrawText(_L("Test"),TPoint(10,60));

	gc->DiscardFont();

	//destruction and tidying up

	gc->Deactivate();

	theWin.EndRedraw();

	TheClient->iWs.Flush();

	TheClient->iScreen->ReleaseFont(font1);

	TheClient->iScreen->ReleaseFont(font2);

	CleanupStack::PopAndDestroy(gc);//gc

	CleanupStack::PopAndDestroy(device);//device

	//do not close the test window yet since there is a comparison

	//required

	//now do the same on an off screen bitmap.  Then create a window

	//and put the bitmap onto it.

	//create a colour bitmap

	//

	CFbsBitmap *bitmapOne;

	bitmapOne = new (ELeave)CFbsBitmap();

	CleanupStack::PushL(bitmapOne);

	User::LeaveIfError(bitmapOne->Create(winSize,mode));

	CFbsBitmapDevice *deviceOne=CFbsBitmapDevice::NewL(bitmapOne);

	CleanupStack::PushL(deviceOne);

	CFont *font3;

	CFont *font4;

	fs1.iFontStyle.SetBitmapType(EDefaultGlyphBitmap);

	error = TheClient->iScreen->GetNearestFontToDesignHeightInPixels((CFont*&)font3,fs1);

	if (error)

		{

		TheClient->iScreen->ReleaseFont(font3);

		User::Panic(_L("font not created"),error);

		}

	fs1.iFontStyle.SetBitmapType(EAntiAliasedGlyphBitmap);

	error = TheClient->iScreen->GetNearestFontToDesignHeightInPixels((CFont*&)font4,fs1);

	if (error)

		{

		TheClient->iScreen->ReleaseFont(font3);

		TheClient->iScreen->ReleaseFont(font4);

		User::Panic(_L("font not created"),error);

		}

	CFbsBitGc *bGcOne = CFbsBitGc::NewL();

	CleanupStack::PushL(bGcOne);

	bGcOne->Activate(deviceOne);

	bGcOne->SetBrushStyle(CGraphicsContext::ESolidBrush);

	bGcOne->SetBrushColor(TRgb(127,0,255,127));

	bGcOne->DrawRect(TRect(0,0,winSize.iWidth,winSize.iHeight));

	bGcOne->SetPenStyle(CGraphicsContext::ESolidPen);

	bGcOne->SetPenColor(TRgb(0,0,0,127));

	bGcOne->UseFont(font3);

	bGcOne->SetBrushStyle( CGraphicsContext::ENullBrush );

	bGcOne->DrawText(_L("Test"),TPoint(10,20));

	bGcOne->DiscardFont();

	bGcOne->UseFont(font4);

	bGcOne->DrawText(_L("Test"),TPoint(10,60));

	bGcOne->DiscardFont();

	//destruction and tidying up

	//measure the text

	CFont::TMeasureTextOutput textSize;

	font4->MeasureText(_L("Test"),NULL,&textSize);

	TheClient->iScreen->ReleaseFont(font3);

	TheClient->iScreen->ReleaseFont(font4);

	//display at the left

	RWindow refWin(BaseWin->Client()->iWs);

	CleanupClosePushL(refWin);

	User::LeaveIfError(refWin.Construct(*(BaseWin->WinTreeNode()),(TUint32)&refWin));

	refWin.SetExtent(TPoint(0,0), winSize);

	refWin.SetRequiredDisplayMode(mode);

	refWin.SetVisible(ETrue);

	refWin.SetTransparencyAlphaChannel();

	refWin.Activate();

	TheClient->iWs.Flush();

	//a gc for the ref win

	CWsScreenDevice *refDevice;

	refDevice = new (ELeave)CWsScreenDevice(BaseWin->Client()->iWs);

	User::LeaveIfError(refDevice->Construct(iTest->ScreenNumber()));

	CleanupStack::PushL(refDevice);

	CWindowGc *gcRef;

	refDevice->CreateContext(gcRef);

	CleanupStack::PushL(gcRef);

	refWin.Invalidate();

	refWin.BeginRedraw();

	gcRef->Activate(refWin);

	gcRef->BitBlt(TPoint(0,0), bitmapOne);

	gcRef->Deactivate();

	refWin.EndRedraw();

	TheClient->iWs.Flush();

	TPoint refPos = refWin.AbsPosition();

	TPoint winPos = theWin.AbsPosition();

	//Compare the anti-aliased text areas

	TInt textLength=textSize.iBounds.iBr.iX;

	TInt textHeight=Abs(textSize.iBounds.iTl.iY);

	TRect rect1(refPos.iX+10,refPos.iY+60-textHeight,

			refPos.iX+10+textLength,refPos.iY+60);

	TRect rect2(winPos.iX+10,winPos.iY+60-textHeight,

			winPos.iX+10+textLength,winPos.iY+60);

	TBool match = refDevice->RectCompare(rect1,rect2);

	TEST(match);

	CleanupStack::PopAndDestroy(gcRef);

	CleanupStack::PopAndDestroy(refDevice);

	CleanupStack::PopAndDestroy(&refWin);

	CleanupStack::PopAndDestroy(bGcOne);

	CleanupStack::PopAndDestroy(deviceOne);

	CleanupStack::PopAndDestroy(bitmapOne);

	CleanupStack::PopAndDestroy(&theWin);//theWin

	}

//

// CTDrawOpWin

//

CTDrawOpWin* CTDrawOpWin::NewL(CTAlphaWin* aTest, CTWinBase* aParent, TPoint aPos, TSize aSize, TRgb aDrawColour)

	{

	CTDrawOpWin* theWin = new(ELeave) CTDrawOpWin(aTest,aDrawColour);

	theWin->ConstructL(*aParent);

	theWin->SetExtL(aPos, aSize);

	theWin->AssignGC(*TheClient->iGc);

	if (TheClient->iScreen->DisplayMode() == EColor16MA)

		{

		theWin->BaseWin()->SetRequiredDisplayMode(EColor16MA);

		}

	else

		{

		theWin->BaseWin()->SetRequiredDisplayMode(EColor64K);

		}

	theWin->Activate();

	theWin->DrawNow();

	return theWin;

	}

CTDrawOpWin::CTDrawOpWin(CTAlphaWin* aTest, TRgb aDrawColour)

: iTest(aTest), iDrawColour(aDrawColour)

	{}

void CTDrawOpWin::SetDrawOp(TInt aDrawOp)

	{

	iDrawOp = aDrawOp;

	}

void CTDrawOpWin::Draw()

	{

	_LIT(KText,"Text test");

	iGc->SetPenColor(iDrawColour);

	iGc->SetBrushColor(iDrawColour);

	TSize size = Size();

	TInt top = 5;

	TInt left = 5;

	TInt bottom = size.iHeight - 5;

	TInt right = size.iWidth - 5;

	TInt square = Min(bottom-top,right-left);

	switch (iDrawOp)

		{

	case EOpDrawRect:

		iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

		iGc->SetPenStyle(CGraphicsContext::ENullPen);

		iGc->DrawRect(TRect(left,top,right,bottom));

		break;

	case EOpDrawLine:

		//!! FAILS

		//!! The endpoint of the line is drawn twice, with the result that it is darker when we do blending

		//!! Not intending to fix at the moment

		/*

		iGc->SetPenStyle(CGraphicsContext::ESolidPen);

		iGc->SetPenSize(TSize(4,4));

		// The lines must not overlap, otherwise the blended lines will be darker at the overlap

		iGc->DrawLine(TPoint(left+5,top), TPoint(left+square,top));

		iGc->DrawLine(TPoint(left+5,top+5), TPoint(left+square,top+square));

		iGc->DrawLine(TPoint(left,top+5), TPoint(left,top+square));

		*/

		break;

	case EOpDrawEllipse:

		iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

		iGc->SetPenStyle(CGraphicsContext::ENullPen);

		iGc->DrawEllipse(TRect(left,top,right,bottom));

		break;

	case EOpDrawText:

	case EOpDrawTextVertical:

		{

		iGc->SetBrushStyle(CGraphicsContext::ENullBrush);

		iGc->SetPenStyle(CGraphicsContext::ESolidPen);

		CFont* font;

		TFontSpec fontSpec(KTestFontTypefaceName,200);

		User::LeaveIfError(TheClient->iScreen->GetNearestFontToDesignHeightInTwips(font, fontSpec));

		iGc->UseFont(font);

		if (iDrawOp==EOpDrawText)

			iGc->DrawText(KText(), TPoint(5,30));

		else

			iGc->DrawTextVertical(KText(), TPoint(5,30), EFalse);

		iGc->DiscardFont();

		TheClient->iScreen->ReleaseFont(font);

		}

		break;

	case EOpDrawTextAntiAliased:

		{

		iGc->SetBrushStyle(CGraphicsContext::ENullBrush);

		iGc->SetPenStyle(CGraphicsContext::ESolidPen);

		CFont* font;

		TFontSpec fontSpec(KTestFontTypefaceName,600);

		fontSpec.iFontStyle.SetStrokeWeight(EStrokeWeightBold);

		fontSpec.iFontStyle.SetBitmapType(EAntiAliasedGlyphBitmap);

		User::LeaveIfError(TheClient->iScreen->GetNearestFontToDesignHeightInTwips(font, fontSpec));

		iGc->UseFont(font);

		iGc->DrawText(KText(), TPoint(5,30));

		iGc->DiscardFont();

		TheClient->iScreen->ReleaseFont(font);

		}

		break;

	case EOpBitBlt:

		break;

	case EOpBitBltMasked:

		break;

	default:

		break;

		};

	}

//

// CTAlphaWindow

//

CTAlphaWindow::~CTAlphaWindow()

	{

	DestroyChildren();

	}

CTAlphaWindow* CTAlphaWindow::NewL(CTAlphaWin* aTest, CTWinBase* aParent, TPoint aPos, TSize aSize, TInt aDrawState)

	{

	CTAlphaWindow* theWin = new (ELeave) CTAlphaWindow(aTest);

	theWin->ConstructL(*aParent);

	theWin->SetExtL(aPos, aSize);

	theWin->SetDrawState(aDrawState);

	theWin->AssignGC(*TheClient->iGc);

	theWin->Activate();

	theWin->iDrawState |= EActive;

	theWin->DrawNow();

	return theWin;

	}

void CTAlphaWindow::SetDrawState(TInt aDrawState)

	{

	TBool active = iDrawState & EActive;

	iDrawState = aDrawState & 0x7fffffff;

	TRgb colour = ColourFromDrawState(iDrawState);

	((RWindow*) DrawableWin())->SetBackgroundColor(colour);

	if (iDrawState & EModeColor16MA)

		BaseWin()->SetRequiredDisplayMode(EColor16MA);

	else

		BaseWin()->SetRequiredDisplayMode(EColor64K);

	BaseWin()->SetVisible(! (iDrawState & EInvisible));

	if (!active)

		{

		if (iDrawState & EAlphaTransparency)

			((RWindow*) DrawableWin())->SetTransparencyAlphaChannel();

		else if (iDrawState & ETransparencyFactor)

			((RWindow*) DrawableWin())->SetTransparencyFactor(TRgb(128,128,128));

		}

	if (active)

		iDrawState |= EActive;

	}

void CTAlphaWindow::SetVisible(TBool aVisible)

	{

	if (aVisible)

		iDrawState &= ~EInvisible;

	else

		iDrawState |= EInvisible;

	BaseWin()->SetVisible(aVisible);

	}

void CTAlphaWindow::CreateChildrenL(TInt aDepth)

	{

	DestroyChildren();

	if (aDepth>0)

		{

		TSize size = Size();

		iChild1 = CTAlphaWindow::NewL(iTest, this, TPoint(size.iWidth/3,0), TSize(2*size.iWidth/3, 2*size.iHeight/3), ERed | EGreen | EBlue | EOpaque);

		iChild2 = CTAlphaWindow::NewL(iTest, this, TPoint(0,size.iHeight/3), TSize(2*size.iWidth/3, 2*size.iHeight/3), ERed | EGreen | EBlue | EAlphaTransparency);

		iChild2->CreateChildrenL(aDepth-1);

		}

	}

void CTAlphaWindow::DestroyChildren()

	{

	if (iChild1)

		{

		iChild1->DestroyChildren();

		delete iChild1;

		iChild1 = NULL;

		}

	if (iChild2)

		{

		iChild2->DestroyChildren();

		delete iChild2;

		iChild2 = NULL;

		}

	}

TInt CTAlphaWindow::DrawState()

	{

	return iDrawState;

	}

void CTAlphaWindow::Draw()

	{

	// we draw a diagonal line from top left to bottom right

	// we use the complementary colour to the window background colour

	TInt red = (iDrawState & ERed) ? 0 : 255;

	TInt green = (iDrawState & EGreen) ? 0 : 255;

	TInt blue = (iDrawState & EBlue) ? 0 : 255;

	TRgb color(red,green,blue);

	TSize size = Size();

	iGc->SetPenColor(color);

	iGc->SetPenSize(TSize(4,4));

	iGc->DrawLine(TPoint(0,0), TPoint(size.iWidth, size.iHeight));

	}

//

// CTAlphaRefWin

//

CTAlphaRefWin::CTAlphaRefWin(TFixedArray<CTAlphaWindow*,5>& aAlphaWin)

: iAlphaWin(aAlphaWin)

	{}

CTAlphaRefWin* CTAlphaRefWin::NewL(CTWinBase* aParent, TPoint aPos, TSize aSize, TFixedArray<CTAlphaWindow*,5>& aAlphaWin)

	{

	CTAlphaRefWin* theWin = new(ELeave) CTAlphaRefWin(aAlphaWin);

	theWin->ConstructL(*aParent);

	theWin->SetExtL(aPos, aSize);

	theWin->AssignGC(*TheClient->iGc);

	theWin->BaseWin()->SetRequiredDisplayMode(EColor64K);

	theWin->Activate();

	theWin->DrawNow();

	return theWin;

	}

void CTAlphaRefWin::Draw()

	{

	iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

	iGc->SetBrushColor(KRgbWhite);

	iGc->Clear();

	// Note, the order of the windows in the array must correspond to their z-order

	for (TInt i=0; i<5; i++)

		DrawWindow(iAlphaWin[i], iAlphaWin[i]->Position());

	}

void CTAlphaRefWin::DrawWindow(CTAlphaWindow* aWindow, TPoint aPos)

	{

	TInt drawState = aWindow->DrawState();

	if ( (drawState & EInvisible) || ! (drawState & EActive) )

		return;

	TRgb colour = ColourFromDrawState(drawState);

	if (drawState & EOpaque)

		colour.SetAlpha(255);

	if (drawState & ETransparent)

		colour.SetAlpha(0);

	iGc->SetBrushColor(colour);

	TPoint tl = aPos;

	TPoint br = tl + aWindow->Size();

	TRect rect(tl,br);

	iGc->Clear(rect);

	TInt red = (drawState & ERed) ? 0 : 255;

	TInt green = (drawState & EGreen) ? 0 : 255;

	TInt blue = (drawState & EBlue) ? 0 : 255;

	colour = TRgb(red,green,blue);

	iGc->SetClippingRect(rect);

	TSize size = Size();

	iGc->SetPenColor(colour);

	iGc->SetPenSize(TSize(4,4));

	iGc->DrawLine(tl, br);

	iGc->CancelClippingRect();

	if (aWindow->iChild1)

		DrawWindow(aWindow->iChild1, aPos + aWindow->iChild1->Position() );

	if (aWindow->iChild2)

		DrawWindow(aWindow->iChild2, aPos + aWindow->iChild2->Position() );

	}

//

// Main test loop

//

void CTAlphaWin::RunTestCaseL(TInt /*aCurTestCase*/)

	{

	//User::After(TTimeIntervalMicroSeconds32(1000 * 1000));

	((CTAlphaWinStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);

	switch (++iTest->iState)

		{

/**

  @SYMTestCaseID GRAPHICS-WSERV-0278

  @SYMDEF             DEF081259

  @SYMPREQ 915

  @SYMTestCaseDesc Semi-transparent drawing

  @SYMTestPriority High

  @SYMTestStatus Implemented

  @SYMTestActions Use draw operations with semi-transparent pen or brush colours

  @SYMTestExpectedResults Draw operations must do alpha blending

*/

	case 1:

		{

		((CTAlphaWinStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0278"));

		if(TransparencySupportedL() == KErrNotSupported)

			{

			LOG_MESSAGE(_L("Test(1) complete - Transparency not supported\n"));

			TestComplete();

			break;

			}

		TDisplayMode mode = TheClient->iScreen->DisplayMode();

		if (mode < EColor64K)

			{

			LOG_MESSAGE(_L("Test(1) complete - Display mode < EColor64K\n"));

			TestComplete();

			break;

			}

		_LIT(KSemiTrans64K,"(1) Semi transparent drawing Color64K");

		iTest->LogSubTest(KSemiTrans64K);

		TestSemiTransparentDrawingL();

		break;

		}

/**

  @SYMTestCaseID GRAPHICS-WSERV-0287

  @SYMDEF             DEF081259

  @SYMPREQ 915

  @SYMTestCaseDesc Invisible. All windows are in EColor16MA display mode.

  @SYMTestPriority High

  @SYMTestStatus Implemented

  @SYMTestActions Transparent alpha channel windows are made invisible and visible both in front and behind one another

  @SYMTestExpectedResults The windows are redrawn correctly, as compared to a reference drawing

*/

	case 2:

		((CTAlphaWinStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0287"));

		ConfigureDisplayModes(EColor16MA);

		if(TransparencySupportedL()==KErrNone)

			{

			_LIT(KInvisible16MA,"(2) Invisible Color16MA");

			iTest->LogSubTest(KInvisible16MA);

			TestInvisible();

			}

		break;

/**

  @SYMTestCaseID GRAPHICS-WSERV-0280

  @SYMDEF             DEF081259

  @SYMPREQ 915

  @SYMTestCaseDesc Initial Configuration. All windows are in EColor64K display mode.

  @SYMTestPriority High

  @SYMTestStatus Implemented

  @SYMTestActions Several windows are set to be transparent alpha channel, and given semi-transparent or transparent background colours

  @SYMTestExpectedResults The transparent window configuration matches a reference drawing created using only alpha blending

*/

	//Test 3 to 6 can't be run without transparency support

	case 3:

		((CTAlphaWinStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0280"));

		ConfigureDisplayModes(EColor64K);

		if(TransparencySupportedL()==KErrNone)

			{

			_LIT(KInitialConfiguration64K,"(3) Initial configuration Color64K");

			iTest->LogSubTest(KInitialConfiguration64K);

			TestInitialConfiguration();

			}

		break;

/**

  @SYMTestCaseID GRAPHICS-WSERV-0281

  @SYMDEF             DEF081259

  @SYMPREQ 915

  @SYMTestCaseDesc Move. All windows are in EColor64K display mode.

  @SYMTestPriority High

  @SYMTestStatus Implemented

  @SYMTestActions Transparent alpha channel windows are moved both in front and behind one another

  @SYMTestExpectedResults The windows are redrawn correctly, as compared to a reference drawing

*/

	case 4:

		((CTAlphaWinStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0281"));

		if(TransparencySupportedL()==KErrNone)

			{

			_LIT(KMove64K,"(4) Move Color64K");

			iTest->LogSubTest(KMove64K);

			TestMove();

			}

		break;