MercurialSymaptic / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
os/graphics/windowing/windowserver/test/ttime/TTGRAPH.CPP
author sl
Tue, 10 Jun 2014 14:32:02 +0200
changeset 1 260cb5ec6c19
permissions -rw-r--r--
Update contrib. 
     1 // Copyright (c) 1996-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 // used for timing graphics

    15 // 

    16 //

    17 

    18 #include "TTIME.H"

    19 

    20 #define TEST_BITMAP_NAME _L("Z:\\WSTEST\\TEST.MBM")

    21 

    22 GLREF_C void Panic(TInt aPanic);

    23 

    24 enum TFuncType

    25 	{

    26 	EBitmapTest,

    27 	EXorTest,

    28 	ESmallClearTest,

    29 	ERectCompareTest,

    30 	EUseFontTest,

    31 	EBitBltTest,

    32 	EFullScreenBitBltTest,

    33 	EMaskedBitBltTest,

    34 	EFillPatternTest,

    35 	EBackupWindowDrawingTest,

    36 	};

    37 

    38 class TGraphicsTest : public CBase

    39 	{

    40 public:

    41 	void DoTestL(TInt aOwningGroup, TFuncType aFunc, TInt aParam1, TAny *aParam2);

    42 	void DrawBitmapTestL(TInt aParam1, TAny *aParam2);

    43 	void XorTest(TInt aParam1, TAny *aParam2);

    44 	void SmallClearTest(TInt , TAny *);

    45 	void RectCompareTest(TInt , TAny *);

    46 	void UseFontTestL(TInt , TAny *);

    47 	void BitBltTestL(TInt , TAny *);

    48 	void FullScreenBitBltTestL(TInt , TAny *);

    49 	void MaskedBitBltTestL(TInt , TAny *);

    50 	void FillPatternTestL(TInt , TAny *);

    51 	void BackedUpWindowDrawingL(TInt aMode, TAny *);

    52 private:

    53 	RWsSession iWs;

    54 	CWsScreenDevice *iDevice;

    55 	RWindowGroup iGroup;

    56 	RWindow iWindow;

    57 	RBackedUpWindow iBackedUpWindow;

    58 	RDrawableWindow *iWindowPtr;

    59 	CWindowGc *iGc;

    60 	};

    61 	

    62 TInt CreateGraphicsTest(TInt aOwningGroup, TFuncType aFunc, TInt aParam1, TAny *aParam2)

    63 	{

    64 	TGraphicsTest *iTest=NULL;

    65 	TRAPD(err,iTest=new(ELeave) TGraphicsTest());

    66 	if (err==KErrNone)

    67 		{

    68 		TRAP(err,iTest->DoTestL(aOwningGroup, aFunc, aParam1, aParam2));

    69 		delete iTest;

    70 		}

    71 	return(err);

    72 	}

    73 

    74 void TGraphicsTest::DoTestL(TInt aOwningGroup, TFuncType aFunc, TInt aParam1, TAny *aParam2)

    75 	{

    76 	iWs.Connect();

    77 	iDevice=new(ELeave) CWsScreenDevice(iWs);

    78 	iDevice->Construct();

    79 	iGroup=RWindowGroup(iWs);

    80 	iGroup.Construct(ENullWsHandle);

    81 	iGroup.SetOwningWindowGroup(aOwningGroup);

    82 //

    83 	if (aFunc==EBackupWindowDrawingTest)

    84 		{

    85 		iBackedUpWindow=RBackedUpWindow(iWs);

    86 		iWindowPtr=&iBackedUpWindow;

    87 		iBackedUpWindow.Construct(iGroup,EGray4,ENullWsHandle);

    88 		}

    89 	else

    90 		{

    91 		iWindow=RWindow(iWs);

    92 		iWindowPtr=&iWindow;

    93 		iWindow.Construct(iGroup,ENullWsHandle);

    94 		}

    95 	User::LeaveIfError(iWindowPtr->SetExtentErr(TPoint(), iDevice->SizeInPixels()));

    96 	iWindowPtr->Activate();

    97 	//

    98 	iDevice->CreateContext(iGc);

    99 	iGc->Activate(*iWindowPtr);

   100 	if (iWindowPtr==&iWindow)

   101 		{

   102 		iWindow.BeginRedraw();

   103 		iGc->Clear();

   104 		iWindow.EndRedraw();

   105 		}

   106 	switch(aFunc)

   107 		{

   108 		case EBitmapTest:

   109 			DrawBitmapTestL(aParam1, aParam2);

   110 			break;

   111 		case EXorTest:

   112 			XorTest(aParam1, aParam2);

   113 			break;

   114 		case ESmallClearTest:

   115 			SmallClearTest(aParam1, aParam2);

   116 			break;

   117 		case ERectCompareTest:

   118 			RectCompareTest(aParam1, aParam2);

   119 			break;

   120 		case EUseFontTest:

   121 			UseFontTestL(aParam1, aParam2);

   122 			break;

   123 		case EBitBltTest:

   124 			BitBltTestL(aParam1, aParam2);

   125 			break;

   126 		case EFullScreenBitBltTest:

   127 			FullScreenBitBltTestL(aParam1, aParam2);

   128 			break;

   129 		case EMaskedBitBltTest:

   130 			MaskedBitBltTestL(aParam1, aParam2);

   131 			break;

   132 		case EFillPatternTest:

   133 			FillPatternTestL(aParam1, aParam2);

   134 			break;

   135 		case EBackupWindowDrawingTest:

   136 			BackedUpWindowDrawingL(aParam1, aParam2);

   137 			break;

   138 		default:;

   139 		}

   140 //

   141 	delete iGc;

   142 	iWindowPtr->Close();

   143 	iGroup.Close();

   144 	delete iDevice;

   145 	iWs.Close();

   146 	}

   147 

   148 // Draw bitmap //

   149 

   150 void TGraphicsTest::DrawBitmapTestL(TInt , TAny *)

   151 	{

   152 	CFbsBitmap *bitmap=new(ELeave) CFbsBitmap;

   153 	User::LeaveIfError(bitmap->Load(TEST_BITMAP_NAME,0));

   154 	for(TInt nTimes=0;nTimes<10;nTimes++)

   155 		{

   156 		iGc->Clear();

   157 		TSize size(iDevice->SizeInPixels());

   158 		iGc->DrawBitmap(TRect(-size.iWidth,-size.iHeight,size.iWidth<<1,size.iHeight<<1),bitmap);

   159 		iWs.Flush();

   160 		}

   161 	delete bitmap;

   162 	}

   163 

   164 TInt DrawBitmapTestFunc(TInt aOwningGroup)

   165 	{

   166 	return(CreateGraphicsTest(aOwningGroup, EBitmapTest, 0, NULL));

   167 	}

   168 

   169 GLDEF_D TTimeTestHeader DrawBitmapTest={_S("Draw bitmap"),DrawBitmapTestFunc};

   170 

   171 // XOR Test //

   172 

   173 void TGraphicsTest::XorTest(TInt , TAny *)

   174 	{

   175 	iGc->SetDrawMode(CGraphicsContext::EDrawModeXOR);

   176 	iGc->SetBrushColor(TRgb::Gray256(255));

   177 	iGc->SetPenStyle(CGraphicsContext::ENullPen);

   178 	iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

   179 	for(TInt count=0;count<10;count++)

   180 		{

   181 		for(TInt wid=1;wid<320;wid+=3)

   182 			{

   183 			iGc->DrawRect(TRect(10,10,10+wid,150));

   184 	//		iWs.Flush();

   185 			}

   186 		}

   187 	}

   188 

   189 TInt XorIngTestFunc(TInt aOwningGroup)

   190 	{

   191 	return(CreateGraphicsTest(aOwningGroup, EXorTest, 0, NULL));

   192 	}

   193 

   194 GLDEF_D TTimeTestHeader XorIngTest={_S("Xor'ing"),XorIngTestFunc};

   195 

   196 // XOR Test //

   197 

   198 void TGraphicsTest::SmallClearTest(TInt , TAny *)

   199 	{

   200 	iGc->SetBrushColor(TRgb::Gray256(255));

   201 	iGc->SetPenStyle(CGraphicsContext::ENullPen);

   202 	iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

   203 	for(TInt count=0;count<500;count++)

   204 		{

   205 		for(TInt wid=1;wid<30;wid++)

   206 			{

   207 			iGc->DrawRect(TRect(1,0,10+wid,100));

   208 //			iWs.Flush();

   209 			}

   210 		}

   211 	}

   212 

   213 TInt SmallClearTestFunc(TInt aOwningGroup)

   214 	{

   215 	return(CreateGraphicsTest(aOwningGroup, ESmallClearTest, 0, NULL));

   216 	}

   217 

   218 GLDEF_D TTimeTestHeader SmallClearTest={_S("Small clear rect"),SmallClearTestFunc};

   219 

   220 // XOR Test //

   221 

   222 enum {EMaxWidth=100};

   223 

   224 void TGraphicsTest::RectCompareTest(TInt , TAny *)

   225 	{

   226 	TSize size(iDevice->SizeInPixels());

   227 	for(TInt count=0;count<10;count++)

   228 		iDevice->RectCompare(TRect(0,0,size.iWidth>>1,size.iHeight),TRect(size.iWidth>>1,0,size.iWidth,size.iHeight));

   229 	}

   230 

   231 TInt RectCompareTestFunc(TInt aOwningGroup)

   232 	{

   233 	return(CreateGraphicsTest(aOwningGroup, ERectCompareTest, 0, NULL));

   234 	}

   235 

   236 GLDEF_D TTimeTestHeader RectCompareTest={_S("RectCompare"),RectCompareTestFunc};

   237 

   238 // Use Font //

   239 

   240 void TGraphicsTest::UseFontTestL(TInt , TAny *)

   241 	{

   242 	CFbsFont *font;

   243 	TFontSpec fspec(KTestFontTypefaceName,200);

   244 	User::LeaveIfError(iDevice->GetNearestFontToDesignHeightInTwips((CFont *&)font, fspec));

   245 	for(TInt count=0;count<1000;count++)

   246 		iGc->UseFont(font);

   247 	iDevice->ReleaseFont(font);

   248 	}

   249 

   250 TInt UseFontTestFunc(TInt aOwningGroup)

   251 	{

   252 	return(CreateGraphicsTest(aOwningGroup, EUseFontTest, 0, NULL));

   253 	}

   254 

   255 GLDEF_D TTimeTestHeader UseFontTest={_S("UseFont(x1000)"),UseFontTestFunc};

   256 

   257 // Small BitBlt //

   258 

   259 void TGraphicsTest::BitBltTestL(TInt , TAny *)

   260 	{

   261 	CWsBitmap *bitmap=new(ELeave) CWsBitmap(iWs);

   262 	TSize size(25,50);

   263 	bitmap->Create(size,EGray4);

   264 	CFbsDevice *bitmapDevice=CFbsBitmapDevice::NewL(bitmap);

   265 	CFbsBitGc *gc=CFbsBitGc::NewL();

   266 	gc->Activate(bitmapDevice);

   267 	gc->DrawEllipse(TRect(size));

   268 	delete gc;

   269 	delete bitmapDevice;

   270 	for(TInt count=0;count<10;count++)

   271 		{

   272 		iGc->Clear();

   273 		TPoint pos(0,0);

   274 		for(TInt xcount=0;xcount<25;xcount++,pos.iX+=size.iWidth)

   275 			{

   276 			pos.iY=0;

   277 			for(TInt ycount=0;ycount<4;ycount++,pos.iY+=size.iHeight)

   278 				iGc->BitBlt(pos,bitmap);

   279 			}

   280 		}

   281 	delete bitmap;

   282 	}

   283 

   284 TInt BitBltTestFunc(TInt aOwningGroup)

   285 	{

   286 	return(CreateGraphicsTest(aOwningGroup, EBitBltTest, 0, NULL));

   287 	}

   288 

   289 GLDEF_D TTimeTestHeader BitBltTest={_S("BitBlt"),BitBltTestFunc};

   290 

   291 // Full Screen BitBlt //

   292 

   293 void TGraphicsTest::FullScreenBitBltTestL(TInt , TAny *)

   294 	{

   295 	CWsBitmap *bitmap=new(ELeave) CWsBitmap(iWs);

   296 	TSize size(640,240);

   297 	User::LeaveIfError(bitmap->Create(size,EGray4));

   298 	CFbsDevice *bitmapDevice=CFbsBitmapDevice::NewL(bitmap);

   299 	CFbsBitGc *gc=CFbsBitGc::NewL();

   300 	gc->Activate(bitmapDevice);

   301 	for(TInt pos=0;pos<size.iWidth;pos+=8)

   302 		{

   303 		gc->DrawRect(TRect(pos,0,pos+16,size.iHeight));

   304 		iGc->BitBlt(TPoint(0,0),bitmap);

   305 		iWs.Flush();

   306 		}

   307 	delete gc;

   308 	delete bitmapDevice;

   309 	delete bitmap;

   310 	}

   311 

   312 TInt FullScreenBitBltTestFunc(TInt aOwningGroup)

   313 	{

   314 	return(CreateGraphicsTest(aOwningGroup, EFullScreenBitBltTest, 0, NULL));

   315 	}

   316 

   317 GLDEF_D TTimeTestHeader FullScreenBitBltTest={_S("FullScreenBitBlt"),FullScreenBitBltTestFunc};

   318 

   319 // Masked BitBlt //

   320 

   321 void TGraphicsTest::MaskedBitBltTestL(TInt , TAny *)

   322 	{

   323 	TSize size(24,48);

   324 	CWsBitmap *bitmap=new(ELeave) CWsBitmap(iWs);

   325 	bitmap->Create(size,EGray4);

   326 	CFbsDevice *bitmapDevice=CFbsBitmapDevice::NewL(bitmap);

   327 	CFbsBitGc *gc=CFbsBitGc::NewL();

   328 	gc->Activate(bitmapDevice);

   329 	gc->DrawEllipse(TRect(size));

   330 	delete bitmapDevice;

   331 // Now do the mask

   332 	CWsBitmap *mask=new(ELeave) CWsBitmap(iWs);

   333 	mask->Create(size,EGray4);

   334 	bitmapDevice=CFbsBitmapDevice::NewL(mask);

   335 	gc->Activate(bitmapDevice);

   336 	gc->SetPenColor(TRgb::Gray4(3));

   337 	gc->DrawEllipse(TRect(size));

   338 	delete bitmapDevice;

   339 //

   340 	delete gc;

   341 	for(TInt count=0;count<10;count++)

   342 		{

   343 		iGc->Clear();

   344 		TPoint pos(0,0);

   345 		for(TInt xcount=0;xcount<25;xcount++,pos.iX+=size.iWidth+1)

   346 			{

   347 			pos.iY=0;

   348 			for(TInt ycount=0;ycount<4;ycount++,pos.iY+=size.iHeight)

   349 				iGc->BitBltMasked(pos,bitmap,TRect(size),mask,EFalse);

   350 			}

   351 		}

   352 	delete bitmap;

   353 	delete mask;

   354 	}

   355 

   356 TInt MaskedBitBltTestFunc(TInt aOwningGroup)

   357 	{

   358 	return(CreateGraphicsTest(aOwningGroup, EMaskedBitBltTest, 0, NULL));

   359 	}

   360 

   361 GLDEF_D TTimeTestHeader MaskedBitBltTest={_S("MaskedBitBlt"),MaskedBitBltTestFunc};

   362 

   363 // Fill Pattern //

   364 

   365 void TGraphicsTest::FillPatternTestL(TInt , TAny *)

   366 	{

   367 	TSize scrSize(iDevice->SizeInPixels());

   368 	TSize rectSize(scrSize.iWidth/5-1,scrSize.iHeight/2);

   369 

   370 	CWsBitmap *bitmap=new(ELeave) CWsBitmap(iWs);

   371 

   372 	TSize bitmapSize(50,40);

   373 	bitmap->Create(bitmapSize,EGray4);

   374 	CFbsDevice *bitmapDevice=CFbsBitmapDevice::NewL(bitmap);

   375 	CFbsBitGc *gc=CFbsBitGc::NewL();

   376 	gc->Activate(bitmapDevice);

   377 	gc->SetBrushColor(TRgb::Gray4(2));

   378 	gc->SetBrushStyle(CGraphicsContext::ESolidBrush);

   379 	gc->DrawEllipse(TRect(bitmapSize));

   380 	delete bitmapDevice;

   381 	delete gc;

   382 //

   383 	iGc->UseBrushPattern(bitmap);

   384 	iGc->SetBrushStyle(CGraphicsContext::EPatternedBrush);

   385 	iGc->SetPenStyle(CGraphicsContext::ESolidPen);

   386 	for(TInt count=0;count<50;count++)

   387 		{

   388 		iGc->Clear();

   389 		TPoint pos(0,0);

   390 		for(TInt xcount=0;xcount<5;xcount++,pos.iX+=rectSize.iWidth)

   391 			{

   392 			pos.iY=0;

   393 			for(TInt ycount=0;ycount<2;ycount++,pos.iY+=rectSize.iHeight)

   394 				iGc->DrawRect(TRect(pos,rectSize));

   395 			}

   396 		}

   397 	delete bitmap;

   398 	}

   399 

   400 TInt FillPatternTestFunc(TInt aOwningGroup)

   401 	{

   402 	return(CreateGraphicsTest(aOwningGroup, EFillPatternTest, 0, NULL));

   403 	}

   404 

   405 GLDEF_D TTimeTestHeader FillPatternTest={_S("FillPattern"),FillPatternTestFunc};

   406 

   407 // Backup Window Drawing //

   408 

   409 void TGraphicsTest::BackedUpWindowDrawingL(TInt aMode, TAny *)

   410 	{

   411 	TSize scrSize(iDevice->SizeInPixels());

   412 	CFbsFont *font=NULL;

   413 	if (aMode==1)

   414 		{

   415 		TFontSpec fspec(KTestFontTypefaceName,200);

   416 		User::LeaveIfError(iDevice->GetNearestFontToDesignHeightInTwips((CFont *&)font, fspec));

   417 		iGc->UseFont(font);

   418 		}

   419 	iGc->SetPenStyle(CGraphicsContext::ESolidPen);

   420 	TPoint pos;

   421 	for(TInt count=0;count<10;count++)

   422 		{

   423 		iGc->Clear();

   424 		for(pos.iY=0;pos.iY<scrSize.iHeight;pos.iY++)

   425 			iGc->DrawLine(pos,pos+TSize(scrSize.iWidth,0));

   426 		}

   427 	if (aMode==1)

   428 		iDevice->ReleaseFont(font);

   429 	}

   430 

   431 TInt BackupWindowDrawingFunc1(TInt aOwningGroup)

   432 	{

   433 	return(CreateGraphicsTest(aOwningGroup, EBackupWindowDrawingTest, 0, NULL));

   434 	}

   435 

   436 GLDEF_D TTimeTestHeader BackupWindowDrawingCreate1={_S("BackupWindowDrawing 1"),BackupWindowDrawingFunc1};

   437 

   438 TInt BackupWindowDrawingFunc2(TInt aOwningGroup)

   439 	{

   440 	return(CreateGraphicsTest(aOwningGroup, EBackupWindowDrawingTest, 1, NULL));

   441 	}

   442 

   443 GLDEF_D TTimeTestHeader BackupWindowDrawingCreate2={_S("BackupWindowDrawing 2"),BackupWindowDrawingFunc2};
Symaptic