1 // Copyright (c) 2007-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 //

    15 

    16 /**

    17  @file

    18  @test

    19  @internalComponent - Internal Symbian test code

    20 */

    21 #include "tgc.h"

    22 #include "RemoteGc.h"

    23 #include "CommandBuffer.h"

    24 #ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA

    25 #include "directgdigcwrapper.h"

    26 #include <graphics/directgdidriver.h>

    27 #include <graphics/sgutils.h>

    28 #include <graphics/wsdrawresource.h>

    29 #endif

    30 

    31 #ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA

    32 GLDEF_C void CopyImageToBitmapL(CFbsBitmap* aBitmap, const RSgImage& aImage, const TRect& aRect);

    33 GLDEF_C void CopyImageToDestination(TAny* aDataAddressDest, TInt aDataStrideDest, TDisplayMode aDisplayModeDest, 

    34 				TAny* aDataAddressSrc, TInt aDataStrideSrc, TDisplayMode aDisplayModeSrc, const TRect& aRect);

    35 GLDEF_C void CopyImageToDestination64K(TAny* aDataAddressDest, TInt aDataStrideDest, TDisplayMode aDisplayModeDest, 

    36 		TUint16* aDataAddressSrc, TInt aDataStrideSrc, const TRect& aRect);

    37 

    38 GLDEF_C void CopyImageToBitmapL(CFbsBitmap* aBitmap, const RSgImage& aImage, const TRect& aRect)

    39 	{

    40 	TSgImageInfo info;

    41 	TInt res = aImage.GetInfo(info);

    42 	if(res == KErrNone)

    43 		{

    44 		info.iUsage = ESgUsageNone;

    45 		info.iCpuAccess = ESgCpuAccessReadOnly;

    46 		RSgImage image;

    47 		res = image.Create(info, aImage);

    48 		if(res == KErrNone)

    49 			{	

    50 			const TAny* dataAddressSrc = NULL; 

    51 			TInt dataStrideSrc = 0;

    52 			res = image.MapReadOnly(dataAddressSrc, dataStrideSrc);

    53 			if(res == KErrNone)

    54 				{

    55 				const TDisplayMode displayModeDest = aBitmap->DisplayMode();

    56 				const TDisplayMode displayModeSrc = SgUtils::PixelFormatToDisplayMode(info.iPixelFormat);

    57 				TUint32* dataAddressDest = aBitmap->DataAddress();

    58 				const TInt dataStrideDest = aBitmap -> DataStride();

    59 				TSize bitmapSize = aBitmap->SizeInPixels();

    60 				TRect rect = aRect;

    61 				TRect rectDest = info.iSizeInPixels;

    62 				rect.Intersection(rectDest);

    63 				if(rect.Height() > bitmapSize.iHeight)

    64 					{

    65 					rect.SetHeight(bitmapSize.iHeight);

    66 					}

    67 				if(rect.Width() > bitmapSize.iWidth)

    68 					{

    69 					rect.SetWidth(bitmapSize.iWidth);

    70 					}

    71 				CopyImageToDestination((TAny*)dataAddressDest, dataStrideDest, displayModeDest, (TAny*)dataAddressSrc, 

    72 								dataStrideSrc, displayModeSrc, rect);

    73 

    74 				image.Unmap();

    75 				}

    76 			image.Close();

    77 			}

    78 		}

    79 	}

    80 

    81 GLDEF_C void CopyImageToDestination(TAny* aDataAddressDest, TInt aDataStrideDest, TDisplayMode aDisplayModeDest, 

    82 				TAny* aDataAddressSrc, TInt aDataStrideSrc, TDisplayMode aDisplayModeSrc, const TRect& aRect) 

    83 	{

    84 	if(aRect.IsEmpty())

    85 		return;

    86 	

    87 	if((aDisplayModeDest == aDisplayModeSrc) && (aDataStrideSrc == aDataStrideDest))

    88 		{

    89 		Mem::Copy(aDataAddressDest, aDataAddressSrc, aDataStrideDest * aRect.Height());

    90 		return;

    91 		}

    92 	

    93 	switch(aDisplayModeSrc)

    94 		{

    95 	case EColor64K:

    96 		{

    97 		CopyImageToDestination64K(aDataAddressDest, aDataStrideDest, aDisplayModeDest, 

    98 						(TUint16*)aDataAddressSrc, aDataStrideSrc, aRect);

    99 		break;

   100 		}

   101 	default:

   102 		break;

   103 		}

   104 	}

   105 

   106 GLDEF_C void CopyImageToDestination64K(TAny* aDataAddressDest, TInt aDataStrideDest, TDisplayMode aDisplayModeDest, 

   107 		TUint16* aDataAddressSrc, TInt aDataStrideSrc, const TRect& aRect) 

   108 	{

   109 	const TInt bppSrc = 2;

   110 	const TInt width = aRect.Width();

   111 	const TInt height = aRect.Height();

   112 	const TInt dataStrideLengthSrc = aDataStrideSrc / bppSrc;

   113 	TUint16* dataAddressSrc =  aDataAddressSrc + aRect.iTl.iY * dataStrideLengthSrc + aRect.iTl.iX; 

   114 	const TUint16* dataAddressSrcEnd = dataAddressSrc + dataStrideLengthSrc *  height;  

   115 

   116 	switch(aDisplayModeDest)

   117 		{

   118 	case EColor64K:

   119 		{

   120 		TUint16* dataAddressDest = static_cast<TUint16*> (aDataAddressDest); 

   121 		const TInt dataStrideLengthDest = aDataStrideDest / bppSrc;

   122 		while(dataAddressSrcEnd > dataAddressSrc)

   123 			{

   124 			Mem::Copy(dataAddressDest, dataAddressSrc, width * bppSrc);

   125 			dataAddressSrc += dataStrideLengthSrc;

   126 			dataAddressDest += dataStrideLengthDest;

   127 			}

   128 		break;

   129 		}

   130 	case EColor16MU:

   131 		{

   132 		const TInt bppDest = 4;

   133 		TUint32* dataAddressDest = static_cast<TUint32*> (aDataAddressDest); 

   134 		const TInt dataStrideLengthDest = aDataStrideDest / bppDest;

   135 		

   136 		while(dataAddressSrcEnd > dataAddressSrc)

   137 			{

   138 			const TUint16* dataAddressSrcLineEnd = dataAddressSrc + width;

   139 			TUint32* dataAddressDestCur = dataAddressDest;

   140 			TUint16* dataAddressSrcCur = dataAddressSrc;

   141 

   142 			while(dataAddressSrcLineEnd > dataAddressSrcCur)

   143 				{

   144 				*dataAddressDestCur = TRgb::Color64K(*dataAddressSrcCur).Color16MU();

   145 				dataAddressDestCur++;

   146 				dataAddressSrcCur++;

   147 				}

   148 			dataAddressSrc += dataStrideLengthSrc;

   149 			dataAddressDest += dataStrideLengthDest;

   150 			}

   151 		break;

   152 		}

   153 	case EGray4:

   154 		{

   155 		TUint8* dataAddressDest = static_cast<TUint8*> (aDataAddressDest);

   156 		const TInt dataStrideLengthDest = aDataStrideDest;

   157 		

   158 		while(dataAddressSrcEnd > dataAddressSrc)

   159 			{

   160 			const TUint8* dataAddressDstLineEnd = dataAddressDest + aDataStrideDest;

   161 			TUint8* dataAddressDestCur = dataAddressDest;

   162 			TUint16* dataAddressSrcCur = dataAddressSrc;

   163 

   164 			while(dataAddressDstLineEnd > dataAddressDestCur)

   165 				{

   166 				*dataAddressDestCur = 0;

   167 				for(TInt index = 0; index < 8; index +=2)

   168 					{

   169 					TInt col = TRgb::Color64K(*dataAddressSrcCur).Gray4();

   170 					col <<= index;

   171 					*dataAddressDestCur |= col;

   172 					dataAddressSrcCur++;

   173 					}

   174 				dataAddressDestCur++;

   175 				}

   176 			dataAddressSrc += dataStrideLengthSrc;

   177 			dataAddressDest += dataStrideLengthDest;

   178 			}

   179 		break;

   180 		}

   181 	case EColor256:

   182 		{

   183 		TUint8* dataAddressDest = static_cast<TUint8*> (aDataAddressDest);

   184 		const TInt dataStrideLengthDest = aDataStrideDest;

   185 		

   186 		while(dataAddressSrcEnd > dataAddressSrc)

   187 			{

   188 			const TUint8* dataAddressDstLineEnd = dataAddressDest + aDataStrideDest;

   189 			TUint8* dataAddressDestCur = dataAddressDest;

   190 			TUint16* dataAddressSrcCur = dataAddressSrc;

   191 

   192 			while(dataAddressDstLineEnd > dataAddressDestCur)

   193 				{

   194 				*dataAddressDestCur = TRgb::Color64K(*dataAddressSrcCur).Color256();

   195 				dataAddressSrcCur++;

   196 				dataAddressDestCur++;

   197 				}

   198 			dataAddressSrc += dataStrideLengthSrc;

   199 			dataAddressDest += dataStrideLengthDest;

   200 			}

   201 		break;

   202 		}

   203 	default:

   204 		break;

   205 		}

   206 	}

   207 

   208 TDisplayMode DisplayModeFromPixelFormat(TUidPixelFormat aPixelFormat)

   209 	{

   210 	switch(aPixelFormat)

   211 		{

   212 	case EUidPixelFormatARGB_8888_PRE:

   213 		return EColor16MAP;

   214 	case EUidPixelFormatARGB_8888:

   215 		return EColor16MA;

   216 	case EUidPixelFormatRGB_565:

   217 		return EColor64K;

   218 	default:

   219 		break;

   220 		}

   221 	return ENone;

   222 	}

   223 

   224 TUidPixelFormat PixelFormatFromDisplayMode(TDisplayMode aDisplayMode)

   225 	{

   226 	switch (aDisplayMode)

   227 		{

   228 		case EGray2:

   229 		case EGray4:

   230 		case EGray16:

   231 		case EGray256:

   232 		case EColor16:

   233 		case EColor256:

   234 		case EColor16M:

   235 		case EColor16MU:

   236 			{

   237 			return EUidPixelFormatXRGB_8888;

   238 			}

   239 		case EColor4K:

   240 			{

   241 			return EUidPixelFormatXRGB_4444;

   242 			}

   243 		case EColor64K:

   244 			{

   245 			return EUidPixelFormatRGB_565;

   246 			}

   247 		case EColor16MA:

   248 			{

   249 			return EUidPixelFormatARGB_8888;

   250 			}

   251 		case EColor16MAP:

   252 			{

   253 			return EUidPixelFormatARGB_8888_PRE;

   254 			}

   255 		default:

   256 			{

   257 			return EUidPixelFormatUnknown;

   258 			}

   259 		}

   260 	}

   261 #endif

   262 

   263 CTGc::CTGc(CTestStep* aStep) : CTWsGraphicsBase(aStep)

   264 	{

   265 	}

   266 

   267 CTGc::~CTGc()

   268 	{

   269 	delete iTest;

   270 #ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA

   271 	SgDriver::Close();

   272 	CDirectGdiDriver *directGdiDriver = CDirectGdiDriver::Static();

   273 	if(directGdiDriver)

   274 		{

   275 		directGdiDriver->Close();

   276 		}

   277 #endif

   278 	}

   279 

   280 void CTGc::ConstructL()

   281 	{

   282 	_LIT(KTestName,"GC Test");

   283 	iTest=new(ELeave) CTestBase(KTestName,this);

   284 	

   285 #ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA

   286 	TInt err = CDirectGdiDriver::Open();

   287 	User::LeaveIfError(err);

   288 	err = SgDriver::Open();

   289 	if(err != KErrNone)

   290 		{

   291 		CDirectGdiDriver *directGdiDriver = CDirectGdiDriver::Static();

   292 		if(directGdiDriver)

   293 			{

   294 			directGdiDriver->Close();

   295 			}

   296 		User::Leave(err);

   297 		}

   298 #endif

   299 	}

   300 

   301 //Class derived from MWsGraphicResolver. Used for playing the commands from command buffer

   302 class CWSGraphicsRes: public CBase, public MWsGraphicResolver

   303 	{

   304 public:

   305 	void DrawWsGraphic(TInt /*aId*/, TBool /*aIsUid*/, const TRect& /*aRect*/, const TDesC8& /*aData*/) const

   306 		{

   307 		//Orveriding by giving empty implemention

   308 		}

   309 	};

   310 

   311 #ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA

   312 //

   313 //Class CDrawTextInContextTest

   314 //

   315 

   316 CDrawTextInContextTest::CDrawTextInContextTest(){}

   317 

   318 CDrawTextInContextTest::~CDrawTextInContextTest()

   319 	{

   320 	delete iRefBitmap;

   321 	delete iRefDevice;

   322 	delete iRefBitGc;

   323 	delete iRemoteGc;

   324 	iMsgBuf.Close();

   325 	delete iCommandBuffer;

   326 	delete iWsGraphicRes;

   327 	

   328 	TheClient->iScreen->ReleaseFont(iFont);

   329 

   330 	delete iDirectGdiGcWrapper;

   331 	if(iWrapperImageTarget)

   332 		{

   333 		iWrapperImageTarget->Close();

   334 		}

   335 	delete iWrapperImageTarget;

   336 	iWrapperImage.Close();

   337 	iWrapperImageCollection.Close();

   338 	}

   339 

   340 void CDrawTextInContextTest::BaseConstructL()

   341 	{

   342 	//Initialise font settings

   343 	TFontSpec fsp;

   344 	fsp.iTypeface.iName=_L("Series 60 Sans");

   345 	fsp.iHeight=430;

   346 	User::LeaveIfError(TheClient->iScreen->GetNearestFontToDesignHeightInTwips((CFont*&)iFont,fsp));

   347 	

   348 	//Initialise TTextParameter

   349 	iParam.iStart = 27;

   350 	iParam.iEnd = 60;

   351 	

   352 	//Text to draw

   353 	iText.Set(_L("This text will not be drawnK.,!\"\x00A3$%^&*()_+-=;'#:@~/<>? Latin This text will not be drawn"));

   354 	

   355 	//For reference bitmap

   356 	iRefBitmap = new(ELeave) CFbsBitmap();

   357 	User::LeaveIfError(iRefBitmap->Create(KBitmapSize, EColor64K));

   358 	iRefDevice = CFbsBitmapDevice::NewL(iRefBitmap);

   359 	User::LeaveIfError(iRefDevice->CreateContext(iRefBitGc));

   360 	

   361 	CDirectGdiDriver* theDGdiDriver = CDirectGdiDriver::Static();

   362 	User::LeaveIfNull(theDGdiDriver);

   363 	

   364 	TSgImageInfo info;

   365 	info.iUsage = ESgUsageDirectGdiTarget | ESgUsageDirectGdiSource | ESgUsageCompositionSource;

   366 	info.iSizeInPixels = KBitmapSize;

   367 	info.iPixelFormat = EUidPixelFormatRGB_565;

   368 	

   369 	TInt res = iWrapperImageCollection.Create(info, 1);

   370 	User::LeaveIfError(res);

   371 	res = iWrapperImageCollection.OpenImage(0, iWrapperImage);

   372 	User::LeaveIfError(res);

   373 	iWrapperImageTarget = new (ELeave) RDirectGdiImageTarget(*theDGdiDriver);

   374 	res = iWrapperImageTarget->Create(iWrapperImage);

   375 	User::LeaveIfError(res);

   376 	iDirectGdiGcWrapper = CDirectGdiGcWrapper::NewL(*iWrapperImageTarget);

   377 

   378 	//clean image-----------------

   379 	CDirectGdiGcWrapper* directGdiGcWrapper = CDirectGdiGcWrapper::NewL(*iWrapperImageTarget);

   380 	CleanupStack::PushL(directGdiGcWrapper);

   381 

   382 	directGdiGcWrapper->SetDrawMode(MWsGraphicsContext::EDrawModeWriteAlpha);

   383 	directGdiGcWrapper->SetBrushColor(KRgbWhite);

   384 	directGdiGcWrapper->Clear();

   385 

   386 	CleanupStack::PopAndDestroy(1, directGdiGcWrapper);

   387 	//------------------

   388 	

   389 	//Used to record draw commands

   390 	iRemoteGc = CRemoteGc::NewL(TheClient->iScreen);

   391 	

   392 	//Used to play recorded draw commands

   393 	iCommandBuffer = CCommandBuffer::NewL();

   394 	

   395 	//Dummy class created required for CCommandBuffer::Play

   396 	iWsGraphicRes = new (ELeave) CWSGraphicsRes();

   397 	

   398 	//Offset for CCommandBuffer::Play

   399 	iOffset = TPoint(0,0);

   400 	

   401 	//Result of doing the test

   402 	iHasPassedTest = EFalse;

   403 	}

   404 

   405 void CDrawTextInContextTest::Test()

   406 	{	

   407 	/* Create reference bitmap by drawing using bitgc */

   408 	iRefBitGc->UseFont(iFont);

   409 	DoDrawTextBitGc();

   410 	iRefBitGc->DiscardFont();

   411 	

   412 	/* Drawing using CBitGcWrapper via CRemotGc*/

   413 	

   414 	//Capturing the commands in remote gc

   415 	iRemoteGc->BeginDraw(KBitmapRect);

   416 	iRemoteGc->UseFont(iFont);

   417 	DoDrawTextRemoteGc();

   418 	iRemoteGc->DiscardFont();

   419 	iRemoteGc->EndDraw();

   420 		

   421 	//Externalize the captured commands from remote gc in to a buffer

   422 	iRemoteGc->ExternalizeL(iMsgBuf, ETrue);

   423 

   424 	//Internalize the buffer with captured commands (from CRemoteGC) in to CCommandBuffer

   425 	iCommandBuffer->InternalizeL(iMsgBuf.Pckg());

   426 	

   427 	//Play the commands on test window using command buffer

   428 	iCommandBuffer->Play(iOffset,&KBitmapRegion,KBitmapRect,*iWsGraphicRes,*iDirectGdiGcWrapper);

   429 	

   430 	//Test to see if the bitmap drawn to using CRemoteGc is the same as the reference bitmap

   431 	CFbsBitmap* bitmap = new (ELeave) CFbsBitmap;

   432 	CleanupStack::PushL(bitmap);

   433 	

   434 	TSgImageInfo info;

   435 	iWrapperImage.GetInfo(info);

   436 	TDisplayMode displayMode = DisplayModeFromPixelFormat(info.iPixelFormat);

   437 	bitmap->Create(info.iSizeInPixels, displayMode);

   438 	TRect rect(info.iSizeInPixels);

   439 	CopyImageToBitmapL(bitmap, iWrapperImage, rect);

   440 	

   441 	iHasPassedTest = LossyCompareBitmap(*iRefBitmap, *bitmap, KBitmapRect, EFalse);

   442 

   443 	CleanupStack::PopAndDestroy(bitmap);

   444 	}

   445 

   446 TBool CDrawTextInContextTest::HasPassedTest()

   447 	{

   448 	return iHasPassedTest;

   449 	}

   450 

   451 //

   452 // Class DrawTextInContextTestPoint

   453 //

   454 

   455 CDrawTextInContextTestPoint::CDrawTextInContextTestPoint(){}

   456 

   457 CDrawTextInContextTestPoint::~CDrawTextInContextTestPoint(){}

   458 

   459 CDrawTextInContextTestPoint* CDrawTextInContextTestPoint::NewL()

   460 	{

   461 	CDrawTextInContextTestPoint* self = new(ELeave) CDrawTextInContextTestPoint;

   462 	CleanupStack::PushL(self);

   463 	self->ConstructL();

   464 	CleanupStack::Pop(self);

   465 	return self;

   466 	}

   467 

   468 void CDrawTextInContextTestPoint::ConstructL()

   469 	{

   470 	BaseConstructL();

   471 	iPosition = TPoint(0,0);

   472 	}

   473 

   474 void CDrawTextInContextTestPoint::DoDrawTextBitGc()

   475 	{

   476 	iRefBitGc->DrawText(iText,&iParam,iPosition);

   477 	}

   478 

   479 void CDrawTextInContextTestPoint::DoDrawTextRemoteGc()

   480 	{

   481 	iRemoteGc->DrawText(iText,&iParam,iPosition);

   482 	}

   483 

   484 //

   485 // Class DrawTextInContextTestBox

   486 //

   487 

   488 CDrawTextInContextTestBox::CDrawTextInContextTestBox(){}

   489 

   490 CDrawTextInContextTestBox::~CDrawTextInContextTestBox(){}

   491 

   492 CDrawTextInContextTestBox* CDrawTextInContextTestBox::NewL()

   493 	{

   494 	CDrawTextInContextTestBox* self = new(ELeave) CDrawTextInContextTestBox;

   495 	CleanupStack::PushL(self);

   496 	self->ConstructL();

   497 	CleanupStack::Pop(self);

   498 	return self;

   499 	}

   500 

   501 void CDrawTextInContextTestBox::ConstructL()

   502 	{

   503 	BaseConstructL();

   504 	iClipFillRect = TRect(10,50,640,120);

   505 	iBaselineOffset = 40;

   506 	iTTextAlign = CGraphicsContext::ELeft;

   507 	}

   508 

   509 void CDrawTextInContextTestBox::DoDrawTextBitGc()

   510 	{

   511 	iRefBitGc->DrawText(iText,&iParam,iClipFillRect,iBaselineOffset,iTTextAlign);

   512 	}

   513 

   514 void CDrawTextInContextTestBox::DoDrawTextRemoteGc()

   515 	{

   516 	iRemoteGc->DrawText(iText,&iParam,iClipFillRect,iBaselineOffset,iTTextAlign);

   517 	}

   518 

   519 //

   520 // Class CDrawTextInContextTestPointVertical

   521 //

   522 

   523 CDrawTextInContextTestPointVertical::CDrawTextInContextTestPointVertical(){}

   524 

   525 CDrawTextInContextTestPointVertical::~CDrawTextInContextTestPointVertical(){}

   526 

   527 CDrawTextInContextTestPointVertical* CDrawTextInContextTestPointVertical::NewL()

   528 	{

   529 	CDrawTextInContextTestPointVertical* self = new(ELeave) CDrawTextInContextTestPointVertical;

   530 	CleanupStack::PushL(self);

   531 	self->ConstructL();

   532 	CleanupStack::Pop(self);

   533 	return self;

   534 	}

   535 

   536 void CDrawTextInContextTestPointVertical::ConstructL()

   537 	{

   538 	BaseConstructL();

   539 	iPosition = TPoint(0,0);

   540 	iUp = EFalse;

   541 	}

   542 

   543 void CDrawTextInContextTestPointVertical::DoDrawTextBitGc()

   544 	{

   545 	iRefBitGc->DrawTextVertical(iText,&iParam,iPosition,iUp);

   546 	}

   547 

   548 void CDrawTextInContextTestPointVertical::DoDrawTextRemoteGc()

   549 	{

   550 	iRemoteGc->DrawTextVertical(iText,&iParam,iPosition,iUp);

   551 	}

   552 

   553 //

   554 // Class CDrawTextInContextTestBoxVertical

   555 //

   556 

   557 CDrawTextInContextTestBoxVertical::CDrawTextInContextTestBoxVertical(){}

   558 

   559 CDrawTextInContextTestBoxVertical::~CDrawTextInContextTestBoxVertical(){}

   560 

   561 CDrawTextInContextTestBoxVertical* CDrawTextInContextTestBoxVertical::NewL()

   562 	{

   563 	CDrawTextInContextTestBoxVertical* self = new(ELeave) CDrawTextInContextTestBoxVertical;

   564 	CleanupStack::PushL(self);

   565 	self->ConstructL();

   566 	CleanupStack::Pop(self);

   567 	return self;

   568 	}

   569 

   570 void CDrawTextInContextTestBoxVertical::ConstructL()

   571 	{

   572 	BaseConstructL();

   573 	iClipFillRect = TRect(10,50,640,120);

   574 	iBaselineOffset = 40;

   575 	iUp = EFalse;

   576 	iTTextAlign = CGraphicsContext::ELeft;

   577 	}

   578 

   579 void CDrawTextInContextTestBoxVertical::DoDrawTextBitGc()

   580 	{

   581 	iRefBitGc->DrawTextVertical(iText,&iParam,iClipFillRect,iBaselineOffset,iUp,iTTextAlign);

   582 	}

   583 

   584 void CDrawTextInContextTestBoxVertical::DoDrawTextRemoteGc()

   585 	{

   586 	iRemoteGc->DrawTextVertical(iText,&iParam,iClipFillRect,iBaselineOffset,iUp,iTTextAlign);

   587 	}

   588 #endif //TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA

   589 

   590 void CleanUpFont(TAny* aFont)

   591 	{

   592 	//Will be called in case of a leave to release the font

   593 	CFont* font= static_cast<CFont*>(aFont);

   594 	TheClient->iScreen->ReleaseFont(font);

   595 	}

   596 

   597 /**

   598 @SYMTestCaseID		GRAPHICS-WSERV-0437

   599 @SYMPREQ            PREQ1543

   600 @SYMTestCaseDesc    Draw text using CWindowGc and CRemoteGc with both outline and shadow

   601 effect on.

   602 @SYMTestPriority    High

   603 @SYMTestStatus      Implemented

   604 @SYMTestActions     Create a font with both outline and shadow effects. Record the commands 

   605 (like setting colours,drawing text etc) using CRemoteGc and play the recorded commands on a window. Use the same

   606 commands in CWindowGc and draw text on a different window

   607 @SYMTestExpectedResults Text drawn using CWindowGc and CRemoteGc should be same

   608 */

   609 void CTGc::TestOutlineAndShadowL()

   610 	{

   611 	TRect sourceRect(0, 0, TestWin->Size().iWidth, TestWin->Size().iHeight);

   612 	TRegionFix<1> clippingRegion(sourceRect);

   613 	

   614 	CWsScreenDevice* device = TheClient->iScreen;

   615 

   616 	_LIT(KText,"Outline and shadow");

   617 	TFontSpec fSpec(KTestFontTypefaceName,23);

   618 	fSpec.iFontStyle.SetBitmapType(EAntiAliasedGlyphBitmap);

   619 	fSpec.iFontStyle.SetEffects(FontEffect::EDropShadow, ETrue);

   620 	fSpec.iFontStyle.SetEffects(FontEffect::EOutline, ETrue);

   621 	

   622 	CFont *font;

   623 	User::LeaveIfError(TheClient->iScreen->GetNearestFontToDesignHeightInPixels((CFont *&)font, fSpec));

   624 	CleanupStack::PushL(TCleanupItem(CleanUpFont, font));

   625 	

   626 	CRemoteGc* remoteGc = CRemoteGc::NewL(device);

   627 	CleanupStack::PushL(remoteGc);

   628 	remoteGc->BeginDraw(sourceRect);

   629 	//Capturing the commands in remote gc

   630 	remoteGc->SetBrushColor(KRgbGreen);

   631 	remoteGc->SetShadowColor(KRgbDarkRed);

   632 	remoteGc->SetPenColor(KRgbBlack);

   633 	remoteGc->UseFont(font);

   634 	remoteGc->DrawText(KText, TPoint(2,40));

   635 	remoteGc->DiscardFont();

   636 	remoteGc->EndDraw();

   637 

   638 	RWsGraphicMsgBuf msgBuf;

   639 	CleanupClosePushL(msgBuf);

   640 	//Externalize the captured commands from remote gc in to a buffer

   641 	remoteGc->ExternalizeL(msgBuf, ETrue);

   642 

   643 	CWSGraphicsRes* wsGrap = new (ELeave) CWSGraphicsRes();

   644 	CleanupStack::PushL(wsGrap);

   645 	

   646 	CCommandBuffer* cmdBuf = CCommandBuffer::NewL();

   647 	CleanupStack::PushL(cmdBuf);

   648 	//Internalize the buffer with captured commands (from CRemoteGC) 

   649 	//in to CCommandBuffer

   650 	cmdBuf->InternalizeL(msgBuf.Pckg());

   651 	

   652 	TestWin->Win()->Invalidate();

   653 	TestWin->Win()->BeginRedraw();

   654 	TheGc->Activate(*TestWin->Win());

   655 	TheGc->Clear();

   656 	//Play the commands on test window using command buffer

   657 #ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA

   658 	cmdBuf->Play(TPoint(0, 0), &clippingRegion, sourceRect, TheClient->iWs, *TheGc);

   659 #else

   660 	cmdBuf->Play(TPoint(),TRect(TestWin->Size()),*wsGrap,*TheGc);

   661 #endif

   662 	TheGc->Deactivate();

   663 	TestWin->Win()->EndRedraw();

   664 	

   665 	BaseWin->Win()->Invalidate();

   666 	BaseWin->Win()->BeginRedraw();

   667 	TheGc->Activate(*BaseWin->Win());

   668 	TheGc->Clear();

   669 	TheGc->SetBrushColor(KRgbGreen);

   670 	TheGc->SetShadowColor(KRgbDarkRed);

   671 	TheGc->SetPenColor(KRgbBlack);

   672 	TheGc->UseFont(font);

   673 	//Draw the text on base window using CWindowGC

   674 	TheGc->DrawText(KText, TPoint(2, 40));

   675 	TheGc->DiscardFont();

   676 	TheGc->Deactivate();

   677 	BaseWin->Win()->EndRedraw();

   678 	TheClient->iWs.Finish();

   679 	TheClient->WaitForRedrawsToFinish();

   680 

   681 	//Check the text drawn on base and test windows.

   682 	CheckRect(BaseWin, TestWin, TRect(0, 0, BaseWin->Size().iWidth, BaseWin->Size().iHeight), _L("CTGc::TestOutlineAndShadowL()"));

   683 

   684 	CleanupStack::PopAndDestroy(4, remoteGc); //cmdBuf, wsGrap, msgBuf and remoteGc

   685 	CleanupStack::Pop();//font

   686 	TheClient->iScreen->ReleaseFont(font);

   687 	}

   688 

   689 void CTGc::TestGcClipRectOrigin_DrawContent(TestWindow& aWindow, TBool bActivateBeforeRedraw /*= ETrue*/)

   690 	{

   691 	TSize winSize = aWindow.Size();

   692 	TPoint gcOrigin(winSize.iWidth >> 3, winSize.iWidth >> 3);

   693 	TRect gcClipRect(0, 0, (winSize.iWidth * 3) >> 2, (winSize.iHeight * 3) >> 2);

   694 	TRect ellipseRect(gcClipRect);

   695 	// Shrink the ellipse for better visibility and to fit well within the clip area.

   696 	ellipseRect.Shrink(3, 3);

   697 	TSize penSize(1, 1);

   698 

   699 	aWindow.Win()->SetBackgroundColor(KRgbGreen);

   700 	aWindow.ClearWin();

   701 	aWindow.Win()->Invalidate();

   702 

   703 	if(!bActivateBeforeRedraw)

   704 		{

   705 		aWindow.Win()->BeginRedraw();

   706 		}

   707 

   708 	TheGc->Activate(*(aWindow.Win()));

   709 	TheGc->SetOrigin(gcOrigin);

   710 	TheGc->SetClippingRect(gcClipRect);

   711 

   712 	if(bActivateBeforeRedraw)

   713 		{

   714 		aWindow.Win()->BeginRedraw();

   715 		}

   716 

   717 	TheGc->SetBrushColor(KRgbDarkRed);

   718 	TheGc->SetPenColor(KRgbDarkRed);

   719 	TheGc->SetPenSize(penSize);

   720 	TheGc->SetPenStyle(CGraphicsContext::ESolidPen);

   721 	TheGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

   722 	TheGc->DrawEllipse(ellipseRect);

   723 	TheGc->SetBrushStyle(CGraphicsContext::ENullBrush);

   724 	TheGc->SetPenColor(KRgbYellow);

   725 	TheGc->SetPenStyle(CGraphicsContext::EDashedPen);

   726 	TheGc->DrawRect(gcClipRect);

   727 

   728 	aWindow.Win()->EndRedraw();

   729 	TheGc->Deactivate();

   730 	}

   731 

   732 /**

   733 @SYMTestCaseID		GRAPHICS-WSERV-0471

   734 @SYMTestCaseDesc    This test is to verify that the GC correctly applies the clip rect and

   735 					origin attributes irrespective of whether the GC is activated on the

   736 					window before or after the BeginRedraw.

   737 @SYMDEF				PDEF120091

   738 @SYMTestPriority    High

   739 @SYMTestStatus      Implemented

   740 @SYMTestActions     The test has following steps:

   741 	1. For the Test window follow the steps:

   742 		A. Activate the GC on Test window.

   743 		B. Set the Origin of the GC to centre of the window.

   744 		C. Set the Clipping rectangle of the GC to half the size of the window.

   745 		D. In the BeginDraw and EndDraw call bracket perform the following:

   746 			a. Draw an ellipse with the rectangle smaller by 5 pixels than the clip rectangle.

   747 			b. Draw a rectangle that is size of the clip rectangle.

   748 		E. Deactivate the GC. 

   749 	2. For the Base window follow the steps:

   750 		A. In the BeginDraw and EndDraw call bracket perform the following:

   751 			a. Activate the GC on Base window.

   752 			b. Set the Origin of the GC to centre of the window.

   753 			c. Set the Clipping rectangle of the GC to half the size of the window.

   754 			d. Draw an ellipse with the rectangle smaller by 5 pixels than the clip rectangle.

   755 			e. Draw a rectangle that is size of the clip rectangle.

   756 			f. Deactivate the GC. 

   757 	3. Compare Test and Base window.

   758 @SYMTestExpectedResults Both the Test and Base window should have the complete

   759 						non-clipped ellipse completely encapsulated within the rectangle. 

   760 */

   761 void CTGc::TestGcClipRectOrigin()

   762 	{

   763 	TestGcClipRectOrigin_DrawContent(*BaseWin, EFalse);

   764 	TestGcClipRectOrigin_DrawContent(*TestWin, ETrue);

   765 	

   766 	TheClient->Flush();

   767 	

   768 	CheckRect(BaseWin, TestWin, TRect(0, 0, BaseWin->Size().iWidth, BaseWin->Size().iHeight), _L("CTGc::TestGcClipRectOriginL()"));

   769 	}

   770 

   771 /**

   772 @SYMTestCaseID		GRAPHICS-WSERV-0469

   773 @SYMDEF             INC116406

   774 @SYMTestCaseDesc    Try playback on MWsGraphicsContext and CWindowGc to check that the background colour is

   775 set correctly.

   776 @SYMTestPriority    High

   777 @SYMTestStatus      Implemented

   778 @SYMTestActions

   779 @SYMTestExpectedResults Text drawn using CWindowGc should use the background colour of

   780 the window, and MWsGraphicsContext should use transparent white.

   781 */

   782 void CTGc::TestResetWithBackgroundColorL()

   783 	{

   784 	const TRect KSourceRect(0, 0, TestWin->Size().iWidth, TestWin->Size().iHeight);

   785 	const TRegionFix<1> KClippingRegion(KSourceRect);

   786 	

   787 	CWsScreenDevice* device = TheClient->iScreen;

   788 

   789 	CRemoteGc* remoteGc = CRemoteGc::NewL(device);

   790 	CleanupStack::PushL(remoteGc);

   791 	

   792 	//note this remote GC has not been activated on any window

   793 	remoteGc->BeginDraw(KSourceRect);

   794 

   795 	//Draw the commands in remote gc

   796 	remoteGc->SetBrushColor(KRgbGreen);  //nothing green is seen in this test

   797 

   798 	remoteGc->Reset(); //This resets the brush colour to the background colour of the window

   799 					   //where playback is, in the case of playing back to a window

   800 					   //however with a CFbsBitGc the color is transparent white, as there is no window.

   801 	remoteGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

   802 	remoteGc->SetDrawMode(CGraphicsContext::EDrawModeWriteAlpha);

   803 	remoteGc->DrawRect(KSourceRect);

   804 	remoteGc->EndDraw();

   805 

   806 #ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA

   807 	CDirectGdiDriver* theDGdiDriver = CDirectGdiDriver::Static();

   808 	User::LeaveIfNull(theDGdiDriver);

   809 	

   810 	TSgImageInfo info;

   811 	info.iUsage = ESgUsageDirectGdiTarget | ESgUsageCompositionSource;

   812 	info.iSizeInPixels = TSize(TestWin->Size().iWidth, TestWin->Size().iHeight);

   813 	info.iPixelFormat = EUidPixelFormatXRGB_8888;//among display modes with alpha channel only pre-multiply alpha is supported in directGDI currently

   814 	

   815 	RSgImageCollection imageCollection;

   816 	CleanupClosePushL(imageCollection);

   817 	TInt res = imageCollection.Create(info, 1);

   818 	User::LeaveIfError(res);

   819 	RSgImage image;

   820 	CleanupClosePushL(image);

   821 	res = imageCollection.OpenImage(0, image);

   822 	User::LeaveIfError(res);

   823 	RDirectGdiImageTarget imageTarget(*theDGdiDriver);

   824 	CleanupClosePushL(imageTarget);

   825 	res = imageTarget.Create(image);

   826 	User::LeaveIfError(res);

   827 #endif

   828 #ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA

   829 	//create a bitmap

   830 	CFbsBitmap *bitmap = new (ELeave) CFbsBitmap();

   831 	User::LeaveIfError(bitmap->Create(TSize(TestWin->Size().iWidth, TestWin->Size().iHeight), EColor16MA));

   832 	CleanupStack::PushL(bitmap);

   833 

   834 	CFbsBitmapDevice  *fbsDevice = CFbsBitmapDevice::NewL(bitmap);

   835 	CleanupStack::PushL(fbsDevice);

   836 #endif

   837 

   838 	//prepare the command buffer for playback

   839 	RWsGraphicMsgBuf msgBuf;

   840 	CleanupClosePushL(msgBuf);

   841 

   842 	//Externalize the captured commands from remote gc in to a buffer

   843 	remoteGc->ExternalizeL(msgBuf, ETrue);

   844 

   845 	CWSGraphicsRes* wsGrap = new (ELeave) CWSGraphicsRes();

   846 	CleanupStack::PushL(wsGrap);

   847 

   848 	CCommandBuffer* cmdBuf = CCommandBuffer::NewL();

   849 	CleanupStack::PushL(cmdBuf);

   850 	cmdBuf->InternalizeL(msgBuf.Pckg());

   851 

   852 	TRgb color;

   853 	TRgb testColor(KRgbWhite);

   854 #ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA

   855 	CDirectGdiGcWrapper* directGdiGcWrapper=CDirectGdiGcWrapper::NewL(imageTarget);

   856 	CleanupStack::PushL(directGdiGcWrapper);

   857 	cmdBuf->Play(TPoint(),&KClippingRegion,KSourceRect,*wsGrap,*directGdiGcWrapper);

   858 

   859 	//check that the background has been cleared to transparent white.

   860 	image.GetInfo(info);

   861 	info.iUsage = ESgUsageNone;

   862 	info.iCpuAccess = ESgCpuAccessReadOnly;

   863 	RSgImage image1;

   864 	CleanupClosePushL(image1);

   865 	res = image1.Create(info, image);

   866 	const TAny* data;

   867 	TInt stride = 0;

   868 	res = image1.MapReadOnly(data, stride);

   869 	User::LeaveIfError(res);

   870 	TPoint pixel(10,10);

   871 	TInt offset = pixel.iY * stride + pixel.iX * 4;

   872 	TAny* non_const_data = const_cast <TAny*> (data);

   873 	TUint8* pointData = static_cast <TUint8*> (non_const_data) + offset;

   874 	color = *(reinterpret_cast <TRgb*> (pointData));

   875 	image1.Unmap();

   876 #endif

   877 #ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA

   878 	CFbsBitGc* fbsBitGc=NULL;

   879 	User::LeaveIfError(fbsDevice->CreateContext(fbsBitGc));

   880 	CleanupStack::PushL(fbsBitGc);

   881 	fbsBitGc->Activate(fbsDevice);

   882 	cmdBuf->Play(TPoint(0, 0), KSourceRect, *wsGrap, *fbsBitGc);

   883 	bitmap->GetPixel(color, TPoint(10,10));

   884 	testColor.SetAlpha(0);

   885 #endif

   886 	iStep->TEST(color==testColor);

   887 

   888 	//now test drawing to a window to ensure that the brush colour is

   889 	//the window background colour

   890 

   891 	//display a blue window

   892 	BaseWin->Win()->SetBackgroundColor(KRgbBlue);

   893 	BaseWin->Win()->Invalidate();

   894 	BaseWin->Win()->BeginRedraw();

   895 	TheGc->Activate(*BaseWin->Win());

   896 	TheGc->Clear();

   897 	TheGc->Deactivate();

   898 	BaseWin->Win()->EndRedraw();

   899 	TheClient->iWs.Finish();

   900 	TheClient->WaitForRedrawsToFinish();

   901 

   902 	//start drawing the display commands with a green background

   903 	

   904 	BaseWin->Win()->SetBackgroundColor(KRgbYellow);

   905 	BaseWin->Win()->Invalidate();

   906 	BaseWin->Win()->BeginRedraw();

   907 	TheGc->Activate(*BaseWin->Win());

   908 

   909 	//Play the commands on test window using command buffer

   910 #ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA

   911 	cmdBuf->Play(TPoint(0, 0), &KClippingRegion, KSourceRect, TheClient->iWs, *TheGc);

   912 #else

   913 	cmdBuf->Play(TPoint(0, 0), KSourceRect, *wsGrap, *TheGc);

   914 #endif

   915 

   916 	TheGc->Deactivate();

   917 	BaseWin->Win()->EndRedraw();

   918 	TheClient->iWs.Finish();

   919 	TheClient->WaitForRedrawsToFinish();

   920 

   921 	//check that the background has been cleared to yellow, using brush colour

   922 	TPoint position = BaseWin->Win()->InquireOffset(*TheClient->iGroup->WinTreeNode());

   923 	position.iX+=10;

   924 	position.iY+=10;

   925 	TheClient->iScreen->GetPixel(color, position);

   926 	iStep->TEST(color==KRgbYellow);

   927 

   928 	BaseWin->Win()->SetBackgroundColor(KRgbGreen); //set back to original backgroundcolor

   929 

   930 #ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA

   931 	CleanupStack::PopAndDestroy(9, remoteGc);

   932 #else

   933 	CleanupStack::PopAndDestroy(7, remoteGc);

   934 #endif

   935 	}

   936 

   937 /**

   938 @SYMTestCaseID		GRAPHICS-WSERV-0481

   939 @SYMPREQ            1841

   940 @SYMTestCaseDesc    Create font and graphics with various effect effects. Record the commands 

   941 (like setting colours,drawing text etc) using CRemoteGc and play the recorded commands on a window. Use the same

   942 commands in CWindowGc and draw text on a different window

   943 @SYMTestPriority    Medium

   944 @SYMTestStatus      Implemented

   945 @SYMTestActions

   946 @SYMTestExpectedResults Text/graphics drawn using CWindowGc and CRemoteGc should be same

   947 */

   948 void CTGc::TestCommandBufferL()

   949 	{	

   950 	CWsScreenDevice* device = TheClient->iScreen;

   951 

   952 	_LIT(KBuffText,"Command Buffer");

   953 	TFontSpec fSpec(KTestFontTypefaceName,23);

   954 	fSpec.iFontStyle.SetBitmapType(EAntiAliasedGlyphBitmap);

   955 	fSpec.iFontStyle.SetEffects(FontEffect::EDropShadow, ETrue);

   956 	fSpec.iFontStyle.SetEffects(FontEffect::EOutline, ETrue);

   957 	

   958 	CFont *font;

   959 	User::LeaveIfError(TheClient->iScreen->GetNearestFontToDesignHeightInPixels((CFont *&)font, fSpec));

   960 	CleanupStack::PushL(TCleanupItem(CleanUpFont, font));

   961 	

   962 	CRemoteGc* remoteGc = CRemoteGc::NewL(device);

   963 	CleanupStack::PushL(remoteGc);	

   964 

   965 #ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA

   966 	//-------create image---------

   967 	CDirectGdiDriver* theDGdiDriver = CDirectGdiDriver::Static();

   968 	User::LeaveIfNull(theDGdiDriver);

   969 	const TSize KImageSize = TSize(2, 2);

   970 	TSgImageInfo info;

   971 	info.iUsage = ESgUsageWindowGcSource;

   972 	info.iSizeInPixels = KImageSize;

   973 	info.iPixelFormat = EUidPixelFormatRGB_565;

   974 	info.iShareable = ETrue;

   975 	const TInt stride = KImageSize.iWidth * 2;

   976 	TUint8* buf = (TUint8*) (User::AllocL(KImageSize.iHeight * stride));

   977 	CleanupStack::PushL(buf);

   978 	TUint16* bufCur = ((TUint16*)buf);

   979 	*bufCur = KRgbRed.Color64K();

   980 	*(bufCur + 1) = KRgbRed.Color64K();

   981 	*(bufCur + 2) = KRgbRed.Color64K();

   982 	*(bufCur + 3) = KRgbRed.Color64K();

   983 

   984 	RSgImage image;

   985 	TInt res = image.Create(info, buf, stride);

   986 	User::LeaveIfError(res);

   987 	CleanupClosePushL(image);	

   988 	RWsDrawableSource drawableSource(TheClient->iWs);

   989 	res = drawableSource.Create(image, TheClient->iScreen->GetScreenNumber());

   990 	if(res == KErrNotSupported)

   991 		{

   992 		INFO_PRINTF1(_L("The current screen is not supports drawable source. This test case terminates now."));

   993 		CleanupStack::PopAndDestroy(3, remoteGc);

   994 		CleanupStack::Pop();//font

   995 		TheClient->iScreen->ReleaseFont(font);

   996 		return;

   997 		}

   998 	User::LeaveIfError(res);

   999 	CleanupClosePushL(drawableSource);	

  1000 	//-------end create image---------

  1001 #endif	

  1002 	remoteGc->ResetCommandBuffer();

  1003 	remoteGc->BeginDraw(TRect(0, 0, TestWin->Size().iWidth, TestWin->Size().iHeight));

  1004 	//Capturing the commands in remote gc

  1005 	remoteGc->Clear();

  1006 	remoteGc->DrawRect(TRect(10,10,30,30));

  1007 	remoteGc->Clear(TRect(10,10,11,11));

  1008 	remoteGc->CopyRect(TPoint(5,5), TRect(25,25,30,30));

  1009 	CFbsBitmap* bitmap = new (ELeave) CFbsBitmap;

  1010 	CFbsBitmap* bitmapMask = new (ELeave) CFbsBitmap;

  1011 	User::LeaveIfError(bitmap->Load(_L("Z:\\WSTEST\\WSAUTOTEST.MBM"), EMbmWsautotestCircles24b));

  1012 	User::LeaveIfError(bitmapMask->Load(_L("Z:\\WSTEST\\WSAUTOTEST.MBM"), EMbmWsautotestCircles_mask2b));

  1013 	remoteGc->BitBlt(TPoint(100,100), bitmap);

  1014 	remoteGc->BitBlt(TPoint(0,0), bitmap, TRect(0,0,1,1));	

  1015 	remoteGc->BitBltMasked(TPoint(0,5), bitmap, TRect(0,0,1,1), bitmapMask, EFalse);

  1016 	CWsBitmap* bitmapWs = new (ELeave) CWsBitmap(TheClient->iWs);

  1017 	CWsBitmap* bitmapWsMask = new (ELeave) CWsBitmap(TheClient->iWs);

  1018 	User::LeaveIfError(bitmapWs->Load(_L("Z:\\WSTEST\\TEST.MBM"), 0));

  1019 	remoteGc->BitBlt(TPoint(110,110), bitmapWs);

  1020 	remoteGc->BitBlt(TPoint(5,0), bitmapWs, TRect(0,0,1,1));

  1021 	remoteGc->BitBltMasked(TPoint(10,0), bitmap, TRect(0,0,1,1), bitmapWsMask, EFalse);

  1022 	remoteGc->SetFadingParameters(128,128);

  1023 	remoteGc->SetFaded(EFalse);	

  1024 	remoteGc->AlphaBlendBitmaps(TPoint(2,2), bitmap, TRect(0,0,1,1), bitmapMask, TPoint(2,2));

  1025 	remoteGc->AlphaBlendBitmaps(TPoint(3,3), bitmapWs, TRect(0,0,1,1), bitmapWsMask, TPoint(2,2));

  1026 	remoteGc->SetOrigin(TPoint(0,30));

  1027 	remoteGc->SetDrawMode(CGraphicsContext::EDrawModePEN);

  1028 	remoteGc->SetClippingRect(TRect(0,0,10,10));

  1029 	remoteGc->SetPenStyle(CGraphicsContext::ESolidPen);

  1030 	remoteGc->SetPenSize(TSize(1,2));

  1031 	remoteGc->UseBrushPattern(bitmap);

  1032 	remoteGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  1033 	remoteGc->SetBrushOrigin(TPoint(0,0));

  1034 	remoteGc->DrawPie(TRect(0,0,15,15),TPoint(0,8),TPoint(15,8));

  1035 	remoteGc->CancelClippingRect();

  1036 	remoteGc->DiscardBrushPattern();

  1037 	remoteGc->CancelClippingRegion();

  1038 	remoteGc->Reset();

  1039 	remoteGc->SetOrigin(TPoint(0,0));

  1040 	remoteGc->SetUnderlineStyle(EUnderlineOff);

  1041 	remoteGc->SetStrikethroughStyle(EStrikethroughOff);

  1042 	remoteGc->SetWordJustification(1,2);

  1043 	remoteGc->SetCharJustification(1,2);

  1044 	remoteGc->UseFont(font);

  1045 	remoteGc->DrawText(KBuffText,TRect(50,0,100,50),10,CGraphicsContext::ELeft,0);

  1046 	remoteGc->DrawTextVertical(KBuffText,TPoint(170,20),EFalse);

  1047 	remoteGc->DrawTextVertical(KBuffText,TRect(120,20,150,100),5,EFalse,CGraphicsContext::ELeft,0);	

  1048 	remoteGc->MoveTo(TPoint(25,150));

  1049 	remoteGc->MoveBy(TPoint(5,5));

  1050 	remoteGc->DrawLineTo(TPoint(35,160));

  1051 	remoteGc->DrawLine(TPoint(35,160),TPoint(25,150));

  1052 	remoteGc->DrawLineBy(TPoint(15,6));	

  1053 	remoteGc->Plot(TPoint(5,5));	

  1054 	remoteGc->DrawArc(TRect(0,80,10,90),TPoint(0,85),TPoint(10,85));

  1055 	remoteGc->DrawEllipse(TRect(0,90,10,100));	

  1056 	remoteGc->DrawRoundRect(TRect(30,80,50,100),TSize(5,5));	

  1057 	remoteGc->DrawBitmap(TPoint(150,150),bitmap);	

  1058 	remoteGc->DrawBitmap(TRect(160,160,170,170), bitmap);	

  1059 	remoteGc->DrawBitmap(TRect(175,175,180,180), bitmap, TRect(0,5,5,10));	

  1060 	remoteGc->DrawBitmapMasked(TRect(185,185,190,190), bitmap, TRect(0,50,5,55),bitmapMask,EFalse);

  1061 	remoteGc->DrawBitmapMasked(TRect(195,195,200,200), bitmapWs, TRect(0,50,5,55),bitmapWsMask,EFalse);		

  1062 	CArrayFixFlat<TPoint>* polyPoints = new(ELeave) CArrayFixFlat<TPoint>(3); //CArrayFixFlat

  1063 	CleanupStack::PushL(polyPoints);

  1064 	TRect rect (200,0,200,100);

  1065 	polyPoints->AppendL(rect.iTl);

  1066 	polyPoints->AppendL(rect.Center());

  1067 	polyPoints->AppendL(TPoint(rect.iBr.iX, rect.iTl.iY));	

  1068 	remoteGc->DrawPolyLine(polyPoints);

  1069 	remoteGc->DrawPolyLine(&polyPoints->At(0), 3);

  1070 	remoteGc->DrawPolygon(polyPoints, CGraphicsContext::EWinding);

  1071 	remoteGc->DrawPolygon(&polyPoints->At(0), 3, CGraphicsContext::EAlternate);

  1072 #ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA

  1073 	MWsDrawResource* dr = static_cast<MWsDrawResource*>(remoteGc->Interface(KMWsDrawResourceInterfaceUid));

  1074 	if(dr)

  1075 		dr->DrawResource(TPoint(30, 40), drawableSource);

  1076 #endif

  1077 	RRegion region;

  1078 	remoteGc->SetClippingRegion(region);

  1079 	remoteGc->DiscardFont();

  1080 	remoteGc->EndDraw();

  1081 

  1082 	RWsGraphicMsgBuf msgBuf;

  1083 	CleanupClosePushL(msgBuf);

  1084 	//Externalize the captured commands from remote gc in to a buffer

  1085 	remoteGc->ExternalizeL(msgBuf, EFalse);

  1086 	

  1087 	CCommandBuffer* cmdBuf = CCommandBuffer::NewL();

  1088 	CleanupStack::PushL(cmdBuf);

  1089 	const CCommandBuffer* testCmdBuf = CCommandBuffer::NewL();

  1090 	if(cmdBuf->IsIdentical(*testCmdBuf)==EFalse)

  1091 		{

  1092 		User::Panic(_L("TestCommandBufferL"), KErrGeneral);

  1093 		}

  1094 	delete testCmdBuf;

  1095 	//Internalize the buffer with captured commands (from CRemoteGC) 

  1096 	//in to CCommandBuffer

  1097 	cmdBuf->InternalizeL(msgBuf.Pckg());

  1098 	

  1099 	TheGc->Activate(*TestWin->Win());

  1100 	TestWin->Win()->Invalidate();

  1101 	

  1102 #ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA

  1103 	/*

  1104 	 * Make sure anything that can leave is done outside the

  1105 	 * BeginRedraw/EndRedraw bracket.

  1106 	 */

  1107 	CWSGraphicsRes* wsGrap=new(ELeave) CWSGraphicsRes();

  1108 	CleanupStack::PushL(wsGrap);

  1109 #endif

  1110 	/*

  1111 	 * Note we need to still do BeginRedraw/EndRedraw for the TestWin Window

  1112 	 * even though the CRemoteGc we are going to Play into TestWin already has

  1113 	 * BeginRedraw/EndRedraw commands issued into it.  Those commands just allow

  1114 	 * for replacement of draw ops already in the CRemoteGc to be replaced by

  1115 	 * new draw ops covering the same area.  The BeginRedraw/EndRedraws never 

  1116 	 * get Play()'ed into TestWin.

  1117 	 */

  1118 	TestWin->Win()->BeginRedraw();

  1119 	TheGc->Clear();

  1120 	//Play the commands on test window using command buffer

  1121 #ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA

  1122 	cmdBuf->Play(TPoint(), NULL, TRect(TestWin->Size()), TheClient->iWs, *TheGc);

  1123 #endif

  1124 #ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA

  1125 	cmdBuf->Play(TPoint(),TRect(TestWin->Size()),*wsGrap,*TheGc);

  1126 	CleanupStack::PopAndDestroy(wsGrap);

  1127 #endif

  1128 	TheGc->Deactivate();

  1129 	TestWin->Win()->EndRedraw();

  1130 	remoteGc->ResetCommandBuffer();

  1131 	BaseWin->Win()->Invalidate();

  1132 	BaseWin->Win()->BeginRedraw();

  1133 	TheGc->Activate(*BaseWin->Win());

  1134 	TheGc->Clear();