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 // Test the text cursor.

    15 //

    16 // This suite of tests checks to see if the TextCursors are operating

    17 // correctly for a number of use case scenarios; see doxygen comments

    18 // for each sub-test.  This test suite is applicable on both winscw

    19 // emulator and armv5 target hardware.  However, it must be noted that

    20 // text cursors are special due to their timeliness.  The text cursor

    21 // must flash every second: half a second ON, half a second OFF.  One

    22 // consequence of this is that when the test suite is run on emulator,

    23 // the PC must be otherwise quiescent.  No other IO or CPU intensive

    24 // activities may occur on the system, because these will cause delays

    25 // to the flashing of the text cursor giving unreliable results.

    26 // Where timeliness is a consideration, we use TEST_SOFTFAIL_WINSCW so

    27 // that if the test fails and we are running on the PC emulator, we only

    28 // record the fact, but don't mark the test as failing.

    29 

    30 /**

    31  @file

    32  @test

    33  @internalComponent - Internal Symbian test code

    34 */

    35 

    36 #include "TTEXTCURS.H"

    37 #include "graphics/windowserverconstants.h"

    38 

    39 const TInt KNumberOfCustoTextCursors	= 3;

    40 const TInt KTextCursorInitialIdValue	= 1001;

    41 const TInt KTextCursorPanicUid1			= 200;

    42 const TInt KTextCursorPanicUid2			= 2000;

    43 const TInt KTextCursorPanicUid3			= 3000;

    44 const TInt KTextCursorPanicUid4			= 4000;

    45 const TInt KTextCursorPanicUid5			= 5000;

    46 

    47 CTestBase* CTCursorTest::iStaticTest = NULL;

    48 const TInt kWinWidth=400;

    49 const TInt kWinHeight=100;

    50 const TSize kWinSize(kWinWidth,kWinHeight);

    51 const TInt kWinXPos=150;

    52 const TInt kCursorWidth = 10;

    53 const TInt kCursorHeight = 20;

    54 const TSize kCursorSize(kCursorWidth,kCursorHeight);

    55 const TPoint kWin1TopLeft(kWinXPos,0);

    56 const TPoint kWin2TopLeft(kWinXPos,kWinHeight+10);

    57 

    58 LOCAL_D void DeleteSpriteMember(TAny* aSpriteMember)

    59 	{

    60 	TSpriteMember* member=reinterpret_cast<TSpriteMember*>(aSpriteMember);

    61 	delete member->iBitmap;

    62 	member->iBitmap=NULL;

    63 	delete member->iMaskBitmap;

    64 	member->iMaskBitmap=NULL;

    65 	}

    66 

    67 CCustomTextCursor::~CCustomTextCursor()

    68 	{

    69 	const TInt count = iSpriteMemberArray.Count();

    70 	for (TInt index=0; index<count; ++index)

    71 		{

    72 		DeleteSpriteMember(&iSpriteMemberArray[index]);

    73 		}

    74 	iSpriteMemberArray.Close();

    75 	}

    76 	

    77 CCustomTextCursor::CCustomTextCursor(CTestBase* aTest)

    78 	: iTest(aTest)

    79 	{	

    80 	}

    81 

    82 void CCustomTextCursor::ConstructL(TInt aScreenNumber,TInt aBmpIndex)

    83 	{

    84 	ASSERT(aBmpIndex < KNumberOfCustoTextCursors);

    85 	

    86 

    87 	TSpriteMember spriteMember;

    88 	spriteMember.iBitmap = NULL;

    89 	spriteMember.iMaskBitmap = NULL;

    90 	spriteMember.iInvertMask =EFalse;

    91 	spriteMember.iDrawMode = CGraphicsContext::EDrawModePEN;

    92 	spriteMember.iOffset = TPoint();

    93 	spriteMember.iInterval = TTimeIntervalMicroSeconds32(0);

    94 	CleanupStack::PushL(TCleanupItem(DeleteSpriteMember, &spriteMember));

    95 	spriteMember.iBitmap = new (ELeave) CFbsBitmap;

    96 	User::LeaveIfError(spriteMember.iBitmap->Load(TEST_BITMAP_NAME, EMbmWsautotestBmp1));

    97 	spriteMember.iMaskBitmap = new (ELeave) CFbsBitmap;

    98 	User::LeaveIfError(spriteMember.iMaskBitmap->Load(TEST_BITMAP_NAME, EMbmWsautotestBmp1mask));

    99 

   100 	User::LeaveIfError(iSpriteMemberArray.Append(spriteMember));

   101 	CleanupStack::Pop(&spriteMember);

   102 

   103 	// create unique-id accross screens

   104 	//

   105 	iIdentifier = KTextCursorInitialIdValue + aScreenNumber*KNumberOfCustoTextCursors + aBmpIndex;

   106 	iAlignment = (RWsSession::TCustomTextCursorAlignment)(aBmpIndex);

   107 	}

   108 

   109 CCustomTextCursor* CCustomTextCursor::CreateCustomTextCursorL(TInt aScreenNumber,TInt aBmpIndex,CTestBase* aTest)

   110 	{

   111 	CCustomTextCursor* customTextCursor = new (ELeave) CCustomTextCursor(aTest);

   112 	CleanupStack::PushL(customTextCursor);

   113 	customTextCursor->ConstructL(aScreenNumber,aBmpIndex);

   114 	CleanupStack::Pop(customTextCursor);

   115 	return customTextCursor;

   116 	}

   117 

   118 /*

   119  * Wrapper class for a list of custom text cursor.

   120  */

   121 class CCustomTextCursorsWrapper : public CBase

   122 	{

   123 public:

   124 	static CCustomTextCursorsWrapper* NewLC(TInt aScreenNumber,CTestBase* aTest);

   125 	~CCustomTextCursorsWrapper();

   126 	inline RPointerArray<CCustomTextCursor>& CustomTextCursorsArray();

   127 	inline CCustomTextCursor& CustomTextCursor(TInt aIndex);

   128 private:

   129 	void ConstructL(TInt aScreenNumber,CTestBase* aTest);

   130 private:

   131 	RPointerArray<CCustomTextCursor> iCustomTextCursors;

   132 	};

   133 

   134 inline RPointerArray<CCustomTextCursor>& CCustomTextCursorsWrapper::CustomTextCursorsArray()

   135 		{

   136 		return iCustomTextCursors;

   137 		}

   138 

   139 inline CCustomTextCursor& CCustomTextCursorsWrapper::CustomTextCursor(TInt aIndex)

   140 		{

   141 		return *(iCustomTextCursors[aIndex]);

   142 		}

   143 

   144 CCustomTextCursorsWrapper* CCustomTextCursorsWrapper::NewLC(TInt aScreenNumber,CTestBase* aTest)

   145 	{

   146 	CCustomTextCursorsWrapper* self = new(ELeave) CCustomTextCursorsWrapper();

   147 	CleanupStack::PushL(self);

   148 	self->ConstructL(aScreenNumber,aTest);

   149 	return self;

   150 	}

   151 

   152 CCustomTextCursorsWrapper::~CCustomTextCursorsWrapper()

   153 	{

   154 	iCustomTextCursors.ResetAndDestroy();

   155 	iCustomTextCursors.Close();

   156 	}

   157 

   158 void CCustomTextCursorsWrapper::ConstructL(TInt aScreenNumber, CTestBase* aTest)

   159 	{

   160 	for (TInt index=0; index<KNumberOfCustoTextCursors; ++index)

   161 		{

   162 		CCustomTextCursor* customTextCursor=CCustomTextCursor::CreateCustomTextCursorL(aScreenNumber,index, aTest);

   163 		CleanupStack::PushL(customTextCursor);

   164 		User::LeaveIfError(iCustomTextCursors.Append(customTextCursor));

   165 		CleanupStack::Pop(customTextCursor);

   166 		}

   167 	}

   168 

   169 CTCursorTest::CTCursorTest(CTestStep* aStep) :

   170 	CTWsGraphicsBase(aStep)

   171 	{

   172 	iCursorType = TTextCursor::ETypeFirst;

   173 	iStaticTest=iTest;

   174 	}

   175 	

   176 CTCursorTest::~CTCursorTest()

   177 	{

   178 	delete iWorkInProgress;

   179 	delete iComparisonWindow;

   180 	}

   181 

   182 TInt CTCursorTest::DoPanicTest(TInt aInt, TAny *aScreenNumber)

   183 	{

   184 	RWsSession ws;

   185 	if (ws.Connect()==KErrNone)

   186 		{

   187 		// use correct screen

   188 		CWsScreenDevice* screen = new (ELeave) CWsScreenDevice(ws);

   189 		User::LeaveIfError(screen->Construct((TInt)aScreenNumber));

   190 		RWindowGroup group(ws);

   191 		if (group.Construct(444)==KErrNone)

   192 			{

   193 			group.EnableReceiptOfFocus(EFalse);	// Stop auto group switching on close

   194 			RWindow wnd(ws);

   195 			if (wnd.Construct(group, TInt32(&ws))==KErrNone)

   196 				{

   197 				TTextCursor tc;

   198 				tc.iHeight=10;

   199 				tc.iAscent=5;

   200 				tc.iWidth=10;

   201 				tc.iFlags=0;

   202 				tc.iColor=TRgb(0,0,0);

   203 				switch(aInt)

   204 					{

   205 					case 0:

   206 						{

   207 						/* TESTCASE:	6.1

   208 						* TITLE:		Invalid use of a custom text cursor ID (basic text cursor).

   209 						* IMPORTANCE:	1

   210 						* REQUIREMENT:	Unknown.

   211 						* 

   212 						* ACTION:		This test tries to set a text cursor using an ID which is invalid.

   213 						* 

   214 						* CHECK:		The thread should panic with the exit reason EWservPanicInvalidTextCursor

   215 						*/ 

   216 						tc.iType=(TTextCursor::EType)KTextCursorPanicUid1;

   217 						group.SetTextCursor(wnd,TPoint(10,10),tc);

   218 						}

   219 						break;

   220 					case 1:

   221 						{

   222 						/* TESTCASE:	6.2

   223 						* TITLE:		Invalid use of a window for a text cursor.

   224 						* IMPORTANCE:	1

   225 						* REQUIREMENT:	REQ 1079, CR RDEF-5F7Q24 (10/04/2003).

   226 						* 

   227 						* ACTION:		This test tries to set a text cursor using a window which is not part

   228 						*				of the window group calling the setting API.

   229 						* 

   230 						* CHECK:		The thread should panic with the exit reason EWservPanicWindow

   231 						*/ 

   232 						tc.iType=(TTextCursor::EType)KTextCursorPanicUid2;

   233 						group.SetTextCursor(*TestWin->Win(),TPoint(10,10),tc);

   234 						}

   235 						break;

   236 					case 2:

   237 						{

   238 						/* TESTCASE:	6.3

   239 						* TITLE:		Invalid use of a custom text cursor ID.

   240 						* IMPORTANCE:	1

   241 						* REQUIREMENT:	REQ 1079, CR RDEF-5F7Q24 (10/04/2003).

   242 						* 

   243 						* ACTION:		This test tries to set a text cursor using an ID which is associated to

   244 						*				an non-existing custom text cursor.

   245 						* 

   246 						* CHECK:		The thread should panic with the exit reason EWservPanicNoCustomTextCursor

   247 						*/ 

   248 						tc.iType=(TTextCursor::EType)KTextCursorPanicUid3;

   249 						group.SetTextCursor(wnd,TPoint(10,10),tc);

   250 						}

   251 						break;

   252 					case 3:

   253 						{

   254 						/* TESTCASE:	6.4

   255 						* TITLE:		Invalid use of a custom text cursor ID.

   256 						* IMPORTANCE:	1

   257 						* REQUIREMENT:	REQ 1079, CR RDEF-5F7Q24 (10/04/2003).

   258 						* 

   259 						* ACTION:		This test tries to set a custom text cursor which has been set to use

   260 						*				an invalid alignment.

   261 						* 

   262 						* CHECK:		The thread should panic with the exit reason EWservPanicCustomTextCursorAlign

   263 						*/ 

   264 						CCustomTextCursor* customTextCursor=NULL;

   265 						TRAPD(error, customTextCursor=CCustomTextCursor::CreateCustomTextCursorL((TInt)aScreenNumber,0,iStaticTest));

   266 						if (error==KErrNone)

   267 							{

   268 							error = ws.SetCustomTextCursor(KTextCursorPanicUid4, customTextCursor->iSpriteMemberArray.Array(), 0, (RWsSession::TCustomTextCursorAlignment)(RWsSession::ECustomTextCursorAlignBottom+1));

   269 							if (error==KErrNone || error==KErrAlreadyExists)

   270 								{

   271 								tc.iType=(TTextCursor::EType)KTextCursorPanicUid4;

   272 								group.SetTextCursor(wnd,TPoint(10,10),tc);

   273 								}

   274 							}

   275 						delete customTextCursor;

   276 						}

   277 						break;

   278 					case 4:

   279 						{

   280 						/* TESTCASE:	6.5

   281 						* TITLE:		Use of an invalid custom text cursor

   282 						* IMPORTANCE:	1

   283 						* REQUIREMENT:	REQ 1079, CR RDEF-5F7Q24 (10/04/2003).

   284 						* 

   285 						* ACTION:		This test tries to set a custom text cursor which does not have

   286 						*				any sprite member set.

   287 						* 

   288 						* CHECK:		The thread should panic with the exit reason EWservPanicNoSpriteMember

   289 						*/ 

   290 						RArray<TSpriteMember> spriteMemberArray;

   291 						const TInt error = ws.SetCustomTextCursor(KTextCursorPanicUid5, spriteMemberArray.Array(), 0, (RWsSession::TCustomTextCursorAlignment)(RWsSession::ECustomTextCursorAlignBottom));

   292 						if (error==KErrNone || error==KErrAlreadyExists)

   293 							{

   294 							tc.iType=(TTextCursor::EType)KTextCursorPanicUid5;

   295 							group.SetTextCursor(wnd,TPoint(10,10),tc);

   296 							}

   297 						}

   298 						break;

   299 					case 5:

   300 						{

   301 						// Uncover set.cursor.iType < TTextCursor::ETypeFirst code path

   302 						tc.iType=(TTextCursor::EType)TTextCursor::ETypeFirst - 1;

   303 						group.SetTextCursor(wnd,TPoint(10,10),tc);

   304 						}

   305 						break;

   306 					case 6:

   307 						{

   308 						// Uncover (set.cursor.iFlags&static_cast<TUint>(TTextCursor::EPrivateFlags) code path

   309 						tc.iFlags=ETextCursorPrivateFlags;

   310 						group.SetTextCursor(wnd,TPoint(10,10),tc);

   311 						}

   312 						break;

   313 					case 7:

   314 						{

   315 						// Uncover (iGroupWin != searchWin) i.e. bogus group window

   316 						tc.iType=(TTextCursor::EType)TTextCursor::ETypeRectangle;

   317 						RWindow windowNotAssociatedWithAGroup(ws);

   318 						group.SetTextCursor(windowNotAssociatedWithAGroup, TPoint(10,10),tc);

   319 						}

   320 						break;

   321 					}

   322 				}

   323 			ws.Flush();

   324 			}

   325 		}

   326 	return(EWsExitReasonBad);

   327 	}

   328 

   329 void CTCursorTest::TestPanicsL()

   330 	{	

   331 		TEST(iTest->TestWsPanicL(DoPanicTest, EWservPanicInvalidTextCursor, 0, (TAny*)iTest->iScreenNumber));

   332 		TEST(iTest->TestWsPanicL(DoPanicTest, EWservPanicWindow, 1, (TAny*)iTest->iScreenNumber));

   333 		TEST(iTest->TestWsPanicL(DoPanicTest, EWservPanicNoCustomTextCursor, 2, (TAny*)iTest->iScreenNumber));

   334 		TEST(iTest->TestWsPanicL(DoPanicTest, EWservPanicCustomTextCursorAlign, 3, (TAny*)iTest->iScreenNumber));

   335 		TEST(iTest->TestWsPanicL(DoPanicTest, EWservPanicNoSpriteMember, 4, (TAny*)iTest->iScreenNumber));

   336 		TEST(iTest->TestWsPanicL(DoPanicTest, EWservPanicInvalidTextCursor, 5, (TAny*)iTest->iScreenNumber));

   337 		TEST(iTest->TestWsPanicL(DoPanicTest, EWservPanicInvalidTextCursor, 6, (TAny*)iTest->iScreenNumber));

   338 		TEST(iTest->TestWsPanicL(DoPanicTest, EWservPanicWindow, 7, (TAny*)iTest->iScreenNumber));

   339 		iTest->CloseAllPanicWindows();

   340 	}

   341 

   342 void CTCursorTest::TextCursorSetLCoverageTests()

   343 	{

   344 	ValidateWin(BaseWin,TRgb::Gray256(255));

   345 	ValidateWin(TestWin,TRgb::Gray256(255));	

   346 	TTextCursor textCursor;

   347 	textCursor.iHeight = 10;

   348 	textCursor.iAscent = 0;

   349 	textCursor.iWidth = 10;

   350 	textCursor.iFlags = 0;

   351 	textCursor.iColor = KRgbBlack;

   352 	textCursor.iType = (TTextCursor::EType)TTextCursor::ETypeRectangle;

   353 	TPoint position(10, 10);

   354 	TRect clipRect0(10, 10, 10, 10);

   355 	TRect clipRect1(10, 10, 5, 5);

   356 	RWindowGroup *group = TheClient->iGroup->GroupWin(); 

   357 	group->SetTextCursor(*TestWin->Win(), position, textCursor);

   358 	/*

   359 	 * Duplicate the previous SetTextCursor command to uncover the code which checks for any delta in SetL

   360 	 * compared to the current settings.

   361 	 */

   362 	group->SetTextCursor(*TestWin->Win(), position, textCursor);

   363 	/*

   364 	 * Change the type only to pick up that difference in SetL.

   365 	 */

   366 	textCursor.iType++;

   367 	group->SetTextCursor(*TestWin->Win(), position, textCursor);

   368 	textCursor.iType--;

   369 	/*

   370 	 * Vary the clipping rectangle.

   371 	 */

   372 	group->SetTextCursor(*TestWin->Win(), position, textCursor, clipRect0);

   373 	group->SetTextCursor(*TestWin->Win(), position, textCursor, clipRect1);

   374 	/*

   375 	 * Vary the color.

   376 	 */

   377 	textCursor.iColor = KRgbGreen;

   378 	group->SetTextCursor(*TestWin->Win(), position, textCursor);

   379 	textCursor.iColor = KRgbBlack;

   380 	group->SetTextCursor(*TestWin->Win(), position, textCursor);

   381 	/*

   382 	 * Vary the target Window.

   383 	 */

   384 	group->SetTextCursor(*BaseWin->Win(), position, textCursor);

   385 	group->SetTextCursor(*TestWin->Win(), position, textCursor);

   386 	/*

   387 	 * Vary the size of the cursor.

   388 	 */

   389 	textCursor.iWidth++;

   390 	group->SetTextCursor(*TestWin->Win(), position, textCursor);

   391 	textCursor.iWidth--;

   392 	/*

   393 	 * Set different custom cursors.

   394 	 */

   395 	CCustomTextCursorsWrapper* customTextCursorsWrapper = CCustomTextCursorsWrapper::NewLC(iTest->iScreenNumber, iTest);

   396 	const TInt count = customTextCursorsWrapper->CustomTextCursorsArray().Count();

   397 	for (TInt index=0; index<count; ++index)

   398 		{

   399 		CCustomTextCursor& customTextCursor = customTextCursorsWrapper->CustomTextCursor(index);

   400 		textCursor.iType = customTextCursor.iIdentifier;

   401 		group->SetTextCursor(*TestWin->Win(), position, textCursor);

   402 		}			

   403 	CleanupStack::PopAndDestroy(customTextCursorsWrapper);

   404 	/*

   405 	 * Set the last custom cursor from the above loop again so the

   406 	 * product code sees the same Custom Text Cursor settings come

   407 	 * in a second time.

   408 	 */

   409 	group->SetTextCursor(*TestWin->Win(), position, textCursor);

   410 	textCursor.iType = (TTextCursor::EType)TTextCursor::ETypeRectangle;

   411 	/*

   412 	 * Vary the horizontal clipping.

   413 	 */

   414 	textCursor.iFlags = TTextCursor::EFlagClipHorizontal;

   415 	group->SetTextCursor(*TestWin->Win(), position, textCursor);

   416 	/*

   417 	 * Vary the horizontal clipping.

   418 	 */

   419 	textCursor.iFlags = TTextCursor::EFlagClipVertical;

   420 	group->SetTextCursor(*TestWin->Win(), position, textCursor);

   421 	/*

   422 	 * Try both horizontal and vertical clipping.

   423 	 */

   424 	textCursor.iFlags = TTextCursor::EFlagClipVertical|TTextCursor::EFlagClipHorizontal;

   425 	group->SetTextCursor(*TestWin->Win(), position, textCursor);

   426 	textCursor.iFlags = 0;

   427 	

   428 	TheClient->iWs.Flush();

   429 	CancelTextCursor();

   430 	}

   431 

   432 void CTCursorTest::SetCursor(const TPoint &aPos,const TSize &aSize,TRgb aColor, const TRect &aRect, TUint aFlags)

   433 	{

   434 	TTextCursor tc;

   435 	tc.iType=iCursorType;

   436     tc.iHeight=aSize.iHeight;

   437     tc.iAscent=aSize.iHeight*4/5;

   438     tc.iWidth=aSize.iWidth;

   439     tc.iFlags=aFlags;

   440 	tc.iColor=aColor;

   441 	TheClient->iGroup->GroupWin()->SetTextCursor(*TestWin->Win(),TPoint(aPos.iX,aPos.iY+tc.iAscent),tc,aRect);

   442 	}

   443 

   444 void CTCursorTest::SetCursor(const TPoint &aPos,const TSize &aSize,TRgb aColor, TUint aFlags)

   445 	{

   446 	TTextCursor tc;

   447 	tc.iType=iCursorType;

   448     tc.iHeight=aSize.iHeight;

   449     tc.iAscent=aSize.iHeight*4/5;

   450     tc.iWidth=aSize.iWidth;

   451     tc.iFlags=aFlags;

   452 	tc.iColor=aColor;

   453 	TheClient->iGroup->GroupWin()->SetTextCursor(*TestWin->Win(),TPoint(aPos.iX,aPos.iY+tc.iAscent),tc);

   454 	}

   455 

   456 void CTCursorTest::SetCursorPlusBox(const TPoint &aPos,const TSize &aSize,TRgb aColor, const TRect *aClipRect, TUint aFlags)

   457 	{

   458 	if (aClipRect)

   459 		SetCursor(aPos,aSize,aColor,*aClipRect,aFlags);

   460 	else

   461 		SetCursor(aPos,aSize,aColor,aFlags);

   462 	TRect rect(aPos,aSize);

   463 	if (aClipRect)

   464 		rect.Intersection(*aClipRect);

   465 	rect.Grow(2,2);

   466 	

   467 	TheClient->iGc->Activate(*(TestWin->Win()));

   468 	TestWin->Invalidate(rect);

   469 	TestWin->Win()->BeginRedraw(rect);

   470 	TheClient->iGc->SetPenColor(aColor);

   471 	TheClient->iGc->SetDrawMode(CGraphicsContext::EDrawModeXOR);

   472 

   473 	TheClient->iGc->DrawRect(rect);

   474 	TheClient->iGc->Deactivate();

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

   476 	

   477 	}

   478 

   479 void CTCursorTest::CancelTextCursor()

   480 	{

   481 	TheClient->iGroup->GroupWin()->CancelTextCursor();

   482 	}

   483 

   484 void CTCursorTest::ConstructL()

   485 	{

   486 	// for allocating some cached memory

   487 	CFbsBitmap* bitmap = new (ELeave) CFbsBitmap;

   488 	CleanupStack::PushL(bitmap);

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

   490 	CleanupStack::PopAndDestroy(bitmap);

   491 

   492 	CCustomTextCursorsWrapper* customTextCursorsWrapper = CCustomTextCursorsWrapper::NewLC(iTest->iScreenNumber, iTest);

   493 	const TInt count = customTextCursorsWrapper->CustomTextCursorsArray().Count();

   494 	for (TInt index=0; index<count; ++index)

   495 		{

   496 		CCustomTextCursor& customTextCursor = customTextCursorsWrapper->CustomTextCursor(index);

   497 		TInt err = TheClient->iWs.SetCustomTextCursor(customTextCursor.iIdentifier, customTextCursor.iSpriteMemberArray.Array(), customTextCursor.iSpriteFlags, customTextCursor.iAlignment);

   498 		TEST(err == KErrNone || err == KErrAlreadyExists);

   499 		if (err!=KErrNone && err != KErrAlreadyExists)

   500 			INFO_PRINTF4(_L("TheClient->iWs.SetCustomTextCursor return value  - Expected: %d or %d, Actual: %d"), KErrNone, KErrAlreadyExists, err);

   501 

   502 		__UHEAP_MARK;

   503 		err = TheClient->iWs.SetCustomTextCursor(customTextCursor.iIdentifier, customTextCursor.iSpriteMemberArray.Array(), customTextCursor.iSpriteFlags, customTextCursor.iAlignment);

   504 		__UHEAP_MARKEND;

   505 		TEST(err == KErrAlreadyExists);

   506 		if (err != KErrAlreadyExists)

   507 			INFO_PRINTF3(_L("TheClient->iWs.SetCustomTextCursor return value  - Expected: %d, Actual: %d"), KErrAlreadyExists, err);

   508 

   509 		}

   510 	_LIT(KLog,"Text Cursor: Loaded %d Custom Cursors");

   511 	TLogMessageText buf;

   512 	buf.Format(KLog,count);

   513 	TheClient->LogMessage(buf);

   514 	CleanupStack::PopAndDestroy(customTextCursorsWrapper);

   515 //

   516 	ValidateWin(BaseWin,TRgb::Gray256(204));

   517 	ValidateWin(TestWin,TRgb::Gray256(204));

   518 //

   519 	SetCursor(TPoint(10,90),TSize(80,100),TRgb(255,255,255));

   520 //

   521 	iWinState=0;

   522 	iWinPos=TPoint(2*TheClient->iGroup->Size().iWidth/3,0);

   523 //

   524 	iMoveWin=new(ELeave) CBlankWindow(TRgb::Gray256(220));

   525 	TDisplayMode mode=EGray16;

   526 	TInt testWinWidth = TestWin->Size().iWidth;

   527 	TInt halfTestWinWidth = testWinWidth/2;

   528 	TInt halfTestWinHeight = TestWin->Size().iHeight/2;

   529 	

   530 	iMoveWin->SetUpL(iWinPos,TSize(halfTestWinHeight,halfTestWinHeight),

   531 			TheClient->iGroup,*TheClient->iGc,&mode);

   532 

   533 	iCheckWin=new(ELeave) CBlankWindow(TRgb::Gray256(220));

   534 	iCheckWin->SetUpL(TPoint(testWinWidth+halfTestWinWidth,halfTestWinHeight),

   535 			TSize(halfTestWinWidth,halfTestWinHeight),

   536 			TheClient->iGroup,*TheClient->iGc,&mode);

   537 	}

   538 

   539 void CTCursorTest::DeleteMoveWindows()

   540 	{

   541 	delete iMoveWin;

   542 	delete iCheckWin;

   543 	CancelTextCursor();

   544 	}

   545 

   546 void CTCursorTest::ResetMoveWindowsL()

   547 	{

   548 	SetCursor(TPoint(10,90),TSize(80,100),TRgb(255,255,255));

   549 	iWinState=0;

   550 	iWinPos=TPoint(2*TheClient->iGroup->Size().iWidth/3,0);

   551 	iMoveWin->SetExtL(iWinPos,TSize(TestWin->Size().iWidth/2,TestWin->Size().iHeight/2));

   552 	iCheckWin->SetExtL(TPoint(TestWin->Size().iWidth+(TestWin->Size().iWidth>>1),TestWin->Size().iHeight>>1),

   553 														TSize(TestWin->Size().iWidth/2,TestWin->Size().iHeight/2));

   554 	}

   555 

   556 TBool CTCursorTest::MoveWindow()

   557 	{

   558 	TSize scrSize(TheClient->iScreen->SizeInPixels());

   559 	iWinState++;

   560 	if (iWinState<20)

   561 		iWinPos+=TPoint((4*scrSize.iWidth)/640,(4*scrSize.iHeight)/240);

   562 	else if (iWinState<40)

   563 		iWinPos+=TPoint((1*scrSize.iWidth)/640,(-3*scrSize.iHeight)/240);

   564 	else if (iWinState<60)

   565 		iWinPos+=TPoint((-6*scrSize.iWidth)/640,(3*scrSize.iHeight)/240);

   566 	else

   567 		iWinPos+=TPoint((1*scrSize.iWidth)/640,(-2*scrSize.iHeight)/240);

   568 	iMoveWin->SetPos(iWinPos);

   569 	return (iWinState==80);

   570 	}

   571 

   572 void CTCursorTest::ValidateWin(TestWindow *aWin, TRgb aColor)

   573 	{

   574 	aWin->Win()->Invalidate();

   575 	RedrawWin(*aWin->Win(),aColor);

   576 	}

   577 

   578 void CTCursorTest::RedrawWin(RWindow &aWin, TRgb aColor)

   579 	{

   580 	aWin.BeginRedraw();

   581 	TheClient->iGc->Activate(aWin);

   582 	TheClient->iGc->SetBrushColor(aColor);

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

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

   585 	TheClient->iGc->Clear();

   586 	TheClient->iGc->Deactivate();

   587 	aWin.EndRedraw();

   588 	}

   589 

   590 void CTCursorTest::ScrollTest()

   591 	{

   592 	const TSize size(20,40);

   593 	ValidateWin(TestWin,TRgb::Gray256(255));

   594 

   595 	SetCursor(TPoint(10,20),size,TRgb::Gray256(255),TTextCursor::EFlagNoFlash);

   596 	TheClient->iWs.Flush();

   597 	TheClient->WaitForRedrawsToFinish();

   598 	TheClient->iWs.Finish();

   599 

   600 	for(TInt ii=0;ii<20;ii++)

   601 		{

   602 		TInt dist=(ii&3)*2;

   603 		TInt nx=ii&0x1?1:-1;

   604 		TInt ny=ii&0x2?1:-1;

   605 		TestWin->Win()->Scroll(TPoint(dist*nx,dist*ny),TRect(10,20,30,40));

   606 		TheClient->iWs.Flush();

   607 		}

   608 	TheClient->WaitForRedrawsToFinish();

   609 	TheClient->iWs.Finish();

   610 

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

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

   613 	TheClient->iGc->Activate(*(BaseWin->Win()));

   614 	TheClient->iGc->Clear();

   615 	TheClient->iGc->SetBrushColor(TRgb::Gray256(255));

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

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

   618 	TheClient->iGc->Clear(TRect(TPoint(10,20),size));

   619 	TheClient->iGc->Deactivate();

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

   621 

   622 	TheClient->iWs.Flush();

   623 	TheClient->WaitForRedrawsToFinish();

   624 	TheClient->iWs.Finish();

   625 

   626 	/*

   627 	 * NOTE: Reason for removal of COMPARE_WINDOWS_SOFTFAIL_WINSCW

   628 	 * Due to the new implementation of sprites in wserv2, the sprites no longer keep a 

   629 	 * backup bitmap of what the screen looks like beneath them. As it is not possible to 

   630 	 * move the sprites associated with the custom text cursors that were created in second 

   631 	 * phase construction of the CTCursorTest object, the COMPARE_WINDOWS_SOFTFAIL_WINSCW; 

   632 	 * macro function has been removed. Otherwise the test case is going to subject to the

   633 	 * timing of the flashing sprite. An alternative solution would be to assign NULL values

   634 	 * to the sprite bitmaps in second phase construction, but this is avoided as it would

   635 	 * trigger failures in some test cases later on (that are depended on these "embedded"

   636 	 * sprite images).

   637 	 */	

   638 	CancelTextCursor();

   639 	}

   640 

   641 void DrawTestSprite(CBitmapContext *aGc,TInt , const TSize &aSize, TBool aDoMask, TAny *)

   642 	{

   643 	aGc->SetBrushColor(TRgb::Gray4(aDoMask ? 0 : 2));

   644 	aGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

   645 	aGc->SetPenStyle(CGraphicsContext::ENullPen);

   646 	aGc->DrawRect(TRect(aSize));

   647 	aGc->SetPenStyle(CGraphicsContext::ESolidPen);

   648 	aGc->SetPenColor(TRgb::Gray4(aDoMask ? 3 : 0));

   649 	aGc->SetBrushColor(TRgb::Gray4(aDoMask ? 3 : 1));

   650 	aGc->DrawEllipse(TRect(aSize));

   651 	}

   652 

   653 CTSprite *CTCursorTest::CreateTestSpriteLC(RWindowTreeNode &aWindow, const TPoint &aPos, TInt aCount)

   654 //

   655 // At the moment aCount must be 1 or 2

   656 //

   657 	{

   658 	TSpriteCreateParams params(TSize(30,70),TPoint(0,0),DrawTestSprite);

   659 	TSpriteCreateParams paramarray[2];

   660 	params.iInterval=TTimeIntervalMicroSeconds32(200000);

   661 

   662 	paramarray[0]=params;

   663 	paramarray[1]=params;

   664 	paramarray[1].iSize=TSize(100,10);

   665 	CTSprite *sprite=new(ELeave) CTSprite(TheClient->iWs);

   666 	CleanupStack::PushL(sprite);

   667 	sprite->ConstructL(aWindow,aPos,aCount,&paramarray[0],0);

   668 	return(sprite);

   669 	}

   670 

   671 void CTCursorTest::doMoveWindowTestL()

   672 	{

   673 	RBlankWindow blankwin(TheClient->iWs);

   674 	User::LeaveIfError(blankwin.Construct(*TestWin->Win(),1));

   675 	CleanupStack::PushL(TCleanupItem(CleanUpWindow,&blankwin));

   676 //

   677 	blankwin.SetExtent(TPoint(35,165),TSize(40,40));

   678 	blankwin.SetColor(TRgb::Gray256(220));

   679 	blankwin.Activate();

   680 	TheClient->iWs.SetAutoFlush(ETrue);

   681 	User::After(500000);

   682 	blankwin.SetPosition(TPoint(25,55));

   683 	User::After(500000);

   684 	blankwin.SetPosition(TPoint(30,160));

   685 	User::After(500000);

   686 	blankwin.SetPosition(TPoint(12,22));	// Almost totally covering sprite

   687 	User::After(500000);

   688 	blankwin.SetPosition(TPoint(-100,-100));	// Totally off the sprite

   689 	User::After(500000);

   690 	blankwin.SetPosition(TPoint(10,20));	// Write on top of sprite

   691 	User::After(500000);

   692 	blankwin.SetPosition(TPoint(24,24));	// moving off...

   693 	User::After(500000);

   694 	blankwin.SetPosition(TPoint(38,28));	// ...

   695 	User::After(500000);

   696 	blankwin.SetPosition(TPoint(58,48));	// ...

   697 	User::After(500000);

   698 	blankwin.SetPosition(TPoint(92,62));	// ... off

   699 	User::After(500000);

   700 	CleanupStack::PopAndDestroy();	// blank window

   701 	TheClient->iWs.Flush();

   702 	TheClient->WaitForRedrawsToFinish();

   703 	TheClient->iWs.Finish();

   704 

   705 	TheClient->iWs.SetAutoFlush(EFalse);

   706 	}

   707 

   708 void CTCursorTest::MoveWindowTest1L()

   709 	{

   710 	ValidateWin(TestWin,TRgb::Gray256(255));

   711 // Check it with a static sprite

   712 	CTSprite * sprite_static = CreateTestSpriteLC(*TestWin->Win(), TPoint(10,20), 1);

   713 	doMoveWindowTestL();

   714 	(sprite_static->Sprite()).SetPosition(TPoint(500,500)); //move the sprite out of the viewing area before the window comparison 

   715 	CleanupStack::PopAndDestroy(1);	// sprite

   716 // Check it an animated sprite

   717 	CTSprite * sprite_anim = CreateTestSpriteLC(*TestWin->Win(), TPoint(10,20), 2);

   718 	doMoveWindowTestL();

   719 	(sprite_anim->Sprite()).SetPosition(TPoint(500,500)); //move the sprite out of the viewing area before the window comparison

   720 	CleanupStack::PopAndDestroy(1);	// sprite

   721 	}

   722 

   723 void CTCursorTest::MoveWindowTest2L()

   724 	{

   725 	const TSize size(20,40);

   726 // Check it with a text cursor

   727 	ValidateWin(TestWin,TRgb::Gray256(255));

   728 	SetCursor(TPoint(10,25),size,TRgb::Gray256(255),TTextCursor::EFlagNoFlash);

   729 	doMoveWindowTestL();

   730 	CancelTextCursor();

   731 // Check it with an anaimated sprite and a text cursor

   732 	ValidateWin(TestWin,TRgb::Gray256(255));

   733 	CTSprite * sprite_anim = CreateTestSpriteLC(*TestWin->Win(), TPoint(10,20), 2);

   734 	SetCursor(TPoint(10,45),size,TRgb::Gray256(255),TTextCursor::EFlagNoFlash);

   735 	doMoveWindowTestL();

   736 	(sprite_anim->Sprite()).SetPosition(TPoint(500,500));

   737 	CancelTextCursor();

   738 	CleanupStack::PopAndDestroy(1);	// sprite

   739 	}

   740 

   741 TBool CTCursorTest::IncrementCursorType()

   742 	{

   743 	// each screen has it own set of cursor

   744 	//

   745 	// the values would be ETypeLast=2 ETypeLastBasic=1009

   746 	//

   747 	if (iCursorType == TTextCursor::ETypeFirst)

   748 		{

   749 		iCursorType = (TTextCursor::EType)(TTextCursor::ETypeLastBasic + 1 + iTest->iScreenNumber*KNumberOfCustoTextCursors);

   750 		return ETrue;

   751 		}

   752 	else if (iCursorType >= TTextCursor::ETypeLastBasic + (iTest->iScreenNumber+1)*KNumberOfCustoTextCursors)

   753 		{

   754 		iCursorType = TTextCursor::ETypeFirst;

   755 		return EFalse;

   756 		}

   757 	else

   758 		{

   759 		iCursorType = (TTextCursor::EType)(iCursorType + 1);

   760 		return ETrue;

   761 		}

   762 	}

   763 

   764 void CTCursorTest::GeneralTestsL()

   765 	{

   766 	const TInt winColor=255;		//Best to use Light Grey that is 170, but this code is bugged and doing so shows them up.

   767 	ValidateWin(BaseWin,TRgb::Gray256(255));

   768 	ValidateWin(TestWin,TRgb::Gray256(255));

   769 	SetCursor(TPoint(-1000,10),TSize(10,30),TRgb::Gray256(255));

   770 	TheClient->iWs.Flush();

   771 	SetCursor(TPoint(10,10),TSize(10,30),TRgb::Gray256(255));

   772 	TheClient->iWs.Flush();

   773 	TRect rect(15,15,18,25);

   774 	SetCursorPlusBox(TPoint(10,10),TSize(10,30),TRgb::Gray256(255), &rect);

   775 	CancelTextCursor();

   776 //

   777 	ValidateWin(BaseWin,TRgb::Gray256(255));

   778 	ValidateWin(TestWin,TRgb::Gray256(255));

   779 	TheClient->iWs.Flush();

   780 	for(TInt winType=0;winType<3;winType++)

   781 		{

   782 		RWindowBase *cursorwin=NULL;

   783 		RBackedUpWindow backcursorwin(TheClient->iWs);

   784 		RWindow backwindow(TheClient->iWs);

   785 		RBlankWindow backblankwin(TheClient->iWs);

   786 		switch(winType)

   787 			{

   788 			case 0:

   789 				cursorwin=&backcursorwin;

   790 				User::LeaveIfError(backcursorwin.Construct(*TestWin->BaseWin(),EGray4,1));

   791 				break;

   792 			case 1:

   793 				cursorwin=&backwindow;

   794 				User::LeaveIfError(backwindow.Construct(*TestWin->BaseWin(),1));

   795 				break;

   796 			case 2:

   797 				cursorwin=&backblankwin;

   798 				User::LeaveIfError(backblankwin.Construct(*TestWin->BaseWin(),1));

   799 				break;

   800 			}

   801 		CleanupStack::PushL(TCleanupItem(CleanUpWindow,cursorwin));

   802 		User::LeaveIfError(cursorwin->SetSizeErr(TestWin->BaseWin()->Size()));

   803 		cursorwin->Activate();

   804 //

   805 		TTextCursor tc;

   806 		tc.iType=iCursorType;

   807 		tc.iHeight=30;

   808 		tc.iAscent=0;

   809 		tc.iWidth=50;

   810 		tc.iFlags=0;

   811 		tc.iColor=TRgb::Gray256(255);

   812 		TheClient->iGroup->GroupWin()->SetTextCursor(*cursorwin,TPoint(10,10),tc);

   813 //

   814 		CreateTestSpriteLC(*cursorwin, TPoint(10,20), 2);

   815 //

   816 		if (cursorwin==&backwindow)

   817 			RedrawWin(backwindow,TRgb::Gray256(255));

   818 		for(TInt count=0;count<9;count++)

   819 			{

   820 			RWindowBase *pwin=NULL;

   821 			RBackedUpWindow backedup(TheClient->iWs);

   822 			RWindow window(TheClient->iWs);

   823 			RBlankWindow blankwin(TheClient->iWs);

   824 			switch(count%3)

   825 				{

   826 				case 0:

   827 					pwin=&window;

   828 					window.Construct(*cursorwin,2);

   829 					window.SetBackgroundColor(TRgb(winColor,winColor,winColor));

   830 					break;

   831 				case 1:

   832 					pwin=&backedup;

   833 					backedup.Construct(*cursorwin,EGray4,2);

   834 					break;

   835 				case 2:

   836 					pwin=&blankwin;

   837 					blankwin.Construct(*cursorwin,2);

   838 					blankwin.SetColor(TRgb(winColor,winColor,winColor));

   839 					break;

   840 				}

   841 			CleanupStack::PushL(TCleanupItem(CleanUpWindow,pwin));

   842 			pwin->SetExtentErr(TPoint(30,30),TSize(50,80));

   843 			pwin->Activate();

   844 			TheClient->iWs.Flush();

   845 			CleanupStack::PopAndDestroy();	// window

   846 			if (cursorwin==&backwindow)

   847 				RedrawWin(backwindow,TRgb::Gray256(255));

   848 			TheClient->iWs.Flush();

   849 			TheClient->WaitForRedrawsToFinish();

   850 			COMPARE_WINDOWS_SOFTFAIL_WINSCW;

   851 			User::After(200000);	// Wait a fifth of a second to make sure the test is run during different states of flashing

   852 			}

   853 		for(TInt count2=0;count2<4;count2++)

   854 			{

   855 			cursorwin->SetPosition(TPoint(10,5));

   856 			TheClient->iWs.Flush();

   857 			User::After(100000);

   858 			cursorwin->SetPosition(TPoint(5,10));

   859 			TheClient->iWs.Flush();

   860 			User::After(100000);

   861 			cursorwin->SetPosition(TPoint(0,0));

   862 			TheClient->iWs.Flush();

   863 			User::After(100000);

   864 			TheClient->WaitForRedrawsToFinish();

   865 			COMPARE_WINDOWS_SOFTFAIL_WINSCW;

   866 			}

   867 		CleanupStack::PopAndDestroy(2);	// sprite & window containing sprite and cursor

   868 		}

   869 	CancelTextCursor();

   870 	}

   871 

   872 void CTCursorTest::INC040489L()

   873 	{

   874 	INFO_PRINTF1(_L("AUTO_TCur INC040489 "));

   875 	RWindowGroup group1(TheClient->iWs);

   876 	PushWindowL(&group1);

   877 	User::LeaveIfError(group1.Construct(ENullWsHandle));

   878 	RBlankWindow blank1(TheClient->iWs);

   879 	PushWindowL(&blank1);

   880 	User::LeaveIfError(blank1.Construct(group1,ENullWsHandle));

   881 	blank1.SetRequiredDisplayMode(EColor4K);

   882 	blank1.SetColor(TRgb(250,150,0));

   883 	blank1.Activate();

   884 	RWindowGroup group2(TheClient->iWs);

   885 	PushWindowL(&group2);

   886 	User::LeaveIfError(group2.Construct(ENullWsHandle));

   887 	RBlankWindow blank2(TheClient->iWs);

   888 	PushWindowL(&blank2);

   889 	User::LeaveIfError(blank2.Construct(group2,ENullWsHandle));

   890 	blank2.SetRequiredDisplayMode(EColor4K);

   891 	blank2.SetColor(TRgb(75,200,125));

   892 	blank2.Activate();

   893 	TheClient->Flush();

   894 	INFO_PRINTF1(_L(" Created Windows "));

   895 	TTextCursor tc;

   896 	tc.iType=KTextCursorInitialIdValue + iTest->iScreenNumber*KNumberOfCustoTextCursors;

   897 	tc.iHeight=80;

   898 	tc.iAscent=10;

   899 	tc.iWidth=30;

   900 	tc.iFlags=0;

   901 	tc.iColor=TRgb::Gray256(255);

   902 	INFO_PRINTF1(_L(" About to Set Text Cursor 1 "));

   903 	group2.SetTextCursor(blank2,TPoint(20,20),tc);

   904 	TheClient->Flush();

   905 	INFO_PRINTF1(_L(" Set Text Cursor 1 "));

   906 	User::After(2000000);		//2sec

   907 	TheClient->iWs.PrepareForSwitchOff();

   908 	TheClient->Flush();

   909 	User::After(2000000);		//2sec

   910 	group1.SetOrdinalPosition(0);

   911 	group2.CancelTextCursor();

   912 	TheClient->Flush();

   913 	INFO_PRINTF1(_L(" Canceled Text Cursor "));

   914 	User::After(2000000);		//2sec

   915 	//

   916 	// Before applying the fix, the following operations makes the Custom Text 

   917 	// Cursor Sprite invisible (happens even without wserv heartbeat suppression)

   918 	INFO_PRINTF1(_L(" About to Set Text Cursor 2 "));

   919 	group1.SetOrdinalPosition(2);

   920 	group2.SetTextCursor(blank2,TPoint(20,20),tc);

   921 	TheClient->Flush();

   922 	INFO_PRINTF1(_L(" Set Text Cursor 2 "));

   923 	User::After(2000000);		//2sec

   924 	TRawEvent event;

   925 	event.Set(TRawEvent::EActive);

   926 	TheClient->iWs.SimulateRawEvent(event);

   927 	TheClient->Flush();

   928 	INFO_PRINTF1(_L(" Simulated Active Event "));

   929 	User::After(2000000);		//2sec

   930 	CleanupStack::PopAndDestroy(4, &group1);

   931 	INFO_PRINTF1(_L(" End of test "));

   932 	}

   933 

   934 void CTCursorTest::CursorUpdatedBeforeWindowRenderedL()

   935 	{

   936 	INFO_PRINTF1(_L("CursorUpdatedBeforeWindowRenderedL"));

   937 	TheClient->iGroup->WinTreeNode()->SetOrdinalPosition(0);

   938 	// We use some unique looking colors otherwise its harder

   939 	// to spot which test is which

   940 	TRgb kAqua(134, 242, 251);

   941 	

   942 	iWorkInProgress = new(ELeave) CBlankWindow(kAqua);

   943 	iComparisonWindow = new(ELeave) CBlankWindow(kAqua);

   944 	CancelTextCursor();

   945 	

   946 	const TSize screenSize=TheClient->iGroup->Size();

   947 	const TInt kPad = 5;

   948 	const TInt kThirdOfScreenWidth = screenSize.iWidth/3;

   949 	const TInt kWinWidth = kThirdOfScreenWidth - 2*kPad;

   950 	const TInt kWinHeight = screenSize.iHeight - 2*kPad;

   951 	const TSize kWinSize(kWinWidth, kWinHeight);

   952 	const TPoint kCursorPos(30, 30);

   953 	iComparisonWindow->SetUpL(TPoint(2*kThirdOfScreenWidth + kPad, kPad), kWinSize, TheClient->iGroup, *TheClient->iGc);

   954 	iWorkInProgress->SetUpL(  TPoint(  kThirdOfScreenWidth + kPad, kPad), kWinSize, TheClient->iGroup, *TheClient->iGc);

   955 	

   956 	TTextCursor nonFlashingCursor;

   957 	nonFlashingCursor.iType = TTextCursor::ETypeRectangle;

   958 	nonFlashingCursor.iHeight=kCursorHeight;

   959 	nonFlashingCursor.iAscent=0;

   960 	nonFlashingCursor.iWidth=kCursorWidth;

   961 	nonFlashingCursor.iFlags=TTextCursor::EFlagNoFlash;

   962 	nonFlashingCursor.iColor = KRgbBlack; 

   963 	TheClient->iGroup->GroupWin()->SetTextCursor(*iWorkInProgress->BaseWin(), kCursorPos, nonFlashingCursor);

   964 	

   965 	// Up till this point, there has not been a CWsWindow::Render() for iWorkInProgress

   966 	// because the window has not been invalid

   967 	

   968 	/*

   969 	 * Here is the crux of the test.  We want to create the following condition in a window group:

   970 	 * 1) None of its windows have yet been Rendered using CWsWindow::Render()

   971 	 * 2) A text cursor is present

   972 	 * 3) Focus is lost then received

   973 	 * 

   974 	 * It used to be the case that Wserv picked up the handle to the Render Stage Text Cursor

   975 	 * drawer upon a Refresh caused by Rendering the window.  But drawing the Text Cursor could

   976 	 * come either from a Window Render or a change to the state of the Text Cursor, such as

   977 	 * receiving focus in the window.  A bug was experienced when the Text Cursor was drawn in

   978 	 * a window which never had been rendered.  This meant that the handle was not set up causing

   979 	 * an assert.

   980 	 * 

   981 	 * The code has been modified since then, to setup the handle to the Render Stage Text

   982 	 * Cursor during Wserv initialisation.  However, to guard against future changes, its

   983 	 * worthwhile to have this corner case test to ensure it is possible to receive focus

   984 	 * in a window which has never been rendered.  That is because the text cursor state

   985 	 * is updated in such circumstances, and that might trigger a draw of the cursor in a

   986 	 * future version of the text cursor code.

   987 	 */

   988 	TheClient->iGroup->WinTreeNode()->SetOrdinalPosition(1);  // lose focus

   989 	TheClient->iWs.Finish();

   990 	TheClient->iGroup->WinTreeNode()->SetOrdinalPosition(0); // gain focus

   991 	TheClient->iWs.Finish();

   992 	

   993 	// If we get this far without a panic or assert, we have passed this test.

   994 	

   995 	// Now allow CWsWindow::Render() to occur in iWorkInProgress

   996 	// The reason for doing this is so that when you watch the test

   997 	// progress you can see visual confirmation via the progress message and

   998 	// the coloured windows appear on the screen.  Otherwise you would think

   999 	// that the test had either been skipped or had broken.

  1000 	iWorkInProgress->Invalidate();

  1001 	iWorkInProgress->Redraw();

  1002 	iComparisonWindow->Invalidate();

  1003 	iComparisonWindow->Redraw();

  1004 	TheClient->iWs.Finish();

  1005 	delete iWorkInProgress;

  1006 	iWorkInProgress = NULL;

  1007 	delete iComparisonWindow;

  1008 	iComparisonWindow = NULL;

  1009 	INFO_PRINTF1(_L("End of test"));

  1010 	}

  1011 

  1012 void CTCursorTest::INC097774()

  1013 	{

  1014 	TTimeIntervalMicroSeconds32 initialRepeatRate;

  1015 	TTimeIntervalMicroSeconds32 repeatRate;

  1016 	TheClient->iWs.GetKeyboardRepeatRate(initialRepeatRate,repeatRate);

  1017 	

  1018 	//simulates a text cursor moving across the screen as if a user was holding down

  1019 	//a key to scroll the cursor through a section of text.

  1020 	//before applying the fix the cursor only shows up intermittently instead of smoothly

  1021 	//scrolling across the screen.

  1022 	const TSize cursorSize(3,20);

  1023 	const TInt moveInterval=10;

  1024 	SetCursor(TPoint(0,20),cursorSize,TRgb::Gray256(255),TTextCursor::EFlagNoFlash);

  1025 	TheClient->Flush();

  1026 	User::After(initialRepeatRate);

  1027 	for(TInt offset=10;offset<=100;offset+=moveInterval)

  1028 		{

  1029 		SetCursor(TPoint(offset,20),cursorSize,TRgb::Gray256(255),TTextCursor::EFlagNoFlash);

  1030 		TheClient->Flush();

  1031 		User::After(repeatRate);

  1032 		}

  1033 		

  1034 	//simulate clipped text cursor moving accross the screen

  1035 	TRect rect(0,20,3,40);

  1036 	SetCursor(TPoint(0,20),cursorSize,TRgb::Gray256(255),rect,TTextCursor::EFlagNoFlash);

  1037 	TheClient->Flush();

  1038 	User::After(initialRepeatRate);

  1039 	for(TInt offset=10;offset<=100;offset+=moveInterval)

  1040 		{

  1041 		rect.Move(moveInterval,0);

  1042 		SetCursor(TPoint(offset,20),cursorSize,TRgb::Gray256(255),rect,TTextCursor::EFlagNoFlash);

  1043 		TheClient->Flush();

  1044 		User::After(repeatRate);

  1045 		}	

  1046 	}

  1047 /** What happens when a cursor becomes off-screen when the screen is resized/rotated? 

  1048  * 

  1049  * 

  1050  **/

  1051 void CTCursorTest::INC117232()

  1052 	{

  1053 	const TInt initialRepeatRate=300000;	// 3/10 seconds should be long enough to update everything!

  1054 	TInt currMode=TheClient->iScreen->CurrentScreenMode();

  1055 	TInt testMode=currMode;

  1056 	TPixelsTwipsAndRotation currModeSize;

  1057 	TheClient->iScreen->GetScreenModeSizeAndRotation(currMode, currModeSize);

  1058 	//find a (rotated) mode where the dimensions of the screen shrank

  1059 	for (TInt mode=0;mode<TheClient->iScreenModes.Count();mode++)

  1060 		{

  1061 		TPixelsTwipsAndRotation testModeSize;

  1062 		TheClient->iScreen->GetScreenModeSizeAndRotation(mode,testModeSize);

  1063 		if (	testModeSize.iPixelSize.iWidth<currModeSize.iPixelSize.iWidth-10

  1064 			||	testModeSize.iPixelSize.iHeight<currModeSize.iPixelSize.iHeight-10

  1065 			)

  1066 			{

  1067 			testMode=mode;

  1068 			break;

  1069 			}

  1070 		}

  1071 	if (testMode==currMode)

  1072 		{

  1073 		_LIT(KLog,"No smaller screen-size modes available - INC117232 test skipped");

  1074 		LOG_MESSAGE(KLog);

  1075 		//iStep->SetTestStepResult(EInconclusive);		//With this line the whole test fails which is too drastic

  1076 		return;

  1077 		}

  1078 	//enable a cursor on the bottom right corner of the screen

  1079 	TestWin->SetFullScreenExtL();

  1080 	TheClient->Flush();

  1081 	iCursorType=TTextCursor::ETypeRectangle;

  1082 	SetCursor(TPoint(-20,-20)+TestWin->Size(),TSize(40,40),KRgbDarkMagenta,TTextCursor::EFlagNoFlash);

  1083 	TheClient->Flush();

  1084 	User::After(initialRepeatRate);

  1085 	//shrink the screen

  1086 	TheClient->iScreen->SetScreenMode(testMode);

  1087 	TheClient->iScreen->SetAppScreenMode(testMode);

  1088 	//The defect was that WServ would now crash! 

  1089 	TheClient->Flush();

  1090 	User::After(initialRepeatRate);

  1091 	//Set everything back

  1092 	TheClient->iScreen->SetScreenMode(currMode);

  1093 	TheClient->iScreen->SetAppScreenMode(currMode);

  1094 	TheClient->Flush();

  1095 	User::After(initialRepeatRate);

  1096 	}

  1097 

  1098 #ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA

  1099 /**

  1100  * Sets up a text cursor whose attributes indicate it should not be flashing

  1101  * and then checks to ensure this is the actual behaviour.

  1102  */

  1103 void CTCursorTest::TextCursorNoFlashTestL()

  1104 	{

  1105 	TheClient->iGroup->WinTreeNode()->SetOrdinalPosition(0);

  1106 	// We use some unique looking colors otherwise its harder

  1107 	// to spot which test is which

  1108 	TRgb kGentleYellow(251, 249, 198);

  1109 	TRgb kGentlePink(253, 196, 221);

  1110 	

  1111 	iWorkInProgress = new(ELeave) CBlankWindow(kGentleYellow);

  1112 	iComparisonWindow = new(ELeave) CBlankWindow(kGentleYellow);

  1113 	CancelTextCursor();

  1114 	TheClient->Flush();

  1115 	

  1116 	const TSize screenSize=TheClient->iGroup->Size();

  1117 	const TInt kPad = 5;

  1118 	const TInt kThirdOfScreenWidth = screenSize.iWidth/3;

  1119 	const TInt kWinWidth = kThirdOfScreenWidth - 2*kPad;

  1120 	const TInt kWinHeight = screenSize.iHeight - 2*kPad;

  1121 	const TSize kWinSize(kWinWidth, kWinHeight);

  1122 	const TPoint kCursorPos(30, 30);

  1123 	iWorkInProgress->SetUpL(  TPoint(  kThirdOfScreenWidth + kPad, kPad), kWinSize, TheClient->iGroup, *TheClient->iGc);

  1124 	iComparisonWindow->SetUpL(TPoint(2*kThirdOfScreenWidth + kPad, kPad), kWinSize, TheClient->iGroup, *TheClient->iGc);

  1125 	

  1126 	TTextCursor nonFlashingCursor;

  1127 	

  1128 	nonFlashingCursor.iType = TTextCursor::ETypeRectangle;

  1129 	nonFlashingCursor.iHeight=kCursorHeight;

  1130 	nonFlashingCursor.iAscent=0;

  1131 	nonFlashingCursor.iWidth=kCursorWidth;

  1132 	nonFlashingCursor.iFlags=TTextCursor::EFlagNoFlash;

  1133 	nonFlashingCursor.iColor = kGentlePink; // We expect a Flicker Buffer Render Stage to ignore this color

  1134 	

  1135 	iWorkInProgress->Invalidate();