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

 	}