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 //

    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 

    37 class COomFailBase : public CBase

    38 	{

    39 public:

    40 	COomFailBase(CTOom *aTest);

    41 	virtual void ConstructL();

    42 	virtual void PreFail();

    43 	virtual void ClearUpL();

    44 	virtual void Flush();

    45 	virtual TInt Fail()=0;

    46 	virtual TOomTestName TestName()=0;

    47 protected:

    48 	RWsSession iWs;

    49 	CWsScreenDevice* iDummyScreen;

    50 	CTOom *iTest;

    51 	};

    52 

    53 

    54 class COomConnect : public COomFailBase

    55 	{

    56 public:

    57 	COomConnect(CTOom *aTest);

    58 	TInt Fail();

    59 	void ClearUpL();

    60 	TOomTestName TestName();

    61 	};

    62 

    63 class COomSetup : public COomFailBase

    64 	{

    65 public:

    66 	COomSetup(CTOom *aTest);

    67 	~COomSetup();

    68 	void ConstructL();

    69 protected:

    70 	RWindowGroup iWinGroup;

    71 	};

    72 

    73 class COomWindowGroup : public COomSetup

    74 	{

    75 public:

    76 	COomWindowGroup(CTOom *aTest);

    77 	void ClearUpL();

    78 	TInt Fail();

    79 	TOomTestName TestName();

    80 private:

    81 	RWindowGroup iFailWinGroup;

    82 	};

    83 

    84 class COomWindow : public COomSetup

    85 	{

    86 public:

    87 	COomWindow(CTOom *aTest);

    88 	void ClearUpL();

    89 	TInt Fail();

    90 	TOomTestName TestName();

    91 private:

    92 	RWindow iFailWin;

    93 	};

    94 

    95 class COomBackedUpWindow : public COomSetup

    96 	{

    97 public:

    98 	COomBackedUpWindow(CTOom *aTest);

    99 	void ClearUpL();

   100 	TInt Fail();

   101 	TOomTestName TestName();

   102 private:

   103 	RBackedUpWindow iFailWin;

   104 	};

   105 

   106 class COomBlankWindow : public COomSetup

   107 	{

   108 public:

   109 	COomBlankWindow(CTOom *aTest);

   110 	void ClearUpL();

   111 	TInt Fail();

   112 	TOomTestName TestName();

   113 private:

   114 	RBlankWindow iFailWin;

   115 	};

   116 

   117 class COomGc : public COomSetup

   118 	{

   119 public:

   120 	COomGc(CTOom *aTest);

   121 	~COomGc();

   122 	void ConstructL();

   123 	void ClearUpL();

   124 	TInt Fail();

   125 	TOomTestName TestName();

   126 private:

   127 	CWsScreenDevice *iScrDev;

   128 	CWindowGc *iFailGc;

   129 	};

   130 

   131 class COomPolygon : public COomSetup

   132 	{

   133 public:

   134 	COomPolygon(CTOom *aTest);

   135 	~COomPolygon();

   136 	void ConstructL();

   137 	void ClearUpL();

   138 	TInt Fail();

   139 	TOomTestName TestName();

   140 private:

   141 	CWsScreenDevice *iScrDev;

   142 	RBackedUpWindow iWin;

   143 	CWindowGc *iGc;

   144 	CArrayFixSeg<TPoint> iPnts;

   145 	};

   146 

   147 class COomScreenDevice : public COomSetup

   148 	{

   149 public:

   150 	COomScreenDevice(CTOom *aTest);

   151 	void ClearUpL();

   152 	TInt Fail();

   153 	TOomTestName TestName();

   154 private:

   155 	CWsScreenDevice *iScrDev;

   156 	};

   157 

   158 class COomBackupResize : public COomSetup

   159 	{

   160 public:

   161 	COomBackupResize(CTOom *aTest);

   162 	~COomBackupResize();

   163 	void ConstructL();

   164 	void ClearUpL();

   165 	TInt Fail();

   166 	TOomTestName TestName();

   167 private:

   168 	RBackedUpWindow iFailWin;

   169 	};

   170 

   171 class COomPointerBuffer : public COomSetup

   172 	{

   173 public:

   174 	COomPointerBuffer(CTOom *aTest);

   175 	~COomPointerBuffer();

   176 	void ConstructL();

   177 	void ClearUpL();

   178 	TInt Fail();

   179 	TOomTestName TestName();

   180 private:

   181 	RBackedUpWindow iFailWin;

   182 	};

   183 

   184 class COomPriorityKey : public COomSetup

   185 	{

   186 public:

   187 	COomPriorityKey(CTOom *aTest);

   188 	~COomPriorityKey();

   189 	void ConstructL();

   190 	void ClearUpL();

   191 	TInt Fail();

   192 	TOomTestName TestName();

   193 	};

   194 

   195 class COomCaptureKey : public COomSetup

   196 	{

   197 public:

   198 	COomCaptureKey(CTOom *aTest);

   199 	~COomCaptureKey();

   200 	void ConstructL();

   201 	void ClearUpL();

   202 	TInt Fail();

   203 	TOomTestName TestName();

   204 private:

   205 	TInt32 iCapKey[20];

   206 	TInt iIndex;

   207 	};

   208 

   209 class COomCaptureKeyUpDown : public COomSetup

   210 	{

   211 public:

   212 	COomCaptureKeyUpDown(CTOom *aTest);

   213 	~COomCaptureKeyUpDown();

   214 	void ConstructL();

   215 	void ClearUpL();

   216 	TInt Fail();

   217 	TOomTestName TestName();

   218 private:

   219 	TInt32 iCapKey[20];

   220 	TInt iIndex;

   221 	};

   222 

   223 class COomHotKey : public COomSetup

   224 	{

   225 public:

   226 	COomHotKey(CTOom *aTest);

   227 	~COomHotKey();

   228 	void ConstructL();

   229 	void ClearUpL();

   230 	TInt Fail();

   231 	TOomTestName TestName();

   232 	};

   233 

   234 class COomGroupName : public COomSetup

   235 	{

   236 public:

   237 	COomGroupName(CTOom *aTest);

   238 	~COomGroupName();

   239 	void ConstructL();

   240 	void ClearUpL();

   241 	TInt Fail();

   242 	TOomTestName TestName();

   243 	};

   244 

   245 class COomMessageSend: public COomSetup

   246 	{

   247 public:

   248 	COomMessageSend(CTOom *aTest);

   249 	~COomMessageSend();

   250 	void ConstructL();

   251 	void PreFail();

   252 	void ClearUpL();

   253 	TInt Fail();

   254 	TOomTestName TestName();

   255 private:

   256 	RWindowGroup iWinGroup2;

   257 	};

   258 

   259 class COomMessageFetch: public COomSetup

   260 	{

   261 public:

   262 	COomMessageFetch(CTOom *aTest);

   263 	~COomMessageFetch();

   264 	void PreFail();

   265 	void ConstructL();

   266 	void ClearUpL();

   267 	TInt Fail();

   268 	TOomTestName TestName();

   269 private:

   270 	RWindowGroup iWinGroup2;

   271 	};

   272 

   273 class COomCopyScreen : public COomSetup

   274 	{

   275 public:

   276 	COomCopyScreen(CTOom *aTest);

   277 	~COomCopyScreen();

   278 	void ConstructL();

   279 	void ClearUpL();

   280 	TInt Fail();

   281 	TOomTestName TestName();

   282 private:

   283 	CWsScreenDevice *iScrDev;

   284 	CFbsBitmap *iBitmap;

   285 	};

   286 

   287 class COomRequestEvents : public COomSetup

   288 	{

   289 public:

   290 	COomRequestEvents(CTOom *aTest);

   291 	~COomRequestEvents();

   292 	void ConstructL();

   293 	void ClearUpL();

   294 	TInt Fail();

   295 	TOomTestName TestName();

   296 	};

   297 

   298 class COomSpriteBase : public COomSetup

   299 	{

   300 public:

   301 	COomSpriteBase(CTOom *aTest);

   302 	~COomSpriteBase();

   303 	void ConstructL();

   304 protected:

   305 	RWindow iWin;

   306 	CFbsBitmap *iBitmap;

   307 	CFbsBitmap *iMask;

   308 	CFbsBitmap *iBitmap2;

   309 	CFbsBitmap *iMask2;

   310 	};

   311 

   312 class COomSprite : public COomSpriteBase

   313 	{

   314 public:

   315 	COomSprite(CTOom *aTest);

   316 	void ClearUpL();

   317 	TInt Fail();

   318 	TOomTestName TestName();

   319 private:

   320 	RWsSprite iSprite;

   321 	};

   322 

   323 class COomPointerCursor : public COomSpriteBase

   324 	{

   325 public:

   326 	COomPointerCursor(CTOom *aTest);

   327 	void ClearUpL();

   328 	TInt Fail();

   329 	TOomTestName TestName();

   330 private:

   331 	RWsPointerCursor iPointerCursor;

   332 	};

   333 

   334 class COomCustomTextCursor : public COomSetup

   335 	{

   336 public:

   337 	COomCustomTextCursor(CTOom *aTest);

   338 	~COomCustomTextCursor();

   339 	void ConstructL();

   340 	void ClearUpL();

   341 	TInt Fail();

   342 	TOomTestName TestName();

   343 private:

   344 	CArrayFixFlat<TSpriteMember>* iMemberArray;

   345 	CFbsBitmap* iBitmap;

   346 	};

   347 

   348 class COomTranspWindow : public COomSetup

   349 	{

   350 public:

   351 	COomTranspWindow(CTOom *aTest);

   352 	~COomTranspWindow();

   353 	void ConstructL();

   354 	void ClearUpL();

   355 	TInt Fail();

   356 	TOomTestName TestName();

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

   358 private:

   359 	TInt SetTransparencyTesting();

   360 

   361 	CBlankWindow* iBackgroundWin;

   362 	CTransWindow* iFirst;

   363 	CTransWindow* iSecond;

   364 	

   365 	CFbsBitmap* iFbsBitmap;

   366 	CWsBitmap* iWsBitmap;

   367 	CFbsBitmapDevice* iFbsBitmapDevice; 

   368 	CFbsBitGc* iFbsBitmapGc;

   369 	CFbsBitmapDevice* iWsBitmapDevice; 

   370 	CFbsBitGc* iWsBitmapGc;

   371 	TBool iTransparencyEnabled;

   372 	};

   373 

   374 

   375 class CWindowWithOneLine : public CTWin

   376 	{

   377 public:

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

   379 	void Draw();

   380 	};

   381 	

   382 class COomObscuredWindow : public COomSetup

   383 	{

   384 public:

   385 	COomObscuredWindow(CTOom *aTest);

   386 	void ClearUpL();

   387 	TInt Fail();

   388 	TOomTestName TestName();

   389 private:

   390 	void DoFailL();

   391 	};

   392 

   393 class CTOom : public CTWsGraphicsBase

   394 	{

   395 public:

   396 	CTOom(CTestStep* aStep);

   397 	~CTOom();

   398 	const TDesC& TestName() const;

   399 	void ConstructL();

   400 	void DoOomTestL(COomFailBase *aOomTest);

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

   402 

   403 protected:

   404 	virtual void RunTestCaseL(TInt aCurTestCase);

   405 

   406 private:

   407 	TInt iOldCount;

   408 	RBlankWindow iShieldWin;

   409 	TSize iWinSize;

   410 	TInt iState;

   411 	};

   412 

   413 class CTOomStep : public CTGraphicsStep

   414 	{

   415 public:

   416 	CTOomStep();

   417 protected:	

   418 	//from CTGraphicsStep

   419 	virtual CTGraphicsBase* CreateTestL();

   420 	};

   421 

   422 _LIT(KTOomStep,"TOom");

   423 

   424 

   425 #endif