/*

* Copyright (c) 2004 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:  Implementation of scaling processor

*              : using MIHLBitmap type bitmaps.

*

*/

// INCLUDE FILES

#include "CIHLBitmapProcessor.h"

#include "CIHLScaler.h"

#include "CIHLBitmap.h"

#include "IHLImplementationIds.h"

#include "IHLDebugPrint.h" // Debug print

#include <IHLInterfaceIds.h>

#include <fbs.h> // CFbsBitmap

#include <bitdev.h> // CFbsBitmapDevice, CFbsBitGc

// Private namespace for constants and functions

namespace

	{

	// Panic function

    _LIT( KIHLPanicString, "IHLBitmapProcessor" );

    void Panic( TInt aPanicCode ) { User::Panic( KIHLPanicString, aPanicCode ); }

	}

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

//

// C++ default constructor can NOT contain any code, that

// might leave.

// -----------------------------------------------------------------------------

CIHLBitmapProcessor::CIHLBitmapProcessor()

:CActive( CActive::EPriorityStandard )

    {

	CActiveScheduler::Add( this );

    }

// -----------------------------------------------------------------------------

//

// Two-phased constructor.

// -----------------------------------------------------------------------------

CIHLBitmapProcessor* CIHLBitmapProcessor::NewL( const TUint32 aOptions )

    {

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

    CleanupStack::PushL( self );

    self->ConstructL( aOptions );

	CleanupStack::Pop(); // self

    return self;

    }

// -----------------------------------------------------------------------------

//

// Symbian constructor can leave.

// -----------------------------------------------------------------------------

void CIHLBitmapProcessor::ConstructL( const TUint32 aOptions )

	{

	iScaler = CIHLScaler::NewL( aOptions );

	}

// -----------------------------------------------------------------------------

// Destructor

// -----------------------------------------------------------------------------

CIHLBitmapProcessor::~CIHLBitmapProcessor()

    {

	Cancel();

	delete iScaler;

    }

// -----------------------------------------------------------------------------

// CIHLBitmapProcessor::Type

// -----------------------------------------------------------------------------

TIHLInterfaceType CIHLBitmapProcessor::Type() const

	{

	return TIHLInterfaceType( KIHLInterfaceIdBitmapProcessor, KIHLImplementationIdBitmapProcessor );

	}

// -----------------------------------------------------------------------------

// CIHLBitmapProcessor::Process

// -----------------------------------------------------------------------------

TInt CIHLBitmapProcessor::Process( TRequestStatus& aStatus,

									const MIHLBitmap& aSrcBitmap,

									const TRect& aSrcRect,

									MIHLBitmap& aDstBitmap,

									const TRect& aDstRect )

	{

	if( IsBusy() )

		{

		return KErrNotReady;

		}

	// Check bitmaps (no checking of masks is needed)

	const CFbsBitmap& srcBitmap = aSrcBitmap.Bitmap();

	const CFbsBitmap& dstBitmap = aDstBitmap.Bitmap();

	if( !srcBitmap.Handle() ||

		!iScaler->IsValidRect( srcBitmap.SizeInPixels(), aSrcRect ) ||

		!dstBitmap.Handle() ||

		!iScaler->IsValidRect( dstBitmap.SizeInPixels(), aDstRect ) )

		{

		return KErrArgument;

		}

    IHL_DEBUG1( KIHLDebug, "IHL - CIHLBitmapProcessor - Start asynchronous bitmap processing" );

	// Set references to member data

	iSrcBitmap = &aSrcBitmap;

	iSrcRect = aSrcRect;

	iDstBitmap = static_cast<CIHLBitmap*>( &aDstBitmap ); //lint !e826

	iDstRect = aDstRect;

	// Start processing

	iProcessorStatus = &aStatus;

	*iProcessorStatus = KRequestPending;

	iProcessorState = EProcessBitmap;

	SelfComplete();

	return KErrNone;

	}

// -----------------------------------------------------------------------------

// CIHLBitmapProcessor::IsBusy

// -----------------------------------------------------------------------------

TBool CIHLBitmapProcessor::IsBusy() const

	{

	return ( iProcessorState != EInactive );

	}

// -----------------------------------------------------------------------------

// CIHLBitmapProcessor::CancelProcess

// -----------------------------------------------------------------------------

void CIHLBitmapProcessor::CancelProcess()

	{

    IHL_DEBUG1( KIHLDebug, "IHL - CIHLBitmapProcessor - Process cancelled" );

	Cancel();

	}

// -----------------------------------------------------------------------------

// CIHLBitmapProcessor::SetFilter

// -----------------------------------------------------------------------------

void CIHLBitmapProcessor::SetFilter( MIHFilter* /*aFilter*/ )

	{

	// Not in use

	}

// -----------------------------------------------------------------------------

// CIHLBitmapProcessor::DoCancel

// -----------------------------------------------------------------------------

void CIHLBitmapProcessor::DoCancel()

	{

	iScaler->CancelProcess();

	iProcessorState = EInactive;

	RequestComplete( KErrCancel );

	}

// -----------------------------------------------------------------------------

// CIHLBitmapProcessor::RunL

// -----------------------------------------------------------------------------

void CIHLBitmapProcessor::RunL()

	{

	User::LeaveIfError( iStatus.Int() );

	switch( iProcessorState )

		{

		case EProcessBitmap:

			{

			ProcessBitmapL();

			if( iDstBitmap->Mask().Handle() )

				{

				iProcessorState = EProcessMask;

				}

			else

				{

				// Destination has no mask -> finish process

				iProcessorState = EFinish;

				}

			break;

			}

		case EProcessMask:

			{

			ProcessMaskL();

			iProcessorState = EFinish;

			break;

			}

		case EFinish:

			{

            IHL_DEBUG1( KIHLDebug, "IHL - CIHLBitmapProcessor - Process complete!" );

			iProcessorState = EInactive;

			RequestComplete( KErrNone );

			break;

			}

		default:

			{

			Panic( KErrTotalLossOfPrecision );

			}

		}

	}

// -----------------------------------------------------------------------------

// CIHLBitmapProcessor::RunError

// -----------------------------------------------------------------------------

TInt CIHLBitmapProcessor::RunError( TInt aError )

	{

    IHL_DEBUG2( KIHLDebug, "IHL - CIHLBitmapProcessor - Processing error: %d", aError );

	iProcessorState = EInactive;

	RequestComplete( aError );

	return KErrNone;

	}

// -----------------------------------------------------------------------------

// CIHLBitmapProcessor::ProcessBitmapL

// -----------------------------------------------------------------------------

void CIHLBitmapProcessor::ProcessBitmapL()

	{

	User::LeaveIfError( iScaler->Scale( iStatus,

										iSrcBitmap->Bitmap(),

										iSrcRect,

										iDstBitmap->BitmapModifyable(),

										iDstRect ) );

	SetActive();

	}

// -----------------------------------------------------------------------------

// CIHLBitmapProcessor::ProcessMaskL

// -----------------------------------------------------------------------------

void CIHLBitmapProcessor::ProcessMaskL()

	{

	if( iSrcBitmap->Mask().Handle() )

		{

		User::LeaveIfError( iScaler->Scale( iStatus,

											iSrcBitmap->Mask(),

											iSrcRect,

											iDstBitmap->MaskModifyable(),

											iDstRect ) );

		SetActive();

		}

	else

		{

		// No source bitmap where mask can be copied

		// -> clear destination mask at given rectangle

		CFbsBitGc* bitGc;

		CFbsBitmapDevice* bitDev = CFbsBitmapDevice::NewL(

										&(iDstBitmap->BitmapModifyable()) );

		CleanupStack::PushL( bitDev );

		User::LeaveIfError( bitDev->CreateContext( bitGc ) );

		CleanupStack::PushL( bitGc );

		bitGc->SetPenColor( KRgbWhite ); // white is non-transparent

		bitGc->SetBrushColor( KRgbWhite );

		bitGc->SetBrushStyle( CGraphicsContext::ESolidBrush );

		bitGc->DrawRect( iDstRect );

		CleanupStack::PopAndDestroy( 2 ); // bitGc, bitDev

		}

	}

// -----------------------------------------------------------------------------

// CIHLBitmapProcessor::SelfComplete

// -----------------------------------------------------------------------------

void CIHLBitmapProcessor::SelfComplete()

	{

	SetActive();

	iStatus = KRequestPending;

	TRequestStatus* status = &iStatus;

	User::RequestComplete( status, KErrNone );

	}

// -----------------------------------------------------------------------------

// CIHLBitmapProcessor::RequestComplete

// -----------------------------------------------------------------------------

void CIHLBitmapProcessor::RequestComplete( TInt aReason )

	{

	ASSERT( iProcessorStatus );

	User::RequestComplete( iProcessorStatus, aReason );

	}

//  End of File