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 "walkwindowtree.h"

    17 #include "cliwin.h"

    18 #include "rootwin.h"

    19 #include "offscreenbitmap.h"

    20 #include "ANIM.H"

    21 #include "tcursor.h"

    22 #include "pointer.h"

    23 

    24 TWalkWindowTreeFocusChanged::TWalkWindowTreeFocusChanged(TBool aNewFocusState) :

    25 	iNewFocusState(aNewFocusState)

    26 	{

    27 	}

    28 

    29 TBool TWalkWindowTreeFocusChanged::DoIt(CWsWindow *aWin)

    30 //

    31 // Walk all windows that have had their focus state changed

    32 //

    33 	{

    34 	aWin->FocusChanged(iNewFocusState);

    35 	return(EFalse);

    36 	}

    37 

    38 TResumableWalkWindowTreeFindInvalid::TResumableWalkWindowTreeFindInvalid(CWsWindowRedraw** aResult) :

    39 	iResult(aResult)

    40 	{

    41 	}

    42 

    43 TBool TResumableWalkWindowTreeFindInvalid::DoIt(CWsWindow* aWin)

    44 //

    45 // Find a window with an invalid area

    46 //

    47 	{

    48 	WS_ASSERT_DEBUG(aWin->WinType()==EWinTypeClient, EWsPanicWindowType);

    49 	CWsWindowRedraw *redraw=((CWsClientWindow *)aWin)->Redraw();

    50 	if (redraw->NeedsRedraw()>0)

    51 		{

    52 		*iResult=redraw;

    53 		return(ETrue);

    54 		}

    55 	return(EFalse);

    56 	}

    57 

    58 TWalkWindowTreeDisconnect::TWalkWindowTreeDisconnect(RWsTextCursor *aCursor) :

    59 	iTextCursor(aCursor)

    60 	{}

    61 

    62 TBool TWalkWindowTreeDisconnect::DoIt(CWsWindow *aWin)

    63 //

    64 // Disconnect a window

    65 //

    66 	{

    67 	if (aWin->WinType()==EWinTypeClient)

    68 		{

    69 		CWsClientWindow *win=(CWsClientWindow *)aWin;

    70 		win->iRedraw->WindowClosing();

    71 		win->DeactivateAllSprites();

    72 

    73 		if (iTextCursor)

    74 			iTextCursor->WindowDisconnected(win);

    75 		CWsAnim::WindowClosing(win->iAnimList);	// Destroy any animated objects attached to this window

    76 		WsPointer::WindowDisconected(aWin);

    77 

    78 		win->iParent=NULL;

    79 		win->iSibling=NULL;

    80 		win->iChild=NULL;

    81 		win->iFlags&=~EFlagActive;

    82 		win->ResetHiddenFlag();

    83 		}

    84 	return(EFalse);

    85 	}

    86 	

    87 TWalkWindowTreeRegionBase::TWalkWindowTreeRegionBase(RWsRegion *aRegion, TTranslucentBehaviour aTranslucentBehaviour) :

    88 	iTranslucentBehaviour(aTranslucentBehaviour), iRegion(aRegion), iSubRegion(NULL)

    89 	{}

    90 

    91 TBool TWalkWindowTreeRegionBase::DoIt(CWsWindow *aWin)

    92 	{

    93 	if (aWin->IsVisible())

    94 		{

    95 		DoIt2(aWin);

    96 		if (aWin->WinType()!=EWinTypeRoot)

    97 			{

    98 			STACK_REGION tmp;

    99 			switch(iTranslucentBehaviour)

   100 				{

   101 				case EDontWalkTranslucent:

   102 					static_cast<CWsClientWindow *>(aWin)->SetClippedBaseArea(tmp);

   103 					iRegion->SubRegion(tmp,iSubRegion);

   104 					break;

   105 				case EWalkTranslucent:

   106 					static_cast<CWsClientWindow *>(aWin)->SetClippedBaseArea(*iSubRegion);

   107 					iSubRegion->Intersect(*iRegion);

   108 					if (iSubRegion->Count() > 0)

   109 						{

   110 						static_cast<CWsClientWindow *>(aWin)->SetOpaqueClippedBaseArea(tmp);

   111 						iRegion->SubRegion(tmp);

   112 						}

   113 					break;

   114 				}

   115 			tmp.Close();

   116 			}

   117 		else if(iSubRegion)

   118 			{

   119 			iSubRegion->Copy(*iRegion);

   120 			}

   121 		if (iSubRegion && (iSubRegion->Count()>0 || iSubRegion->CheckError()))

   122 			{

   123 			if (DoIt3(aWin))

   124 				return ETrue;

   125 			iSubRegion->Clear();

   126 			}

   127 		}

   128 	return(iRegion->IsEmpty());

   129 	}

   130 TBool TWalkWindowTreeRegionBase::DoIt3(CWsWindow*)

   131 	{return EFalse;}

   132 

   133 TWalkWindowTreeSchedule::TWalkWindowTreeSchedule() :

   134 	TWalkWindowTreeBase(),

   135 	iHead(0)

   136 	{

   137 	}

   138 

   139 CWsWindow * TWalkWindowTreeSchedule::HeadWindow() const

   140 	{

   141 	return iHead;

   142 	}

   143 

   144 TWalkWindowTreeScheduleRegions::TWalkWindowTreeScheduleRegions(RWsRegion *aRegion, const TRegion& aTopLayer) :

   145 	TWalkWindowTreeSchedule(),

   146 	iRegion(aRegion),

   147 	iTopLayer(aTopLayer),

   148 	iScheduledRegionsOk(ETrue)

   149 	{

   150 	}

   151 

   152 // This is similar to TWalkWindowTreeRegionBase::DoIt

   153 TBool TWalkWindowTreeScheduleRegions::DoIt(CWsWindow *aWin)

   154 	{

   155 	WS_ASSERT_DEBUG((aWin != iHead), EWsPanicScheduledRedraw);

   156 	if (aWin->IsVisible())

   157 		{

   158 		// Calculate the region we care about for this window:

   159 		STACK_REGION region;

   160 		if (aWin->WinType()==EWinTypeRoot)

   161 			{

   162 			region.Copy(*iRegion);

   163 			}

   164 		else

   165 			{

   166 			static_cast<CWsClientWindow *>(aWin)->SetClippedBaseArea(region);

   167 			region.Intersect(*iRegion);

   168 			}

   169 		// If there is a region we care about, remember the window:

   170 		// NOTE: Even if there are no redraw segments (ReadyToDraw is false) the window should

   171 		//   be scheduled if it has some animations which will be redrawn via PostDrawWindow (cf def131912)

   172 		if (!region.IsEmpty() && (aWin->ReadyToDraw() || aWin->HasAnimation() || aWin->HasSprite()) )

   173 			{

   174 			// Add window to linked list:

   175 			aWin->SetNextScheduled(iHead);

   176 			iHead = aWin;

   177 			// Set the window scheduled region to something appropriate:

   178 			if (iScheduledRegionsOk)

   179 				{

   180 				if (region.CheckError())

   181 					{

   182 					iScheduledRegionsOk = EFalse;

   183 					}

   184 				else

   185 					{

   186 					iScheduledRegionsOk = aWin->SetScheduledRegion(region);

   187 					}

   188 				}

   189 			}

   190 		if (aWin->WinType()!=EWinTypeRoot)

   191 			{

   192 			// Remove the opaque part from our working region:

   193 			STACK_REGION opaqueRegion;

   194 			static_cast<CWsClientWindow *>(aWin)->SetOpaqueClippedBaseArea(opaqueRegion);

   195 			iRegion->SubRegion(opaqueRegion);

   196 			opaqueRegion.Close();

   197 			

   198 			// Where we were drawing transparent and doing top layer only, remove

   199 			// that bit too:

   200 			if (!iTopLayer.IsEmpty())

   201 				{

   202 				region.Intersect(iTopLayer);

   203 				iRegion->SubRegion(region);

   204 				}

   205 			}

   206 		region.Close();

   207 		}

   208 

   209 	return(iRegion->IsEmpty() || !iScheduledRegionsOk);

   210 	}

   211 

   212 const TRegion * TWalkWindowTreeScheduleRegions::Region(const CWsWindow* aWin) const

   213 	{

   214 	WS_ASSERT_DEBUG(iScheduledRegionsOk, EWsPanicScheduledRedraw);

   215 	return aWin->ScheduledRegion();

   216 	}

   217 

   218 TBool TWalkWindowTreeScheduleRegions::ScheduledRegionsOk() const

   219 	{

   220 	return iScheduledRegionsOk;

   221 	}

   222 

   223 TWalkWindowTreeScheduleFallback::TWalkWindowTreeScheduleFallback(CScreen::CFallbackMap * aFallbackMap) :

   224 	TWalkWindowTreeSchedule(),

   225 	iFallbackMap(aFallbackMap)

   226 	{

   227 	}

   228 

   229 // This is similar to TWalkWindowTreeRegionBase::DoIt

   230 TBool TWalkWindowTreeScheduleFallback::DoIt(CWsWindow *aWin)

   231 	{

   232 	WS_ASSERT_DEBUG((aWin != iHead), EWsPanicScheduledRedraw);

   233 	if (aWin->IsVisible())

   234 		{

   235 		if (aWin == aWin->RootWindow())

   236 			{

   237 			aWin->SetNextScheduled(iHead);

   238 			return ETrue;

   239 			}

   240 		else

   241 			{

   242 			TBool addWindow = EFalse;

   243 			CWsClientWindow* cliWin = static_cast<CWsClientWindow *>(aWin);

   244 			if (cliWin->IsTranslucent())

   245 				{

   246 				addWindow = ETrue; // costs more to work out than it is worth

   247 				const TRegion * opaque = cliWin->GetUserOpaqueRegion();

   248 				if (opaque && !opaque->CheckError())

   249 					iFallbackMap->FillRegion(*opaque);

   250 				}

   251 			else

   252 				{

   253 				addWindow = iFallbackMap->FillRegion(*cliWin->BaseArea());

   254 				}

   255 			if (addWindow)

   256 				{

   257 				aWin->SetNextScheduled(iHead);

   258 				iHead = aWin;

   259 				}

   260 			}

   261 		}

   262 

   263 	return(iFallbackMap->Count() < 1);

   264 	}

   265 

   266 const TRegion * TWalkWindowTreeScheduleFallback::Region(const CWsWindow* aWin) const

   267 	{

   268 	if (aWin == aWin->RootWindow())

   269 		return iFallbackMap->Region();

   270 	else

   271 		{

   272 		const CWsClientWindow* win = static_cast<const CWsClientWindow *>(aWin);

   273 		const TRegion* region = win->VisibleRegionIfValid();

   274 		if (!region)

   275 			region = win->BaseArea();

   276 		return region;

   277 		}

   278 	}

   279 

   280 TWalkWindowTreeIsObscured::TWalkWindowTreeIsObscured(TBool &aResult) :

   281 	iResult(&aResult)

   282 	{

   283 	aResult=ETrue;

   284 	}

   285 

   286 TBool TWalkWindowTreeIsObscured::DoIt(CWsWindow *aWin)

   287 	{

   288 	if (!aWin->VisibleRegion().IsEmpty())

   289 		{

   290 		*iResult=EFalse;

   291 		return(ETrue);

   292 		}

   293 	return(EFalse);

   294 	}

   295 

   296 TWalkWindowTreeSetNonFading::TWalkWindowTreeSetNonFading(TBool aNonFading) :

   297 	iNonFading(aNonFading)

   298 	{}

   299 TBool TWalkWindowTreeSetNonFading::DoIt(CWsWindow *aWin)

   300 	{

   301 	aWin->SetNonFading(iNonFading); 

   302 	return EFalse;

   303 	}

   304 

   305 TWalkWindowTreeSetFaded::TWalkWindowTreeSetFaded(TBool aFaded,CWsWindowBase* aWin,TUint8 aBlackMap,TUint8 aWhiteMap) :

   306 	iBlackMap(aBlackMap), iWhiteMap(aWhiteMap), iFaded(aFaded), iGroup(aWin->WinGroup())

   307 	{

   308 	}

   309 	

   310 TBool TWalkWindowTreeSetFaded::DoIt(CWsWindow *aWin)

   311 	{

   312 	if (aWin->WinGroup()!=iGroup)

   313 		return ETrue;

   314 	((CWsClientWindow*)aWin)->SetFaded(iFaded,iBlackMap,iWhiteMap); 

   315 	return EFalse;

   316 	}

   317 

   318 TWalkWindowTreePurgeEvents::TWalkWindowTreePurgeEvents()

   319 	{}

   320 TBool TWalkWindowTreePurgeEvents::DoIt(CWsWindow *aWin)

   321 	{

   322 	aWin->PurgeEvents();

   323 	return EFalse;

   324 	}

   325 

   326 TWalkWindowTreeCalcInvalidGraphics::TWalkWindowTreeCalcInvalidGraphics(RWsRegion *aRegion,TRegion &aDirty,const TArray<TGraphicDrawerId>& aInvalid):

   327 	TWalkWindowTreeRegionBase(aRegion, EWalkTranslucent),

   328 	iDirty(aDirty),

   329 	iInvalid(aInvalid)

   330 	{

   331 	}

   332 

   333 void TWalkWindowTreeCalcInvalidGraphics::DestroyRegions()

   334 	{

   335 	if(iSubRegion)

   336 		{

   337 		iSubRegion->Close();

   338 		}

   339 	delete iSubRegion;

   340 	iSubRegion = NULL;	

   341 	iDirty.Clear();

   342 	}	

   343 

   344 void TWalkWindowTreeCalcInvalidGraphics::CalcInvalid(CScreen& aScreen)

   345 	{

   346 	if(aScreen.RootWindow())

   347 		{

   348 		aScreen.RootWindow()->WalkWindowTree(*this,EWalkChildren);

   349 		if(iRegion->CheckError())

   350 			{

   351 			iDirty.ForceError();

   352 			}

   353 		}

   354 	}

   355 

   356 TBool TWalkWindowTreeCalcInvalidGraphics::CreateSubRegion()

   357 	{

   358 	iSubRegion=new RWsRegion;

   359 	return iSubRegion!=NULL;

   360 	}

   361 

   362 TBool TWalkWindowTreeCalcInvalidGraphics::DoIt3(CWsWindow *aWin) 

   363 	{

   364 	if (!iDirty.CheckError() && aWin->Redraw() && aWin->Redraw()->Contains(iInvalid,aWin->VisibleRegion()))

   365 		{

   366 		STACK_REGION intersection;

   367 		intersection.Intersection(*iSubRegion,aWin->VisibleRegion());

   368 		iDirty.Union(intersection);

   369 		intersection.Close();

   370 		}

   371 	return iDirty.CheckError();

   372 	}

   373 	

   374 #if defined(_DEBUG)

   375 

   376 TBool TWalkWindowTreeCheck::DoIt(CWsWindow *aWin)

   377 	{

   378 	if (aWin->WinType()==EWinTypeRoot)

   379 		{

   380 		WS_ASSERT_DEBUG(aWin->BaseParent()==NULL, EWsPanicWindowCheck);

   381 		WS_ASSERT_DEBUG(aWin->NextSibling()==NULL, EWsPanicWindowCheck);

   382 		}

   383 	else

   384 		{

   385 		WS_ASSERT_DEBUG(aWin->WinType()==EWinTypeClient, EWsPanicWindowCheck);

   386 		}

   387 	if (aWin->BaseChild())

   388 		{

   389 		WS_ASSERT_DEBUG(aWin->BaseChild()->BaseParent()==aWin, EWsPanicWindowCheck);

   390 		}

   391 	if (aWin->NextSibling())

   392 		{

   393 		WS_ASSERT_DEBUG(aWin->NextSibling()->GetPrevSibling()==aWin, EWsPanicWindowCheck);

   394 		}

   395 	return(EFalse);

   396 	}

   397 

   398 TBool TWalkWindowTreeFindWithFlag::DoIt(CWsWindow *aWin)

   399 	{

   400 	if (aWin->iFlags & iFlag)

   401 		{

   402 		iFound = aWin;

   403 		return ETrue;

   404 		}

   405 	return EFalse;

   406 	}

   407 	

   408 #endif

   409 

   410 #include "wnredraw.h"	

   411 TWalkWindowTreeRedrawStoreSize::TWalkWindowTreeRedrawStoreSize() : iTotalSize(0)

   412 	{

   413 	}

   414 

   415 TBool TWalkWindowTreeRedrawStoreSize::DoIt(CWsWindow *aWin)

   416 	{

   417 	iTotalSize += aWin->Redraw()->SizeInBytes();

   418 	return EFalse;

   419 	}

   420 

   421 

   422 TBool TWalkWindowTreeFindByHandle::DoIt(CWsWindow *aWin)

   423 	{

   424 	if (aWin->ClientHandle() == iHandle)

   425 		{

   426 		iFound = aWin;

   427 		return ETrue;

   428 		}

   429 	return EFalse;

   430 	}

   431 

   432 TWalkWindowTreeUpdateRegions::TWalkWindowTreeUpdateRegions(CScreen & aScreen) :

   433 	iScreen(aScreen)

   434 	{

   435 	}

   436 

   437 void TWalkWindowTreeUpdateRegions::Walk()

   438 	{

   439 	STACK_REGION floatingSpriteRgn;

   440 	iScreen.SpriteManager()->CalcFloatingSpriteRgn( floatingSpriteRgn, iScreen.RootWindow()->AbsRect() );

   441 	iVisible.AddRect(iScreen.RootWindow()->AbsRect());

   442 	iTop.AddRect(iScreen.RootWindow()->AbsRect());

   443 	iRemainsOfFadableScreen.AddRect( iScreen.RootWindow()->AbsRect() );

   444 	iTop.SubRegion(floatingSpriteRgn);

   445 	iScreen.RootWindow()->WalkWindowTree(*this, EWalkChildren);

   446 	iTop.Close();

   447 	iVisible.Close();	

   448 	iRemainsOfFadableScreen.Close();

   449 	floatingSpriteRgn.Close();

   450 	}

   451 

   452 TBool TWalkWindowTreeUpdateRegions::DoIt(CWsWindow * aWin)

   453 	{

   454 	if (aWin->IsVisible() && !iVisible.IsEmpty())

   455 		{

   456 		// Calculate the region we care about for this window:

   457 		STACK_REGION newVisibleRegion;

   458 		STACK_REGION newFadableRegion;

   459 		if (aWin->WinType()==EWinTypeRoot)

   460 			{

   461 			newVisibleRegion.Copy(iVisible);

   462 			}

   463 		else

   464 			{

   465 			static_cast<CWsClientWindow *>(aWin)->SetClippedBaseArea(newVisibleRegion);

   466 			newVisibleRegion.Intersect(iVisible);

   467 			if (!aWin->IsTranslucent())

   468 				{

   469 				iVisible.SubRegion(newVisibleRegion);

   470 				}

   471 			else

   472 				{

   473 				STACK_REGION opaque;

   474 				static_cast<CWsClientWindow *>(aWin)->SetOpaqueClippedBaseArea(opaque);

   475 				iVisible.SubRegion(opaque);

   476 				opaque.Close();

   477 				}

   478 			//If the window has been faded calculate what region actually needs fading 

   479 			//(i.e. subtract what has already been faded)

   480 			if ( aWin->FadeCount() && !aWin->IsNonFading() && aWin->IsVisible()  && !iRemainsOfFadableScreen.IsEmpty() )

   481 				{

   482 				newFadableRegion.Copy( newVisibleRegion );

   483 				newFadableRegion.Intersect( iRemainsOfFadableScreen );

   484 				}

   485 			}

   486 		aWin->SetVisibleRegion(newVisibleRegion, &iTop, newFadableRegion);

   487 		iTop.SubRegion(newVisibleRegion);

   488 		iRemainsOfFadableScreen.SubRegion( newFadableRegion ); // Subtract the new faded region

   489 		newFadableRegion.Close();

   490 		newVisibleRegion.Close();

   491 		}

   492 	else

   493 		{

   494 		if (!aWin->VisibleRegion().IsEmpty())

   495 			{

   496 			aWin->ClearVisibleRegion();

   497 			}

   498 		}

   499 	return(EFalse);

   500 	}

   501 

   502 TWalkWindowTreeScheduleRedraws::TWalkWindowTreeScheduleRedraws():

   503 	iScheduleRedrawFilter( ERedrawFilterNoFilter )

   504 	{

   505 	}

   506 

   507 TWalkWindowTreeScheduleRedraws::TWalkWindowTreeScheduleRedraws( TUint32 aFilter ):

   508 	iScheduleRedrawFilter( aFilter )

   509 	{ }

   510 

   511 TBool TWalkWindowTreeScheduleRedraws::DoIt(CWsWindow * aWin)

   512 	{

   513 	if (aWin->WinType() != EWinTypeClient || static_cast<CWsClientWindow *>(aWin)->HasBeenDrawnToScreen())

   514 		{

   515 		TBool ban = (iScheduleRedrawFilter & ERedrawFilterOmitDSA) && ( aWin->IsDSAHost() );

   516 		if ( !ban )

   517 			{

   518 			aWin->Screen()->AddRedrawRegion(aWin->VisibleRegion());

   519 			}

   520 		}

   521 	return EFalse;

   522 	}

   523 

   524 TWalkWindowTreeOffsetTransparentRegions::TWalkWindowTreeOffsetTransparentRegions(const TPoint& aOffset) :

   525 	iOffset(aOffset)

   526 	{

   527 	}

   528 

   529 TBool TWalkWindowTreeOffsetTransparentRegions::DoIt(CWsWindow * aWin)

   530 	{

   531 	if (aWin != aWin->RootWindow())

   532 		static_cast<CWsClientWindow *>(aWin)->OffsetUserTransparentRegion(iOffset);

   533 	return EFalse;

   534 	}

   535 

   536 TWalkWindowTreeRecalcOpaque::TWalkWindowTreeRecalcOpaque()

   537 	{

   538 	}

   539 

   540 TBool TWalkWindowTreeRecalcOpaque::DoIt(CWsWindow * aWin)

   541 	{

   542 	if (aWin != aWin->RootWindow())

   543 		static_cast<CWsClientWindow *>(aWin)->SetUserOpaqueRegion();

   544 	return EFalse;

   545 	}

   546 

   547 TBool TWalkWindowTreeReactivateGcs::DoIt(CWsWindow *aWin)

   548 	{

   549 	if (aWin != aWin->RootWindow())

   550 		static_cast<CWsClientWindow *>(aWin)->ReactivateGcs();

   551 	return EFalse;

   552 	}

   553 

   554 TWalkWindowTreeScheduleFadeNoRedraw::TWalkWindowTreeScheduleFadeNoRedraw()

   555 	{ } // empty

   556 

   557 TBool TWalkWindowTreeScheduleFadeNoRedraw::DoIt(CWsWindow *aWin)

   558 	{

   559 	aWin->Screen()->ScheduleRegionUpdate( aWin->VisibleRegionIfValid() );

   560 	return EFalse;	

   561 	}