// 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 "windowelementset.h"

CWsWindow* CWsWindow::iAccessListRecentEnd = 0;

CWsWindow* CWsWindow::iAccessListOldestEnd = 0;

#ifndef _DEBUG

#define LOG_WINDOW_REDRAW_START(wswin)

#define LOG_WINDOW_REDRAW_END(wswin)

#define LOG_WINDOW_ANIM_REDRAW_START(wswin)

#define LOG_WINDOW_ANIM_REDRAW_END(wswin)

#define LOG_WINDOW_SPRITE_REDRAW_START(aWsWin)

#define LOG_WINDOW_SPRITE_REDRAW_END(aWsWin)

#else

#define LOG_WINDOW_REDRAW_START(wswin) LogWindowRedrawStart(wswin)

#define LOG_WINDOW_REDRAW_END(wswin) LogWindowRedrawEnd(wswin)

#define LOG_WINDOW_ANIM_REDRAW_START(wswin) LogWindowAnimRedrawStart(wswin)

#define LOG_WINDOW_ANIM_REDRAW_END(wswin) LogWindowAnimRedrawEnd(wswin)

#define LOG_WINDOW_SPRITE_REDRAW_START(wswin) LogWindowSpriteRedrawStart(wswin)

#define LOG_WINDOW_SPRITE_REDRAW_END(wswin) LogWindowSpriteRedrawEnd(wswin) 

#include "../debuglog/DEBUGLOG.H"

extern CDebugLogBase *wsDebugLog;

extern void LogRegion(const TRegion* aRegion)

    {

    TBuf<LogTBufSize> log;

    TTruncateOverflow overflow;

    TInt rectCount = (aRegion == NULL ? 0 : aRegion->Count());

    log.AppendFormat(_L("Fading region: [%d,"), &overflow, rectCount);

    if (rectCount > 0)

        {

        const TRect* rectangles = aRegion->RectangleList();

        TBuf<1> comma;

        for (TInt ii = 0; ii < rectCount; ii++)

            {

            TRect current = rectangles[ii];

            log.AppendFormat(_L("%S{{%d,%d},{%d,%d}}"), &overflow, &comma,

                             current.iTl.iX,current.iTl.iY,current.iBr.iX,current.iBr.iY);

            comma = _L(",");

            }

        }

    else

        {

        log.AppendFormat(_L("NULL"), &overflow);

        }

    log.AppendFormat(_L("]"), &overflow);

    wsDebugLog->MiscMessage(CDebugLogBase::ELogEverything, log);

    }

extern void LogFadeStart(const CWsWindow* aWsWin)

    {

    if (wsDebugLog && aWsWin->WsOwner())

        {

        _LIT(KLogDrawCommandsStart, ">> CWsRedrawMsgWindow::Fade() [%S][app %d] RWindow[%d]");

        const TDesC& clientName = aWsWin->WsOwner()->Client().FullName();

        TBuf<LogTBufSize> log;

        TTruncateOverflow overflow;

        log.AppendFormat(KLogDrawCommandsStart, &overflow, &clientName, aWsWin->WsOwner()->ConnectionHandle(), aWsWin->LogHandle());

        wsDebugLog->MiscMessage(CDebugLogBase::ELogEverything, log);

        }

    }

extern void LogFadeRegion(const TRegion* aRegion)

    {

    if (wsDebugLog)

        {

        LogRegion(aRegion);

        }

    }

extern void LogFadeEnd(const CWsWindow* aWsWin)

    {

    if (wsDebugLog && aWsWin->WsOwner())

        {

        _LIT(KLogDrawCommandsEnd, "<< CWsRedrawMsgWindow::Fade() [%S][app %d] RWindow[%d]");

        const TDesC& clientName = aWsWin->WsOwner()->Client().FullName();

        TBuf<LogTBufSize> log;

        TTruncateOverflow overflow;

        log.AppendFormat(KLogDrawCommandsEnd, &overflow, &clientName, aWsWin->WsOwner()->ConnectionHandle(), aWsWin->LogHandle());      

        wsDebugLog->MiscMessage(CDebugLogBase::ELogEverything, log);

        }

    }

static void LogWindowRedrawStart(const CWsWindow& aWsWin)

    {

    if (wsDebugLog)

         {

         TBuf<LogTBufSize> log;

         TTruncateOverflow overflow;

         if(aWsWin.Type() == WS_HANDLE_ROOT_WINDOW)

             {

             _LIT(KAnnotateWindowRedrawStart, ">> MWsDrawAnnotationObserver::WindowRedrawStart RootWindow for screen:%d");

             log.AppendFormat(KAnnotateWindowRedrawStart, &overflow, aWsWin.Screen()->ScreenNumber());

             }

         else

             {

             _LIT(KAnnotateWindowRedrawStart, ">> MWsDrawAnnotationObserver::WindowRedrawStart [%S][app %d] RWindow[%d]");

             const TDesC& clientName = aWsWin.WsOwner()->Client().FullName();

             log.AppendFormat(KAnnotateWindowRedrawStart, &overflow, &clientName, aWsWin.WsOwner()->ConnectionHandle(), aWsWin.LogHandle());

             }

         wsDebugLog->MiscMessage(CDebugLogBase::ELogEverything, log);

         }    

    }

static void LogWindowRedrawEnd(const CWsWindow& aWsWin)

    {

    if (wsDebugLog)

        {

        TBuf<LogTBufSize> log;

        TTruncateOverflow overflow;

        if(aWsWin.Type() == WS_HANDLE_ROOT_WINDOW)

            {

            _LIT(KAnnotateWindowRedrawEnd, "<< MWsDrawAnnotationObserver::WindowRedrawEnd RootWindow for screen:%d");

            log.AppendFormat(KAnnotateWindowRedrawEnd, &overflow, aWsWin.Screen()->ScreenNumber());

            }

        else

            {

            _LIT(KAnnotateWindowRedrawEnd, "<< MWsDrawAnnotationObserver::WindowRedrawEnd [%S][app %d] RWindow[%d]");

            const TDesC& clientName = aWsWin.WsOwner()->Client().FullName();

            log.AppendFormat(KAnnotateWindowRedrawEnd, &overflow, &clientName, aWsWin.WsOwner()->ConnectionHandle(), aWsWin.LogHandle());

            }

        wsDebugLog->MiscMessage(CDebugLogBase::ELogEverything, log);

        }

    }

static void LogWindowAnimRedrawStart(const CWsWindow& aWsWin)

    {

    if (wsDebugLog)

        {

        _LIT(KAnnotateWindowAnimRedrawStart, " >> MWsDrawAnnotationObserver::WindowAnimRedrawStart [%S][app %d] RWindow[%d]");

        const TDesC& clientName = aWsWin.WsOwner()->Client().FullName();

        TBuf<LogTBufSize> log;

        TTruncateOverflow overflow;

        log.AppendFormat(KAnnotateWindowAnimRedrawStart, &overflow, &clientName, aWsWin.WsOwner()->ConnectionHandle(), aWsWin.LogHandle());

        wsDebugLog->MiscMessage(CDebugLogBase::ELogEverything, log);

        }

    }

static void LogWindowAnimRedrawEnd(const CWsWindow& aWsWin)

    {

    if (wsDebugLog)

        {

        _LIT(KAnnotateWindowAnimRedrawEnd, " << MWsDrawAnnotationObserver::WindowAnimRedrawEnd [%S][app %d] RWindow[%d]");

        const TDesC& clientName = aWsWin.WsOwner()->Client().FullName();

        TBuf<LogTBufSize> log;

        TTruncateOverflow overflow;

        log.AppendFormat(KAnnotateWindowAnimRedrawEnd, &overflow, &clientName, aWsWin.WsOwner()->ConnectionHandle(), aWsWin.LogHandle());

        wsDebugLog->MiscMessage(CDebugLogBase::ELogEverything, log);

        }

    }

static void LogWindowSpriteRedrawStart(const CWsWindow& aWsWin)

    {

    if (wsDebugLog)

        {

        TBuf<LogTBufSize> log;

        TTruncateOverflow overflow;

        if(aWsWin.Type() == WS_HANDLE_ROOT_WINDOW)

            {

            _LIT(KAnnotateSpriteRedrawStart, "<< MWsDrawAnnotationObserver::WindowSpriteRedrawStart RootWindow for screen:%d");

            log.AppendFormat(KAnnotateSpriteRedrawStart, &overflow, aWsWin.Screen()->ScreenNumber());

            }

        else

            {

            _LIT(KAnnotateSpriteRedrawStart, " >> MWsDrawAnnotationObserver::WindowSpriteRedrawStart [%S][app %d] RWindow[%d]");

            const TDesC& clientName = aWsWin.WsOwner()->Client().FullName();

            log.AppendFormat(KAnnotateSpriteRedrawStart, &overflow, &clientName, aWsWin.WsOwner()->ConnectionHandle(), aWsWin.LogHandle());

            }

        wsDebugLog->MiscMessage(CDebugLogBase::ELogEverything, log);

        }

    }

static void LogWindowSpriteRedrawEnd(const CWsWindow& aWsWin)

    {

    if (wsDebugLog)

        {

        TBuf<LogTBufSize> log;

        TTruncateOverflow overflow;

        if(aWsWin.Type() == WS_HANDLE_ROOT_WINDOW)

            {

            _LIT(KAnnotateSpriteRedrawEnd, " << MWsDrawAnnotationObserver::WindowSpriteRedrawEnd RootWindow for screen:%d");

            log.AppendFormat(KAnnotateSpriteRedrawEnd, &overflow, aWsWin.Screen()->ScreenNumber());

            }

        else

            {

            _LIT(KAnnotateSpriteRedrawEnd, " << MWsDrawAnnotationObserver::WindowSpriteRedrawEnd [%S][app %d] RWindow[%d]");

            const TDesC& clientName = aWsWin.WsOwner()->Client().FullName();

            log.AppendFormat(KAnnotateSpriteRedrawEnd, &overflow, &clientName, aWsWin.WsOwner()->ConnectionHandle(), aWsWin.LogHandle());

            }

        wsDebugLog->MiscMessage(CDebugLogBase::ELogEverything, log);

        }

    }

#endif

extern void AnnotateWindowRedrawStart(const CWsWindow& aWsWin, const TRegion& aRegion)

    {

    LOG_WINDOW_REDRAW_START(aWsWin);

    MWsDrawAnnotationObserver* annoObs = aWsWin.Screen()->DrawAnnotationObserver();

    if(annoObs)

        {

        annoObs->WindowRedrawStart(aWsWin, aRegion);

        }

    }

extern void AnnotateWindowRedrawEnd(const CWsWindow& aWsWin)

    {

    LOG_WINDOW_REDRAW_END(aWsWin);

    MWsDrawAnnotationObserver* annoObs = aWsWin.Screen()->DrawAnnotationObserver();

    if(annoObs)

        {

        annoObs->WindowRedrawEnd(aWsWin);

        }

    }

extern void AnnotateWindowAnimRedrawStart(const CWsWindow& aWsWin, const CWsAnim& aAnim, const TRegion& aRegion)

    {

    LOG_WINDOW_ANIM_REDRAW_START(aWsWin);

    MWsDrawAnnotationObserver* annoObs = aWsWin.Screen()->DrawAnnotationObserver();

    if(annoObs)

        {

        annoObs->WindowAnimRedrawStart(aAnim, aRegion);

        }

    }

extern void AnnotateWindowAnimRedrawEnd(const CWsWindow& aWsWin, const CWsAnim& aAnim)

    {

    LOG_WINDOW_ANIM_REDRAW_END(aWsWin);

    MWsDrawAnnotationObserver* annoObs = aWsWin.Screen()->DrawAnnotationObserver();

    if(annoObs)

        {

        annoObs->WindowAnimRedrawEnd(aAnim);

        }

    }

extern void AnnotateSpriteRedrawStart(const CWsWindow& aWsWin, const CWsSpriteBase& aSprite, const TRegion& aRegion)

    {

    LOG_WINDOW_SPRITE_REDRAW_START(aWsWin);

    MWsDrawAnnotationObserver* annoObs = aWsWin.Screen()->DrawAnnotationObserver();

    if(annoObs)

        {

        annoObs->SpriteRedrawStart(aSprite, aRegion);

        }   

    }

extern void AnnotateSpriteRedrawEnd(const CWsWindow& aWsWin, const CWsSpriteBase& aSprite)

    {

    LOG_WINDOW_SPRITE_REDRAW_END(aWsWin);

    MWsDrawAnnotationObserver* annoObs = aWsWin.Screen()->DrawAnnotationObserver();

    if(annoObs)

        {

        annoObs->SpriteRedrawEnd(aSprite);

        }

    }

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

	iFlags(EFlagHidden),

	iDSAs(_FOFF(CWsDirectScreenAccess,iMultipleDSALink))

	{

	}

CWsWindow::~CWsWindow()

	{

	//2-phase destruction, Shutdown() is called before destructor

	iFadableRegion.Reset();

	iQuickFadeRegion.Reset();

	}

void CWsWindow::Fade(MWsGraphicsContext * aGc, const TRegion& aRegion)

	{

	if ( NULL != iRedraw )

		{

		iRedraw->Fade( aGc, aRegion );

		}

	}

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.Reset();

	iScheduledRegion.Reset();

	iScheduledSpriteRegion.Reset();

	iDirtyWindowRegion.Reset();

	iDirtySpriteRegion.Reset();

	AbortAllDSAs();

	CWsWindowBase::Shutdown();

	SetPointerCursor(NULL);

	delete iRedraw;

	iRedraw=NULL;

	Screen()->RemoveFromScheduledList(this);

	Screen()->RemoveFromTimedDrawList(this);

	Screen()->RemoveFromQuickFadeList(this);

	}

//

// Region and invalid area functions //

//

TRect CWsWindow::FullRect() const

	{

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

	}

//

// Normal regions //

//

void CWsWindow::AreaCovered(TRegion &aRegion)

	{

	aRegion.Copy(WindowArea());

	}

void CWsWindow::SetNonFading(TBool aNonFade)

	{

	const TUint oldFlags = iFlags;

	if (aNonFade)

		iFlags|=EFlagNonFadingWindow;

	else

		iFlags&=(~EFlagNonFadingWindow);

 	//Schedule window for quickfade if non-fading flag is changed	

	if (!Screen()->ChangeTracking() &&  CWsTop::IsFadeEnabled() && (oldFlags != iFlags) ) 

		{

		Screen()->AcceptFadeRequest(this, !aNonFade);

		}

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

	if (windowTreeObserver && oldFlags!=iFlags)

		windowTreeObserver->FlagChanged(*this, MWsWindowTreeObserver::ENonFading, aNonFade); 

	}

TPoint CWsWindow::InquireOffset(TUint32 aHandle) const

	{

	CWsWindowBase *win2;

	iWsOwner->HandleToWindow(aHandle,&win2);

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

	}

TDisplayMode CWsWindow::SetRequiredDisplayModeL(TDisplayMode)

	{

	return DisplayMode();

	}

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);

	TDisplayMode displayMode = DisplayMode();

	aBuf.AppendFormat(KStatusString3,(TInt&)displayMode);

	if (!IsVisible())

		aBuf.Append(KStatusInvisible);

	}

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

	{

	return(NULL);

	}

TInt CWsWindow::AddDSA(CWsDirectScreenAccess& aDirect)

	{

	TInt error = KErrNone;

	if (iDSAs.IsEmpty() && !aDirect.IsRegionTrackingOnly())

		{

		TRAP(error,iRedraw->SetDsaElementL());

		}

	if (!error)

		{

		iDSAs.AddLast(aDirect);

		}

	return error;

	}

void CWsWindow::RemoveDSA(CWsDirectScreenAccess& aDirect)

	{

	iDSAs.Remove(aDirect);

	}

void CWsWindow::AbortAllDSAs()

	{

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

	}

void CWsWindow::PossibleVisibilityChangedEvent(TBool aForceSend)

	{

	// notify plugin

	//

	// coverity[unchecked_value]

	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 TRegion& aRegion)

	{

	iScheduledRegion.Copy(aRegion);

	return !iScheduledRegion.CheckError();

	}