1 // Copyright (c) 1996-2010 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  @test

    19  @internalComponent - Internal Symbian test code

    20 */

    21 

    22 #ifndef __TOOM_H__

    23 #define __TOOM_H__

    24 

    25 #include <e32std.h>

    26 #include <w32std.h>

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

    28 #include "AUTO.H"

    29 #include "TGraphicsHarness.h"

    30 

    31 

    32 typedef TBuf<0x40> TOomTestName;

    33 

    34 class CTOom;

    35 

    36 const TInt KNumCapKeyRequest = 20;

    37 

    38 

    39 class COomFailBase : public CBase

    40 	{

    41 public:

    42 	COomFailBase(CTOom *aTest);

    43 	virtual void ConstructL();

    44 	virtual void PreFail();

    45 	virtual void ClearUpL();

    46 	virtual void Flush();

    47 	virtual TInt Fail()=0;

    48 	virtual TOomTestName TestName()=0;

    49 protected:

    50 	RWsSession iWs;

    51 	CWsScreenDevice* iDummyScreen;

    52 	CTOom *iTest;

    53 	};

    54 

    55 

    56 class COomConnect : public COomFailBase

    57 	{

    58 public:

    59 	COomConnect(CTOom *aTest);

    60 	TInt Fail();

    61 	void ClearUpL();

    62 	TOomTestName TestName();

    63 	};

    64 

    65 class COomSetup : public COomFailBase

    66 	{

    67 public:

    68 	COomSetup(CTOom *aTest);

    69 	~COomSetup();

    70 	void ConstructL();

    71 protected:

    72 	RWindowGroup iWinGroup;

    73 	};

    74 

    75 class COomWindowGroup : public COomSetup

    76 	{

    77 public:

    78 	COomWindowGroup(CTOom *aTest);

    79 	void ClearUpL();

    80 	TInt Fail();

    81 	TOomTestName TestName();

    82 private:

    83 	RWindowGroup iFailWinGroup;

    84 	};

    85 

    86 class COomWindow : public COomSetup

    87 	{

    88 public:

    89 	COomWindow(CTOom *aTest);

    90 	void ClearUpL();

    91 	TInt Fail();

    92 	TOomTestName TestName();

    93 private:

    94 	RWindow iFailWin;

    95 	};

    96 

    97 class COomBackedUpWindow : public COomSetup

    98 	{

    99 public:

   100 	COomBackedUpWindow(CTOom *aTest);

   101 	void ClearUpL();

   102 	TInt Fail();

   103 	TOomTestName TestName();

   104 private:

   105 	RBackedUpWindow iFailWin;

   106 	};

   107 

   108 class COomBlankWindow : public COomSetup

   109 	{

   110 public:

   111 	COomBlankWindow(CTOom *aTest);

   112 	void ClearUpL();

   113 	TInt Fail();

   114 	TOomTestName TestName();

   115 private:

   116 	RBlankWindow iFailWin;

   117 	};

   118 

   119 class COomGc : public COomSetup

   120 	{

   121 public:

   122 	COomGc(CTOom *aTest);

   123 	~COomGc();

   124 	void ConstructL();

   125 	void ClearUpL();

   126 	TInt Fail();

   127 	TOomTestName TestName();

   128 private:

   129 	CWsScreenDevice *iScrDev;

   130 	CWindowGc *iFailGc;

   131 	};

   132 

   133 class COomPolygon : public COomSetup

   134 	{

   135 public:

   136 	COomPolygon(CTOom *aTest);

   137 	~COomPolygon();

   138 	void ConstructL();

   139 	void ClearUpL();

   140 	TInt Fail();

   141 	TOomTestName TestName();

   142 private:

   143 	CWsScreenDevice *iScrDev;

   144 	RBackedUpWindow iWin;

   145 	CWindowGc *iGc;

   146 	CArrayFixSeg<TPoint> iPnts;

   147 	};

   148 

   149 class COomScreenDevice : public COomSetup

   150 	{

   151 public:

   152 	COomScreenDevice(CTOom *aTest);

   153 	void ClearUpL();

   154 	TInt Fail();

   155 	TOomTestName TestName();

   156 private:

   157 	CWsScreenDevice *iScrDev;

   158 	};

   159 

   160 class COomBackupResize : public COomSetup

   161 	{

   162 public:

   163 	COomBackupResize(CTOom *aTest);

   164 	~COomBackupResize();

   165 	void ConstructL();

   166 	void ClearUpL();

   167 	TInt Fail();

   168 	TOomTestName TestName();

   169 private:

   170 	RBackedUpWindow iFailWin;

   171 	};

   172 

   173 class COomPointerBuffer : public COomSetup

   174 	{

   175 public:

   176 	COomPointerBuffer(CTOom *aTest);

   177 	~COomPointerBuffer();

   178 	void ConstructL();

   179 	void ClearUpL();

   180 	TInt Fail();

   181 	TOomTestName TestName();

   182 private:

   183 	RBackedUpWindow iFailWin;

   184 	};

   185 

   186 class COomPriorityKey : public COomSetup

   187 	{

   188 public:

   189 	COomPriorityKey(CTOom *aTest);

   190 	~COomPriorityKey();

   191 	void ConstructL();

   192 	void ClearUpL();

   193 	TInt Fail();

   194 	TOomTestName TestName();

   195 	};

   196 

   197 class COomCaptureKeyBase : public COomSetup

   198 	{

   199 public:

   200 	COomCaptureKeyBase(CTOom *aTest);

   201 	~COomCaptureKeyBase();

   202 	void ConstructL();

   203 protected:

   204 	TInt32 iCapKey[KNumCapKeyRequest];

   205 	TInt iIndex;	

   206 	};

   207 

   208 class COomCaptureKey : public COomCaptureKeyBase

   209 	{

   210 public:

   211 	COomCaptureKey(CTOom *aTest);

   212 	~COomCaptureKey();

   213 	void ClearUpL();

   214 	TInt Fail();

   215 	TOomTestName TestName();

   216 	};

   217 

   218 class COomCaptureKeyUpDown : public COomCaptureKeyBase

   219 	{

   220 public:

   221 	COomCaptureKeyUpDown(CTOom *aTest);

   222 	~COomCaptureKeyUpDown();

   223 	void ClearUpL();

   224 	TInt Fail();

   225 	TOomTestName TestName();

   226 	};

   227 

   228 class COomLongKeyCapture : public COomCaptureKeyBase

   229 	{

   230 public:

   231 	COomLongKeyCapture(CTOom *aTest);

   232 	~COomLongKeyCapture();

   233 	void ClearUpL();

   234 	TInt Fail();

   235 	TOomTestName TestName();

   236 	};

   237 

   238 class COomHotKey : public COomSetup

   239 	{

   240 public:

   241 	COomHotKey(CTOom *aTest);

   242 	~COomHotKey();

   243 	void ConstructL();

   244 	void ClearUpL();

   245 	TInt Fail();

   246 	TOomTestName TestName();

   247 	};

   248 

   249 class COomGroupName : public COomSetup

   250 	{

   251 public:

   252 	COomGroupName(CTOom *aTest);

   253 	~COomGroupName();

   254 	void ConstructL();

   255 	void ClearUpL();

   256 	TInt Fail();

   257 	TOomTestName TestName();

   258 	};

   259 

   260 class COomMessageSend: public COomSetup

   261 	{

   262 public:

   263 	COomMessageSend(CTOom *aTest);

   264 	~COomMessageSend();

   265 	void ConstructL();

   266 	void PreFail();

   267 	void ClearUpL();

   268 	TInt Fail();

   269 	TOomTestName TestName();

   270 private:

   271 	RWindowGroup iWinGroup2;

   272 	};

   273 

   274 class COomMessageFetch: public COomSetup

   275 	{

   276 public:

   277 	COomMessageFetch(CTOom *aTest);

   278 	~COomMessageFetch();

   279 	void PreFail();

   280 	void ConstructL();

   281 	void ClearUpL();

   282 	TInt Fail();

   283 	TOomTestName TestName();

   284 private:

   285 	RWindowGroup iWinGroup2;

   286 	};

   287 

   288 class COomCopyScreen : public COomSetup

   289 	{

   290 public:

   291 	COomCopyScreen(CTOom *aTest);

   292 	~COomCopyScreen();

   293 	void ConstructL();

   294 	void ClearUpL();

   295 	TInt Fail();

   296 	TOomTestName TestName();

   297 private:

   298 	CWsScreenDevice *iScrDev;

   299 	CFbsBitmap *iBitmap;

   300 	};

   301 

   302 class COomRequestEvents : public COomSetup

   303 	{

   304 public:

   305 	COomRequestEvents(CTOom *aTest);

   306 	~COomRequestEvents();

   307 	void ConstructL();

   308 	void ClearUpL();

   309 	TInt Fail();

   310 	TOomTestName TestName();

   311 	};

   312 

   313 class COomSpriteBase : public COomSetup

   314 	{

   315 public:

   316 	COomSpriteBase(CTOom *aTest);

   317 	~COomSpriteBase();

   318 	void ConstructL();

   319 protected:

   320 	RWindow iWin;

   321 	CFbsBitmap *iBitmap;

   322 	CFbsBitmap *iMask;

   323 	CFbsBitmap *iBitmap2;

   324 	CFbsBitmap *iMask2;

   325 	};

   326 

   327 class COomSprite : public COomSpriteBase

   328 	{

   329 public:

   330 	COomSprite(CTOom *aTest);

   331 	void ClearUpL();

   332 	TInt Fail();

   333 	TOomTestName TestName();

   334 private:

   335 	RWsSprite iSprite;

   336 	};

   337 

   338 class COomPointerCursor : public COomSpriteBase

   339 	{

   340 public:

   341 	COomPointerCursor(CTOom *aTest);

   342 	void ClearUpL();

   343 	TInt Fail();

   344 	TOomTestName TestName();

   345 private:

   346 	RWsPointerCursor iPointerCursor;

   347 	};

   348 

   349 class COomCustomTextCursor : public COomSetup

   350 	{

   351 public:

   352 	COomCustomTextCursor(CTOom *aTest);

   353 	~COomCustomTextCursor();

   354 	void ConstructL();

   355 	void ClearUpL();

   356 	TInt Fail();

   357 	TOomTestName TestName();

   358 private:

   359 	CArrayFixFlat<TSpriteMember>* iMemberArray;

   360 	CFbsBitmap* iBitmap;

   361 	};

   362 

   363 class COomTranspWindow : public COomSetup

   364 	{

   365 public:

   366 	COomTranspWindow(CTOom *aTest);

   367 	~COomTranspWindow();

   368 	void ConstructL();

   369 	void ClearUpL();

   370 	TInt Fail();

   371 	TOomTestName TestName();

   372 	CTransWindow* CreateTransWinL(CTWinBase* aParent,TRgb aColor,TRect aPos, TDisplayMode* aDisplayMode);

   373 private:

   374 	TInt SetTransparencyTesting();

   375 

   376 	CBlankWindow* iBackgroundWin;

   377 	CTransWindow* iFirst;

   378 	CTransWindow* iSecond;

   379 	

   380 	CFbsBitmap* iFbsBitmap;

   381 	CWsBitmap* iWsBitmap;

   382 	CFbsBitmapDevice* iFbsBitmapDevice; 

   383 	CFbsBitGc* iFbsBitmapGc;

   384 	CFbsBitmapDevice* iWsBitmapDevice; 

   385 	CFbsBitGc* iWsBitmapGc;

   386 	TBool iTransparencyEnabled;

   387 	};

   388 

   389 

   390 class CWindowWithOneLine : public CTWin

   391 	{

   392 public:

   393 	static CWindowWithOneLine* NewL(CTWinBase& aParent, const TRect& aExtent);

   394 	void Draw();

   395 	};

   396 	

   397 class COomObscuredWindow : public COomSetup

   398 	{

   399 public:

   400 	COomObscuredWindow(CTOom *aTest);

   401 	void ClearUpL();

   402 	TInt Fail();

   403 	TOomTestName TestName();

   404 private:

   405 	void DoFailL();

   406 	};

   407 

   408 class CTOom : public CTWsGraphicsBase

   409 	{

   410 public:

   411 	CTOom(CTestStep* aStep);

   412 	~CTOom();

   413 	const TDesC& TestName() const;

   414 	void ConstructL();

   415 	void DoOomTestL(COomFailBase *aOomTest);

   416 	inline TInt ScreenNumber(){ return iTest->ScreenNumber();}

   417 

   418 protected:

   419 	virtual void RunTestCaseL(TInt aCurTestCase);

   420 

   421 private:

   422 	TInt iOldCount;

   423 	RBlankWindow iShieldWin;

   424 	TSize iWinSize;

   425 	TInt iState;

   426 	};

   427 

   428 class CTOomStep : public CTGraphicsStep

   429 	{

   430 public:

   431 	CTOomStep();

   432 protected:	

   433 	//from CTGraphicsStep

   434 	virtual CTGraphicsBase* CreateTestL();

   435 	};

   436 

   437 _LIT(KTOomStep,"TOom");

   438 

   439 

   440 #endif