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

//

/**

 @file

 @internalComponent

*/

#include <graphics/wsgraphicscontext.h>

#include "mmfsubtitlegraphicdrawer.h"

// Compensation value in microseconds to account for differences in the requested callback time and the actual

// time the callback is delivered

static const TInt KClockDrift=100000;

CMMFSubtitleGraphicDrawer* CMMFSubtitleGraphicDrawer::NewL()

    {

    CMMFSubtitleGraphicDrawer* self = new(ELeave) CMMFSubtitleGraphicDrawer();  

    return self;

    }

CMMFSubtitleGraphicDrawer::~CMMFSubtitleGraphicDrawer()

    {

    delete iBitmap1;

    delete iBitmap2;

    delete iTempBitmap;

    }

void CMMFSubtitleGraphicDrawer::ConstructL(MWsGraphicDrawerEnvironment& aEnv, const TGraphicDrawerId& aId, MWsClient& aOwner, const TDesC8& /*aData*/)

    {

    // Note this method is called by the baseclass not CMMFSubtitleGraphicDrawer

    BaseConstructL(aEnv, aId, aOwner);

    // Construct bitmap objects.  Do this here as we can leave usefully with

    // any construction errors

	iBitmap1 = new (ELeave) CFbsBitmap();

	iBitmap2 = new (ELeave) CFbsBitmap();

	iTempBitmap = new (ELeave) CFbsBitmap();

    }

// From CwsGraphicDrawer

void CMMFSubtitleGraphicDrawer::HandleMessage(const TDesC8& aData)

    {   

    // Retreive message type from buffer

    TInt8 msgType = aData[0];

    switch (msgType)

    	{    	

	case ESubtitleCrpMessageInit:

		{

		iCaptureRegion = ETrue;

		TPckgBuf<TSubtitleCrpMsgInit> message;

		message.Copy(aData);

		ProcessMessageInit(message());

		}

		break;

	case ESubtitleCrpMessageInitSimple:

		iCaptureRegion = ETrue;

		iBitmap1Valid=EFalse;

    	iBitmap2Valid=EFalse;

    	iTempBitmapValid=ETrue;

		break;

	case ESubtitleCrpMessageDrawFrame:

		{

		iState = ESubtitleGraphicStateDrawFrame;

		TPckgBuf<TSubtitleCrpMsgDrawFrame> message;

		message.Copy(aData);

		ProcessMessageDrawFrame(message());

		}

		break;

	case ESubtitleCrpMessageSwapFrame:

		{

		iState = ESubtitleGraphicStateSwapFrame;

		TPckgBuf<TSubtitleCrpMsgRenderSwapFrame> message;

		message.Copy(aData);

        ProcessMessageSwapFrame(message());

		}

        break;

    case ESubtitleCrpMessageClear:

    	iDisplayClearDue.UniversalTime();

    	iState = ESubtitleGraphicStateClear;

    	break;

	default:

		// Silently ignore unrecognised messages

		// Clear messages for example require no further processing

		// Set the state to waiting so DoDraw will do nothing.

		iState = ESubtitleGraphicStateWaiting;

	break;

    	}

    // Note clear messages require no further processing we just need to invalidate the display

	// Ask WSERV to redraw the CRP

    Invalidate();

    }

void CMMFSubtitleGraphicDrawer::DoDraw(MWsGc& aGc, const TRect& aRect, const TDesC8& /*aData*/) const

	{	

	// For some crp rendering states we need to ensure that this DoDraw has been called

	// in response to Invalidate() and not generated in response to a portion of the CRP

	// becoming invald for some reason (menus, dialogs etc)

	// Store the invalid region as our subtitle region to complete initialization.

	if (iCaptureRegion)

		{

		iSubtitleRegion = aRect;

		iCaptureRegion = EFalse;

		}

	// If the current state is waiting we do dont need to do anything

	if ((iSubtitleRegion.IsEmpty())||(iState==ESubtitleGraphicStateWaiting))

		{

		return;

		}

	switch(iState)

	    {   	

	case ESubtitleGraphicStateDrawFrame:

	case ESubtitleGraphicStateSwapFrame:	

		// Blt new content

		DoBitBlt(aGc, iDirtyRegion);

		if ( iDisplayDuration.Int64() > 0 )

			{

			// Schedule a clear frame to remove this subtitle after the requested time

		    // Note clear messages require no further processing we just need to schedule a redraw

			aGc.ScheduleAnimation(iSubtitleRegion, iDisplayDuration.Int64());

			iDisplayClearDue.UniversalTime();

			iDisplayClearDue=iDisplayDuration.Int64()+iDisplayClearDue.Int64()-KClockDrift;

			iState = ESubtitleGraphicStateClear;

			}

		else

			{

			// Redraw this frames content until instructed to stop

			iState = ESubtitleGraphicStateRefreshContent;

			}

	    break;

	case ESubtitleGraphicStateRefreshContent:

		// Refresh current frame content

		DoBitBlt(aGc, iDirtyRegion);

		break;

	case ESubtitleGraphicStateClear:

		{

		// Clear is due, check to see if the clear is due now

		TTime timeNow;

		timeNow.UniversalTime();

		TInt diff=iDisplayClearDue.Int64()-timeNow.Int64();

		if ( diff > 0 )

			{

			// Clear is not due do a standard bitblt		

			DoBitBlt(aGc, iDirtyRegion);

			}

		else

			{

			// No further processing required as WSERV clears the region for us

			iState = ESubtitleGraphicStateWaiting;

			}

		}

		break;

	default:

		// Should never happen

#ifdef _DEBUG

		RDebug::Printf("CMMFSubtitleGraphicDrawer::DoDraw() - Invalid State in Drawer should never happen");

		User::Invariant();

#endif

	    break;

	    }

	}

/**

Renders the current bitmap frame

*/

void CMMFSubtitleGraphicDrawer::DoBitBlt(MWsGc& aGc, const TRect& aRect) const

	{

	MWsGraphicsContext* context = aGc.ObjectInterface<MWsGraphicsContext>();

	if(!context)

		{

		RDebug::Printf("CMMFSubtitleGraphicDrawer::DoBitBlt can not get MWsGraphicsContext");

		return;

		}

	context->Push();

	switch (iCurrentFrame)

		{

		case ESubtitleGraphicFrame1:

			if (iBitmap1Valid)

				{

				context->BitBlt(iSubtitleRegion.iTl + aRect.iTl, *iBitmap1, aRect);

				}

			break;

		case ESubtitleGraphicFrame2:

			if (iBitmap2Valid)

				{

				context->BitBlt(iSubtitleRegion.iTl + aRect.iTl, *iBitmap2, aRect);

				}

			break;

		case ESubtitleGraphicFrame3:

			if (iTempBitmapValid)

				{

				context->BitBlt(iSubtitleRegion.iTl + aRect.iTl, *iTempBitmap, aRect);

				}

			break;

		default:

			break;

		}

	context->Pop();	

	}

/**

Process initialization message from client.  Readies the CRP for drawing

@param aMessage Message data received from client

*/

void CMMFSubtitleGraphicDrawer::ProcessMessageInit(TSubtitleCrpMsgInit& aMessage)

	{

	// Duplicate client bitmap handles

	// These are verified by the client before they are sent

	iBitmap1->Reset();

	TInt err = iBitmap1->Duplicate(aMessage.iBitmapHandle1);

	// This should never be a problem but check in debug modes just in case

	// We dont do this in release mode as it panics the window server...

	__ASSERT_DEBUG(KErrNone==err, User::Invariant());

	iBitmap2->Reset();

	err = iBitmap2->Duplicate(aMessage.iBitmapHandle2);

	// This should never be a problem but check in debug modes just in case

	// We dont do this in release mode as it panics the window server...

	__ASSERT_DEBUG(KErrNone==err, User::Invariant());

	iCurrentFrame=ESubtitleGraphicFrame1;

	iBitmap1Valid=ETrue;

	iBitmap2Valid=ETrue;

	iTempBitmapValid=EFalse;

	}

/**

Process draw frame message from client.  Draw the bitmap provided.

@param aMessage Message data received from client

*/

void CMMFSubtitleGraphicDrawer::ProcessMessageDrawFrame(TSubtitleCrpMsgDrawFrame& aMessage)

	{

	// Duplicate client bitmap handle

	iTempBitmap->Reset();

	iTempBitmap->Duplicate(aMessage.iBitmapHandle);

    iOldDirtyRegion=iDirtyRegion;

	iDirtyRegion=aMessage.iDirtyRegion;

    iDisplayDuration=aMessage.iDisplayDuration;

    iCurrentFrame=ESubtitleGraphicFrame3;

	}

/**

Process swap frame message from client.  Draws the current backbuffer provided.

@param aMessage Message data received from client

*/

void CMMFSubtitleGraphicDrawer::ProcessMessageSwapFrame(TSubtitleCrpMsgRenderSwapFrame& aMessage)

	{

	__ASSERT_DEBUG((aMessage.iExpectedFrame==ESubtitleGraphicFrame1)||(aMessage.iExpectedFrame==ESubtitleGraphicFrame2), User::Invariant());

	iDisplayDuration = aMessage.iDisplayDuration;

	iOldDirtyRegion=iDirtyRegion;

	iDirtyRegion = aMessage.iDirtyRegion;

	// Swap the frame pointer

	iCurrentFrame = static_cast<TSubtitleGraphicFrame>(aMessage.iExpectedFrame);

	}