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 #include "tdrawshapes.h"

    17 

    18 #include <e32math.h>

    19 

    20 

    21 CTDrawShapes::CTDrawShapes()

    22 	{

    23 	SetTestStepName(KTDirectGdiDrawShapeStep);

    24 	}

    25 

    26 CTDrawShapes::~CTDrawShapes()

    27 	{

    28 	}

    29 

    30 /**

    31 @SYMTestCaseID

    32 	GRAPHICS-DIRECTGDI-SHAPEDRAWING-0001

    33 

    34 @SYMPREQ 

    35 	PREQ39

    36 

    37 @SYMREQ

    38 	REQ9195

    39 	REQ9201 

    40 	REQ9202 

    41 	REQ9222 

    42 	REQ9223 

    43 	REQ9236 

    44 	REQ9237

    45 

    46 @SYMTestCaseDesc

    47 	Test shape drawing with basic parameters.

    48 

    49 @SYMTestStatus

    50 	Implemented

    51 

    52 @SYMTestPriority

    53 	Critical

    54 

    55 @SYMTestActions

    56 	Test various shape drawing methods:

    57 	void Plot(const TPoint& aPoint)

    58 		- Draw points on the destination surface in various colours (use colours from

    59 		COLOR_TABLE), increasing the distance between the points.

    60 	void DrawLine(const TPoint& aStart, const TPoint& aEnd)

    61 		- Draw lines with various colours (use colours from COLOR_TABLE).

    62 		- Draw line from top-left to bottom-right corner. Move starting point to the right

    63 		and ending point to the left and draw again. Repeat increasing the distance between

    64 		the previous and next starting and ending points, until reaching a position outside

    65 		the destination surface.

    66 		- Draw line from top-left to bottom-right corner. Move starting point down and ending

    67 		point up and draw again. Repeat increasing the distance between the previous and next

    68 		starting and ending points, until reaching a position outside the destination surface.

    69 	void DrawLineTo(const TPoint& aPoint)

    70 		- Draw lines with various colours (use colours from COLOR_TABLE).

    71 		- Draw line from top-left corner to the bottom of the drawing area. Now draw a line

    72 		in opposite direction, moving the end point a little to the right. Repeat, increasing

    73 		the distance, by which the end point is moved right, until reaching a position outside

    74 		the destination surface.

    75 	void DrawLineBy(const TPoint& aVector)

    76 		- Draw lines with various colours (use colours from COLOR_TABLE).

    77 		- Draw line from top-left corner to the right end of the drawing area. Now draw a line

    78 		in opposite direction, moving the end point a little down. Repeat, increasing the distance,

    79 		by which the end point is moved down, until reaching a position outside the destination surface.

    80 	void DrawRect(const TRect& aRect)

    81 		- Draw empty and filled rectangles.

    82 		- Draw rectangles with various colours (pen & brush colours; use colours from COLOR_TABLE).

    83 		- Draw rectangle with size of the whole drawing area, shrink it and repeat until rectangle

    84 		size reaches 0.

    85 	void DrawRoundRect(const TRect& aRect, const TSize& aEllipse)

    86 		- Draw empty and filled rectangles.

    87 		- Draw rectangles with various colours (pen & brush colours; use colours from COLOR_TABLE).

    88 		- Draw rectangle with size of the whole drawing area, shrink it, increase  the round corners

    89 		size and repeat until rectangle size reaches 0.

    90 	void DrawArc(const TRect& aRect, const TPoint& aStart, const TPoint& aEnd)

    91 		- Draw arcs with various colours (use colours from COLOR_TABLE).

    92 		- Draw an arc within the rectangle size of entire drawing area.

    93 		- Shrink the rectangle.

    94 		- Repeat until rectangle size reaches zero, move arc's start and end points.

    95 	void DrawPie(const TRect& aRect, const TPoint& aStart, const TPoint& aEnd)

    96 		- Draw empty and filled pies.

    97 		- Draw pies with various colours (pen & brush colours; use colours from COLOR_TABLE).

    98 		- Draw a pie within the rectangle size of entire drawing area.

    99 		- Shrink the rectangle.

   100 		- Repeat until rectangle size reaches zero, move pie's start and end points.

   101 	void DrawPolyLine(const TArray<TPoint>& aPointList)

   102 	void DrawPolyLineNoEndPoint(const TArray<TPoint>& aPointList)

   103 		- Draw a poly line in the target area, constructed from a large number of points.

   104 	void DrawPolygon(const TArray<TPoint>& aPointList, CGraphicsContext::TFillRule aFillRule=CGraphicsContext::EAlternate)

   105 		- Draw a polygon on the target area, constructed from a large number of points.

   106 	void DrawEllipse(const TRect& aRect)

   107 		- Draw empty and filled ellipses.

   108 		- Draw ellipses with various colours (pen & brush colours; use colours from COLOR_TABLE).

   109 		- Use rectangle (aRect) with size of the whole drawing area, shrink it and repeat until

   110 		rectangle size reaches zero.

   111 

   112 @SYMTestExpectedResults

   113 	All graphic operations completed successfully without errors. Individual shapes should

   114 	be drawn in the target area. Valid bitmap should be created. This bitmap should be

   115 	the same as a reference one.

   116 */

   117 void CTDrawShapes::TestBasicDrawShapeL()

   118 	{

   119 	_LIT(KTestName, "ShapeDrawing-Basic"); 

   120 	if(!iRunningOomTests)

   121 		{

   122 		INFO_PRINTF1(KTestName);

   123 		}

   124 

   125 	ResetGc();

   126 

   127 	TSize size(iGdiTarget->SizeInPixels().iWidth/4,

   128 			   iGdiTarget->SizeInPixels().iHeight/4);

   129 

   130 	for(TInt i=0; i<17; i++)

   131 		{

   132 		TPoint pos(size.iWidth*(i%4), size.iHeight*(i/4));

   133 

   134 		iGc->Reset();

   135 

   136 		switch(i)

   137 			{

   138 			case 0: // void Plot(const TPoint& aPoint)

   139 				{

   140 				TInt step = 0;

   141 				for(TInt y=0; y<size.iHeight; y+=step)

   142 					{

   143 					for(TInt x=0; x<size.iWidth; x+=step)

   144 						{

   145 						iGc->SetPenColor(KColor16Table[step%16]);

   146 						iGc->SetPenStyle(DirectGdi::ENullPen);

   147 						iGc->Plot(TPoint(x, y)+pos);

   148 						TESTNOERRORL(iGc->GetError());

   149 						iGc->SetPenStyle(DirectGdi::ESolidPen);

   150 						for(TInt penSize = 0; penSize <= 2; penSize++)

   151 							{

   152 							iGc->SetPenSize(TSize(penSize,penSize));

   153 							iGc->Plot(TPoint(x, y)+pos);

   154 							TESTNOERRORL(iGc->GetError());

   155 							}						

   156 						step++;

   157 						}

   158 					}

   159 				break;

   160 				}

   161 

   162 			case 1: // void DrawLine(const TPoint& aStart, const TPoint& aEnd)

   163 				{

   164 				TInt step = 0;

   165 				for(TInt x1=0,x2=size.iWidth-1; x1<size.iWidth; x1+=step,x2-=step)

   166 					{

   167 					iGc->SetPenColor(KColor16Table[step%16]);

   168 					iGc->DrawLine(TPoint(x1, 0)+pos, TPoint(x2, size.iHeight-1)+pos);

   169 					TESTNOERRORL(iGc->GetError());

   170 					step++;

   171 					}

   172 				

   173 				step = 0;

   174 				for(TInt y1=0,y2=size.iHeight-1; y1<size.iHeight; y1+=step,y2-=step)

   175 					{

   176 					iGc->SetPenColor(KColor16Table[step%16]);

   177 					iGc->DrawLine(TPoint(0, y1)+pos, TPoint(size.iWidth-1, y2)+pos);

   178 					TESTNOERRORL(iGc->GetError());

   179 					step++;

   180 					}

   181 

   182 				break;

   183 				}

   184 

   185 			case 2: // void DrawLineTo(const TPoint& aPoint), void DrawLineBy(const TPoint& aVector)

   186 				{

   187 				iGc->MoveTo(pos);

   188 				for(TInt x1=1,a=1,s=1; x1<size.iWidth; a++,x1+=a,s=-s)

   189 					{

   190 					iGc->SetPenColor(KColor16Table[a%16]);

   191 					iGc->DrawLineTo(TPoint(x1, (s>0)*(size.iHeight-1))+pos);

   192 					TESTNOERRORL(iGc->GetError());

   193 					}

   194 				

   195 				iGc->MoveTo(pos);

   196 				for(TInt y1=1,a=1,s=1; y1<size.iHeight; a++,y1+=a,s=-s)

   197 					{

   198 					iGc->SetPenColor(KColor16Table[a%16]);

   199 					iGc->DrawLineBy(TPoint(s*(size.iWidth-1), a));

   200 					TESTNOERRORL(iGc->GetError());

   201 					}

   202 

   203 				break;

   204 				}

   205 

   206 			case 4: // void DrawRect(const TRect& aRect), filled

   207 				{

   208 				iGc->SetBrushStyle(DirectGdi::ESolidBrush);

   209 				}

   210 			case 3: // void DrawRect(const TRect& aRect)

   211 				{

   212 				TRect rect(pos, size);

   213 				for(TInt a=0; (rect.Size().iWidth>0) && (rect.Size().iHeight>0); a++,rect.Shrink(3, 3))

   214 					{

   215 					iGc->SetPenColor(KColor16Table[a%16]);

   216 					iGc->SetBrushColor(KColor16Table[(a+2)%16]);

   217 					iGc->DrawRect(rect);

   218 					TESTNOERRORL(iGc->GetError());

   219 					}

   220 				break;

   221 				}

   222 			case 6: // void DrawRoundRect(const TRect& aRect, const TSize& aEllipse), filled

   223 				{

   224 				iGc->SetBrushStyle(DirectGdi::ESolidBrush);

   225 				}

   226 			case 5: // void DrawRoundRect(const TRect& aRect, const TSize& aEllipse)

   227 				{

   228 				TRect rect(pos, size);

   229 				TSize csize(1, 1);

   230 				for(TInt a=0; (rect.Size().iWidth>0) && (rect.Size().iHeight>0); a++,rect.Shrink(5, 5),csize+=TSize(2, 2))

   231 					{

   232 					iGc->SetPenColor(KColor16Table[a%16]);

   233 					iGc->SetBrushColor(KColor16Table[(a+2)%16]);

   234 					for(TInt penSize = 0; penSize <= 1; penSize++)

   235 						{

   236 						iGc->SetPenSize(TSize(penSize,penSize));

   237 						iGc->SetPenStyle(DirectGdi::ENullPen);

   238 						iGc->DrawRoundRect(rect, csize);

   239 						TESTNOERRORL(iGc->GetError());

   240 						iGc->SetPenStyle(DirectGdi::ESolidPen);

   241 						iGc->DrawRoundRect(rect, csize);

   242 						TESTNOERRORL(iGc->GetError());

   243 						iGc->SetPenStyle(DirectGdi::EDottedPen);

   244 						iGc->DrawRoundRect(rect, csize);

   245 						TESTNOERRORL(iGc->GetError());

   246 						}

   247 					}

   248 				break;

   249 				}

   250 

   251 			case 7: // void DrawArc(const TRect& aRect, const TPoint& aStart, const TPoint& aEnd)

   252 				{

   253 				TRect rect(pos, size);

   254 				TPoint pos2(pos);

   255 				pos2 += TPoint(size.iWidth/2, size.iHeight/2); // center

   256 				TReal start = KPiBy2;

   257 				TReal end = 0.0;

   258 				for(TInt a=0; (rect.Size().iWidth>0) && (rect.Size().iHeight>0); a++,rect.Shrink(3, 3),start+=0.3,end+=0.2)

   259 					{

   260 					TReal ss;

   261 					TReal cc;

   262 					Math::Sin(ss, start);

   263 					Math::Cos(cc, start);

   264 					TInt32 startX;

   265 					TInt32 startY;

   266 					Math::Int(startX, cc*100);

   267 					Math::Int(startY, ss*100);

   268 					Math::Sin(ss, end);

   269 					Math::Cos(cc, end);

   270 					TInt32 endX;

   271 					TInt32 endY;

   272 					Math::Int(endX, cc*100);

   273 					Math::Int(endY, ss*100);

   274 					

   275 					iGc->SetPenColor(KColor16Table[a%16]);

   276 					iGc->DrawArc(rect, TPoint(startX, startY)+pos2, TPoint(endX, endY)+pos2);

   277 					TESTNOERRORL(iGc->GetError());

   278 					}

   279 

   280 				break;

   281 				}

   282 

   283 			case 9: // void DrawPie(const TRect& aRect, const TPoint& aStart, const TPoint& aEnd), filled

   284 					{

   285 					iGc->SetBrushStyle(DirectGdi::ESolidBrush);

   286 					}

   287 			case 8: // void DrawPie(const TRect& aRect, const TPoint& aStart, const TPoint& aEnd)

   288 				{

   289 				TRect rect(pos, size);

   290 				TPoint pos2(pos);

   291 				pos2 += TPoint(size.iWidth/2, size.iHeight/2); // center

   292 				TReal start = 0.0;

   293 				TReal end = 0.1;

   294 				for(TInt a=0; (rect.Size().iWidth>0) && (rect.Size().iHeight>0); a++,rect.Shrink(4, 4),start+=end,end+=0.04)

   295 					{

   296 					TReal ss;

   297 					TReal cc;

   298 					Math::Sin(ss, start+end);

   299 					Math::Cos(cc, start+end);

   300 					TInt32 startX;

   301 					TInt32 startY;

   302 					Math::Int(startX, cc*100);

   303 					Math::Int(startY, ss*100);

   304 					Math::Sin(ss, start);

   305 					Math::Cos(cc, start);

   306 					TInt32 endX;

   307 					TInt32 endY;

   308 					Math::Int(endX, cc*100);

   309 					Math::Int(endY, ss*100);

   310 					

   311 					iGc->SetPenColor(KColor16Table[a%16]);

   312 					iGc->SetBrushColor(KColor16Table[(a+2)%16]);

   313 					iGc->DrawPie(rect, TPoint(startX, startY)+pos2, TPoint(endX, endY)+pos2);

   314 					TESTNOERRORL(iGc->GetError());

   315 					}

   316 

   317 				break;

   318 				}

   319 

   320 			case 10: // void DrawPolyLine(const TArray<TPoint>* aPointList)

   321 			case 11: // void DrawPolyLineNoEndPoint(const TArray<TPoint>* aPointList)

   322 				{

   323 				TInt numPoints = 60;

   324 				CArrayFixFlat<TPoint> *array = new (ELeave)CArrayFixFlat<TPoint>(numPoints);

   325 				CleanupStack::PushL(array);

   326 				TPoint pos2(pos);

   327 				pos2 += TPoint(size.iWidth/2, size.iHeight/2); // center

   328 				TReal angle = 0.0;

   329 				for(TInt r=numPoints; r>0; r--,angle+=0.47)

   330 					{

   331 					TReal ss;

   332 					TReal cc;

   333 					Math::Sin(ss, angle);

   334 					Math::Cos(cc, angle);

   335 					TInt32 x;

   336 					TInt32 y;

   337 					Math::Int(x, cc*r);

   338 					Math::Int(y, ss*r);

   339 

   340 					array->AppendL(TPoint(x, y)+pos2);

   341 					}

   342 

   343 				if(i == 10)

   344 					{

   345 					for(TInt penSize = 0; penSize <= 1; penSize++)

   346 						{

   347 						iGc->SetPenSize(TSize(penSize,penSize));

   348 						iGc->DrawPolyLine(*array);

   349 						}

   350 					}

   351 				else //if(i == 11)

   352 					{

   353 					iGc->DrawPolyLineNoEndPoint(*array);

   354 					}

   355 				TESTNOERRORL(iGc->GetError());

   356 				CleanupStack::PopAndDestroy(array);

   357 

   358 				break;

   359 				}

   360 

   361 			case 13:// TInt DrawPolygon(const TArray<TPoint>* aPointList, CGraphicsContext::TFillRule aFillRule=CGraphicsContext::EAlternate), filled

   362 					{

   363 					iGc->SetBrushStyle(DirectGdi::ESolidBrush);

   364 					iGc->SetBrushColor(KColor16Table[1]);

   365 					}

   366 			case 12:// TInt DrawPolygon(const TArray<TPoint>* aPointList, CGraphicsContext::TFillRule aFillRule=CGraphicsContext::EAlternate)

   367 				{

   368 				TInt numPoints = 20;

   369 				CArrayFixFlat<TPoint> *array = new (ELeave)CArrayFixFlat<TPoint>(numPoints);

   370 				CleanupStack::PushL(array);

   371 				TPoint pos2(pos);

   372 				pos2 += TPoint(size.iWidth/2, size.iHeight/2); // center

   373 				TReal angle = 0.0;

   374 				for(TInt r=60; r>0; r-=3,angle+=0.47)

   375 					{

   376 					TReal ss;

   377 					TReal cc;

   378 					Math::Sin(ss, angle);

   379 					Math::Cos(cc, angle);

   380 					TInt32 x;

   381 					TInt32 y;

   382 					Math::Int(x, cc*r);

   383 					Math::Int(y, ss*r);

   384 

   385 					array->AppendL(TPoint(x, y)+pos2);

   386 					}

   387 

   388 				iGc->DrawPolygon(*array, DirectGdi::EAlternate);

   389 				TESTNOERRORL(iGc->GetError());

   390 

   391 				CleanupStack::PopAndDestroy(array);

   392 				

   393 				break;

   394 				}

   395 

   396 			case 15: // void DrawEllipse(const TRect& aRect), filled

   397 				{

   398 				iGc->SetBrushStyle(DirectGdi::ESolidBrush);

   399 				}

   400 			case 14: // void DrawEllipse(const TRect& aRect)

   401 				{

   402 				TRect rect(pos, size);

   403 				for(TInt a=0; (rect.Size().iWidth>0) && (rect.Size().iHeight>0); a++,rect.Shrink(3, 5))

   404 					{

   405 					iGc->SetPenColor(KColor16Table[a%16]);

   406 					iGc->SetBrushColor(KColor16Table[(a+2)%16]);

   407 					iGc->DrawEllipse(rect);

   408 					TESTNOERRORL(iGc->GetError());

   409 					}

   410 

   411 				break;

   412 				}

   413 			}

   414 

   415 		TESTNOERRORL(iGc->GetError());

   416 		}

   417 

   418 	TESTNOERROR(WriteTargetOutput(iTestParams, KTestName()));

   419 	}

   420 

   421 

   422 /**

   423 @SYMTestCaseID

   424 	GRAPHICS-DIRECTGDI-SHAPEDRAWING-0002

   425 

   426 @SYMPREQ 

   427 	PREQ39

   428 

   429 @SYMREQ

   430 	REQ9195

   431 	REQ9201 

   432 	REQ9202 

   433 	REQ9222 

   434 	REQ9223 

   435 	REQ9236 

   436 	REQ9237

   437 

   438 @SYMTestCaseDesc

   439 	Test line drawing with basic parameters.

   440 

   441 @SYMTestStatus

   442 	Implemented

   443 

   444 @SYMTestPriority

   445 	Critical

   446 

   447 @SYMTestActions

   448 	Set default pen.

   449 		- Draw lines in all directions.

   450 		- Draw lines starting or/and ending outside the target surface.		

   451 	Call functions with valid parameters.

   452 	void DrawLine(const TPoint& aStart, const TPoint& aEnd)

   453 		The test is implemented the following way: lines will be drawn from a little

   454 		distance from the centre (to avoid lines overlapping) to a point outside of the surface

   455 		(testing surface boundary clipping). The next line will be drawn in opposite direction

   456 		(from outside to the centre) at a slightly incremented angle. 

   457 	void DrawLineBy(const TPoint& aVector)

   458 		Test for DrawLineBy() is implemented in a similar way, with checking the continuity

   459 		of line drawing (drawing the next line from the end of the previous one).

   460 	void DrawLineTo(const TPoint& aPoint)

   461 		Test for DrawLineTo() is implemented in a similar way, with checking the continuity

   462 		of line drawing (drawing the next line from the end of the previous one).

   463 		

   464 @SYMTestExpectedResults

   465 	Valid bitmap should be created. This bitmap shall be compared to a reference bitmap.

   466 */

   467 void CTDrawShapes::TestDrawLineL(TDrawShapeAPI aApi)

   468 	{

   469 	_LIT(KDrawLine, "ShapeDrawing-DrawLine");

   470 	_LIT(KDrawLineTo, "ShapeDrawing-DrawLineTo");

   471 	_LIT(KDrawLineBy, "ShapeDrawing-DrawLineBy");

   472 

   473 	TBuf<30> testName;

   474 	if(aApi == EDrawLine)

   475 		testName = KDrawLine();

   476 	else if(aApi == EDrawLineTo)

   477 		testName = KDrawLineTo();

   478 	else if(aApi == EDrawLineBy)

   479 		testName = KDrawLineBy();

   480 	else

   481 		ASSERT(EFalse); // test not supported for shapes other than those above

   482 

   483 	if(!iRunningOomTests)

   484 		{

   485 		INFO_PRINTF1(testName);

   486 		}

   487 	

   488 	ResetGc();

   489 

   490 	TPoint center(iGdiTarget->SizeInPixels().iWidth/2,

   491 			iGdiTarget->SizeInPixels().iHeight/2);

   492 

   493 	TInt steps = 180;

   494 	TReal radius1 = 400.0;

   495 	TReal radius2 = 70.0;

   496 

   497 	TPoint pp;

   498 

   499 	if(aApi != EDrawLine)

   500 		{

   501 		const TInt radius = 200;

   502 		radius1 = radius;

   503 		radius2 = 90.0;

   504 		pp = center;

   505 		pp.iX += radius;

   506 		iGc->MoveTo(pp);

   507 		}

   508 

   509 	for(TInt i=0; i<steps; i++)

   510 		{

   511 		TReal angle = KPi*2.0*i/steps;

   512 

   513 		TReal angleSin, angleCos;

   514 		Math::Sin(angleSin, angle);

   515 		Math::Cos(angleCos, angle);

   516 

   517 		TPoint p1(static_cast<TInt>(angleCos*radius1), static_cast<TInt>(angleSin*radius1));

   518 		p1 += center;

   519 		TPoint p2(static_cast<TInt>(angleCos*radius2), static_cast<TInt>(angleSin*radius2));

   520 		p2 += center;

   521 

   522 		if(i&1)

   523 			{

   524 			TPoint pp = p1;

   525 			p1 = p2;

   526 			p2 = pp;

   527 			}

   528 

   529 		if(aApi == EDrawLine)

   530 			{

   531 			for(TInt penSize = 0; penSize <= 1; penSize ++)

   532 				{

   533 				iGc->SetPenSize(TSize(penSize,penSize));

   534 				iGc->SetPenStyle(DirectGdi::ESolidPen);

   535 				iGc->DrawLine(p1, p2);

   536 				}				

   537 			}

   538 		else if(aApi == EDrawLineTo)

   539 			{

   540 			iGc->DrawLineTo(p1);

   541 			iGc->DrawLineTo(p2);

   542 			}

   543 		else // if(aApi == EDrawLineBy)

   544 			{

   545 			iGc->DrawLineBy(p1-pp);

   546 			iGc->DrawLineBy(p2-p1);

   547 			pp = p2;

   548 			}

   549 		}

   550 

   551 	TESTNOERRORL(iGc->GetError());

   552 	TESTNOERROR(WriteTargetOutput(iTestParams, testName));

   553 	}

   554 

   555 

   556 /**

   557 @SYMTestCaseID

   558 	GRAPHICS-DIRECTGDI-SHAPEDRAWING-0003

   559 

   560 @SYMPREQ 

   561 	PREQ39

   562 

   563 @SYMREQ

   564 	REQ9195

   565 	REQ9201 

   566 	REQ9202 

   567 	REQ9222 

   568 	REQ9223 

   569 	REQ9236 

   570 	REQ9237

   571 

   572 @SYMTestCaseDesc

   573 	Test correctness of size and position reproduction of rectangle, ellipse, arc, and pie.

   574 

   575 @SYMTestStatus

   576 	Implemented

   577 

   578 @SYMTestPriority

   579 	Critical

   580 

   581 @SYMTestActions

   582 	Set default pen and brush.

   583 		- Draw shapes at various positions and sizes.

   584 		- Test position and size outside the target surface.

   585 		- Test boundary positions and sizes.

   586 	Call functions with valid parameters:

   587 	void DrawRect(const TRect& aRect)

   588 		The size of bounding rectangle (aRect) will be iterated over (both height and width),

   589 		each time calling the appropriate drawing method.

   590 	For DrawArc() and DrawPie also the starting and ending points will be changing.

   591 

   592 @SYMTestExpectedResults

   593 	Valid bitmap should be created. This bitmap shall be compared to a reference bitmap.

   594 */

   595 void CTDrawShapes::TestDrawShapePositionAndSizeL(TDrawShapeAPI aApi,

   596 		DirectGdi::TPenStyle aPenStyle,

   597 		DirectGdi::TBrushStyle aBrushStyle)

   598 	{

   599 	_LIT(KDrawRectPositionAndSize, "ShapeDrawing-DrawRect-PositionAndSize");

   600 	_LIT(KDrawRoundRectPositionAndSize, "ShapeDrawing-DrawRoundRect-PositionAndSize");

   601 	_LIT(KDrawEllipsePositionAndSize, "ShapeDrawing-DrawEllipse-PositionAndSize");

   602 	_LIT(KDrawPiePositionAndSize, "ShapeDrawing-DrawPie-PositionAndSize");

   603 	_LIT(KDrawArcPositionAndSize, "ShapeDrawing-DrawArc-PositionAndSize");

   604 

   605 	TBuf<70> testName;

   606 	if(aApi == EDrawRect)

   607 		testName = KDrawRectPositionAndSize();

   608 	else if(aApi == EDrawRoundRect)

   609 		testName = KDrawRoundRectPositionAndSize();

   610 	else if(aApi == EDrawEllipse)

   611 		testName = KDrawEllipsePositionAndSize();

   612 	else if(aApi == EDrawPie)

   613 		testName = KDrawPiePositionAndSize();

   614 	else if(aApi == EDrawArc)

   615 		testName = KDrawArcPositionAndSize();

   616 	else

   617 		ASSERT(EFalse); // test not supported for shapes other than those above

   618 

   619 	if(aPenStyle == DirectGdi::ENullPen)

   620 		{

   621 		testName.Append(KSeparator);

   622 		testName.Append(KPenNameNull);

   623 		}

   624 	

   625 	if(aBrushStyle != DirectGdi::ENullBrush)

   626 		{

   627 		testName.Append(KSeparator);

   628 		testName.Append(KBrushStyleTableNames[aBrushStyle]);

   629 		}

   630 

   631 	if(!iRunningOomTests)

   632 		{

   633 		INFO_PRINTF1(testName);

   634 		}

   635 	

   636 	ResetGc();

   637 

   638 	TInt width = iGdiTarget->SizeInPixels().iWidth;

   639 	TInt height = iGdiTarget->SizeInPixels().iHeight;

   640 	TInt rectWidth = 0;

   641 	TInt rectHeight = 0;

   642 	TInt step = 0;

   643 

   644 	iGc->SetPenStyle(aPenStyle);

   645 	iGc->SetBrushStyle(aBrushStyle);

   646 

   647 	for(TInt y=-45, offsetY=0; y<height+30; y+=rectHeight+1, offsetY++, rectHeight++)

   648 		{

   649 		rectWidth = 0;

   650 		for(TInt x=-45, offsetX=0; x<width+30; x+=rectWidth+1, offsetX++, rectWidth++)

   651 			{

   652 			TRect rect(TPoint(x+offsetY, y+offsetX), TSize(rectWidth, rectHeight));

   653 

   654 			iGc->SetBrushColor(KColor16Table[step%16]);

   655 			step++;

   656 

   657 			if(aApi == EDrawRect)

   658 				{

   659 				iGc->DrawRect(rect);

   660 				}

   661 			else if(aApi == EDrawRoundRect)

   662 				{

   663 				iGc->DrawRoundRect(rect, TSize(offsetX/3, offsetY/3));

   664 				}

   665 			else if(aApi == EDrawEllipse)

   666 				{

   667 				iGc->DrawEllipse(rect);

   668 				}

   669 			else

   670 				{

   671 				TReal angle1 = offsetX*0.2;

   672 				TReal angle2 = angle1-(offsetY+1)*0.18;

   673 

   674 				TReal angleSin, angleCos;

   675 				Math::Sin(angleSin, angle1);

   676 				Math::Cos(angleCos, angle1);

   677 				TPoint p1(static_cast<TInt>(angleCos*100), static_cast<TInt>(angleSin*100));

   678 

   679 				Math::Sin(angleSin, angle2);

   680 				Math::Cos(angleCos, angle2);

   681 				TPoint p2(static_cast<TInt>(angleCos*100), static_cast<TInt>(angleSin*100));

   682 

   683 				p1 += rect.Center();

   684 				p2 += rect.Center();

   685 

   686 				if(aApi == EDrawPie)

   687 					{

   688 					iGc->DrawPie(rect, p1, p2);

   689 					}

   690 				else //if(aApi == EDrawArc)

   691 					{

   692 					iGc->DrawArc(rect, p1, p2);

   693 					}

   694 				}

   695 			TESTNOERRORL(iGc->GetError());

   696 			}

   697 		}

   698 	TESTNOERROR(WriteTargetOutput(iTestParams, testName));

   699 	}

   700 

   701 

   702 /**

   703 @SYMTestCaseID

   704 	GRAPHICS-DIRECTGDI-SHAPEDRAWING-0004

   705 

   706 @SYMPREQ 

   707 	PREQ39

   708 

   709 @SYMREQ

   710 	REQ9195

   711 	REQ9201 

   712 	REQ9202 

   713 	REQ9222 

   714 	REQ9223 

   715 	REQ9236 

   716 	REQ9237

   717 

   718 @SYMTestCaseDesc

   719 	Test functions behaviour after calling with invalid parameters.

   720 

   721 @SYMTestStatus

   722 	Implemented

   723 

   724 @SYMTestPriority

   725 	Critical

   726 

   727 @SYMTestActions

   728 	Test shape drawing methods invalid parameters handling.

   729 	Set default pen and brush.

   730 	Set valid parameters (see ShapeDrawing-Basic).

   731 	Replace valid parameters with invalid ones:

   732 		negative size

   733 			aRect.iTl = ( -30, -30 ) ; aRect.iBr = ( -10, -10 )

   734 			aRect.iTl = ( 30, 30 ) ; aRect.iBr = ( 10, 10 )

   735 			aEllipse.iWidth = -30

   736 			aEllipse.iHeight = -30

   737 		zero size

   738 			aRect.iTl = ( -30, -30 ) ; aRect.iBr = ( -30, -30 )

   739 			aRect.iTl = ( 30, 30 ) ; aRect.iBr = ( 30, 30 )

   740 			Trect(10,50,10,80)

   741 			TRect(80,90,140,90)

   742 			aEllipse.iWidth = 0

   743 			aEllipse.iHeight = 0

   744 

   745 @SYMTestExpectedResults

   746 	Function shall detect invalid parameters and return. Nothing will be drawn on the target surface.

   747 */

   748 void CTDrawShapes::TestDrawShapeInvalidParametersL(TDrawShapeAPI aApi)

   749 	{

   750 	_LIT(KDrawRectInvalidParameters, "ShapeDrawing-DrawRect-InvalidParameters");

   751 	_LIT(KDrawRoundRectInvalidParameters, "ShapeDrawing-DrawRoundRect-InvalidParameters");

   752 	_LIT(KDrawEllipseInvalidParameters, "ShapeDrawing-DrawEllipse-InvalidParameters");

   753 	_LIT(KDrawPieInvalidParameters, "ShapeDrawing-DrawPie-InvalidParameters");

   754 	_LIT(KDrawArcInvalidParameters, "ShapeDrawing-DrawArc-InvalidParameters");

   755 	_LIT(KDrawPolygonInvalidParameters, "ShapeDrawing-DrawPolygon-InvalidParameters");

   756 	

   757 	TBuf<70> testName;

   758 	if(aApi == EDrawRect)

   759 		testName = KDrawRectInvalidParameters();

   760 	else if(aApi == EDrawRoundRect)

   761 		testName = KDrawRoundRectInvalidParameters();

   762 	else if(aApi == EDrawEllipse)

   763 		testName = KDrawEllipseInvalidParameters();

   764 	else if(aApi == EDrawPie)

   765 		testName = KDrawPieInvalidParameters();

   766 	else if(aApi == EDrawArc)

   767 		testName = KDrawArcInvalidParameters();

   768 	else if(aApi == EDrawPolygon)

   769 		testName = KDrawPolygonInvalidParameters();

   770 	else

   771 		ASSERT(EFalse); // test not supported for shapes other than those above

   772 

   773 	if(!iRunningOomTests)

   774 		{

   775 		INFO_PRINTF1(testName);

   776 		}

   777 	

   778 	ResetGc();

   779 

   780 	RArray<TRect> rects;

   781 	CleanupClosePushL(rects);

   782 

   783 	RArray<TSize> sizes;

   784 	CleanupClosePushL(sizes);

   785 

   786 	// negative rect size

   787 	rects.AppendL(TRect(-30, -30, -10, -10));

   788 	rects.AppendL(TRect(30, 30, 10, 10));

   789 	rects.AppendL(TRect(100, 30, 120, 10));

   790 	rects.AppendL(TRect(30, 100, 10, 120));

   791 	

   792 	// negative ellipse size

   793 	sizes.AppendL(TSize(-30, 30));

   794 	sizes.AppendL(TSize(30, -30));

   795 	sizes.AppendL(TSize(-30, -30));

   796 

   797 	// zero rect size

   798 	rects.AppendL(TRect(-30, -30, -30, -30));

   799 	rects.AppendL(TRect(30, 30, 30, 30));

   800 	rects.AppendL(TRect(10, 50, 10, 80));

   801 	rects.AppendL(TRect(80, 90, 140, 90));

   802 

   803 	// zero ellipse size

   804 	sizes.AppendL(TSize(0, 30));

   805 	sizes.AppendL(TSize(30, 0));

   806 	sizes.AppendL(TSize(0, 0));

   807 

   808 	switch(aApi)

   809 		{

   810 		case EDrawRect:

   811 			{

   812 			for(TInt i=0; i<rects.Count(); i++)

   813 				{

   814 				for(TInt penSize = 0; penSize <= 1; penSize++)

   815 					{

   816 					iGc->SetPenSize(TSize(penSize,penSize));

   817 					iGc->DrawRect(rects[i]);

   818 					TESTNOERRORL(iGc->GetError());

   819 					}

   820 				}

   821 			break;

   822 			}

   823 

   824 		case EDrawRoundRect:

   825 			{

   826 			for(TInt i=0; i<rects.Count(); i++)

   827 				{

   828 				for(TInt j=0; j<sizes.Count(); j++)

   829 					{

   830 					iGc->DrawRoundRect(rects[i], sizes[j]);

   831 					TESTNOERRORL(iGc->GetError());

   832 					}

   833 				}

   834 			break;

   835 			}

   836 

   837 		case EDrawEllipse:

   838 			{

   839 			for(TInt i=0; i<rects.Count(); i++)

   840 				{		

   841 				iGc->DrawEllipse(rects[i]);

   842 				TESTNOERRORL(iGc->GetError());

   843 				}

   844 			break;

   845 			}

   846 

   847 		case EDrawPie:

   848 			{

   849 			for(TInt i=0; i<rects.Count(); i++)

   850 				{

   851 				TPoint pos(rects[i].Center());		

   852 				iGc->SetPenStyle(DirectGdi::ENullPen);

   853 				iGc->DrawPie(rects[i], TPoint(100, 0)+pos, TPoint(0, -100)+pos);

   854 				iGc->SetPenStyle(DirectGdi::ESolidPen);

   855 				for(TInt penSize = 0; penSize <= 1; penSize ++)

   856 					{

   857 					iGc->SetPenSize(TSize(penSize,penSize));

   858 					iGc->DrawPie(rects[i], TPoint(100, 0)+pos, TPoint(0, -100)+pos);

   859 					TESTNOERRORL(iGc->GetError());

   860 					}				

   861 				}

   862 			break;

   863 			}

   864 

   865 		case EDrawArc:

   866 			{

   867 			for(TInt i=0; i<rects.Count(); i++)

   868 				{

   869 				TPoint pos(rects[i].Center());

   870 				iGc->SetPenStyle(DirectGdi::ENullPen);

   871 				iGc->DrawArc(rects[i], TPoint(100, 0)+pos, TPoint(0, -100)+pos);

   872 				iGc->DrawArc(rects[i], TPoint(0, -100)+pos, TPoint(100, 0)+pos);

   873 				iGc->SetPenStyle(DirectGdi::ESolidPen);

   874 				for(TInt penSize = 0; penSize <= 1; penSize ++)

   875 					{

   876 					iGc->SetPenSize(TSize(penSize,penSize));

   877 					iGc->DrawArc(rects[i], TPoint(100, 0)+pos, TPoint(0, -100)+pos);

   878 					}

   879 				TESTNOERRORL(iGc->GetError());

   880 				}

   881 			break;

   882 			}

   883 			

   884 		case EDrawPolygon:

   885 			{

   886 			// Try to draw a polygon with 0 points, and a polygon with an invalid fill argument

   887 			CArrayFixFlat<TPoint> *tmpArray = new (ELeave)CArrayFixFlat<TPoint>(1);			

   888 			iGc->DrawPolygon(*tmpArray, DirectGdi::EAlternate);

   889 			TESTNOERROR(iGc->GetError());

   890 			iGc->DrawPolygon(*tmpArray, static_cast<DirectGdi::TFillRule>(-1));

   891 			if (iUseDirectGdi)

   892 				{

   893 				TEST(iGc->GetError() == KErrArgument);

   894 				}

   895 			delete tmpArray;

   896 			break;

   897 			}

   898 		}

   899 

   900 	iGc->Reset();

   901 	CleanupStack::PopAndDestroy(&sizes);

   902 	CleanupStack::PopAndDestroy(&rects);

   903 

   904 	// test if target is still clear

   905 	TBool pass = TestTargetL(KRgbWhite);

   906 	if(!pass)

   907 		{

   908 		// write target only if test failed

   909 		TEST(KErrNone == WriteTargetOutput(iTestParams, testName));

   910 		}

   911 	TEST(pass);

   912 	}

   913 

   914 /**

   915 @SYMTestCaseID

   916 	GRAPHICS-DIRECTGDI-SHAPEDRAWING-0005

   917 

   918 @SYMPREQ 

   919 	PREQ39

   920 

   921 @SYMREQ

   922 	REQ9195

   923 	REQ9201 

   924 	REQ9202 

   925 	REQ9222 

   926 	REQ9223 

   927 	REQ9236 

   928 	REQ9237

   929 

   930 @SYMTestCaseDesc

   931 	Test a few round rectangles, some of which have corners larger than the width

   932 	or height or the rectangles.

   933 

   934 @SYMTestStatus

   935 	Implemented

   936 

   937 @SYMTestPriority

   938 	Critical

   939 

   940 @SYMTestActions

   941 	The tests is implemented the following way: the rectangles' corners' width and height

   942 	will be iterated over, and for each	iteration a set of rounded rectangles will be drawn.

   943 	The test will be repeated with a solid brush.

   944 

   945 @SYMTestExpectedResults

   946 	Valid bitmap should be created. This bitmap shall be compared to a reference bitmap.

   947 */

   948 void CTDrawShapes::TestDrawRoundRectL(DirectGdi::TBrushStyle aBrushStyle)

   949 	{

   950 	_LIT(KDrawRoundRect, "ShapeDrawing-DrawRoundRect");

   951 

   952 	TBuf<50> testName;

   953 	testName = KDrawRoundRect();

   954 	if(aBrushStyle != DirectGdi::ENullBrush)

   955 		{

   956 		testName.Append(KSeparator);

   957 		testName.Append(KBrushStyleTableNames[aBrushStyle]);

   958 		}

   959 	

   960 	if(!iRunningOomTests)

   961 		{

   962 		INFO_PRINTF1(testName);

   963 		}

   964 	

   965 	ResetGc();

   966 

   967 	TInt width = iGdiTarget->SizeInPixels().iWidth;

   968 	TInt height = iGdiTarget->SizeInPixels().iHeight;

   969 	const TInt xRectNum = 16;

   970 	const TInt yRectNum = 16;

   971 	TInt step = 0;

   972 

   973 	iGc->SetBrushStyle(aBrushStyle);

   974 

   975 	for(TInt i=0; i<yRectNum; i++)

   976 		{

   977 		for(TInt j=0; j<xRectNum; j++)

   978 			{

   979 			TRect rect(TPoint(j*width/xRectNum, i*height/yRectNum), TSize(width/xRectNum, height/yRectNum));

   980 

   981 			// draw many concentric rectangles, each smaller than previous

   982 			while((rect.Size().iWidth > 2) && (rect.Size().iHeight > 2))

   983 				{

   984 				iGc->SetBrushColor(KColor16Table[step%16]);

   985 				step++;

   986 

   987 				iGc->DrawRoundRect(rect, TSize(j, i));

   988 				TESTNOERRORL(iGc->GetError());

   989 				rect.Shrink(3, 3);

   990 				}

   991 			}

   992 		}

   993 	TESTNOERROR(WriteTargetOutput(iTestParams, testName));

   994 	}

   995 

   996 

   997 /**

   998 @SYMTestCaseID

   999 	GRAPHICS-DIRECTGDI-SHAPEDRAWING-0006

  1000 

  1001 @SYMPREQ 

  1002 	PREQ39

  1003 

  1004 @SYMREQ

  1005 	REQ9195

  1006 	REQ9201 

  1007 	REQ9202 

  1008 	REQ9222 

  1009 	REQ9223 

  1010 	REQ9236 

  1011 	REQ9237

  1012 

  1013 @SYMTestCaseDesc

  1014 	Test drawing arc functionality.

  1015 

  1016 @SYMTestStatus

  1017 	Implemented

  1018 

  1019 @SYMTestPriority

  1020 	Critical

  1021 

  1022 @SYMTestActions

  1023 	Set default pen and brush.

  1024 	Draw various chunks of arc.

  1025 	Call functions with valid parameters.

  1026 	The tests is implemented the following way: the arc's starting angle will be

  1027 	iterated over, and for each iteration a set of arcs with different end angles will be drawn.

  1028 

  1029 @SYMTestExpectedResults

  1030 	Valid bitmap should be created. This bitmap shall be compared to a reference bitmap.

  1031 */

  1032 void CTDrawShapes::TestDrawArcL()

  1033 	{

  1034 	_LIT(KTestName, "ShapeDrawing-DrawArc"); 

  1035 

  1036 	if(!iRunningOomTests)

  1037 		{

  1038 		INFO_PRINTF1(KTestName);

  1039 		}

  1040 	

  1041 	ResetGc();

  1042 

  1043 	TInt width = iGdiTarget->SizeInPixels().iWidth;

  1044 	TInt height = iGdiTarget->SizeInPixels().iHeight;

  1045 	const TInt xRectNum = 8;

  1046 	const TInt yRectNum = 8;

  1047 	const TReal angleStep = 2.0*KPi/11.0;

  1048 

  1049 	for(TInt i=0; i<yRectNum; i++)

  1050 		{

  1051 		for(TInt j=0; j<xRectNum; j++)

  1052 			{

  1053 			TRect rect(TPoint(j*width/xRectNum, i*height/yRectNum), TSize(width/xRectNum, height/yRectNum));

  1054 

  1055 			TReal angle1 =(i*xRectNum+j)*2.0*KPi/(xRectNum*yRectNum);

  1056 

  1057 			TReal angleSin, angleCos;

  1058 			Math::Sin(angleSin, angle1);

  1059 			Math::Cos(angleCos, angle1);

  1060 			TPoint p1(static_cast<TInt>(angleCos*100), static_cast<TInt>(angleSin*100));

  1061 			p1 += rect.Center();

  1062 

  1063 			TReal angle2 = angle1-angleStep;

  1064 

  1065 			// draw many concentric arcs, each smaller than previous and with different angles

  1066 			while((rect.Size().iWidth > 2) && (rect.Size().iHeight > 2))

  1067 				{

  1068 				Math::Sin(angleSin, angle2);

  1069 				Math::Cos(angleCos, angle2);

  1070 				TPoint p2(static_cast<TInt>(angleCos*100), static_cast<TInt>(angleSin*100));

  1071 				p2 += rect.Center();

  1072 

  1073 				iGc->DrawArc(rect, p1, p2);

  1074 				TESTNOERRORL(iGc->GetError());

  1075 

  1076 				angle2 -= angleStep;

  1077 				rect.Shrink(3, 3);

  1078 				}

  1079 			}

  1080 		}

  1081 	TESTNOERROR(WriteTargetOutput(iTestParams, KTestName()));

  1082 	}

  1083 

  1084 

  1085 /**

  1086 @SYMTestCaseID

  1087 	GRAPHICS-DIRECTGDI-SHAPEDRAWING-0007

  1088 

  1089 @SYMPREQ 

  1090 	PREQ39

  1091 

  1092 @SYMREQ

  1093 	REQ9195

  1094 	REQ9201 

  1095 	REQ9202 

  1096 	REQ9222 

  1097 	REQ9223 

  1098 	REQ9236 

  1099 	REQ9237

  1100 

  1101 @SYMTestCaseDesc

  1102 	Test drawing pie functionality.

  1103 

  1104 @SYMTestStatus

  1105 	Implemented

  1106 

  1107 @SYMTestPriority

  1108 	Critical

  1109 

  1110 @SYMTestActions

  1111 	Set default pen and brush.

  1112 	Draw various chunks of pie.

  1113 	Call functions with valid parameters (see Graphics-DirectGDI-ShapeDrawing-001).

  1114 	The tests is implemented the following way: the pie's starting angle will be

  1115 	iterated over, and for each iteration a complete circle composed of different pies will be drawn.

  1116 

  1117 @SYMTestExpectedResults

  1118 	A set of 64 groups of pies should be draw, each one rotated slightly more than the last. 

  1119 	The size of the pies drawn should look the same for all rotations.

  1120 */

  1121 void CTDrawShapes::TestDrawPieL(DirectGdi::TBrushStyle aBrushStyle)

  1122 	{

  1123 	_LIT(KDrawPie, "ShapeDrawing-DrawPie");

  1124 

  1125 	TBuf<50> testName;

  1126 	testName = KDrawPie();

  1127 	if(aBrushStyle != DirectGdi::ENullBrush)

  1128 		{

  1129 		testName.Append(KSeparator);

  1130 		testName.Append(KBrushStyleTableNames[aBrushStyle]);

  1131 		}

  1132 	

  1133 	if(!iRunningOomTests)

  1134 		{

  1135 		INFO_PRINTF1(testName);