1 // Copyright (c) 2006-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 #include <e32std.h>

    17 #include "cliwin.h"

    18 #include "server.h"

    19 #include "windowelementset.h"

    20 #include "regionextend.h"

    21 #include <graphics/wsscene.h>

    22 #include <graphics/wsgraphicdrawer.h>

    23 #include "panics.h"

    24 #include "wstop.h"

    25 

    26 #include "EVENT.H"

    27 

    28 #ifndef KCacheListGranularity

    29 	enum	{KCacheListGranularity = 8};

    30 #endif

    31 #ifndef KCacheExtensionReserve

    32 	enum	{KCacheExtensionReserve = 1};

    33 #endif

    34 	

    35 

    36 

    37 /** Element to gc rotation function

    38 */

    39 LOCAL_C inline CFbsBitGc::TGraphicsOrientation ElementToGcRotation(MWsElement::TElementRotation aElementRotation)

    40 	{

    41 	CFbsBitGc::TGraphicsOrientation gcRotation = CFbsBitGc::EGraphicsOrientationNormal;

    42 

    43 	switch (aElementRotation)

    44 		{

    45 		case MWsElement::EElementAntiClockwise90:

    46 			gcRotation = CFbsBitGc::EGraphicsOrientationRotated90;

    47 			break;

    48 		case MWsElement::EElementAntiClockwise180:

    49 			gcRotation = CFbsBitGc::EGraphicsOrientationRotated180;

    50 			break;

    51 		case MWsElement::EElementAntiClockwise270:

    52 			gcRotation = CFbsBitGc::EGraphicsOrientationRotated270;

    53 			break;

    54 		default:

    55 			break;

    56 		}

    57 	return gcRotation;

    58 	}

    59 

    60 //

    61 // CWindowElement

    62 //

    63 

    64 CWindowElement::CWindowElement(const CWsClientWindow& aWindow) :

    65 	iWindow(aWindow), iCache(KCacheListGranularity), iHighestReusedIndex(-1)

    66 	{}

    67 

    68 

    69 /** Finds all elements within the window that overlap with the region and 

    70 marks them as unassigned.

    71 If any part of these unassigned elements are outside the region, they are also 

    72 marked overlapping and locked config.

    73 

    74 @param aRegion The region that is being redrawn.

    75 @return KErrNone on success or KErrNoMemory if critical calculations could not be made.

    76 

    77 @see CWindowElementSet::UnassignPlacedElements

    78 **/

    79 TInt CWindowElement::UnassignPlacedElements(const TRegion& aRegion,TInt aGcDrawingCount)

    80 	{

    81 	iFlags = 0;	//reset flags

    82 	iStartGcDrawingCount = aGcDrawingCount;	//Detect any drawing between calls

    83 	iBackgroundElement.SetDrawnOverLast(iBackgroundElement.DrawnOver());

    84 	iNonRedrawVisibleRegion.Clear();

    85 	iNonRedrawVisibleRegion.Copy(const_cast<CWsClientWindow&>(iWindow).VisibleRegion());

    86 	iNonRedrawVisibleRegion.SubRegion(aRegion);

    87 	if (iNonRedrawVisibleRegion.CheckError())

    88 		{	//memory error. Still needs to cope if whole window is being redrawn

    89 		iNonRedrawVisibleRegion.Clear();

    90 		TInt fullWindowRedraw = TRegionExtend::Cast(aRegion).TestDifference(const_cast<CWsClientWindow&>(iWindow).VisibleRegion());

    91 		if (fullWindowRedraw != 0)

    92 			{	//not a full window redraw, return immediately

    93 			return KErrNoMemory;

    94 			}

    95 		}	

    96 	TInt placedElements = iPlacedElements.Count();

    97 	TInt unassignedCount = 0;

    98 	TInt ii;

    99 	TBool cacheError = EFalse;

   100 

   101 	STACK_REGION tempSurfaceBaseArea;

   102 	if (iCache.Reserve(placedElements + KCacheExtensionReserve) < KErrNone)	//quite often there may need to be room for more

   103 		{	//failed to reserve space

   104 		cacheError = ETrue;

   105 		}

   106 	TRect tempExtent;

   107 	TRect tempIntersect;

   108 	

   109 	for (ii=0; ii<placedElements; ii++)

   110 		{

   111 		if (!cacheError)

   112 			{	//cache is ok up to this point but does not contain cache for this element yet

   113 			RRegion newRegion;

   114 			if (iCache.Append(newRegion) < KErrNone)

   115 				{

   116 				cacheError = ETrue;

   117 				}

   118 			newRegion.Close();

   119 			}

   120 

   121 		iPlacedElements[ii].iElement->GetDestinationRectangle(tempExtent);

   122 		TInt regionReturn = TRegionExtend::Cast(aRegion).TestDifference(tempExtent);

   123 		iPlacedElements[ii].SetDrawnOverLast(iPlacedElements[ii].DrawnOver());	//allows detection of change of state

   124 		if (!(regionReturn&TRegionExtend::ENoIntersect))

   125 			{	//redraw region intersects with element

   126 			iPlacedElements[ii].SetUnassigned();

   127 			iPlacedElements[ii].SetDrawnOver(EFalse);

   128 			unassignedCount++;

   129 			

   130 			if (!(regionReturn&TRegionExtend::EAdd))

   131 				{	//surface is entirely within the redraw region

   132 				iPlacedElements[ii].SetOverlapping(EFalse);

   133 				iPlacedElements[ii].SetLockedConfig(EFalse);

   134 				if(!cacheError)

   135 					{

   136 					TRect destinationRect;

   137 					tempSurfaceBaseArea.Clear();

   138                     iPlacedElements[ii].iElement->GetDestinationRectangle(destinationRect);

   139 					tempSurfaceBaseArea.AddRect(destinationRect);

   140 					if (!tempSurfaceBaseArea.CheckError())

   141 						{

   142 						tempSurfaceBaseArea.Offset(tempExtent.iTl);	//cache needs to be in absolute coords

   143 						iCache[ii].Copy(tempSurfaceBaseArea);

   144 						}

   145 					if (tempSurfaceBaseArea.CheckError() || iCache[ii].CheckError())

   146 						{	//cache is no good from this point onwards

   147 						iCache[ii].Close();

   148 						iCache.Remove(ii);

   149 						cacheError = ETrue;

   150 						}

   151 					}

   152 				}

   153 			else

   154 				{

   155                 TRect destinationRect;

   156                 tempSurfaceBaseArea.Clear();

   157                 iPlacedElements[ii].iElement->GetDestinationRectangle(destinationRect);

   158                 tempSurfaceBaseArea.AddRect(destinationRect);

   159 				if (tempSurfaceBaseArea.CheckError())

   160 					{	//critical failure, clear cache and return error

   161 					for (ii=iCache.Count(); ii>0; ii--)

   162 						{

   163 						iCache[ii-1].Close();

   164 						iCache.Remove(ii-1);

   165 						}

   166 					iCache.Reset();

   167 					iNonRedrawVisibleRegion.Close();

   168 					tempSurfaceBaseArea.Close();

   169 					return KErrNoMemory;

   170 					}

   171 				else

   172 					{

   173 					tempSurfaceBaseArea.Offset(tempExtent.iTl);	//change to absolute coordinates

   174 					regionReturn = TRegionExtend::Cast(iNonRedrawVisibleRegion ).TestDifference(tempSurfaceBaseArea);

   175 					if (regionReturn&TRegionExtend::ENoIntersect)

   176 						{	//element base area entirely inside redraw region

   177 						iPlacedElements[ii].SetOverlapping(EFalse);

   178 						iPlacedElements[ii].SetLockedConfig(EFalse);

   179 						}

   180 					else

   181 						{	//element base area is at least partly within non redraw visible region

   182 						iPlacedElements[ii].SetOverlapping(ETrue);

   183 						iPlacedElements[ii].SetLockedConfig(ETrue);

   184 						}

   185 					if(!cacheError)

   186 						{

   187 						iCache[ii].Copy(tempSurfaceBaseArea);

   188 						if (iCache[ii].CheckError())

   189 							{	//cache is no good from this point onwards

   190 							iCache[ii].Close();

   191 							iCache.Remove(ii);

   192 							cacheError = ETrue;

   193 							}

   194 						}

   195 					}

   196 				}

   197 			}

   198 		else

   199 			{	//element does not intersect with redraw region

   200 			iPlacedElements[ii].SetUnassigned(EFalse);

   201 			}

   202 		}

   203 	tempSurfaceBaseArea.Close();

   204 	

   205 	if (iRemovedSurfaces.Reserve(unassignedCount) == KErrNone)

   206 		{

   207 		iRemovedSurfacesValid = ETrue;

   208 		}

   209 	else

   210 		{

   211 		iRemovedSurfacesValid = EFalse;

   212 		}

   213 	return KErrNone;

   214 	}

   215 

   216 /** Marks all elements that have been assigned since the unassign as drawn over.

   217 

   218 @see CWindowElementSet::FlagAssignedElementsDrawnOver

   219 **/

   220 void CWindowElement::FlagAssignedElementsDrawnOver(TInt aGcDrawingCount)

   221 	{

   222 	iStartGcDrawingCount = aGcDrawingCount;

   223 	if (iBackgroundElement.iElement)

   224 		{

   225 		iBackgroundElement.SetDrawnOver();

   226 		}

   227 	TInt placedElementCount = iPlacedElements.Count();

   228 	for (TInt ii = 0; ii < placedElementCount; ii++)

   229 		{

   230 		if(!iPlacedElements[ii].Unassigned() && iPlacedElements[ii].LockedConfig())

   231 			{

   232 			iPlacedElements[ii].SetDrawnOver();

   233 			}

   234 		else if(iPlacedElements[ii].Unassigned() && iPlacedElements[ii].LockedConfig() &&

   235 				!iPlacedElements[ii].ChangedClip() && iPlacedElements[ii].Overlapping())

   236 			{

   237 			iPlacedElements[ii].SetDrawnOver();

   238 			}

   239 		}

   240 	}

   241 

   242 /** Checks whether a elements configuration is the same as that of the surface configuration, taking

   243 into account the stateflags (TPlacedAttributes) passed in.

   244 It must match surfaceId and extent.

   245 If it is a locked config it will need to match viewport and orientation as well.

   246 

   247 @param aElement Element to compare against.

   248 @param aSurfaceConfiguration Configuration to compare.

   249 @param aStateFlags The TPlacedAttributes flags for the element.

   250 @return ETrue if a match, otherwise EFalse.

   251 */

   252 TBool CWindowElement::IsElementAMatch(MWsElement& aElement, const TSurfaceConfiguration& aSurfaceConfiguration,

   253 		TInt aStateFlags)

   254 	{

   255 	TBool match = EFalse;

   256 	

   257 	TRect tempElementExtent;

   258 	TRect tempCRPExtent;

   259 	aElement.GetDestinationRectangle(tempElementExtent);

   260 	aSurfaceConfiguration.GetExtent(tempCRPExtent);

   261 	if (tempElementExtent == tempCRPExtent)

   262 		{

   263 		TSurfaceId tempElementSurfaceId;

   264 		TSurfaceId tempCRPSurfaceId;

   265 		aSurfaceConfiguration.GetSurfaceId(tempElementSurfaceId);

   266 		tempCRPSurfaceId = aElement.ConnectedSurface();

   267 		if (tempElementSurfaceId == tempCRPSurfaceId)

   268 			{

   269 			match = ETrue;

   270 			if (aStateFlags&TPlacedAttributes::ELockedConfig)

   271 				{

   272 				match = EFalse;

   273 				TBool orientationOK = EFalse;

   274 				TRect tempCRPViewport;

   275 				aSurfaceConfiguration.GetViewport(tempCRPViewport);

   276 				//if explicit viewport flagged

   277 				TRect tempElementViewport;

   278 				aElement.GetSourceRectangle(tempElementViewport);

   279 				if (tempElementViewport == tempCRPViewport)

   280 					{

   281 					CFbsBitGc::TGraphicsOrientation tempElementOrientation;

   282 					MWsElement::TElementRotation tempCRPRotation;

   283 					CFbsBitGc::TGraphicsOrientation tempCRPOrientation;

   284 					tempElementOrientation = aSurfaceConfiguration.Orientation();

   285 					tempCRPRotation = aElement.SourceRotation();

   286 					tempCRPOrientation = ElementToGcRotation(tempCRPRotation);	//convert to common type

   287 					if (tempElementOrientation == tempCRPOrientation)

   288 						{

   289 						orientationOK = ETrue;

   290 						}

   291 					}

   292 				if(orientationOK)

   293 				    {

   294 				    TBool tempElementFlip = aSurfaceConfiguration.Flip();

   295 				    TBool tempCRPFlip = aElement.SourceFlipping();

   296 				    if(tempElementFlip == tempCRPFlip)

   297 				        {

   298 				        match = ETrue;

   299 				        }

   300 				    }

   301 				}

   302 			}

   303 		}

   304 	return match;

   305 	}

   306 

   307 /** Sets the surfaceconfiguration to the element.

   308 

   309 @param aElement The element to set.

   310 @param aSurfaceConfiguration The configuration to set to the element.

   311 @param aLimitedSet Set all values if EFalse, otherwise only set viewport and orientation.

   312 @return KErrNone on success, error from compositor if it could not set the surface id.

   313 */

   314 TInt CWindowElement::SetElement(MWsElement& aElement, const TSurfaceConfiguration& aSurfaceConfiguration, TBool aLimitedSet)

   315 	{	//aLimitedSet - EFalse = set all . ETrue = set viewport and orientation only

   316 	if (!aLimitedSet)

   317 		{

   318 		//set surface id

   319 		TSurfaceId newSurfaceId;

   320 		aSurfaceConfiguration.GetSurfaceId(newSurfaceId);

   321 		TInt error = aElement.ConnectSurface(newSurfaceId);

   322 		if (error != KErrNone)

   323 			{

   324 			return error;

   325 			}

   326 		

   327 		//set extent

   328 		TRect newExtent;

   329 		aSurfaceConfiguration.GetExtent(newExtent);

   330 		aElement.SetDestinationRectangle(newExtent);

   331 		}

   332 	

   333 	//set viewport

   334 	TRect newViewport;

   335 	aSurfaceConfiguration.GetViewport(newViewport);

   336 	if (newViewport.iTl.iX < 0 || newViewport.iTl.iY < 0)

   337 		{

   338 		return KErrArgument;

   339 		}

   340 	

   341 	if (!newViewport.IsEmpty())

   342 		{	//need to check if viewport is valid size

   343 		TInt error = aElement.SetSourceRectangle(newViewport);

   344         if (error != KErrNone)

   345             {

   346             return error;

   347             }

   348 		}

   349 

   350 	//set orientation

   351 	//Note for compatibility with Oghma:

   352 	//This method does not properly error check or return KErrArgument,

   353 	//as that would propagate a client panic in SetBackgroundSurface which did not previously occur.

   354 	aElement.SetSourceRotation(GcToElementRotation(aSurfaceConfiguration.Orientation()));

   355 	// Set or clear flip if the element flags are changing

   356 	if (aSurfaceConfiguration.Flip() != aElement.SourceFlipping()) 

   357 	    {

   358         aElement.SetSourceFlipping(!aElement.SourceFlipping());

   359 	    }

   360 	return KErrNone;

   361 	}

   362 

   363 /** Attempts to insert a region cache in to the the windows iCache.

   364 If it fails, it will remove all cache beyond its index as it is now out of step.

   365 

   366 @param aIndexToInsert The index of where to insert the cache.

   367 @return ETrue on success, else EFalse.

   368 */

   369 

   370 TBool CWindowElement::InsertCache(TInt aIndexToInsert)

   371 	{

   372 	RRegion newRegion;

   373 	TInt cacheInsertError = iCache.Insert(newRegion, aIndexToInsert);

   374 	if (cacheInsertError == KErrNone)

   375 		{

   376 		newRegion.Close(); 

   377 		return ETrue;	//inserted cache

   378 		}

   379 	if (iCache.Count() > aIndexToInsert)

   380 		{	//if insert failed and there is more cache above where its trying to insert

   381 		iCache.Remove(iCache.Count()-1);

   382 		cacheInsertError = iCache.Insert(newRegion, aIndexToInsert);

   383 		

   384 		if (cacheInsertError == KErrNone)

   385 			{

   386 			newRegion.Close();

   387 			return ETrue;	//inserted cache

   388 			}

   389 		}

   390 	

   391 	//cant insert this cache, there may be invalid cache to destroy

   392 	TInt count = iCache.Count();

   393 	while(count > aIndexToInsert)

   394 		{	//if there is cache where we wished to insert, it and everything above is now invalid

   395 		iCache[count-1].Close();

   396 		iCache.Remove(count-1);

   397 		count--;

   398 		};

   399 	newRegion.Close();

   400 	return EFalse;	//failed to insert

   401 	}

   402 

   403 /** Will send a notification that a surface being unreferenced if it is not

   404 found in any WindowElementSet

   405 

   406 @pre Make sure the element being removed has already had its surfaceid set to NULL.

   407 @param aSurfaceId The surface being removed

   408 */

   409 void CWindowElement::NotifyReleasingSurface(TSurfaceId aSurfaceId)

   410 	{

   411 	if (CWsTop::SearchDuplicateSurfaceId(aSurfaceId) == EFalse)

   412 		{	//NOT found other instance of surface id, send notification now

   413 		TWservCrEvent crEvent(TWservCrEvent::ESurfaceUnreferenced, sizeof(aSurfaceId), &aSurfaceId);

   414 		TWindowServerEvent::NotifyDrawer(crEvent);

   415 		}

   416 	}

   417 

   418 /** Called to place a element within the window.

   419 It will either create a new element, recycle a element, or extend a element .

   420 

   421 @pre UnassignPlacedElements has already been called.

   422 @param aPlacedAttributes Returns the attributes of the surface placed.

   423 @param aSurfaceConfiguration The surface configuration for the surface to place.

   424 @param aUserDefinedRegion The user defined clipping of the window.

   425 @param aScene Access to the scene.

   426 @return Serious error, otherwise flags to describe what extra work needs doing.

   427 

   428 @see CWindowElementSet::AssignPlacedElement

   429 */

   430 TInt CWindowElement::AssignPlacedElement(

   431 		TPlacedAttributes*& aPlacedAttributes,

   432 		const TSurfaceConfiguration& aSurfaceConfiguration,

   433 		const TRegion& aUserDefinedRegion,

   434 		MWsScene& aScene,

   435 		TInt	aGcDrawingCount

   436 		)

   437 	{	

   438 	if (iStartGcDrawingCount!=aGcDrawingCount)

   439 		{

   440 		FlagAssignedElementsDrawnOver(aGcDrawingCount);

   441 		}

   442 

   443 	if (iNonRedrawVisibleRegion.CheckError())

   444 		{

   445 		//CANNOT DO ANYTHING, LEAVE

   446 		return KErrNotReady;	//error

   447 		}

   448 

   449 	TRect surfaceExtent;

   450 	aSurfaceConfiguration.GetExtent(surfaceExtent);

   451 	if (!aUserDefinedRegion.Intersects(surfaceExtent))

   452 		{

   453 		//clippedRegion.Close();

   454 		return KErrCancel;	//no intersection, so nothing to do

   455 		}

   456 

   457 	TInt matchFound = -1;

   458 	

   459 	//check 'current' (last placed element) to see if it is a match

   460 	if (iHighestReusedIndex != -1)

   461 		{

   462 		if (IsElementAMatch(*(iPlacedElements[iHighestReusedIndex].iElement),aSurfaceConfiguration,iPlacedElements[iHighestReusedIndex].Flags()) )

   463 			{

   464 			matchFound = iHighestReusedIndex;

   465 			}

   466 		}

   467 

   468 	if (matchFound == -1)

   469 		{

   470 		//check current unassigned elements to see if there is a match

   471 		for (TInt ii = (iHighestReusedIndex == -1)?0:iHighestReusedIndex+1; ii < iPlacedElements.Count(); ii++)

   472 			{

   473 			if (IsElementAMatch(*(iPlacedElements[ii].iElement),aSurfaceConfiguration,iPlacedElements[ii].Flags()))

   474 				{

   475 				matchFound = ii;

   476 				break;

   477 				}

   478 			}

   479 		}

   480 	TInt returnValue = 0;

   481 	if (matchFound == -1)

   482 		{	//not found a element to extend

   483 		//iResort = ETrue;

   484 		matchFound = 0;

   485 		while(1)

   486 			{

   487 			if (iPlacedElements.Count() == 0 || iHighestReusedIndex == -1 || matchFound == iHighestReusedIndex)	//reached last re assigned element, so cannot reuse one

   488 				{

   489 				matchFound = -1;

   490 				break;

   491 				}

   492 			if (iPlacedElements[matchFound].Unassigned() && !iPlacedElements[matchFound].LockedConfig())	//found a element to reuse

   493 				{

   494 				break;

   495 				}

   496 			matchFound++;

   497 			};

   498 

   499 		if (matchFound != -1)

   500 			{	//found a element to recycle

   501 			returnValue = AssignRecycleElement(matchFound,aSurfaceConfiguration,aUserDefinedRegion,aScene);

   502 			}

   503 		else

   504 			{	//need to create a new element

   505 			returnValue = AssignCreateElement(aSurfaceConfiguration,aUserDefinedRegion,aScene);

   506 			}

   507 		}

   508 	else

   509 		{	//found a candidate to extend

   510 		returnValue = AssignExtendElement(matchFound,aSurfaceConfiguration,aUserDefinedRegion,aScene);

   511 		}

   512 	if (returnValue < KErrNone)

   513 		{	//failed with error

   514 			return returnValue;

   515 		}

   516 	aPlacedAttributes = &iPlacedElements[iHighestReusedIndex];

   517 	iFlags|=returnValue;	//update window wide flags

   518 	return returnValue;

   519 	}

   520 

   521 /** Recycle a element assigned to the window.

   522 

   523 @param aIndex The index of the placed element to recycle.

   524 @param aSurfaceConfiguration The surface configuration for the surface to place.

   525 @param aUserDefinedRegion The user defined clipping of the window.

   526 @param aScene Access to the scene.

   527 @return Serious error, otherwise flags to describe what extra work needs doing.

   528 

   529 @see CWindowElement::AssignPlacedElement

   530 */

   531 TInt CWindowElement::AssignRecycleElement(const TInt aIndex, const TSurfaceConfiguration& aSurfaceConfiguration, const TRegion& aUserDefinedRegion, MWsScene& aScene)

   532 	{

   533 	TInt returnValue = 0;

   534 	TInt error = KErrNone;

   535 	STACK_REGION clippedRegion;

   536 	TRect surfaceExtent;

   537 	aSurfaceConfiguration.GetExtent(surfaceExtent);

   538 	clippedRegion.AddRect(surfaceExtent);

   539 	clippedRegion.Intersect(aUserDefinedRegion);

   540 	if (clippedRegion.CheckError())

   541 		{	//failed crucial calculation, leave while nothing has been changed!

   542 		clippedRegion.Close();

   543 		return KErrNoMemory;

   544 		}

   545 	WS_ASSERT_DEBUG(!clippedRegion.IsEmpty(),EWsPanicRegion);

   546 	if (clippedRegion.IsEmpty())

   547 		{

   548 		return KErrArgument;

   549 		}

   550 	

   551 	//keep note of surface being removed

   552 	TSurfaceId oldSurfaceId = iPlacedElements[aIndex].iElement->ConnectedSurface();

   553 	

   554 	//set element with new attributes

   555 	error = SetElement(*(iPlacedElements[aIndex].iElement),aSurfaceConfiguration,EFalse);

   556 	

   557 	if (error < KErrNone)

   558 		{	//must be a bad surface id or bad viewport, leave while nothing has been changed!

   559 		clippedRegion.Close();

   560 		return error;

   561 		}

   562 	

   563 	returnValue|=EFastPath;

   564 	returnValue|=EPauseComposition;

   565 	//element has been altered, must make sure old surface unreferenced notify will be called

   566 	if (!iRemovedSurfacesValid)

   567 		{	//didnt reserve space for surface ids, do search immediately

   568 		NotifyReleasingSurface(oldSurfaceId);

   569 		}

   570 	else

   571 		{	//keep memory of surface id - search will be done during cleanup. Space already been reserved

   572 		iRemovedSurfaces.Append(oldSurfaceId);

   573 		}

   574 

   575 	//order placed element correctly in iPlacedElements

   576 	TPlacedAttributes tempAttributes = iPlacedElements[aIndex];

   577 	iPlacedElements.Remove(aIndex);

   578 	//keep cache up to date

   579 	if (iCache.Count() > aIndex)

   580 		{

   581 		iCache[aIndex].Close();

   582 		iCache.Remove(aIndex);

   583 		}

   584 

   585 	WS_ASSERT_DEBUG(iHighestReusedIndex != -1,EWsPanicRecycleElement);

   586 	if (iHighestReusedIndex == -1)

   587 		{

   588 		return KErrArgument;

   589 		}

   590 	

   591 	error = iPlacedElements.Insert(tempAttributes, iHighestReusedIndex);

   592 	if (error < KErrNone)

   593 		{	//must destroy the element and leave.  Old elements surface unregistration already dealt with

   594 		aScene.DestroySceneElement(tempAttributes.iElement);

   595 		clippedRegion.Close();

   596 		return KErrNoMemory;

   597 		}

   598 	returnValue|=EResort;	//element has been moved, will need a resort

   599 	//set placed element attributes

   600 	iPlacedElements[iHighestReusedIndex].SetUnassigned(EFalse);

   601 	iPlacedElements[iHighestReusedIndex].SetLockedConfig(ETrue);

   602 	iPlacedElements[iHighestReusedIndex].SetChangedClip(ETrue);

   603 	

   604 	TRect tempViewport;

   605 	aSurfaceConfiguration.GetViewport(tempViewport);

   606 

   607 	TBool cacheSaved = EFalse;

   608 	if (iCache.Count() >= iHighestReusedIndex)

   609 		{	//need to update cache with visible region of element

   610 		TBool insertSuccess = InsertCache(iHighestReusedIndex);

   611 		if (insertSuccess != EFalse)

   612 			{

   613 			iCache[iHighestReusedIndex].Copy(clippedRegion);

   614 			if (!iCache[iHighestReusedIndex].CheckError())

   615 				{

   616 				cacheSaved = ETrue;

   617 				}

   618 			}

   619 		}

   620 	if (cacheSaved == EFalse)

   621 		{	//need to set clipping to element immediately

   622 		TInt count = iCache.Count();

   623 		while(count > iHighestReusedIndex)

   624 			{	//if there is cache where we wished to insert, it and everything above is now invalid

   625 			iCache[count-1].Close();

   626 			iCache.Remove(count-1);

   627 			count--;

   628 			};

   629 		}

   630 	clippedRegion.Close();

   631 	return returnValue;

   632 	}

   633 

   634 /** Create a new element for the placed surface.

   635 

   636 @param aSurfaceConfiguration The surface configuration for the surface to place.

   637 @param aUserDefinedRegion The user defined clipping of the window.

   638 @param aScene Access to the scene.

   639 @return Serious error, otherwise flags to describe what extra work needs doing.

   640 

   641 @see CWindowElement::AssignPlacedElement

   642 */

   643 TInt CWindowElement::AssignCreateElement(const TSurfaceConfiguration& aSurfaceConfiguration, const TRegion& aUserDefinedRegion, MWsScene& aScene)

   644 	{

   645 	TInt returnValue = 0;

   646 	TInt error = KErrNone;

   647 	STACK_REGION clippedRegion;

   648 	TRect surfaceExtent;

   649 	aSurfaceConfiguration.GetExtent(surfaceExtent);

   650 	//calculate region

   651 	clippedRegion.AddRect(surfaceExtent);

   652 	clippedRegion.Intersect(aUserDefinedRegion);

   653 	if (clippedRegion.CheckError())

   654 		{	//failed, return KErrNoMemory

   655 		clippedRegion.Close();

   656 		return KErrNoMemory;

   657 		}

   658 	

   659 	TPlacedAttributes newElement;

   660 	if (iHighestReusedIndex == -1)

   661 		{

   662 		error = iPlacedElements.Insert(newElement,0);

   663 		}

   664 	else

   665 		{	//insert above current highest reused element

   666 		error = iPlacedElements.Insert(newElement,iHighestReusedIndex+1);

   667 		}

   668 	if (error >= KErrNone)

   669 		{

   670 		iHighestReusedIndex++;

   671 		}

   672 	else

   673 		{

   674 		//FAILED! LEAVE FUNCTION. nothing has been changed

   675 		clippedRegion.Close();

   676 		return KErrNoMemory;

   677 		}

   678 

   679 	//create new element with new configuration

   680 	MWsElement* element = NULL;

   681 	TRAP(error,element = aScene.CreateSceneElementL());

   682 	if (error != KErrNone)

   683 		{

   684 		//FAILED! LEAVE FUNCTION. nothing has been changed

   685 		clippedRegion.Close();

   686 		return error;

   687 		}

   688 

   689 	element->SetGlobalAlpha( 0xFF );

   690 

   691 	iPlacedElements[iHighestReusedIndex].iElement = element;

   692 	error = SetElement(*element,aSurfaceConfiguration,EFalse);

   693 	if (error < KErrNone)

   694 		{

   695 		//must be a bad surface id or viewport. Leave now.

   696 		aScene.DestroySceneElement(element);

   697 		clippedRegion.Close();

   698 		iPlacedElements.Remove(iHighestReusedIndex);

   699 		iHighestReusedIndex--;

   700 		return error;

   701 		}

   702 	

   703 	//Now certain that these must be flagged

   704 	returnValue|=EFastPath;

   705 	returnValue|=EPauseComposition;

   706 	returnValue|=EResort;

   707 

   708 	//set placed element attributes

   709 	iPlacedElements[iHighestReusedIndex].SetUnassigned(EFalse);

   710 	iPlacedElements[iHighestReusedIndex].SetChangedClip(ETrue);

   711 	iPlacedElements[iHighestReusedIndex].SetLockedConfig(ETrue);

   712 	

   713 	TRect tempViewport;

   714 	aSurfaceConfiguration.GetViewport(tempViewport);

   715 

   716 	TBool cacheSaved = EFalse;

   717 	if (iCache.Count() >= iHighestReusedIndex)

   718 		{	//should try to add new elements region to cache

   719 		TBool insertSuccess = InsertCache(iHighestReusedIndex);

   720 		if (insertSuccess != EFalse)

   721 			{

   722 			iCache[iHighestReusedIndex].Copy(clippedRegion);

   723 			if (!iCache[iHighestReusedIndex].CheckError())

   724 				{

   725 				cacheSaved = ETrue;

   726 				}

   727 			}

   728 		}

   729 	if (cacheSaved == EFalse)

   730 		{	//need to clear cache from this point onward, and set clipping to element immediately

   731 		TInt count = iCache.Count();

   732 		while(count > iHighestReusedIndex)

   733 			{	//if there is cache where we wished to insert, it and everything above is now invalid

   734 			iCache[count-1].Close();

   735 			iCache.Remove(count-1);

   736 			count--;

   737 			};

   738 		}

   739 	//add the new element to the scene

   740     error = aScene.InsertSceneElement(element, NULL);    //place at the back. will get ordered correctly later

   741 	WS_ASSERT_DEBUG(error == KErrNone,EWsPanicSceneErrorIgnored);

   742 	clippedRegion.Close();

   743 	return returnValue;

   744 	}

   745 

   746 /** Extend an existing placed surface element.

   747 

   748 @param The index of the element to extend.

   749 @param aSurfaceConfiguration The surface configuration for the surface to place.

   750 @param aUserDefinedRegion The user defined clipping of the window.

   751 @param aScene Access to the scene.

   752 @return Serious error, otherwise flags to describe what extra work needs doing.

   753 

   754 @see CWindowElement::AssignPlacedElement

   755 */

   756 TInt CWindowElement::AssignExtendElement(const TInt aIndex, const TSurfaceConfiguration& aSurfaceConfiguration, const TRegion& aUserDefinedRegion, MWsScene& /*aScene*/)

   757 	{

   758 	TInt returnValue = 0;

   759 	TInt error = KErrNone;

   760 	STACK_REGION backupRegionAgainstFail;

   761 	STACK_REGION clippedRegion;

   762 	TRect surfaceExtent;

   763 	aSurfaceConfiguration.GetExtent(surfaceExtent);

   764 	TRect surfaceViewport;

   765 	aSurfaceConfiguration.GetViewport(surfaceViewport);

   766 	

   767 	if (!iPlacedElements[aIndex].LockedConfig())

   768 		{	//set element now. If viewport is invalid its ok to fail now

   769 		error = SetElement(*iPlacedElements[aIndex].iElement,aSurfaceConfiguration,ETrue);

   770 		if (error < KErrNone)

   771 			{

   772 			backupRegionAgainstFail.Close();

   773 			clippedRegion.Close();

   774 			return error;

   775 			}

   776 		}

   777 

   778 	if(iPlacedElements[aIndex].Unassigned() && !iPlacedElements[aIndex].Overlapping())

   779 		{

   780 		//backup stays clear

   781 		clippedRegion.Copy(aUserDefinedRegion);

   782 		}

   783 	else

   784 		{

   785 		clippedRegion.Copy(iNonRedrawVisibleRegion);

   786 		if (iCache.Count() > aIndex)	//if cache is ok

   787 			{

   788 			clippedRegion.Intersect(iCache[aIndex]);

   789 			clippedRegion.Union(iCache[aIndex]);	//previously added regions should be kept

   790 			}

   791 		else

   792 			{

   793 			STACK_REGION tempSurfaceBaseArea;

   794             TRect destinationRect;

   795             iPlacedElements[aIndex].iElement->GetDestinationRectangle(destinationRect);

   796             tempSurfaceBaseArea.AddRect(destinationRect);

   797 			tempSurfaceBaseArea.Offset(surfaceExtent.iTl);

   798 			clippedRegion.Intersect(tempSurfaceBaseArea);

   799 			clippedRegion.Union(tempSurfaceBaseArea);

   800 			tempSurfaceBaseArea.Close();

   801 			}

   802 		backupRegionAgainstFail.Copy(clippedRegion);

   803 		//clipped region should contain something

   804 		clippedRegion.Union(aUserDefinedRegion);

   805 		}

   806 	clippedRegion.ClipRect(surfaceExtent);

   807 	

   808 	if (backupRegionAgainstFail.CheckError() || clippedRegion.CheckError())

   809 		{	//failed critical calculations, leave now before anything has been changed

   810 		clippedRegion.Close();

   811 		backupRegionAgainstFail.Close();

   812 		return KErrNoMemory;

   813 		}

   814 

   815 	TBool setCache = EFalse;

   816 	if (iCache.Count() > aIndex)	//if Cache is ok

   817 		{

   818 		//compare

   819 		TInt compareReturn;

   820 		compareReturn = TRegionExtend::Cast(iCache[aIndex]).TestDifference(clippedRegion);

   821 

   822 		if (compareReturn&TRegionExtend::EDiffers)	//element has changed

   823 			{

   824 			iPlacedElements[aIndex].SetChangedClip(ETrue);

   825 			if (compareReturn&TRegionExtend::EAdd)	//element has become revealed on the screen

   826 				{

   827 				returnValue|=EPauseComposition;	//need to pause before the end of assign placed element

   828 				}

   829 			else

   830 				{

   831 				returnValue|=EFastPath;	//fastpath and pause will be called during cleanup

   832 				}

   833 			}

   834 		

   835 		//copy clipped region to cache

   836 		iCache[aIndex].Copy(clippedRegion);	//can fail

   837 		setCache = ETrue;

   838 		if (iCache[aIndex].CheckError())

   839 			{	//copy failed, remove cache from this element onwards

   840 			TInt count = iCache.Count();

   841 			while(count > aIndex)

   842 				{	//if there is cache where we wished to insert, it and everything above is now invalid

   843 				iCache[count-1].Close();

   844 				iCache.Remove(count-1);

   845 				count--;

   846 				};

   847 			setCache = EFalse;

   848 			}

   849 		}

   850 	if (setCache == EFalse)

   851 		{	//need to pause composition and update element immediately

   852 		returnValue|=EPauseComposition;

   853 		}

   854 	iPlacedElements[aIndex].SetUnassigned(EFalse);

   855 	iPlacedElements[aIndex].SetLockedConfig(ETrue);

   856 	iHighestReusedIndex = aIndex;

   857 	backupRegionAgainstFail.Close();

   858 	clippedRegion.Close();

   859 	return returnValue;

   860 	}

   861 

   862 /** Called at the end of a redraw to set cached changed to elements, and

   863 removed elements that are still unassigned.

   864 

   865 @param aScene Access to the scene.

   866 @return Flags to describe what extra work needs doing.

   867 @see CWindowElementSet::CleanUpPlacedElements

   868 */

   869 TInt CWindowElement::CleanUpPlacedElements(MWsScene& aScene, TInt aGcDrawingCount)

   870 	{

   871 	if (iStartGcDrawingCount!=aGcDrawingCount)

   872 		{

   873 		FlagAssignedElementsDrawnOver(aGcDrawingCount);

   874 		}

   875 	TInt returnFlags = iFlags;

   876 	if (iFlags > 0)

   877 		{	//copy flags to return, and ensure pause is flagged

   878 		returnFlags|=EPauseComposition;

   879 		}

   880 	TInt ii;

   881 	TBool removeElements = EFalse;

   882 	//destroy placed element reference

   883 	for (ii=0; ii<iPlacedElements.Count(); ii++)

   884 		{

   885 		if (iPlacedElements[ii].Unassigned() && !iPlacedElements[ii].Overlapping())

   886 			{

   887 			returnFlags|=EFastPath;	//need to invoke 1108

   888 			if (iRemovedSurfacesValid)

   889 				{

   890 				iRemovedSurfaces.Append(iPlacedElements[ii].iElement->ConnectedSurface());

   891 				iPlacedElements[ii].iElement->ConnectSurface(TSurfaceId::CreateNullId());

   892 				}

   893 			else

   894 				{

   895 				TSurfaceId tempId = iPlacedElements[ii].iElement->ConnectedSurface();

   896 				iPlacedElements[ii].iElement->ConnectSurface(TSurfaceId::CreateNullId());

   897 				NotifyReleasingSurface(tempId);

   898 				}

   899 			removeElements = ETrue;

   900 			}

   901 		}

   902 

   903 	if (removeElements)

   904 		{	//there will be elements to remove

   905 		for (ii=0; ii<iPlacedElements.Count(); ii++)

   906 			{

   907 			if (iPlacedElements[ii].iElement->ConnectedSurface().IsNull())

   908 				{

   909 				aScene.DestroySceneElement(iPlacedElements[ii].iElement);

   910 				iPlacedElements.Remove(ii);

   911 				if (iCache.Count() > ii)

   912 					{	//there is cache for this element, remove it

   913 					iCache[ii].Close();

   914 					iCache.Remove(ii);

   915 					}

   916 				ii--;

   917 				}

   918 			}

   919 		}

   920 

   921 	if (iRemovedSurfaces.Count() > 1)

   922 		{	//remove duplicates of surface id from removal list

   923 		for (ii = 0; ii < iRemovedSurfaces.Count() - 1; ii++)

   924 			{

   925 			for (TInt jj = ii+1; jj < iRemovedSurfaces.Count(); jj++)

   926 				{

   927 				if (iRemovedSurfaces[ii] == iRemovedSurfaces[jj])

   928 					{

   929 					iRemovedSurfaces.Remove(jj);

   930 					jj--;

   931 					}

   932 				}

   933 			}

   934 		}

   935 	

   936 	//do global search for surface ids

   937 	while (iRemovedSurfaces.Count()>0)

   938 		{

   939 		TInt tempRemoval = iRemovedSurfaces.Count() - 1;

   940 		NotifyReleasingSurface(iRemovedSurfaces[tempRemoval]);

   941 		iRemovedSurfaces.Remove(tempRemoval);

   942 		};

   943 

   944 	iRemovedSurfaces.Reset();

   945 

   946 	//clip unassigned overlapping entries, mark as changedclip if region changed

   947 	for (ii=0; ii<iPlacedElements.Count(); ii++)

   948 		{

   949 		if (iPlacedElements[ii].Unassigned())	//non overlapping unassigned have already been destroyed

   950 			{	//these must overlap

   951 			TBool failureOccured = EFalse;

   952 			if (iCache.Count() > ii)

   953 				{

   954 				//if cache region is entirely inside non redraw vis region, nothing to update!

   955 				TInt changed = 

   956 						TRegionExtend::Cast(iCache[ii]).TestDifference(iNonRedrawVisibleRegion);

   957 				if (changed&TRegionExtend::ESub)

   958 					{	//the clipping will change

   959 					iCache[ii].Intersect(iNonRedrawVisibleRegion);

   960 					if (iCache[ii].CheckError())

   961 						{

   962 						failureOccured = ETrue;

   963 						iCache[ii].Close();

   964 						iCache.Remove(ii);

   965 						}

   966 					else

   967 						{

   968 						iPlacedElements[ii].SetChangedClip(ETrue);	//changed clipping

   969 						}

   970 					}

   971 				}

   972 			else

   973 				{	//attempt getting element region to perform calculation and update element directly

   974 				STACK_REGION elementRegion;

   975 	            TRect destinationRect;

   976 	            iPlacedElements[ii].iElement->GetDestinationRectangle(destinationRect);

   977 	            elementRegion.AddRect(destinationRect);

   978 				if (elementRegion.CheckError())

   979 					{

   980 					failureOccured = ETrue;

   981 					}

   982 				else

   983 					{

   984 					TRect elementExtent;

   985 					iPlacedElements[ii].iElement->GetDestinationRectangle(elementExtent);

   986 					elementRegion.Offset(elementExtent.iTl);	//get element region into absolute coordinates

   987 					TInt changed =

   988 						TRegionExtend::Cast(elementRegion).TestDifference(iNonRedrawVisibleRegion);

   989 					if (changed&TRegionExtend::ESub)

   990 						{	//need to clip element back

   991 						elementRegion.Intersect(iNonRedrawVisibleRegion);

   992 						if (!elementRegion.CheckError())

   993 							{

   994 							elementRegion.Offset(-elementExtent.iTl);	//put element region back into relative coords

   995 							returnFlags|=EFastPath;

   996 							}

   997 						else

   998 							{

   999 							failureOccured = ETrue;

  1000 							}

  1001 						}

  1002 					}

  1003 				elementRegion.Close();

  1004 				}

  1005 			if (failureOccured)

  1006 				{	//need to release element

  1007 				TSurfaceId tempId = iPlacedElements[ii].iElement->ConnectedSurface();

  1008 				iPlacedElements[ii].iElement->ConnectSurface(TSurfaceId::CreateNullId());

  1009 				NotifyReleasingSurface(tempId);

  1010 				aScene.DestroySceneElement(iPlacedElements[ii].iElement);

  1011 				returnFlags|=EFailed;

  1012 				iPlacedElements.Remove(ii);	//remove placed element entry, cache is already removed

  1013 				ii--;

  1014 				}

  1015 			}

  1016 		}

  1017 

  1018 	//update any elements marked as changedclip , clear all cache, clear flags

  1019 	for (ii=0; ii<iPlacedElements.Count(); ii++)

  1020 		{

  1021 		if (iPlacedElements[ii].ChangedClip())

  1022 			{

  1023 			returnFlags|=EFastPath;	//need to invoke 1108

  1024 			}

  1025 		else

  1026 			if (	!(returnFlags&EFastPath)

  1027 				&&	iPlacedElements[ii].LockedConfig() && !iPlacedElements[ii].Unassigned()

  1028 				&&	iPlacedElements[ii].DrawnOver()!=iPlacedElements[ii].DrawnOverLast()	)

  1029 						{

  1030 						returnFlags|=EFastPath;

  1031 						}

  1032 		iPlacedElements[ii].ClearRedrawFlags();

  1033 		if (iCache.Count() > ii)

  1034 			{

  1035 			iCache[ii].Clear();

  1036 			}

  1037 		}

  1038 	iCache.Reset();

  1039 	iNonRedrawVisibleRegion.Clear();

  1040 	iHighestReusedIndex = -1;

  1041 	return returnFlags;

  1042 	}

  1043 

  1044 /** Move all elements in this windowelement to above the supplied element in the scene

  1045 

  1046 @param aScene Access to the scene.

  1047 @param aElement The element to set all this windows elements above.

  1048 */

  1049 

  1050 void CWindowElement::MoveToAboveGivenElement(MWsScene& aScene, MWsElement* aElement)

  1051 	{

  1052 	MWsElement* newAboveElement = iBackgroundElement.iElement;

  1053 	MWsElement* previousAboveElement = aElement;

  1054 	if (newAboveElement)

  1055 		{

  1056 		aScene.InsertSceneElement(newAboveElement, previousAboveElement);	//background element is put on first

  1057 		previousAboveElement = newAboveElement;		

  1058 		}

  1059 	TInt placedElements = iPlacedElements.Count();

  1060 	if (placedElements != 0)

  1061 		{

  1062 		for (TInt ii = 0; ii < placedElements; ii++)

  1063 			{

  1064 			newAboveElement = iPlacedElements[ii].iElement;

  1065 			aScene.InsertSceneElement(newAboveElement, previousAboveElement);	//place element above previous above element

  1066 			previousAboveElement = newAboveElement;	

  1067 			}

  1068 		}

  1069 	}

  1070 

  1071 /** Updates the elements extent, whether from a window movement or a change in window size

  1072 

  1073 @param aOffset The movement of the window.  If NULL then the window has changed size.

  1074 @see CWindowElementSet::UpdateElementExtent

  1075 */

  1076 void CWindowElement::UpdateElementExtent(const TPoint* aOffset)

  1077 	{

  1078 	if (aOffset)	//window moved

  1079 		{

  1080 		TRect tempExtent;

  1081 		MWsElement* element = iBackgroundElement.iElement;

  1082 		TBool complete = EFalse;

  1083 		TInt placedElementDone = -1;

  1084 		while (!complete)

  1085 			{

  1086 			if (!element && placedElementDone < iPlacedElements.Count()-1)

  1087 				{

  1088 				placedElementDone++;

  1089 				element = iPlacedElements[placedElementDone].iElement;

  1090 				}

  1091 			if (!element)

  1092 				{

  1093 				complete = ETrue;

  1094 				}

  1095 			else

  1096 				{

  1097 				tempExtent = const_cast<CWsClientWindow&>(iWindow).GetOriginalDestElementRect();

  1098 				tempExtent.Move(*aOffset);

  1099 				element->SetDestinationRectangle(tempExtent);

  1100 				const_cast<CWsClientWindow&>(iWindow).SetOriginalDestElementRect(tempExtent);

  1101 				}

  1102 			element = NULL;

  1103 			}

  1104 		}

  1105 	else			//window changed size

  1106 		{

  1107 		if (!iBackgroundElement.ExplicitExtent() && iBackgroundElement.iElement)

  1108 			{

  1109 			iBackgroundElement.iElement->SetDestinationRectangle(iWindow.FullRect());

  1110 			const_cast<CWsClientWindow&>(iWindow).SetOriginalDestElementRect(iWindow.FullRect());

  1111 			}

  1112 		}

  1113 	}

  1114 

  1115 /** Checks the windows placed elements when the windows visibility is changed.

  1116 If the placed elements are no longer visible, they are removed.

  1117 

  1118 @param aRegion The new visible region of the window.

  1119 @param aScene Access to the scene.

  1120 @return ETrue if any elements have been removed, otherwise EFalse.

  1121 @see CWindowElementSet::SetVisibleRegion

  1122 */

  1123 TBool CWindowElement::SetVisibleRegion(const TRegion& aRegion, MWsScene& aScene)

  1124 	{

  1125 	TBool retcode=EFalse;

  1126 	if (iPlacedElements.Count() == 0)

  1127 		{

  1128 		return EFalse;	//there is noting to do

  1129 		}

  1130 	

  1131 	STACK_REGION tempRegion;

  1132 	for (TInt ii = 0; ii < iPlacedElements.Count(); ii++)

  1133 		{

  1134 		TRect tempExtent;