--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/windowing/windowserver/tauto/TAlphaChannel.CPP	Tue Feb 02 01:47:50 2010 +0200
@@ -0,0 +1,1936 @@
+// 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:
+// An alpha channel test case. 
+// Output different graphics primitives in each window using three graphics modes
+// for pen and brush : semi-transparent,transparent, opaque
+// Test also exercises anti-aliasing and fading for 16MA display mode
+// Moves sprite on the window. Tests a sprite functionality.
+// Creates RBackedUpWindow window and moves it over transparent window,
+// hides and shows it.
+// Moves windows on the screen, overlaps them
+// Actions:
+// Create a background window, and five foreground windows:
+// -transparent and semi-transparent 
+// -transparent with transparency factor
+// -not transparent
+// 
+//
+
+#include "TAlphaChannel.H"
+
+const TInt KWindowIndention = 2;
+const TInt KSizeKoeff = 15;
+
+
+LOCAL_D TPtrC ColumnName[]={
+	_L("Opaque"),
+	_L("Semi-transparent"),
+	_L("Transparent"),
+	_L(""),
+	_L(""),
+	_L(""),
+	};
+
+LOCAL_D TPtrC RowName[]={
+	_L("n"),
+	_L("and"),
+	_L("or"),
+	_L("xor"),
+	_L(""),
+	_L(""),
+	};
+
+
+//
+//
+CTAlphaChannel::CTAlphaChannel(CTestStep* aStep):
+	CTWsGraphicsBase(aStep), iArrWindow(8)
+	{
+	}
+
+CTAlphaChannel::~CTAlphaChannel()
+	{
+	delete iBitmap64K_1;
+	delete iBitmap16MA_1;
+	delete iBitmap64K_2;
+	delete iBitmap16MA_2;
+	delete iBitmap64K_3;
+	delete iBitmap16MA_3;
+
+	delete iBitmapMask;
+	delete iBitmapGray256Mask;
+	
+	delete iBitmapContext64K_1;
+	delete iBitmapContext16MA_1;
+	delete iBitmapContext64K_2;
+	delete iBitmapContext16MA_2;
+	delete iBitmapContext64K_3;
+	delete iBitmapContext16MA_3;
+
+	delete iBitmapDevice64K_1;
+	delete iBitmapDevice16MA_1;
+	delete iBitmapDevice64K_2;
+	delete iBitmapDevice16MA_2;
+	delete iBitmapDevice64K_3;
+	delete iBitmapDevice16MA_3;
+
+	delete iBackgroundWindow;
+	
+	
+	iArrWindow.ResetAndDestroy();
+	
+	if(iFont)
+		TheClient->iScreen->ReleaseFont(iFont);
+	if(iFont1)
+		TheClient->iScreen->ReleaseFont(iFont1);
+	
+	BaseWin->SetVisible(ETrue);
+	TestWin->SetVisible(ETrue);
+	}
+
+void CTAlphaChannel::ConstructL()
+	{
+	const TInt KIndent = 10;
+	BaseWin->SetVisible(EFalse);
+	TestWin->SetVisible(EFalse);
+
+	iText = _L("This is a text");
+	iBrushStyle = CGraphicsContext::ESolidBrush;
+	iPenTable = KRgbBlack;
+
+	TSize screenSize=TheClient->iGroup->Size();
+	TInt winWidth=(screenSize.iWidth)-KIndent;
+	TInt winHeight=screenSize.iHeight-KIndent;
+	TDisplayMode dispMode = EColor64K;
+	
+	//background opaque window
+	iBackgroundWindow = new (ELeave) CTWinAlpha();
+	iBackgroundWindow->SetUpL(TPoint(5,5),TSize(winWidth,winHeight),TheClient->iGroup,*TheClient->iGc, &dispMode);
+	RWindow *theWin = (RWindow*) (iBackgroundWindow->DrawableWin());
+	theWin->SetBackgroundColor(TRgb(255, 0, 0));
+	iBackgroundWindow->DrawNow();
+
+	iSizeForegroundWindow.iWidth = (winWidth - KWindowIndention * 4) / 5 ;
+	iSizeForegroundWindow.iHeight = winHeight;
+	
+	CalculateSizePrimitives(iSizeForegroundWindow);
+
+	//-------------create bitmaps
+	//create 64K bitmap
+	iBitmap64K_1 = new (ELeave) CFbsBitmap ;
+	iBitmap64K_1->Create(iBitmapSize,EColor64K);
+	iBitmap64K_2 = new (ELeave) CFbsBitmap ;
+	iBitmap64K_2->Create(iBitmapSize,EColor64K);
+	iBitmap64K_3 = new (ELeave) CFbsBitmap ;
+	iBitmap64K_3->Create(iBitmapSize,EColor64K);
+	iBitmapDevice64K_1 = CFbsBitmapDevice::NewL(iBitmap64K_1);
+	iBitmapDevice64K_1->CreateContext(iBitmapContext64K_1);
+	iBitmapDevice64K_2 = CFbsBitmapDevice::NewL(iBitmap64K_2);
+	iBitmapDevice64K_2->CreateContext(iBitmapContext64K_2);
+	iBitmapDevice64K_3 = CFbsBitmapDevice::NewL(iBitmap64K_3);
+	iBitmapDevice64K_3->CreateContext(iBitmapContext64K_3);
+	
+	//create 16MA bitmap
+	iBitmap16MA_1 = new (ELeave) CFbsBitmap ;
+	iBitmap16MA_1->Create(iBitmapSize, EColor16MA);
+	iBitmap16MA_2 = new (ELeave) CFbsBitmap ;
+	iBitmap16MA_2->Create(iBitmapSize, EColor16MA);
+	iBitmap16MA_3 = new (ELeave) CFbsBitmap ;
+	iBitmap16MA_3->Create(iBitmapSize, EColor16MA);
+
+	iBitmapDevice16MA_1 = CFbsBitmapDevice::NewL(iBitmap16MA_1);
+	iBitmapDevice16MA_1->CreateContext(iBitmapContext16MA_1);
+	iBitmapDevice16MA_2 = CFbsBitmapDevice::NewL(iBitmap16MA_2);
+	iBitmapDevice16MA_2->CreateContext(iBitmapContext16MA_2);
+	iBitmapDevice16MA_3 = CFbsBitmapDevice::NewL(iBitmap16MA_3);
+	iBitmapDevice16MA_3->CreateContext(iBitmapContext16MA_3);
+
+	//create mask bitmap
+	iBitmapMask = new (ELeave) CFbsBitmap ;
+	iBitmapMask->Create(iBitmapSize, EGray2);
+	
+	CFbsBitmapDevice* theBitmapDevice = CFbsBitmapDevice::NewL(iBitmapMask);
+	CGraphicsContext*  theBitmapContext = NULL;
+	theBitmapDevice->CreateContext(theBitmapContext);
+	TRect rect = TRect(iBitmapMask->SizeInPixels());
+	theBitmapContext->SetBrushColor(KRgbWhite);
+   	theBitmapContext->SetPenColor(KRgbWhite);
+   	theBitmapContext->SetBrushStyle(CGraphicsContext::ESolidBrush);
+	theBitmapContext->DrawRect(rect);
+
+	rect.Shrink(4, 4);
+	theBitmapContext->SetBrushColor(KRgbBlack);
+	theBitmapContext->SetPenColor(KRgbBlack);
+	theBitmapContext->DrawEllipse(rect);
+	delete theBitmapContext;
+	delete theBitmapDevice;
+	
+	//create 256gray bitmap mask
+	iBitmapGray256Mask = new (ELeave) CFbsBitmap;
+	iBitmapGray256Mask->Create(iBitmapSize, EGray256);
+	theBitmapDevice = CFbsBitmapDevice::NewL(iBitmapGray256Mask);
+	theBitmapDevice->CreateContext(theBitmapContext);
+	
+	if(iBitmapSize != TSize(0, 0))
+		{
+	//fill bitmap with 256 gradation of gray
+		TInt theStep = 256 / iBitmapGray256Mask->SizeInPixels().iWidth;
+	
+		for(TInt ii = 0; ii < iBitmapGray256Mask->SizeInPixels().iWidth; ii++)
+			{
+			TInt theSingleCol = theStep * ii; 
+			TRgb theCol(theSingleCol, theSingleCol, theSingleCol);
+			theBitmapContext->SetBrushColor(theCol);
+			theBitmapContext->SetPenColor(theCol);
+			TPoint ptFrom(ii, 0);
+			TPoint ptTo(ii, iBitmapGray256Mask->SizeInPixels().iHeight);
+			theBitmapContext->DrawLine(ptFrom, ptTo);
+			}
+		}
+	delete theBitmapContext;
+	delete theBitmapDevice;
+	//--------------
+	TFontSpec fontSpec(KTestFontTypefaceName,600);
+
+	fontSpec.iFontStyle.SetStrokeWeight(EStrokeWeightBold);
+	fontSpec.iFontStyle.SetBitmapType(EAntiAliasedGlyphBitmap);
+	
+	User::LeaveIfError(TheClient->iScreen->GetNearestFontToDesignHeightInTwips(iFont, fontSpec));
+	
+	TFontSpec fontSpec1(KTestFontTypefaceName,100);
+	User::LeaveIfError(TheClient->iScreen->GetNearestFontToDesignHeightInTwips(iFont1, fontSpec1));
+	}
+
+void CTAlphaChannel::CalculateSizePrimitives(const TSize& aSize)
+	{
+	TInt theLen = aSize.iWidth / KSizeKoeff;
+	
+	iBitmapSize = TSize(2 * theLen, 2 * theLen);
+	iRectangleSize = TSize(2 * theLen, 2 * theLen);
+	iEllipseSize = TSize(4 * theLen, 2 * theLen);
+	iTriangleSize = TSize(3 * theLen, 2 * theLen);
+	iFirstCellWidth = static_cast <TInt> (1.2 * theLen);
+	iFirstCellHeight = static_cast <TInt> (1.5 * theLen);
+	}
+
+void CTAlphaChannel::DrawOffscreenBitmapsL(const TRgb& /*aPen*/, const TRgb& aBrush,
+										CGraphicsContext* aBitmapContext64K, CGraphicsContext* aBitmapContext16MA, 
+										CFbsBitmap* aBitmap64K, CFbsBitmap* aBitmap16MA)
+	{
+
+	if(aBitmapContext64K && aBitmap64K)
+		{
+		SEpocBitmapHeader header = aBitmap64K->Header();
+		TInt source_buffer_size = header.iBitmapSize / header.iSizeInPixels.iHeight * header.iBitsPerPixel ;
+		TUint8* buffer = new(ELeave) TUint8[source_buffer_size];
+		TPtr8 source_ptr(buffer, source_buffer_size, source_buffer_size);
+		
+		TUint16* bufferCur = reinterpret_cast<TUint16*> (buffer);
+		TInt ii;
+		for(ii = 0; ii < header.iSizeInPixels.iWidth; ++ii)
+			{
+			*bufferCur = aBrush._Color64K();
+			bufferCur ++;
+			}
+	
+		for(ii = 0; ii < header.iSizeInPixels.iHeight; ++ii)
+			{
+			aBitmap64K -> SetScanLine(source_ptr, ii);
+			}
+		
+		delete [] buffer;
+		}
+		
+	if(aBitmapContext16MA && aBitmap16MA)
+		{
+		SEpocBitmapHeader header = aBitmap16MA -> Header();
+		TInt source_buffer_size = header.iBitmapSize / header.iSizeInPixels.iHeight * header.iBitsPerPixel ;
+		TUint8* buffer = new(ELeave) TUint8[source_buffer_size];
+		TPtr8 source_ptr(buffer, source_buffer_size, source_buffer_size);
+		
+		TUint32* bufferCur = reinterpret_cast<TUint32*> (buffer);
+		TInt ii;
+		for(ii = 0; ii < header.iSizeInPixels.iWidth; ++ii)
+			{
+			*bufferCur = aBrush._Color16MA();
+			bufferCur ++;
+			}
+	
+		for(ii = 0; ii < header.iSizeInPixels.iHeight; ++ii)
+			{
+			aBitmap16MA -> SetScanLine(source_ptr, ii);
+			}
+		
+		delete [] buffer;
+		}
+	
+	}
+
+enum {EOpaque, ESemiTrans, ETrans};
+
+TRgb CTAlphaChannel::GetBrush(TInt aIndex) const
+	{
+	switch(aIndex)
+		{
+			case EOpaque:
+			return TRgb(0, 0, 255, 255);
+			case ESemiTrans:
+			return TRgb(0, 0, 255, 128);
+			case ETrans:
+			return TRgb(0, 0, 255, 0);
+			default : break;
+		}
+		
+	return 	TRgb(0, 0, 255, 255);
+	}
+
+TRgb CTAlphaChannel::GetPen(TInt aIndex) const
+	{
+	switch(aIndex)
+		{
+			case EOpaque:
+			return TRgb(0, 0, 255, 255);
+			case ESemiTrans:
+			return TRgb(0, 0, 255, 128);
+			case ETrans:
+			return TRgb(0, 0, 255, 0);
+			default : break;
+		}
+		
+	return 	TRgb(0, 0, 255, 255);
+	}
+   
+CGraphicsContext::TDrawMode CTAlphaChannel::GetDrawMode(TInt /*aIndex*/) const
+	{
+	return CGraphicsContext::EDrawModePEN;
+	}
+
+enum {EAll64K, EAll16MA, EAllDifferent};// later may add EAll16M
+void CTAlphaChannel::SetDisplayModeConfiguration(TInt aConfig)
+	{
+	switch (aConfig)
+		{
+	case EAll64K:
+		if(iForegroundWindowOpaque)
+			iForegroundWindowOpaque->SetDisplayMode(EColor64K);
+		if(iForegroundWindowSemiTrans)
+			iForegroundWindowSemiTrans->SetDisplayMode(EColor64K);
+		if(iForegroundWindowTrans)
+			iForegroundWindowTrans->SetDisplayMode(EColor64K);
+		break;
+	case EAll16MA:
+		if(iForegroundWindowOpaque)
+			iForegroundWindowOpaque->SetDisplayMode(EColor16MA);
+		if(iForegroundWindowSemiTrans)
+			iForegroundWindowSemiTrans->SetDisplayMode(EColor16MA);
+		if(iForegroundWindowTrans)
+			iForegroundWindowTrans->SetDisplayMode(EColor16MA);
+		break;
+	case EAllDifferent:
+		if(iForegroundWindowOpaque)
+			iForegroundWindowOpaque->SetDisplayMode(EColor256);
+		if(iForegroundWindowSemiTrans)
+			iForegroundWindowSemiTrans->SetDisplayMode(EColor64K);
+		if(iForegroundWindowTrans)
+			iForegroundWindowTrans->SetDisplayMode(EColor16MA);
+		break;
+		}
+	}
+
+enum {ETiled, EOverlapping};
+
+void CTAlphaChannel::SetPositionConfiguration(TInt aConfig)
+	{
+	TSize screenSize=TheClient->iGroup->Size();
+	TInt winWidth=(screenSize.iWidth)-10;
+	TInt winHeight=screenSize.iHeight-10;
+	if (aConfig==ETiled)
+		{
+		if(iForegroundWindowOpaque)
+			iForegroundWindowOpaque->SetPos(TPoint(winWidth/5, 0));
+		if(iForegroundWindowSemiTrans)
+			iForegroundWindowSemiTrans->SetPos(TPoint(2*winWidth/5, 0));
+		if(iForegroundWindowTrans)
+			iForegroundWindowTrans->SetPos(TPoint(3*winWidth/5, 0));
+		}
+	else
+		{
+		if(iForegroundWindowOpaque)
+			iForegroundWindowOpaque->SetPos(TPoint(winWidth/3, -winHeight/3));
+		if(iForegroundWindowSemiTrans)
+			iForegroundWindowSemiTrans->SetPos(TPoint(2*winWidth/5, winHeight/3));
+		if(iForegroundWindowTrans)
+			iForegroundWindowTrans->SetPos(TPoint(winWidth/2, -winHeight/3));
+		}
+	if (iForegroundWindowBottom)
+		iForegroundWindowBottom->SetPos(TPoint(0, 0));
+	if (iForegroundWindowTop)
+		iForegroundWindowTop->SetPos(TPoint(4*winWidth/5, 0));
+	}
+
+enum {EVaryingTransparency, EVaryingColour};
+
+void CTAlphaChannel::SetColourConfiguration(TInt aConfig)
+	{
+	RWindow* win;
+	if (aConfig==EVaryingTransparency)
+		{
+		// red background, green foregrounds of varying transparency
+		win = (RWindow*)(iBackgroundWindow->DrawableWin());
+		win->SetBackgroundColor(TRgb(255,0,0,255));
+
+		if(iForegroundWindowOpaque)
+			iForegroundWindowOpaque->SetBackgroundColor(TRgb(0,255,0,255));
+		if(iForegroundWindowSemiTrans)
+			iForegroundWindowSemiTrans->SetBackgroundColor(TRgb(0,255,0,128));
+		if(iForegroundWindowTrans)
+			iForegroundWindowTrans->SetBackgroundColor(TRgb(0,255,0,0));
+		}
+	else
+		{
+		// white background, semi-transparent foregrounds in primary colours
+		win = (RWindow*)(iBackgroundWindow->DrawableWin());
+		win->SetBackgroundColor(TRgb(255,255,255,255));
+
+		if(iForegroundWindowOpaque)
+			iForegroundWindowOpaque->SetBackgroundColor(TRgb(255,0,0,128));
+		if(iForegroundWindowSemiTrans)
+			iForegroundWindowSemiTrans->SetBackgroundColor(TRgb(0,255,0,128));
+		if(iForegroundWindowTrans)
+			iForegroundWindowTrans->SetBackgroundColor(TRgb(0,0,255,128));
+		}
+	}
+
+void CTAlphaChannel::DoMoving()
+	{
+	TPoint pos;
+	for (TInt i = 0; i<20; i++)
+		{
+		if (iForegroundWindowBottom)
+			{
+			pos = iForegroundWindowBottom->Position();
+			pos += TPoint(1,5);
+			iForegroundWindowBottom->SetPos(pos);
+			}
+
+		if (iForegroundWindowOpaque)
+			{
+			pos = iForegroundWindowOpaque->Position();
+			pos += TPoint(1,5);
+			iForegroundWindowOpaque->SetPos(pos);
+			}
+
+		if (iForegroundWindowSemiTrans)
+			{
+			pos = iForegroundWindowSemiTrans->Position();
+			pos += TPoint(1,5);
+			iForegroundWindowSemiTrans->SetPos(pos);
+			}
+
+		if (iForegroundWindowTrans)
+			{
+			pos = iForegroundWindowTrans->Position();
+			pos += TPoint(1,5);
+			iForegroundWindowTrans->SetPos(pos);
+			}
+
+		if (iForegroundWindowTop)
+			{
+			pos = iForegroundWindowTop->Position();
+			pos += TPoint(1,5);
+			iForegroundWindowTop->SetPos(pos);
+			}
+
+		TheClient->iWs.Flush();	
+		User::After(TTimeIntervalMicroSeconds32(50000));
+		}
+
+	}
+
+void CTAlphaChannel::DoMoveBehind()
+	{
+	TPoint pos = iBackgroundWindow->Position();
+	for (TInt i = 0; i<20; i++)
+		{
+		pos += TPoint(0,5);
+		iBackgroundWindow->SetPos(pos);
+
+		TheClient->iWs.Flush();	
+		User::After(TTimeIntervalMicroSeconds32(50000));
+		}
+	iBackgroundWindow->SetPos(TPoint(5,5));
+	}
+
+void CTAlphaChannel::DoInvisibility()
+	{
+	RWindow* win;
+	if (iForegroundWindowBottom)
+		{
+		win = (RWindow*)(iForegroundWindowBottom->DrawableWin());
+		win->SetVisible(EFalse);
+		TheClient->iWs.Flush();	
+		User::After(TTimeIntervalMicroSeconds32(1000000));
+
+		win->SetVisible(ETrue);
+		TheClient->iWs.Flush();	
+		User::After(TTimeIntervalMicroSeconds32(1000000));
+		}
+	if (iForegroundWindowOpaque)
+		{
+		win = (RWindow*)(iForegroundWindowOpaque->DrawableWin());
+		win->SetVisible(EFalse);
+		TheClient->iWs.Flush();	
+		User::After(TTimeIntervalMicroSeconds32(1000000));
+
+		win->SetVisible(ETrue);
+		TheClient->iWs.Flush();	
+		User::After(TTimeIntervalMicroSeconds32(1000000));
+		}
+	if (iForegroundWindowSemiTrans)
+		{
+		win = (RWindow*)(iForegroundWindowSemiTrans->DrawableWin());
+		win->SetVisible(EFalse);
+		TheClient->iWs.Flush();	
+		User::After(TTimeIntervalMicroSeconds32(1000000));
+
+		win->SetVisible(ETrue);
+		TheClient->iWs.Flush();	
+		User::After(TTimeIntervalMicroSeconds32(1000000));
+		}
+	if (iForegroundWindowTrans)
+		{
+		win = (RWindow*)(iForegroundWindowTrans->DrawableWin());
+		win->SetVisible(EFalse);
+		TheClient->iWs.Flush();	
+		User::After(TTimeIntervalMicroSeconds32(1000000));
+
+		win->SetVisible(ETrue);
+		TheClient->iWs.Flush();	
+		User::After(TTimeIntervalMicroSeconds32(1000000));
+		}
+	if (iForegroundWindowTop)
+		{
+		win = (RWindow*)(iForegroundWindowTop->DrawableWin());
+		win->SetVisible(EFalse);
+		TheClient->iWs.Flush();	
+		User::After(TTimeIntervalMicroSeconds32(1000000));
+
+		win->SetVisible(ETrue);
+		TheClient->iWs.Flush();	
+		User::After(TTimeIntervalMicroSeconds32(1000000));
+		}
+	}
+
+/** 
+	@SYMTestCaseID	GRAPHICS-WSERV-0328
+  	
+  	@SYMTestCaseDesc			Testing a Fading.
+  	
+  	@SYMTestPriority			High
+  	
+  	@SYMTestStatus      		Implemented
+  	
+  	@SYMTestActions		
+		 Set fading parameters. Draw all graphics primitives and bitmaps with 
+		 various transparency				.
+ 
+  	@SYMTestExpectedResults
+ 				All windows should be drawn according their fading values. 
+ */
+
+void CTAlphaChannel::TestFading()
+	{
+	iIsFading = ETrue;
+	iBlackFading = 0;
+	iWhiteFading = 128;
+	iText.Format(_L("Fading. %dX%d"), iBlackFading, iWhiteFading);
+	INFO_PRINTF1(iText);
+	DrawTestWindowsNow();
+
+	User::After(TTimeIntervalMicroSeconds32(1000000 * 1));
+	iIsFading = EFalse;
+	DrawTestWindowsNow();
+	iIsFading = ETrue;
+	iBlackFading = 128;
+	iWhiteFading = 255;
+	iText.Format(_L("Fading. %dX%d"), iBlackFading, iWhiteFading);
+	INFO_PRINTF1(iText);
+	DrawTestWindowsNow();
+
+	iIsFading = EFalse;
+	}
+	
+/** 
+	@SYMTestCaseID	GRAPHICS-WSERV-0329
+  	
+  	@SYMTestCaseDesc			Tests moving of foreground windows.
+  	
+  	@SYMTestPriority			High
+  	
+  	@SYMTestStatus      		Implemented
+  	
+  	@SYMTestActions		
+		 Set fading parameters. Set position of foreground windows as tile				.
+ 
+  	@SYMTestExpectedResults
+ 			Foreground window has to be redrawn properly.
+ */
+
+void CTAlphaChannel::TestMoving()
+	{
+	SetPositionConfiguration(ETiled);
+	DoMoving();
+	SetPositionConfiguration(ETiled);
+	}
+
+/** 
+	@SYMTestCaseID	GRAPHICS-WSERV-0330
+  	
+  	@SYMTestCaseDesc			Tests moving of foreground windows.
+  	
+  	@SYMTestPriority			High
+  	
+  	@SYMTestStatus      		Implemented
+  	
+  	@SYMTestActions		
+		 Set fading parameters. Moves foreground windows over the screen			.
+ 
+  	@SYMTestExpectedResults
+ 			Foreground window has to be redrawn properly.
+ */
+
+
+void CTAlphaChannel::TestMovingOverlapping()
+	{
+	TPoint pos;
+
+	for (TInt i = 0; i < 20; i++)
+		{
+		if (iForegroundWindowOpaque)
+			{
+			pos = iForegroundWindowOpaque->Position();
+			pos += TPoint(3,0);
+			iForegroundWindowOpaque->SetPos(pos);
+			}
+		if (iForegroundWindowTrans)
+			{
+			pos = iForegroundWindowTrans->Position();
+			pos -= TPoint(3,0);
+			iForegroundWindowTrans->SetPos(pos);
+			}
+		TheClient->iWs.Flush();	
+		User::After(TTimeIntervalMicroSeconds32(50000));
+		}
+	}
+
+/** 
+	@SYMTestCaseID	GRAPHICS-WSERV-0331
+  	
+  	@SYMTestCaseDesc			Testing transparency factor for windows with alpha channel.
+  	
+  	@SYMTestPriority			High
+  	
+  	@SYMTestStatus      		Implemented
+  	
+  	@SYMTestActions		
+		 Sets background colour with various level of transparency			.
+ 
+  	@SYMTestExpectedResults
+ 			Foreground window must be redrawn properly.
+ */
+void CTAlphaChannel::TestChangingTransparencyFactor()
+	{
+	TInt i = 0;
+	while (i <= 255)
+		{
+		iForegroundWindowOpaque->SetBackgroundColor(TRgb(0,255,0,255-i));
+		iForegroundWindowTrans->SetBackgroundColor(TRgb(0,255,0,i));
+		iForegroundWindowOpaque->DrawNow();
+		iForegroundWindowTrans->DrawNow();
+		i+=15;
+		}
+	i=0;
+	while (i <= 255)
+		{
+		iForegroundWindowOpaque->SetBackgroundColor(TRgb(0,255,0,i));
+		iForegroundWindowTrans->SetBackgroundColor(TRgb(0,255,0,255-i));
+		iForegroundWindowOpaque->DrawNow();
+		iForegroundWindowTrans->DrawNow();
+		User::After(TTimeIntervalMicroSeconds32(50000));// 20 frames per second
+		i+=15;
+		}
+	}
+
+/** 
+	@SYMTestCaseID	GRAPHICS-WSERV-0332
+  	
+  	@SYMTestCaseDesc			Testing redrawing of foreground windows while their positions and 
+  				invisibility have been changed.
+  	
+  	@SYMTestPriority			High
+  	
+  	@SYMTestStatus      		Implemented
+  	
+  	@SYMTestActions		
+		 Sets position of the foreground windows as overlapping, tiled.
+		Change visability of semi transparent foreground window.		.
+ 
+  	@SYMTestExpectedResults
+ 		Foreground window must be redrawn properly.
+ */
+
+void CTAlphaChannel::TestInvisibility()
+	{
+	RWindow* win = (RWindow*)(iForegroundWindowSemiTrans->DrawableWin());
+	SetPositionConfiguration(EOverlapping);
+	TheClient->iWs.Flush();	
+	User::After(TTimeIntervalMicroSeconds32(1000000));
+
+	win->SetVisible(EFalse);
+	TheClient->iWs.Flush();	
+	User::After(TTimeIntervalMicroSeconds32(1000000));
+
+	win->SetVisible(ETrue);
+	TheClient->iWs.Flush();	
+	User::After(TTimeIntervalMicroSeconds32(1000000));
+
+	SetPositionConfiguration(ETiled);
+
+	}
+
+/** 
+	@SYMTestCaseID	GRAPHICS-WSERV-0333
+  	
+  	@SYMTestCaseDesc			Testing redrawing of foreground windows after a 
+  				background window has been moved.
+  	
+  	@SYMTestPriority			High
+  	
+  	@SYMTestStatus      		Implemented
+  	
+  	@SYMTestActions		
+		 Sets position of the foreground windows as tiled.
+		Moves background window.
+ 
+  	@SYMTestExpectedResults
+ 		Foreground windows must be redrawn properly.
+ */
+void CTAlphaChannel::TestMoveUnderneath()
+	{
+	SetPositionConfiguration(ETiled);
+	DoMoveBehind();
+	}
+/** 
+	@SYMTestCaseID	GRAPHICS-WSERV-0334
+  	
+  	@SYMTestCaseDesc			Testing redrawing of foreground windows after a 
+  				background window has been moved.
+  	
+  	@SYMTestPriority			High
+  	
+  	@SYMTestStatus      		Implemented
+  	
+  	@SYMTestActions		
+		 Sets different position of the foreground windows: tiled, overlapping.
+		Moves background window.
+ 
+  	@SYMTestExpectedResults
+ 		Foreground windows has to be redrawn properly.
+ */
+
+void CTAlphaChannel::TestMoveBehindInvisible()
+	{
+	SetPositionConfiguration(ETiled);
+	RWindow* win;
+	win = (RWindow*)(iForegroundWindowOpaque->DrawableWin());
+	win->SetVisible(EFalse);
+	win = (RWindow*)(iForegroundWindowSemiTrans->DrawableWin());
+	win->SetVisible(EFalse);
+	win = (RWindow*)(iForegroundWindowTrans->DrawableWin());
+	win->SetVisible(EFalse);
+	TheClient->iWs.Flush();
+
+	DoMoveBehind();
+
+	SetPositionConfiguration(EOverlapping);
+	DoMoveBehind();
+
+	win = (RWindow*)(iForegroundWindowOpaque->DrawableWin());
+	win->SetVisible(ETrue);
+	win = (RWindow*)(iForegroundWindowSemiTrans->DrawableWin());
+	win->SetVisible(ETrue);
+	win = (RWindow*)(iForegroundWindowTrans->DrawableWin());
+	win->SetVisible(ETrue);
+	TheClient->iWs.Flush();
+	}
+/** 
+	@SYMTestCaseID	GRAPHICS-WSERV-0335
+  	
+  	@SYMTestCaseDesc			Testing redrawing of foreground windows.
+  	
+  	@SYMTestPriority			High
+  	
+  	@SYMTestStatus      		Implemented
+  	
+  	@SYMTestActions		
+		 Redraws background window
+ 
+  	@SYMTestExpectedResults
+ 		Foreground windows should be redrawn properly, if background window 
+  		 has been redrawn.
+ */
+void CTAlphaChannel::TestRedrawBehind()
+	{
+	TheClient->iWs.Flush();	
+	iBackgroundWindow->iState += 1;
+	iBackgroundWindow->DrawNow();
+	TheClient->iWs.Flush();	
+	User::After(TTimeIntervalMicroSeconds32(1000000));
+	}
+/** 
+	@SYMTestCaseID	GRAPHICS-WSERV-0336
+  	
+  	@SYMTestCaseDesc			Testing transparency with RWsSprite class.
+  	
+  	@SYMTestPriority			High
+  	
+  	@SYMTestStatus      		Implemented
+  	
+  	@SYMTestActions		
+		 Creates RBackedUpWindow window and moves it over transparent window
+		appears and dissapears set up window as transparent
+ 
+  	@SYMTestExpectedResults
+ 			Must work with transparent windows. 
+ */
+
+void CTAlphaChannel::TestAnimationL()
+	{
+	for(TInt ii = 0; ii < iArrWindow.Count(); ii++)
+		{
+		iArrWindow[ii]->StartAnimationL();
+		}
+	}
+/** 
+	@SYMTestCaseID	GRAPHICS-WSERV-0337
+  	
+  	@SYMTestCaseDesc			Testing transparency with RBackedUpWindow window class.
+  	
+  	@SYMTestPriority			High
+  	
+  	@SYMTestStatus      		Implemented
+  	
+  	@SYMTestActions		
+		 Creates RBackedUpWindow window and moves it over transparent window
+		appears and dissapears set up transparent window as transparent
+ 
+  	@SYMTestExpectedResults
+ 				Do not expect correct work of alpha channel with 
+ 				RBackedUpWindow window class. 
+*/
+void CTAlphaChannel::TestBackedWindowL()
+	{
+	for(TInt ii = 0; ii < iArrWindow.Count(); ii++)
+		{
+		iArrWindow[ii]->CreateBackedWindowL();
+		}
+	}
+
+/** 
+	@SYMTestCaseID	GRAPHICS-WSERV-0338
+  	
+  	@SYMTestCaseDesc			Implication of setting SetDrawOpaque on drawing with alpha channel.
+  	
+  	@SYMTestPriority			High
+  	
+  	@SYMTestStatus      		Implemented
+  	
+  	@SYMTestActions		
+		 Change graphic context to opaque and none opaque and rewdraw all test windows
+ 
+  	@SYMTestExpectedResults
+ 				must not impact on output with alpha channel 
+ */
+
+void CTAlphaChannel::TestEffectSetOpaque()
+	{
+	for(TInt ii = 0; ii < 3; ii++)
+		{
+		
+		for(TInt ii = 0; ii < iArrWindow.Count(); ii++)
+			{
+			iArrWindow[ii]->SetDrawOpaque(EFalse);
+			}
+	
+		DrawTestWindowsNow();
+		User::After(TTimeIntervalMicroSeconds32(1000000));
+
+		for(TInt jj = 0; jj < iArrWindow.Count(); jj++)
+			{
+			iArrWindow[jj]->SetDrawOpaque(ETrue);
+			}
+
+		DrawTestWindowsNow();
+		User::After(TTimeIntervalMicroSeconds32(1000000));
+		}
+	}
+
+/** 
+	@SYMTestCaseID	GRAPHICS-WSERV-0339
+  	
+  	@SYMTestCaseDesc			Redrawing of child windows with transparency.
+  	
+  	@SYMTestPriority			High
+  	
+  	@SYMTestStatus      		Implemented
+  	
+  	@SYMTestActions		
+		 	Creates a few child windows with various levels of transparency.
+		Moves parent window over the screen.
+  	@SYMTestExpectedResults
+ 				Child and parent windows must be redrawn properly 
+ */
+
+void CTAlphaChannel::TestChildWindowL()
+	{
+	SetPositionConfiguration(ETiled);
+	SetColourConfiguration(EVaryingColour);
+	DrawTestWindowsNow(ETrue);
+	TDisplayMode mode = EColor64K;
+	CTWinAlphaForeground* childWin[] = {NULL, NULL, NULL, NULL, NULL};
+	if (iForegroundWindowBottom)
+		{
+		childWin[0] = CTWinAlphaForeground::NewL(*this, TPoint(0,0),TSize(50,50),iForegroundWindowBottom,*TheClient->iGc, &mode, TRgb(0, 255, 0,128), ENonTransparentAlpha);
+		childWin[0]->DrawNow();
+		}
+	if (iForegroundWindowOpaque)
+		{
+		childWin[1] = CTWinAlphaForeground::NewL(*this, TPoint(0,0),TSize(50,50),iForegroundWindowOpaque,*TheClient->iGc, &mode, TRgb(0, 255, 0,128), ETransparencyFactor);
+		childWin[1]->DrawNow();
+		}
+	if (iForegroundWindowSemiTrans)
+		{
+		childWin[2] = CTWinAlphaForeground::NewL(*this, TPoint(0,0),TSize(50,50),iForegroundWindowSemiTrans,*TheClient->iGc, &mode, TRgb(0, 255, 0,128), ETransparencyAlpha);
+		childWin[2]->DrawNow();
+		}
+	if (iForegroundWindowTrans)
+		{
+		childWin[3] = CTWinAlphaForeground::NewL(*this, TPoint(0,0),TSize(50,50),iForegroundWindowTrans,*TheClient->iGc, &mode, TRgb(0, 255, 0,128), ENonTransparentAlpha);
+		childWin[3]->DrawNow();
+		}
+	if (iForegroundWindowTop)
+		{
+		childWin[4] = CTWinAlphaForeground::NewL(*this, TPoint(0,0),TSize(50,50),iForegroundWindowTop,*TheClient->iGc, &mode, TRgb(0, 255, 0,128), ENonTransparentAlpha);
+		childWin[4]->DrawNow();
+		}
+	TheClient->iWs.Flush();	
+
+	User::After(TTimeIntervalMicroSeconds32(1000000));
+	DoMoving();
+
+	delete childWin[0];
+	delete childWin[1];
+	delete childWin[2];
+	delete childWin[3];
+	delete childWin[4];
+	}
+/** 
+	@SYMTestCaseID	GRAPHICS-WSERV-0340
+  	
+  	@SYMTestCaseDesc			Redrawing of multiple child windows with transparency.
+  	
+  	@SYMTestPriority			High
+  	
+  	@SYMTestStatus      		Implemented
+  	
+  	@SYMTestActions		
+		 	Creates multiple child windows with various levels of transparency.
+		Moves parent windows over the screen.
+  	@SYMTestExpectedResults
+ 				Child and parent windows must be redrawn properly 
+ */
+
+void CTAlphaChannel::TestMultipleChildrenL()
+	{
+	SetPositionConfiguration(ETiled);
+	SetColourConfiguration(EVaryingColour);
+	TDisplayMode mode = EColor64K;
+	CTWinAlphaForeground* childWin[] = {NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL};
+	if (iForegroundWindowBottom)
+		{
+		childWin[0] = CTWinAlphaForeground::NewL(*this, TPoint(0,0),TSize(50,50),iForegroundWindowBottom,*TheClient->iGc, &mode, TRgb(255, 255, 255,128), ETransparencyFactor);
+		childWin[1] = CTWinAlphaForeground::NewL(*this, TPoint(20,20),TSize(50,50),childWin[0],*TheClient->iGc, &mode, TRgb(255, 255, 255,128), ENonTransparentAlpha);
+		childWin[0]->DrawNow();
+		childWin[1]->DrawNow();
+		}
+	if (iForegroundWindowOpaque)
+		{
+		childWin[4] = CTWinAlphaForeground::NewL(*this, TPoint(0,0),TSize(100,100),iForegroundWindowOpaque,*TheClient->iGc, &mode, TRgb(255, 255, 255,128), ETransparencyAlpha);
+		childWin[5] = CTWinAlphaForeground::NewL(*this, TPoint(20,80),TSize(50,50),iForegroundWindowOpaque,*TheClient->iGc, &mode, TRgb(255, 255, 255,128), ENonTransparentAlpha);
+		childWin[6] = CTWinAlphaForeground::NewL(*this, TPoint(20,20),TSize(60,60),childWin[4],*TheClient->iGc, &mode, TRgb(0, 255, 0,128), ENonTransparentAlpha);
+		childWin[7] = CTWinAlphaForeground::NewL(*this, TPoint(20,20),TSize(50,50),childWin[6],*TheClient->iGc, &mode, TRgb(0, 255, 0,128), ENonTransparentAlpha);
+		childWin[4]->DrawNow();
+		childWin[5]->DrawNow();
+		childWin[6]->DrawNow();
+		childWin[7]->DrawNow();
+		}
+	DrawTestWindowsNow(ETrue);
+
+	TestMoving();
+
+	delete childWin[0];
+	delete childWin[1];
+	delete childWin[2];
+	delete childWin[3];
+	delete childWin[4];
+	delete childWin[5];
+	delete childWin[6];
+	delete childWin[7];
+	}
+
+/** 
+	@SYMTestCaseID	GRAPHICS-WSERV-0341
+  	
+  	@SYMTestCaseDesc			Test transparent window which positioned under opaque.
+  	
+  	@SYMTestPriority			High
+  	
+  	@SYMTestStatus      		Implemented
+  	
+  	@SYMTestActions		
+		 	Creates an opaque window on the topt of transparent windows.
+		Moves transparent windows over the screen.
+  	@SYMTestExpectedResults
+ 				Transparent windows must be redrawn properly 
+ */
+
+void CTAlphaChannel::TestTransparentMovingUnderOpaqueL()
+	{
+	SetColourConfiguration(EVaryingColour);
+	TDisplayMode mode = EColor64K;
+	CTWinAlphaForeground* win = CTWinAlphaForeground::NewL(*this, TPoint(0,100),TSize(600,40),TheClient->iGroup,*TheClient->iGc, &mode, TRgb(0, 255, 0,128), ENonTransparentAlpha);
+	win->DrawNow();
+
+	TestMoving();
+
+	delete win;
+	}
+/** 
+	@SYMTestCaseID	GRAPHICS-WSERV-0342
+  	
+  	@SYMTestCaseDesc			Changing orinary position of the foreground windows.
+  	
+  	@SYMTestPriority			High
+  	
+  	@SYMTestStatus      		Implemented
+  	
+  	@SYMTestActions		
+		 	Set ordinal position of foreground windows.
+  	@SYMTestExpectedResults
+ 				Foreground windows must be redrawn properly 
+ */
+
+void CTAlphaChannel::TestSetOrdinalPosition()
+	{
+	SetColourConfiguration(EVaryingColour);
+	SetPositionConfiguration(EOverlapping);
+	DrawTestWindowsNow(ETrue);
+	TheClient->iWs.Flush();	
+	User::After(TTimeIntervalMicroSeconds32(1000000));
+	RWindow* win;
+	for (TInt i=0; i<3; i++)
+		{
+		if (iForegroundWindowOpaque)
+			{
+			win = (RWindow*)(iForegroundWindowOpaque->DrawableWin());
+			win->SetOrdinalPosition(0);
+			TheClient->iWs.Flush();	
+			User::After(TTimeIntervalMicroSeconds32(1000000));
+			}
+		if (iForegroundWindowSemiTrans)
+			{
+			win = (RWindow*)(iForegroundWindowSemiTrans->DrawableWin());
+			win->SetOrdinalPosition(0);
+			TheClient->iWs.Flush();	
+			User::After(TTimeIntervalMicroSeconds32(1000000));
+			}
+		if (iForegroundWindowTrans)
+			{
+			win = (RWindow*)(iForegroundWindowTrans->DrawableWin());
+			win->SetOrdinalPosition(0);
+			TheClient->iWs.Flush();	
+			User::After(TTimeIntervalMicroSeconds32(1000000));
+			}
+		}
+	}
+
+void CTAlphaChannel::RunTestCaseL(TInt aCurTestCase)
+	{
+	User::After(TTimeIntervalMicroSeconds32(1000000 * 2));
+	
+	((CTAlphaChannelStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);
+	switch (aCurTestCase)
+		{
+		case 1:
+			((CTAlphaChannelStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);
+			CreateForegroundWindowsL(iSizeForegroundWindow, EColor16MU);
+			break;
+		case 2:
+			{
+			CreateForegroundWindowsL(iSizeForegroundWindow, EColor64K);
+			((CTAlphaChannelStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0339"));
+			TestChildWindowL();
+			((CTAlphaChannelStep*)iStep)->RecordTestResultL();
+			((CTAlphaChannelStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0340"));
+			TestMultipleChildrenL();
+			((CTAlphaChannelStep*)iStep)->RecordTestResultL();
+			((CTAlphaChannelStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0342"));
+			TestSetOrdinalPosition();
+			}
+			break;
+		case 3: 
+			((CTAlphaChannelStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0336"));
+			TestAnimationL();
+		case 4: 
+			((CTAlphaChannelStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0337"));
+			TestBackedWindowL();
+			break;
+		case 5: 
+			((CTAlphaChannelStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0338"));
+			TestEffectSetOpaque();
+			break;
+		case 6:
+			((CTAlphaChannelStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);
+			iIsFading = EFalse;
+			DrawTestWindowsNow();
+			INFO_PRINTF1(_L("Anti-aliasing"));
+			iIsFading = EFalse;
+			iDrawText = ETrue;
+			DrawTestWindowsNow();
+			break;
+		case 7:	
+			SetColourConfiguration(EVaryingColour);
+			SetPositionConfiguration(EOverlapping);
+			((CTAlphaChannelStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0335"));
+			TestRedrawBehind();		
+			((CTAlphaChannelStep*)iStep)->RecordTestResultL();
+			((CTAlphaChannelStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0329"));
+			TestMoving();
+			((CTAlphaChannelStep*)iStep)->RecordTestResultL();
+			((CTAlphaChannelStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0330"));
+			TestMovingOverlapping();		
+			((CTAlphaChannelStep*)iStep)->RecordTestResultL();
+			((CTAlphaChannelStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0341"));
+			TestMoveBehindInvisible();
+			((CTAlphaChannelStep*)iStep)->RecordTestResultL();
+			((CTAlphaChannelStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0334"));
+			TestTransparentMovingUnderOpaqueL();
+			((CTAlphaChannelStep*)iStep)->RecordTestResultL();
+			((CTAlphaChannelStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0331"));
+			TestInvisibility();
+			((CTAlphaChannelStep*)iStep)->RecordTestResultL();
+			((CTAlphaChannelStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0332"));
+			TestChangingTransparencyFactor();
+			break;
+		case 8:
+			((CTAlphaChannelStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0328"));
+			TestFading();
+			break;
+		case 9:
+			{
+			((CTAlphaChannelStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);
+			iDrawText = EFalse;
+			SetDisplayModeConfiguration(EAll16MA);
+			}
+			break;
+		case 10:
+			((CTAlphaChannelStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);
+			iIsFading = EFalse;
+			DrawTestWindowsNow();
+			INFO_PRINTF1(_L("Anti-aliasing"));
+			iIsFading = EFalse;
+			iDrawText = ETrue;
+			DrawTestWindowsNow();
+			break;
+		case 11:
+			SetColourConfiguration(EVaryingColour);
+			SetPositionConfiguration(EOverlapping);
+			((CTAlphaChannelStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0333"));
+			TestMoveUnderneath();
+			((CTAlphaChannelStep*)iStep)->RecordTestResultL();
+			((CTAlphaChannelStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0335"));
+			TestRedrawBehind();
+			((CTAlphaChannelStep*)iStep)->RecordTestResultL();
+			((CTAlphaChannelStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0329"));
+			TestMoving();
+			((CTAlphaChannelStep*)iStep)->RecordTestResultL();
+			((CTAlphaChannelStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0332"));
+			TestInvisibility();
+			((CTAlphaChannelStep*)iStep)->RecordTestResultL();
+			((CTAlphaChannelStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0331"));
+			TestChangingTransparencyFactor();
+			break;
+		case 12:
+			((CTAlphaChannelStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0328"));
+			TestFading();
+			break;
+		case 13:
+			SetDisplayModeConfiguration(EAllDifferent);
+			SetColourConfiguration(EVaryingColour);
+			((CTAlphaChannelStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0333"));
+			TestMoveUnderneath();
+			((CTAlphaChannelStep*)iStep)->RecordTestResultL();
+			((CTAlphaChannelStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0335"));
+			TestRedrawBehind();
+			((CTAlphaChannelStep*)iStep)->RecordTestResultL();
+			((CTAlphaChannelStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0332"));
+			TestInvisibility();
+			((CTAlphaChannelStep*)iStep)->RecordTestResultL();
+			((CTAlphaChannelStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0329"));
+			TestMoving();
+			break;
+		case 14:
+			((CTAlphaChannelStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0336"));
+			TestAnimationL();
+			break;
+		case 15:
+			((CTAlphaChannelStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0337"));
+			TestBackedWindowL();
+			break;
+		case 16:
+			((CTAlphaChannelStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0338"));
+			TestEffectSetOpaque();
+			break;
+		case 17:
+			((CTAlphaChannelStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);
+			((CTAlphaChannelStep*)iStep)->CloseTMSGraphicsStep();
+			TestComplete();
+			break;
+		}
+	((CTAlphaChannelStep*)iStep)->RecordTestResultL();
+	}
+	
+/** Calculate foreground windows margin and create them*/
+void CTAlphaChannel::CreateForegroundWindowsL(const TSize& aSize, TDisplayMode aMode)
+	{
+	TPoint pt = TPoint(5, 5);
+	
+	//creating foreground windows
+	//bottom window
+	TDisplayMode dispMode = aMode;
+	iForegroundWindowBottom = CTWinAlphaForeground::NewL(*this, pt,aSize,TheClient->iGroup,*TheClient->iGc, &dispMode, TRgb(0, 255, 0,128), ETransparencyFactor);
+	iArrWindow.AppendL( iForegroundWindowBottom);
+
+	//dispMode = EColor16MA;
+	pt.iX += aSize.iWidth + KWindowIndention;
+	//opaque window
+	iForegroundWindowOpaque = CTWinAlphaForeground::NewL(*this, pt,aSize,TheClient->iGroup,*TheClient->iGc, &dispMode, TRgb(0, 255, 0, 255), ETransparencyAlpha);
+	iArrWindow.AppendL( iForegroundWindowOpaque);
+
+	pt.iX += aSize.iWidth + KWindowIndention;
+	//semi-transparent window
+	iForegroundWindowSemiTrans = CTWinAlphaForeground::NewL(*this, pt,aSize,TheClient->iGroup,*TheClient->iGc, &dispMode, TRgb(0, 255, 0, 128), ETransparencyAlpha);
+	iArrWindow.AppendL( iForegroundWindowSemiTrans);
+
+	//transparent window
+	pt.iX += aSize.iWidth + KWindowIndention;
+	iForegroundWindowTrans = CTWinAlphaForeground::NewL(*this, pt,aSize,TheClient->iGroup,*TheClient->iGc, &dispMode, TRgb(0, 255, 0, 0), ETransparencyAlpha);
+	iArrWindow.AppendL( iForegroundWindowTrans);
+
+	// top window
+	pt.iX += aSize.iWidth + KWindowIndention;
+	iForegroundWindowTop = CTWinAlphaForeground::NewL(*this, pt,aSize,TheClient->iGroup,*TheClient->iGc, &dispMode, TRgb(0, 255, 0,128), ENonTransparentAlpha);
+	iArrWindow.AppendL( iForegroundWindowTop);
+	}
+
+void CTAlphaChannel::DestroyForegroundWindows()
+	{
+	iArrWindow.ResetAndDestroy();
+	iForegroundWindowBottom = NULL;
+	iForegroundWindowOpaque = NULL;
+	iForegroundWindowSemiTrans = NULL;
+	iForegroundWindowTrans = NULL;
+	iForegroundWindowTop = NULL;
+	}
+
+/** Draw all foreground windows */
+void CTAlphaChannel::DrawTestWindowsNow(TBool aDrawBackgroundWin)
+	{
+	if(iBackgroundWindow && aDrawBackgroundWin)
+		{
+		iBackgroundWindow->DrawNow();
+		}
+
+	for(TInt ii = 0; ii < iArrWindow.Count(); ii++)
+		{
+		iArrWindow[ii]->DrawNow();
+		}
+	}
+	
+//-------------
+
+CTWinAlphaForeground* CTWinAlphaForeground::NewL(CTAlphaChannel& aTest, TPoint aPos, TSize aSize, CTWinBase *aParent, CWindowGc &aGc, TDisplayMode *aMode, TRgb aCol, TInt aTransparencyType)
+	{
+	CTWinAlphaForeground* theWin = new(ELeave) CTWinAlphaForeground(aTest);
+	
+	theWin->ConstructL(*aParent);
+	if (aMode)
+		theWin->SetDisplayMode(*aMode);
+	theWin->SetExtL(aPos, aSize);
+	theWin->AssignGC(aGc);
+	theWin->PrepareForDrawingL();	
+
+	// for hardware testing	only we create an additional bitmap
+#ifndef __WINS__
+	theWin->CreateBackgroundBitmapL(*aMode);
+#endif
+		
+	RWindow* win = (RWindow*) (theWin->DrawableWin());
+	win->SetShadowHeight(0);
+	win->SetShadowDisabled(ETrue);
+	switch (aTransparencyType)
+		{
+	case ETransparencyFactor:
+		{
+		win->SetTransparencyFactor(aCol);
+		theWin->SetBackgroundColor(aCol);
+		}
+		break;
+	case ETransparencyAlpha:
+		win->SetTransparencyAlphaChannel();
+		// fall through into next case
+	case ENonTransparentAlpha:
+	default:
+		theWin->SetBackgroundColor(aCol);
+		break;
+		}
+	
+	theWin->Activate();
+
+	return theWin;
+	}
+
+CTWinAlphaForeground::~CTWinAlphaForeground()
+	{
+	if(iPolygon)
+		{
+		iPolygon->Reset();
+		delete iPolygon;
+		}
+	delete iBitmapBackground;
+	delete iBitmapDeviceBackground;
+	delete iBitmapContextBackground;
+	}
+	
+CTWinAlphaForeground::CTWinAlphaForeground(CTAlphaChannel& aTest)
+	: iTest(aTest)
+	{	
+	}
+
+
+void CTWinAlphaForeground::SetDisplayMode(TDisplayMode aDisplayMode)
+	{
+	BaseWin()->SetRequiredDisplayMode(aDisplayMode);
+	switch (aDisplayMode)
+		{
+	case EColor256:
+		iTitle1 = _L("256");
+		break;
+	case EColor64K:
+		iTitle1 = _L("64K");
+		break;
+	case EColor16MU:
+		iTitle1 = _L("16MU");
+		break;
+	case EColor16MA:
+		iTitle1 = _L("16MA");
+		break;
+	case EColor16MAP:
+		iTitle1 = _L("16MAP");
+		break;
+	default:
+		iTitle1 = _L("");
+		break;
+		}
+	}
+
+void CTWinAlphaForeground::SetBackgroundColor(TRgb aRgb)
+	{
+	switch (aRgb.Alpha())
+		{
+		case 0:
+		iTitle2 = _L(" trans ");		
+		break;
+		case 255:
+		iTitle2 = _L(" opaque ");		
+		break;
+		case 128:
+		default:
+		iTitle2 = _L(" s-trans ");		
+		break;
+		}
+	if (aRgb.Red())
+		iTitle2 += _L("R");
+	if (aRgb.Green())
+		iTitle2 += _L("G");
+	if (aRgb.Blue())
+		iTitle2 += _L("B");
+
+	iBackgroundColor = aRgb;
+	((RWindow*) DrawableWin())->SetBackgroundColor(aRgb);
+	}
+
+void CTWinAlphaForeground::Draw()
+	{
+	CBitmapContext* theGc = TheClient->iGc;
+	((CWindowGc*)theGc)->SetOpaque(iDrawOpaque);
+	
+	if(iBitmapContextBackground)
+		{
+		//CGraphicsContext
+		theGc = iBitmapContextBackground;
+		CleanBackgroundBitmap();
+		}
+	if(iTest.iFont1)
+		theGc->UseFont(iTest.iFont1);
+	
+	
+	theGc->SetFaded(EFalse);
+	DrawTable(*theGc);
+
+	TInt numRows = sizeof(iRows) / sizeof(iRows[0]) ;
+
+	theGc->SetBrushStyle(iTest.iBrushStyle);
+	if(iTest.iFont && iTest.iDrawText)
+		{
+		theGc->DiscardFont();
+		theGc->UseFont(iTest.iFont);
+		}
+	
+	theGc->SetFaded(iTest.iIsFading);
+	
+	// the factor and offset are calculated as follows: 
+	// iFadeMapFactor = iWhiteFading - iBlackFading;
+	// iFadeMapOffset = iBlackFading;
+
+	theGc->SetFadingParameters(iTest.iBlackFading, iTest.iWhiteFading); //black and white
+		
+	for(TInt ii = 0; ii < numRows - 1; ii++)
+		{
+		theGc -> SetBrushStyle(iTest.iBrushStyle);
+
+		TRect theRect = TRect(iCol, iRows[ii], Size().iWidth, iRows[ii + 1]);
+				
+   		TRgb theBrush = iTest.GetBrush(ii);
+   		TRgb thePen = iTest.GetPen(ii);
+
+   		CGraphicsContext::TDrawMode theDrawMode = iTest.GetDrawMode(ii);
+    		
+   		theGc->SetBrushColor(theBrush);
+		theGc->SetPenColor(thePen);
+   		theGc->SetDrawMode(theDrawMode);
+		
+		CGraphicsContext* theBitmapContext64K;
+		CGraphicsContext* theBitmapContext16MA;
+		CFbsBitmap* theBitmap64K;
+		CFbsBitmap* theBitmap16MA;
+
+		switch(ii)
+			{
+			case 0:
+				{
+				theBitmapContext64K = iTest.iBitmapContext64K_1;
+				theBitmapContext16MA = iTest.iBitmapContext16MA_1;
+				theBitmap64K = iTest.iBitmap64K_1;
+				theBitmap16MA = iTest.iBitmap16MA_1;
+				break;
+				}
+			case 1:
+				{
+				theBitmapContext64K = iTest.iBitmapContext64K_2;
+				theBitmapContext16MA = iTest.iBitmapContext16MA_2;
+				theBitmap64K = iTest.iBitmap64K_2;
+				theBitmap16MA = iTest.iBitmap16MA_2;
+				break;
+				}
+			default:
+				{
+				theBitmapContext64K = iTest.iBitmapContext64K_3;
+				theBitmapContext16MA = iTest.iBitmapContext16MA_3;
+				theBitmap64K = iTest.iBitmap64K_3;
+				theBitmap16MA = iTest.iBitmap16MA_3;
+				break;
+				}
+			}
+			if(iTest.iDrawText)
+				{
+				DrawTextInCell(*theGc, theRect);
+				}
+			else
+				{
+				TRAP_IGNORE(iTest.DrawOffscreenBitmapsL(thePen, theBrush, theBitmapContext64K, 
+					theBitmapContext16MA, theBitmap64K, theBitmap16MA));
+				DrawPrimitivesInCell(*theGc, theRect, theBitmap64K, theBitmap16MA);
+				}
+		TheClient->iWs.Flush();	
+		}
+
+	theGc->DiscardFont();
+
+	if(iBitmapContextBackground)
+		{
+		theGc = TheClient->iGc;
+		theGc->BitBlt(TPoint(0, 0), iBitmapBackground);
+		}
+	}
+
+void CTWinAlphaForeground::SetPoligonLocation(const TPoint &ptOffset)
+	{
+	TRect rect = TRect(iTest.iTriangleSize);
+	(*iPolygon)[0] = rect.iTl + ptOffset;
+	(*iPolygon)[1] = TPoint(rect.iTl.iX, rect.iBr.iY) + ptOffset;
+	(*iPolygon)[2] = rect.iBr + ptOffset;
+	}
+	
+/** Define boundary of the table*/
+void CTWinAlphaForeground::CalculateTableMargin()
+	{
+	TInt numRows = sizeof(iRows) / sizeof(iRows[0]) ;
+	iRows[0] = iTest.iFirstCellHeight;
+	TInt theRowHeight = (Size().iHeight - iTest.iFirstCellHeight) / 3;
+	for(TInt ii = 1; ii < numRows; ii++)
+		{
+		iRows[ii] = iRows[ii-1] + theRowHeight;
+		}
+	}
+	
+/** Draw a table which comprises 3 rows: for transparent, semi-transparent 
+	and opaque output
+
+*/	
+void CTWinAlphaForeground::DrawTable(CBitmapContext& aGc) const
+	{
+	TInt numRows = sizeof(iRows) / sizeof(iRows[0]) ;
+	
+	aGc.SetPenColor(iTest.iPenTable);
+	
+	for (TInt ii = 0; ii < numRows - 1; ii++)
+		{
+		TBuf<4> iBuf;
+		TPoint pt1 = TPoint(0, iRows[ii]);
+		TPoint pt2 = TPoint(Size().iWidth, iRows[ii]);
+
+		aGc.DrawLine(pt1, pt2);
+		
+		if(iCol)
+			{
+			TPoint pt3 = TPoint(0, iRows[ii]) + TPoint(2,(iRows[1] - iRows[0]) / 2); 
+			switch(ii)
+				{
+					case 0: iBuf = _L("o"); break;
+					case 1: iBuf = _L("s"); break;
+					case 2: iBuf = _L("t"); break;
+					default : iBuf = _L(""); break;
+				}
+			aGc.DrawText(iBuf, pt3); 
+			}
+		}
+	if(iCol)
+		{
+		TPoint pt3 = TPoint(iCol, iRows[0]) + TPoint(1,-2); 
+		TBuf<32> text = iTitle1;
+		text += iTitle2;
+		aGc.DrawText(text, pt3); 
+	
+		TPoint pt1 = TPoint(iCol, 0);
+		TPoint pt2 = TPoint(iCol, Size().iHeight);
+		aGc.DrawLine(pt1, pt2);
+		}
+		
+	}
+
+/** Draw truetype font to check anti-aliasing*/
+void CTWinAlphaForeground::DrawTextInCell(CBitmapContext& aGc, const TRect& aRect)
+	{
+    TPoint pt(aRect.iTl.iX, aRect.iBr.iY);
+    pt += TPoint(2, -10);
+    
+    aGc.DrawText(_L("ABCD"), pt);
+	}
+
+/** Draw graphics primitive in a cell:
+	rectangle, ellipse, triangle, a few lines, bitmaps
+
+ */	
+void CTWinAlphaForeground::DrawPrimitivesInCell(CBitmapContext& aGc, const TRect& aRect, 
+								CFbsBitmap* aBitmap64K, CFbsBitmap* aBitmap16MA)
+	{
+	TRect theCellRect = aRect;
+	theCellRect.Shrink(1, 1);
+	
+	//rectangle
+	TRect rect = TRect(iTest.iRectangleSize);
+	rect.Move(theCellRect.iTl);
+    aGc.DrawRect(rect);
+    
+    //ellipse
+    rect = TRect(iTest.iEllipseSize);
+	rect.Move(theCellRect.iTl + TPoint(iTest.iRectangleSize.iWidth + 5, 0));
+    aGc.DrawEllipse(rect);
+
+	//triangle
+	TPoint pt = TPoint(rect.iBr.iX, rect.iTl.iY) + TPoint(5, 0);
+	SetPoligonLocation(pt);
+   	aGc.DrawPolygon(iPolygon);
+    
+    //DrawLine
+    pt = pt + TPoint (((*iPolygon)[2]).iX - ((*iPolygon)[0]).iX, 0) + TPoint(5, 2);
+    rect = TRect(iTest.iTriangleSize);
+    rect.Move(pt);
+    aGc.DrawLine(rect.iTl, TPoint(rect.iTl.iX, rect.iBr.iY));
+    aGc.DrawLine(TPoint(rect.iTl.iX, rect.iBr.iY), rect.iBr);
+    aGc.DrawLine(rect.iBr, TPoint(rect.iBr.iX, rect.iTl.iY));
+    aGc.DrawLine(TPoint(rect.iBr.iX, rect.iTl.iY), rect.iTl);
+    aGc.DrawLine(rect.iTl, rect.iBr);
+    aGc.DrawLine(TPoint(rect.iBr.iX, rect.iTl.iY), TPoint(rect.iTl.iX, rect.iBr.iY));
+
+    //64K bitmap
+    aGc.SetBrushStyle(CGraphicsContext::ENullBrush);
+    pt = TPoint(theCellRect.iTl.iX, rect.iBr.iY) + TPoint(0, 5);
+    if(aBitmap64K)
+    	{
+    	aGc.BitBlt(pt, aBitmap64K);
+    	pt = pt + TPoint( aBitmap64K->SizeInPixels().iWidth, 0) + TPoint(2, 0);
+
+    	aGc.BitBltMasked(pt, 
+    		aBitmap64K, TRect(aBitmap64K->SizeInPixels()),
+	    	iTest.iBitmapGray256Mask, EFalse);
+    	pt = pt + TPoint( aBitmap64K->SizeInPixels().iWidth, 0) + TPoint(2, 0);
+
+    	aGc.BitBltMasked(pt, 
+	    	aBitmap64K, TRect(aBitmap64K->SizeInPixels()),
+    		iTest.iBitmapMask, EFalse);
+
+    	pt = pt + TPoint( aBitmap64K->SizeInPixels().iWidth, 0) + TPoint(2, 0);
+	   	}
+    
+    if(aBitmap16MA)
+    	{
+    	aGc.BitBlt(pt, aBitmap16MA);
+
+    	pt = pt + TPoint( aBitmap16MA->SizeInPixels().iWidth, 0) + TPoint(2, 0);
+
+    	aGc.BitBltMasked(pt, 
+	    	aBitmap16MA, TRect(aBitmap16MA->SizeInPixels()),
+    		iTest.iBitmapGray256Mask, EFalse);
+
+    	pt = pt + TPoint( aBitmap16MA->SizeInPixels().iWidth, 0) + TPoint(2,0);
+
+    	pt = pt + TPoint( 0, aBitmap16MA->SizeInPixels().iHeight);
+    	}
+    
+	pt.iX = aRect.iTl.iX + 2;
+	pt.iY = pt.iY + 18;
+	
+    if(aBitmap64K)
+    	{
+		TSize size = aBitmap64K->SizeInPixels();
+		TRect srcRect(TPoint(0,0),size);
+		size += TSize(5,5);
+		TRect destRect(pt - TPoint(0, 8), size);
+    	aGc.DrawBitmap(destRect, aBitmap64K, srcRect);
+    	pt = pt + TPoint( size.iWidth, 0) + TPoint(2, 0);
+
+#ifdef __WINS__
+    	destRect.Move(TPoint(aBitmap64K->SizeInPixels().iWidth + 8, 0));
+    	((CWindowGc&) aGc).DrawBitmapMasked(destRect, 
+    		aBitmap64K, srcRect,
+	    	iTest.iBitmapGray256Mask, EFalse);
+    	pt = pt + TPoint( aBitmap64K->SizeInPixels().iWidth, 0) + TPoint(2, 0);
+#endif
+	   	}
+    
+    aGc.DrawText(iTest.iText, pt);
+    
+#ifdef __WINS__
+    ((CWindowGc&) aGc).DrawTextVertical(iTest.iText, pt, ETrue);
+#endif
+	}
+	
+/** calculate table's size and size of graphics primitieves */
+void CTWinAlphaForeground::PrepareForDrawingL()
+	{
+	iCol = iTest.iFirstCellWidth;
+
+	CalculateTableMargin();
+
+	//create triangle
+	iPolygon = new (ELeave) CArrayFixFlat<TPoint> (3);
+	TRect rect = TRect(iTest.iTriangleSize);
+	iPolygon->AppendL(rect.iTl);
+	iPolygon->AppendL(TPoint(rect.iTl.iX, rect.iBr.iY));
+	iPolygon->AppendL(rect.iBr);
+	}
+
+/** Bitmap is intended to use on target only*/	
+void CTWinAlphaForeground::CreateBackgroundBitmapL(const TDisplayMode& aDispMode)
+	{
+	ASSERT(!iBitmapBackground);
+	
+	TSize size = Size(); 
+		
+	iBitmapBackground = new (ELeave) CFbsBitmap ;
+	iBitmapBackground->Create(size,aDispMode);
+	
+	iBitmapDeviceBackground = CFbsBitmapDevice::NewL(iBitmapBackground);
+	CGraphicsContext *&theGc = (CGraphicsContext*&)iBitmapContextBackground;
+	iBitmapDeviceBackground->CreateContext(theGc);
+	}
+	
+void CTWinAlphaForeground::CleanBackgroundBitmap()
+	{
+	ASSERT(iBitmapBackground);
+	
+	TRect rect = TRect(iBitmapBackground->SizeInPixels());
+	iBitmapContextBackground->SetBrushColor(iBackgroundColor);
+   	iBitmapContextBackground->SetPenColor(iBackgroundColor);
+   	iBitmapContextBackground->SetBrushStyle(CGraphicsContext::ESolidBrush);
+	iBitmapContextBackground->DrawRect(rect);
+	}
+
+void CTWinAlphaForeground::StartAnimationL()
+	{
+	__UHEAP_MARK;
+	RWsSprite theSprite;
+	
+	RDrawableWindow *theWin = DrawableWin();
+
+	theSprite=RWsSprite(TheClient->iWs);
+	TPoint theSpritePos = TPoint(10, 10); 
+	TInt theFlags = 0;
+	theSprite.Construct(*theWin, theSpritePos, theFlags);
+	TDisplayMode dispMode = EColor256;
+	//create a ball bitmap for animation
+	CFbsBitmap* theBitmapBall= new (ELeave) CFbsBitmap;
+	theBitmapBall->Create(TSize(32, 32), dispMode);
+	CFbsBitmapDevice* theBitmapDeviceBall = CFbsBitmapDevice::NewL(theBitmapBall);
+	CGraphicsContext* theBitmapContextBall = NULL;
+	theBitmapDeviceBall->CreateContext(theBitmapContextBall);
+	//draw a background
+	theBitmapContextBall->SetBrushColor(TRgb(128, 0, 255));
+   	theBitmapContextBall->SetPenColor(TRgb(128, 0, 255));
+   	theBitmapContextBall->SetBrushStyle(CGraphicsContext::ESolidBrush);
+	theBitmapContextBall->DrawRect(theBitmapBall->SizeInPixels());
+	
+	//create a ball's mask
+	CFbsBitmap* theBitmapMask= new (ELeave) CFbsBitmap;
+	theBitmapMask->Create(TSize(32, 32), dispMode);
+	CFbsBitmapDevice* theBitmapDeviceMask = CFbsBitmapDevice::NewL(theBitmapMask);
+	CGraphicsContext* theBitmapContextMask = NULL;
+	theBitmapDeviceMask->CreateContext(theBitmapContextMask);
+	//draw a mask
+	theBitmapContextMask->SetBrushColor(TRgb(0, 0, 0));
+   	theBitmapContextMask->SetPenColor(TRgb(0, 0, 0));
+   	theBitmapContextMask->SetBrushStyle(CGraphicsContext::ESolidBrush);
+	theBitmapContextMask->DrawRect(theBitmapMask->SizeInPixels());
+
+	theBitmapContextMask->SetBrushColor(TRgb(255, 255, 255));
+   	theBitmapContextMask->SetPenColor(TRgb(255, 255, 255));
+   	TRect rect = TRect(theBitmapMask->SizeInPixels());
+	theBitmapContextMask->SetPenSize(TSize(6,6));
+	theBitmapContextMask->DrawLine(rect.iTl, rect.iBr);
+	theBitmapContextMask->DrawLine(TPoint(0, rect.iBr.iY), TPoint(rect.iBr.iX, 0));
+
+	//create a second ball's mask
+	CFbsBitmap* theBitmapMask1= new (ELeave) CFbsBitmap;
+	theBitmapMask1->Create(TSize(32, 32), dispMode);
+	CFbsBitmapDevice* theBitmapDeviceMask1 = CFbsBitmapDevice::NewL(theBitmapMask1);
+	CGraphicsContext* theBitmapContextMask1 = NULL;
+	theBitmapDeviceMask1->CreateContext(theBitmapContextMask1);
+	//draw a mask
+	theBitmapContextMask1->SetBrushColor(TRgb(0, 0, 0));
+   	theBitmapContextMask1->SetPenColor(TRgb(0, 0, 0));
+   	theBitmapContextMask1->SetBrushStyle(CGraphicsContext::ESolidBrush);
+	theBitmapContextMask1->DrawRect(theBitmapMask1->SizeInPixels());
+
+	theBitmapContextMask1->SetBrushColor(TRgb(255, 255, 255));
+   	theBitmapContextMask1->SetPenColor(TRgb(255, 255, 255));
+   	rect = TRect(theBitmapMask1->SizeInPixels());
+	theBitmapContextMask1->SetPenSize(TSize(6,6));
+	theBitmapContextMask1->DrawLine(TPoint(rect.iBr.iX/2, 0), TPoint(rect.iBr.iX/2, rect.iBr.iY));
+	theBitmapContextMask1->DrawLine(TPoint(0, rect.iBr.iY/2), TPoint(rect.iBr.iX, rect.iBr.iY/2));
+
+
+	TSpriteMember theSpriteList;
+	theSpriteList.iBitmap = theBitmapBall;
+	theSpriteList.iMaskBitmap = theBitmapMask;
+	theSpriteList.iInvertMask = EFalse;
+	theSpriteList.iDrawMode = CGraphicsContext::EDrawModePEN;
+	theSpriteList.iOffset = TPoint(0, 0);
+	theSpriteList.iInterval = TTimeIntervalMicroSeconds32(100000);
+	theSprite.AppendMember(theSpriteList);
+
+	TSpriteMember theSpriteList1;
+	theSpriteList1.iBitmap = theBitmapBall;
+	theSpriteList1.iMaskBitmap = theBitmapMask1;
+	theSpriteList1.iInvertMask = EFalse;
+	theSpriteList1.iDrawMode = CGraphicsContext::EDrawModePEN;
+	theSpriteList1.iOffset = TPoint(0, 0);
+	theSpriteList1.iInterval = TTimeIntervalMicroSeconds32(100000);
+	
+	theSprite.AppendMember(theSpriteList1);
+	
+	theSprite.Activate();
+	
+	for(TInt ii = 0; ii < 20; ii++)
+		{
+		theSpritePos += TPoint(3, 8);
+		theSprite.SetPosition(theSpritePos);
+		TheClient->iWs.Flush();	
+		User::After(TTimeIntervalMicroSeconds32(50000));		
+		}
+
+	for(TInt jj = 0; jj < 20; jj++)
+		{
+		theSpritePos -= TPoint(0, 8);
+		theSprite.SetPosition(theSpritePos);
+		TheClient->iWs.Flush();	
+		User::After(TTimeIntervalMicroSeconds32(50000));
+		}
+	
+	theSprite.Close();
+	
+	delete theBitmapContextBall;
+	delete theBitmapDeviceBall;
+	
+	delete theBitmapBall;
+	
+	delete theBitmapMask;
+	delete theBitmapContextMask;
+	delete theBitmapDeviceMask;
+	
+	delete theBitmapMask1;
+	delete theBitmapContextMask1;
+	delete theBitmapDeviceMask1;
+
+	__UHEAP_MARKEND;
+	}
+
+void CTWinAlphaForeground::CreateBackedWindowL()
+	{
+	RBackedUpWindow theBackedWindow(TheClient->iWs); 
+	CleanupClosePushL(theBackedWindow);
+	
+	TDisplayMode theDisplayMode = EColor16MA;
+	
+	RWindow* theWin = (RWindow*) DrawableWin();
+
+	theBackedWindow.Construct(*theWin,theDisplayMode, ENullWsHandle);
+	
+	TPoint pos =TPoint(10, 10);
+	TSize size = theWin->Size();
+	size.SetSize(size.iWidth / 5, size.iHeight/10);
+	
+	theBackedWindow.SetExtentErr(pos, size);
+	theBackedWindow.SetOrdinalPosition(0);
+
+	
+	//draw to backed window	
+	TRgb color = TRgb(255, 0, 128);
+	TInt bitmapHandle = theBackedWindow.BitmapHandle();
+	CFbsBitmap bitmapWin;
+	bitmapWin.Duplicate(bitmapHandle);
+	//Leave poss here - theBackedWindow could leak
+	CFbsBitmapDevice* theBitmapDevice = CFbsBitmapDevice::NewL(&bitmapWin);
+	CGraphicsContext* theBitmapContext = NULL;
+	theBitmapDevice->CreateContext(theBitmapContext);
+	theBitmapContext->SetBrushColor(color);
+   	theBitmapContext->SetPenColor(color);
+   	theBitmapContext->SetBrushStyle(CGraphicsContext::ESolidBrush);
+	theBitmapContext->DrawRect(TRect(bitmapWin.SizeInPixels()));
+
+	color = TRgb(0, 0, 0);
+   	theBitmapContext->SetPenColor(color);
+	for(TInt kk = 0; kk < bitmapWin.SizeInPixels().iWidth; kk += 8)
+		{
+		theBitmapContext->DrawLine(TPoint(kk, 0), TPoint(kk, bitmapWin.SizeInPixels().iHeight));
+		}
+	
+	
+	theBackedWindow.Activate();
+	TheClient->iWs.Flush();
+	User::After(TTimeIntervalMicroSeconds32(500000));
+	
+	//hide the window
+	theBackedWindow.SetVisible(EFalse);
+	TheClient->iWs.Flush();
+	User::After(TTimeIntervalMicroSeconds32(500000));
+	theBackedWindow.SetVisible(ETrue);
+	TheClient->iWs.Flush();
+	
+	for(TInt ii = 0; ii < 7; ii++)
+		{
+		User::After(TTimeIntervalMicroSeconds32(100000));
+		pos.iX += 5;
+		pos.iY += 15;
+		 
+		theBackedWindow.SetExtentErr(pos, size);
+		TheClient->iWs.Flush();
+		}
+
+	User::After(TTimeIntervalMicroSeconds32(500000));
+	
+	//transparent color. don't expect it to work
+	pos.iX -= 5;
+	pos.iY -= 15;
+
+	theBackedWindow.SetExtentErr(pos, size);
+	color = TRgb(255, 255, 128, 128);
+	theBitmapContext->SetBrushColor(color);
+   	theBitmapContext->SetPenColor(color);
+	theBitmapContext->DrawRect(TRect(bitmapWin.SizeInPixels()));
+	TheClient->iWs.Flush();
+	User::After(TTimeIntervalMicroSeconds32(500000));
+
+	//semi-transparent color
+	pos.iX -= 5;
+	pos.iY -= 15;
+	theBackedWindow.SetExtentErr(pos, size);
+	color = TRgb(255, 255, 128, 255);
+	theBitmapContext->SetBrushColor(color);
+   	theBitmapContext->SetPenColor(color);
+	TheClient->iWs.Flush();
+	User::After(TTimeIntervalMicroSeconds32(500000));
+
+	
+	CleanupStack::PopAndDestroy();	 //bitmapWin
+	delete theBitmapContext;
+	delete theBitmapDevice;
+	
+	}
+
+	
+//-------------------
+void CTWinAlpha::Draw()
+	{
+	CBitmapContext* theGc = TheClient->iGc;
+	TSize size = Size();
+	
+	for(TInt ii = 0; ii < size.iHeight; ii += (20+iState))
+		{
+		theGc->DrawLine(TPoint(0, ii), TPoint(size.iWidth, ii));
+		}
+	}
+	
+__WS_CONSTRUCT_STEP__(AlphaChannel)