// 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;
/**

  @SYMTestCaseID GRAPHICS-WSERV-0282

  @SYMDEF             DEF081259

  @SYMPREQ 915

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

  @SYMTestPriority High

  @SYMTestStatus Implemented

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

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

*/
	case 5:
		((CTAlphaWinStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0282"));
		if(TransparencySupportedL()==KErrNone)
			{
			_LIT(KRedraw64K,"(5) Redraw Color64K");
			iTest->LogSubTest(KRedraw64K);
			TestRedraw();
			}
		break;
/**

  @SYMTestCaseID GRAPHICS-WSERV-0283-0001

  @SYMDEF             DEF081259

  @SYMPREQ 915

  @SYMTestCaseDesc Invisible. All windows are in EColor64K 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 6:
		((CTAlphaWinStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0283-0001"));
		if(TransparencySupportedL()==KErrNone)
			{
			_LIT(KInvisible64K,"(6) Invisible Color64K");
			iTest->LogSubTest(KInvisible64K);
			TestInvisible();
			}
		break;
/**

  @SYMTestCaseID GRAPHICS-WSERV-0283-0002

  @SYMDEF             DEF081259

  @SYMPREQ 915

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

  @SYMTestPriority High

  @SYMTestStatus Implemented

  @SYMTestActions Transparent alpha channel windows are given child windows, both transparent and non-transparent,
 			    	and are then moved, redrawn, set visible or invisible both in front and behind one another

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

*/
	case 7:
		((CTAlphaWinStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0283-0002"));
		_LIT(KChildren64K,"(7)Children Color64K");
		iTest->LogSubTest(KChildren64K);
		TestChildrenL();
		break;
/**

  @SYMTestCaseID GRAPHICS-WSERV-0356

  @SYMDEF             DEF081259

  @SYMPREQ 915

  @SYMTestCaseDesc Initial Configuration. All windows are in EColor64k Dispaly Mode

  @SYMTestPriority High

  @SYMTestStatus Implemented

  @SYMTestActions Tests Anti-aliasing of text

  @SYMTestExpectedResults Anti-alisaing should behave correctly

*/
	case 8:
		((CTAlphaWinStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0356"));
		_LIT(KAntiAliasedText64K,"(8) AntiAliasedText DEF082251 Color64K");
		iTest->LogSubTest(KAntiAliasedText64K);
		TestAntiAliasedTextTransparentL();
		break;

/**

  @SYMTestCaseID GRAPHICS-WSERV-0284

  @SYMDEF             DEF081259

  @SYMPREQ 915

  @SYMTestCaseDesc Initial Configuration. All windows are in EColor16MA 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

*/
	case 9:
		{ 
		((CTAlphaWinStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0284"));
		ConfigureDisplayModes(EColor16MA);
		TDisplayMode mode1 = TheClient->iScreen->DisplayMode();
	 	_LIT(KInitialConfiguration16MA,"(9)Initial configuration Color16MA");
		iTest->LogSubTest(KInitialConfiguration16MA);
		TestInitialConfiguration();
		break;
		}
/**

  @SYMTestCaseID GRAPHICS-WSERV-0285

  @SYMDEF             DEF081259

  @SYMPREQ 915

  @SYMTestCaseDesc Move. All windows are in EColor16MA 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 10:
		((CTAlphaWinStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0285"));
		_LIT(KMove16MA,"(10)Move Color16MA");
		iTest->LogSubTest(KMove16MA);
		TestMove();
		break;
/**

  @SYMTestCaseID GRAPHICS-WSERV-0286

  @SYMDEF             DEF081259

  @SYMPREQ 915

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

  @SYMTestPriority High

  @SYMTestStatus Implemented

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

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

*/
	case 11:
		((CTAlphaWinStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0286"));
		_LIT(KRedraw16MA,"(11)Redraw Color16MA");
		iTest->LogSubTest(KRedraw16MA);
		TestRedraw();
		break;
		
/**

  @SYMTestCaseID GRAPHICS-WSERV-0279

  @SYMDEF             DEF081259

  @SYMPREQ 915

  @SYMTestCaseDesc Transparent drawing

  @SYMTestPriority High

  @SYMTestStatus Implemented

  @SYMTestActions Use draw operations with transparent pen or brush colours

  @SYMTestExpectedResults Draw operations with transparent pen or brush colours should leave the destination unchanged

*/

	case 12:
		((CTAlphaWinStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0279"));
		ConfigureDisplayModes(EColor64K);
		_LIT(KTrans64K,"(12) Transparent drawing Color64K");
		iTest->LogSubTest(KTrans64K);
		TestTransparentDrawingL();
		break;


/**

  @SYMTestCaseID GRAPHICS-WSERV-0288

  @SYMDEF             DEF081259

  @SYMPREQ 915

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

  @SYMTestPriority High

  @SYMTestStatus Implemented

  @SYMTestActions Transparent alpha channel windows are given child windows, both transparent and non-transparent,
 			    	and are then moved, redrawn, set visible or invisible both in front and behind one another

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

*/
	case 13:
		((CTAlphaWinStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0288"));
		_LIT(KChildren16MA,"(13) Children Color16MA");
		iTest->LogSubTest(KChildren16MA);
		TestChildrenL();
		break;
/**

  @SYMTestCaseID GRAPHICS-WSERV-0357

  @SYMDEF             DEF081259

  @SYMPREQ 915

  @SYMTestCaseDesc Initial Configuration. All windows are in EColor16MA Dispaly Mode

  @SYMTestPriority High

  @SYMTestStatus Implemented

  @SYMTestActions Tests Anti-aliasing of text

  @SYMTestExpectedResults Anti-alisaing should behave correctly

*/
	case 14:
		((CTAlphaWinStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0357"));
		_LIT(KAntiAliasedText16MA,"(14) AntiAliasedText DEF082251 Color16MA");
		iTest->LogSubTest(KAntiAliasedText16MA);
		TestAntiAliasedTextTransparentL();
		break;
	default:
		((CTAlphaWinStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);
		((CTAlphaWinStep*)iStep)->CloseTMSGraphicsStep();
		TestComplete();
		break;
		}
	((CTAlphaWinStep*)iStep)->RecordTestResultL();
	}

__WS_CONSTRUCT_STEP__(AlphaWin)