// Copyright (c) 1994-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// Window functions

// 

//

#include "server.h"

#include "rootwin.h"

#include "window.h"

#include "walkwindowtree.h"

#include "wstop.h"

#include "ScrDev.H"

#include "EVENT.H"

#include "ANIM.H"

#include "Direct.H"

#include "panics.h"

#include "backedupwindow.h"

#include "wstypes.h"

#include "offscreenbitmap.h"

CWsWindow* CWsWindow::iAccessListRecentEnd = 0;

CWsWindow* CWsWindow::iAccessListOldestEnd = 0;

CWsWindow::CWsWindow(CWsClient* aOwner,WH_HANDLES aType, CScreen* aScreen) : CWsWindowBase(aOwner,aType,aScreen),

	iFlags(EFlagHidden),

	 iDSAs(_FOFF(CWsDirectScreenAccess,iMultipleDSALink))

	{

	}

CWsWindow::~CWsWindow()

	{

	iFadableRegion.Close();

	}

void CWsWindow::Construct()

	{

	InsertIntoAccessListOldestEnd();

	}

void CWsWindow::Shutdown()

	{

	TWindowServerEvent::NotifyDrawer(TWservCrEvent(TWservCrEvent::EWindowClosing, 0, 0, this));

	RemoveFromAccessList();	

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

	iVisibleRegion.Close();

	iScheduledRegion.Close();

	AbortAllDSAs();

	CWsWindowBase::Shutdown();

	SetPointerCursor(NULL);

	delete iRedraw;

	}

//

// Region and invalid area functions //

//

TRect CWsWindow::FullRect() const

	{

	return(TRect(iOrigin,iRel.Size()));

	}

//

// Normal regions //

//

void CWsWindow::SetNonFading(TBool aNonFade)

	{

	if (aNonFade)

		iFlags|=EFlagNonFadingWindow;

	else

		iFlags&=(~EFlagNonFadingWindow);

	}

TPoint CWsWindow::InquireOffset(TUint32 aHandle) const

	{

	CWsWindowBase *win2;

	iWsOwner->HandleToWindow(aHandle,&win2);

	return(iOrigin-win2->Origin());

	}

TDisplayMode CWsWindow::DisplayMode() const

	{

	return iScreen->DisplayMode();

	}

void CWsWindow::StatusDump(TDes &aBuf)

	{

	_LIT(KStatusString1,"CWsWindow[0x%x]RWindow[0x%x,%d],Pos(%d,%d),Size(%d,%d)");

	_LIT(KStatusString3,",Mode=%d");

	_LIT(KStatusInvisible,",Inv");

	aBuf.AppendFormat(KStatusString1,this,iClientHandle,LogHandle(),iRel.iTl.iX,iRel.iTl.iY,Size().iWidth,Size().iHeight);

	aBuf.AppendFormat(KStatusString3,(TInt)iScreen->DisplayMode());

	if (!IsVisible())

		aBuf.Append(KStatusInvisible);

	}

TDblQue<TPointerKeyList> *CWsWindow::PointerKeyList() const

	{

	return(NULL);

	}

void CWsWindow::AbortAllDSAs()

	{

	iScreen->AbortDSAs(RDirectScreenAccess::ETerminateRegion,iDSAs);

	}

void CWsWindow::PossibleVisibilityChangedEvent(TBool aForceSend)

	{

	// notify plugin

	//

	TWservCrEvent crEvent(TWservCrEvent::EWindowVisibilityChanged, HasBeenDrawnToScreen(), IsVisible()? &iVisibleRegion : NULL, this);

	TWindowServerEvent::NotifyDrawer(crEvent);

	if (!(iFlags & EFlagGeneratesVisibilityEvents))

		return;

	if (!IsVisible())

		{

		goto notvisible;

		}

	if (iVisibleRegion.Count() == 0)

		{

		goto notvisible;

		}

		{// braces here to avoid gccxml error

		TInt visibleArea = 0;

		TInt count = iVisibleRegion.Count();

		TInt ii;

		for (ii = 0; ii < count; ii++)

			{

			visibleArea+= iVisibleRegion[ii].Width() * iVisibleRegion[ii].Height();

			}

		const TRegion* baseRegion = (static_cast<CWsClientWindow*>(this))->BaseArea();

		TInt baseArea = 0;

		count = baseRegion->Count();

		for (ii = 0; ii < count; ii++)

			{

			const TRect& rect = (*baseRegion)[ii];

			baseArea+= rect.Width() * rect.Height();

			}

		if (visibleArea == baseArea)

			{

			goto fullyvisible;

			}

		else

			{

			goto partiallyvisible;

			}

		}

fullyvisible:

	if (aForceSend || !(iFlags & EFlagNotCantBeSeen) || !(iFlags & EFlagCanBeSeen))

		{

		iFlags |= (EFlagCanBeSeen | EFlagNotCantBeSeen);

		TWindowServerEvent::SendVisibilityChangedEvents(this, TWsVisibilityChangedEvent::EPartiallyVisible | TWsVisibilityChangedEvent::EFullyVisible);

		// we have to set EPartiallyVisible too for compatibility reasons

		}

	return;

partiallyvisible:

	if (aForceSend || !(iFlags & EFlagCanBeSeen) || (iFlags & EFlagNotCantBeSeen))

		{

		iFlags |= EFlagCanBeSeen;

		iFlags &= ~EFlagNotCantBeSeen;

		TWindowServerEvent::SendVisibilityChangedEvents(this, TWsVisibilityChangedEvent::EPartiallyVisible);

		}

	return;

notvisible:

	if (aForceSend || (iFlags & EFlagCanBeSeen) || (iFlags & EFlagNotCantBeSeen))

		{

		iFlags &= ~(EFlagCanBeSeen | EFlagNotCantBeSeen);

		TWindowServerEvent::SendVisibilityChangedEvents(this, TWsVisibilityChangedEvent::ENotVisible);

		}

	return;

	}

TPoint CWsWindow::Origin() const

	{

	return iOrigin;

	}

TRect CWsWindow::AbsRect() const

	{

	return iAbs;

	}

TSize CWsWindow::Size() const

	{

	return iRel.Size();

	}

TBool CWsWindow::SetScheduledRegion(const RWsRegion& aRegion)

	{

	iScheduledRegion.Copy(aRegion);

	return !iScheduledRegion.CheckError();

	}

void CWsWindow::ClearScheduledRegion()

	{

	iScheduledRegion.Clear();

	}

void CWsWindow::SetFadeBehind(TBool aFade)

	{

	if (aFade != ((iFlags & EFlagFadeBehind) != 0))

		{

		iFlags ^= EFlagFadeBehind;

		}

	}

void CWsWindow::FocusChanged(TBool aNewFocusState)

	{

	TRAPD(err,FocusChangedL(aNewFocusState));

	if (err!=KErrNone)

		OwnerPanic(EWservPanicAnimLeave);

	}

void CWsWindow::FocusChangedL(TBool aNewFocusState)

	{

	for (CWsAnim * anim = iAnimList; anim; anim = anim->Next())

		{

		anim->FocusChanged(aNewFocusState);

		}

	}

// Moves a window to the recent end of the accessed list

void CWsWindow::Accessed()

	{

	WS_ASSERT_DEBUG(iAccessListRecentEnd && iAccessListOldestEnd, EWsPanicAccessList);

	RemoveFromAccessList();	

	InsertIntoAccessListRecentEnd();

	}

void CWsWindow::InsertIntoAccessListOldestEnd()

	{

	iAccessListPrev = 0;

	iAccessListNext = iAccessListOldestEnd;

	if (iAccessListNext)

		iAccessListNext->iAccessListPrev = this;

	iAccessListOldestEnd = this;

	if (!iAccessListRecentEnd)

		iAccessListRecentEnd = this;

	}

void CWsWindow::InsertIntoAccessListRecentEnd()

	{

	iAccessListNext = 0;

	iAccessListPrev = iAccessListRecentEnd;

	if (iAccessListPrev)

		iAccessListPrev->iAccessListNext = this;

	iAccessListRecentEnd = this;

	if (!iAccessListOldestEnd)

		iAccessListOldestEnd = this;

	}

void CWsWindow::RemoveFromAccessList()

	{

	if (iAccessListOldestEnd == this)

		iAccessListOldestEnd = iAccessListNext;

	if (iAccessListRecentEnd == this)

		iAccessListRecentEnd = iAccessListPrev;

	if (iAccessListPrev)

		iAccessListPrev->iAccessListNext = iAccessListNext;

	if (iAccessListNext)

		iAccessListNext->iAccessListPrev = iAccessListPrev;

	}

TBool CWsWindow::ReleaseMemory(MWsMemoryRelease::TMemoryReleaseLevel aLevel)

	{

	for (CWsWindow * access = iAccessListOldestEnd; access; access = access->iAccessListNext)

		{

		if(access->Redraw())

			{

			if (access->Redraw()->ReleaseMemory(aLevel))

				return ETrue;

			}

		}

	return EFalse;

	}

const TRegion& CWsWindow::VisibleRegion() const

	{

	return(iVisibleRegion);

	}

TBool CWsWindow::IsDSAHost() const

	{

	TBool res = EFalse; 

	if ( !iDSAs.IsEmpty() )

		{

		TSglQueIter<CWsDirectScreenAccess> iter( (TSglQueBase&)iDSAs );

		iter.SetToFirst();

		CWsDirectScreenAccess* dsa;

		while ( (dsa = iter++) != NULL && !res )

			{

			res = dsa->IsVisible() || dsa->IsSyncTimeoutPending();

			}

		}

	return res;

	}

void CWsWindow::ResetVisibleRegion()

	{

	if (!iVisibleRegion.IsEmpty())

		{

		iVisibleRegion.Clear();

		}

	iFadableRegion.Clear();

	}

void CWsWindow::SetVisibleRegion(const TRegion& aNewRegion, const TRegion* aTop, TRegion& aNewFadableRegion)

	{

	STACK_REGION difference;

	TBool diffs = EFalse;

	difference.Copy(iVisibleRegion);

	difference.SubRegion(aNewRegion);

	if (!difference.IsEmpty())

		{

		diffs = ETrue;

		if (IsTranslucent())

			{

			// Andy - If this is a client window (what else could it be) we can also subtract the

			// user defined opaque region before doing this:

			iScreen->AddRedrawRegion(difference, EFalse);

			}

		}

	difference.Copy(aNewRegion);

	if (HasBeenDrawnToScreen())

		{

		difference.SubRegion(iVisibleRegion);

		}

	if (!difference.IsEmpty())

		{

		diffs = ETrue;

		STACK_REGION topDiff;

		topDiff.Copy(difference);

		WS_ASSERT_DEBUG(aTop,EWsPanicRegion);

		topDiff.Intersect(*aTop);

		difference.SubRegion(topDiff);

		iScreen->AddRedrawRegion(topDiff, EFalse, ERedrawTopOnly);

		iScreen->AddRedrawRegion(difference, EFalse, ERedrawAll);

		topDiff.Close();

		}

	difference.Close();

	AbortDsaIfRequired(aNewRegion, aTop);

	if (diffs)

		{

		ResetVisibleRegion();

		iVisibleRegion.Copy(aNewRegion);

		PossibleVisibilityChangedEvent(EFalse);

		}

	iFadableRegion.Copy( aNewFadableRegion );

	// Just because the visible region (screen coordinates) didn't change doesn't

	// mean the invalid region (window coordinates) didn't change, so we always call this.

	iRedraw->VisibleRegionChange();

	}

void CWsWindow::ClearVisibleRegion()

	{

	AbortAllDSAs();         

	iScreen->AddRedrawRegion(VisibleRegion(), EFalse);

	ResetVisibleRegion();

	PossibleVisibilityChangedEvent(EFalse);

	iFlags &= ~EFlagDrawnToScreen;

	}

void CWsWindow::AbortDsaIfRequired(const TRegion& aNewRegion, const TRegion* aTop)

	{

	if (!iDSAs.IsEmpty())

		{

		// If the top visible region of this window has changed, DSA clients may need

		// to be sent a DSA abort, as they may be drawing to a different region

		STACK_REGION newTopVisible;

		newTopVisible.Copy(aNewRegion); // new visible region

		if (aTop!=NULL)

			{

			newTopVisible.Intersect(*aTop); // area of new visible region not obscured by any other opaque or translucent windows

			}

		// Build a list of DSA clients that need to be sent a DSA abort

		TSglQue<CWsDirectScreenAccess> dsaList(_FOFF(CWsDirectScreenAccess,iAbortLink));

		TSglQueIter<CWsDirectScreenAccess> iter(iDSAs);

		CWsDirectScreenAccess* dsa;

		while ((dsa=iter++)!=NULL)

			{

			if (dsa->IsAbortRequired(newTopVisible))

				{

				dsaList.AddLast(*dsa);

				}

			}

		if (!dsaList.IsEmpty())

			{

			iScreen->AbortDSAs(RDirectScreenAccess::ETerminateRegion, dsaList);

			}

		newTopVisible.Close();

		}

	}

const TRegion* CWsWindow::VisibleRegionIfValid() const

	{

	return iVisibleRegion.CheckError() ? NULL : &iVisibleRegion;

	}

TBool CWsWindow::ReadyToDraw() const

	{

	return iRedraw->ReadyToDraw();

	}

/**

This function draws the region specified

Andy - I would be happier if no region was specified here - the GC should incorporate that information

*/

void CWsWindow::Render(CFbsBitGc * aGc, const TRegion& aRegion)

	{

	WS_ASSERT_DEBUG(IsVisible() || (WinType() == EWinTypeRoot), EWsPanicScheduledRedraw);

	Accessed();

	iFlags |= EFlagDrawnToScreen;

	iRedraw->PreDrawWindow(aGc, aRegion);

	iRedraw->DrawWindow();

	iRedraw->PostDrawWindow(aGc);

	}

void CWsWindow::SetNextScheduled(CWsWindow * aWin)

	{

	iNextScheduled = aWin;

	}

CWsWindow * CWsWindow::NextScheduled()  const

	{

	return iNextScheduled;

	}

void CWsWindow::AddSprite(CWsSpriteBase * aSprite)

	{

	aSprite->SetNext(iSpriteList);

	iSpriteList = aSprite;

	}

void CWsWindow::RemoveSprite(CWsSpriteBase * aSprite)

	{

	if (aSprite == iSpriteList)

		{

		iSpriteList = aSprite->Next();

		}

	else

		{

		for (CWsSpriteBase * sprite = iSpriteList; sprite; sprite = sprite->Next())

			{

			if (sprite->Next() == aSprite)

				{

				sprite->SetNext(aSprite->Next());

				}

			}

		}

	aSprite->SetNext(0);

	}

void CWsWindow::DeactivateAllSprites()

	{

	CWsSpriteBase * current = iSpriteList;

	while (current)

		{

		CWsSpriteBase * next = current->Next();

		current->Deactivate();

		current = next;

		}

	}

void CWsWindow::ClipRectToViewport(TRect& aRect) const

	{

	const CWsWindowBase * win = this;

	while (win)

		{

		if (win->WinType() != EWinTypeGroup)

			{

			aRect.Intersection(win->AbsRect());

			}

		win = win->BaseParent();

		}

	}

const TRegion& CWsWindow::FadableRegion() const

	{

	return iFadableRegion;

	}

/**

MWsWindow

*/

MWsWindow * CWsWindow::FindChildByHandle(TUint32 aHandle)

	{

	TWalkWindowTreeFindByHandle wwt(aHandle);

	WalkWindowTree(wwt, EWalkChildren);

	return wwt.Found();

	}

TUint32 CWsWindow::Handle() const

	{

	return ClientHandle();

	}

MWsScreen * CWsWindow::WsScreen() const

	{

	return iScreen;