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