1 // Copyright (c) 1995-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 // Automatically test the window server

    15 // 

    16 //

    17 

    18 

    19 #include <e32std.h>

    20 #include <w32std.h>

    21 #include <e32svr.h>

    22 #include <hal.h>

    23 #include "../tlib/testbase.h"

    24 #include <stdlib.h>

    25 #include "AUTO.H"

    26 

    27 LOCAL_D const TUint KPanicThreadHeapSize=0x8000;

    28 

    29 GLREF_C TInt ProcPriTestOtherProcess(TAny *aScreenNumber);

    30 GLREF_C TInt ProcToKill(TAny *aScreenNumber);

    31 GLREF_C TInt ProcDirect(TAny *aScreenNumber);

    32 GLREF_C TInt ProcMultiDisplay(TAny *aScreenNumber);

    33 

    34 _LIT(Priority,"ProcPriTest");

    35 _LIT(ToKill,"ProcToKill");

    36 _LIT(Direct,"ProcDirect");

    37 _LIT(MultiDisplay,"ProcMultiDisplay");

    38 

    39 CProcess::TInitialFunction CProcess::iFunctions[]=

    40 	{

    41 	TInitialFunction(Priority,ProcPriTestOtherProcess),

    42 	TInitialFunction(ToKill,ProcToKill),

    43 	TInitialFunction(Direct,ProcDirect),

    44 	TInitialFunction(MultiDisplay,ProcMultiDisplay)

    45 	};

    46 

    47 GLDEF_D TestWindow *BaseWin;

    48 GLDEF_D TestWindow *TestWin;

    49 GLDEF_D TestClient *TheClient=NULL;

    50 GLDEF_D CWindowGc *TheGc;

    51 TInt CTestBase::iMaxGrays=0;

    52 TInt CTestBase::iScreenNo=0;

    53 TInt CTestBase::iMaxColors=0;

    54 TInt CTestBase::iNumberTestsPass=0;

    55 TInt CTestBase::iNumberTests=0;

    56 TRect CTestBase::iNormalPointerCursorArea;

    57 TPartialRedrawType CTestBase::iRedrawType=EPartialRedraw_Unknown;

    58 TInt CTestBase::iNumberOfGrpWndsOnPrimaryScreenWithZeroPriority = 0;

    59 TInt CTestDriver::iTestNum=0;

    60 

    61 GLDEF_D TInt TheTestResult=ETestPassed; // start with passed to anticipate empty test table

    62 

    63 const TInt KBorderWinWidth = 5;

    64 

    65 _LIT(Auto,"AUTO ");

    66 

    67 TInt64 TTestRects::iSeed=0;

    68 TRect TTestRects::iList[]={

    69 // 0-5

    70 	TRect(2,2,2,2),

    71 	TRect(2,2,2,2),

    72 	TRect(2,2,2,2),

    73 	TRect(2,2,2,2),

    74 	TRect(2,2,2,2),

    75 // 5-13

    76 	TRect(0,0,0,0),

    77 	TRect(2,0,2,0),

    78 	TRect(4,0,4,0),

    79 	TRect(0,2,0,2),

    80 	TRect(2,2,2,2),

    81 	TRect(4,2,4,2),

    82 	TRect(0,4,0,4),

    83 	TRect(2,4,2,4),

    84 	TRect(4,4,4,4),

    85 // 13-22

    86 	TRect(0,0,1,1),

    87 	TRect(1,0,3,1),

    88 	TRect(3,0,4,1),

    89 	TRect(0,1,1,3),

    90 	TRect(1,1,3,3),

    91 	TRect(3,1,4,3),

    92 	TRect(0,3,1,4),

    93 	TRect(1,3,3,4),

    94 	TRect(3,3,4,4),

    95 // 23-31

    96 	TRect(0,0,2,0),

    97 	TRect(2,0,4,0),

    98 	TRect(0,0,4,0),

    99 	TRect(0,2,2,2),

   100 	TRect(2,2,4,2),

   101 	TRect(0,2,4,2),

   102 	TRect(0,4,2,4),

   103 	TRect(2,4,4,4),

   104 	TRect(0,4,4,4),

   105 // 32-40

   106 	TRect(0,0,0,2),

   107 	TRect(0,2,0,4),

   108 	TRect(0,0,0,4),

   109 	TRect(2,0,2,2),

   110 	TRect(2,2,2,4),

   111 	TRect(2,0,2,4),

   112 	TRect(4,0,4,2),

   113 	TRect(4,2,4,4),

   114 	TRect(4,0,4,4),

   115 // 41-44

   116 	TRect(0,0,2,2),

   117 	TRect(2,0,4,2),

   118 	TRect(0,2,2,4),

   119 	TRect(2,2,4,4),

   120 // 45-48

   121 	TRect(0,0,3,3),

   122 	TRect(1,0,4,3),

   123 	TRect(0,1,3,4),

   124 	TRect(1,1,4,4),

   125 // 49

   126 	TRect(0,0,4,4),

   127 // 40-53

   128 	TRect(1,2,2,2),

   129 	TRect(2,2,3,2),

   130 	TRect(2,1,2,2),

   131 	TRect(2,2,3,2),

   132 // 54-59

   133 	TRect(1,2,3,2),

   134 	TRect(2,1,2,3),

   135 	TRect(1,1,2,2),

   136 	TRect(1,2,2,3),

   137 	TRect(2,2,3,3),

   138 	TRect(2,1,3,2),

   139 // 60-63

   140 	TRect(1,1,3,2),

   141 	TRect(1,1,2,3),

   142 	TRect(1,2,3,3),

   143 	TRect(2,1,3,3)};

   144 

   145 #if defined(__WINS__)

   146 void FindNonMatchingPixelL(TPoint aPt1,TPoint aPt2,TSize aSize)

   147 // This function is purely for use when debugging to find the first non-matching pixel

   148 // when a check of two on screen rects has failed.

   149 	{

   150 	HBufC8* buf1=HBufC8::NewMaxLC(2*aSize.iWidth);

   151 	HBufC8* buf2=HBufC8::NewMaxLC(2*aSize.iWidth);

   152 	TPtr8 ptr1=buf1->Des();

   153 	TPtr8 ptr2=buf2->Des();

   154 	TInt row=0;

   155 	TBool ret = true;

   156 	for (;row<aSize.iHeight;++row)

   157 		{

   158 		TheClient->iScreen->GetScanLine(ptr1,aPt1,aSize.iWidth,EColor64K);

   159 		TheClient->iScreen->GetScanLine(ptr2,aPt2,aSize.iWidth,EColor64K);

   160 		if (ptr1!=ptr2)

   161 			break;

   162 		++aPt1.iY;

   163 		++aPt2.iY;

   164 		}

   165 	TRgb color1,color2;

   166 	if (row<aSize.iHeight)

   167 		{

   168 		for (TInt col=0;col<aSize.iWidth;++col)

   169 			{

   170 			TheClient->iScreen->GetPixel(color1,aPt1);

   171 			TheClient->iScreen->GetPixel(color2,aPt2);

   172 			if (color1!=color2)

   173 				{	// Break here to find first pixel that didn't match.

   174 				TBuf<256> buf;

   175 				_LIT(KFindNonMatchingPixelFmt,"First non matching pixel (%d,%d)");

   176 				buf.Format(KFindNonMatchingPixelFmt,col,row);

   177 				TheClient->iWs.LogMessage(buf);

   178 				break;

   179 				

   180 				}

   181 			++aPt1.iX;

   182 			++aPt2.iX;

   183 			}

   184 		}

   185 	CleanupStack::PopAndDestroy(2);

   186 	}

   187 

   188 void FindNonMatchingPixel(TPoint aPt1,TPoint aPt2,TSize aSize)

   189 	{

   190 	TRAPD(ignore,FindNonMatchingPixelL(aPt1,aPt2,aSize));

   191 	}

   192 #endif

   193 

   194 void AutoPanic(TInt aPanic)

   195 	{

   196 	User::Panic(_L("Auto"),aPanic);

   197 	}

   198 

   199 void CleanUpWindow(TAny *aWindow)

   200 	{

   201 	((RWindowTreeNode  *)aWindow)->Close();

   202 	}

   203 

   204 void PushWindowL(RWindowTreeNode *aWindow)

   205 	{

   206 	CleanupStack::PushL(TCleanupItem(CleanUpWindow,aWindow));

   207 	}

   208 

   209 

   210 TBool OpacityAndAlphaSupportedL()

   211 	{

   212 	// If opacity is not implemented, EFalse will be returned

   213 	if(TransparencySupportedL()!=KErrNone)

   214 		return EFalse;

   215 

   216 	const TRgb KTransparencyColor(0,0,0);

   217 	RWindow winb(TheClient->iWs);

   218 	CleanupClosePushL(winb);

   219 	RWindow wint(TheClient->iWs);

   220 	CleanupClosePushL(wint);

   221 	User::LeaveIfError(winb.Construct(*TheClient->iGroup->GroupWin(), ENullWsHandle));

   222 	User::LeaveIfError(wint.Construct(*TheClient->iGroup->GroupWin(), ENullWsHandle));

   223 	winb.SetExtent(TPoint(0,0), TSize(50,50));

   224 	wint.SetExtent(TPoint(0,0), TSize(50,50));

   225 	winb.SetRequiredDisplayMode(EColor256);

   226 	wint.SetRequiredDisplayMode(EColor256);

   227 	wint.SetTransparencyFactor(KTransparencyColor);

   228 	winb.SetBackgroundColor(TRgb(0,0,255));

   229 	wint.SetBackgroundColor(TRgb(255,0,0));

   230 	winb.Activate();

   231 	wint.Activate();

   232 

   233 	wint.BeginRedraw();

   234 	TheClient->iGc->Activate(wint);

   235 	TheClient->iGc->SetOpaque(ETrue);

   236 	TheClient->iGc->SetPenStyle(CGraphicsContext::ENullPen);

   237 	TheClient->iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

   238 	TheClient->iGc->SetBrushColor(TRgb(0,255,0));

   239 	TheClient->iGc->DrawRect(TRect(TPoint(0,0), TSize(50,50)));

   240 	TheClient->iGc->SetOpaque(EFalse);

   241 	TheClient->iGc->Deactivate();

   242 	wint.EndRedraw();

   243 	TheClient->Flush();

   244 

   245 	// The window should be all green, if opacity is working, or all blue if it isn't.

   246 	// If the window has any other colour, then something has broken.

   247 	TRgb color;

   248 	TheClient->iScreen->GetPixel(color,TPoint(25,25));

   249 	if (color.Red()>0 || ((color.Green()==0) == (color.Blue()==0)))

   250 		User::Leave(KErrGeneral);

   251 	TBool ret=(color.Green()>0);

   252 

   253 	CleanupStack::PopAndDestroy(2,&winb); // wint

   254 	return ret;

   255 	}

   256 

   257 TInt TransparencySupportedL()

   258 	{

   259 	// Creates a window and enables alpha transparency, if this feature

   260 	// is not enabled, KErrNotSupported will be returned

   261 	RWindow win(TheClient->iWs);

   262 	User::LeaveIfError(win.Construct(*TheClient->iGroup->GroupWin(), ENullWsHandle));

   263 	win.SetExtent(TPoint(0,0), TSize(50,50));

   264 	TInt ret=win.SetTransparencyAlphaChannel();

   265 	win.Close();

   266 	return ret;

   267 	}

   268 

   269 TInt CheckScalingSupportedOrNot()

   270 	{

   271 	TBool scalingSupported=EFalse;

   272 	TSizeMode originalModeData=TheClient->iScreen->GetCurrentScreenModeAttributes();

   273 	TSizeMode tempData=originalModeData;

   274 	tempData.iScreenScale=TSize(2,2);

   275 	TheClient->iScreen->SetCurrentScreenModeAttributes(tempData);

   276 	TSize scale=TheClient->iScreen->GetCurrentScreenModeScale();

   277 	if (scale.iWidth==2 && scale.iHeight==2)

   278 		{

   279 		scalingSupported=ETrue;

   280 		}

   281 	TheClient->iScreen->SetCurrentScreenModeAttributes(originalModeData);

   282 	TheClient->Flush();

   283 	return scalingSupported;

   284 	}

   285 

   286 TBool CheckNonZeroOriginsSupportedOrNot()

   287 	{

   288 	TBool nonZeroOriginsSupported=EFalse;

   289 	TSizeMode sizeMode1=TheClient->iScreen->GetCurrentScreenModeAttributes();

   290 	TSizeMode sizeMode2=sizeMode1;

   291 	sizeMode2.iOrigin=TPoint(30,30);

   292 	TheClient->iScreen->SetCurrentScreenModeAttributes(sizeMode2);

   293 	TPoint origin=TheClient->iScreen->GetCurrentScreenModeScaledOrigin();

   294 	if (origin.iX==30 && origin.iY==30)

   295 		{

   296 		nonZeroOriginsSupported=ETrue;

   297 		}

   298 	TheClient->iScreen->SetCurrentScreenModeAttributes(sizeMode1);

   299 	TheClient->Flush();

   300 	return nonZeroOriginsSupported;

   301 	}

   302 

   303 TPoint PhysicalToLogical(TPoint aPhysicalPtMinusOrigin,TSize aScale)

   304 	{

   305 	TPoint logicalPt(aPhysicalPtMinusOrigin);

   306 	if (aScale.iWidth!=1)

   307 		{

   308 		logicalPt.iX=(logicalPt.iX>= 0 ? logicalPt.iX/aScale.iWidth : (logicalPt.iX-(aScale.iWidth-1))/aScale.iWidth);

   309 		}

   310 	if (aScale.iHeight!=1)

   311 		{

   312 		logicalPt.iY=(logicalPt.iY>= 0 ? logicalPt.iY/aScale.iHeight : (logicalPt.iY-(aScale.iHeight-1))/aScale.iHeight);

   313 		}

   314 	return logicalPt;

   315 	}

   316 

   317 //

   318 // Log window, logs testing //

   319 //

   320 

   321 LogWindow::LogWindow() : CTWin(), iTestTitle(KNullDesC), iSubTitle(KNullDesC), iMessage(KNullDesC)

   322 	{}

   323 

   324 void LogWindow::ConstructL(CTWinBase &parent)

   325 	{

   326 	CTWin::ConstructL(parent);

   327 	iTitleHeight=iFont->HeightInPixels()+4;

   328 	}

   329 

   330 void LogWindow::DrawSubTitle()

   331 	{

   332 	iGc->DrawText(iSubTitle, TRect(2,iTitleHeight*2,iSize.iWidth-2,iTitleHeight*3),iFont->AscentInPixels(), CGraphicsContext::ECenter);

   333 	}

   334 

   335 void LogWindow::DrawMessage()

   336 	{

   337 	iGc->DrawText(iMessage, TRect(1,iTitleHeight*4,iSize.iWidth-2,iTitleHeight*5),iFont->AscentInPixels(), CGraphicsContext::ECenter);

   338 	}

   339 

   340 void LogWindow::Draw()

   341 	{

   342 	iGc->SetPenColor(TRgb::Gray16(8));

   343 	iGc->SetPenColor(TRgb::Gray16(0));

   344 	DrawBorder();

   345 	iGc->DrawLine(TPoint(0,iTitleHeight),TPoint(iSize.iWidth,iTitleHeight));

   346 	iGc->DrawText(iTestTitle, TPoint((iSize.iWidth-iFont->TextWidthInPixels(iTestTitle))/2,iFont->AscentInPixels()+2));

   347 	DrawSubTitle();

   348 	DrawMessage();

   349 	}

   350 

   351 /**

   352 This function is not used at the moment but I leave it in in case I need it when I improve the logging in 

   353 the log window.

   354 */

   355 void LogWindow::LogTest(const TDesC &aTitle,TInt aNum)

   356 	{

   357 	_LIT(Test,"Test %d,%S");

   358 	iTestTitle.Format(Test,aNum,&aTitle);

   359 	TLogMessageText buf;

   360 	_LIT(AutoNewTest,"AUTO New Test: ");

   361 	buf.Append(AutoNewTest);

   362 	buf.Append(iTestTitle);

   363 	TheClient->LogMessage(buf);

   364 	iMessage.Zero();

   365 	iWin.Invalidate();

   366 	}

   367 

   368 /**

   369 This function is not used at the moment but I leave it in in case I need it when I improve the logging in 

   370 the log window.

   371 */

   372 const TDesC& LogWindow::LogSubTest(const TDesC &aTitle,TInt aNum)

   373 	{

   374 	_LIT(SubTest,"Sub-Test[%d], %S");

   375 	iSubTitle.Format(SubTest,aNum,&aTitle);

   376 	TLogMessageText buf;

   377 	buf.Append(Auto);

   378 	buf.Append(iSubTitle);

   379 	TheClient->LogMessage(buf);

   380 	iMessage.Zero();

   381 	iGc->Activate(iWin);

   382 	iGc->UseFont((CFont *)iFont);

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

   384 	DrawSubTitle();

   385 	DrawMessage();

   386 	iGc->Deactivate();

   387 	TheClient->iWs.Flush();

   388 	return iSubTitle;

   389 	}

   390 

   391 const TDesC& LogWindow::LogMessage(TBool aLog,const TDesC& aText,TInt aNum)

   392 	{

   393 	if (aNum!=EDummyValue)

   394 		{

   395 		_LIT(StringInt,"%S %d");

   396 		iMessage.Format(StringInt,&aText,aNum);

   397 		}

   398 	else

   399 		{

   400 		_LIT(String,"%S");

   401 		iMessage.Format(String,&aText);

   402 		}

   403 	iGc->Activate(iWin);

   404 	iGc->UseFont((CFont *)iFont);

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

   406 	DrawMessage();

   407 	iGc->Deactivate();

   408 	if (aLog)

   409 		{

   410 		TLogMessageText buf;

   411 		buf.Append(Auto);

   412 		buf.Append(iMessage);

   413 		TheClient->LogMessage(buf);

   414 		}

   415 	TheClient->iWs.Flush();

   416 	return iMessage;

   417 	}

   418 

   419 

   420 //

   421 // Test window, simple window used to do test graphics in //

   422 //

   423 TestWindow::TestWindow() : CTWin()

   424 	{

   425 	}

   426 

   427 TestWindow::~TestWindow()

   428 	{

   429 	delete iBorderWin;

   430 	}

   431 

   432 void TestWindow::SetUpL(TPoint pos,TSize size,CTWinBase *parent, CWindowGc &aGc)

   433 	{

   434 	iBorderWin=new(ELeave) CBorderWindow();

   435 	iBorderWin->SetUpL(pos,size,parent,aGc);

   436 	TRAPD(err, CTWin::ConstructL(*iBorderWin));

   437 	if (err==KErrNone)

   438 		{

   439 		SetExt(TPoint(2,2),TSize(size.iWidth-4,size.iHeight-4));

   440 		if (err==KErrNone)

   441 			{

   442 			Activate();

   443 			AssignGC(aGc);

   444 			return;

   445 			}

   446 		}

   447 	delete this;

   448 	User::Leave(err);

   449 	}

   450 

   451 void TestWindow::Draw()

   452 	{

   453 	iGc->Clear();

   454 	}

   455 

   456 void TestWindow::ClearWin()

   457 	{

   458 	TheGc->Activate(*Win());

   459 	TheGc->Clear();

   460 	TheGc->Deactivate();

   461 	}

   462 	

   463 void TestWindow::SetBorderExt(TPoint aPos, TSize aSize)

   464 	{

   465 	iBorderWin->SetExt(aPos, aSize);

   466 	}

   467 

   468 CBorderWindow* TestWindow::GetBorderWin()

   469 	{

   470 	return iBorderWin;

   471 	}

   472 //

   473 CBorderWindow::CBorderWindow() : CTWin()

   474 	{

   475 	}

   476 

   477 void CBorderWindow::ConstructL(CTWinBase &parent)

   478 	{

   479 	CTWin::ConstructL(parent);

   480 	}

   481 

   482 void CBorderWindow::Draw()

   483 	{

   484 	iGc->SetBrushColor(TRgb::Gray16(0));

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

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

   487 	iGc->DrawRect(TRect(Size()));

   488 	}

   489 

   490 //

   491 

   492 TestWindowGroup::TestWindowGroup(CTClient *aClient) : CTWindowGroup(aClient)

   493 	{

   494 	}

   495 

   496 void TestWindowGroup::BecomeOwning()

   497 	{

   498 	iGroupWin.DefaultOwningWindow();

   499 	}

   500 

   501 void TestWindowGroup::KeyL(const TKeyEvent &aKey,const TTime &aTime)

   502 	{

   503 	if (aKey.iModifiers&EModifierFunc)

   504 		{

   505 		switch(aKey.iCode)

   506 			{

   507 			case 'f':

   508 				TheClient->Driver()->iTest->TriggerFail();

   509 				break;

   510 			}

   511 		}

   512 	else if (iCurWin)

   513 		iCurWin->WinKeyL(aKey,aTime);

   514 	}

   515 

   516 void TestWindowGroup::KeyDownL(const TKeyEvent &aKey,const TTime &aTime)

   517 	{

   518 	if (iCurWin)

   519 		iCurWin->KeyDownL(aKey,aTime);

   520 	}

   521 

   522 void TestWindowGroup::KeyUpL(const TKeyEvent &aKey,const TTime &aTime)

   523 	{

   524 	if (iCurWin)

   525 		iCurWin->KeyUpL(aKey,aTime);

   526 	}

   527 

   528 //

   529 

   530 TestClient::TestClient()

   531 	{}

   532 

   533 void TestClient::ConstructL()

   534 	{

   535 	CTClient::ConstructL();

   536 

   537 	iGroup=new(ELeave) TestWindowGroup(this);

   538 	iGroup->ConstructL();

   539 

   540 	iScreen->GetScreenSizeModeList(&iScreenModes);

   541 	iScreen->SetScreenMode(iScreenModes[0]);

   542 	TSize screenSize=iScreen->SizeInPixels();

   543 

   544 	TInt winWidth=(screenSize.iWidth/3)-10;

   545 	TInt winHeight=screenSize.iHeight-10;

   546 	iStdLogWindow=new(ELeave) LogWindow();

   547 	iStdLogWindow->SetUpL(TPoint(5,5),TSize(winWidth,winHeight),iGroup,*iGc);

   548 	BaseWin=new(ELeave) TestWindow();

   549 	BaseWin->SetUpL(TPoint(screenSize.iWidth/3+5,5),TSize(winWidth,winHeight),iGroup,*iGc);

   550 	TestWin=new(ELeave) TestWindow();

   551 	TestWin->SetUpL(TPoint(screenSize.iWidth/3*2+5,5),TSize(winWidth,winHeight),iGroup,*iGc);

   552 

   553 	iDriver = CTestDriver::CreateL(iScreenNumber); // virtual constructor

   554 

   555 	TheGc=new(ELeave) CWindowGc(iScreen);

   556 	User::LeaveIfError(TheGc->Construct());

   557 

   558 	_LIT(KTestLog,"WSERV Auto Test Log");

   559 	LogMessage(KTestLog());

   560 	LogAvailableScreenModeL();

   561 	

   562 	//This class was designed to be created once and reused by all the tests, now it is created for each test,

   563 	//this needs to be changed back so tests like the following are only done once.

   564 	TestWsSetBufferSizeL();

   565 	TestWsSetMaxBufferSizeL();

   566 	}

   567 	

   568 inline CTestDriver* TestClient::Driver()

   569 	{

   570 	return iDriver;

   571 	}

   572 

   573 TBool TestClient::WaitForEvent()

   574 	{

   575 	if (iEventHandler->iStatus!=KRequestPending)

   576 		return ETrue;

   577 	else if (iRedrawEventHandler->iStatus!=KRequestPending)

   578 		return EFalse;

   579 	User::WaitForRequest(iEventHandler->iStatus,iRedrawEventHandler->iStatus);

   580 	TRequestStatus* status=&iEventHandler->iStatus;

   581 	TBool ret=ETrue;

   582 	if (iEventHandler->iStatus==KRequestPending)

   583 		{

   584 		status=&iRedrawEventHandler->iStatus;

   585 		ret=EFalse;

   586 		}

   587 	TInt reason=status->Int();

   588 	*status=KRequestPending;

   589 	User::RequestComplete(status,reason);

   590 	return ret;

   591 	}

   592 

   593 TBool TestClient::IsEventWaiting()

   594 	{

   595 	return (iEventHandler->iStatus!=KRequestPending || iRedrawEventHandler->iStatus!=KRequestPending);

   596 	}

   597 

   598 TestClient::~TestClient()

   599 	{

   600 	iScreenModes.Close();

   601 	delete iDriver;

   602 	delete TheGc;

   603 	delete iStdLogWindow;

   604 	delete BaseWin;

   605 	delete TestWin;

   606 	}

   607 

   608 void TestClient::LogAvailableScreenModeL()

   609 	{

   610 	_LIT(KColorModes,"Color Modes: ");

   611 	_LIT(KComma,", ");

   612 	_LIT(KColor,"Color");

   613 	_LIT(KGrey,"Grey");

   614 	CArrayFixFlat<TInt>* modeList=new(ELeave) CArrayFixFlat<TInt>(15);

   615 	iWs.GetColorModeList(modeList);

   616 	TLogMessageText buf,buf2;

   617 	buf.Append(KColorModes);

   618 	TDisplayMode mode;

   619 	TInt ii=0;

   620 	FOREVER

   621 		{

   622 		mode=STATIC_CAST(TDisplayMode,(*modeList)[ii]);

   623 		buf.AppendNum((*modeList)[ii]);

   624 		buf2.Append(TDisplayModeUtils::IsDisplayModeColor(mode)?KColor():KGrey());

   625 		buf2.AppendNum(TDisplayModeUtils::NumDisplayModeColors(mode));

   626 		if (mode==EColor16MU)

   627 			buf2.Append('U');

   628 		if (++ii==modeList->Count())

   629 			break;

   630 		buf.Append(KComma);

   631 		buf2.Append(KComma);

   632 		}

   633 	LogMessage(buf);

   634 	LogMessage(buf2);

   635 	delete modeList;

   636 	}

   637 

   638 void TestClient::TestWsSetBufferSizeL()

   639 	{

   640 	RWsSession ws;

   641 	User::LeaveIfError(ws.Connect());

   642 	ws.SetBufferSizeL(256);		// default buffer size 640

   643 	ws.SetBufferSizeL(0x8000);	// 16K is max buffer size

   644 	ws.SetBufferSizeL(0x4000);

   645 	ws.Close();

   646 	}

   647 

   648 void TestClient::TestWsSetMaxBufferSizeL() 

   649 	{

   650 	RWsSession ws;

   651 	User::LeaveIfError(ws.Connect());

   652 	// allow buffer to grow bigger than the default 640 bytes

   653 	const TInt KBigMessageSize = 800;

   654 	ws.SetMaxBufferSizeL(KBigMessageSize + 8);	// big message + command header length

   655 	

   656 	// send the big message to the wserv

   657 	TBuf8<KBigMessageSize>	bigMessage;

   658 

   659 	// LogMessage needs a pointer to a TInt with the message size at the start of the buffer

   660 	const TInt szLength = sizeof(TInt);

   661 	TInt length = KBigMessageSize - szLength;			// length in Unicode characters

   662 	bigMessage.Append((TUint8*) &length, szLength);

   663 

   664 	_LIT(KLetterA, "a");

   665 	do 

   666 		{

   667 		bigMessage.Append((TUint8*) KLetterA().Ptr(), 2);

   668 		}

   669 		while (bigMessage.Length() < KBigMessageSize);

   670 

   671 	// send to Wserv, note that the message is too long to be logged

   672 	ws.TestWrite(ws.WsHandle(), EWsClOpLogMessage, bigMessage.Ptr(), KBigMessageSize);

   673 	ws.Flush();

   674 

   675 	ws.Close();

   676 	}

   677 

   678 void TestClient::SetTestClientScreenMode(TInt aMode)

   679 	{

   680 	iScreen->SetAppScreenMode(aMode);

   681 	iScreen->SetScreenMode(aMode);

   682 	UpdateTestClientScreenMode();

   683 	}

   684 	

   685 void TestClient::UpdateTestClientScreenMode()

   686 	{

   687 	TSize screenSize=iScreen->SizeInPixels();

   688 

   689 	// Sets new positions and dimensions for the three window and their controlling border windows

   690 	

   691 	if (screenSize.iHeight > screenSize.iWidth)		// Portrait mode

   692 		{

   693 		TInt winWidth=screenSize.iWidth - (KBorderWinWidth * 2);

   694 		TInt winHeight=(screenSize.iHeight/3) - (KBorderWinWidth * 2);

   695 		

   696 		iStdLogWindow->SetExt(TPoint(KBorderWinWidth,KBorderWinWidth),TSize(winWidth,winHeight));

   697 		BaseWin->SetBorderExt(TPoint(KBorderWinWidth,screenSize.iHeight/3+KBorderWinWidth),TSize(winWidth,winHeight));

   698 		BaseWin->SetExt(TPoint(2,2),TSize(winWidth - (KBorderWinWidth - 1),winHeight - (KBorderWinWidth - 1)));

   699 		TestWin->SetBorderExt(TPoint(KBorderWinWidth,screenSize.iHeight/3*2+KBorderWinWidth),TSize(winWidth,winHeight));

   700 		TestWin->SetExt(TPoint(2,2),TSize(winWidth - (KBorderWinWidth - 1),winHeight - (KBorderWinWidth - 1)));

   701 		}

   702 	else											// Landscape modes

   703 		{

   704 		TInt winWidth=(screenSize.iWidth/3) - (KBorderWinWidth * 2);

   705 		TInt winHeight=screenSize.iHeight - (KBorderWinWidth * 2);

   706 		

   707 		iStdLogWindow->SetExt(TPoint(KBorderWinWidth,KBorderWinWidth),TSize(winWidth,winHeight));

   708 		BaseWin->SetBorderExt(TPoint(screenSize.iWidth/3 + KBorderWinWidth,KBorderWinWidth),TSize(winWidth,winHeight));

   709 		BaseWin->SetExt(TPoint(2,2),TSize(winWidth - (KBorderWinWidth - 1),winHeight - (KBorderWinWidth - 1)));

   710 		TestWin->SetBorderExt(TPoint(screenSize.iWidth/3*2+KBorderWinWidth,KBorderWinWidth),TSize(winWidth,winHeight));	

   711 		TestWin->SetExt(TPoint(2,2),TSize(winWidth - (KBorderWinWidth - 1),winHeight - (KBorderWinWidth - 1)));		

   712 		}	

   713 		

   714 	// Remove shading artefacts from window resizing operations		

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

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

   717 	TestWin->ClearWin();

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

   719 	

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

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

   722 	BaseWin->ClearWin();

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

   724 	

   725 	TheClient->iWs.Flush();

   726 	}

   727 

   728 

   729 //

   730 // TestDriver, drives the test code //

   731 //

   732 CTestDriver* CTestDriver::CreateL(TInt aScreenNumber)

   733 	{

   734 	CTestDriver* self = NULL;

   735 	if (aScreenNumber==KDefaultScreen)

   736 		self = new (ELeave) CTestDriverPrimary(aScreenNumber);

   737 	else

   738 		self = new (ELeave) CTestDriverSecondary(aScreenNumber);

   739 

   740 	return self;

   741 	}

   742 

   743 CTestDriver::CTestDriver(TInt aScreenNumber)

   744 	: iScreenNumber(aScreenNumber)

   745 	{

   746 	iStartTime.HomeTime();

   747 	HAL::Get(HALData::EDisplayNumberOfScreens, iNumberOfScreens);

   748 	}

   749 

   750 CTestDriver::~CTestDriver()

   751 	{

   752 	}

   753 

   754 void CTestDriver::DestroyTest()

   755 	{

   756 	delete iTest;

   757 	iTest=NULL;

   758 	}

   759 

   760 void CTestDriver::TestComplete2()

   761 	{

   762 	++iTestNum;

   763 	if (iTestNum==iTestSize)

   764 		{

   765 		TBuf<64> timeBuf;

   766 		TTime endTime;

   767 		endTime.HomeTime();

   768 		TTimeIntervalMicroSeconds elapseTime=endTime.MicroSecondsFrom(iStartTime);

   769 		TInt64 elapseTime2=elapseTime.Int64()/1000;

   770 		TUint diffi = I64LOW(elapseTime2);

   771 		_LIT(TestPass,"PASSED");

   772 		_LIT(TestFail,"FAILED");

   773 		TInt noOfTests=CTestBase::iNumberTests;

   774 		TInt noOfTestsPass=CTestBase::iNumberTestsPass;

   775 		_LIT(TimeBuf,"Elapse Time  %d:%02d.%03d   %S");

   776 		timeBuf.Format(TimeBuf,diffi/60000,(diffi/1000)%60,diffi%1000000,&(noOfTests==noOfTestsPass?TestPass:TestFail));

   777 		TBuf<60> testReport;

   778 		_LIT(Checks,"Checks");

   779 		_LIT(Fails,"Fails");

   780 		_LIT(TestReport,"Tests:%d %S:%d");

   781 		TInt testNumber=(noOfTests==noOfTestsPass? noOfTestsPass : noOfTests-noOfTestsPass);

   782 		testReport.Format(TestReport,iTestNum,&(noOfTests==noOfTestsPass?Checks():Fails()),testNumber);

   783 		if (noOfTests!=noOfTestsPass)

   784 			{

   785 			_LIT(NumTests,"/%d");

   786 			testReport.AppendFormat(NumTests,noOfTests);

   787 			}

   788 

   789 		TBuf<60> logTestReport;

   790 		_LIT(LogReport," %S:%d/%d");

   791 		logTestReport.Format(LogReport,&Checks,noOfTestsPass,noOfTests);

   792 		TLogMessageText buf;

   793 		_LIT(Finished,"AUTO Testing Complete, ");

   794 		buf.Append(Finished);

   795 		buf.Append(timeBuf);

   796 		buf.Append(logTestReport);

   797 		TheClient->LogMessage(buf);

   798 

   799 		TheTestResult = noOfTests==noOfTestsPass? ETestPassed : ETestFailed;

   800 		DoDisplayDialog(timeBuf,testReport);

   801 		}

   802 	}

   803 

   804 //

   805 // Test driver for primary screen (has digitiser/pointer)

   806 //

   807 CTestDriverPrimary::CTestDriverPrimary(TInt aScreenNumber) : CTestDriver(aScreenNumber)

   808 	{

   809 	TInt i;

   810 	TInt numOfEntries = 1;

   811 	for (i=0; i<numOfEntries; ++i)

   812 		{

   813 		++iTestSize;

   814 		}

   815 

   816 	// omit multi display test (last entry in test table)

   817 	// for single screen platform

   818 	//

   819 	if (iNumberOfScreens==1)

   820 		--iTestSize;

   821 

   822 	}

   823 

   824 void CTestDriverPrimary::DoDisplayDialog(TDesC& timeBuf,TDesC& testReport)

   825 	{

   826 	DisplayDialog(_L("Auto tests complete"),timeBuf, testReport);

   827 	}

   828 

   829 //

   830 // Test driver for secondary screens

   831 //

   832 CTestDriverSecondary::CTestDriverSecondary(TInt aScreenNumber) : CTestDriver(aScreenNumber)

   833 	{

   834 	TInt i;

   835 	TInt numOfEntries = 1;

   836 	for (i=0; i<numOfEntries; ++i)

   837 		{

   838 		++iTestSize;

   839 		}

   840 	}

   841 

   842 void CTestDriverSecondary::DoDisplayDialog(TDesC& timeBuf,TDesC& testReport)

   843 	{

   844 	if (TheTestResult==ETestFailed)

   845 		DisplayDialog(iScreenNumber,_L("Auto tests complete"),timeBuf, testReport);

   846 	}

   847 

   848 // TTestRects //

   849 //

   850 // This class provides a list of rectangles to test graphics to the test windows

   851 // The list designed to test all cases total clipping, partial clipping, touching the edges,

   852 // unclipped etc etc...

   853 //

   854 // NOTE:- Quick test version, does not provide a proper list yet

   855 //

   856 // For the rectangle list the graphics area is divided into 9 logical areas:-

   857 // 0:The area above & left of the drawing area

   858 // 1:The area above but within the left & right limits of the drawing area

   859 // 2:The area above & right of the drawing area

   860 // 3:The area left of but within the top & bottom limits of the drawing area

   861 // 4:The area within the drawing area

   862 // 5:The area right of but within the top & bottom limits of the drawing area

   863 // 6:The area below & left of the drawing area

   864 // 7:The area below but within the left & right limits of the drawing area

   865 // 8:The area below & right of the drawing area

   866 //

   867 //			|		|

   868 //		0	|	1	|	2

   869 //			|		|

   870 //	-------------------------

   871 //			|		|

   872 //		3	|	4	|	5

   873 //			|		|

   874 //	-------------------------

   875 //			|		|

   876 //		6	|	7	|	8

   877 //			|		|

   878 //

   879 //

   880 // The full list of rectangles needed to test an official release is as follows:

   881 //

   882 //	0-8:	A rectangle wholly within each area (0 to 8) without touching the edges (if possible)

   883 //	9-17:	A rectangle wholly within each area and touching all bounding edges

   884 //	18-26:	A rectangle traversing each horizontal pair & triple of areas without touching the boundarys

   885 //	27-35:	A rectangle traversing each vertical pair & triple of areas without touching the boundarys

   886 //	36-39:	A rectangle traversing each 2x2 block of areas without touching the boundarys

   887 //	40-43:	A rectangle traversing each 2x2 block of areas touching each boundary

   888 //  44:		A rectangle that includes all areas

   889 //  45-48:	A rectangle fully enclosed in the central area that touches each edge

   890 //	49-54:	A rectangle fully enclosed in the central area that touches each pair of edges

   891 //	55-58:	A rectangle fully enclosed in the central area that touches each set of three edges

   892 //  59-67:	A Zero size rectangle in each of the 9 areas

   893 //	68-77:	Wide rectangles with heights from 0 to 9 in the central area

   894 //	78-87:	Tall rectangles with widths from 0 to 9 in the central area

   895 //

   896 

   897 void TTestRects::Construct(const RWindow &aWindow)

   898 	{

   899 // 59-67

   900 //		Special case, does not use rectangles from here

   901 // 68-77

   902 //		Special case, does not use rectangles from here

   903 // 78-87

   904 //		Special case, does not use rectangles from here

   905 //

   906 

   907 	iSize=aWindow.Size();

   908 /*

   909 	TInt wid=size.iWidth;

   910 	TInt hgt=size.iHeight;

   911 	TInt wid2=wid/2;

   912 	TInt hgt2=hgt/2;

   913 	TInt wid3=wid/3;

   914 	TInt hgt3=hgt/3;

   915 	TInt wid4=wid/4;

   916 	TInt hgt4=hgt/4;

   917 	TInt 2wid=wid*2;

   918 	TInt 2hgt=hgt*2;

   919 	TInt 3wid=wid*3;

   920 	TInt 3hgt=hgt*3;

   921 // 0-8

   922 	iList[0]=TRect(-wid,-hgt,-wid2,-hgt2);

   923 	iList[1]=TRect(wid3,-hgt,wid-wid3,-hgt2);

   924 	iList[2]=TRect(wid+wid2,-2hgt,2wid,-hgt);

   925 	iList[3]=TRect(-3wid,hgt3,-wid3,hgt-hgt3);

   926 	iList[4]=TRect(wid4,hgt3,wid-wid3,hgt-hgt4);

   927 	iList[5]=TRect(3wid,hgt4,wid+3wid,hgt-hgt4);

   928 	iList[6]=TRect(-wid3,hgt+hgt4,-wid2,hgt+hgt);

   929 	iList[7]=TRect(wid2,hgt+hgt4,wid-wid4,hgt+hgt3);

   930 	iList[8]=TRect(2wid,hgt+hgt4,3wid,hgt+hgt2);

   931 // 9-17

   932 	iList[9]=TRect(-wid,-hgt,0,0);

   933 	iList[10]=TRect(0,-2hgt,wid,0);

   934 	iList[11]=TRect(wid,-hgt2,wid+wid3,0);

   935 	iList[12]=TRect(-wid3,0,0,hgt);

   936 	iList[13]=TRect(0,0,wid,hgt);

   937 	iList[14]=TRect(wid,0,wid+wid4,hgt);

   938 	iList[15]=TRect(-wid,hgt,0,hgt+hgt4);

   939 	iList[16]=TRect(0,hgt,wid,hgt+hgt);

   940 	iList[17]=TRect(wid,hgt,wid+3wid,hgt+3hgt);

   941 // 18-26

   942 	iList[18]=TRect(-wid,-hgt,wid2,hgt3);

   943 	iList[19]=TRect(wid3,-2hgt,2wid,-hgt3);

   944 	iList[20]=TRect(-wid,-hgt2,wid3,-hgt3);

   945 	iList[21]=TRect(-wid3,hgt4,wid2,hgt2);

   946 	iList[22]=TRect(wid3,hgt3,wid+wid3,hgt-hgt3);

   947 	iList[23]=TRect(-wid,hgt2,wid+wid4,hgt-hgt3);

   948 	iList[24]=TRect(-wid,2hgt,wid3,3hgt);

   949 	iList[25]=TRect(wid-wid4,hgt+hgt3,wid+wid4,2hgt);

   950 	iList[26]=TRect(-wid4,hgt+hgt4,wid+wid4,3);

   951 */

   952 /*

   953 	iList[0]=TRect(0,0,size.iWidth,size.iHeight);

   954 	iList[1]=TRect(-10,-10,size.iWidth/2,size.iHeight/2);

   955 	iList[2]=TRect(size.iWidth/2,size.iHeight/2,size.iWidth+10,size.iHeight+10);

   956 	iList[3]=TRect(size.iWidth/4,size.iHeight/4,size.iWidth/2,size.iHeight/2);

   957 	iList[4]=TRect(-10,size.iHeight/4,size.iWidth+10,size.iHeight/2);

   958 */

   959 	}

   960 

   961 TInt TTestRects::Count1() const

   962 //

   963 // Count1() provides the simple base set of rectangles

   964 //

   965 	{

   966 	return(2);

   967 	}

   968 

   969 TInt TTestRects::Count2() const

   970 //

   971 // Count2() provides an increased set of rectangles for each graphics func to test itself more thoroughly

   972 //

   973 	{

   974 	return(5);

   975 	}

   976 

   977 TInt TTestRects::Count3() const

   978 //

   979 // Count3() provides the full set of rects for each graphics func to a quick test on

   980 //

   981 	{

   982 	return(88);

   983 	}

   984 

   985 /** Reset the seed value to 0. */

   986 void TTestRects::ResetSeed()

   987 	{

   988 	iSeed = 0;

   989 	}

   990 

   991 TInt TTestRects::Rnd(TInt aSize)

   992 //

   993 // Return a random based around aSize, maybe bigger maybe smaller, who knows?

   994 //

   995 	{

   996 	TInt rnd=Math::Rand(iSeed);

   997 	TInt result;

   998 	if (rnd&0x8)	// Increase from aSize

   999 		result=aSize*((rnd&0x7)+1);

  1000 	else 			// Decrease from aSize

  1001 		result=aSize/((rnd&0x7)+1);

  1002 	return(result);

  1003 	}

  1004 

  1005 TInt TTestRects::RndMax(TInt aSize)

  1006 //

  1007 // Return a random from 0 to aSize inclusive

  1008 //

  1009 	{

  1010 	TInt64 tmpl=Math::Rand(iSeed);

  1011 	TInt tmp = I64INT(tmpl) & 0xFFFF;

  1012 	tmp*=aSize;

  1013 	tmp/=0xFFFF;

  1014 	return(tmp);

  1015 	}

  1016 

  1017 TInt TTestRects::RectCoord(TInt aSection,TInt aSize)

  1018 	{

  1019 	TInt result=0;

  1020 	switch(aSection)

  1021 		{

  1022 		case 0:

  1023 			result=-(1+Rnd(aSize));

  1024 			break;

  1025 		case 1:

  1026 			result=0;

  1027 			break;

  1028 		case 2:

  1029 			result=1+RndMax(aSize-2);

  1030 			break;

  1031 		case 3:

  1032 			result=aSize;

  1033 			break;

  1034 		case 4:

  1035 			result=aSize+1+Rnd(aSize);

  1036 			break;

  1037 		default:

  1038 			AutoPanic(EAutoPanicTestRectsSection);

  1039 		}

  1040 	return(result);

  1041 	}

  1042 

  1043 void TTestRects::RectCoordPair(TInt &aTl, TInt &aBr, TInt aSection, TInt aSize)

  1044 	{

  1045 	do

  1046 		{

  1047 		aTl=RectCoord(aSection,aSize);

  1048 		aBr=RectCoord(aSection,aSize);

  1049 		} while(aTl==aBr && aSize>1);

  1050 	if (aTl>aBr)

  1051 		{

  1052 		TInt tmp=aBr;

  1053 		aBr=aTl;

  1054 		aTl=tmp;

  1055 		}

  1056 	}

  1057 

  1058 TRect TTestRects::operator[](TInt aIndex)

  1059 	{

  1060 	TRect rect;

  1061 	if (aIndex<EMaxRectFromList)

  1062 		{

  1063 		const TRect *pRect=&iList[aIndex];

  1064 		if (pRect->iTl.iX==pRect->iBr.iX)

  1065 			RectCoordPair(rect.iTl.iX,rect.iBr.iX,pRect->iTl.iX,iSize.iWidth);

  1066 		else

  1067 			{

  1068 			rect.iTl.iX=RectCoord(pRect->iTl.iX,iSize.iWidth);

  1069 			rect.iBr.iX=RectCoord(pRect->iBr.iX,iSize.iWidth);

  1070 			}

  1071 		if (pRect->iTl.iY==pRect->iBr.iY)

  1072 			RectCoordPair(rect.iTl.iY,rect.iBr.iY,pRect->iTl.iY,iSize.iHeight);

  1073 		else

  1074 			{

  1075 			rect.iTl.iY=RectCoord(pRect->iTl.iX,iSize.iHeight);

  1076 			rect.iBr.iY=RectCoord(pRect->iBr.iX,iSize.iHeight);

  1077 			}

  1078 		}

  1079 	else if (aIndex<EMaxRectZeroSize)

  1080 		{

  1081 		rect.iTl.iX=RectCoord(((aIndex-EMaxRectFromList)%3)*2,iSize.iWidth);

  1082 		rect.iTl.iY=RectCoord(((aIndex-EMaxRectFromList)/3)*2,iSize.iHeight);

  1083 		rect.iBr=rect.iTl;

  1084 		}

  1085 	else if (aIndex<EMaxRectWide)

  1086 		{

  1087 		rect.iTl.iX=1;

  1088 		rect.iBr.iX=iSize.iWidth-1;

  1089 		rect.iTl.iY=1;

  1090 		rect.iBr.iY=rect.iTl.iY+(aIndex-EMaxRectWide);

  1091 		}

  1092 	else if (aIndex<EMaxRectHigh)

  1093 		{

  1094 		rect.iTl.iX=1;

  1095 		rect.iBr.iX=rect.iTl.iX+(aIndex-EMaxRectHigh);

  1096 		rect.iTl.iY=1;

  1097 		rect.iBr.iY=iSize.iHeight-1;

  1098 		}

  1099 	else

  1100 		AutoPanic(EAutoPanicTestRectsIndex);

  1101 	return(rect);

  1102 	}

  1103 

  1104 

  1105 /*CBitmap*/

  1106 

  1107 CBitmap* CBitmap::NewLC(const TSize& aSizeInPixels,TDisplayMode aDispMode)

  1108 	{

  1109 	return NewLC(0,aSizeInPixels,aDispMode);

  1110 	}

  1111 

  1112 CBitmap* CBitmap::NewL(const TSize& aSizeInPixels,TDisplayMode aDispMode)

  1113 	{

  1114 	CBitmap* self=NewLC(0,aSizeInPixels,aDispMode);

  1115 	CleanupStack::Pop(self);

  1116 	return self;

  1117 	}

  1118 

  1119 CBitmap* CBitmap::NewL(TInt aHandle)

  1120 	{

  1121 	CBitmap* self=NewLC(aHandle,TSize(),ENone);

  1122 	CleanupStack::Pop(self);

  1123 	return self;

  1124 	}

  1125 

  1126 CBitmap* CBitmap::NewL(TDesC& /*aFileName*/)

  1127 	{

  1128 	User::Leave(KErrNotSupported);

  1129 	return NULL;

  1130 	}

  1131 

  1132 CBitmap* CBitmap::NewLC(TInt aHandle,const TSize& aSizeInPixels,TDisplayMode aDispMode)

  1133 	{

  1134 	CBitmap* self=new(ELeave) CBitmap();

  1135 	CleanupStack::PushL(self);