1 // Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 /**

    17  @file

    18  @internalComponent - Internal Symbian test code 

    19 */

    20 

    21 

    22 #include "TFrames.h"

    23 #include "AnimationConfig.h"

    24 #include "AnimationTestServer.h"

    25 

    26 _LIT(KSquares1File, "Z:\\private\\10204F5B\\sqdisp1.gif");

    27 _LIT(KSquares1MbmFile, "Z:\\private\\10204F5B\\sqdisp1.mbm");

    28 _LIT(KSquares2File, "Z:\\private\\10204F5B\\sqdisp2.gif");

    29 _LIT(KSquares2MbmFile, "Z:\\private\\10204F5B\\sqdisp2.mbm");

    30 _LIT(KSquares3File, "Z:\\private\\10204F5B\\previous.gif");

    31 _LIT(KSquares3MbmFile, "Z:\\private\\10204F5B\\previous.mbm");

    32 // These two pairs of files are commented pending defect fixes.

    33 // See comments in doACtiveTestStepL

    34 //_LIT(KDisposalFile, "Z:\\private\\10204F5B\\disposal.gif");

    35 //_LIT(KDisposalMbmFile, "Z:\\private\\10204F5B\\disposal.mbm");

    36 //_LIT(KMovingFile, "Z:\\private\\10204F5B\\moving.gif");

    37 //_LIT(KMovingMbmFile, "Z:\\private\\10204F5B\\moving.mbm");

    38 

    39 const TInt KFramesWindowHeight = 32;

    40 const TInt KFramesFrameLength = 100000;

    41 

    42 //

    43 // Windows:

    44 //

    45 CFramesTestWindow::CFramesTestWindow(RWsSession& aWsSession, CTestWindowGroup& aGroup, CWindowGc& aGc) : CTestWindow(aWsSession, aGroup, aGc)

    46 	{

    47 	}

    48 	

    49 void CFramesTestWindow::DrawL()

    50 	{

    51 	iGc.Reset();

    52 	if (iOpaque)

    53 		iGc.SetOpaque(ETrue);

    54 	if (iLined)

    55 		{

    56 		for (TInt row = 0; row < KFramesWindowHeight; row += 4)

    57 			{

    58 			iGc.SetPenColor(0x00FF00);

    59 			iGc.SetPenSize(TSize(2,2));

    60 			iGc.SetPenStyle(CGraphicsContext::ESolidPen);

    61 			iGc.DrawLine(TPoint(0, row), TPoint(400,row));

    62 			}		

    63 		}

    64 	}

    65 

    66 CFramesAnimationWindow::CFramesAnimationWindow(RWsSession& aWsSession, CTestWindowGroup& aGroup, CWindowGc& aGc) : CFramesTestWindow(aWsSession, aGroup, aGc)

    67 	{

    68 	}

    69 

    70 void CFramesAnimationWindow::SetAnimations(RPointerArray<CAnimation>* aAnimations, TBool aBasic)

    71 	{

    72 	iBasicAnimations = aBasic;

    73 	iAnimations = aAnimations;

    74 	}

    75 

    76 void CFramesAnimationWindow::DrawL()

    77 	{

    78 	CFramesTestWindow::DrawL();

    79 	if(iBasicAnimations && iAnimations && iAnimations->Count())

    80 		{

    81 		for (TInt frame = 0; frame < iAnimations->Count(); ++frame)

    82 			{

    83 			static_cast<CBasicAnimation*>((*iAnimations)[frame])->Draw(iGc);

    84 			}

    85 		}

    86 	}

    87 	

    88 CFramesFrameWindow::CFramesFrameWindow(RWsSession& aWsSession, CTestWindowGroup& aGroup, CWindowGc& aGc) :

    89 CFramesTestWindow(aWsSession, aGroup, aGc)

    90 	{

    91 	}

    92 

    93 CFramesFrameWindow::~CFramesFrameWindow()

    94 	{

    95 	FreeData();

    96 	}

    97 

    98 void CFramesFrameWindow::FreeData()

    99 	{

   100 	iFrames.ResetAndDestroy();

   101 	iMasks.ResetAndDestroy();

   102 	}

   103 	

   104 void CFramesFrameWindow::DrawL()

   105 	{

   106 	CFramesTestWindow::DrawL();

   107 	if (iFrames.Count())

   108 		{

   109 		TPoint pos(0,0);

   110 		TSize size = iFrames[0]->SizeInPixels();	

   111 		

   112 		for (TInt frame = 0; frame < iFrames.Count(); ++frame)

   113 			{

   114 			iGc.BitBltMasked(pos, iFrames[frame], size, iMasks[frame], EFalse);

   115 			pos.iX += size.iWidth;

   116 			}

   117 		iGc.BitBltMasked(pos, iFrames[0], size, iMasks[0], EFalse);

   118 		pos.iX += size.iWidth;

   119 		iGc.BitBltMasked(pos, iFrames[1], size, iMasks[1], EFalse);

   120 		pos.iX += size.iWidth;

   121 		iGc.BitBltMasked(pos, iFrames[iFrames.Count() - 1], size, iMasks[iFrames.Count() - 1], EFalse);

   122 		}

   123 	}

   124 

   125 TInt CFramesFrameWindow::LoadL(const TDesC& aFile)

   126 	{

   127 	FreeData();

   128 	

   129 	TInt num = 0;

   130 	TInt err = KErrNone;

   131 	CFbsBitmap* frame;

   132 	CFbsBitmap* mask;

   133 	while(err == KErrNone)

   134 		{

   135 		frame = new (ELeave) CFbsBitmap;

   136 		CleanupStack::PushL(frame);

   137 		mask = new (ELeave) CFbsBitmap;

   138 		CleanupStack::PushL(mask);

   139 		err = frame->Load(aFile,num * 2);

   140 		if (!err)

   141 			{

   142 			User::LeaveIfError(mask->Load(aFile,num * 2 + 1));

   143 			User::LeaveIfError(iMasks.Append(mask));

   144 			CleanupStack::Pop(mask);

   145 			User::LeaveIfError(iFrames.Append(frame));

   146 			CleanupStack::Pop(frame);

   147 			++num;

   148 			}

   149 		}

   150 	CleanupStack::PopAndDestroy(mask);

   151 	CleanupStack::PopAndDestroy(frame);

   152 	if (err != KErrEof)

   153 		User::LeaveIfError(err);

   154 	Window()->Invalidate();

   155 	return num;

   156 	}

   157 

   158 //

   159 // The test:

   160 //

   161 CFrames::CFrames()

   162 	{

   163 	SetTestStepName(KFramesStep);

   164 	}

   165 	

   166 CFrames::~CFrames()

   167 	{

   168 	iBasicAnimations.ResetAndDestroy();

   169 	iSpriteAnimations.ResetAndDestroy();

   170 	delete iBasicAnimWin;

   171 	delete iSpriteAnimWin;

   172 	delete iTransBasicAnimWin;

   173 	delete iTransSpriteAnimWin;

   174 	delete iFrameWin;

   175 	delete iTransFrameWin;

   176 	}

   177 	

   178 void CFrames::InitialiseL()

   179 	{

   180 	CAnimationTestStep::InitialiseL();

   181 	

   182 	ANIM_INFO1(_L("Begin test FRAMES"));

   183 

   184 	TInt winborder = 2;

   185 	iWinSize = Screen()->SizeInPixels();

   186 	iWinSize.iWidth /= 2;

   187 	iWinSize.iHeight = KFramesWindowHeight + winborder * 2;

   188 	iBasicAnimWinPosition = TPoint(iWinSize.iWidth + winborder,winborder);

   189 	iSpriteAnimWinPosition = TPoint(iBasicAnimWinPosition.iX, iBasicAnimWinPosition.iY + iWinSize.iHeight + winborder);

   190 	iFrameWinPosition = TPoint(iSpriteAnimWinPosition.iX, iSpriteAnimWinPosition.iY + iWinSize.iHeight + winborder);

   191 	iWinSize.iWidth -= winborder * 2;

   192 	iWinSize.iHeight -= winborder * 2;

   193 

   194 	iBasicAnimWin = new (ELeave) CFramesAnimationWindow(Ws(), *GroupWin(), *Gc());

   195 	iBasicAnimWin->Window()->SetRequiredDisplayMode(iDisplayMode);

   196 	iBasicAnimWin->Window()->SetExtent(iBasicAnimWinPosition, iWinSize);

   197 	iBasicAnimWin->Window()->SetBackgroundColor(iBackgroundColor1);

   198 	iBasicAnimWin->Window()->SetVisible(ETrue);

   199 	iBasicAnimWin->Window()->Activate();

   200 	

   201 	iTransBasicAnimWin = new (ELeave) CFramesAnimationWindow(Ws(), *GroupWin(), *Gc());

   202 	iTransBasicAnimWin->Window()->SetTransparencyFactor(0x808080);

   203 	iTransBasicAnimWin->Window()->SetRequiredDisplayMode(iDisplayMode);

   204 	iTransBasicAnimWin->Window()->SetExtent(iBasicAnimWinPosition, iWinSize);

   205 	iTransBasicAnimWin->Window()->SetBackgroundColor(iBackgroundColor2);

   206 	iTransBasicAnimWin->Window()->SetVisible(EFalse);

   207 	iTransBasicAnimWin->Window()->Activate();

   208 

   209 	iSpriteAnimWin = new (ELeave) CFramesAnimationWindow(Ws(), *GroupWin(), *Gc());

   210 	iSpriteAnimWin->Window()->SetRequiredDisplayMode(iDisplayMode);

   211 	iSpriteAnimWin->Window()->SetExtent(iSpriteAnimWinPosition, iWinSize);

   212 	iSpriteAnimWin->Window()->SetBackgroundColor(iBackgroundColor1);

   213 	iSpriteAnimWin->Window()->SetVisible(ETrue);

   214 	iSpriteAnimWin->Window()->Activate();

   215 	

   216 	iTransSpriteAnimWin = new (ELeave) CFramesAnimationWindow(Ws(), *GroupWin(), *Gc());

   217 	iTransSpriteAnimWin->Window()->SetTransparencyFactor(0x808080);

   218 	iTransSpriteAnimWin->Window()->SetRequiredDisplayMode(iDisplayMode);

   219 	iTransSpriteAnimWin->Window()->SetExtent(iSpriteAnimWinPosition, iWinSize);

   220 	iTransSpriteAnimWin->Window()->SetBackgroundColor(iBackgroundColor2);

   221 	iTransSpriteAnimWin->Window()->SetVisible(EFalse);

   222 	iTransSpriteAnimWin->Window()->Activate();

   223 

   224 	iFrameWin = new (ELeave) CFramesFrameWindow(Ws(), *GroupWin(), *Gc());

   225 	iFrameWin->Window()->SetRequiredDisplayMode(iDisplayMode);

   226 	iFrameWin->Window()->SetExtent(iFrameWinPosition, iWinSize);

   227 	iFrameWin->Window()->SetBackgroundColor(iBackgroundColor1);

   228 	iFrameWin->Window()->SetVisible(ETrue);

   229 	iFrameWin->Window()->Activate();

   230 

   231 	iTransFrameWin = new (ELeave) CFramesFrameWindow(Ws(), *GroupWin(), *Gc());

   232 	iTransFrameWin->Window()->SetTransparencyFactor(0x808080);

   233 	iTransFrameWin->Window()->SetRequiredDisplayMode(iDisplayMode);

   234 	iTransFrameWin->Window()->SetExtent(iFrameWinPosition, iWinSize);

   235 	iTransFrameWin->Window()->SetBackgroundColor(iBackgroundColor2);

   236 	iTransFrameWin->Window()->SetVisible(EFalse);

   237 	iTransFrameWin->Window()->Activate();

   238 

   239 	}

   240 

   241 /**

   242 	@SYMTestCaseID UIF-animation-TFrames-TestFramesL

   243 

   244 	@SYMTestCaseDesc 

   245 	This tests basic animation and sprite animation with frames.

   246 

   247 	@SYMPREQ 269

   248 

   249 	@SYMTestStatus Implemented

   250 

   251 	@SYMTestPriority High

   252 

   253 	@SYMTestActions 

   254 	The animation windows are initialised.  Then basic and sprite animations are

   255 	started, the program waits for the animations to finish, and finally the output checked.

   256 

   257 	@SYMTestExpectedResults Pass

   258 

   259 */

   260 void CFrames::TestFramesL(TInt aFlags)

   261 	{

   262 	iBasicAnimWin->Window()->Invalidate();

   263 	iTransBasicAnimWin->Window()->Invalidate();

   264 	iSpriteAnimWin->Window()->Invalidate();

   265 	iTransSpriteAnimWin->Window()->Invalidate();

   266 	iFrameWin->Window()->Invalidate();

   267 	iTransFrameWin->Window()->Invalidate();

   268 	Ws().Flush();

   269 	WaitForRedrawsToFinish();

   270 	

   271 	// Start the animations:

   272 	TAnimationConfig config;

   273 	config.iFlags = TAnimationConfig::ELoop | TAnimationConfig::ECountFrames;

   274 	

   275 	TInt frameCount = iBasicAnimations.Count() - 3;

   276 	

   277 	for (TInt frame = 0; frame < iBasicAnimations.Count(); ++frame)

   278 		{

   279 		// Some special cases:

   280 		switch(frame - frameCount)

   281 			{

   282 			case 2:

   283 				config.iFlags |= TAnimationConfig::EEndOnLastFrame;

   284 				config.iData = frameCount;

   285 				break;

   286 			default:

   287 				config.iData = frame;

   288 				break;

   289 			}

   290 		iBasicAnimations[frame]->Start(config);

   291 		iSpriteAnimations[frame]->Start(config);

   292 		}

   293 	

   294 	// Why * 4? because we seem to go very slowly?

   295 	Wait(KFramesFrameLength * iBasicAnimations.Count() * 4);

   296 

   297 	// Verify output:

   298 	WaitForRedrawsToFinish();

   299 	ANIMTESTRECT(TRect(iBasicAnimWinPosition, iWinSize), TRect(iFrameWinPosition, iWinSize));

   300 	if(!(aFlags & ENoSprites))

   301 		ANIMTESTRECT(TRect(iSpriteAnimWinPosition, iWinSize), TRect(iFrameWinPosition, iWinSize));

   302 	}

   303 /**

   304 	@SYMTestCaseID UIF-animation-TFrames-TestFramesL2

   305 

   306 	@SYMTestCaseDesc 

   307 	This tests basic animation and sprite animation with frames.  

   308 

   309 	@SYMPREQ 269

   310 

   311 	@SYMTestStatus Implemented

   312 

   313 	@SYMTestPriority High

   314 

   315 	@SYMTestActions 

   316 	The animation windows are initialised.  This function is used to set up tests by TestFramesL by

   317 	initializing basic and sprite animations for a sequence of frames.

   318 

   319 	@SYMTestExpectedResults Tests performed by TestFramesL.

   320 

   321 */

   322 void CFrames::TestFramesL(CFramesAnimationWindow& aBasicAnimWin, CFramesAnimationWindow& aSpriteAnimWin, const TDesC& aFile, CFramesFrameWindow& aFrameWin, const TDesC& aMbm, TInt aFlags)

   323 	{

   324 	iBasicAnimations.ResetAndDestroy();

   325 	iSpriteAnimations.ResetAndDestroy();

   326 	// Load the MBM file into the frame window:

   327 	TInt num = aFrameWin.LoadL(aMbm);

   328 	TSize size = aFrameWin.Size();

   329 	// Load the animation file multiple times:

   330 	CICLAnimationDataProvider * dataProvider;

   331 

   332 	// num + 3 = every frame, 2 more looped past the end, and 1 special case

   333 	for(TInt frame = 0; frame < num + 3; ++frame)

   334 		{

   335 		CAnimation* anim;

   336 		

   337 		dataProvider=new (ELeave) CICLAnimationDataProvider;

   338 		CleanupStack::PushL(dataProvider);

   339 		dataProvider->SetFileL(iFs, aFile);

   340 		CleanupStack::Pop(dataProvider);

   341 		anim = CBasicAnimation::NewL(dataProvider, TPoint((size.iWidth * frame), 0), Ws(), *aBasicAnimWin.Window());

   342 		CleanupStack::PushL(anim);

   343 		User::LeaveIfError(iBasicAnimations.Append(anim));

   344 		CleanupStack::Pop(anim);

   345 

   346 		dataProvider=new (ELeave) CICLAnimationDataProvider;

   347 		CleanupStack::PushL(dataProvider);

   348 		dataProvider->SetFileL(iFs, aFile);

   349 		CleanupStack::Pop(dataProvider);

   350 		anim = CSpriteAnimation::NewL(dataProvider, TPoint((size.iWidth * frame), 0), Ws(), *aSpriteAnimWin.Window());

   351 		CleanupStack::PushL(anim);

   352 		User::LeaveIfError(iSpriteAnimations.Append(anim));

   353 		CleanupStack::Pop(anim);

   354 		}

   355 

   356 	Wait(2000000); // wait for loading to complete

   357 	// Give the animations to the animation window:

   358 	aBasicAnimWin.SetAnimations(&iBasicAnimations, ETrue);

   359 	aSpriteAnimWin.SetAnimations(&iSpriteAnimations, EFalse);

   360 

   361 	TestFramesL(aFlags);

   362 	}

   363 

   364 void CFrames::TestFramesL(const TDesC& aFile, const TDesC& aMbm, TInt aFlags)

   365 	{

   366 	TestFramesL(*iBasicAnimWin, *iSpriteAnimWin, aFile, *iFrameWin, aMbm, aFlags);

   367 	}

   368 

   369 /**

   370 	@SYMTestCaseID UIF-animation-TFrames-doActiveTestStepL

   371 

   372 	@SYMTestCaseDesc 

   373 	This tests basic animation and sprite animation with frames.  

   374 

   375 	@SYMPREQ 269

   376 

   377 	@SYMTestStatus Implemented

   378 

   379 	@SYMTestPriority High

   380 

   381 	@SYMTestActions 

   382 	The animation windows are initialized.  This function is used to set up tests by function TestFramesL. 

   383 	To begin three different squares files are used, with different disposal methods. Then testing is performed

   384 	under a transparent window, on a transparent window, and using opaque windows.

   385 

   386 	@SYMTestExpectedResults Testing performed by TestFramesL.

   387 

   388 */	

   389 TVerdict CFrames::doActiveTestStepL()

   390 	{

   391 	_LIT(KTestMethod1, "Test disposal method 1");

   392 	_LIT(KTestMethod2, "Test disposal method 2");

   393 	_LIT(KTestMethod3, "Test disposal method 3");

   394 	_LIT(KTestMasked, "Test disposal methods on masked images");

   395 	_LIT(KTestMoving, "Test a small moving image");

   396 	_LIT(KTestUnderTransparent, "Test under a transparent window");

   397 	_LIT(KTestOnTransparent, "Test on a transparent window");

   398 	_LIT(KTestOpaque, "Test opaque animation on a transparent window");

   399 	

   400 	InitialiseL();

   401 	

   402 	TInt stage = 0;

   403 	TBool finished = false;

   404 	SetTestStepID(_L("UIF-animation-TFrames-TestFramesL"));

   405 	while(TestStepResult() == EPass && !finished)

   406 		{

   407 		switch(stage)

   408 			{

   409 			case 0:

   410 				ANIM_INFO1(KTestMethod1);

   411 				TestFramesL(KSquares1File, KSquares1MbmFile);

   412 				break;

   413 			case 1:

   414 				ANIM_INFO1(KTestMethod2);

   415 				TestFramesL(KSquares2File, KSquares2MbmFile);

   416 				break;

   417 			case 2:

   418 				ANIM_INFO1(KTestMethod3);

   419 				TestFramesL(KSquares3File, KSquares3MbmFile);

   420 				break;

   421 			case 3:

   422 				ANIM_INFO1(KTestMasked);

   423 				// Skip this test - I think the failure is caused by a disposal method of RestoreToPrevious

   424 				// on an image which is smaller than the full animation, and which is immediately after an

   425 				// image with a disposal method of RestoreToBackground.  However, I am not sure if it is this

   426 				// code which is wrong, or the bitmaps to which the output is being compared.

   427 				// Web browsers generally agree with the bitmaps, but not with the original GIF specification.

   428 				// TestFramesL(KDisposalFile, KDisposalMbmFile); 

   429 				break;

   430 			case 4:

   431 				ANIM_INFO1(KTestMoving);

   432 				// ## Skip this too - defect against ICL because first frame is the wrong size and shape?

   433 				// ## See DEF050484

   434 				//TestFramesL(KMovingFile, KMovingMbmFile);

   435 				stage = 100; // Do transparency last so we don't have to keep setting the windows up.

   436 				break;

   437 			case 101:

   438 				ANIM_INFO1(KTestUnderTransparent);

   439 				iTransBasicAnimWin->Window()->SetVisible(ETrue);

   440 				iTransSpriteAnimWin->Window()->SetVisible(ETrue);

   441 				iTransFrameWin->Window()->SetVisible(ETrue);

   442 				iTransBasicAnimWin->SetLined(ETrue);

   443 				iTransSpriteAnimWin->SetLined(ETrue);

   444 				iTransFrameWin->SetLined(ETrue);

   445 				TestFramesL(KSquares1File, KSquares1MbmFile, ENoSprites);

   446 				break;

   447 			case 102:

   448 				ANIM_INFO1(KTestOnTransparent);

   449 				iTransBasicAnimWin->SetLined(EFalse);

   450 				iTransSpriteAnimWin->SetLined(EFalse);

   451 				iBasicAnimWin->SetAnimations(0);

   452 				iSpriteAnimWin->SetAnimations(0);

   453 				iBasicAnimWin->SetLined(ETrue);

   454 				iSpriteAnimWin->SetLined(ETrue);

   455 				iTransFrameWin->SetLined(EFalse);

   456 				iFrameWin->FreeData();

   457 				iFrameWin->SetLined(ETrue);

   458 				TestFramesL(*iTransBasicAnimWin, *iTransSpriteAnimWin, KSquares2File, *iTransFrameWin, KSquares2MbmFile, ENoSprites);

   459 				break;

   460 			case 103:

   461 				ANIM_INFO1(KTestOpaque);

   462 				iTransBasicAnimWin->SetOpaque(ETrue);

   463 				iTransSpriteAnimWin->SetOpaque(ETrue);

   464 				iTransFrameWin->SetOpaque(ETrue);

   465 				TestFramesL(ENoSprites);

   466 				break;

   467 			default:

   468 				finished = ETrue;

   469 			}

   470 		++stage;

   471 		}

   472 

   473 	RecordTestResultL();

   474 	CloseTMSGraphicsStep();

   475 

   476 	return TestStepResult();

   477 	}

   478