// Copyright (c) 1995-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:

 // Root window sub-class of CWsWindow

 // 

 //

 #include "rootwin.h"

 #include <e32std.h>

 #include <graphics/wsscreendevice.h>

 #include "server.h"

 #include "windowgroup.h"

 #include "walkwindowtree.h"

 #include "wstop.h"

 #include "ScrDev.H"

 #include "panics.h"

 #include "inifile.h"

 #include "EVENT.H"

 _LIT(KNoBlank,"NOBLANKSCREEN");

 _LIT(KDefaultBackgroundColor,"BACKGROUNDCOLOR");

 _LIT(KDefaultBackgroundAlpha,"BACKGROUNDALPHA");

 _LIT(KRootWinDefaultBackgroundColor,"ROOTBACKGROUNDCOLOR");

 CWsRootWindow::CWsRootWindow(CWsClient* aOwner, CScreen* aScreen) : CWsWindow(aOwner,WS_HANDLE_ROOT_WINDOW,aScreen)

 	{

 	iWinType=EWinTypeRoot;

 	}

 CWsRootWindow::~CWsRootWindow()

 	{

 	if (Screen() && (iBaseWinFlags&EBaseWinNodeCreated))

 		{

 		MWsWindowTreeObserver* const windowTreeObserver = Screen()->WindowTreeObserver();

 		if (windowTreeObserver)

 			{

 			windowTreeObserver->NodeReleased(*this);

 			iBaseWinFlags &= ~EBaseWinNodeCreated;

 			}

 		}

 	Shutdown();

 	}

 void CWsRootWindow::ConstructL()

 	{

 	CWsWindow::Construct();

 	iParent=NULL;

 	iSibling=NULL;

 	iChild=NULL;

 	iClientHandle=NULL;

 	iAbs.Resize(iScreen->SizeInPixels());

 	iRel=iAbs;

 	iFlags=EFlagPointerCaptured;

 	iPointerFilter=EPointerFilterEnterExit|EPointerFilterMove|EPointerFilterDrag;

 	iArea.AddRect(iAbs);

 	iRedraw=new(ELeave) CWsBlankWindow(this);

 	iRedraw->ConstructL();

 	TInt backgroundcolor;

 	if(!WsIniFile->FindVar(KDefaultBackgroundColor,backgroundcolor))

 		backgroundcolor = KRgbWhite.Value();

 	TInt backgroundalpha;

 	if(!WsIniFile->FindVar(KDefaultBackgroundAlpha,backgroundalpha))

 		backgroundalpha = 0xFF;	

 	iDefaultBackgroundColor = TRgb(backgroundcolor,backgroundalpha);

 	if (WsIniFile->FindVar(KNoBlank))

 		BlankRedraw()->SetBackgroundClear();

 	else

 		{

 		if (WsIniFile->FindVar(KRootWinDefaultBackgroundColor,backgroundcolor))

 			SetColor(TRgb(backgroundcolor,backgroundalpha));

 		else

 			SetColor(iDefaultBackgroundColor);

 		}

 	MWsWindowTreeObserver* const windowTreeObserver = Screen()->WindowTreeObserver();

 	if (windowTreeObserver)

 		{

 		windowTreeObserver->NodeCreated(*this, NULL);

 		iBaseWinFlags |= EBaseWinNodeCreated;

 		}

 	}

 void CWsRootWindow::SetColor(TRgb aColor)

 	{

 	BlankRedraw()->SetColor(aColor);

 	}

 void CWsRootWindow::SetColorIfClear()

 	{

 	if (!BlankRedraw()->IsBackgroundColor())

 		SetColor(iDefaultBackgroundColor);

 	}

 const CWsWindow *CWsRootWindow::PointerWindow(const TPoint &aInPos,TPoint *aOutPos, TPoint *aParentPos,

 					const CWsWindow *aGrabWin, const CWsWindow *&aOriginalWinItIsIn, const CWsWindowGroup *aForceInGroup)

 //

 // For aInPos (a global point on screen) find which window it is in, starting the search from 'this'.

 // aOutPos is set to be aInPos adjusted relative to the top left of the result window.

 // If the pointer is not in any of the searched windows the result is returned as though it was in 'this'

 // even though it may actually be oustside the bounds of this.

 //

 // If aForceInGroup==NULL search all groups otherwise only search it only

 //

 	{

 	aOriginalWinItIsIn=this;

 	const CWsWindowGroup *group;

 	const CWsWindowGroup *winItIsInGroup=aForceInGroup;

 //

 // First determine owner of the window the event is in regardless of any capture

 // This is so we can decide whether the capture affects this case or not

 //

 	for(group=(aForceInGroup ? aForceInGroup:Child());group!=NULL;group=group->NextSibling())

 		{

 		CWsClientWindow *win=group->Child();

 		while(win!=NULL)

 			{

 			const TRegion *baseArea=win->BaseArea();

 			if (win->IsVisible() && baseArea->Contains(aInPos))

 				{

 				aOriginalWinItIsIn=win;

 				winItIsInGroup=group;

 				win=win->Child();

 				}

 			else

 				win=win->NextSibling();

 			}

 		if (aOriginalWinItIsIn!=this || aForceInGroup!=NULL)

 			break;

 		}

 //

 // Then try again taking note of any pointer capture or grab

 //

 	const CWsWindow *winItIsIn;

 	if (aGrabWin!=NULL)

 		winItIsIn=aGrabWin;

 	else

 		{

 		winItIsIn=this;

 		for(group=(aForceInGroup ? aForceInGroup:Child());group!=NULL;group=group->NextSibling())

 			{

 			CWsClientWindow *win=group->Child();

 			while(win!=NULL)

 				{

 				const TRegion *baseArea=win->BaseArea();

 				const TBool underTheSameGroup=winItIsInGroup==group;

 				if (win->IsVisible() && 

 					((win->iFlags&EFlagPointerCaptured && 

 					 ((!underTheSameGroup && win->iFlags&EFlagPointerCaptureAllGroups) || 

 					  (winItIsInGroup==NULL && group==CWsTop::FocusWindowGroup()) || 

 					  (underTheSameGroup && win->iPointerCapturePriority>=aOriginalWinItIsIn->iPointerCapturePriority)))

 					   || baseArea->Contains(aInPos)))

 					{

 				 	winItIsIn=win;

 					win=win->Child();

 					}

 				else

 					win=win->NextSibling();

 				}

 			if (winItIsIn!=this || aForceInGroup!=NULL)

 				break;

 			}

 		}

 	if (aOutPos!=NULL)

 		{

 		*aOutPos=aInPos-winItIsIn->iOrigin;

 		}

 	if (aParentPos!=NULL)

 		{

 		const CWsWindowBase *win=winItIsIn->BaseParent();

 		if (win==NULL)

 			win=winItIsIn;

 		*aParentPos=aInPos-win->Origin();

 		}

 	return(winItIsIn);

 	}

 void CWsRootWindow::GenerateWindowRegion(RWsRegion &aRegion) const

 	{

 	aRegion.Clear();

 	aRegion.AddRect(iAbs);

 	if (iChild)

 		{

 		for(CWsTopClientWindow *win=FirstTopClientWindow();aRegion.Count()>0 && win!=NULL;win=win->NextSiblingMultiParent())

 			{

 			if (win->IsVisible())

 				aRegion.SubRegion(*win->BaseArea());

 			}

 		}

 	}

 void CWsRootWindow::CommandL(TInt , const TAny *)

 	{

 	WS_PANIC_ALWAYS(EWsPanicRootCommand);

 	}

 void CWsRootWindow::InvalidateWholeScreen()

 	{

 	RWsRegion screen(iAbs);

 	Invalidate(&screen);

 	screen.Close();

 	}

 void CWsRootWindow::Invalidate(RWsRegion* aRegion)

 	{

 	iScreen->AddRedrawRegion(*aRegion);

 	}

 void CWsRootWindow::AdjustCoordsDueToRotation()

 	{

 	iArea.Clear();

 	iAbs=iScreen->DrawableArea();

 	iRel=iAbs;

 	iArea.AddRect(iAbs);

 	iOrigin=iAbs.iTl;

 	for(CWsTopClientWindow *win=FirstTopClientWindow();win!=NULL;win=win->NextSiblingMultiParent())

 		{

 		win->RecalcChildAbs(NULL);

 		}

 	}

 void CWsRootWindow::ClearDisplay()

 	{

 	MWsScreenDevice *sd=static_cast<MWsScreenDevice*>(iScreen->ResolveObjectInterface(KMWsScreenDevice));

 	WS_ASSERT_ALWAYS(sd, EWsPanicScreenDeviceMissing); 

 	sd->ClearDisplay(BackColor());	

 	}

 void CWsRootWindow::SetSystemFaded(TBool aFaded, TUint8 aBlackMap, TUint8 aWhiteMap)

 	{

 	WS_ASSERT_DEBUG(Screen(),EWsPanicNoScreen);

 	TBool stateChanged = EFalse; //will be set to true if one or more windows change fade state.

 	for(CWsWindowGroup* win=Child();win!=NULL;win=win->NextSibling())

 		{

 		TWalkWindowTreeSetSystemFaded wwt(aFaded, win, aBlackMap, aWhiteMap, stateChanged);

 		win->WalkWindowTree(wwt,EWalkChildren);

 		}

 	MWsWindowTreeObserver* windowTreeObserver = Screen()->WindowTreeObserver();

 	if(windowTreeObserver && stateChanged)

 		{

 		windowTreeObserver->FadeAllChildren(*this, aFaded);

 		}

 	}

 CWsWindowGroup* CWsRootWindow::WindowGroup(TInt aWindowGroup)

 	{

 	CWsWindowBase* group=iChild;

 	while (aWindowGroup-->0 && group)

 		group=group->NextSibling();

 	return static_cast<CWsWindowGroup*>(group);

 	}

 CWsTopClientWindow *CWsRootWindow::FirstTopClientWindow() const

 	{

 	CWsWindowGroup* group;

 	for(group=Child();group && group->Child()==NULL;group=group->NextSibling())

 		{}

 	return(group?group->Child():NULL);

 	}

 const TRegion& CWsRootWindow::WindowArea() const

 	{

 	return iArea;

 	}

 void CWsRootWindow::SendState(MWsWindowTreeObserver& aWindowTreeObserver) const

 	{

 	aWindowTreeObserver.NodeCreated(*this, NULL);

 	}

 /** @see MWsWindowTreeNode */

 const MWsWindow* CWsRootWindow::Window() const

 	{

 	return NULL;

 	}