MercurialSymaptic / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
os/graphics/windowing/windowserver/test/t_integ/src/t_pseudoappwindow.cpp
author sl
Tue, 10 Jun 2014 14:32:02 +0200
changeset 1 260cb5ec6c19
permissions -rw-r--r--
Update contrib. 
     1 // Copyright (c) 2007-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

    20 */

    21 

    22 #include "t_pseudoappwindow.h"

    23 #include "t_winutils.h"

    24 

    25 EXPORT_C CTestWindow::CTestWindow(TInt aScreenNo, TDisplayMode aMode)

    26 	{

    27 	RDebug::Print(_L("Creating CTestWindow class\n"));

    28     TRAPD(err, ConstructL(aScreenNo, aMode));

    29 	if(err)

    30 		{

    31 		RDebug::Print(_L("CTestWindow::ConstructL() leaves with error %d\n"), err);

    32 		User::Exit(0);

    33 		}

    34 	}

    35 

    36 CTestWindow::~CTestWindow()

    37 	{

    38 	if(iScreen)

    39 		{

    40 		delete iScreen;

    41 		}

    42 

    43 	if(iWindowGc)

    44 		{

    45 		delete iWindowGc;

    46 		}

    47 

    48 	iSession.Close();

    49 	}

    50 

    51 EXPORT_C void CTestWindow::ConstructL(TInt aScreenNo, TDisplayMode aMode)

    52 	{

    53 	RDebug::Print(_L("Constructing CTestWindow class\n"));

    54 	User::LeaveIfError(iSession.Connect());

    55 

    56 	RDebug::Print(_L("Create CWsScreenDevice\n"));

    57 	iScreen = new(ELeave) CWsScreenDevice(iSession);

    58 	User::LeaveIfError(iScreen->Construct(aScreenNo));

    59 

    60 	RDebug::Print(_L("Create RWindowGroup\n"));

    61 	iGroup = RWindowGroup(iSession);

    62 

    63 	User::LeaveIfError(iGroup.Construct(8970 + aScreenNo, ETrue));

    64 

    65 	RDebug::Print(_L("Create Window\n"));

    66 	iWindow = RWindow(iSession);

    67 	User::LeaveIfError(iWindow.Construct((RWindowTreeNode)iGroup,(TUint32)this));

    68 

    69 	RDebug::Print(_L("Create CWindowGc\n"));

    70 	iWindowGc = new (ELeave) CWindowGc(iScreen);

    71 	User::LeaveIfError(iWindowGc->Construct());

    72 

    73 	TInt ret = iWindow.SetRequiredDisplayMode(aMode);

    74 	RDebug::Print(_L("Window display mode set to %d\n"), ret);

    75 

    76 	iMode = aMode;

    77 	iWindow.Activate();

    78 	}

    79 

    80 EXPORT_C void CTestWindow::Rotate(TSize /*aScreenSize*/)

    81 	{

    82 	}

    83 

    84 EXPORT_C void CTestWindow::DrawL()

    85 	{

    86 	}

    87 

    88 void CTestWindow::SetPosition()

    89 	{

    90 	iWindow.SetPosition((*iLoadsaParameters)[iFrameCounter].iWindowPos);

    91 	iSession.Flush();

    92 	}

    93 

    94 void CTestWindow::SetSize()

    95 	{

    96 	iWindow.SetSize((*iLoadsaParameters)[iFrameCounter].iWindowSize);

    97 	iSession.Flush();

    98 	}

    99 

   100 void CTestWindow::SetExtent()

   101 	{

   102 	iWindow.SetExtent((*iLoadsaParameters)[iFrameCounter].iWindowPos, (*iLoadsaParameters)[iFrameCounter].iWindowSize);

   103 	iSession.Flush();

   104 	}

   105 

   106 EXPORT_C CTestEmptyWindow* CTestEmptyWindow::NewL(TInt aScreenNo, TDisplayMode aMode, const TSize& aScreenSize)

   107     {

   108     CTestEmptyWindow* self = new (ELeave) CTestEmptyWindow(aScreenNo, aMode);

   109     CleanupStack::PushL(self);

   110     self->ConstructL(aScreenSize);

   111     CleanupStack::Pop(); // self;

   112     return self;

   113     }

   114 

   115 void CTestEmptyWindow::ConstructL(const TSize& aScreenSize)

   116 	{

   117 	RDebug::Print(_L("Construct CTestEmptyWindow class\n"));

   118 	iWindowDrawn = EFalse;

   119 	iWindow.SetExtent(TPoint(0,0), aScreenSize);

   120 	}

   121 

   122 EXPORT_C CTestEmptyWindow::CTestEmptyWindow(TInt aScreenNo, TDisplayMode aMode) :

   123                                    CTestWindow(aScreenNo, aMode)

   124 	{

   125 	}

   126 

   127 CTestEmptyWindow::~CTestEmptyWindow()

   128 	{

   129 	}

   130 

   131 EXPORT_C void CTestEmptyWindow::Rotate(TSize /*aScreenSize*/)

   132 	{

   133 	}

   134 

   135 EXPORT_C void CTestEmptyWindow::DrawL()

   136 	{

   137 	iWindowDrawn = ETrue;

   138 	iWindowGc->Activate(iWindow);

   139 	iWindow.Invalidate();

   140 	iWindow.BeginRedraw();

   141 	iWindow.EndRedraw();

   142 	iWindowGc->Deactivate();

   143 

   144 	iSession.Flush();

   145 	}

   146 

   147 EXPORT_C CTestEcomWindow* CTestEcomWindow::NewL(TInt aScreenNo, TDisplayMode aMode, const TPtrC& aMultiBitmapEcomFile,

   148                                                 TInt aMultiBitmapEcomFileSize, TGceTestResults* aGceTestResults,

   149                                                 CArrayFixFlat<TDrawParameters>* aLoadsaParameters)

   150     {

   151     CTestEcomWindow* self = new (ELeave) CTestEcomWindow(aScreenNo, aMode);

   152     CleanupStack::PushL(self);

   153     self->ConstructL(aMultiBitmapEcomFile, aMultiBitmapEcomFileSize, aGceTestResults, aLoadsaParameters);

   154     CleanupStack::Pop(); // self;

   155     return self;

   156     }

   157 

   158 void CTestEcomWindow::ConstructL(const TPtrC& aMultiBitmapEcomFile, TInt aMultiBitmapEcomFileSize, TGceTestResults* aGceTestResults,

   159                                  CArrayFixFlat<TDrawParameters>* aLoadsaParameters)

   160 	{

   161 	RDebug::Print(_L("Construct CTestEcomWindow class\n"));

   162 

   163 	iMultiBitmapEcomFile.Set(aMultiBitmapEcomFile);

   164 	iMultiBitmapEcomFileSize = aMultiBitmapEcomFileSize;

   165 	iLoadsaParameters = aLoadsaParameters;

   166 

   167 	//Pass notification value back to ui

   168 	iGceTestResults = aGceTestResults;

   169 	}

   170 

   171 EXPORT_C CTestEcomWindow::CTestEcomWindow(TInt aScreenNo, TDisplayMode aMode) :

   172                                    CTestWindow(aScreenNo, aMode)

   173 	{

   174 	}

   175 

   176 CTestEcomWindow::~CTestEcomWindow()

   177 	{

   178 	}

   179 

   180 EXPORT_C void CTestEcomWindow::Rotate(TSize /*aScreenSize*/)

   181 	{

   182 	}

   183 

   184 EXPORT_C void CTestEcomWindow::DrawL()

   185 	{

   186 	if(iBitmapCounter == iMultiBitmapEcomFileSize)

   187 		{

   188 		iBitmapCounter = 0;

   189 		}

   190 

   191 	TParamChange redraw = Redraw();

   192 	if(redraw != ENoParamChange)

   193 		{

   194 		if(redraw == EPositionChange)

   195 			{

   196 			SetPosition();

   197 			}

   198 

   199 		if(redraw == ESizeChange)

   200 			{

   201 			SetSize();

   202 			}

   203 

   204 		if(redraw == EExtentChange)

   205 			{

   206 			SetExtent();

   207 			}

   208 		}

   209 

   210 	CFbsBitmap bitmap;

   211 	iWindowGc->Activate(iWindow);

   212 	iWindow.Invalidate();

   213 	iWindow.BeginRedraw();

   214 

   215 	bitmap.Load(iMultiBitmapEcomFile, iBitmapCounter);

   216 

   217 	iWindowGc->DrawBitmap(TRect(TPoint(0,0), (*iLoadsaParameters)[0].iWindowSize), &bitmap);

   218 

   219 	iWindow.EndRedraw();

   220 	iWindowGc->Deactivate();

   221 	iSession.Flush();

   222 

   223 	iFrameCounter++;

   224 	iBitmapCounter++;

   225 	}

   226 

   227 TParamChange CTestEcomWindow::Redraw()

   228 	{

   229 	if(iFrameCounter == 0)

   230 		{

   231 		iWindow.SetExtent((*iLoadsaParameters)[0].iWindowPos, (*iLoadsaParameters)[0].iWindowSize);

   232 		iWindow.SetVisible(ETrue);

   233 

   234 		return EFirstFrame;

   235 		}

   236 	else

   237 		{

   238 		TDrawParameters current = (*iLoadsaParameters)[iFrameCounter];

   239 		TDrawParameters last =  (*iLoadsaParameters)[iFrameCounter - 1];

   240 

   241 		if(current.iWindowSize != last.iWindowSize)

   242 			{

   243 			if(current.iWindowPos != last.iWindowPos)

   244 				{

   245 				return EExtentChange;

   246 				}

   247 			return ESizeChange;

   248 			}

   249 		else if(current.iWindowPos != last.iWindowPos)

   250 			{

   251 			return EPositionChange;

   252 			}

   253 		}

   254 	return ENoParamChange;

   255 	}

   256 

   257 EXPORT_C CTestUiWindow* CTestUiWindow::NewL(TInt aScreenNo, TDisplayMode aMode, const TPtrC& aMultiBitmapUiFile, TInt aMultiBitmapUiFileSize,

   258                                    CArrayFixFlat<TRect>* aRectArray, TInt aFrameDuration, TInt aMultiBitmapUiFileTransparency,

   259                                    TGceTestResults* aGceTestResults,

   260                                    CArrayFixFlat<TDrawParameters>* aLoadsaParameters)

   261     {

   262     CTestUiWindow* self = new (ELeave) CTestUiWindow(aScreenNo ,aMode);

   263     CleanupStack::PushL(self);

   264     self->ConstructL(aMultiBitmapUiFile, aMultiBitmapUiFileSize, aRectArray, aFrameDuration,

   265                      aMultiBitmapUiFileTransparency, aGceTestResults,

   266                      aLoadsaParameters);

   267 

   268     CleanupStack::Pop(); // self;

   269     return self;

   270     }

   271 

   272 void CTestUiWindow::ConstructL(const TPtrC& aMultiBitmapUiFile, TInt aMultiBitmapUiFileSize, CArrayFixFlat<TRect>* aRectArray,

   273                                TInt aFrameDuration, TInt aMultiBitmapUiFileTransparency, TGceTestResults* aGceTestResults,

   274                                CArrayFixFlat<TDrawParameters>* aLoadsaParameters)

   275 	{

   276 	RDebug::Print(_L("Construct CTestUiWindow class\n"));

   277 

   278 	iSimUiDrawn = EFalse;

   279 	iMultiBitmapUiFile.Set(aMultiBitmapUiFile);

   280 	iMultiBitmapUiFileSize = aMultiBitmapUiFileSize;

   281 	iMultiBitmapUiFileTransparency = aMultiBitmapUiFileTransparency;

   282 	iRectArray = aRectArray;

   283 	iFrameDuration = aFrameDuration;

   284 	iLoadsaParameters = aLoadsaParameters;

   285 

   286 	//Pass notification value back to ui

   287 	iGceTestResults = aGceTestResults;

   288 	}

   289 

   290 EXPORT_C CTestUiWindow::CTestUiWindow(TInt aScreenNo, TDisplayMode aMode) :

   291                              CTestWindow(aScreenNo, aMode)

   292 	{

   293 	}

   294 

   295 CTestUiWindow::~CTestUiWindow()

   296 	{

   297 	}

   298 

   299 void CTestUiWindow::SetBitmapTransparency(CFbsBitmap* aBitmap, TUint8 aAlphaValue, TInt aAlphaByteLocation)

   300 	{

   301 	aBitmap->LockHeap();

   302 	TUint32* bitmapBufferPtr = aBitmap->DataAddress();

   303 	if(bitmapBufferPtr == 0)

   304 		{

   305 		RDebug::Print(_L("Error getting bitmap address, aborting\n"));

   306 		//Unlock heap before exitting

   307 		aBitmap->UnlockHeap();

   308 		User::Exit(0);

   309 		}

   310 

   311 	TSize aBitmapSize = aBitmap->SizeInPixels();

   312 	TUint32 noOfPixels = aBitmapSize.iHeight * aBitmapSize.iWidth;

   313 

   314 	while(noOfPixels)

   315 		{

   316 		*bitmapBufferPtr = ( (*bitmapBufferPtr & ~(0xFF << (aAlphaByteLocation * 8))) | (aAlphaValue << (aAlphaByteLocation * 8)) );

   317 		bitmapBufferPtr++;

   318 		noOfPixels--;

   319 		}

   320 	aBitmap->UnlockHeap();

   321 	}

   322 

   323 EXPORT_C void CTestUiWindow::Rotate(const TSize& aScreenSize)

   324 	{

   325 	//Adjust the sizes of the UI bitmap components to reflect the aspect ratio  change

   326 	for(TInt j=0; j<iMultiBitmapUiFileSize; j++)

   327 		{

   328 		(*iRectArray)[j].iTl.iX = ((*iRectArray)[j].iTl.iX*aScreenSize.iWidth)/aScreenSize.iHeight;

   329 		(*iRectArray)[j].iTl.iY = ((*iRectArray)[j].iTl.iY*aScreenSize.iHeight)/aScreenSize.iWidth;

   330 		(*iRectArray)[j].iBr.iX = ((*iRectArray)[j].iBr.iX*aScreenSize.iWidth)/aScreenSize.iHeight;

   331 		(*iRectArray)[j].iBr.iY = ((*iRectArray)[j].iBr.iY*aScreenSize.iHeight)/aScreenSize.iWidth;

   332 		}

   333 

   334 	iWindow.SetSize(aScreenSize);

   335 	}

   336 

   337 EXPORT_C void CTestUiWindow::DrawL()

   338 	{

   339 	TParamChange redraw = Redraw();

   340 

   341 		if(redraw == EPositionChange)

   342 			{

   343 			SetPosition();

   344 			}

   345 

   346 		if(redraw == ESizeChange)

   347 			{

   348 			SetSize();

   349 			}

   350 

   351 		if(redraw == EExtentChange)

   352 			{

   353 			SetExtent();

   354 			}

   355 

   356 		CFbsBitmap bitmap;

   357 		iWindowGc->Activate(iWindow);

   358 		iWindow.Invalidate();

   359 		iWindow.BeginRedraw();

   360 

   361 		CTestBitmap* bitmapSource = NULL;

   362 		bitmapSource = CTestBitmap::NewL(TSize(0,0), iMode);

   363 

   364 		for(TInt j=0; j<iMultiBitmapUiFileSize; j++)

   365 			{

   366 			User::LeaveIfError(bitmapSource->Bitmap().Load(iMultiBitmapUiFile, j));

   367 

   368 			TInt lastSize = (*iLoadsaParameters)[iFrameCounter].iBitmapScale;

   369 			TRect destRect;

   370 			TPoint drawPos;

   371 

   372 

   373 			destRect.SetRect(TPoint(  ((*iRectArray)[j].iTl.iX*lastSize)/100, ((*iRectArray)[j].iTl.iY*lastSize)/100),

   374 						     TPoint(  ((*iRectArray)[j].iBr.iX*lastSize)/100, ((*iRectArray)[j].iBr.iY*lastSize)/100 ));

   375 

   376 			drawPos = TPoint(((*iRectArray)[j].iTl.iX*lastSize)/100, ((*iRectArray)[j].iTl.iY*lastSize)/100);

   377 

   378 			if(iMultiBitmapUiFileTransparency)

   379 				{

   380 				CTestBitmap* bitmapSourceAlpha = CTestBitmap::NewL(TSize(0,0), EGray256);

   381 				User::LeaveIfError(bitmapSourceAlpha->Bitmap().Load(iMultiBitmapUiFile, j+iMultiBitmapUiFileSize));

   382 

   383 				//Adjust the transparency controlled by the alpha bitmap

   384 				SetBitmapAlpha(&(bitmapSourceAlpha->Bitmap()));

   385 

   386 				CTestBitmap* bitmapDest = CTestBitmap::NewL(destRect.Size(), iMode);

   387 				bitmapDest->Bitmap().SetSizeInTwips(bitmapSource->Bitmap().SizeInTwips());

   388 				bitmapDest->Gc().DrawBitmap(TRect(TPoint(0,0), destRect.Size()), &(bitmapSource->Bitmap()));

   389 

   390 				CTestBitmap* bitmapDestAlpha = CTestBitmap::NewL(destRect.Size(), EGray256);

   391 				bitmapDestAlpha->Bitmap().SetSizeInTwips(bitmapSourceAlpha->Bitmap().SizeInTwips());

   392 				bitmapDestAlpha->Gc().DrawBitmap(TRect(TPoint(0,0), destRect.Size()), &(bitmapSourceAlpha->Bitmap()));

   393 

   394 				iWindowGc->AlphaBlendBitmaps(drawPos, &(bitmapDest->Bitmap()), TRect(TPoint(0,0), destRect.Size()),

   395 				                             &(bitmapDestAlpha->Bitmap()), TPoint(0,0));

   396 

   397 				delete bitmapSourceAlpha;

   398 				delete bitmapDest;

   399 				delete bitmapDestAlpha;

   400 				}

   401 			else

   402 				{

   403 				iWindowGc->DrawBitmap(destRect, &(bitmapSource->Bitmap()));

   404 				}

   405 			}

   406 

   407 		delete bitmapSource;

   408 

   409 		iWindow.EndRedraw();

   410 		iWindowGc->Deactivate();

   411 		iSession.Flush();

   412 

   413 	iFrameCounter++;

   414 	}

   415 

   416 void CTestUiWindow::SetBitmapAlpha(CFbsBitmap* aBitmap)

   417 	{

   418 	aBitmap->LockHeap();

   419 	TUint32* bitmapBufferPtr = aBitmap->DataAddress();

   420 

   421 	TSize aBitmapSize = aBitmap->SizeInPixels();

   422 	TUint32 noOfPixels = (aBitmapSize.iHeight * aBitmapSize.iWidth)/4;

   423 	TUint8 alpha = (*iLoadsaParameters)[iFrameCounter].iBitmapAlpha;

   424 

   425 	TUint32 alpha32 = (alpha << 24) | (alpha << 16) | (alpha << 8) | alpha;

   426 	while(noOfPixels)

   427 		{

   428 		//Only modify grey pixels leaving the white ones untouched

   429 		if(*bitmapBufferPtr != 0x0)

   430 			{

   431 			*bitmapBufferPtr = alpha32;

   432 			}

   433 

   434 		bitmapBufferPtr++;

   435 		noOfPixels--;

   436 		}

   437 	aBitmap->UnlockHeap();

   438 	}

   439 

   440 TParamChange CTestUiWindow::Redraw()

   441 	{

   442 	if(iFrameCounter == 0)

   443 		{

   444 		iWindow.SetExtent((*iLoadsaParameters)[0].iWindowPos, (*iLoadsaParameters)[0].iWindowSize);

   445 		iWindow.SetVisible(ETrue);

   446 

   447 		return EFirstFrame;

   448 		}

   449 	else

   450 		{

   451 		TDrawParameters current = (*iLoadsaParameters)[iFrameCounter];

   452 		TDrawParameters last =  (*iLoadsaParameters)[iFrameCounter - 1];

   453 

   454 		if(current.iWindowSize != last.iWindowSize)

   455 			{

   456 			if(current.iWindowPos != last.iWindowPos)

   457 				{

   458 				return EExtentChange;

   459 				}

   460 			return ESizeChange;

   461 			}

   462 		else if(current.iWindowPos != last.iWindowPos)

   463 			{

   464 			return EPositionChange;

   465 			}

   466 		else if(current.iBitmapScale != last.iBitmapScale)

   467 			{

   468 			return EBitmapScale;

   469 			}

   470 		else if(current.iBitmapAlpha != last.iBitmapAlpha)

   471 			{

   472 			return EOpacityChange;

   473 			}

   474 		}

   475 	return ENoParamChange;

   476 	}

   477 

   478 TDrawParameters::TDrawParameters() : iRedraw(EFalse), iBitmapScale(0), iBitmapAlpha(0), iWindowSize(0,0), iWindowPos(0,0)

   479 	{

   480 	}

   481 

   482 TDrawParameters::~TDrawParameters()

   483 	{

   484 	}

   485 

   486 TBool TDrawParameters::operator==(const TDrawParameters& x) const

   487 	{

   488 	if( (x.iBitmapScale != iBitmapScale) ||

   489 		(x.iBitmapAlpha != iBitmapAlpha) ||

   490 		(x.iWindowSize != iWindowSize)   ||

   491 		(x.iWindowPos != iWindowPos) )

   492 		{

   493 		return ETrue;

   494 		}

   495 

   496 	return EFalse;

   497 	}
Symaptic