/*

* Copyright (c) 2006-2007 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 Image Viewer class.

*

*/

// INCLUDE FILES

#include "CIHLImageViewerExtJpg.h"

#include "CIHLBitmap.h"

#include "CIHLBitmapProcessor.h"

#include "IHLImplementationIds.h"

#include <IHLInterfaceIds.h>

#include <IclExtJpegApi.h>

#include <ImageCodecData.h>

#include <MIHLViewerObserver.h>

#include "MIHLFileImageExtJpg.h"

#include <fbs.h>

// Private namespace for constants and functions

namespace

	{

	// Panic function

	_LIT( KIHLImageViewerExtJpgPanic, "IHLImageViewerExtJpg" );

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

	}

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

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

//

// C++ constructor can NOT contain any code, that might leave.

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

CIHLImageViewerExtJpg::CIHLImageViewerExtJpg( const TSize& aViewerSize,

								  MIHLFileImageExtJpg& aSource,

								  MIHLBitmap& aDestination,

								  MIHLViewerObserver& aObserver,

								  const TUint32 aOptions )

: CTimer( EPriorityNormal ), iObserver( aObserver ),

iSource( aSource ), iDestination( aDestination ),

iOptions( aOptions ), iViewerSize( aViewerSize ), iSrcBitmapScaleFactor(1)

    {

	CActiveScheduler::Add( this );

    }

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

//

// Two-phased constructor.

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

CIHLImageViewerExtJpg* CIHLImageViewerExtJpg::NewL( const TSize& aViewerSize,

										MIHLFileImageExtJpg& aSource,

										MIHLBitmap& aDestination,

										MIHLViewerObserver& aObserver,

										const TUint32 aOptions )

    {

    CIHLImageViewerExtJpg* self = new( ELeave ) CIHLImageViewerExtJpg(

		aViewerSize, aSource, aDestination, aObserver, aOptions );

    CleanupStack::PushL( self );

    self->ConstructL();

	CleanupStack::Pop(); // self

    return self;

    }

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

//

// Symbian constructor can leave.

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

void CIHLImageViewerExtJpg::ConstructL()

	{

	CTimer::ConstructL();

	iCacheSource = CIHLBitmap::NewL();

	iCacheDestination = CIHLBitmap::NewL();

	// Check codec capabilities

	iCapabilities = iSource.CapabilitiesL();

	if( !( iCapabilities & ( CExtJpegDecoder::ECapRotation +

						CExtJpegDecoder::ECapMirroring +

						CExtJpegDecoder::ECapFlipping ) ) )

		{

		iInternalProcessingNeeded = ETrue;

		iProcessor = CIHLBitmapProcessor::NewL( iOptions );

		}

	// Initialize settings and start load (default is zoom to fit)

	iSourceSize = iSource.Size();

	CalculateZoomToFitRatio();

	User::LeaveIfError( SetZoomRatio( iZoomToFitRatio ) );

	}

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

// Destructor

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

CIHLImageViewerExtJpg::~CIHLImageViewerExtJpg()

    {

	Cancel();

	if( iProcessor )

		{

		delete iProcessor;

		}

	delete iCacheSource;

    delete iCacheDestination;

    }

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

// CIHLImageViewerExtJpg::Id

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

TIHLInterfaceType CIHLImageViewerExtJpg::Type() const

	{

	return TIHLInterfaceType( KIHLInterfaceIdImageViewer, KIHLImplementationIdImageViewerExtJpg );

	}

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

// CIHLImageViewerExtJpg::IsAnimation

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

TBool CIHLImageViewerExtJpg::IsAnimation() const

	{

	return EFalse;

	}

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

// CIHLImageViewerExtJpg::Play

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

void CIHLImageViewerExtJpg::Play()

	{

	}

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

// CIHLImageViewerExtJpg::Stop

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

void CIHLImageViewerExtJpg::Stop()

	{

	}

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

// CIHLImageViewerExtJpg::IsPlaying

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

TBool CIHLImageViewerExtJpg::IsPlaying() const

	{

	return EFalse;

	}

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

// CIHLImageViewerExtJpg::AnimationFrameCount

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

TInt CIHLImageViewerExtJpg::AnimationFrameCount() const

	{

	return KErrNone;

	}

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

// CIHLImageViewerExtJpg::AnimationFrame

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

TInt CIHLImageViewerExtJpg::AnimationFrame() const

	{

	return KErrNone;

	}

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

// CIHLImageViewerExtJpg::SetAnimationFrame

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

TInt CIHLImageViewerExtJpg::SetAnimationFrame( TInt /*aFrameIndex*/ )

	{

    return KErrNone;

	}

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

// CIHLImageViewerExtJpg::SetViewerSize

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

TInt CIHLImageViewerExtJpg::SetViewerSize( const TSize& aViewerSize, int aSrcBitmapScaleFactor )

	{

    // Public API, negative value check -> panic also on hardware

	__ASSERT_ALWAYS( aViewerSize.iWidth >= 0 &&

					 aViewerSize.iHeight >= 0, Panic( KErrArgument ) );

	iSrcBitmapScaleFactor = aSrcBitmapScaleFactor;

	// Save new viewer size

	iViewerSize = aViewerSize;

	// Recalculate source rect and destination size

	CalculateSourceRectAndDestinationSize();

	// Recalculate zoom to fit ratio

	CalculateZoomToFitRatio();

	// Start load

	return ApplySettings();

	}

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

// CIHLImageViewerExtJpg::ViewerSize

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

TSize CIHLImageViewerExtJpg::ViewerSize() const

	{

	return iViewerSize;

	}

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

// CIHLImageViewerExtJpg::MoveSourceRect

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

TInt CIHLImageViewerExtJpg::MoveSourceRect( TInt aDx, TInt aDy )

	{

	TInt dx( aDx );

	TInt dy( aDy );

	switch( iRotationAngle )

		{

		case ERotationAngle0:

			{

			break;

			}

		case ERotationAngle90:

			{

			dx = aDy;

			dy = -aDx;

			break;

			}

		case ERotationAngle180:

			{

			dx = -aDx;

			dy = -aDy;

			break;

			}

		case ERotationAngle270:

			{

			dx = -aDy;

			dy = aDx;

			break;

			}

		default:

			{

            // Internal state error, debug panic only

            #ifdef _DEBUG

			    Panic( KErrGeneral );

            #endif

			}

		}

	if( iHorizontalMirroring )

		{

		dx = -dx;

		}

	if( iVerticalMirroring )

		{

		dy = -dy;

		}

	if( iSourceRect.iTl.iX + dx < 0 ||

		iSourceRect.iBr.iX + dx > iSourceSize.iWidth ||

		iSourceRect.iTl.iY + dy < 0 ||

		iSourceRect.iBr.iY + dy > iSourceSize.iHeight )

		{

		return KErrArgument;

		}

	iSourceRect.Move( dx, dy );

	// Start load

	return ApplySettings();

	}

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

// CIHLImageViewerExtJpg::SetSourceRectPosition

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

TInt CIHLImageViewerExtJpg::SetSourceRectPosition( const TPoint& aPosition )

	{

	TPoint newPosition( aPosition );

	TSize sourceRectSize( iSourceRect.Size() );

	switch( iRotationAngle )

		{

		case ERotationAngle0:

			{

			break;

			}

		case ERotationAngle90:

			{

			newPosition.iX = aPosition.iY;

			newPosition.iY = iSourceSize.iHeight - sourceRectSize.iHeight - aPosition.iX;

			break;

			}

		case ERotationAngle180:

			{

			newPosition.iX = iSourceSize.iWidth - sourceRectSize.iWidth - aPosition.iX;

			newPosition.iY = iSourceSize.iHeight - sourceRectSize.iHeight - aPosition.iY;

			break;

			}

		case ERotationAngle270:

			{

			newPosition.iX = iSourceSize.iWidth - sourceRectSize.iWidth - aPosition.iY;

			newPosition.iY = aPosition.iX;

			break;

			}

		default:

			{

            // Internal state error, debug panic only

            #ifdef _DEBUG

    			Panic( KErrGeneral );

            #endif

			}

		}

	if( iHorizontalMirroring )

		{

		newPosition.iX = iSourceSize.iWidth - sourceRectSize.iWidth - newPosition.iX;

		}

	if( iVerticalMirroring )

		{

		newPosition.iY = iSourceSize.iHeight - sourceRectSize.iHeight - newPosition.iY;

		}

	if( newPosition.iX < 0 ||

		newPosition.iX > ( iSourceSize.iWidth - sourceRectSize.iWidth ) ||

		newPosition.iY < 0 ||

		newPosition.iY > ( iSourceSize.iHeight - sourceRectSize.iHeight ) )

		{

		return KErrArgument;

		}

	iSourceRect = TRect( newPosition, sourceRectSize );

	// Start load

	return ApplySettings();

	}

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

// CIHLImageViewerExtJpg::SourceRect

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

TRect CIHLImageViewerExtJpg::SourceRect() const

	{

	TRect mirroredSourceRect( iSourceRect );

	if( iHorizontalMirroring )

		{

		mirroredSourceRect.iTl.iX  = iSourceSize.iWidth - iSourceRect.iBr.iX;

		mirroredSourceRect.iBr.iX  = iSourceSize.iWidth - iSourceRect.iTl.iX;

		}

	if( iVerticalMirroring )

		{

		mirroredSourceRect.iTl.iY  = iSourceSize.iHeight - iSourceRect.iBr.iY;

		mirroredSourceRect.iBr.iY  = iSourceSize.iHeight - iSourceRect.iTl.iY;

		}

	TRect rotatedSourceRect( mirroredSourceRect );

	switch( iRotationAngle )

		{

		case ERotationAngle0:

			{

			break;

			}

		case ERotationAngle90:

			{

			rotatedSourceRect.iTl.iX = iSourceSize.iHeight - mirroredSourceRect.iBr.iY;

			rotatedSourceRect.iTl.iY = mirroredSourceRect.iTl.iX;

			rotatedSourceRect.iBr.iX = iSourceSize.iHeight - mirroredSourceRect.iTl.iY;

			rotatedSourceRect.iBr.iY = mirroredSourceRect.iBr.iX;

			break;

			}

		case ERotationAngle180:

			{

			rotatedSourceRect.iTl.iX = iSourceSize.iWidth - mirroredSourceRect.iBr.iX;

			rotatedSourceRect.iTl.iY = iSourceSize.iHeight - mirroredSourceRect.iBr.iY;

			rotatedSourceRect.iBr.iX = iSourceSize.iWidth - mirroredSourceRect.iTl.iX;

			rotatedSourceRect.iBr.iY = iSourceSize.iHeight - mirroredSourceRect.iTl.iY;

			break;

			}

		case ERotationAngle270:

			{

			rotatedSourceRect.iTl.iX = mirroredSourceRect.iTl.iY;

			rotatedSourceRect.iTl.iY = iSourceSize.iWidth - mirroredSourceRect.iBr.iX;

			rotatedSourceRect.iBr.iX = mirroredSourceRect.iBr.iY;

			rotatedSourceRect.iBr.iY = iSourceSize.iWidth - mirroredSourceRect.iTl.iX;

			break;

			}

		default:

			{

            // Internal state error, debug panic only

            #ifdef _DEBUG

    			Panic( KErrGeneral );

            #endif

			}

		}

	return rotatedSourceRect;

	}

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

// CIHLImageViewerExtJpg::SourceSize

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

TSize CIHLImageViewerExtJpg::SourceSize() const

	{

	if( iRotationAngle == ERotationAngle90 ||

		iRotationAngle == ERotationAngle270 )

		{

		return TSize( iSourceSize.iHeight, iSourceSize.iWidth );

		}

	else

		{

		return iSourceSize;

		}

	}

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

// CIHLImageViewerExtJpg::SetZoomRatio

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

TInt CIHLImageViewerExtJpg::SetZoomRatio( TReal aZoomRatio )

	{

	if( aZoomRatio <= 0 )

		{

		return KErrArgument;

		}

	iZoomRatio = aZoomRatio;

	// Recalculate source rect and destination size

	CalculateSourceRectAndDestinationSize();

	// Start load

	return ApplySettings();

	}

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

// CIHLImageViewerExtJpg::ZoomRatio

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

TReal CIHLImageViewerExtJpg::ZoomRatio() const

	{

	return iZoomRatio;

	}

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

// CIHLImageViewerExtJpg::ZoomToFitRatio

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

TReal CIHLImageViewerExtJpg::ZoomToFitRatio() const

	{

	return iZoomToFitRatio;

	}

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

// CIHLImageViewerExtJpg::RotateClockwise

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

TInt CIHLImageViewerExtJpg::RotateClockwise()

	{

	TInt rotationAngle( iRotationAngle + ERotationAngle90 );

	if( rotationAngle > ERotationAngle270 )

		{

		rotationAngle = ERotationAngle0;

		}

	return SetRotationAngle( rotationAngle );

	}

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

// CIHLImageViewerExtJpg::RotateCounterClockwise

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

TInt CIHLImageViewerExtJpg::RotateCounterClockwise()

	{

	TInt rotationAngle( iRotationAngle - ERotationAngle90 );

	if( rotationAngle < ERotationAngle0 )

		{

		rotationAngle = ERotationAngle270;

		}

	return SetRotationAngle( rotationAngle );

	}

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

// CIHLImageViewerExtJpg::SetRotationAngle

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

TInt CIHLImageViewerExtJpg::SetRotationAngle( TInt aRotationAngle )

	{

	if( aRotationAngle != ERotationAngle0 &&

		aRotationAngle != ERotationAngle90 &&

		aRotationAngle != ERotationAngle180 &&

		aRotationAngle != ERotationAngle270 )

		{

		return KErrArgument;

		}

	iRotationAngle = aRotationAngle;

	// Recalculate source rect and destination size

	CalculateSourceRectAndDestinationSize();

	// Recalculate zoom to fit ratio

	CalculateZoomToFitRatio();

	// Start load

	return ApplySettings();

	}

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

// CIHLImageViewerExtJpg::RotationAngle

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

TInt CIHLImageViewerExtJpg::RotationAngle() const

	{

	return iRotationAngle;

	}

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

// CIHLImageViewerExtJpg::SetVerticalMirroring

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

TInt CIHLImageViewerExtJpg::SetVerticalMirroring( TBool aValue )

	{

	if( iVerticalMirroring != aValue )

		{

		iVerticalMirroring = aValue;

		// Start load

		return ApplySettings();

		}

	return KErrNone;

	}

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

// CIHLImageViewerExtJpg::VerticalMirroring

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

TBool CIHLImageViewerExtJpg::VerticalMirroring() const

	{