// Copyright (c) 1996-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 server redraw queue handling
//
#include <e32std.h>
#include "server.h"
#include "rootwin.h"
#include "windowgroup.h"
#include "walkwindowtree.h"
#include "EVQUEUE.H"
#include "panics.h"
#include "wstop.h"
#include "wstraces.h"

const TInt KGranularity = 10;

void TWsRedrawEvent::SetHandle(TUint aHandle)
	{
	iHandle=aHandle;
	}

void TWsRedrawEvent::SetRect(TRect aRect)
	{
	iRect=aRect;
	}

TWsRedrawEvent CRedrawQueue::iNullRedrawEvent;

CRedrawQueue::CRedrawQueue(CWsClient *aOwner) : CEventBase(aOwner)
	{
	__DECLARE_NAME(_S("CRedrawQueue"));
	}

void CRedrawQueue::ConstructL()
	{
	iRedrawTrigger=EFalse;
	iRedraws=new(ELeave) CArrayFixSeg<TRedraw>(KGranularity);
	iKeyPriority=new(ELeave) TKeyArrayFix(_FOFF(TRedraw,iPriority),ECmpTUint32);
	iKeyWindow=new(ELeave) TKeyArrayFix(_FOFF(TRedraw,iRedraw),ECmpTUint32);
	Mem::FillZ(&iNullRedrawEvent,sizeof(iNullRedrawEvent));
	}

CRedrawQueue::~CRedrawQueue()
	{
	delete iRedraws;
	delete iKeyPriority;
	delete iKeyWindow;
	}

void CRedrawQueue::ReCalcOrder()
	{
	const TInt redrawsCount=iRedraws->Count();
	for(TInt index=0;index<redrawsCount;index++)
		{
		TRedraw *redraw=&iRedraws->At(index);
		redraw->iPriority=static_cast<CWsClientWindow*>(redraw->iRedraw->WsWin())->RedrawPriority();
		}
	iRedraws->Sort(*iKeyPriority);
	}

void CRedrawQueue::AddInvalid(CWsWindowRedraw *aRedrawWin) 
//
// Add a window to the update list.
//
	{
	TInt index;
	TRedraw redraw;

	redraw.iRedraw=aRedrawWin;
	if (iRedraws->Find(redraw,*iKeyWindow,index)!=0)
		{
		redraw.iPriority=static_cast<CWsClientWindow*>(aRedrawWin->WsWin())->RedrawPriority();
		TRAPD(err,iRedraws->InsertIsqAllowDuplicatesL(redraw,*iKeyPriority));
		if (err!=KErrNone)
			{
			WS_ASSERT_DEBUG(err==KErrNoMemory,EWsPanicRedrawQueueError);
			iAllocError=ETrue;
			}
		iRedrawTrigger=ETrue;
		}
	}

void CRedrawQueue::DeleteFromQueue(TInt aIndex)
	{
	iRedraws->Delete(aIndex,1);
	
	//We are certain we will need iRedraws again, so it would be silly to compress away the last KGranularity slots.
	const TInt count = iRedraws->Count();
	if((count >= KGranularity) && (count % KGranularity == 0))
		{
		iRedraws->Compress();
		}
	}

void CRedrawQueue::RemoveInvalid(CWsWindowRedraw *aRedrawWin)
//
// remove the window from the invalid window list.
// harmless to call if the window is not in the list.
//
	{
	TInt index;
	TRedraw redraw;

	redraw.iRedraw=aRedrawWin;
	redraw.iPriority=0;
	if ((iRedraws->Find(redraw,*iKeyWindow,index))==KErrNone)
		DeleteFromQueue(index);
	}

TBool CRedrawQueue::TriggerRedraw()
//
// Trigger any pending redraw messages in the queue
// Returns ETrue if a redraw was sent, EFalse if not.
//
	{
	WS_TRACE_SERVER_TRIGGERREDRAW();	
	TBool ret=EFalse;
	if (iRedrawTrigger)
		{
		iRedrawTrigger=EFalse;
		if (!iEventMsg.IsNull() && (iRedraws->Count()>0 || iAllocError))
			{
			SignalEvent();
			ret=ETrue;
			}
		}
	return(ret);
	}

void CRedrawQueue::EventReady(const RMessagePtr2& aEventMsg)
//
// Queue a read of an event from the queue
//
	{
	CEventBase::EventReady(aEventMsg);
	iRedrawTrigger=ETrue;
	TriggerRedraw();
	}

TBool CRedrawQueue::FindOutstandingRedrawEvent(CWsWindowRedraw& aRedraw, TWsRedrawEvent& aEvent)
	{
	TRect rect;
	if (aRedraw.GetRedrawRect(rect))
		{
		aEvent.SetRect(rect);
		aEvent.SetHandle(aRedraw.WsWin()->ClientHandle());
		CEventBase::GetData(&aEvent,sizeof(aEvent));
		return ETrue;
		}
	return EFalse;
	}

TBool CRedrawQueue::FindWindowNeedingRedrawEvent(TWsRedrawEvent& aEvent)
	{
#if defined(_DEBUG)
	CWsWindowRedraw* previousRedraw = NULL;
#endif
	// search all screens
	TInt invalidWindows = 0;
	for (TInt screenNo = 0; screenNo < CWsTop::NumberOfScreens(); ++screenNo)
		{
		CWsRootWindow* rootWindow = CWsTop::Screen(screenNo)->RootWindow();
		for (CWsWindowGroup *groupWin = rootWindow->Child(); groupWin; groupWin = groupWin->NextSibling())
			{
			if (groupWin->WsOwner() == iWsOwner)
				{
				CWsWindowRedraw* redrawWin = NULL;
				// use a window tree walk that can be resumed to find windows with an invalid region
				TResumableWalkWindowTreeFindInvalid wwt(&redrawWin);
				groupWin->WalkWindowTree(wwt, EWalkChildren, EFalse);
				while (redrawWin != NULL)
					{
					WS_ASSERT_DEBUG(redrawWin != previousRedraw, EWsPanicRedrawQueueError);
					// (the window may not actually need the client to redraw it, e.g. a CWsBlankWindow can redraw itself)
					if (FindOutstandingRedrawEvent(*redrawWin, aEvent))
						{
						return ETrue;
						}
					else
						{ // continue the Tree Walk
#if defined(_DEBUG)
						previousRedraw = redrawWin;
#endif
						if (redrawWin->NeedsRedraw())
							{ // needs to be redrawn later?
							++invalidWindows;
							}
						redrawWin = NULL;
						groupWin->WalkWindowTree(wwt, EWalkChildren, ETrue);
						}
					}
				}
			}
		}

	if (invalidWindows == 0)
		{ // error recovery is complete
		iAllocError = 0;
		}
	return EFalse;
	}

void CRedrawQueue::GetData()
//
// If there is an outstanding redraw event in the queue, reply with it's data
//
	{
	CWsWindowRedraw *redraw;
	TWsRedrawEvent event;

	while (iRedraws->Count()>0)
		{
		redraw=(*iRedraws)[0].iRedraw;
		if (FindOutstandingRedrawEvent(*redraw,event))
			{
			return;
			}
		TInt toDelete=0;
		if (redraw!=(*iRedraws)[0].iRedraw)
			{		//In low memory conditions calls to FindOutstandingRedrawEvent can cause extra entries to be added to the array
			TRedraw redrawFind;
			redrawFind.iRedraw=redraw;
			iRedraws->Find(redrawFind,*iKeyWindow,toDelete);
			}
		DeleteFromQueue(toDelete);
		}

	if (iAllocError && FindWindowNeedingRedrawEvent(event))
		{
		return;
		}

	CEventBase::GetData(&iNullRedrawEvent,sizeof(iNullRedrawEvent));
	}

TUint CRedrawQueue::RedrawPriority(CWsWindowRedraw *aRedrawWin)
	{
	TInt index;
	TRedraw redraw;
	TUint priority=0;
	redraw.iRedraw=aRedrawWin;

	if ((iRedraws->Find(redraw,*iKeyWindow,index))==KErrNone)
		{
		priority=iRedraws->At(index).iPriority;
		}
	return priority;
	}