Symaptic: os/graphics/graphicsdeviceinterface/bitgdi/tbit/TAccelerator.cpp@bde4ae8d615e

     1 // Copyright (c) 2000-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    16 #include <graphicsaccelerator.h>

    17 #include "TAccelerator.h"

    18 #include <graphics/fbsdefs.h>

    20 class TAcceleratedBitmapSpecTest : public TAcceleratedBitmapSpec

    21 	{

    22 // Provides public access to TAcceleratedBitmapSpec

    23 public:

    24 	inline TAcceleratedBitmapSpecTest() : TAcceleratedBitmapSpec() {}

    25 	inline TAcceleratedBitmapSpecTest(CFbsBitmap* aBitmap) : TAcceleratedBitmapSpec(aBitmap) {}

    26 	inline TAcceleratedBitmapSpecTest(RHardwareBitmap aBitmap) : TAcceleratedBitmapSpec(aBitmap) {}

    27 	//

    28 	inline TInt GetInfo(TAcceleratedBitmapInfo& aInfo) const { return TAcceleratedBitmapSpec::GetInfo(aInfo); }

    29 	inline void Lock(TBitmapLockCount& aCount) { TAcceleratedBitmapSpec::Lock(aCount); }

    30 	inline void Lock(TBitmapLockCount& aCount,TAcceleratedBitmapInfo& aInfo) { TAcceleratedBitmapSpec::Lock(aCount,aInfo); }

    31 	inline void	Unlock(TBitmapLockCount& aCount)  { TAcceleratedBitmapSpec::Unlock(aCount); }

    32 	};

    34 const TInt KNumDisplayModes = 13;

    35 static struct

    36 	{

    37 	TDisplayMode iMode;

    38 	TBool iEnabled;

    39 	TInt iPixelShift;

    40 	} TestDisplayModes[KNumDisplayModes] =

    41    {

    42 		{EGray2,EFalse,0},

    43 		{EGray4,EFalse,1},

    44 		{EGray16,EFalse,2},

    45 		{EGray256,EFalse,3},

    46 		{EColor16,EFalse,2},

    47 		{EColor256,EFalse,3},

    48 		{EColor64K,EFalse,4},

    49 		{EColor16M,EFalse,5},

    50 		{ERgb,EFalse,5},

    51 		{EColor4K,EFalse,4},

    52 		{EColor16MU,EFalse,5},

    53 		{EColor16MA,EFalse,5},

    54 		{EColor16MAP,EFalse,5}

    55 	};

    57 _LIT(KRam32BitmapOnZ, "z:\\system\\data\\32RAM.mbm");

    58 _LIT(KRamC24BitmapOnZ, "z:\\system\\data\\24RAMC.mbm");

    59 _LIT(KRomC24Bitmap, "z:\\system\\data\\24ROMC.mbm");

    61 //

    62 // CTestBitmap

    63 //

    65 TInt CTestBitmap::ConstructL(TDisplayMode aDisplayMode,TSize aSize,TBool aHWBitmap)

    66 	{

    67 	Reset();

    69 	iBitmap = new CFbsBitmap;

    70 	if(iBitmap==NULL)

    71 		User::Panic(_L("Bitmap not created"),KErrGeneral);

    73 	TInt ret;

    74 	if(aHWBitmap)

    75 		ret = iBitmap->CreateHardwareBitmap(aSize,aDisplayMode,TUid());

    76 	else

    77 		ret = iBitmap->Create(aSize,aDisplayMode);

    79 	if (ret == KErrNotSupported)

    80 		{

    81 		Reset();

    82 		return ret;

    83 		}

    85 	User::LeaveIfError(ret);

    87 	TRAPD(err,iDevice = CFbsBitmapDevice::NewL(iBitmap));

    88 	if(err)

    89 		User::Panic(_L("BitmapDevice not created"),err);

    91 	err = iDevice->CreateContext(iGc);

    92 	if(err)

    93 		User::Panic(_L("BitmapDevice not created"),err);

    95 	return KErrNone;

    96 	}

    98 void CTestBitmap::Reset()

    99 	{

   100 	delete iGc;

   101 	iGc = 0;

   102 	delete iDevice;

   103 	iDevice = 0;

   104 	delete iBitmap;

   105 	iBitmap = 0;

   106 	}

   108 CTestBitmap::~CTestBitmap()

   109 	{

   110 	Reset();

   111 	}

   113 TBool CTestBitmap::Compare(CTestBitmap* aBitmap2)

   114 	{

   115 	TInt width=iBitmap->SizeInPixels().iWidth;

   116 	TInt pitch = iBitmap->DataStride();

   117 	TInt height=iBitmap->SizeInPixels().iHeight;

   119 	for(TInt yLoop=0;yLoop<height;yLoop++)

   120 		{

   121 		TInt offset=yLoop*pitch;

   122 		TUint8* data1 = ((TUint8*)iBitmap->DataAddress())+offset;

   123 		TUint8* data2 = ((TUint8*)aBitmap2->iBitmap->DataAddress())+offset;

   124 		TUint8* dataLimit = data1 + CFbsBitmap::ScanLineLength(width, iBitmap->DisplayMode());

   125 		while(data1<dataLimit)

   126 			{

   127 			if(*(data1++)!=*(data2++))

   128 				{

   129 				iBitmap->Save(_L("C:\\Compare1.mbm"));

   130 				aBitmap2->iBitmap->Save(_L("C:\\Compare2.mbm"));

   131 				return EFalse;

   132 				}

   133 			}

   134 		}

   135 	return(ETrue);

   136 	}

   138 //

   139 // CTAccelerator

   140 //

   142 CTAccelerator::CTAccelerator(CTestStep* aStep):

   143 	CTGraphicsBase(aStep),

   144 	iRandomSeed(1),

   145 	iGraphicsAccelerator1(0),

   146 	iGraphicsAccelerator2(0),

   147 	iHwScreenDevice(0),

   148 	iScreenGc(0)

   149 	{

   150 	TInt i;

   151 	for(i=0;i<9;i++)

   152 		iFixedRegion.AddRect(TRect(i*16,i*8,i*16+32,i*8+32));

   153 	for(i=0;i<9;i++)

   154 		iFixedRegion.AddRect(TRect(183-(i*16),i*8,199-(i*16),i*8+32));

   156 	iDefaultRegion.AddRect(TRect(0,0,199,99));

   157 	INFO_PRINTF1(_L("Graphics Accelerator Testing"));

   158 	}

   160 void CTAccelerator::Cleanup()

   161 	{

   162 	delete iGraphicsAccelerator1;

   163 	iGraphicsAccelerator1 = 0;

   164 	delete iGraphicsAccelerator2;

   165 	iGraphicsAccelerator2 = 0;

   166 	if(iHwScreenDevice)

   167 		{

   168 		delete iHwScreenDevice;

   169 		iHwScreenDevice = 0;

   170 		}

   171 	if(iScreenGc)

   172 		{

   173 		delete iScreenGc;

   174 		iScreenGc = 0;

   175 		}

   176 	iBitmap1.Reset();

   177 	iBitmap2.Reset();

   178 	iBitmap3.Reset();

   179 	iBitmap4.Reset();

   180 	iBitmap5.Reset();

   181 	iBitmap6.Reset();

   182 	iBitmap7.Reset();

   183 	iTileBitmap.Reset();

   184 	iAlphaBitmap.Reset();

   185 	}

   187 TInt CTAccelerator::Random(TInt aMax)	// aMax <= 0xFFFF

   188 	{

   189 	iRandomSeed *= 69069;

   190 	TUint r = ((iRandomSeed>>16)*aMax)>>16;

   191 	return r;

   192 	}

   194 void CTAccelerator::RunTestCaseL(TInt aCurTestCase)

   195 	{

   196 	TInt i;

   197 	((CTAcceleratorStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);

   199 	switch(aCurTestCase)

   200 		{

   201 	case 1:

   202 		((CTAcceleratorStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0021"));

   203 		INFO_PRINTF1(_L("Testing TAcceleratedBitmapSpec with software bitmaps."));

   204 		for(i=0; i<KNumDisplayModes; i++)

   205 			if (TestDisplayModes[i].iEnabled)

   206 				{

   207 				TestAcceleratedBitmapSpecL(TestDisplayModes[i].iMode,EFalse);

   208 				}

   209 		break;

   210 	case 2:

   211 		((CTAcceleratorStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0022"));

   212 		INFO_PRINTF1(_L("Testing graphics operations with software bitmaps."));

   213 		for(i=0; i<KNumDisplayModes; i++)

   214 			if (TestDisplayModes[i].iEnabled)

   215 				{

   216 				TestGraphicsOperations(TestDisplayModes[i].iMode,EFalse);

   217 				}

   218 		break;

   219 	case 3:

   220 		((CTAcceleratorStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0021"));

   221 		INFO_PRINTF1(_L("Testing TAcceleratedBitmapSpec with hardware bitmaps."));

   222 		for(i=0; i<KNumDisplayModes; i++)

   223 			if (TestDisplayModes[i].iEnabled)

   224 				{

   225 				TestAcceleratedBitmapSpecL(TestDisplayModes[i].iMode,ETrue);

   226 				}

   227 		break;

   228 	case 4:

   229 		((CTAcceleratorStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0022"));

   230 		INFO_PRINTF1(_L("Testing graphics operations with hardware bitmaps."));

   231 		for(i=0; i<KNumDisplayModes; i++)

   232 			if (TestDisplayModes[i].iEnabled)

   233 				{

   234 				TestGraphicsOperations(TestDisplayModes[i].iMode,ETrue);

   235 				}

   236 		break;

   237 	case 5:

   238 		((CTAcceleratorStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0023"));

   239 		INFO_PRINTF1(_L("Testing graphics operations with hardware bitmap as screen."));

   240 		for(i=0; i<KNumDisplayModes; i++)

   241 			if (TestDisplayModes[i].iEnabled)

   242 				{

   243 				TestGraphicsOperationsWithScreenL(TestDisplayModes[i].iMode,ETrue);

   244 				}

   245 		break;

   246 	case 6:

   248 /**

   249  @SYMTestCaseID          GRAPHICS-BITGDI-0112

   250 */

   251 		((CTAcceleratorStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0112"));

   252 		INFO_PRINTF1(_L("Testing passing of compressed info to accelerator"));

   253 		TestAcceleratorInfo();

   254 		break;

   255 	case 7:

   256 /**

   257  @SYMTestCaseID          GRAPHICS-BITGDI-0113

   258 */

   259 		((CTAcceleratorStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0113"));

   260 		INFO_PRINTF1(_L("Testing GetInfo() with an extended bitmap"));

   261 		TestAcceleratorInfoForExtendedBitmapL();

   262 		break;

   264 	case 8:

   265 		((CTAcceleratorStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);

   266 		((CTAcceleratorStep*)iStep)->CloseTMSGraphicsStep();

   267 		TestComplete();

   268 		break;

   269 		}

   270 	((CTAcceleratorStep*)iStep)->RecordTestResultL();

   271  	}

   273 const TSize TestBitmapSize = TSize(199,99);

   274 TSize TestScreenSize;

   275 const TSize TestBitmapSize1 = TSize(165,53);

   278 /**

   279  @SYMTestCaseID          GRAPHICS-BITGDI-0021

   280  @SYMCreationDate        21/11/2008

   281  @SYMAuthor              douglashetherington

   282  @SYMTestStatus          3. Released

   283  @SYMTestPriority        High

   284  @SYMTestCaseDesc        Checks that TAcceleratedBitmapSpec does not change the underlaying bitmaps data

   285  @SYMTestExpectedResults The bitmap data is not changed

   286  @SYMTestActions         Creates a bitmap, puts it into a TAcceleratedBitmapSpec then checks the pixel data is unchanged

   287  @SYMDEF

   288 */

   289 void CTAccelerator::TestAcceleratedBitmapSpecL(TDisplayMode aDisplayMode,TBool aHWBitmap)

   290 	{

   291 	TInt ret=0;

   293 	INFO_PRINTF2(_L("  DisplayMode=%d"),aDisplayMode);

   295 	// Create bitmap

   296 	ret = iBitmap1.ConstructL(aDisplayMode,TestBitmapSize,aHWBitmap);

   297 	INFO_PRINTF2(_L(" TestAcceleratedBitmapSpecL ret=%d"),ret);

   298 	if(ret!=KErrNone)

   299 		{

   300 		WARN_PRINTF1(_L("  Not Supported."));

   301 		return;

   302 		}

   304 	TAcceleratedBitmapSpecTest bitmapSpec(iBitmap1.iBitmap);

   305 	TAcceleratedBitmapInfo info;

   307 	// Check correct size

   308 	bitmapSpec.Lock(iBitmapLockCount);

   309 	User::LeaveIfError(bitmapSpec.GetInfo(info));

   310 	TEST(info.iSize==iBitmap1.iBitmap->SizeInPixels());

   311 	INFO_PRINTF3(_L("Test Display Modes , Expected iPixelShift : %d, Actual iPixelShift: %d"),TestDisplayModes[aDisplayMode-1].iPixelShift,info.iPixelShift);

   312 	TEST(info.iPixelShift == TestDisplayModes[aDisplayMode-1].iPixelShift);

   313 	bitmapSpec.Unlock(iBitmapLockCount);

   315 	TInt scanLineLength = iBitmap1.iBitmap->ScanLineLength(TestBitmapSize.iWidth,aDisplayMode);

   316 	HBufC8* scanLineBuffer = HBufC8::NewMaxLC(scanLineLength);

   317 	TPtr8 scanLine(scanLineBuffer->Des());

   319 	TInt y,x;

   321 	// fill bitmap with test data

   322 	for(y=info.iSize.iHeight-1; y>=0; y--)

   323 		{

   324 		TUint8* ptr = &(scanLine)[0];

   325 		TUint8* ptrLimit = ptr+scanLineLength;

   326 		x = 42;

   327 		while(ptr<ptrLimit)

   328 			*(ptr++) = (TUint8)(y^(x++));

   329 		iBitmap1.iBitmap->SetScanLine(scanLine,y);

   330 		}

   332 	// use TAcceleratedBitmapSpec to check contents

   333 	bitmapSpec.Lock(iBitmapLockCount,info);

   334 	for(y=0; y<info.iSize.iHeight; y++)

   335 		{

   336 		TUint8* ptr = info.iAddress+y*info.iLinePitch;

   337 		TUint8* ptrLimit = ptr+scanLineLength;

   338 		x = 42;

   339 		while(ptr<ptrLimit)

   340 			if(*(ptr++) != (TUint8)(y^(x++)))

   341 				{

   342 				ERR_PRINTF2(_L("!!!  Failed at compare A, line %d"),y);

   343 				User::Leave(KErrGeneral);

   344 				}

   345 		}

   346 	bitmapSpec.Unlock(iBitmapLockCount);

   348 	// fill bitmap with test data (inverse of previous)

   349 	for(y=info.iSize.iHeight-1; y>=0; y--)

   350 		{

   351 		TUint8* ptr = &(scanLine)[0];

   352 		TUint8* ptrLimit = ptr+scanLineLength;

   353 		x = 42;

   354 		while(ptr<ptrLimit)

   355 			*(ptr++) = (TUint8)~(y^(x++));

   356 		iBitmap1.iBitmap->SetScanLine(scanLine,y);

   357 		}

   359 	// use TAcceleratedBitmapSpec to check contents

   360 	bitmapSpec.Lock(iBitmapLockCount,info);

   361 	for(y=0; y<info.iSize.iHeight; y++)

   362 		{

   363 		TUint8* ptr = info.iAddress+y*info.iLinePitch;

   364 		TUint8* ptrLimit = ptr+scanLineLength;

   365 		x = 42;

   366 		while(ptr<ptrLimit)

   367 			if(*(ptr++) != (TUint8)~(y^(x++)))

   368 				{

   369 				ERR_PRINTF2(_L("!!!  Failed at compare B, line %d"),y);

   370 				User::Leave(KErrGeneral);

   371 				}

   372 		}

   373 	bitmapSpec.Unlock(iBitmapLockCount);

   375 	// End

   376 	CleanupStack::PopAndDestroy();	//scanLineBuffer

   378 	Cleanup();

   380 	INFO_PRINTF1(_L("  OK"));

   381 	}

   383 class CTestFbsDevice : public CFbsDevice

   384 	{

   385 public:

   386 	inline CGraphicsAccelerator* StealGraphicsAccelerator()

   387 		{ CGraphicsAccelerator* acc = iGraphicsAccelerator; iGraphicsAccelerator = 0; return acc; };

   388 	};

   391 /**

   392  @SYMTestCaseID          GRAPHICS-BITGDI-0022

   393  @SYMCreationDate        21/11/2008

   394  @SYMAuthor              douglashetherington

   395  @SYMTestStatus          3. Released

   396  @SYMTestPriority        High

   397  @SYMTestCaseDesc        Tests various basic graphic operations

   398  @SYMTestExpectedResults Tests should perform graphics operations succesfully.

   399  @SYMTestActions         Creates a number of bitmaps then uses them in various graphic operations

   400  @SYMDEF

   401 */

   402 void CTAccelerator::TestGraphicsOperations(TDisplayMode aDisplayMode,TBool aHWBitmap)

   403 	{

   404 	TInt ret=0;

   406 	INFO_PRINTF2(_L("  DisplayMode=%d"),aDisplayMode);

   407 	TRAPD(errCode, ret = iBitmap1.ConstructL(aDisplayMode,TestBitmapSize,aHWBitmap));

   408 	if((ret!=KErrNone) || (errCode !=KErrNone) || (!iBitmap1.iDevice->GraphicsAccelerator()))

   409 		{

   410 		WARN_PRINTF1(_L("  Not Supported."));

   411 		return;

   412 		}

   414 	iGraphicsAccelerator1 = ((CTestFbsDevice*)iBitmap1.iDevice)->StealGraphicsAccelerator();

   415 	delete iGraphicsAccelerator1;

   416 	iGraphicsAccelerator1 = 0;

   418 	if(!iSubRegion.IsEmpty())

   419 		iSubRegion.Clear();

   420 	iSubRegion.AddRect(iBitmap1.iBitmap->SizeInPixels());

   421 	iSubRegion.SubRegion(iFixedRegion);

   422 	iSubRegionPtr = &iSubRegion;

   424 	TRAP(errCode, ret = iBitmap2.ConstructL(aDisplayMode,TestBitmapSize,aHWBitmap));

   425 	TEST(errCode== KErrNone);

   426 	if(ret!=KErrNone)

   427 		User::Panic(_L("Bitmap not created"),ret);

   429 	TRAP(errCode, ret = iBitmap3.ConstructL(aDisplayMode,TestBitmapSize,aHWBitmap));

   430 	TEST(errCode== KErrNone);

   431 	if(ret!=KErrNone)

   432 		User::Panic(_L("Bitmap not created"),ret);

   434 	iGraphicsAccelerator1 = ((CTestFbsDevice*)iBitmap3.iDevice)->StealGraphicsAccelerator();

   436 	TRAP(errCode, ret = iBitmap4.ConstructL(aDisplayMode,TestBitmapSize,aHWBitmap));

   437 	TEST(errCode== KErrNone);

   438 	if(ret!=KErrNone)

   439 		User::Panic(_L("Bitmap not created"),ret);

   441 	TRAP(errCode, ret = iBitmap5.ConstructL(aDisplayMode,TestBitmapSize1,aHWBitmap));

   442 	TEST(errCode== KErrNone);

   443 	if(ret!=KErrNone)

   444 		User::Panic(_L("Bitmap not created"),ret);

   446 	TRAP(errCode, ret = iBitmap6.ConstructL(aDisplayMode,TestBitmapSize,aHWBitmap));

   447 	TEST(errCode== KErrNone);

   448 	if(ret!=KErrNone)

   449 		User::Panic(_L("Bitmap not created"),ret);

   451 	TRAP(errCode, ret = iBitmap7.ConstructL(aDisplayMode,TestBitmapSize,aHWBitmap));

   452 	TEST(errCode== KErrNone);

   453 	if(ret!=KErrNone)

   454 		User::Panic(_L("Bitmap not created"),ret);

   456 	TRAP(errCode, ret = iBitmap8.ConstructL(aDisplayMode,TestBitmapSize,aHWBitmap));

   457 	TEST(errCode== KErrNone);

   458 	if(ret!=KErrNone)

   459 		User::Panic(_L("Bitmap not created"),ret);

   461 	//BrushBitmap

   462     CFbsBitmap* iTile = new CFbsBitmap();

   463 	TEST(iTile!=NULL);

   464 	ret = iTile->Load(_L("z:\\system\\data\\tile.mbm"),0,aHWBitmap);

   465     TEST(ret==KErrNone);

   467 	TSize tileSize = iTile->SizeInPixels();

   468 	TDisplayMode tileDisplayMode = iTile->DisplayMode();

   470 	TRAP(errCode, ret = iTileBitmap.ConstructL(tileDisplayMode,tileSize,aHWBitmap));

   471 	TEST(errCode== KErrNone);

   472 	if(ret== KErrNotSupported)

   473 		{

   474 		WARN_PRINTF1(_L("  Not Supported."));

   475 		delete iTile;

   476 		iTile = NULL;

   477 		return;

   478 		}

   479 	iTileBitmap.iGc->BitBlt(TPoint(0,0),iTile);

   480 	delete iTile;

   481 	iTile = NULL;

   483 	//Alpha bitmap

   484 	TRAP(errCode, ret = iAlphaBitmap.ConstructL(EGray256,TestBitmapSize,aHWBitmap));

   485 	TEST(errCode== KErrNone);

   486 	if(ret!=KErrNone)

   487 		User::Panic(_L("Bitmap not created"),ret);

   489 	iGraphicsAccelerator2 = ((CTestFbsDevice*)iBitmap4.iDevice)->StealGraphicsAccelerator();

   491 	INFO_PRINTF1(_L("FilledRect"));

   492 	TestFilledRect();

   494 	resetColorBitmaps();

   496 	INFO_PRINTF1(_L("FilledRectWithPattern "));

   497 	TestFilledRectWithPattern();

   499 	resetColorBitmaps();

   501 	INFO_PRINTF1(_L("InvertRect"));

   502 	TestInvertRect();

   504 	resetColorBitmaps();

   506 	INFO_PRINTF1(_L("FadeRect "));

   507 	TestFadeRect();

   509 	resetColorBitmaps();

   511 	INFO_PRINTF1(_L("BitBlt "));

   512 	TestBitBlt();

   514 	resetColorBitmaps();

   516 	INFO_PRINTF1(_L("BitBltMasked "));

   517 	TestBitBltMasked();

   519 	resetColorBitmaps();

   521 	INFO_PRINTF1(_L("BitBltAlphaBitmap"));

   522 	TestBitBltAlphaBitmap();

   524 	resetColorBitmaps();

   526 	INFO_PRINTF1(_L("AlphaBlendTwoBitmaps "));

   527 	TestAlphaBlendTwoBitmaps();

   529 	resetColorBitmaps();

   531 	INFO_PRINTF1(_L("AlphaBlendOneBitmap "));

   532 	TestAlphaBlendOneBitmap();

   534 	resetColorBitmaps();

   536 	Cleanup();

   537 	}

   540 /**

   541  @SYMTestCaseID          GRAPHICS-BITGDI-0023

   542  @SYMCreationDate        21/11/2008

   543  @SYMAuthor              douglashetherington

   544  @SYMTestStatus          3. Released

   545  @SYMTestPriority        High

   546  @SYMTestCaseDesc        Tests various basic graphic operations draw directly to the screen device

   547  @SYMTestExpectedResults Tests should perform graphics operations succesfully.

   548  @SYMTestActions         Creates a number of bitmaps then uses them in various graphic operations drawing directly to the screen gc

   549  @SYMDEF

   550 */

   551 void CTAccelerator::TestGraphicsOperationsWithScreenL(TDisplayMode aDisplayMode,TBool aHWBitmap)

   552 	{

   553 	TInt ret;

   555 	INFO_PRINTF2(_L("  DisplayMode=%d."),aDisplayMode);

   557 	ret = iBitmap1.ConstructL(aDisplayMode,TestBitmapSize,aHWBitmap);

   558 	if((ret!=KErrNone) || (!iBitmap1.iDevice->GraphicsAccelerator()))

   559 		{

   560 		WARN_PRINTF1(_L("  Not Supported."));

   561 		return;

   562 		}

   564 	TRAPD(err,iHwScreenDevice = CFbsScreenDevice::NewL(_L(""),aDisplayMode));

   565 	if(err)

   566 		User::Panic(_L("BitmapDevice not created"),err);

   567 	iHwScreenDevice->ChangeScreenDevice(NULL);

   568 	err = iHwScreenDevice->CreateContext(iScreenGc);

   569 	if(err)

   570 		User::Panic(_L("BitmapDevice not created"),err);

   572 	TestScreenSize.SetSize(iHwScreenDevice->SizeInPixels().iWidth,iHwScreenDevice->SizeInPixels().iHeight);

   573 	iDefaultScreenRegion.AddRect(TestScreenSize);

   575 	iBitmap1.Reset();

   576 	iBitmap1.ConstructL(aDisplayMode,TestScreenSize,aHWBitmap);

   577 	iGraphicsAccelerator1 = ((CTestFbsDevice*)iBitmap1.iDevice)->StealGraphicsAccelerator();

   578 	delete iGraphicsAccelerator1;

   579 	iGraphicsAccelerator1 = 0;

   581 	if(!iSubRegion.IsEmpty())

   582 		iSubRegion.Clear();

   583 	iSubRegion.AddRect(iBitmap1.iBitmap->SizeInPixels());

   584 	iSubRegion.SubRegion(iFixedRegion);

   585 	iSubRegionPtr = &iSubRegion;

   587 	ret = iBitmap2.ConstructL(aDisplayMode,TestScreenSize,aHWBitmap);

   588 	if(ret!=KErrNone)

   589 		User::Panic(_L("Bitmap not created"),ret);

   591 	ret = iBitmap3.ConstructL(aDisplayMode,TestScreenSize,aHWBitmap);

   592 	if(ret!=KErrNone)

   593 		User::Panic(_L("Bitmap not created"),ret);

   595 	iGraphicsAccelerator1 = ((CTestFbsDevice*)iBitmap3.iDevice)->StealGraphicsAccelerator();

   597 	ret = iBitmap4.ConstructL(aDisplayMode,TestScreenSize,aHWBitmap);

   598 	if(ret!=KErrNone)

   599 		User::Panic(_L("Bitmap not created"),ret);

   601 	ret = iBitmap5.ConstructL(aDisplayMode,TestBitmapSize1,aHWBitmap);

   602 	if(ret!=KErrNone)

   603 		User::Panic(_L("Bitmap not created"),ret);

   605 	ret = iBitmap6.ConstructL(aDisplayMode,TestScreenSize,aHWBitmap);

   606 	if(ret!=KErrNone)

   607 		User::Panic(_L("Bitmap not created"),ret);

   609 	ret = iBitmap7.ConstructL(aDisplayMode,TestScreenSize,aHWBitmap);

   610 	if(ret!=KErrNone)

   611 		User::Panic(_L("Bitmap not created"),ret);

   613 	//BrushBitmap

   614     CFbsBitmap* iTile = new CFbsBitmap();

   615 	TEST(iTile!=NULL);

   616 	ret = iTile->Load(_L("z:\\system\\data\\tile.mbm"),0,aHWBitmap);

   617     TEST(ret==KErrNone);

   619 	TSize tileSize = iTile->SizeInPixels();

   620 	TDisplayMode tileDisplayMode = iTile->DisplayMode();

   622 	ret= iTileBitmap.ConstructL(tileDisplayMode,tileSize,aHWBitmap);

   623 	if(ret == KErrNotSupported)

   624 		{

   625 		WARN_PRINTF1(_L("  Not Supported."));

   626 		delete iTile;

   627 		iTile = NULL;

   628 		return;

   629 		}

   630 	iTileBitmap.iGc->BitBlt(TPoint(0,0),iTile);

   631 	delete iTile;

   632 	iTile = NULL;

   634 	//Alpha bitmap

   635 	ret = iAlphaBitmap.ConstructL(EGray256,TestBitmapSize,aHWBitmap);

   636 	if(ret!=KErrNone)

   637 		User::Panic(_L("Bitmap not created"),ret);

   639 	iGraphicsAccelerator2 = ((CTestFbsDevice*)iBitmap4.iDevice)->StealGraphicsAccelerator();

   640 	resetColorBitmaps();

   642 	INFO_PRINTF1(_L("FilledRect in the screen"));

   643 	TestScreenFilledRect();

   645 	resetColorBitmaps();

   647 	INFO_PRINTF1(_L("FilledRectWithPattern in the screen"));

   648 	TestScreenFilledRectWithPattern();

   650 	resetColorBitmaps();

   652 	INFO_PRINTF1(_L("InvertRect in the screen"));

   653 	TestScreenInvertRect();

   655 	resetColorBitmaps();

   657 	INFO_PRINTF1(_L("FadeRect in the screen"));

   658 	TestScreenFadeRect();

   660 	resetColorBitmaps();

   662 	INFO_PRINTF1(_L("BitBlt in the screen"));

   663 	TestScreenBitBlt();

   665 	resetColorBitmaps();

   667 	INFO_PRINTF1(_L("BitBltMasked in the screen"));

   668 	TestScreenBitBltMasked();

   670 	resetColorBitmaps();

   672 	INFO_PRINTF1(_L("BitBltAlphaBitmap in the screen"));

   673 	TestScreenBitBltAlphaBitmap();

   675 	resetColorBitmaps();

   677 	INFO_PRINTF1(_L("AlphaBlendTwoBitmaps in the screen"));

   678 	TestScreenAlphaBlendTwoBitmaps();

   680 	resetColorBitmaps();

   683 	INFO_PRINTF1(_L("AlphaBlendOneBitmap in the screen"));

   684 	TestScreenAlphaBlendOneBitmap();

   686 	resetColorBitmaps();

   688 	INFO_PRINTF1(_L("Rotating the screen"));

   689 	TestScreenRotation();

   691 	resetColorBitmaps();

   693 	INFO_PRINTF1(_L("Changing user display mode"));

   694 	TestUserDisplayMode();

   696 	resetColorBitmaps();

   698 	Cleanup();

   699 	}

   701 void CTAccelerator::TestAcceleratorInfo()

   702 	{

   703 	TInt errCode;

   704 	TInt ret=0;

   706 	iBitmap5.iBitmap=new CFbsBitmap();

   707 	TRAP(errCode, ret=iBitmap5.iBitmap->Load(KRam32BitmapOnZ,0));

   708 	TEST(errCode==KErrNone);

   709 	TEST(ret==KErrNone);

   710 	TAcceleratedBitmapSpec spec(iBitmap5.iBitmap);

   711 	TAcceleratedBitmapInfo info;

   712 	iBitmap5.iBitmap->LockHeap();

   713 	spec.GetInfo(info);

   714 	iBitmap5.iBitmap->UnlockHeap();

   715 	TEST(info.iLinePitch==iBitmap5.iBitmap->Header().iSizeInPixels.iWidth*iBitmap5.iBitmap->Header().iBitsPerPixel/8);

   717 	TRAP(errCode, ret=iBitmap5.iBitmap->Compress());

   718 	TEST(errCode==KErrNone);

   719 	TEST(ret==KErrNone);

   720 	iBitmap5.iBitmap->LockHeap();

   721 	spec.GetInfo(info);

   722 	iBitmap5.iBitmap->UnlockHeap();

   723 	TEST(info.iLinePitch==-iBitmap5.iBitmap->Header().iCompression);

   725 	TUint32* romAddress = NULL;

   726 	if(CFbsBitmap::IsFileInRom(KRomC24Bitmap, romAddress))

   727 		{

   728 		TRAP(errCode, ret=iBitmap5.iBitmap->Load(KRomC24Bitmap,0));

   729 		TEST(errCode==KErrNone);

   730 		TEST(ret==KErrNone);

   731 		iBitmap5.iBitmap->LockHeap();

   732 		spec.GetInfo(info);

   733 		iBitmap5.iBitmap->UnlockHeap();

   734 		TEST(info.iLinePitch==-iBitmap5.iBitmap->Header().iCompression);

   735 		}

   736 	else

   737 		{

   738 		INFO_PRINTF2(_L("Skipping ROM bitmap test since file \"%S\" is reported to not be a ROM bitmap."),

   739 				&KRomC24Bitmap);

   740 		INFO_PRINTF1(_L("This should only occur on non-XIP ROMs, e.g. NAND ROMs, where ROM bitmaps aren't supported."));

   741 		}

   743 	TRAP(errCode, ret=iBitmap5.iBitmap->LoadAndCompress(KRamC24BitmapOnZ,0));

   744 	TEST(errCode==KErrNone);

   745 	TEST(ret==KErrNone);

   746 	iBitmap5.iBitmap->LockHeap();

   747 	spec.GetInfo(info);

   748 	iBitmap5.iBitmap->UnlockHeap();

   749 	TEST(info.iLinePitch==-iBitmap5.iBitmap->Header().iCompression);

   751 	Cleanup();

   752 	}

   754 void CTAccelerator::TestAcceleratorInfoForExtendedBitmapL()

   755 	{

   756 	const TSize KSizeInPixels(64,65);

   757 	const TDisplayMode KDisplayMode	= EColor64K;

   758 	const TUid KExtendedBitmapUid = {0x87654321};

   759 	const TUint8 KTestData[] = "Extended bitmap test data 123456";

   760 	const TInt KTestDataSize = sizeof(KTestData);

   762 	CFbsBitmap* exBmp = new (ELeave) CFbsBitmap;

   763 	CleanupStack::PushL(exBmp);

   764 	TInt err = exBmp->CreateExtendedBitmap(KSizeInPixels, KDisplayMode, KExtendedBitmapUid, KTestData, KTestDataSize);

   765 	TEST(err == KErrNone);

   767 	TAcceleratedBitmapSpec exSpec(exBmp);

   768 	TAcceleratedBitmapInfo info;

   769 	exBmp->LockHeap();

   770 	err = exSpec.GetInfo(info);

   771 	TEST(err == KErrNone);

   772 	exBmp->UnlockHeap();

   774 	TEST(info.iDisplayMode == KDisplayMode);

   775 	TEST(info.iSize == KSizeInPixels);

   776 	TEST(info.iLinePitch == -EProprietaryCompression);

   777 	TEST(info.iPixelShift == KExtendedBitmapUid.iUid);

   778 	TEST(info.iDataSize == KTestDataSize);

   780 	CleanupStack::PopAndDestroy(exBmp);

   781 	}

   783 const TInt KNumTestFilledRect = 100;

   784 const TInt KNumTestInvertRect = 100;

   785 const TInt KNumTestBitBlt = 100;

   786 const TInt KNumTestFadeRect= 1000;

   787 const TInt KNumTestBitBltMasked= 100;

   788 const TInt KNumTestBitBltAlphaBitmap= 100;

   789 const TInt KNumTestAlphaBlendBitmaps= 100;

   791 void CTAccelerator::TestFilledRect()

   792 	{

   793 	TInt gopBufferSize = KNumTestFilledRect*sizeof(TGopFilledRect);

   794 	TUint8* gopBuffer = new TUint8[gopBufferSize];

   795 	TPtr8 gopDes = TPtr8(gopBuffer,0,gopBufferSize);

   797 	TRect bitmapRect(0,0,TestBitmapSize.iWidth,TestBitmapSize.iHeight);

   798 	TRect rect;

   800 	iFixedRegionPtr = &iFixedRegion;

   802 	iBitmap1.iGc->SetPenStyle(CGraphicsContext::ENullPen);

   803 	iBitmap1.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

   804 	iBitmap1.iGc->SetClippingRegion(iFixedRegionPtr);

   806 	iBitmap2.iGc->SetPenStyle(CGraphicsContext::ENullPen);

   807 	iBitmap2.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

   808 	iBitmap2.iGc->SetClippingRegion(iFixedRegionPtr);

   810 	TRgb white;

   811 	iBitmap3.iGc->SetPenStyle(CGraphicsContext::ENullPen);

   812 	iBitmap3.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

   813 	iBitmap3.iGc->SetBrushColor(white);

   814 	iBitmap3.iGc->SetClippingRegion(iSubRegionPtr);

   816 	iBitmap4.iGc->SetPenStyle(CGraphicsContext::ENullPen);

   817 	iBitmap4.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

   818 	iBitmap4.iGc->SetBrushColor(white);

   819 	iBitmap4.iGc->SetClippingRegion(iSubRegionPtr);

   821 	for(TInt n=0; n<100; n++)

   822 		{

   823 		rect.iTl.iX = Random(TestBitmapSize.iWidth+20)-10;

   824 		rect.iTl.iY = Random(TestBitmapSize.iHeight+20)-10;

   825 		rect.iBr.iX = rect.iTl.iX+1+Random(TestBitmapSize.iWidth+20);

   826 		rect.iBr.iY = rect.iTl.iY+1+Random(TestBitmapSize.iHeight+20);

   829 		TRgb colorRect(Random(256),Random(256),Random(256));

   831 		iBitmap1.iGc->SetBrushColor(colorRect);

   832 		iBitmap1.iGc->DrawRect(rect);

   834 		iBitmap2.iGc->SetBrushColor(colorRect);

   835 		iBitmap2.iGc->DrawRect(rect);

   837 		TEST(iBitmap1.Compare(&iBitmap2));

   839 		rect.Intersection(bitmapRect);

   840 		if( (rect.iBr.iX>rect.iTl.iX) && (rect.iBr.iY>rect.iTl.iY))

   841 			{

   842 			TGopFilledRect gop(rect,colorRect);

   843 			gopDes.Append((TUint8*)&gop,sizeof(gop));

   844 			TInt error = iGraphicsAccelerator1->Operation(gop);

   845 			if(error == KErrNotSupported)

   846 				{

   847 				delete gopBuffer;

   848 				WARN_PRINTF1(_L("  Not Supported."));

   849 				return;

   850 				}

   851 			}

   852 		iBitmap3.iGc->DrawRect(iBitmap3.iBitmap->SizeInPixels());

   854 		TEST(iBitmap2.Compare(&iBitmap3));

   855 		}

   857 	iGraphicsAccelerator2->Operation(gopDes);

   858 	iBitmap4.iGc->DrawRect(iBitmap4.iBitmap->SizeInPixels());

   859 	TEST(iBitmap3.Compare(&iBitmap4));

   860 	delete gopBuffer;

   861 	}

   863 void CTAccelerator::TestFilledRectWithPattern()

   864 	{

   865 	TInt gopBufferSize = KNumTestInvertRect*sizeof(TGopFilledRectWithPattern);

   866 	TUint8* gopBuffer = new TUint8[gopBufferSize];

   867 	TPtr8 gopDes = TPtr8(gopBuffer,0,gopBufferSize);

   869 	TRect bitmapRect(0,0,TestBitmapSize.iWidth,TestBitmapSize.iHeight);

   870 	TRect rect;

   872 	iFixedRegionPtr = &iFixedRegion;

   874 	iBitmap1.iGc->SetPenStyle(CGraphicsContext::ENullPen);

   875 	iBitmap1.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

   876 	iBitmap1.iGc->SetBrushStyle(CGraphicsContext::EPatternedBrush);

   877 	iBitmap1.iGc->UseBrushPattern(iTileBitmap.iBitmap);

   878 	iBitmap1.iGc->SetClippingRegion(iFixedRegionPtr);

   880 	iBitmap2.iGc->SetPenStyle(CGraphicsContext::ENullPen);

   881 	iBitmap2.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

   882 	iBitmap2.iGc->SetBrushStyle(CGraphicsContext::EPatternedBrush);

   883 	iBitmap2.iGc->UseBrushPattern(iTileBitmap.iBitmap);

   884 	iBitmap2.iGc->SetClippingRegion(iFixedRegionPtr);

   886 	TRgb white;

   887 	iBitmap3.iGc->SetPenStyle(CGraphicsContext::ENullPen);

   888 	iBitmap3.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

   889 	iBitmap3.iGc->SetBrushColor(white);

   890 	iBitmap3.iGc->SetClippingRegion(iSubRegionPtr);

   892 	iBitmap4.iGc->SetPenStyle(CGraphicsContext::ENullPen);

   893 	iBitmap4.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

   894 	iBitmap4.iGc->SetBrushColor(white);

   895 	iBitmap4.iGc->SetClippingRegion(iSubRegionPtr);

   897 	TAcceleratedBitmapSpec patternBitmapSpec(iTileBitmap.iBitmap);

   898 	TGopFillPattern gopFillPattern;

   899 	gopFillPattern.iBitmap = patternBitmapSpec;

   901 	for(TInt n=0; n<100; n++)

   902 		{

   903 		rect.iTl.iX = Random(TestBitmapSize.iWidth);

   904 		rect.iTl.iY = Random(TestBitmapSize.iHeight);

   905 		rect.iBr.iX = rect.iTl.iX+1+Random(TestBitmapSize.iWidth);

   906 		rect.iBr.iY = rect.iTl.iY+1+Random(TestBitmapSize.iHeight);

   908 		TPoint brushOrigin(Random(TestBitmapSize.iWidth -5),Random(TestBitmapSize.iHeight-5));

   910 		iBitmap1.iGc->SetBrushOrigin(brushOrigin);

   911 		iBitmap1.iGc->DrawRect(rect);

   913 		iBitmap2.iGc->SetBrushOrigin(brushOrigin);

   914 		iBitmap2.iGc->DrawRect(rect);

   916 		TEST(iBitmap1.Compare(&iBitmap2));

   918 		rect.Intersection(bitmapRect);

   919 		if( (rect.iBr.iX>rect.iTl.iX) && (rect.iBr.iY>rect.iTl.iY))

   920 			{

   921 			gopFillPattern.iOrigin = brushOrigin;

   922 			TGopFilledRectWithPattern gop(rect,gopFillPattern);

   923 			gopDes.Append((TUint8*)&gop,sizeof(gop));

   924 			TInt error = iGraphicsAccelerator1->Operation(gop);

   925 			if(error == KErrNotSupported)

   926 				{

   927 				delete gopBuffer;

   928 				WARN_PRINTF1(_L("  Not Supported."));

   929 				return;

   930 				}

   931 			}

   932 		iBitmap3.iGc->DrawRect(iBitmap3.iBitmap->SizeInPixels());

   933 		TEST(iBitmap2.Compare(&iBitmap3));

   934 		}

   935 	iGraphicsAccelerator2->Operation(gopDes);

   936 	iBitmap4.iGc->DrawRect(iBitmap4.iBitmap->SizeInPixels());

   937 	TEST(iBitmap3.Compare(&iBitmap4));

   938 	iBitmap1.iGc->DiscardBrushPattern();

   939 	delete gopBuffer;

   940 	}

   942 void CTAccelerator::TestInvertRect()

   943 	{

   944 	TInt gopBufferSize = KNumTestInvertRect*sizeof(TGopInvertRect);

   945 	TUint8* gopBuffer = new TUint8[gopBufferSize];

   946 	TPtr8 gopDes = TPtr8(gopBuffer,0,gopBufferSize);

   948 	TRect bitmapRect(0,0,TestBitmapSize.iWidth,TestBitmapSize.iHeight);

   949 	TRect rect;

   951 	iFixedRegionPtr = &iFixedRegion;

   953 	iBitmap1.iGc->SetPenStyle(CGraphicsContext::ENullPen);

   954 	iBitmap1.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

   955     iBitmap1.iGc->SetDrawMode(CGraphicsContext::EDrawModeNOTSCREEN);

   956 	iBitmap1.iGc->SetClippingRegion(iFixedRegionPtr);

   958 	iBitmap2.iGc->SetPenStyle(CGraphicsContext::ENullPen);

   959 	iBitmap2.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

   960     iBitmap2.iGc->SetDrawMode(CGraphicsContext::EDrawModeNOTSCREEN);

   961 	iBitmap2.iGc->SetClippingRegion(iFixedRegionPtr);

   963 	TRgb white;

   964 	iBitmap3.iGc->SetPenStyle(CGraphicsContext::ENullPen);

   965 	iBitmap3.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

   966 	iBitmap3.iGc->SetBrushColor(white);

   967 	iBitmap3.iGc->SetClippingRegion(iSubRegionPtr);

   969 	iBitmap4.iGc->SetPenStyle(CGraphicsContext::ENullPen);

   970 	iBitmap4.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

   971 	iBitmap4.iGc->SetBrushColor(white);

   972 	iBitmap4.iGc->SetClippingRegion(iSubRegionPtr);

   974 	for(TInt n=0; n<100; n++)

   975 		{

   976 		rect.iTl.iX = Random(TestBitmapSize.iWidth+20)-10;

   977 		rect.iTl.iY = Random(TestBitmapSize.iHeight+20)-10;

   978 		rect.iBr.iX = rect.iTl.iX+1+Random(TestBitmapSize.iWidth+20);

   979 		rect.iBr.iY = rect.iTl.iY+1+Random(TestBitmapSize.iHeight+20);

   981 		iBitmap1.iGc->DrawRect(rect);

   982 		iBitmap2.iGc->DrawRect(rect);

   984 		TEST(iBitmap1.Compare(&iBitmap2));

   986 		rect.Intersection(bitmapRect);

   987 		if((rect.iBr.iX>rect.iTl.iX) && (rect.iBr.iY>rect.iTl.iY))

   988 			{

   989 			TGopInvertRect gop(rect);

   990 			gopDes.Append((TUint8*)&gop,sizeof(gop));

   991 			TInt error = iGraphicsAccelerator1->Operation(gop);

   992 			if(error == KErrNotSupported)

   993 				{

   994 				delete gopBuffer;

   995 				WARN_PRINTF1(_L("  Not Supported."));

   996 				return;

   997 				}

   998 			}

   999 		iBitmap3.iGc->DrawRect(iBitmap3.iBitmap->SizeInPixels());

  1000 		TEST(iBitmap2.Compare(&iBitmap3));

  1001 		}

  1002 	iGraphicsAccelerator2->Operation(gopDes);

  1003 	iBitmap4.iGc->DrawRect(iBitmap4.iBitmap->SizeInPixels());

  1004 	TEST(iBitmap3.Compare(&iBitmap4));

  1005 	delete gopBuffer;

  1006 	}

  1008 void CTAccelerator::TestFadeRect()

  1009 	{

  1010 	TInt gopBufferSize = KNumTestFadeRect*sizeof(TGopFadeRect);

  1011 	TUint8* gopBuffer = new TUint8[gopBufferSize];

  1012 	TPtr8 gopDes = TPtr8(gopBuffer,0,gopBufferSize);

  1014 	TRect bitmapRect(0,0,TestBitmapSize.iWidth,TestBitmapSize.iHeight);

  1015     TRect rect;

  1017 	iFixedRegionPtr = &iFixedRegion;

  1019 	iBitmap1.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  1020 	iBitmap1.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  1021     iBitmap1.iGc->SetDrawMode(CGraphicsContext::EDrawModePEN);

  1022 	iBitmap1.iGc->SetClippingRegion(iFixedRegionPtr);

  1024 	iBitmap2.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  1025 	iBitmap2.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  1026     iBitmap2.iGc->SetDrawMode(CGraphicsContext::EDrawModePEN);

  1027 	iBitmap2.iGc->SetClippingRegion(iFixedRegionPtr);

  1029 	for(TInt n=0; n<100; n++)

  1030 		{

  1031 		rect.iTl.iX = Random(TestBitmapSize.iWidth);

  1032 		rect.iTl.iY = Random(TestBitmapSize.iHeight);

  1033 		rect.iBr.iX = rect.iTl.iX+1+Random(TestBitmapSize.iWidth);

  1034 		rect.iBr.iY = rect.iTl.iY+1+Random(TestBitmapSize.iHeight);

  1036 		TUint8 blackMap = (TUint8)Random(256);

  1037 		TUint8 whiteMap = (TUint8)Random(256);

  1039 		RRegion region(rect);

  1041 		iBitmap1.iGc->SetFaded(ETrue);

  1042 		iBitmap1.iGc->SetFadingParameters(blackMap,whiteMap);

  1043 		iBitmap1.iGc->FadeArea((TRegion*)&region);

  1045 		iBitmap2.iGc->SetFaded(ETrue);

  1046 		iBitmap2.iGc->SetFadingParameters(blackMap,whiteMap);

  1047 		iBitmap2.iGc->FadeArea((TRegion*)&region);

  1049 		region.Close();

  1051 		TEST(iBitmap1.Compare(&iBitmap2));

  1053 		TGopFadeParams fadeParams;

  1054 		fadeParams.iScale = whiteMap - blackMap + 1;

  1055 		fadeParams.iOffset = blackMap;

  1056 		rect.Intersection(bitmapRect);

  1058 		if( (rect.iBr.iX>rect.iTl.iX) && (rect.iBr.iY>rect.iTl.iY))

  1059 			{

  1060 			TGopFadeRect gop(rect,fadeParams);

  1061 			gopDes.Append((TUint8*)&gop,sizeof(gop));

  1062 			TInt error = iGraphicsAccelerator1->Operation(gop);

  1063 			if(error == KErrNotSupported)

  1064 				{

  1065 				WARN_PRINTF1(_L("  Not Supported."));

  1066 				goto quitFade2;

  1067 				}

  1068 			}

  1069 		TEST(iBitmap2.Compare(&iBitmap3));

  1070 		}

  1072 	iGraphicsAccelerator2->Operation(gopDes);

  1073 	TEST(iBitmap3.Compare(&iBitmap4));

  1074 quitFade2:

  1075 	delete gopBuffer;

  1076 	iBitmap1.iGc->SetFaded(EFalse);

  1077 	iBitmap2.iGc->SetFaded(EFalse);

  1078 	}

  1080 void CTAccelerator::TestBitBlt()

  1081 	{

  1082 	TInt gopBufferSize = KNumTestBitBlt*sizeof(TGopBitBlt);

  1083 	TUint8* gopBuffer = new TUint8[gopBufferSize];

  1084 	TPtr8 gopDes = TPtr8(gopBuffer,0,gopBufferSize);

  1086 	//dest bitmap has different size

  1087 	TRect bitmapRect1(0,0,TestBitmapSize1.iWidth,TestBitmapSize1.iHeight);

  1089 	TRect rect;

  1090 	iFixedRegionPtr = &iFixedRegion;

  1092 	iBitmap1.iGc->SetClippingRegion(iFixedRegionPtr);

  1093 	iBitmap2.iGc->SetClippingRegion(iFixedRegionPtr);

  1095 	TRgb white;

  1096 	iBitmap3.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  1097 	iBitmap3.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  1098 	iBitmap3.iGc->SetBrushColor(white);

  1099 	iBitmap3.iGc->SetClippingRegion(iSubRegionPtr);

  1101 	iBitmap4.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  1102 	iBitmap4.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  1103 	iBitmap4.iGc->SetBrushColor(white);

  1104 	iBitmap4.iGc->SetClippingRegion(iSubRegionPtr);

  1106 	TRgb color1(Random(256),Random(256),Random(256));

  1108 	iBitmap5.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  1109 	iBitmap5.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  1110 	iBitmap5.iGc->SetBrushColor(color1);

  1111 	iBitmap5.iGc->DrawRect(bitmapRect1);

  1114 	for(TInt n=0; n<100; n++)

  1115 		{

  1116 		rect.iTl.iX = Random(TestBitmapSize1.iWidth);

  1117 		rect.iTl.iY = Random(TestBitmapSize1.iHeight);

  1118 		rect.iBr.iX = rect.iTl.iX+1+Random(TestBitmapSize1.iWidth);

  1119 		rect.iBr.iY = rect.iTl.iY+1+Random(TestBitmapSize1.iHeight);

  1121         TPoint pointDest(Random(TestBitmapSize.iWidth),Random(TestBitmapSize.iHeight));

  1123 		//bitblt with GC

  1124 		iBitmap1.iGc->BitBlt(pointDest,iBitmap5.iBitmap,rect);

  1125 		iBitmap2.iGc->BitBlt(pointDest,iBitmap5.iBitmap,rect);

  1127 		TEST(iBitmap1.Compare(&iBitmap2));

  1129 		rect.Intersection(bitmapRect1);

  1130 		TSize maxSize=TestBitmapSize-pointDest;

  1131 		if (rect.Width()>maxSize.iWidth)

  1132 			rect.iBr.iX=rect.iTl.iX+maxSize.iWidth;

  1133 		if (rect.Height()>maxSize.iHeight)

  1134 			rect.iBr.iY=rect.iTl.iY+maxSize.iHeight;

  1135 		if(rect.IsEmpty())

  1136 			continue;

  1138 		if( (rect.iBr.iX>rect.iTl.iX) && (rect.iBr.iY>rect.iTl.iY))

  1139 			{

  1140 			TAcceleratedBitmapSpec bitmap5Spec(iBitmap5.iBitmap);

  1141 			TGopBitBlt gopBitBlt(pointDest,bitmap5Spec,rect);

  1142 			gopDes.Append((TUint8*)&gopBitBlt,sizeof(gopBitBlt));

  1143 			TInt error = iGraphicsAccelerator1->Operation(gopBitBlt);

  1144 			if(error == KErrNotSupported)

  1145 				{

  1146 				delete gopBuffer;

  1147 				WARN_PRINTF1(_L("  Not Supported."));

  1148 				return;

  1149 				}

  1150 			}

  1151 		iBitmap3.iGc->DrawRect(iBitmap3.iBitmap->SizeInPixels());

  1152 		TEST(iBitmap2.Compare(&iBitmap3));

  1153 		}

  1154 	iGraphicsAccelerator2->Operation(gopDes);

  1155 	iBitmap4.iGc->DrawRect(iBitmap4.iBitmap->SizeInPixels());

  1156 	TEST(iBitmap3.Compare(&iBitmap4));

  1157 	delete gopBuffer;

  1158 	}

  1160 void CTAccelerator::TestBitBltMasked()

  1161 	{

  1162 	TInt gopBufferSize = KNumTestBitBltMasked*sizeof(TGopBitBltMasked);

  1163 	TUint8* gopBuffer = new TUint8[gopBufferSize];

  1164 	TPtr8 gopDes = TPtr8(gopBuffer,0,gopBufferSize);

  1166 	TRect bitmapRect(0,0,TestBitmapSize.iWidth,TestBitmapSize.iHeight);

  1168 	TRect rect;

  1169 	iFixedRegionPtr = &iFixedRegion;

  1171 	iBitmap1.iGc->SetClippingRegion(iFixedRegionPtr);

  1172 	iBitmap2.iGc->SetClippingRegion(iFixedRegionPtr);

  1174 	TRgb white;

  1175 	iBitmap3.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  1176 	iBitmap3.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  1177 	iBitmap3.iGc->SetBrushColor(white);

  1178 	iBitmap3.iGc->SetClippingRegion(iSubRegionPtr);

  1180 	iBitmap4.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  1181 	iBitmap4.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  1182 	iBitmap4.iGc->SetBrushColor(white);

  1183 	iBitmap4.iGc->SetClippingRegion(iSubRegionPtr);

  1185 	//Mask bitmap

  1186 	iBitmap6.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  1187 	iBitmap6.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  1189 	TRgb color1(Random(256),Random(256),Random(256));

  1191 	//Source bitmap

  1192 	iBitmap7.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  1193 	iBitmap7.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  1194 	iBitmap7.iGc->SetBrushColor(color1);

  1195 	iBitmap7.iGc->DrawRect(bitmapRect);

  1196 	iBitmap7.iGc->SetBrushStyle(CGraphicsContext::ENullBrush);

  1198 	TAcceleratedBitmapSpec bitmap7Spec(iBitmap7.iBitmap);

  1199 	TAcceleratedBitmapSpec bitmap6Spec(iBitmap6.iBitmap);

  1201 	TPoint dest;

  1202 	TRect rectMask;

  1204 	//clear the mask bitmap with white

  1205 	iBitmap6.iGc->SetBrushColor(TRgb(255,255,255));

  1206 	iBitmap6.iGc->DrawRect(bitmapRect);

  1208 	//Put randomly in the Bitmap Mask a numbers of black rects

  1209 	iBitmap6.iGc->SetBrushColor(TRgb(0,0,0));

  1211 	for(TInt n=0; n<10; n++)

  1212 		{

  1213 		rectMask.iTl.iX = Random(TestBitmapSize1.iWidth);

  1214 		rectMask.iTl.iY = Random(TestBitmapSize1.iHeight);

  1215 		rectMask.iBr.iX = rectMask.iTl.iX+1+Random(TestBitmapSize1.iWidth);

  1216 		rectMask.iBr.iY = rectMask.iTl.iY+1+Random(TestBitmapSize1.iHeight);

  1217 		iBitmap6.iGc->DrawRect(rectMask);

  1218 		}

  1220 	for(TInt i=0; i<100; i++)

  1221 		{

  1222 	    //random rect to blit

  1223 		rect.iTl.iX = Random(TestBitmapSize1.iWidth);

  1224 		rect.iTl.iY = Random(TestBitmapSize1.iHeight);

  1225 		rect.iBr.iX = rect.iTl.iX+1+Random(TestBitmapSize1.iWidth);

  1226 		rect.iBr.iY = rect.iTl.iY+1+Random(TestBitmapSize1.iHeight);

  1228 		//random point destination

  1229 		dest.iX = Random(TestBitmapSize1.iWidth);

  1230 		dest.iY = Random(TestBitmapSize1.iHeight);

  1232 		//do BitBltMasked with graphics contex

  1233         iBitmap1.iGc->BitBltMasked(dest,iBitmap7.iBitmap,rect,iBitmap6.iBitmap,ETrue);

  1234         iBitmap2.iGc->BitBltMasked(dest,iBitmap7.iBitmap,rect,iBitmap6.iBitmap,ETrue);

  1235 		TEST(iBitmap1.Compare(&iBitmap2));

  1237 		rect.Intersection(bitmapRect);

  1238 		if(rect.IsEmpty())

  1239 			continue;

  1241 		if((rect.iBr.iX>rect.iTl.iX) && (rect.iBr.iY>rect.iTl.iY))

  1242 			{

  1243 			TGopBitBltMasked gopBitBltMasked(dest,bitmap7Spec,rect,bitmap6Spec);

  1244 			gopDes.Append((TUint8*)&gopBitBltMasked,sizeof(gopBitBltMasked));

  1245 			TInt error = iGraphicsAccelerator1->Operation(gopBitBltMasked);

  1246 			if(error == KErrNotSupported)

  1247 				{

  1248 				delete gopBuffer;

  1249 				WARN_PRINTF1(_L("  Not Supported."));

  1250 				return;

  1251 				}

  1252 			}

  1253 		iBitmap3.iGc->DrawRect(iBitmap3.iBitmap->SizeInPixels());

  1254 		TEST(iBitmap2.Compare(&iBitmap3));

  1255 		}

  1256 	iGraphicsAccelerator2->Operation(gopDes);

  1257 	iBitmap4.iGc->DrawRect(iBitmap4.iBitmap->SizeInPixels());

  1258 	TEST(iBitmap3.Compare(&iBitmap4));

  1259 	delete gopBuffer;

  1260 	}

  1262 void CTAccelerator::TestBitBltAlphaBitmap()

  1263 	{

  1264 	TInt gopBufferSize = KNumTestBitBltAlphaBitmap*sizeof(TGopBitBltAlphaBitmap);

  1265 	TUint8* gopBuffer = new TUint8[gopBufferSize];

  1266 	TPtr8 gopDes = TPtr8(gopBuffer,0,gopBufferSize);

  1268 	TRect bitmapRect(0,0,TestBitmapSize.iWidth,TestBitmapSize.iHeight);

  1270     TRect rect;

  1271 	iFixedRegionPtr = &iFixedRegion;

  1273 	iBitmap1.iGc->SetClippingRegion(iFixedRegionPtr);

  1274 	iBitmap2.iGc->SetClippingRegion(iFixedRegionPtr);

  1276 	TRgb white;

  1277 	iBitmap3.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  1278 	iBitmap3.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  1279 	iBitmap3.iGc->SetBrushColor(white);

  1280 	iBitmap3.iGc->SetClippingRegion(iSubRegionPtr);

  1282 	iBitmap4.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  1283 	iBitmap4.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  1284 	iBitmap4.iGc->SetBrushColor(white);

  1285 	iBitmap4.iGc->SetClippingRegion(iSubRegionPtr);

  1287 	TRgb color = TRgb(Random(256),Random(256),Random(256));

  1289 	//Source bitmap

  1290 	iBitmap7.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  1291 	iBitmap7.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  1292 	iBitmap7.iGc->SetBrushColor(color);

  1293 	iBitmap7.iGc->DrawRect(bitmapRect);

  1294 	iBitmap7.iGc->SetBrushStyle(CGraphicsContext::ENullBrush);

  1296 	iAlphaBitmap.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  1297 	iAlphaBitmap.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  1299 	//create 10 gray level for the alpha bitmap

  1300     for(TInt i=0; i<10;i++)

  1301 		{

  1302 		TRect tmpRect(0,10*i,200,10+10*i);

  1303 		TInt index = 255-(20*i);

  1304 		TRgb tmpRgb;

  1305         iAlphaBitmap.iGc->SetBrushColor(tmpRgb.Gray256(index));

  1306         iAlphaBitmap.iGc->DrawRect(tmpRect);

  1307 		}

  1309 	TAcceleratedBitmapSpec bitmap7Spec(iBitmap7.iBitmap);

  1310 	TAcceleratedBitmapSpec alphaBitmapSpec(iAlphaBitmap.iBitmap);

  1312 	iAlphaBitmap.iGc->SetBrushStyle(CGraphicsContext::ENullBrush);

  1314 	for(TInt n=0; n<100; n++)

  1315 		{

  1316 		rect.iTl.iX = Random(TestBitmapSize.iWidth);

  1317 		rect.iTl.iY = Random(TestBitmapSize.iHeight);

  1318 		rect.iBr.iX = rect.iTl.iX+1+Random(TestBitmapSize.iWidth);

  1319 		rect.iBr.iY = rect.iTl.iY+1+Random(TestBitmapSize.iHeight);

  1321 		//Random destination point

  1322 		TPoint pointDest(Random(TestBitmapSize.iWidth),Random(TestBitmapSize.iHeight));

  1324 		//alpha blitting with Graphics Contex

  1325 		iBitmap1.iGc->BitBltMasked(pointDest,iBitmap7.iBitmap,rect,iAlphaBitmap.iBitmap,ETrue);

  1326 		iBitmap2.iGc->BitBltMasked(pointDest,iBitmap7.iBitmap,rect,iAlphaBitmap.iBitmap,ETrue);

  1328 		TEST(iBitmap1.Compare(&iBitmap2));

  1330 		rect.Intersection(bitmapRect);

  1331 		//alpha blitting with Graphics accelerator

  1332 		TGopBitBltAlphaBitmap gopBitBltAlphaBitmap(pointDest,bitmap7Spec,rect,alphaBitmapSpec);

  1333 		gopDes.Append((TUint8*)&gopBitBltAlphaBitmap,sizeof(gopBitBltAlphaBitmap));

  1334 		TInt error = iGraphicsAccelerator1->Operation(gopBitBltAlphaBitmap);

  1335 		if(error == KErrNotSupported)

  1336 			{

  1337 			WARN_PRINTF1(_L("  Not Supported."));

  1338 			goto done;

  1339 			}

  1340 		iBitmap3.iGc->DrawRect(iBitmap3.iBitmap->SizeInPixels());

  1341 		TEST(iBitmap2.Compare(&iBitmap3));

  1342 		}

  1343 	iGraphicsAccelerator2->Operation(gopDes);

  1344 	iBitmap4.iGc->DrawRect(iBitmap4.iBitmap->SizeInPixels());

  1345 	TEST(iBitmap3.Compare(&iBitmap4));

  1346 done:

  1347 	delete gopBuffer;

  1348 	}

  1350 void CTAccelerator::TestAlphaBlendTwoBitmaps()

  1351 	{

  1352 	TInt gopBufferSize = KNumTestAlphaBlendBitmaps*sizeof(TGopAlphaBlendTwoBitmaps);

  1353 	TUint8* gopBuffer = new TUint8[gopBufferSize];

  1354 	TPtr8 gopDes = TPtr8(gopBuffer,0,gopBufferSize);

  1356 	TRect bitmapRect(0,0,TestBitmapSize.iWidth,TestBitmapSize.iHeight);

  1358 	TRect rect;

  1359 	iFixedRegionPtr = &iFixedRegion;

  1361 	iBitmap1.iGc->SetClippingRegion(iFixedRegionPtr);

  1362 	iBitmap2.iGc->SetClippingRegion(iFixedRegionPtr);

  1364 	TRgb white;

  1365 	iBitmap3.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  1366 	iBitmap3.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  1367 	iBitmap3.iGc->SetBrushColor(white);

  1368 	iBitmap3.iGc->SetClippingRegion(iSubRegionPtr);

  1370 	iBitmap4.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  1371 	iBitmap4.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  1372 	iBitmap4.iGc->SetBrushColor(white);

  1373 	iBitmap4.iGc->SetClippingRegion(iSubRegionPtr);

  1375 	TRgb color = TRgb(Random(256),Random(256),Random(256));

  1377 	// First Source bitmap

  1378 	iBitmap7.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  1379 	iBitmap7.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  1380 	iBitmap7.iGc->SetBrushColor(color);

  1381 	iBitmap7.iGc->DrawRect(bitmapRect);

  1382 	iBitmap7.iGc->SetBrushStyle(CGraphicsContext::ENullBrush);

  1384 	// Get a new random color

  1385 	color = TRgb(Random(256),Random(256),Random(256));

  1387 	// Second Source bitmap

  1388 	iBitmap8.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  1389 	iBitmap8.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  1390 	iBitmap8.iGc->SetBrushColor(color);

  1391 	iBitmap8.iGc->DrawRect(bitmapRect);

  1392 	iBitmap8.iGc->SetBrushStyle(CGraphicsContext::ENullBrush);

  1394 	iAlphaBitmap.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  1395 	iAlphaBitmap.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  1397 	//create 10 gray level for the alpha bitmap

  1398 	for(TInt i=0; i<10;i++)

  1399 		{

  1400 		TRect tmpRect(0,10*i,200,10+10*i);

  1401 		TInt index = 255-(20*i);

  1402 		TRgb tmpRgb;

  1403 		iAlphaBitmap.iGc->SetBrushColor(tmpRgb.Gray256(index));

  1404 		iAlphaBitmap.iGc->DrawRect(tmpRect);

  1405 		}

  1407 	TAcceleratedBitmapSpec bitmap7Spec(iBitmap7.iBitmap);

  1408 	TAcceleratedBitmapSpec bitmap8Spec(iBitmap8.iBitmap);

  1409 	TAcceleratedBitmapSpec alphaBitmapSpec(iAlphaBitmap.iBitmap);

  1411 	iAlphaBitmap.iGc->SetBrushStyle(CGraphicsContext::ENullBrush);

  1413 	for(TInt n=0; n<100; n++)

  1414 		{

  1415 		rect.iTl.iX = Random(TestBitmapSize.iWidth - 1);

  1416 		rect.iTl.iY = Random(TestBitmapSize.iHeight - 1);

  1417 		rect.iBr.iX = rect.iTl.iX+1+Random(TestBitmapSize.iWidth - rect.iTl.iX);

  1418 		rect.iBr.iY = rect.iTl.iY+1+Random(TestBitmapSize.iHeight - rect.iTl.iY);

  1420 		TPoint pointDest(Random(TestBitmapSize.iWidth),Random(TestBitmapSize.iHeight));

  1421 		TPoint pointSource(Random(TestBitmapSize.iWidth),Random(TestBitmapSize.iHeight));

  1422 		TPoint pointAlpha(Random(TestBitmapSize.iWidth - rect.Width() - 1),Random(TestBitmapSize.iHeight - rect.Height() - 1));

  1424 		//alpha blending Graphics Context - invalid parameter causes skip to next test

  1425 		TInt rc = iBitmap1.iGc->AlphaBlendBitmaps(pointDest,iBitmap7.iBitmap,iBitmap8.iBitmap,rect,pointSource,iAlphaBitmap.iBitmap,pointAlpha);

  1426 		if(rc!=KErrNone)

  1427 			{

  1428 			continue;

  1429 			}

  1430 		iBitmap2.iGc->AlphaBlendBitmaps(pointDest,iBitmap7.iBitmap,iBitmap8.iBitmap,rect,pointSource,iAlphaBitmap.iBitmap,pointAlpha);

  1431 		TEST(iBitmap1.Compare(&iBitmap2));

  1433 		rect.Intersection(bitmapRect);

  1434 		//alpha blending with Graphics accelerator

  1435 		TGopAlphaBlendTwoBitmaps gopAlphaBlendTwoBitmaps(pointDest,bitmap7Spec,bitmap8Spec,rect,pointSource,alphaBitmapSpec,pointAlpha);

  1436 		gopDes.Append((TUint8*)&gopAlphaBlendTwoBitmaps,sizeof(gopAlphaBlendTwoBitmaps));

  1437 		TInt error = iGraphicsAccelerator1->Operation(gopAlphaBlendTwoBitmaps);

  1438 		if(error == KErrNotSupported)

  1439 			{

  1440 			WARN_PRINTF1(_L("  Not Supported."));

  1441 			goto done;

  1442 			}

  1443 		iBitmap3.iGc->DrawRect(iBitmap3.iBitmap->SizeInPixels());

  1444 		TEST(iBitmap2.Compare(&iBitmap3));

  1445 		}

  1446 	iGraphicsAccelerator2->Operation(gopDes);

  1447 	iBitmap4.iGc->DrawRect(iBitmap4.iBitmap->SizeInPixels());

  1448 	TEST(iBitmap3.Compare(&iBitmap4));

  1449 done:

  1450 	delete gopBuffer;

  1451 	}

  1453 void CTAccelerator::TestAlphaBlendOneBitmap()

  1454 	{

  1455 	TInt gopBufferSize = KNumTestAlphaBlendBitmaps*sizeof(TGopAlphaBlendOneBitmap);

  1456 	TUint8* gopBuffer = new TUint8[gopBufferSize];

  1457 	TPtr8 gopDes = TPtr8(gopBuffer,0,gopBufferSize);

  1459 	TRect bitmapRect(0,0,TestBitmapSize.iWidth,TestBitmapSize.iHeight);

  1461 	TRect rect;

  1462 	iFixedRegionPtr = &iFixedRegion;

  1464 	iBitmap1.iGc->SetClippingRegion(iFixedRegionPtr);

  1465 	iBitmap2.iGc->SetClippingRegion(iFixedRegionPtr);

  1467 	TRgb white;

  1468 	iBitmap3.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  1469 	iBitmap3.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  1470 	iBitmap3.iGc->SetBrushColor(white);

  1471 	iBitmap3.iGc->SetClippingRegion(iSubRegionPtr);

  1473 	iBitmap4.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  1474 	iBitmap4.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  1475 	iBitmap4.iGc->SetBrushColor(white);

  1476 	iBitmap4.iGc->SetClippingRegion(iSubRegionPtr);

  1478 	TRgb color = TRgb(Random(256),Random(256),Random(256));

  1480 	// First Source bitmap

  1481 	iBitmap7.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  1482 	iBitmap7.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  1483 	iBitmap7.iGc->SetBrushColor(color);

  1484 	iBitmap7.iGc->DrawRect(bitmapRect);

  1485 	iBitmap7.iGc->SetBrushStyle(CGraphicsContext::ENullBrush);

  1487 	// Get a new random color

  1488 	color = TRgb(Random(256),Random(256),Random(256));

  1490 	iAlphaBitmap.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  1491 	iAlphaBitmap.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  1493 	//create 10 gray level for the alpha bitmap

  1494 	for(TInt i=0; i<10;i++)

  1495 		{

  1496 		TRect tmpRect(0,10*i,200,10+10*i);

  1497 		TInt index = 255-(20*i);

  1498 		TRgb tmpRgb;

  1499 		iAlphaBitmap.iGc->SetBrushColor(tmpRgb.Gray256(index));

  1500 		iAlphaBitmap.iGc->DrawRect(tmpRect);

  1501 		}

  1503  	TAcceleratedBitmapSpec bitmap7Spec(iBitmap7.iBitmap);

  1504 	TAcceleratedBitmapSpec alphaBitmapSpec(iAlphaBitmap.iBitmap);

  1506 	iAlphaBitmap.iGc->SetBrushStyle(CGraphicsContext::ENullBrush);

  1508 	for(TInt n=0; n<100; n++)

  1509 		{

  1510 		rect.iTl.iX = Random(TestBitmapSize.iWidth - 1);

  1511 		rect.iTl.iY = Random(TestBitmapSize.iHeight - 1);

  1512 		rect.iBr.iX = rect.iTl.iX+1+Random(TestBitmapSize.iWidth - rect.iTl.iX);

  1513 		rect.iBr.iY = rect.iTl.iY+1+Random(TestBitmapSize.iHeight - rect.iTl.iY);

  1515 		TPoint pointDest(Random(TestBitmapSize.iWidth),Random(TestBitmapSize.iHeight));

  1516 		TPoint pointAlpha(Random(TestBitmapSize.iWidth - rect.Width()),Random(TestBitmapSize.iHeight - rect.Height()));

  1518 		iBitmap1.iGc->DrawRect(iBitmap1.iBitmap->SizeInPixels());

  1519 		//alpha blending Graphics Context - wrong argument cause skip to next test

  1520 		TInt rc = iBitmap1.iGc->AlphaBlendBitmaps(pointDest,iBitmap7.iBitmap,rect,iAlphaBitmap.iBitmap,pointAlpha);

  1521 		if(rc!=KErrNone)

  1522 			{

  1523 			continue;

  1524 			}

  1525 		iBitmap2.iGc->AlphaBlendBitmaps(pointDest,iBitmap7.iBitmap,rect,iAlphaBitmap.iBitmap,pointAlpha);

  1526 		TEST(iBitmap1.Compare(&iBitmap2));

  1528 		rect.Intersection(bitmapRect);

  1529 		//alpha blending with Graphics accelerator

  1530 		TGopAlphaBlendOneBitmap gopAlphaBlendOneBitmap(pointDest,iBitmap7.iBitmap,rect,iAlphaBitmap.iBitmap,pointAlpha);

  1531 		gopDes.Append((TUint8*)&gopAlphaBlendOneBitmap,sizeof(gopAlphaBlendOneBitmap));

  1532 		TInt error = iGraphicsAccelerator1->Operation(gopAlphaBlendOneBitmap);

  1533 		if(error == KErrNotSupported)

  1534 			{

  1535 			WARN_PRINTF1(_L("  Not Supported."));

  1536 			goto done;

  1537 			}

  1538 		iBitmap3.iGc->DrawRect(iBitmap3.iBitmap->SizeInPixels());

  1539 		TEST(iBitmap2.Compare(&iBitmap3));

  1540 		}

  1541 	iGraphicsAccelerator2->Operation(gopDes);

  1542 	iBitmap4.iGc->DrawRect(iBitmap4.iBitmap->SizeInPixels());

  1543 	TEST(iBitmap3.Compare(&iBitmap4));

  1544 done:

  1545 	delete gopBuffer;

  1546 	}

  1548 void CTAccelerator::TestScreenFilledRect()

  1549 	{

  1550 	TInt gopBufferSize = KNumTestFilledRect*sizeof(TGopFilledRect);

  1551 	TUint8* gopBuffer = new TUint8[gopBufferSize];

  1552 	TPtr8 gopDes = TPtr8(gopBuffer,0,gopBufferSize);

  1554 	TRect screenRect(0,0,TestScreenSize.iWidth,TestScreenSize.iHeight);

  1556 	TRect rect;

  1557 	iFixedRegionPtr = &iFixedRegion;

  1559 	//used with GC

  1560 	iBitmap1.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  1561 	iBitmap1.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  1562 	iBitmap1.iGc->SetClippingRegion(iFixedRegionPtr);

  1564 	iScreenGc->SetPenStyle(CGraphicsContext::ENullPen);

  1565 	iScreenGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  1566 	iScreenGc->SetClippingRegion(iFixedRegionPtr);

  1568 	TRgb white;

  1569 	iBitmap3.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  1570 	iBitmap3.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  1571 	iBitmap3.iGc->SetBrushColor(white);

  1572 	iBitmap3.iGc->SetClippingRegion(iSubRegionPtr);

  1574 	iBitmap4.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  1575 	iBitmap4.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  1576 	iBitmap4.iGc->SetBrushColor(white);

  1577 	iBitmap4.iGc->SetClippingRegion(iSubRegionPtr);

  1579 	for(TInt n=0; n<100; n++)

  1580 		{

  1581 		rect.iTl.iX = Random(TestScreenSize.iWidth+20)-10;

  1582 		rect.iTl.iY = Random(TestScreenSize.iHeight+20)-10;

  1583 		rect.iBr.iX = rect.iTl.iX+1+Random(TestScreenSize.iWidth+20);

  1584 		rect.iBr.iY = rect.iTl.iY+1+Random(TestScreenSize.iHeight+20);

  1586 		TRgb colorRect(Random(256),Random(256),Random(256));

  1588 		iBitmap1.iGc->SetBrushColor(colorRect);

  1589 		iBitmap1.iGc->DrawRect(rect);

  1591 		iScreenGc->SetBrushColor(colorRect);

  1592 		iScreenGc->DrawRect(rect);

  1594 		iBitmap2.iGc->BitBlt(TPoint(0,0),*iScreenGc,screenRect);

  1595 		TEST(iBitmap1.Compare(&iBitmap2));

  1597 		rect.Intersection(screenRect);

  1598 		if( (rect.iBr.iX>rect.iTl.iX) && (rect.iBr.iY>rect.iTl.iY))

  1599 			{

  1600 			TGopFilledRect gop(rect,colorRect);

  1601 			gopDes.Append((TUint8*)&gop,sizeof(gop));

  1602 			TInt error = iGraphicsAccelerator1->Operation(gop);

  1603 			if(error == KErrNotSupported)

  1604 				{

  1605 				delete gopBuffer;

  1606 				WARN_PRINTF1(_L("  Not Supported."));

  1607 				return;

  1608 				}

  1609 			}

  1610 		iBitmap3.iGc->DrawRect(iBitmap3.iBitmap->SizeInPixels());

  1611 		TEST(iBitmap2.Compare(&iBitmap3));

  1612 		}

  1613 	iGraphicsAccelerator2->Operation(gopDes);

  1614 	iBitmap4.iGc->DrawRect(iBitmap4.iBitmap->SizeInPixels());

  1615 	TEST(iBitmap3.Compare(&iBitmap4));

  1616 	delete gopBuffer;

  1617 	}

  1619 void CTAccelerator::TestScreenFilledRectWithPattern()

  1620 	{

  1621 	TInt gopBufferSize = KNumTestInvertRect*sizeof(TGopFilledRectWithPattern);

  1622 	TUint8* gopBuffer = new TUint8[gopBufferSize];

  1623 	TPtr8 gopDes = TPtr8(gopBuffer,0,gopBufferSize);

  1625 	TRect screenRect(0,0,TestScreenSize.iWidth,TestScreenSize.iHeight);

  1627 	TRect rect;

  1628 	iFixedRegionPtr = &iFixedRegion;

  1630 	//used with GC

  1631 	iBitmap1.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  1632 	iBitmap1.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  1633 	iBitmap1.iGc->UseBrushPattern(iTileBitmap.iBitmap);

  1634 	iBitmap1.iGc->SetBrushStyle(CGraphicsContext::EPatternedBrush);

  1635 	iBitmap1.iGc->SetClippingRegion(iFixedRegionPtr);

  1637 	iScreenGc->SetPenStyle(CGraphicsContext::ENullPen);

  1638 	iScreenGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  1639 	iScreenGc->UseBrushPattern(iTileBitmap.iBitmap);

  1640 	iScreenGc->SetBrushStyle(CGraphicsContext::EPatternedBrush);

  1641 	iScreenGc->SetClippingRegion(iFixedRegionPtr);

  1643 	TRgb white;

  1644 	iBitmap3.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  1645 	iBitmap3.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  1646 	iBitmap3.iGc->SetBrushColor(white);

  1647 	iBitmap3.iGc->SetClippingRegion(iSubRegionPtr);

  1649 	iBitmap4.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  1650 	iBitmap4.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  1651 	iBitmap4.iGc->SetBrushColor(white);

  1652 	iBitmap4.iGc->SetClippingRegion(iSubRegionPtr);

  1654 	TAcceleratedBitmapSpec patternBitmapSpec(iTileBitmap.iBitmap);

  1655 	TGopFillPattern gopFillPattern;

  1656 	gopFillPattern.iBitmap = patternBitmapSpec;

  1658 	for(TInt n=0; n<100; n++)

  1659 		{

  1660 		rect.iTl.iX = Random(TestScreenSize.iWidth);

  1661 		rect.iTl.iY = Random(TestScreenSize.iHeight);

  1662 		rect.iBr.iX = rect.iTl.iX+1+Random(TestScreenSize.iWidth);

  1663 		rect.iBr.iY = rect.iTl.iY+1+Random(TestScreenSize.iHeight);

  1665 		TPoint brushOrigin(Random(TestScreenSize.iWidth -5),Random(TestScreenSize.iHeight-5));

  1667 		iBitmap1.iGc->SetBrushOrigin(brushOrigin);

  1668 		iBitmap1.iGc->DrawRect(rect);

  1670 		iScreenGc->SetBrushOrigin(brushOrigin);

  1671 		iScreenGc->DrawRect(rect);

  1673 		iBitmap2.iGc->BitBlt(TPoint(0,0),*iScreenGc,screenRect);

  1674 		TEST(iBitmap1.Compare(&iBitmap2));

  1676 		rect.Intersection(screenRect);

  1677 		if( (rect.iBr.iX>rect.iTl.iX) && (rect.iBr.iY>rect.iTl.iY))

  1678 			{

  1679 			gopFillPattern.iOrigin = brushOrigin;

  1680 			TGopFilledRectWithPattern gop(rect,gopFillPattern);

  1681 			gopDes.Append((TUint8*)&gop,sizeof(gop));

  1682 			TInt error = iGraphicsAccelerator1->Operation(gop);

  1683 			if(error == KErrNotSupported)

  1684 				{

  1685 				delete gopBuffer;

  1686 				WARN_PRINTF1(_L("  Not Supported."));

  1687 				return;

  1688 				}

  1689 			}

  1690 		iBitmap3.iGc->DrawRect(iBitmap3.iBitmap->SizeInPixels());

  1691 		TEST(iBitmap2.Compare(&iBitmap3));

  1692 		}

  1694 	iGraphicsAccelerator2->Operation(gopDes);

  1695 	iBitmap4.iGc->DrawRect(iBitmap4.iBitmap->SizeInPixels());

  1696 	TEST(iBitmap3.Compare(&iBitmap4));

  1697 	iBitmap1.iGc->DiscardBrushPattern();

  1698 	delete gopBuffer;

  1699 	}

  1701 void CTAccelerator::TestScreenInvertRect()

  1702 	{

  1703 	TInt gopBufferSize = KNumTestInvertRect*sizeof(TGopInvertRect);

  1704 	TUint8* gopBuffer = new TUint8[gopBufferSize];

  1705 	TPtr8 gopDes = TPtr8(gopBuffer,0,gopBufferSize);

  1707 	TRect screenRect(0,0,TestScreenSize.iWidth,TestScreenSize.iHeight);

  1709 	TRect rect;

  1710 	iFixedRegionPtr = &iFixedRegion;

  1712 	iBitmap1.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  1713 	iBitmap1.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  1714     iBitmap1.iGc->SetDrawMode(CGraphicsContext::EDrawModeNOTSCREEN);

  1715 	iBitmap1.iGc->SetClippingRegion(iFixedRegionPtr);

  1717 	iScreenGc->SetPenStyle(CGraphicsContext::ENullPen);

  1718 	iScreenGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  1719     iScreenGc->SetDrawMode(CGraphicsContext::EDrawModeNOTSCREEN);

  1720 	iScreenGc->SetClippingRegion(iFixedRegionPtr);

  1722 	TRgb white;

  1723 	iBitmap3.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  1724 	iBitmap3.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  1725 	iBitmap3.iGc->SetBrushColor(white);

  1726 	iBitmap3.iGc->SetClippingRegion(iSubRegionPtr);

  1728 	iBitmap4.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  1729 	iBitmap4.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  1730 	iBitmap4.iGc->SetBrushColor(white);

  1731 	iBitmap4.iGc->SetClippingRegion(iSubRegionPtr);

  1733 	for(TInt n=0; n<100; n++)

  1734 		{

  1735 		rect.iTl.iX = Random(TestScreenSize.iWidth+20)-10;

  1736 		rect.iTl.iY = Random(TestScreenSize.iHeight+20)-10;

  1737 		rect.iBr.iX = rect.iTl.iX+1+Random(TestScreenSize.iWidth+20);

  1738 		rect.iBr.iY = rect.iTl.iY+1+Random(TestScreenSize.iHeight+20);

  1740 		iBitmap1.iGc->DrawRect(rect);

  1741 		iScreenGc->DrawRect(rect);

  1743 		iBitmap2.iGc->BitBlt(TPoint(0,0),*iScreenGc,screenRect);

  1744 		TEST(iBitmap1.Compare(&iBitmap2));

  1746 		rect.Intersection(screenRect);

  1747 		if((rect.iBr.iX>rect.iTl.iX) && (rect.iBr.iY>rect.iTl.iY))

  1748 			{

  1749 			TGopInvertRect gop(rect);

  1750 			gopDes.Append((TUint8*)&gop,sizeof(gop));

  1751 			TInt error = iGraphicsAccelerator1->Operation(gop);

  1752 			if(error == KErrNotSupported)

  1753 				{

  1754 				delete gopBuffer;

  1755 				WARN_PRINTF1(_L("  Not Supported."));

  1756 				return;

  1757 				}

  1758 			}

  1759 		iBitmap3.iGc->DrawRect(iBitmap3.iBitmap->SizeInPixels());

  1760 		TEST(iBitmap2.Compare(&iBitmap3));

  1761 		}

  1762 	iGraphicsAccelerator2->Operation(gopDes);

  1763 	iBitmap4.iGc->DrawRect(iBitmap4.iBitmap->SizeInPixels());

  1764 	TEST(iBitmap3.Compare(&iBitmap4));

  1765 	delete gopBuffer;

  1766 	}

  1768 void CTAccelerator::TestScreenFadeRect()

  1769 	{

  1770 	TInt gopBufferSize = KNumTestFadeRect*sizeof(TGopFadeRect);

  1771 	TUint8* gopBuffer = new TUint8[gopBufferSize];

  1772 	TPtr8 gopDes = TPtr8(gopBuffer,0,gopBufferSize);

  1774 	TRect screenRect(0,0,TestScreenSize.iWidth,TestScreenSize.iHeight);

  1776 	TRect rect;

  1777 	iFixedRegionPtr = &iFixedRegion;

  1779 	iBitmap1.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  1780 	iBitmap1.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  1781     iBitmap1.iGc->SetDrawMode(CGraphicsContext::EDrawModePEN);

  1782 	iBitmap1.iGc->SetClippingRegion(iFixedRegionPtr);

  1784 	iScreenGc->SetPenStyle(CGraphicsContext::ENullPen);

  1785 	iScreenGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  1786     iScreenGc->SetDrawMode(CGraphicsContext::EDrawModePEN);

  1787 	iScreenGc->SetClippingRegion(iFixedRegionPtr);

  1789 	for(TInt n=0; n<100; n++)

  1790 		{

  1791 		rect.iTl.iX = Random(TestScreenSize.iWidth);

  1792 		rect.iTl.iY = Random(TestScreenSize.iHeight);

  1793 		rect.iBr.iX = rect.iTl.iX+1+Random(TestScreenSize.iWidth);

  1794 		rect.iBr.iY = rect.iTl.iY+1+Random(TestScreenSize.iHeight);

  1796 		TUint8 blackMap = (TUint8)Random(256);

  1797 		TUint8 whiteMap = (TUint8)Random(256);

  1799 		RRegion region(rect);

  1801 		iBitmap1.iGc->SetFaded(ETrue);

  1802 		iBitmap1.iGc->SetFadingParameters(blackMap,whiteMap);

  1803 		iBitmap1.iGc->FadeArea((TRegion*)&region);

  1805 		iScreenGc->SetFaded(ETrue);

  1806 		iScreenGc->SetFadingParameters(blackMap,whiteMap);

  1807 		iScreenGc->FadeArea((TRegion*)&region);

  1809 		iBitmap2.iGc->BitBlt(TPoint(0,0),*iScreenGc,screenRect);

  1811 		region.Close();

  1812 		TEST(iBitmap1.Compare(&iBitmap2));

  1814 		TGopFadeParams fadeParams;

  1815 		fadeParams.iScale = whiteMap - blackMap + 1;

  1816 		fadeParams.iOffset = blackMap;

  1817 		rect.Intersection(screenRect);

  1819 		if( (rect.iBr.iX>rect.iTl.iX) && (rect.iBr.iY>rect.iTl.iY))

  1820 			{

  1821 			TGopFadeRect gop(rect,fadeParams);

  1822 			gopDes.Append((TUint8*)&gop,sizeof(gop));

  1823 			TInt error = iGraphicsAccelerator1->Operation(gop);

  1824 			if(error == KErrNotSupported)

  1825 				{

  1826 				WARN_PRINTF1(_L("  Not Supported."));

  1827 				goto quitFade;

  1828 				}

  1829 			}

  1830 		TEST(iBitmap2.Compare(&iBitmap3));

  1831 		}

  1832 	iGraphicsAccelerator2->Operation(gopDes);

  1833 	TEST(iBitmap3.Compare(&iBitmap4));

  1834 quitFade:

  1835 	delete gopBuffer;

  1836 	iBitmap1.iGc->SetFaded(EFalse);

  1837 	iScreenGc->SetFaded(EFalse);

  1838 	}

  1840 void CTAccelerator::TestScreenBitBlt()

  1841 	{

  1842 	TInt gopBufferSize = KNumTestBitBlt*sizeof(TGopBitBlt);

  1843 	TUint8* gopBuffer = new TUint8[gopBufferSize];

  1844 	TPtr8 gopDes = TPtr8(gopBuffer,0,gopBufferSize);

  1846 	TRect screenRect(0,0,TestScreenSize.iWidth,TestScreenSize.iHeight);

  1847 	//dest bitmap has different size

  1848 	TRect bitmapRect1(0,0,TestBitmapSize1.iWidth,TestBitmapSize1.iHeight);

  1850 	TRect rect;

  1851 	iFixedRegionPtr = &iFixedRegion;

  1853 	iBitmap1.iGc->SetClippingRegion(iFixedRegionPtr);

  1854 	iScreenGc->SetClippingRegion(iFixedRegionPtr);

  1856 	TRgb white;

  1857 	iBitmap3.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  1858 	iBitmap3.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  1859 	iBitmap3.iGc->SetBrushColor(white);

  1860 	iBitmap3.iGc->SetClippingRegion(iSubRegionPtr);

  1862 	iBitmap4.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  1863 	iBitmap4.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  1864 	iBitmap4.iGc->SetBrushColor(white);

  1865 	iBitmap4.iGc->SetClippingRegion(iSubRegionPtr);

  1867 	TRgb color1(Random(256),Random(256),Random(256));

  1869 	iBitmap5.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  1870 	iBitmap5.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  1871 	iBitmap5.iGc->SetBrushColor(color1);

  1872 	iBitmap5.iGc->DrawRect(bitmapRect1);

  1875 	for(TInt n=0; n<100; n++)

  1876 		{

  1877 		rect.iTl.iX = Random(TestBitmapSize1.iWidth);

  1878 		rect.iTl.iY = Random(TestBitmapSize1.iHeight);

  1879 		rect.iBr.iX = rect.iTl.iX+1+Random(TestBitmapSize1.iWidth);

  1880 		rect.iBr.iY = rect.iTl.iY+1+Random(TestBitmapSize1.iHeight);

  1882         TPoint pointDest(Random(TestScreenSize.iWidth),Random(TestScreenSize.iHeight));

  1884 		//bitblt with GC

  1885 		iBitmap1.iGc->BitBlt(pointDest,iBitmap5.iBitmap,rect);

  1886 		iScreenGc->BitBlt(pointDest,iBitmap5.iBitmap,rect);

  1888 		iBitmap2.iGc->BitBlt(TPoint(0,0),*iScreenGc,screenRect);

  1889 		TEST(iBitmap1.Compare(&iBitmap2));

  1891 		TInt extraWidth=(pointDest.iX+rect.Width())-TestScreenSize.iWidth;

  1892 		if (extraWidth>0)

  1893 			rect.iBr.iX-=extraWidth;

  1894 		TInt extraHeight=(pointDest.iY+rect.Height())-TestScreenSize.iHeight;

  1895 		if (extraHeight>0)

  1896 			rect.iBr.iY-=extraHeight;

  1897 		rect.Intersection(bitmapRect1);

  1898 		TSize maxSize=TestBitmapSize-pointDest;

  1899 		if (rect.Width()>maxSize.iWidth)

  1900 			rect.iBr.iX=rect.iTl.iX+maxSize.iWidth;

  1901 		if (rect.Height()>maxSize.iHeight)

  1902 			rect.iBr.iY=rect.iTl.iY+maxSize.iHeight;

  1903 		if(rect.IsEmpty())

  1904 			continue;

  1906 		if( (rect.iBr.iX>rect.iTl.iX) && (rect.iBr.iY>rect.iTl.iY))

  1907 			{

  1908 			TAcceleratedBitmapSpec bitmap5Spec(iBitmap5.iBitmap);

  1909 			TGopBitBlt gopBitBlt(pointDest,bitmap5Spec,rect);

  1910 			gopDes.Append((TUint8*)&gopBitBlt,sizeof(gopBitBlt));

  1911 			TInt error = iGraphicsAccelerator1->Operation(gopBitBlt);

  1912 			if(error == KErrNotSupported)

  1913 				{

  1914 				delete gopBuffer;

  1915 				WARN_PRINTF1(_L("  Not Supported."));

  1916 				return;

  1917 				}

  1918 			}

  1919 		iBitmap3.iGc->DrawRect(iBitmap3.iBitmap->SizeInPixels());

  1920 		TEST(iBitmap2.Compare(&iBitmap3));

  1921 		}

  1922 	iGraphicsAccelerator2->Operation(gopDes);

  1923 	iBitmap4.iGc->DrawRect(iBitmap4.iBitmap->SizeInPixels());

  1924 	TEST(iBitmap3.Compare(&iBitmap4));

  1925 	delete gopBuffer;

  1926 	}

  1928 void CTAccelerator::TestScreenBitBltMasked()

  1929 	{

  1930 	TInt gopBufferSize = KNumTestBitBltMasked*sizeof(TGopBitBltMasked);

  1931 	TUint8* gopBuffer = new TUint8[gopBufferSize];

  1932 	TPtr8 gopDes = TPtr8(gopBuffer,0,gopBufferSize);

  1934 	TRect screenRect(0,0,TestScreenSize.iWidth,TestScreenSize.iHeight);

  1936 	TRect rect;

  1937 	iFixedRegionPtr = &iFixedRegion;

  1939 	iBitmap1.iGc->SetClippingRegion(iFixedRegionPtr);

  1940 	iScreenGc->SetClippingRegion(iFixedRegionPtr);

  1942 	TRgb white;

  1943 	iBitmap3.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  1944 	iBitmap3.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  1945 	iBitmap3.iGc->SetBrushColor(white);

  1946 	iBitmap3.iGc->SetClippingRegion(iSubRegionPtr);

  1948 	iBitmap4.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  1949 	iBitmap4.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  1950 	iBitmap4.iGc->SetBrushColor(white);

  1951 	iBitmap4.iGc->SetClippingRegion(iSubRegionPtr);

  1953 	//Mask bitmap

  1954 	iBitmap6.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  1955 	iBitmap6.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  1957 	TRgb color1(Random(256),Random(256),Random(256));

  1959 	//Source bitmap

  1960 	iBitmap7.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  1961 	iBitmap7.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  1962 	iBitmap7.iGc->SetBrushColor(color1);

  1963 	iBitmap7.iGc->DrawRect(iBitmap7.iBitmap->SizeInPixels());

  1964 	iBitmap7.iGc->SetBrushStyle(CGraphicsContext::ENullBrush);

  1966 	TAcceleratedBitmapSpec bitmap7Spec(iBitmap7.iBitmap);

  1967 	TAcceleratedBitmapSpec bitmap6Spec(iBitmap6.iBitmap);

  1969 	TPoint dest;

  1970 	TRect rectMask;

  1972 	//Put randomly in the Bitmap Mask a numbers of black rects

  1973 	iBitmap6.iGc->SetBrushColor(TRgb(0,0,0));

  1975 	for(TInt n=0; n<3; n++)

  1976 		{

  1977 		rectMask.iTl.iX = Random(TestScreenSize.iWidth);

  1978 		rectMask.iTl.iY = Random(TestScreenSize.iHeight);

  1979 		rectMask.iBr.iX = rectMask.iTl.iX+1+Random(TestScreenSize.iWidth);

  1980 		rectMask.iBr.iY = rectMask.iTl.iY+1+Random(TestScreenSize.iHeight);

  1981 		iBitmap6.iGc->DrawRect(rectMask);

  1982 		}

  1984 	for(TInt i=0; i<100; i++)

  1985 		{

  1986 	    //random rect to blit

  1987 		rect.iTl.iX = Random(TestScreenSize.iWidth);

  1988 		rect.iTl.iY = Random(TestScreenSize.iHeight);

  1989 		rect.iBr.iX = rect.iTl.iX+1+Random(TestScreenSize.iWidth);

  1990 		rect.iBr.iY = rect.iTl.iY+1+Random(TestScreenSize.iHeight);

  1992 		//random point destination

  1993 		dest.iX = Random(TestScreenSize.iWidth);

  1994 		dest.iY = Random(TestScreenSize.iHeight);

  1996         iBitmap1.iGc->BitBltMasked(dest,iBitmap7.iBitmap,rect,iBitmap6.iBitmap,ETrue);

  1997         iScreenGc->BitBltMasked(dest,iBitmap7.iBitmap,rect,iBitmap6.iBitmap,ETrue);

  1998 		iBitmap2.iGc->BitBlt(TPoint(0,0),*iScreenGc,screenRect);

  1999 		TEST(iBitmap1.Compare(&iBitmap2));

  2001 		rect.Intersection(screenRect);

  2002 		if(rect.IsEmpty())

  2003 			continue;

  2005 		if((rect.iBr.iX>rect.iTl.iX) && (rect.iBr.iY>rect.iTl.iY))

  2006 			{

  2007 			TGopBitBltMasked gopBitBltMasked(dest,bitmap7Spec,rect,bitmap6Spec);

  2008 			gopDes.Append((TUint8*)&gopBitBltMasked,sizeof(gopBitBltMasked));

  2009 			TInt error = iGraphicsAccelerator1->Operation(gopBitBltMasked);

  2010 			if(error == KErrNotSupported)

  2011 				{

  2012 				delete gopBuffer;

  2013 				WARN_PRINTF1(_L("  Not Supported."));

  2014 				return;

  2015 				}

  2016 			}

  2017 		iBitmap3.iGc->DrawRect(iBitmap3.iBitmap->SizeInPixels());

  2018 		TEST(iBitmap2.Compare(&iBitmap3));

  2019 		}

  2020 	iGraphicsAccelerator2->Operation(gopDes);

  2021 	iBitmap4.iGc->DrawRect(iBitmap4.iBitmap->SizeInPixels());

  2022 	TEST(iBitmap3.Compare(&iBitmap4));

  2023 	delete gopBuffer;

  2024 	}

  2026 void CTAccelerator::TestScreenBitBltAlphaBitmap()

  2027 	{

  2028 	TInt gopBufferSize = KNumTestBitBltAlphaBitmap*sizeof(TGopBitBltAlphaBitmap);

  2029 	TUint8* gopBuffer = new TUint8[gopBufferSize];

  2030 	TPtr8 gopDes = TPtr8(gopBuffer,0,gopBufferSize);

  2032 	TRect screenRect(0,0,TestScreenSize.iWidth,TestScreenSize.iHeight);

  2034     TRect rect;

  2035 	iFixedRegionPtr = &iFixedRegion;

  2037 	iBitmap1.iGc->SetClippingRegion(iFixedRegionPtr);

  2038 	iScreenGc->SetClippingRegion(iFixedRegionPtr);

  2040 	TRgb white;

  2041 	iBitmap3.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  2042 	iBitmap3.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  2043 	iBitmap3.iGc->SetBrushColor(white);

  2044 	iBitmap3.iGc->SetClippingRegion(iSubRegionPtr);

  2046 	iBitmap4.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  2047 	iBitmap4.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  2048 	iBitmap4.iGc->SetBrushColor(white);

  2049 	iBitmap4.iGc->SetClippingRegion(iSubRegionPtr);

  2051 	TRgb color = TRgb(Random(256),Random(256),Random(256));

  2053 	//Source bitmap

  2054 	iBitmap7.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  2055 	iBitmap7.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  2056 	iBitmap7.iGc->SetBrushColor(color);

  2057 	iBitmap7.iGc->DrawRect(iBitmap7.iBitmap->SizeInPixels());

  2058 	iBitmap7.iGc->SetBrushStyle(CGraphicsContext::ENullBrush);

  2061 	iAlphaBitmap.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  2062 	iAlphaBitmap.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  2065     //create 10 gray level for the alpha bitmap

  2066     for(TInt i=0; i<10;i++)

  2067 		{

  2068 		TRect tmpRect(0,10*i,200,10+10*i);

  2069 		TInt index = 255-(20*i);

  2070 		TRgb tmpRgb;

  2071         iAlphaBitmap.iGc->SetBrushColor(tmpRgb.Gray256(index));

  2072         iAlphaBitmap.iGc->DrawRect(tmpRect);

  2073 		}

  2075 	TAcceleratedBitmapSpec bitmap7Spec(iBitmap7.iBitmap);

  2076 	TAcceleratedBitmapSpec alphaBitmapSpec(iAlphaBitmap.iBitmap);

  2078    	iAlphaBitmap.iGc->SetBrushStyle(CGraphicsContext::ENullBrush);

  2080 	for(TInt n=0; n<100; n++)

  2081 		{

  2082 		rect.iTl.iX = Random(TestBitmapSize.iWidth);

  2083 		rect.iTl.iY = Random(TestBitmapSize.iHeight);

  2084 		rect.iBr.iX = rect.iTl.iX+1+Random(TestBitmapSize.iWidth);

  2085 		rect.iBr.iY = rect.iTl.iY+1+Random(TestBitmapSize.iHeight);

  2087 		//Random destination point

  2088 		TPoint pointDest(Random(TestScreenSize.iWidth),Random(TestScreenSize.iHeight));

  2090 		//alpha blitting with Graphics Contex

  2091 		iBitmap1.iGc->BitBltMasked(pointDest,iBitmap7.iBitmap,rect,iAlphaBitmap.iBitmap,ETrue);

  2092 		iScreenGc->BitBltMasked(pointDest,iBitmap7.iBitmap,rect,iAlphaBitmap.iBitmap,ETrue);

  2093 		iBitmap2.iGc->BitBlt(TPoint(0,0),*iScreenGc,screenRect);

  2095 		TEST(iBitmap1.Compare(&iBitmap2));

  2097 		rect.Intersection(screenRect);

  2098 		//alpha blitting with Graphics accelerator

  2099 		TGopBitBltAlphaBitmap gopBitBltAlphaBitmap(pointDest,bitmap7Spec,rect,alphaBitmapSpec);

  2100 		gopDes.Append((TUint8*)&gopBitBltAlphaBitmap,sizeof(gopBitBltAlphaBitmap));

  2101 		TInt error = iGraphicsAccelerator1->Operation(gopBitBltAlphaBitmap);

  2102 		if(error == KErrNotSupported)

  2103 			{

  2104 			WARN_PRINTF1(_L("  Not Supported."));

  2105 			goto done;

  2106 			}

  2107 		iBitmap3.iGc->DrawRect(iBitmap3.iBitmap->SizeInPixels());

  2108 		TEST(iBitmap2.Compare(&iBitmap3));

  2109 		}

  2110 	iGraphicsAccelerator2->Operation(gopDes);

  2111 	iBitmap4.iGc->DrawRect(iBitmap4.iBitmap->SizeInPixels());

  2112 	TEST(iBitmap3.Compare(&iBitmap4));

  2113 done:

  2114 	delete gopBuffer;

  2115 	}

  2117 void CTAccelerator::TestScreenAlphaBlendTwoBitmaps()

  2118 	{

  2119 	TRect screenRect(0,0,TestBitmapSize.iWidth,TestBitmapSize.iHeight);

  2121 	TRect rect;

  2122 	iFixedRegionPtr = &iFixedRegion;

  2124 	iBitmap1.iGc->SetClippingRegion(iFixedRegionPtr);

  2125 	iBitmap2.iGc->SetClippingRegion(iFixedRegionPtr);

  2127 	TRgb color = TRgb(Random(256),Random(256),Random(256));

  2129 	// First Source bitmap

  2130 	iBitmap7.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  2131 	iBitmap7.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  2132 	iBitmap7.iGc->SetBrushColor(color);

  2133 	iBitmap7.iGc->DrawRect(screenRect);

  2134 	iBitmap7.iGc->SetBrushStyle(CGraphicsContext::ENullBrush);

  2136 	// Get a new random color

  2137 	color = TRgb(Random(256),Random(256),Random(256));

  2139 	// Second Source bitmap

  2140 	iBitmap8.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  2141 	iBitmap8.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  2142 	iBitmap8.iGc->SetBrushColor(color);

  2143 	iBitmap8.iGc->DrawRect(screenRect);

  2144 	iBitmap8.iGc->SetBrushStyle(CGraphicsContext::ENullBrush);

  2146 	iAlphaBitmap.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  2147 	iAlphaBitmap.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  2149 	//create 10 gray level for the alpha bitmap

  2150 	for(TInt i=0; i<10;i++)

  2151 		{

  2152 		TRect tmpRect(0,10*i,200,10+10*i);

  2153 		TInt index = 255-(20*i);

  2154 		TRgb tmpRgb;

  2155 		iAlphaBitmap.iGc->SetBrushColor(tmpRgb.Gray256(index));

  2156 		iAlphaBitmap.iGc->DrawRect(tmpRect);

  2157 		}

  2159 	TAcceleratedBitmapSpec bitmap7Spec(iBitmap7.iBitmap);

  2160 	TAcceleratedBitmapSpec bitmap8Spec(iBitmap8.iBitmap);

  2161 	TAcceleratedBitmapSpec alphaBitmapSpec(iAlphaBitmap.iBitmap);

  2163 	iAlphaBitmap.iGc->SetBrushStyle(CGraphicsContext::ENullBrush);

  2165 	for(TInt n=0; n<100; n++)

  2166 		{

  2167 		rect.iTl.iX = Random(TestBitmapSize.iWidth - 1);

  2168 		rect.iTl.iY = Random(TestBitmapSize.iHeight - 1);

  2169 		rect.iBr.iX = rect.iTl.iX+1+Random(TestBitmapSize.iWidth - rect.iTl.iX);

  2170 		rect.iBr.iY = rect.iTl.iY+1+Random(TestBitmapSize.iHeight - rect.iTl.iY);

  2172 		TPoint pointDest(Random(TestBitmapSize.iWidth),Random(TestBitmapSize.iHeight));

  2173 		TPoint pointSource(Random(TestBitmapSize.iWidth),Random(TestBitmapSize.iHeight));

  2174 		TPoint pointAlpha(Random(TestBitmapSize.iWidth - rect.Width()),Random(TestBitmapSize.iHeight - rect.Height()));

  2176 		//alpha blending Graphics Context - wrong argument cause skip to next test

  2177 		TInt error = iBitmap1.iGc->AlphaBlendBitmaps(pointDest,iBitmap7.iBitmap,iBitmap8.iBitmap,rect,pointSource,iAlphaBitmap.iBitmap,pointAlpha);

  2178 		// AlphaBlendBitmaps can return KErrArgument based on the input data - in that case, continue

  2179 		if(error!=KErrNone)

  2180 			{

  2181 			continue;

  2182 			}

  2183 		iScreenGc->AlphaBlendBitmaps(pointDest,iBitmap7.iBitmap,iBitmap8.iBitmap,rect,pointSource,iAlphaBitmap.iBitmap,pointAlpha);

  2184 		iBitmap2.iGc->BitBlt(TPoint(0,0),*iScreenGc,screenRect);

  2185 		TEST(iBitmap1.Compare(&iBitmap2));

  2186 		}

  2187 	}

  2189 void CTAccelerator::TestScreenAlphaBlendOneBitmap()

  2190 	{

  2191 	TRect screenRect(0,0,TestBitmapSize.iWidth,TestBitmapSize.iHeight);

  2193 	TRect rect;

  2194 	iFixedRegionPtr = &iFixedRegion;

  2196 	iBitmap1.iGc->SetClippingRegion(iFixedRegionPtr);

  2197 	iBitmap2.iGc->SetClippingRegion(iFixedRegionPtr);

  2199 	TRgb color = TRgb(Random(256),Random(256),Random(256));

  2201 	// First Source bitmap

  2202 	iBitmap7.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  2203 	iBitmap7.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  2204 	iBitmap7.iGc->SetBrushColor(color);

  2205 	iBitmap7.iGc->DrawRect(screenRect);

  2206 	iBitmap7.iGc->SetBrushStyle(CGraphicsContext::ENullBrush);

  2208 	// Get a new random color

  2209 	color = TRgb(Random(256),Random(256),Random(256));

  2211 	iAlphaBitmap.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  2212 	iAlphaBitmap.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  2214 	//create 10 gray level for the alpha bitmap

  2215 	for(TInt i=0; i<10;i++)

  2216 		{

  2217 		TRect tmpRect(0,10*i,200,10+10*i);

  2218 		TInt index = 255-(20*i);

  2219 		TRgb tmpRgb;

  2220 		iAlphaBitmap.iGc->SetBrushColor(tmpRgb.Gray256(index));

  2221 		iAlphaBitmap.iGc->DrawRect(tmpRect);

  2222 		}

  2224 	TAcceleratedBitmapSpec bitmap7Spec(iBitmap7.iBitmap);

  2225 	TAcceleratedBitmapSpec alphaBitmapSpec(iAlphaBitmap.iBitmap);

  2227 	iAlphaBitmap.iGc->SetBrushStyle(CGraphicsContext::ENullBrush);

  2229 	for(TInt n=0; n<100; n++)

  2230 		{

  2231 		if(n==0) continue;

  2232 		rect.iTl.iX = Random(TestBitmapSize.iWidth - 1);

  2233 		rect.iTl.iY = Random(TestBitmapSize.iHeight - 1);

  2234 		rect.iBr.iX = rect.iTl.iX+1+Random(TestBitmapSize.iWidth - rect.iTl.iX);

  2235 		rect.iBr.iY = rect.iTl.iY+1+Random(TestBitmapSize.iHeight - rect.iTl.iY);

  2237 		TPoint pointDest(Random(TestBitmapSize.iWidth),Random(TestBitmapSize.iHeight));

  2238 		TPoint pointAlpha(Random(TestBitmapSize.iWidth - rect.Width() - 1),Random(TestBitmapSize.iHeight - rect.Height() - 1));

  2240 		//alpha blending Graphics Context - wrong argument cause skip to next test

  2241 		TInt rc = iBitmap1.iGc->AlphaBlendBitmaps(pointDest,iBitmap7.iBitmap,rect,iAlphaBitmap.iBitmap,pointAlpha);

  2242 		if(rc!=KErrNone)

  2243 			{

  2244 			continue;

  2245 			}

  2246 		iScreenGc->AlphaBlendBitmaps(pointDest,iBitmap7.iBitmap,rect,iAlphaBitmap.iBitmap,pointAlpha);

  2247 		iBitmap2.iGc->BitBlt(TPoint(0,0),*iScreenGc,screenRect);

  2248 		TEST(iBitmap1.Compare(&iBitmap2));

  2249 		}

  2250 	}

  2252 void CTAccelerator::resetColorBitmaps()

  2253 	{

  2254 	TRgb color;

  2255 	iFixedRegionPtr = &iDefaultRegion;

  2257 	if(iHwScreenDevice)

  2258 		{

  2259 		iFixedRegionPtr = &iDefaultScreenRegion;

  2260 		iScreenGc->SetPenStyle(CGraphicsContext::ENullPen);

  2261 		iScreenGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  2262 		iScreenGc->SetDrawMode(CGraphicsContext::EDrawModePEN);

  2263 		iScreenGc->SetClippingRegion(iFixedRegionPtr);

  2264 		iScreenGc->SetBrushColor(color);

  2265 		iScreenGc->DrawRect(TestScreenSize);

  2266 		iScreenGc->SetBrushStyle(CGraphicsContext::ENullBrush);

  2267 		}

  2269 	iBitmap1.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  2270 	iBitmap1.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  2271     iBitmap1.iGc->SetDrawMode(CGraphicsContext::EDrawModePEN);

  2272 	iBitmap1.iGc->SetClippingRegion(iFixedRegionPtr);

  2273 	iBitmap1.iGc->SetBrushColor(color);

  2274 	TRect rect1(iBitmap1.iBitmap->SizeInPixels());

  2275 	iBitmap1.iGc->DrawRect(rect1);

  2276 	iBitmap1.iGc->SetBrushStyle(CGraphicsContext::ENullBrush);

  2278 	iBitmap2.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  2279 	iBitmap2.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  2280 	iBitmap2.iGc->SetDrawMode(CGraphicsContext::EDrawModePEN);

  2281 	iBitmap2.iGc->SetClippingRegion(iFixedRegionPtr);

  2282 	iBitmap2.iGc->SetBrushColor(color);

  2283 	TRect rect2(iBitmap2.iBitmap->SizeInPixels());

  2284 	iBitmap2.iGc->DrawRect(rect2);

  2285 	iBitmap2.iGc->SetBrushStyle(CGraphicsContext::ENullBrush);

  2287 	//GA1

  2288 	iBitmap3.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  2289 	iBitmap3.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  2290     iBitmap3.iGc->SetDrawMode(CGraphicsContext::EDrawModePEN);

  2291 	iBitmap3.iGc->SetClippingRegion(iFixedRegionPtr);

  2292 	iBitmap3.iGc->SetBrushColor(color);

  2293 	TRect rect3(iBitmap3.iBitmap->SizeInPixels());

  2294 	iBitmap3.iGc->DrawRect(rect3);

  2295 	iBitmap3.iGc->SetBrushStyle(CGraphicsContext::ENullBrush);

  2297 	//GA2

  2298 	iBitmap4.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  2299 	iBitmap4.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  2300     iBitmap4.iGc->SetDrawMode(CGraphicsContext::EDrawModePEN);

  2301 	iBitmap4.iGc->SetClippingRegion(iFixedRegionPtr);

  2302 	iBitmap4.iGc->SetBrushColor(color);

  2303 	TRect rect4(iBitmap4.iBitmap->SizeInPixels());

  2304 	iBitmap4.iGc->DrawRect(rect4);

  2305 	iBitmap4.iGc->SetBrushStyle(CGraphicsContext::ENullBrush);

  2307 	iBitmap5.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  2308 	iBitmap5.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  2309     iBitmap5.iGc->SetDrawMode(CGraphicsContext::EDrawModePEN);

  2310 	iBitmap5.iGc->SetBrushColor(color);

  2311 	TRect rect5(iBitmap5.iBitmap->SizeInPixels());

  2312 	iBitmap5.iGc->DrawRect(rect5);

  2313 	iBitmap5.iGc->SetBrushStyle(CGraphicsContext::ENullBrush);

  2315 	iBitmap6.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  2316 	iBitmap6.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  2317     iBitmap6.iGc->SetDrawMode(CGraphicsContext::EDrawModePEN);

  2318 	iBitmap6.iGc->SetBrushColor(color);

  2319 	TRect rect6(iBitmap6.iBitmap->SizeInPixels());

  2320 	iBitmap6.iGc->DrawRect(rect6);

  2321 	iBitmap6.iGc->SetBrushStyle(CGraphicsContext::ENullBrush);

  2323 	iBitmap7.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  2324 	iBitmap7.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  2325     iBitmap7.iGc->SetDrawMode(CGraphicsContext::EDrawModePEN);

  2326 	iBitmap7.iGc->SetBrushColor(color);

  2327 	TRect rect7(iBitmap7.iBitmap->SizeInPixels());

  2328 	iBitmap7.iGc->DrawRect(rect7);

  2329 	iBitmap7.iGc->SetBrushStyle(CGraphicsContext::ENullBrush);

  2331 	iBitmap8.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  2332 	iBitmap8.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  2333 	iBitmap8.iGc->SetDrawMode(CGraphicsContext::EDrawModePEN);

  2334 	iBitmap8.iGc->SetBrushColor(color);

  2335 	TRect rect8(iBitmap8.iBitmap->SizeInPixels());

  2336 	iBitmap8.iGc->DrawRect(rect8);

  2337 	iBitmap8.iGc->SetBrushStyle(CGraphicsContext::ENullBrush);

  2338 	}

  2340 void CTAccelerator::TestScreenRotation()

  2341 	{

  2342 	// Checks that clearing a rotated screen doesn't blow-up

  2343 	iScreenGc->SetOrientation(CFbsBitGc::EGraphicsOrientationRotated90);

  2345 	iScreenGc->Reset();

  2346 	// fill screen using graphics accelerator

  2347 	iScreenGc->SetBrushStyle(CFbsBitGc::ESolidBrush);

  2348 	iScreenGc->SetPenStyle(CFbsBitGc::ENullPen);

  2349 	iScreenGc->DrawRect(TRect(0,0,KMaxTInt/2,KMaxTInt/2));

  2351 	// restore orientation

  2352 	iScreenGc->SetOrientation(CFbsBitGc::EGraphicsOrientationNormal);

  2353 	iScreenGc->Reset();

  2354 	}

  2356 void CTAccelerator::TestUserDisplayMode()

  2357 	{

  2358 	iScreenGc->Reset();

  2359 	// Change to Gray4 mode

  2360 	iScreenGc->SetUserDisplayMode(EGray4);

  2361 	// fill screen using graphics accelerator

  2362 	iScreenGc->SetBrushStyle(CFbsBitGc::ESolidBrush);

  2363 	iScreenGc->SetBrushColor(TRgb(0x44,0x44,0x44)); // should get 'rounded up' to 0x55,0x55,0x55 when drawn

  2364 	iScreenGc->SetPenStyle(CFbsBitGc::ENullPen);

  2365 	iScreenGc->DrawRect(TRect(0,0,KMaxTInt/2,KMaxTInt/2));

  2367 	TRgb pixel;

  2368 	iHwScreenDevice->GetPixel(pixel,TPoint(0,0));

  2369 	TRgb checkValue(0x555555,0xff);

  2370 	if (iHwScreenDevice->DisplayMode()==EColor64K)

  2371 		checkValue=TRgb::Color64K(checkValue.Color64K());

  2372 	TEST(pixel==checkValue);  // check pixel color is that of a Gray4 one

  2374 	// Restore user display mode

  2375 	iScreenGc->Reset();

  2376 	}

  2378 static void CheckDisplayMode()

  2379 	{

  2380 	TInt i;

  2381 	for(i=0; i<KNumDisplayModes; ++i)

  2382 		{

  2383 		TDisplayMode mode = TestDisplayModes[i].iMode;

  2384 		CFbsScreenDevice* device = NULL;

  2385 		TInt err = KErrNone;

  2386 		TRAP(err, device = CFbsScreenDevice::NewL(_L("scdv"), mode));

  2387 		if (err == KErrNone)

  2388 			{

  2389 			TestDisplayModes[i].iEnabled = ETrue;

  2390 			delete device;

  2391 			}

  2392 		}

  2393 	}

  2395 //--------------

  2396 __CONSTRUCT_STEP__(Accelerator)

  2398 void CTAcceleratorStep::TestSetupL()

  2399 	{

  2400 	FbsStartup();

  2401 	User::LeaveIfError(RFbsSession::Connect());

  2403 	CheckDisplayMode();

  2404 	}

  2406 void CTAcceleratorStep::TestClose()

  2407 	{

  2408 	RFbsSession::Disconnect();

  2409 	}

author	sl@SLION-WIN7.fritz.box
	Fri, 15 Jun 2012 03:10:57 +0200
changeset 0	bde4ae8d615e
permissions	-rw-r--r--