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 // Auto test Animated DLL functions

    15 // 

    16 //

    17 

    18 #include <e32std.h>

    19 #include <w32std.h>

    20 #include <w32adll.h>

    21 #include <bitstd.h>

    22 #include "AUTODLL.H"

    23 #include "TAnimDraw.h"

    24 #include "eventdd.h"

    25 #include <gdi.h>

    26 #include <fbs.h>

    27 

    28 union TAnimArgUnion

    29 	{

    30 	const TAny* any;

    31 	const TBool* Bool;

    32 	const TInt* Int;

    33 	const TPoint* Point;

    34 	const TSize* Size;

    35 	const TRect* Rect;

    36 	const TSpriteMemberInfo* SpriteMemberInfo;

    37 	const TShadowDrawTest* ShadowDrawTest;

    38 	const TDrawTestScreen* DrawTestScreen;

    39 	const TSyncTests* SyncTests;

    40 	const TTimeChangeTest* TimeChangeTest;

    41 	const TAnimRawEvent* AnimRawEvent;

    42 	const TWindowGroupInfoParms* WindowGroupInfoParms;

    43 	const TSetOrdinalParms* SetOrdinalParms;

    44 	const TFrameData* FrameData;

    45 	const TRawEvent* RawEvent;

    46 	};

    47 

    48 class CPanicAnim : public CWindowAnim

    49 	{

    50 	enum TSyncState

    51 		{

    52 		ESyncStateNull,

    53 		ESyncStateStarting,

    54 		ESyncStateCounting,

    55 		ESyncLeave,

    56 		ESyncStateTimeChange1,

    57 		ESyncStateTimeChange2,

    58 		ESyncStateTimeChange3

    59 		};

    60 	enum {ESyncCount=8};

    61 public:

    62 	~CPanicAnim();

    63 	virtual void ConstructL(TAny *aArgs, TBool aHasFocus);

    64 	virtual void Animate(TDateTime *aDateTime);

    65 	virtual void Redraw();

    66 	virtual void Command(TInt aOpcode, TAny *aArgs);

    67 	virtual TInt CommandReplyL(TInt aOpcode, TAny *aArgs);

    68 	virtual void FocusChanged(TBool aState);

    69 	//Pure virtual function from MEventHandler

    70 	virtual TBool OfferRawEvent(const TRawEvent &aRawEvent);

    71 private:

    72 	void StartSyncTest(MAnimGeneralFunctions::TAnimSync aSync);

    73 	void StartTimeChangeTest();

    74 	void DoLeaveInActiveCallback();

    75 	static TInt LeaveInActiveCallback(TAny *aThis);

    76 private:

    77 	TRequestStatus *iStatusPtr;

    78 	TRequestStatus *iStatusPtr2;

    79 	TTime iTime;

    80 	TInt iSyncCount;

    81 	TSyncState iSyncState;

    82 	MAnimGeneralFunctions::TAnimSync iSyncMode;

    83 	TBool iLeaveInRedraw;

    84 	CIdle* iActivePanicIdle;

    85 	};

    86 

    87 class CPanicAnim2 : public CWindowAnim

    88 //

    89 // Simply panics in the ConstructL()

    90 //

    91 	{

    92 public:

    93 	virtual void ConstructL(TAny *aArgs, TBool aHasFocus);

    94 	virtual void Animate(TDateTime *aDateTime);

    95 	virtual void Redraw();

    96 	virtual void Command(TInt aOpcode, TAny *aArgs);

    97 	virtual TInt CommandReplyL(TInt aOpcode, TAny *aArgs);

    98 	virtual void FocusChanged(TBool aState);

    99 	//Pure virtual function from MEventHandler

   100 	virtual TBool OfferRawEvent(const TRawEvent &aRawEvent);

   101 	};

   102 

   103 class CAutoAnim3 : public CWindowAnim

   104 //

   105 // test drawing/redrawing

   106 //

   107 	{

   108 public:

   109 	virtual void ConstructL(TAny *aArgs, TBool aHasFocus);

   110 	virtual void Animate(TDateTime *aDateTime);

   111 	virtual void Redraw();

   112 	virtual void Command(TInt aOpcode, TAny *aArgs);

   113 	virtual TInt CommandReplyL(TInt aOpcode, TAny *aArgs);

   114 	virtual void FocusChanged(TBool aState);

   115 	void Draw(const TRect &aRect);

   116 	void DrawTestScreenL(const TDrawTestScreen* aParams);

   117 	//Pure virtual function from MEventHandler

   118 	virtual TBool OfferRawEvent(const TRawEvent &aRawEvent);

   119 private:

   120 	TRequestStatus *iStatusPtr;

   121 	CFbsFont *iFont;

   122 	TRect iRect;

   123 	TRect iBaseRect;

   124 	TInt iMode;

   125 	};

   126 

   127 class CAutoAnimScrBack : public CWindowAnim

   128 //

   129 // test anim drawing behind a backed up window

   130 //

   131 	{

   132 public:

   133 	virtual void ConstructL(TAny *aArgs, TBool aHasFocus);

   134 	virtual void Animate(TDateTime *aDateTime);

   135 	virtual void Redraw();

   136 	virtual void Command(TInt aOpcode, TAny *aArgs);

   137 	virtual TInt CommandReplyL(TInt aOpcode, TAny *aArgs);

   138 	virtual void FocusChanged(TBool aState);

   139 	void Draw();

   140 	//Pure virtual function from MEventHandler

   141 	virtual TBool OfferRawEvent(const TRawEvent &aRawEvent);

   142 private:

   143 	TRect iRect;

   144 	TInt iMode;

   145 	};

   146 

   147 class CTestSpriteAnim : public CSpriteAnim

   148 	{

   149 public:

   150 	virtual void ConstructL(TAny *aArgs);

   151 	virtual void Animate(TDateTime *aDateTime);

   152 	virtual void Command(TInt aOpcode, TAny *aArgs);

   153 	virtual TInt CommandReplyL(TInt aOpcode, TAny *aArgs);

   154 	//Pure virtual function from MEventHandler

   155 	virtual TBool OfferRawEvent(const TRawEvent &aRawEvent);

   156 private:

   157 	TBool CheckMember(const TSpriteMemberInfo& aMemInfo);

   158 	void DrawMemberL(TInt aMember);

   159 	void DrawMemberL();

   160 	};

   161 

   162 /**

   163 Used by CAnimTimer below

   164 */

   165 class MAnimTimerObserver

   166     {

   167 public:

   168     virtual void DisplayNextFrameL()=0;

   169     };

   170 

   171 /**

   172 This class is used by CTestFreeTimerAnim to determine when to swap the current frame with the next one.

   173 */

   174 class CAnimTimer : public CTimer

   175     {

   176 public:

   177     ~CAnimTimer();

   178     static CAnimTimer* NewL(MAnimTimerObserver& aObserver);

   179     void RunL();

   180 private:

   181     CAnimTimer(MAnimTimerObserver& aObserver);

   182     void ConstructL();

   183 private:

   184     MAnimTimerObserver& iAnim;

   185     };

   186 

   187 class CTestFreeTimerAnim : public CFreeTimerWindowAnim, public MAnimTimerObserver

   188 	{

   189 public:

   190     //from CBase 

   191     ~CTestFreeTimerAnim();

   192 	//from CAnim

   193 	void Animate(TDateTime *aDateTime);

   194 	void Command(TInt aOpcode, TAny *aArgs);

   195 	TInt CommandReplyL(TInt aOpcode, TAny *aArgs);

   196 	//from CWindowAnim 

   197     void ConstructL(TAny *aArgs, TBool aHasFocus);

   198     void Redraw();

   199     void FocusChanged(TBool aState);

   200 	//from MEventHandler

   201 	TBool OfferRawEvent(const TRawEvent &aRawEvent);

   202 private:

   203     void DisplayNextFrameL();

   204 private:

   205     CAnimTimer* iTimer;

   206     TInt iFrameTime;

   207     TRgb iColour;

   208     TRect iRect;    

   209 	};

   210 

   211 class CEventTestAnimBase : public CWindowAnim

   212 	{

   213 	enum {EEventBufferSize=40};

   214 public:

   215 	virtual ~CEventTestAnimBase();

   216 	//Pure virtual functions from CAnim

   217 	virtual void Animate(TDateTime *aDateTime);

   218 	virtual void Command(TInt aOpcode, TAny *aArgs);

   219 	virtual TInt CommandReplyL(TInt aOpcode, TAny *aArgs);

   220 	//Pure virtual functions from CWindowAnim

   221 	virtual void ConstructL(TAny *aArgs, TBool aHasFocus);

   222 	virtual void Redraw();

   223 	virtual void FocusChanged(TBool aState);

   224 	//Pure virtual function from MEventHandler

   225 	virtual TBool OfferRawEvent(const TRawEvent &aRawEvent);

   226 protected:

   227 	void Fail();

   228 	TBool IsIgnorableEvent(const TRawEvent& aRawEvent) const;

   229 	TBool GetNextExpectedEvent(TAnimRawEvent& aRawEvent);

   230 	TBool CompareEvents(const TRawEvent& aExpectedEvent, const TRawEvent& aActualEvent) const;

   231 	TBool HandleRecursiveEvent(const TRawEvent& aRawEvent);

   232 

   233 	TInt Error() const;

   234 	TInt EventCount() const;

   235 	void ResetEventCount();

   236 	TInt TotalExpectedEvents() const;

   237 	TInt AddEvent(const TAnimRawEvent* event);

   238 private:

   239 	virtual TInt AddExpectedEvent(const TAnimRawEvent* event)=0;

   240 private:

   241 	CCirBuf<TAnimRawEvent> iExpectedEvents;

   242 	TInt iError;

   243 	TInt iEventCount;

   244 	};

   245 

   246 class CEventTestAnim : public CEventTestAnimBase

   247 	{

   248 public:

   249 	~CEventTestAnim();

   250 	//Pure virtual functions from CWindowAnim overridden in CEventTestAnimBase

   251 	void ConstructL(TAny* aArgs,TBool aHasFocus);

   252 	//Pure virtual functions from CAnim overridden in CEventTestAnimBase

   253 	TInt CommandReplyL(TInt aOpcode,TAny* aArgs);

   254 	void Command(TInt aOpcode,TAny* aArgs);

   255 private:

   256 	TInt UnloadDeviceDriver();

   257 	//Pure virtual function from CEventTestAnimBase

   258 	TInt AddExpectedEvent(const TAnimRawEvent* event);

   259 private:

   260 	TBool iDevDriverLoaded;

   261 	REventDD iLdd;

   262 	};

   263 

   264 class CEventPostingAnim : public CEventTestAnimBase

   265 	{

   266 public:

   267 	~CEventPostingAnim();

   268 	//Virtual functions from CEventTestAnimBase

   269 	virtual void ConstructL(TAny *aArgs, TBool aHasFocus);

   270 	//Virtual function from MEventHandler

   271 	virtual TBool OfferRawEvent(const TRawEvent &aRawEvent);

   272 private:

   273 	//Pure virtual function from CEventTestAnimBase

   274 	virtual TInt AddExpectedEvent(const TAnimRawEvent* event);

   275 	};

   276 

   277 class CRemovableAnim : public CEventTestAnimBase

   278 	{

   279 public:

   280 	~CRemovableAnim();

   281 	//Virtual functions from CEventTestAnimBase

   282 	virtual TInt CommandReplyL(TInt aOpcode, TAny *aArgs);

   283 	virtual TBool OfferRawEvent(const TRawEvent &aRawEvent);

   284 private:

   285 	//Pure virtual function from CEventTestAnimBase

   286 	virtual TInt AddExpectedEvent(const TAnimRawEvent* event);

   287 private:

   288 	TInt iLifetime;

   289 	};

   290 

   291 class CTimerTestAnim : public CWindowAnim

   292 	{

   293 public:

   294 	~CTimerTestAnim();

   295 	//Pure virtual functions from CAnim

   296 	virtual void Animate(TDateTime *aDateTime);

   297 	virtual void Command(TInt aOpcode, TAny *aArgs);

   298 	virtual TInt CommandReplyL(TInt aOpcode, TAny *aArgs);

   299 	//Pure virtual functions from CWindowAnim

   300 	virtual void ConstructL(TAny *aArgs, TBool aHasFocus);

   301 	virtual void Redraw();

   302 	virtual void FocusChanged(TBool aState);

   303 	//Pure virtual function from MEventHandler

   304 	virtual TBool OfferRawEvent(const TRawEvent &aRawEvent);

   305 private:

   306 	TInt iTimerCount;

   307 	TBool iExpectingTicks;

   308 	TBool iFail;

   309 	};

   310 

   311 class CWinFunctionTestAnim : public CWindowAnim

   312 	{

   313 	//enum {EEventBufferSize=40};

   314 public:

   315 	~CWinFunctionTestAnim();

   316 	//Pure virtual functions from CAnim

   317 	virtual void Animate(TDateTime *aDateTime);

   318 	virtual void Command(TInt aOpcode, TAny *aArgs);

   319 	virtual TInt CommandReplyL(TInt aOpcode, TAny *aArgs);

   320 	//Pure virtual functions from CWindowAnim

   321 	virtual void ConstructL(TAny *aArgs, TBool aHasFocus);

   322 	virtual void Redraw();

   323 	virtual void FocusChanged(TBool aState);

   324 	//Pure virtual function from MEventHandler

   325 	virtual TBool OfferRawEvent(const TRawEvent &aRawEvent);

   326 private:

   327 	MAnimGeneralFunctionsWindowExtension* iWinFunctions;

   328 	};

   329 

   330 class CNotificationTestAnim : public CWindowAnim

   331 	{

   332 public:

   333 	CNotificationTestAnim();

   334 	~CNotificationTestAnim();

   335 	//Pure virtual functions from CAnim

   336 	virtual void HandleNotification(const TWsEvent& aEvent);

   337 	virtual void Animate(TDateTime *aDateTime);

   338 	virtual void Command(TInt aOpcode, TAny *aArgs);

   339 	virtual TInt CommandReplyL(TInt aOpcode, TAny *aArgs);

   340 	//Pure virtual functions from CWindowAnim

   341 	virtual void ConstructL(TAny *aArgs, TBool aHasFocus);

   342 	virtual void Redraw();

   343 	virtual void FocusChanged(TBool aState);

   344 	//Pure virtual function from MEventHandler

   345 	virtual TBool OfferRawEvent(const TRawEvent &aRawEvent);

   346 private:

   347 	TFixedArray<TBool,2> iDSA;

   348 	TBool iHeartbeatState;

   349 	TBool iScreenDeviceChanged;

   350 	TTime iLastAnimTime;

   351 	};

   352 

   353 class CTransAnim : public CWindowAnim

   354 //

   355 // Test drawing/redrawing in Transparent window.

   356 //

   357 	{

   358 public:

   359 	//Implementaion for pure virtual functions from CAnim

   360 	void ConstructL(TAny* aArgs, TBool aHasFocus);

   361 	void Animate(TDateTime* aDateTime);

   362 	void Redraw();

   363 	void Command(TInt aOpcode, TAny* aArgs);

   364 	TInt CommandReplyL(TInt aOpcode, TAny* aArgs);

   365 	void FocusChanged(TBool aState);

   366 	TBool OfferRawEvent(const TRawEvent &aRawEvent);

   367 private:

   368 	CFbsFont* iFont;

   369 	TRect iRect;

   370 	TInt iMode;

   371 	TInt iDraw;

   372 	TRgb iColor;

   373 	TInt iCount;

   374 	};

   375 

   376 class CTestHandlerAnim : public CWindowAnim

   377 	{

   378 	public:

   379 		~CTestHandlerAnim();

   380 		void ConstructL(TAny* aArgs, TBool aHasFocus);

   381 		void Redraw();

   382 		void FocusChanged(TBool aState);

   383 		TInt CommandReplyL(TInt aOpcode, TAny* aArgs);

   384 		void Command(TInt aOpcode, TAny* aArgs);

   385 		void Animate(TDateTime* aDateTime);

   386 		TBool OfferRawEvent(const TRawEvent &aRawEvent);

   387 	private:

   388 	};

   389 

   390 class CCoverageAnim : public CWindowAnim

   391 /**

   392  This class adds functional coverage to CWsAnimGc. 

   393  The actual work is handled by the 'Draw' method which calls

   394  each method in turn.

   395  Mostly copied from CAutoAnimScrBack and CAutoAnim3.

   396  @SYMTestCaseID 

   397  @SYMPREQ 1841 Add Coverage tests.

   398  @SYMTestCaseDesc  Functional coverage.

   399  @SYMTestActions Run functional coverage test on CWsAnimGc.

   400  */

   401 	{

   402 public:

   403 	~CCoverageAnim();

   404 	virtual void ConstructL(TAny *aArgs, TBool aHasFocus);

   405 	virtual void Animate(TDateTime *aDateTime);

   406 	virtual void Redraw();

   407 	virtual void Command(TInt aOpcode, TAny *aArgs);

   408 	virtual TInt CommandReplyL(TInt aOpcode, TAny *aArgs);

   409 	virtual void FocusChanged(TBool aState);

   410 	void Draw();

   411 	//Pure virtual function from MEventHandler

   412 	virtual TBool OfferRawEvent(const TRawEvent &aRawEvent);

   413 private:

   414 	TRect iRect; /** rectangle used for all draw ops that require one */

   415 	CFbsFont* iFont;

   416 	};

   417 

   418 class CMultiPointerAnim : public CWindowAnim

   419 	{

   420 	enum {EEventBufferSize=40};

   421 public:

   422 	virtual ~CMultiPointerAnim();

   423 	//Pure virtual functions from CAnim

   424 	virtual void Animate(TDateTime *aDateTime);

   425 	virtual void Command(TInt aOpcode, TAny *aArgs);

   426 	virtual TInt CommandReplyL(TInt aOpcode, TAny *aArgs);

   427 	//Pure virtual functions from CWindowAnim

   428 	virtual void ConstructL(TAny *aArgs, TBool aHasFocus);

   429 	virtual void Redraw();

   430 	virtual void FocusChanged(TBool aState);

   431 	//Pure virtual function from MEventHandler

   432 	virtual TBool OfferRawEvent(const TRawEvent &aRawEvent);

   433 protected:

   434 	TInt AddEvent(const TAnimRawEvent* aEvent);

   435 	TBool CompareEvents(const TRawEvent& aExpectedEvent, const TRawEvent& aActualEvent);

   436 private:

   437 	CCirBuf<TAnimRawEvent> iExpectedEvents;

   438 	TBuf<255> iErrorDes;

   439 	TInt iEventCount;

   440 	TInt iError;

   441 	};

   442 

   443 class CTestAnimDll : public CAnimDll

   444 	{

   445 public:

   446 	CAnim *CreateInstanceL(TInt aType);

   447 private:

   448 	};

   449 

   450 /*#if defined(__WINS__)

   451 #pragma data_seg(".E32_UID")

   452 __WINS_UID(0, KWservAnimDllUidValue, 0)

   453 #pragma data_seg()

   454 #endif*/

   455 

   456 EXPORT_C CAnimDll *CreateCAnimDllL()

   457 	{

   458 	return(new(ELeave) CTestAnimDll());

   459 	}

   460 

   461 

   462 // Panic Tests //

   463 void CPanicAnim::ConstructL(TAny *, TBool )

   464 	{

   465 	iWindowFunctions->SetRect(TRect(0,0,1,1));

   466 	iFunctions->SetSync(MAnimGeneralFunctions::ESyncSecond);

   467 	if (iFunctions->Sync()!=MAnimGeneralFunctions::ESyncSecond)

   468 		User::Leave(KErrGeneral);

   469 // Check the anim time is not ahead of and not more than 2 secs behind the system time

   470 	TTime now;

   471 	now.UniversalTime();

   472 	TDateTime dt=now.DateTime();

   473 	TDateTime adt=iFunctions->SystemTime();

   474 	if (adt.Day()!=dt.Day())

   475 		User::Leave(KErrGeneral);

   476 

   477 	iFunctions->SetSync(MAnimGeneralFunctions::ESyncNone);

   478 	if (iFunctions->Sync()!=MAnimGeneralFunctions::ESyncNone)

   479 		User::Leave(KErrGeneral);

   480 	}

   481 

   482 CPanicAnim::~CPanicAnim()

   483 	{

   484 	delete iActivePanicIdle;

   485 	}

   486 

   487 void CPanicAnim::Animate(TDateTime *aDateTime)

   488 	{

   489 	switch(iSyncState)

   490 		{

   491 		case ESyncStateNull:

   492 			break;

   493 		case ESyncStateStarting:

   494 			iTime=iFunctions->SystemTime();

   495 			iSyncState=ESyncStateCounting;

   496 			iSyncCount=0;

   497 			break;

   498 		case ESyncStateCounting:

   499 			if (aDateTime)

   500 				{

   501 				TTimeIntervalSeconds interval;

   502 				TTime(*aDateTime).SecondsFrom(iTime, interval);

   503 				iSyncCount=interval.Int();

   504 				}

   505 			else

   506 				iSyncCount++;

   507 			if (iSyncCount==ESyncCount)

   508 				{

   509 				TTimeIntervalMicroSeconds minInterval(0);

   510 				TTimeIntervalMicroSeconds maxInterval(0);

   511 				iSyncState=ESyncStateNull;

   512 				switch(iSyncMode)

   513 					{

   514 					case MAnimGeneralFunctions::ESyncSecond:

   515 						minInterval=iSyncCount*1000000-100000;

   516 						maxInterval=iSyncCount*1000000+100000;

   517 						break;

   518 					default:;

   519 					}

   520 				TTime time(iFunctions->SystemTime());

   521 				TTimeIntervalMicroSeconds interval=time.MicroSecondsFrom(iTime);

   522 				TInt ret=KErrNone;

   523 				if (interval<minInterval || interval>maxInterval)

   524 					ret=KErrGeneral;

   525 				iFunctions->Client().RequestComplete(iStatusPtr,ret);

   526 				}

   527 			break;

   528 		case ESyncLeave:

   529 			User::Leave(KErrGeneral);	// Test: Not allowed to leave, will cause a panic

   530 			break;

   531 		case ESyncStateTimeChange1:

   532 			if (!aDateTime)

   533 				{

   534 				iFunctions->Client().RequestComplete(iStatusPtr,KErrNone);

   535 				iSyncState=ESyncStateTimeChange2;

   536 				}

   537 			break;

   538 		case ESyncStateTimeChange2:

   539 			if (!aDateTime)

   540 				{

   541 				iSyncState=ESyncStateTimeChange3;

   542 				break;

   543 				}

   544 		case ESyncStateTimeChange3:

   545 			iFunctions->Client().RequestComplete(iStatusPtr2,aDateTime ? KErrNone : KErrGeneral);

   546 			iSyncState=ESyncStateNull;

   547 			break;

   548 		}

   549 	}

   550 

   551 void CPanicAnim::Redraw()

   552 	{

   553 	if (iLeaveInRedraw)

   554 		User::Leave(KErrGeneral);	//Test: Not allowed to leave, will cause a panic

   555 	}

   556 

   557 void CPanicAnim::Command(TInt aOpcode, TAny *)

   558 	{

   559 	switch(aOpcode)

   560 		{

   561 		case EADllPanicCallPanic:

   562 			iFunctions->Panic();

   563 			break;

   564 		case EADllPanicSetInterval:

   565 			iFunctions->SetSync(MAnimGeneralFunctions::ESyncSecond);

   566 			iFunctions->SetInterval(1);

   567 			break;

   568 		case EADllPanicSetNextInterval:

   569 			iFunctions->SetSync(MAnimGeneralFunctions::ESyncMinute);

   570 			iFunctions->SetNextInterval(1);

   571 			break;

   572 		case EADllPanicDoubleActivateGC:

   573 			iWindowFunctions->ActivateGc();

   574 			iWindowFunctions->ActivateGc();

   575 			break;

   576 		case EADllPanicDrawRectWithNoGc:

   577 			iGc->DrawRect(TRect(0,0,10,10));

   578 			break;

   579 		case EADllPanicDrawTextWithNoFont:

   580 			iWindowFunctions->ActivateGc();

   581 			iGc->DrawText(_L("Panic"),TPoint(20,20));

   582 			break;

   583 		case EADllPanicLeaveInAnimate:

   584 			iFunctions->SetSync(MAnimGeneralFunctions::ESyncFlash);

   585 			iSyncState=ESyncLeave;

   586 			break;

   587 		case EADllPanicLeaveInRedraw:

   588 			iLeaveInRedraw=ETrue;

   589 			iWindowFunctions->Invalidate(TRect(0,0,10,10));

   590 			break;

   591 		case EADllPanicLeave:

   592 			//tests a leaving function in a non-leaving function and should not be moved to CommandReplyL as it leaves

   593 			User::Leave(KErrGeneral);	//LeaveScan: intentional test

   594 			break;

   595 		case EADllPanicSetVisWithGcActive:

   596 			iWindowFunctions->ActivateGc();

   597 			iWindowFunctions->SetVisible(EFalse);

   598 			iWindowFunctions->SetVisible(ETrue);

   599 			break;

   600 		case EADllPanicLeaveInActiveCallback:

   601 			iActivePanicIdle=CIdle::NewL(EPriorityHigh);

   602 			iActivePanicIdle->Start(TCallBack(CPanicAnim::LeaveInActiveCallback,this));

   603 			break;

   604 		case EADllPanicSetClippingRectWithNoGc:

   605 			{

   606 			// currently this test fails because when deactivated iWin is also NULL and is deferenced in function

   607 			TRect rect(20,20,20,20);	

   608 			iGc->SetClippingRect(rect);

   609 			}

   610 			break;

   611 		case EADllPanicCancelClippingRegionWithNoGc:

   612 			// currently this test fails because when deactivated iWin is NULL and function leaves

   613 			iGc->CancelClippingRegion();

   614 			break;

   615 		case EADllPanicCancelClippingRectWithNoGc:

   616 			// currently this test fails because when deactivated iWin is also NULL and is deferenced in function

   617 			iGc->CancelClippingRect();

   618 			break;

   619 		case EADllPanicSetDrawModeWithNoGc:

   620 			iGc->SetDrawMode(CGraphicsContext::EDrawModeAND);

   621 			break;

   622 		case EADllPanicUseFontWithNoGc:

   623 			{

   624 			// currently this test fails because does not check for NULL font

   625 			CFbsFont* font = NULL;

   626 			iGc->UseFont(font);

   627 			}

   628 			break;

   629 		case EADllPanicDiscardFontWithNoGc:

   630 			iGc->DiscardFont();

   631 			break;

   632 		case EADllPanicSetUnderlineStyleWithNoGc:

   633 			iGc->SetUnderlineStyle(EUnderlineOff);

   634 			break;

   635 		case EADllPanicSetStrikeThoughStyleWithNoGc:

   636 			iGc->SetStrikethroughStyle(EStrikethroughOff);

   637 			break;

   638 		case EADllPanicSetWordJustificationWithNoGc:

   639 			iGc->SetWordJustification(0,0);

   640 			break;

   641 		case EADllPanicSetCharJustificationWithNoGc:

   642 			iGc->SetCharJustification(0,0);

   643 			break;

   644 		case EADllPanicSetPenColorWithNoGc:

   645 			{

   646 			TRgb rgbs;

   647 			iGc->SetPenColor(rgbs);

   648 			}

   649 			break;

   650 		case EADllPanicSetPenStyleWithNoGc:

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

   652 			break;

   653 		case EADllPanicSetPenSizeWithNoGc:

   654 			{

   655 			const TSize size;

   656 			iGc->SetPenSize(size);

   657 			}

   658 			break;

   659 		case EADllPanicSetBrushColorWithNoGc:

   660 			{

   661 			TRgb rgbs;

   662 			iGc->SetBrushColor(rgbs);

   663 			}

   664 			break;

   665 		case EADllPanicSetBrushStyleWithNoGc:

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

   667 			break;

   668 		case EADllPanicSetBrushOriginWithNoGc:

   669 			{

   670 			TPoint point;

   671 			iGc->SetBrushOrigin(point);

   672 			}

   673 			break;

   674 		case EADllPanicUseBrushPatterWithNoGc:

   675 			{

   676 			CFbsBitmap* bitmap = new(ELeave) CFbsBitmap();

   677 			CleanupStack::PushL(bitmap);

   678 			User::LeaveIfError(bitmap->Create(TSize(16,16),EGray4));

   679 			iGc->UseBrushPattern(bitmap);

   680 			CleanupStack::PopAndDestroy(bitmap);

   681 			}

   682 			break;

   683 		case EADllPanicDiscardBrushPatternWithNoGc:

   684 			iGc->DiscardBrushPattern();

   685 			break;

   686 		case EADllPanicSetFadedWithNoGc:

   687 			iGc->SetFaded(EFalse);

   688 			break;

   689 		case EADllPanicSetFadingParametersWithNoGc:

   690 			iGc->SetFadingParameters(1,1);

   691 			break;

   692 		case EADllPanicDrawArcWithNoGc:

   693 			{

   694 			TRect rect;

   695 			iGc->DrawArc(rect,

   696 				TPoint(rect.Center().iX, rect.iTl.iY),

   697 				TPoint(rect.iBr.iX, rect.Center().iY));

   698 			}

   699 			break;

   700 		case EADllPanicDrawPieWithNoGc:

   701 			{

   702 			TRect rect;				

   703 			iGc->DrawPie(rect, TPoint(rect.Center().iX, rect.iTl.iY), TPoint(rect.iBr.iX, rect.Center().iY));

   704 			}

   705 			break;

   706 		case EADllPanicDrawLineWithNoGc:

   707 			{	

   708 			const TPoint point1;

   709 			const TPoint point2;

   710 			iGc->DrawLine(point1, point2);

   711 			}

   712 			break;

   713 		case EADllPanicDrawLineToWithNoGc:

   714 			{

   715 			const TPoint point;

   716 			iGc->DrawLineTo(point);

   717 			}

   718 			break;

   719 		case EADllPanicDrawLineByWithNoGc:

   720 			{

   721 			const TPoint point;

   722 			iGc->DrawLineBy(point);

   723 			}

   724 			break;

   725 		case EADllPanicDrawEllipseWithNoGc:

   726 			{

   727 			TRect rect(20,20,20,20);

   728 			iGc->DrawEllipse(rect);

   729 			}

   730 			break;

   731 		case EADllPanicDrawRoundedRecWithNoGc:

   732 			{

   733 			TRect rect;

   734 			iGc->DrawRoundRect(rect, TSize(rect.Width()/8, rect.Height()/8));

   735 			}

   736 			break;

   737 		case EADllPanicClearWithRectWithNoGc:

   738 			{

   739 			TRect rect(20,20,20,20);

   740 			iGc->Clear(rect);

   741 			}

   742 			break;

   743 		case EADllPanicClearWithNoGc:

   744 			iGc->Clear();

   745 			break;

   746 		case EADllPanicBitBltWithNoGc:

   747 			{

   748 			CFbsBitmap* bitmap = new(ELeave) CFbsBitmap();

   749 			CleanupStack::PushL(bitmap);

   750 			User::LeaveIfError(bitmap->Create(TSize(16,16),EGray4));

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

   752 			CleanupStack::PopAndDestroy(bitmap);

   753 			}

   754 			break;

   755 		case EADllPanicBitBltWithRectWithNoGc:

   756 			{

   757 			CFbsBitmap* bitmap = new(ELeave) CFbsBitmap();

   758 			TRect rect;

   759 			CleanupStack::PushL(bitmap);

   760 			User::LeaveIfError(bitmap->Create(TSize(16,16),EGray4));

   761 			iGc->BitBlt(TPoint(0, 0), bitmap, rect);

   762 			CleanupStack::PopAndDestroy(bitmap);

   763 			}

   764 			break;

   765 		case EADllPanicBitBltMaskedWithNoGc:

   766 			{

   767 			CFbsBitmap* bitmap = new(ELeave) CFbsBitmap();

   768 			TRect rect;

   769 			CleanupStack::PushL(bitmap);

   770 			User::LeaveIfError(bitmap->Create(TSize(16,16),EGray4));

   771 			iGc->BitBltMasked(TPoint(0, 0), bitmap, rect, bitmap, EFalse);

   772 			CleanupStack::PopAndDestroy(bitmap);

   773 			}

   774 			break;

   775 		case EADllPanicDrawBitmapMaskedFbsBitmapWithNoGc:

   776 			{

   777 			CFbsBitmap* bitmap = new(ELeave) CFbsBitmap();

   778 			TRect rect;

   779 			CleanupStack::PushL(bitmap);

   780 			User::LeaveIfError(bitmap->Create(TSize(16,16),EGray4));

   781 			iGc->DrawBitmapMasked(rect, bitmap, rect, bitmap, ETrue);

   782 			CleanupStack::PopAndDestroy(bitmap);

   783 			}

   784 			break;

   785 		case EADllPanicDrawBitmapMaskedWsBitmapWithNoGc:

   786 			{

   787 			CWsBitmap* bitmap = NULL;

   788 			TRect rect;

   789 			iGc->DrawBitmapMasked(rect, bitmap, rect, bitmap, ETrue);

   790 			}

   791 			break;

   792 		case EADllPanicDrawBitmapPointWithNoGc:

   793 			{

   794 			CWsBitmap* bitmap = NULL;

   795 			TRect rect;

   796 			iGc->DrawBitmap(rect.iTl, bitmap);

   797 			}

   798 			break;

   799 		case EADllPanicDrawBitmapWithNoGc:

   800 			{

   801 			CWsBitmap* bitmap = NULL;

   802 			TRect rect;

   803 			iGc->DrawBitmap(rect, bitmap);

   804 			}

   805 			break;

   806 		case EADllPanicDrawBitmapRectWithNoGc:

   807 			{

   808 			CWsBitmap* bitmap = NULL;

   809 			TRect rect;

   810 			iGc->DrawBitmap(rect, bitmap, TRect(0, 0, 16, 16));

   811 			}

   812 			break;

   813 		case EADllPanicDrawPolyLinePointsWithNoGc:

   814 			{

   815 			TRect rect;

   816 			CArrayFixFlat<TPoint>* polyPoints = new(ELeave) CArrayFixFlat<TPoint>(3); //CArrayFixFlat

   817 			CleanupStack::PushL(polyPoints);

   818 			polyPoints->AppendL(rect.iTl);

   819 			polyPoints->AppendL(rect.Center());

   820 			polyPoints->AppendL(TPoint(rect.iBr.iX, rect.iTl.iY));

   821 			iGc->DrawPolyLine(&polyPoints->At(0), 3);

   822 			CleanupStack::PopAndDestroy(polyPoints);

   823 			}

   824 			break;

   825 		case EADllPanicDrawPolyLineArrayWithNoGc:

   826 			{

   827 			TRect rect;

   828 			CArrayFixFlat<TPoint>* polyPoints = new(ELeave) CArrayFixFlat<TPoint>(3); //CArrayFixFlat

   829 			CleanupStack::PushL(polyPoints);

   830 			polyPoints->AppendL(rect.iTl);

   831 			polyPoints->AppendL(rect.Center());

   832 			polyPoints->AppendL(TPoint(rect.iBr.iX, rect.iTl.iY));

   833 			iGc->DrawPolyLine(polyPoints);

   834 			CleanupStack::PopAndDestroy(polyPoints);

   835 			}

   836 			break;

   837 		case EADllPanicMoveToWithNoGc:

   838 			{

   839 			TPoint point;

   840 			iGc->MoveTo(point);

   841 			}

   842 			break;

   843 		case EADllPanicMoveByWithNoGc:

   844 			{

   845 			TPoint point;

   846 			iGc->MoveBy(point);

   847 			}

   848 			break;

   849 		case EADllPanicPlotWithNoGc:

   850 			{

   851 			TPoint point;

   852 			iGc->Plot(point);

   853 			}

   854 			break;

   855 		case EADllPanicSetOriginWithNoGc:

   856 			{

   857 			TPoint point;

   858 			iGc->SetOrigin(point);

   859 			}

   860 			break;

   861 		case EADllPanicCopyRectWithNoGc:

   862 			{

   863 			TPoint point;

   864 			TRect rect;

   865 			iGc->CopyRect(point, rect);

   866 			}

   867 			break;

   868 		case EADllPanicResetWithNoGc:

   869 			iGc->Reset();

   870 			break;

   871 		case EADllPanicMapColorsWithNoGc:

   872 			{

   873 			TRgb rgbs[2];

   874 			TRect rect;

   875 			iGc->MapColors(rect, rgbs, 1, ETrue);

   876 			}

   877 			break;

   878 		case EADllPanicDrawTextWithRectWithNoFont:

   879 			iWindowFunctions->ActivateGc();

   880 			iGc->DrawText(_L("Panic"),TRect(20,20,20,20),0);

   881 			break;

   882 		case EADllPanicDrawTextVerticalWithNoFont:

   883 			iWindowFunctions->ActivateGc();

   884 			iGc->DrawTextVertical(_L("Panic"),TPoint(20,20), EFalse);

   885 			break;

   886 		case EADllPanicDrawTextVerticalWithRectWithNoFont:

   887 			iWindowFunctions->ActivateGc();

   888 			iGc->DrawTextVertical(_L("Panic"),TRect(20,20,20,20), 0, EFalse);

   889 			break;

   890 		case EADllPanicInvalidFocusScreenTooBig:

   891 			(static_cast<MAnimGeneralFunctionsWindowExtension*>(iFunctions->ExtendedInterface(MAnimGeneralFunctions::EWindowExtensionInterface)))->SetFocusScreen(3000);

   892 			break;

   893 		case EADllPanicInvalidFocusScreenNegative:

   894 			(static_cast<MAnimGeneralFunctionsWindowExtension*>(iFunctions->ExtendedInterface(MAnimGeneralFunctions::EWindowExtensionInterface)))->SetFocusScreen(-1);

   895 			break;

   896 		default:

   897 			iFunctions->Panic();

   898 		}

   899 	}

   900 

   901 void CPanicAnim::DoLeaveInActiveCallback()

   902 	{

   903 	iWindowFunctions->ActivateGc();

   904 	User::Leave(KErrUnknown);

   905 	}

   906 

   907 TInt CPanicAnim::LeaveInActiveCallback(TAny *aThis)

   908 	{

   909 	CPanicAnim* panicAnim=(CPanicAnim*)aThis;

   910 	panicAnim->DoLeaveInActiveCallback();

   911 	return(KErrNone);

   912 	}

   913 

   914 void CPanicAnim::StartSyncTest(MAnimGeneralFunctions::TAnimSync aSync)

   915 	{

   916 	iFunctions->SetSync(aSync);

   917 	iSyncMode=aSync;

   918 	iSyncState=ESyncStateStarting;

   919 	}

   920 

   921 void CPanicAnim::StartTimeChangeTest()

   922 	{

   923 	iFunctions->SetSync(MAnimGeneralFunctions::ESyncSecond);

   924 	iSyncMode=MAnimGeneralFunctions::ESyncSecond;

   925 	iSyncState=ESyncStateTimeChange1;

   926 	}

   927 

   928 TInt CPanicAnim::CommandReplyL(TInt aOpcode,TAny* aParams)

   929 	{

   930 	TAnimArgUnion pData;

   931 	pData.any=aParams;

   932 	switch(aOpcode)

   933 		{

   934 		case EADllPanicBadFont:

   935 			iFunctions->DuplicateFontL(123);

   936 			break;

   937 		case EADllPanicBadBitmap:

   938 			iFunctions->DuplicateBitmapL(123);

   939 			break;

   940 		case EADllPanicCallPanic:

   941 			iFunctions->Panic();

   942 			break;

   943 		case EADllReadRemoteDescriptor:

   944 			{

   945 			TInt ret=0;

   946 			const RMessagePtr2& message=*iFunctions->Message();

   947 			TInt bufLength = message.GetDesLength(KIpcSlot);

   948 			TUint16* heapCell=static_cast<TUint16*>(User::AllocL(bufLength*2));

   949 			TPtr buf(heapCell,bufLength*2,bufLength*2);

   950 			const TInt theError=message.Read(KIpcSlot,buf);

   951 			if(theError == KErrNone)

   952 				{

   953 				for (TInt index=0;index<bufLength;index++)

   954 					{

   955 					ret+=buf[index];

   956 					}

   957 				}

   958 			User::Free(heapCell);

   959 			return(ret);

   960 			}

   961 		case EADllTestWindowSize:

   962 			return(*pData.Size==iWindowFunctions->WindowSize());

   963 		case EADllSyncTests:

   964 			iStatusPtr=pData.SyncTests->status;

   965 			StartSyncTest(pData.SyncTests->syncMode);

   966 			break;

   967 		case EADllTimeChangedTest:

   968 			iStatusPtr=pData.TimeChangeTest->status;

   969 			iStatusPtr2=pData.TimeChangeTest->status2;

   970 			StartTimeChangeTest();

   971 			break;

   972 		case EADllTestSetVisible:

   973 			if (iWindowFunctions->IsHidden())

   974 				goto setVisFailed;

   975 			iWindowFunctions->SetVisible(EFalse);

   976 			if (!iWindowFunctions->IsHidden())

   977 				goto setVisFailed;

   978 			iWindowFunctions->SetVisible(ETrue);

   979 			if (iWindowFunctions->IsHidden())

   980 setVisFailed:	return(EFalse);

   981 			return(ETrue);

   982 		case EADllPanicSetVisWithGcActiveReply:

   983 			iWindowFunctions->ActivateGc();

   984 			iWindowFunctions->SetVisible(EFalse);

   985 			iWindowFunctions->SetVisible(ETrue);

   986 			break;

   987 		case EADllPanicSetClippingRegionWithNoGc:

   988 			{

   989 			// currently this test fails because when deactivated iWin is also NULL and is deferenced in function

   990 			RRegion region;

   991 			TBool err = iGc->SetClippingRegion(region);

   992 			}

   993 			break;

   994 		case EADllPanicDrawPolygonPointsWithNoGc:

   995 			{	

   996 			TRect rect(20,20,20,20);

   997 			CArrayFixFlat<TPoint>* polyPoints = new(ELeave) CArrayFixFlat<TPoint>(3); //CArrayFixFlat

   998 			CleanupStack::PushL(polyPoints);

   999 			polyPoints->AppendL(rect.iTl);

  1000 			polyPoints->AppendL(rect.Center());

  1001 			polyPoints->AppendL(TPoint(rect.iBr.iX, rect.iTl.iY));

  1002 			iGc->DrawPolygon(polyPoints, CGraphicsContext::EWinding);

  1003 			CleanupStack::PopAndDestroy(polyPoints);

  1004 			}

  1005 			break;

  1006 		case EADllPanicDrawPolygonArrayWithNoGc:

  1007 			{	

  1008 			TRect rect(20,20,20,20);

  1009 			CArrayFixFlat<TPoint>* polyPoints = new(ELeave) CArrayFixFlat<TPoint>(3); //CArrayFixFlat

  1010 			CleanupStack::PushL(polyPoints);

  1011 			polyPoints->AppendL(rect.iTl);

  1012 			polyPoints->AppendL(rect.Center());

  1013 			polyPoints->AppendL(TPoint(rect.iBr.iX, rect.iTl.iY));

  1014 			iGc->DrawPolygon(&polyPoints->At(0), 3, CGraphicsContext::EAlternate);

  1015 			CleanupStack::PopAndDestroy(polyPoints);

  1016 			}

  1017 			break;

  1018 		case EADllPanicAlphaBlendingBitmapsFbsBitmapWithNoGc:

  1019 			{

  1020 			TRect rect(20,20,20,20);

  1021 			CFbsBitmap* bitmap = new(ELeave) CFbsBitmap();

  1022 			CleanupStack::PushL(bitmap);

  1023 			User::LeaveIfError(bitmap->Create(TSize(16,16),EGray4));

  1024 			iGc->AlphaBlendBitmaps(TPoint(0, 0), bitmap, rect, bitmap, TPoint(0,0));

  1025 			CleanupStack::PopAndDestroy(bitmap);

  1026 			}

  1027 			break;

  1028 		case EADllPanicDevice:

  1029 			{

  1030 			CGraphicsDevice *device = iGc->Device();

  1031 			}

  1032 			break;

  1033 		default:

  1034 			iFunctions->Panic();

  1035 		}

  1036 	return(KErrNone);

  1037 	}

  1038 

  1039 void CPanicAnim::FocusChanged(TBool )

  1040 	{

  1041 	}

  1042 

  1043 TBool CPanicAnim::OfferRawEvent(const TRawEvent &/*aRawEvent*/)

  1044 	{

  1045 	return EFalse;

  1046 	}

  1047 

  1048 

  1049 // CPanicAnim2 simply panics in the construct //

  1050 void CPanicAnim2::ConstructL(TAny *, TBool )

  1051 	{

  1052 	iFunctions->Panic();

  1053 	}

  1054 

  1055 void CPanicAnim2::Animate(TDateTime *)

  1056 	{}

  1057 

  1058 void CPanicAnim2::Redraw()

  1059 	{}

  1060 

  1061 void CPanicAnim2::Command(TInt , TAny *)

  1062 	{}

  1063 

  1064 TInt CPanicAnim2::CommandReplyL(TInt , TAny *)

  1065 	{return(0);}

  1066 

  1067 void CPanicAnim2::FocusChanged(TBool )

  1068 	{}

  1069 

  1070 TBool CPanicAnim2::OfferRawEvent(const TRawEvent &/*aRawEvent*/)

  1071 	{

  1072 	return EFalse;

  1073 	}

  1074 

  1075 

  1076 // CAutoAnim3 test drawing/redrawing //

  1077 void CAutoAnim3::ConstructL(TAny *aParam, TBool )

  1078 	{

  1079 	iRect=*((TRect *)aParam);

  1080 	iWindowFunctions->SetRect(iRect);

  1081 	iMode=0;

  1082 	iWindowFunctions->Invalidate(iRect);

  1083 	iFunctions->SetSync(MAnimGeneralFunctions::ESyncSecond);

  1084 	}

  1085 

  1086 void CAutoAnim3::Animate(TDateTime *)

  1087 	{

  1088 	iWindowFunctions->ActivateGc();

  1089 	if (iMode==1)

  1090 		{

  1091 		Draw(iRect);

  1092 		if (iRect.Width()>20 && iRect.Height()>20)

  1093 			iRect.Shrink(TSize(20,20));

  1094 		else

  1095 			iRect=iBaseRect;

  1096 		Draw(iRect);

  1097 		}

  1098 	else if (iMode==2)

  1099 		{

  1100 		Draw(iRect);

  1101 		iFunctions->Client().RequestComplete(iStatusPtr,KErrNone);

  1102 		iFunctions->SetSync(MAnimGeneralFunctions::ESyncNone);

  1103 		}

  1104 	else if (iMode==3)

  1105 		{

  1106 		// flip between two sizes

  1107 		if (iRect.iTl.iX == 10)

  1108 			iRect.SetRect(40,40,80,80);

  1109 		else

  1110 			iRect.SetRect(10,10,110,110);

  1111 		Draw(iRect);

  1112 		}

  1113 	}

  1114 

  1115 void CAutoAnim3::Draw(const TRect &aRect)

  1116 	{

  1117 	switch(iMode)

  1118 		{

  1119 		case 0:

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

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

  1122 			iGc->SetBrushColor(TRgb::Gray256(85));

  1123 			iGc->SetPenColor(TRgb::Gray256(170));

  1124 			iGc->DrawEllipse(aRect);

  1125 			iGc->SetBrushStyle(CGraphicsContext::ENullBrush);

  1126 			break;

  1127 		case 1:	// Shrinking box

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

  1129 			iGc->SetPenColor(TRgb::Gray256(255));

  1130 			iGc->DrawRect(aRect);

  1131 			break;

  1132 		case 2:

  1133 		case 3:

  1134 			iGc->SetDrawMode(CGraphicsContext::EDrawModePEN);