/*

* 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 Image Viewer class.

*

*/

// INCLUDE FILES

#include "CIHLImageViewer.h"

#include "CIHLBitmap.h"

#include "CIHLBitmapProcessor.h"

#include "IHLImplementationIds.h"

#include "IHLDebugPrint.h" // Debug print

#include <IHLInterfaceIds.h>

#include <MIHLViewerObserver.h>

#include <MIHLFileImage.h>

#include <fbs.h>

#include <e32math.h>

// Private namespace for constants and functions

namespace

	{

	// Panic function

    _LIT( KIHLPanicString, "IHLImageViewer" );

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

	}

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

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

//

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

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

CIHLImageViewer::CIHLImageViewer( const TSize& aViewerSize,

								  MIHLFileImage& 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 );

	iAnimDelay = 0;

	iAnimLastFrameDrawTime = 0;

	iAnimDrawStartFastTime = 0; 

    }

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

//

// Two-phased constructor.

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

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

										MIHLFileImage& aSource,

										MIHLBitmap& aDestination,

										MIHLViewerObserver& aObserver,

										const TUint32 aOptions )

    {

    CIHLImageViewer* self = new( ELeave ) CIHLImageViewer(

		aViewerSize, aSource, aDestination, aObserver, aOptions );

    CleanupStack::PushL( self );

    self->ConstructL();

	CleanupStack::Pop(); // self

    return self;

    }

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

//

// Symbian constructor can leave.

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

void CIHLImageViewer::ConstructL()

	{

	CTimer::ConstructL();

	HAL::Get(HALData::EFastCounterFrequency, iTickPeriod);

	iCacheSource = CIHLBitmap::NewL();

	iCacheDestination = CIHLBitmap::NewL();

	iProcessor = CIHLBitmapProcessor::NewL( iOptions );

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

	iSourceSize = iSource.Size();

	CalculateZoomToFitRatio();

	User::LeaveIfError( SetZoomRatio( iZoomToFitRatio ) );

	}

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

// Destructor

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

CIHLImageViewer::~CIHLImageViewer()

    {

	Cancel();

	delete iProcessor;

	delete iCacheDestination;

	delete iCacheSource;

    }

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

// CIHLImageViewer::Id

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

TIHLInterfaceType CIHLImageViewer::Type() const

	{

	return TIHLInterfaceType( KIHLInterfaceIdImageViewer, KIHLImplementationIdImageViewer );

	}

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

// CIHLImageViewer::IsAnimation

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

TBool CIHLImageViewer::IsAnimation() const

	{

	return iSource.IsAnimation();

	}

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

// CIHLImageViewer::SheduleNextFrame

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

void CIHLImageViewer::SheduleNextFrame(TTimeIntervalMicroSeconds32 aDelay)

	{

	TInt delay=aDelay.Int();

	if (delay == 0) // 0 second deleay set in GIF file

		{

			iAnimDelay = TTimeIntervalMicroSeconds32(100000-iAnimLastFrameDrawTime);

		}

	else

		{

			iAnimDelay = delay - iAnimLastFrameDrawTime;

		}

	if (iAnimDelay.Int() <=0) //last frame drawn longer than animation frame interval. 

		{

			iAnimDelay = KMinimumInterval;

		}

	iAnimInitFastTime=User::FastCounter(); //store the start time

	HighRes(iAnimDelay);

	}

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

// CIHLImageViewer::Play

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

void CIHLImageViewer::Play()

	{

	if( iSource.IsAnimation() )

		{

		iIsPlaying = ETrue;

		if( iViewerState == EInactive)

			{

			iViewerState = EAnimation;

			SheduleNextFrame(	iSource.AnimationFrameDelay( iAnimationIndex )	);

			}

		}

	}

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

// CIHLImageViewer::Stop

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

void CIHLImageViewer::Stop()

	{

	iIsPlaying = EFalse;

	if( iViewerState == EAnimation )

		{

		Cancel();

		}

	}

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

// CIHLImageViewer::IsPlaying

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

TBool CIHLImageViewer::IsPlaying() const

	{

	return iIsPlaying;

	}

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

// CIHLImageViewer::AnimationFrameCount

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

TInt CIHLImageViewer::AnimationFrameCount() const

	{

	return iSource.AnimationFrameCount();

	}

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

// CIHLImageViewer::AnimationFrame

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

TInt CIHLImageViewer::AnimationFrame() const

	{

	return iAnimationIndex;

	}

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

// CIHLImageViewer::SetAnimationFrame

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

TInt CIHLImageViewer::SetAnimationFrame( TInt aFrameIndex )

	{

    // Public API, boundary check -> panic also on hardware

	__ASSERT_ALWAYS( aFrameIndex >= 0 &&

		aFrameIndex < iSource.AnimationFrameCount(), Panic( KErrArgument ) );

	// Save new index and clear old source cache to force load new frame

	iAnimationIndex = aFrameIndex;

	iCacheSource->Reset();

	// Start load

	return ApplySettings();

	}

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

// CIHLImageViewer::SetViewerSize

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

TInt CIHLImageViewer::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();

	}

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

// CIHLImageViewer::ViewerSize

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

TSize CIHLImageViewer::ViewerSize() const

	{

	return iViewerSize;

	}

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

// CIHLImageViewer::MoveSourceRect

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

TInt CIHLImageViewer::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();

	}

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

// CIHLImageViewer::SetSourceRectPosition

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

TInt CIHLImageViewer::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();

	}

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

// CIHLImageViewer::SourceRect

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

TRect CIHLImageViewer::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;

	}

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

// CIHLImageViewer::SourceSize

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

TSize CIHLImageViewer::SourceSize() const

	{

	if( iRotationAngle == ERotationAngle90 ||

		iRotationAngle == ERotationAngle270 )

		{

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

		}

	else

		{

		return iSourceSize;

		}

	}

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

// CIHLImageViewer::SetZoomRatio

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

TInt CIHLImageViewer::SetZoomRatio( TReal aZoomRatio )

	{

	if( aZoomRatio <= 0 || Math::IsInfinite( aZoomRatio ) )

		{

		return KErrArgument;

		}

	iZoomRatio = aZoomRatio;

	// Recalculate source rect and destination size

	CalculateSourceRectAndDestinationSize();

	// Start load

	return ApplySettings();

	}

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

// CIHLImageViewer::ZoomRatio

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

TReal CIHLImageViewer::ZoomRatio() const

	{

	return iZoomRatio;

	}

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

// CIHLImageViewer::ZoomToFitRatio

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

TReal CIHLImageViewer::ZoomToFitRatio() const

	{

	return iZoomToFitRatio;

	}

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

// CIHLImageViewer::RotateClockwise

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

TInt CIHLImageViewer::RotateClockwise()

	{

	TInt rotationAngle( iRotationAngle + ERotationAngle90 );

	if( rotationAngle > ERotationAngle270 )

		{

		rotationAngle = ERotationAngle0;

		}

	return SetRotationAngle( rotationAngle );

	}

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

// CIHLImageViewer::RotateCounterClockwise

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

TInt CIHLImageViewer::RotateCounterClockwise()

	{

	TInt rotationAngle( iRotationAngle - ERotationAngle90 );

	if( rotationAngle < ERotationAngle0 )

		{

		rotationAngle = ERotationAngle270;

		}

	return SetRotationAngle( rotationAngle );

	}

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

// CIHLImageViewer::SetRotationAngle

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

TInt CIHLImageViewer::SetRotationAngle( TInt aRotationAngle )

	{

	if( aRotationAngle != ERotationAngle0 &&

		aRotationAngle != ERotationAngle90 &&

		aRotationAngle != ERotationAngle180 &&

		aRotationAngle != ERotationAngle270 )

		{

		return KErrArgument;

		}

	iRotationAngle = aRotationAngle;

	// Recalculate source rect and destination size