// 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:

// Window redraw code, three sorts of redrawing are supported

// This class deals with drawing from backup bitmap

// 

//

#include "backedupwindow.h"

#include "server.h"

#include "gc.h"

#include "wstop.h"

#include "ANIM.H"

#include "EVQUEUE.H"

#include <s32mem.h>

#include <gdi.h>

#include "panics.h"

#include "inifile.h"

#include "rootwin.h"

#include "EVENT.H"

#include "playbackgc.h"

#include "devicemap.h"

CFbsBitGc *CWsBackedUpWindow::iBitGc=NULL;

CWsBackedUpWindow::CWsBackedUpWindow(CWsWindow *aWin, TDisplayMode aDisplayMode) 

	: CWsWindowRedraw(aWin), iDisplayMode(aDisplayMode)

	{}

void CWsBackedUpWindow::StaticInitL()

	{

	iBitGc=CFbsBitGc::NewL();

	}

void CWsBackedUpWindow::StaticDestroy()

	{

	delete iBitGc;

	iBitGc = 0;

	}

void CWsBackedUpWindow::ActivateGc()

	{

	iBitGc->Activate(iBitmapDevice);

	iBitGc->Reset();

	iBitGc->SetBrushColor(BackColor());

	}

TBool CWsBackedUpWindow::DrawCommand(CWsGc*,const TAny*)

	{

	if (Screen()->ChangeTracking())

		MarkDirtyAndSchedule(iCurrentRegion);

	else

		Screen()->AddRedrawRegion(iWsWin->VisibleRegion());

	return ETrue;

	}

void CWsBackedUpWindow::ConstructL()

	{

	iDisplayMode=iWsWin->SetRequiredDisplayModeL(iDisplayMode);

	TSize size=iWsWin->Size();

	iBitmap=new(ELeave) CFbsBitmap();

	User::LeaveIfError(iBitmap->Create(size, iDisplayMode));

	iBitmapDevice=CFbsBitmapDevice::NewL(iBitmap);

	SetSizeInTwips();

//

	ActivateGc();

	iBitGc->SetDrawMode(CGraphicsContext::EDrawModeWriteAlpha);

	iBitGc->Clear(TRect(size));

	iBitGc->SetDrawMode(CGraphicsContext::EDrawModePEN);

	WS_ASSERT_DEBUG(iWsWin->WinType()==EWinTypeClient,EWsPanicWindowType);

	}

void CWsBackedUpWindow::PrepareForResizeL(const TSize &aSize, TSize &aOldSize)

	{

	aOldSize=iBitmapDevice->SizeInPixels();

	if (aOldSize!=aSize)

		{

		User::LeaveIfError(iBitmapDevice->Resize(aSize));

		SetSizeInTwips();

		}

	}

void CWsBackedUpWindow::Resize(const TSize &aSize, const TSize &aOldSize)

	{

	ActivateGc();

	iBitGc->SetClippingRegion(NULL);

	iBitGc->Clear(TRect(aOldSize.iWidth, 0, aSize.iWidth, aOldSize.iHeight));

	iBitGc->Clear(TRect(0, aOldSize.iHeight,aSize.iWidth, aSize.iHeight));

	static_cast<CWsClientWindow *>(iWsWin)->ReactivateGcs();

	if(Screen()->ChangeTracking())

		{

		//Keep track of the region we need to refresh when we recieve draw commands

		iCurrentRegion.Reset();

		iCurrentRegion.Copy(iWsWin->WindowArea());

		iCurrentRegion.Offset(-iWsWin->Origin());

		iCurrentRegion.Tidy();

		if(iCurrentRegion.CheckError())

			{

			iCurrentRegion.Reset();

			TRegionFix<1> fallback(iWsWin->AbsRect());

			iCurrentRegion.Copy(fallback); 

			iCurrentRegion.Offset(-iWsWin->Origin());

			}

		//If the window has nerver been drawn to screen, we now schedule the initial draw. This can't

		//be done in ConstructL because BackedUpWindows are created with size(0,0). And we can't check

		//iWsWin->IsActive() because the client might activate the window before giving it a size.

		if (!iHasBeenScheduled)

			{

			iHasBeenScheduled = ETrue;

			MarkDirtyAndSchedule(iCurrentRegion);

			}

		}

	}

CWsBackedUpWindow::~CWsBackedUpWindow()

	{

	iCurrentRegion.Reset();

	delete iBitmapDevice;

	delete iBitmap;

	}

TBool CWsBackedUpWindow::CommandL(TInt aOpcode, TWsWinCmdUnion &aCmd)

	{

	switch(aOpcode)

		{

		case EWsWinOpUpdateBackupBitmap:

			break;

		case EWsWinOpMaintainBackup:

			break;

		case EWsWinOpBitmapHandle:

			SetReply(iBitmap->Handle());

			break;

		case EWsWinOpUpdateScreen:

			{

			TRegionFix<1> fixRegion(iWsWin->AbsRect());

			UpdateScreen(fixRegion);

			}

			break;

		case EWsWinOpUpdateScreenRegion:

			{

			RWsRegion *clientRegion=NULL;

			TRAPD(err,clientRegion=GetRegionFromClientL(iWsWin->WsOwner(), *aCmd.Int));

			if (err==KErrNone && !clientRegion->CheckError())

				{

				clientRegion->Offset(iWsWin->Origin());

				clientRegion->ClipRect(iWsWin->AbsRect());

				UpdateScreen(*clientRegion);

				}

			else

				{

				TRegionFix<1> fixRegion(iWsWin->AbsRect());

				UpdateScreen(fixRegion);

				}

			clientRegion->Destroy();

			}

			break;

		case EWsWinOpSetBackgroundSurface:

		case EWsWinOpSetBackgroundSurfaceConfig:

		case EWsWinOpGetBackgroundSurfaceConfig:

			OwnerPanic(EWservPanicDrawable);	// Backed up windows don't support these

			break;

		default:

			return(EFalse);

		}

	return(ETrue);

	}

CWsBackedUpWindow *CWsBackedUpWindow::Backup() const

	{

	return((CWsBackedUpWindow *)this);

	}

CFbsDevice* CWsBackedUpWindow::OutputDevice() const

	{

	return iBitmapDevice;

	}

TRgb CWsBackedUpWindow::BackColor() const

	{

	return(iWsWin->RootWindow()->DefaultBackgroundColor());

	}

void CWsBackedUpWindow::Scroll(const TRect &aClipRect, const TPoint &aOffset,const TRect &aRect)

	{

	TRect winBorder=TRect(iWsWin->Size());

	TRect clipRect=aClipRect;

	TRect srcRect = aRect;		

	clipRect.Intersection(winBorder);	

	if (!clipRect.IsEmpty())

		{	// If we have to do something (a visible part will change)

		srcRect.Intersection(clipRect);

		STACK_REGION regionToClear;

		regionToClear.AddRect(aRect);

		regionToClear.SubRect(srcRect);

		regionToClear.Offset(aOffset);

		ActivateGc();

		iBitGc->SetClippingRect(clipRect);

		iBitGc->SetDrawMode(CGraphicsContext::EDrawModeWriteAlpha);

		iBitGc->CopyRect(aOffset,srcRect);				

		for (TInt k=0;k<regionToClear.Count();k++)

			{

			iBitGc->Clear(regionToClear[k]);

			}

		iBitGc->SetClippingRect(winBorder);

		iBitGc->SetDrawMode(CGraphicsContext::EDrawModePEN);

		TRegionFix<1> fixRegion(iWsWin->AbsRect());

		UpdateScreen(fixRegion);

		regionToClear.Close();

		}

	}

TBool CWsBackedUpWindow::NeedsRedraw() const

	{

	return(EFalse);

	}

TBool CWsBackedUpWindow::GetRedrawRect(TRect &) const

	{

	return(EFalse);

	}

void CWsBackedUpWindow::SetSizeInTwips()

	{

	TSize size=iBitmap->SizeInPixels();

	size.iWidth=Screen()->DeviceMap().HorizontalPixelsToTwips(size.iWidth);

	size.iHeight=Screen()->DeviceMap().VerticalPixelsToTwips(size.iHeight);

	iBitmap->SetSizeInTwips(size);

	}

void CWsBackedUpWindow::DrawWindow()

	{

	MWsGraphicsContext* gc = static_cast<MWsGraphicsContext*>(CPlaybackGc::Instance()->ResolveObjectInterface(KMWsGraphicsContext));

	gc->SetOrigin(iWsWin->Origin());

	gc->SetClippingRegion(*iRedrawRegion);

	gc->BitBlt(TPoint(0,0), *iBitmap);

	}

/** 

This function updates the window's dirty region and schedules a redraw if needed.

Only used when the screen is run in CHANGETRACKING mode. 

@param aRegion in window coordinates

*/

void CWsBackedUpWindow::MarkDirtyAndSchedule(const TRegion& aRegion)

	{

	WS_ASSERT_DEBUG(Screen()->ChangeTracking(),EWsPanicNoChangetracking);

	if(!aRegion.IsEmpty())

		{

		iWsWin->AddDirtyWindowRegion(aRegion);

		if (iWsWin->IsActive() && iWsWin->IsVisible())

			{

			Screen()->ScheduleWindow(iWsWin);

			}

		}

	}

/**

This function selects the desired behaviour depending on whether the screen is

run in CHANGETRACKING mode or not. 

@param aRegion in screen coordinates

*/

void CWsBackedUpWindow::UpdateScreen(const TRegion& aRegion)

	{

	if (Screen()->ChangeTracking())

		{

		STACK_REGION region;

		region.Copy(aRegion);

		region.Offset(-WsWin()->Origin()); //convert to window coordinates 

		MarkDirtyAndSchedule(region);

		region.Close();		

		}

	else

		{

		Screen()->AddRedrawRegion(aRegion);

		}

	}