/*
* Copyright (c) 2007-2008 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:    The zoom and pan effect
 *
*/




//  Include Files
#include "shwzoomandpaneffect.h"

#include <glxsetvaluelayout.h>
#include <alf/alfvisual.h>

#include <alf/alfcurvepath.h>
#include <alf/alftimedvalue.h>

#include "shwresourceutility.h"
#include "shwzoomandpanlayout.h"
#include "shwcurvefactory.h"
#include "shwconstants.h"
#include "shwslideshowenginepanic.h"
#include "shwcrossfadelayout.h"
#include "shwtimer.h"
#include "shwcallback.h"
#include "shwgeometryutilities.h"

#include <glxlog.h>

using namespace NShwSlideshow;

/**
 * CShwZoomAndPanEffectImpl
 * Zoom and pan dependencies
 * This class makes our clients indepandant of the effect implementation
 * This gives greater flexibitily in testing as the test suites can just
 * re-implement all the methods in the real class interface without the 
 * need to stub all our real dependencies. 
 * If for example TShwCrossFadeLayout was a direct member of
 * CShwZoomAndPanEffect class, all the clients would need to have access 
 * to TShwCrossFadeLayout constructor and destructor and the test suite
 * would need to either create a stub implementation for it or include
 * the real class in the test (and all its dependencies)
 *
 * There is however no point of duplicating the whole CShwZoomAndPanEffect
 * interface as it would mean double maintenance
 * so we use the iImpl pointer when referencing the class members
 */
NONSHARABLE_CLASS( CShwZoomAndPanEffect::CShwZoomAndPanEffectImpl )
	: public CBase
	{
	public:
		
		/**
		 * Constructor
		 */
		inline CShwZoomAndPanEffectImpl();

		/**
		 * Destructor
		 */
		inline ~CShwZoomAndPanEffectImpl();

		/**
		 * 2nd phase constructor
		 */
		inline void ConstructL();

	public:	// Data

		/// Own: the size of the screen
		TSize iScreenSize;
		/// Own: the maximum thumbnail size
		TSize iMaxThumbnailSize;
		/// Own: the opacity layout
		TShwCrossFadeLayout iOpacityLayout;
		/// Own: the zoom and pan layout
		TShwZoomAndPanLayout iZoomAndPanLayout;
		/// Own: the pan curve
		CAlfCurvePath* iCurve;
		/// Own: Zoom and pan loop timer
		CShwTimer* iLoopTimer;
		/// Own: flag that defines if the image is large enough for zoom&pan
		TBool iShouldZoom;
        /// Own: Count to change the zoom direction
        TInt iCount;
		/// Own: the effect's info.
		TShwEffectInfo iEffectInfo;

	};

// -----------------------------------------------------------------------------
// C++ Constructor. Save a few bits of rom with inlining
// -----------------------------------------------------------------------------
inline CShwZoomAndPanEffect::CShwZoomAndPanEffectImpl::CShwZoomAndPanEffectImpl()
	{
	// CBase clears the values
	// set layout chain
	iOpacityLayout.SetNext( &iZoomAndPanLayout );
	}

// -----------------------------------------------------------------------------
// Destructor. Save a few bits of rom with inlining
// -----------------------------------------------------------------------------
inline CShwZoomAndPanEffect::CShwZoomAndPanEffectImpl::~CShwZoomAndPanEffectImpl()
	{
	delete iCurve;
	delete iLoopTimer;
	}

// -----------------------------------------------------------------------------
// 2nd phase constructor for the implementation
// -----------------------------------------------------------------------------
inline void CShwZoomAndPanEffect::CShwZoomAndPanEffectImpl::ConstructL()
    {
    // timer for zoom and pan looping
    iLoopTimer = CShwTimer::NewL( CActive::EPriorityStandard );

    // load string for effect name, no need to cleanup stack 
    // as no leaves between here and delete
    HBufC* effectName = 
        ShwResourceUtility::LocalisedNameL( R_SHW_EFFECT_ZOOM_AND_PAN );
    if( !effectName )
        {
        // have to use a non-localised version
        iEffectInfo.iName = KEffectNameZoomAndPan;
        }
    else
        {
        // set the localised version
        iEffectInfo.iName = *effectName;
        }

    // info - uid
    iEffectInfo.iId.iPluginUid = KDefaultEffectPluginUid;
    iEffectInfo.iId.iIndex     = KEffectUidZoomAndPan;
    // delete the local string
    delete effectName;
    }

// -----------------------------------------------------------------------------
// C++ Constructor. Save a few bits of rom with inlining
// -----------------------------------------------------------------------------
inline CShwZoomAndPanEffect::CShwZoomAndPanEffect()
	{
	}

// -----------------------------------------------------------------------------
// NewLC. Static construction
// -----------------------------------------------------------------------------
CShwZoomAndPanEffect* CShwZoomAndPanEffect::NewLC()
	{
	CShwZoomAndPanEffect* self = new (ELeave) CShwZoomAndPanEffect;
	CleanupStack::PushL( self );
    
	// create the implementation class
    self->iImpl = new( ELeave ) CShwZoomAndPanEffectImpl;
    // do the second phase, if it leaves impl will be deleted
	self->iImpl->ConstructL();

	return self;
	}

// -----------------------------------------------------------------------------
// Destructor
// -----------------------------------------------------------------------------
CShwZoomAndPanEffect::~CShwZoomAndPanEffect()
	{
	delete iImpl;
	}

// -----------------------------------------------------------------------------
// CloneLC
// -----------------------------------------------------------------------------
MShwEffect* CShwZoomAndPanEffect::CloneLC()
	{
	GLX_LOG_INFO( "CShwZoomAndPanEffect::CloneLC" );
	// create a copy
	CShwZoomAndPanEffect* copy = CShwZoomAndPanEffect::NewLC();
	// transfer the member variables, only screen 
	// size has relevant value this point
	copy->iImpl->iScreenSize = iImpl->iScreenSize;
	// set count to be one greater so it has a different zoom direction
	copy->iImpl->iCount = iImpl->iCount + 1;
    // copy the max thumbnail size
    copy->iImpl->iMaxThumbnailSize = iImpl->iMaxThumbnailSize;
	// return the clone
	return copy;
	}

// -----------------------------------------------------------------------------
// InitializeL
// -----------------------------------------------------------------------------
void CShwZoomAndPanEffect::InitializeL( 
	CAlfEnv* /*aHuiEnv*/, MGlxVisualList* /*aVisualList*/,
    MGlxMediaList* /*aMediaList*/, TSize aScreenSize )
	{
	GLX_LOG_INFO( "CShwZoomAndPanEffect::SetHuiEnv" );
	// set the screen size
	iImpl->iScreenSize = aScreenSize;

    // zoom and pan wants at least triple the screen size thumbnails
    TInt width = iImpl->iScreenSize.iWidth;
    TInt height = iImpl->iScreenSize.iHeight;

    // set the maximum thumbnail size, we need to optimize memory usage
    // so dont load more pixels than KMaxThumbnailSize x Screen size thumbnail
    iImpl->iMaxThumbnailSize.iWidth = width * KMaxThumbnailSize;
	iImpl->iMaxThumbnailSize.iHeight = height * KMaxThumbnailSize;
	}

// -----------------------------------------------------------------------------
// PrepareViewL
// -----------------------------------------------------------------------------
TSize CShwZoomAndPanEffect::PrepareViewL( 
	CAlfVisual* /*aVisual*/, TSize aImageSize )
	{
	GLX_LOG_INFO( "CShwZoomAndPanEffect::PrepareViewL()" );

    // use the namespace for coord utilities
    using namespace NShwGeometryUtilities;

    TSize originalImageSize = aImageSize;
    // take a local copy of the size
    TSize thumbnailSize = aImageSize;
    // check that size was really found
    if( ( aImageSize.iWidth == KErrNotFound )|| 
        ( aImageSize.iHeight == KErrNotFound ) )
        {
        // size attribute not available so use screen size
        thumbnailSize = iImpl->iScreenSize;
        // need to also adjust aImageSize as its used further to make sure
        // we dont load too big thumbnail; in this case we load screen size
        originalImageSize = iImpl->iScreenSize;
        }

    // calculate zoom first as after that we know the real panning
	// optimist assumes we can zoom every image
	iImpl->iShouldZoom = ETrue;
	// set the sizes for layout chain, return value is the zoom factor
	TReal32 zoomFactor = 
		iImpl->iZoomAndPanLayout.SetSizes( 
			iImpl->iScreenSize, thumbnailSize, iImpl->iMaxThumbnailSize );
	// if the zoomfactor is smaller than minimal desired, dont zoom&pan
	if( zoomFactor < KMinZoomAndPanFactor )
		{
		iImpl->iShouldZoom = EFalse;
		}
    // ask for the maximum size from the layout
    TSize maxSize = iImpl->iZoomAndPanLayout.MaximumSize();
    // make sure we don't load the image larger than maximum size
    thumbnailSize = maxSize;
    // thumbnail is never loaded larger than image size, 
    // either in image size or smaller... zooming may go past image size though
    FitInsideBox( 
        thumbnailSize.iWidth, thumbnailSize.iHeight,
        originalImageSize.iWidth, originalImageSize.iHeight );

	// calculate the area for the curve using the maximum size
	// it must not cause the panning to get outside screen so need to calculate
	// the delta box. We dont allow negative pan, 
	// however we need to support panning only in either direction.
    // Note that curve will have negative values, its just curve -defining 
    // box that we make positive as negative value means too small image to pan
    TInt curveWidth = Max( 
        ( maxSize.iWidth - iImpl->iScreenSize.iWidth ) / 2,
        0 );
    TInt curveHeight = Max( 
        ( maxSize.iHeight - iImpl->iScreenSize.iHeight ) / 2,
        0 );
	// delete old curve and set to NULL to prevent double delete
	delete iImpl->iCurve;
	iImpl->iCurve = NULL;
	// if both are zero, dont bother creating curve
	if( ( curveWidth > 0 ) || ( curveHeight > 0 ) )
		{
    	// create size
    	TSize curvearea( curveWidth, curveHeight );

		// construct new curve inside TRAP, if it fails we just dont pan
	    TRAP_IGNORE(
	        {
	        CAlfCurvePath* curve = 
	            NShwCurveFactory::CreateEllipsisL( 
	                curvearea, KZoomAndPanCurveLength );
	        // set new curve
	        iImpl->iCurve = curve;
	        } );
		}

    // return the calculated thumbnail size
    return thumbnailSize;
	}

// -----------------------------------------------------------------------------
// EnterViewL
// -----------------------------------------------------------------------------
MGlxLayout* CShwZoomAndPanEffect::EnterViewL(
	CAlfVisual* /*aVisual*/, TInt aDuration, TInt aFadeInDuration )
    {
	GLX_LOG_INFO1( 
		"CShwZoomAndPanEffect::EnterViewL( %d )", aDuration );

	// calculate zoom&pan length
	// minimum length is the view duration and transition duration * 2
	// this is because there is transition, view and transition while
	// this visual is visible (at least partially)
	TInt zoom_and_pan_dur = aDuration + aFadeInDuration * 2;
    
	// set value, 0% -> 100%
	iImpl->iOpacityLayout.Set( KMinOpacity );
	iImpl->iOpacityLayout.Set( KMaxOpacity, aFadeInDuration );

	// check if the image was large enough for zooming
	if( iImpl->iShouldZoom )
		{
		// start with zoom in
		TShwZoomAndPanLayout::TZoomDirection zoomdir = 
			TShwZoomAndPanLayout::EZoomIn;
		if( iImpl->iCount % 2 )
			{
			zoomdir = TShwZoomAndPanLayout::EZoomOut;
			}

		// start zoom
		// minimum length is the view duration and transition duration * 2
		// this is because there is transition, view and transition while
		// this visual is visible (at least partially)
		iImpl->iZoomAndPanLayout.StartZoom( 
			zoomdir, zoom_and_pan_dur );

		// need to start a timer to invert the zoom in case image load 
		// takes longer than view mode lasts
		iImpl->iLoopTimer->Start( 
			zoom_and_pan_dur, 
			zoom_and_pan_dur,
			TShwCallBack< 
				TShwZoomAndPanLayout, 
                &TShwZoomAndPanLayout::InvertZoom >( 
				&iImpl->iZoomAndPanLayout ) );
		}
	else
		{
		// reset the size to minimum
		iImpl->iZoomAndPanLayout.ResetSizeToMinimum();
		// cancel loop timer in case it is running, if not then 
		// this is a no-op
		iImpl->iLoopTimer->Cancel();
		}
	// return layout chain
	return &iImpl->iOpacityLayout;
    }

// -----------------------------------------------------------------------------
// ExitView
// -----------------------------------------------------------------------------
void CShwZoomAndPanEffect::ExitView( CAlfVisual* /*aVisual*/ )
    {
	GLX_LOG_INFO( "CShwZoomAndPanEffect::ExitView" );
	// Cancel the loop timer as we are already going to the 
	// next effect and visual
	iImpl->iLoopTimer->Cancel();
    }

// -----------------------------------------------------------------------------
// EnterTransitionL
// -----------------------------------------------------------------------------
MGlxLayout* CShwZoomAndPanEffect::EnterTransitionL(
	CAlfVisual* /*aVisual*/, TInt aDuration )
    {
    GLX_LOG_INFO1( "CShwZoomAndPanEffect::EnterTransitionL( %d )", aDuration );

	// increase count, so every other time we can zoom in and out but only if we 
	// really got to transition
	iImpl->iCount++;

	// set value, drop from 100% to 0%
    iImpl->iOpacityLayout.Set( KMaxOpacity );
    iImpl->iOpacityLayout.Set( KMinOpacity, aDuration );

	return &iImpl->iOpacityLayout;
    }

// -----------------------------------------------------------------------------
// ExitTransition
// -----------------------------------------------------------------------------
void CShwZoomAndPanEffect::ExitTransition( CAlfVisual* /*aVisual*/ )
    {
	GLX_LOG_INFO( "CShwZoomAndPanEffect::ExitTransition" );
    }

// -----------------------------------------------------------------------------
// PauseL
// -----------------------------------------------------------------------------
void CShwZoomAndPanEffect::PauseL()
    {
	GLX_LOG_INFO( "CShwZoomAndPanEffect::PauseL" );
	// need to pause the layouts, start with opacity
	iImpl->iOpacityLayout.Pause();
	// freeze zoom and pan layout
	iImpl->iZoomAndPanLayout.Pause();
	// pause loop timer, it is safe to pause the timer even if its not active
    iImpl->iLoopTimer->Pause();
	}

// -----------------------------------------------------------------------------
// Resume
// -----------------------------------------------------------------------------
void CShwZoomAndPanEffect::Resume()
    {
	GLX_LOG_INFO( "CShwZoomAndPanEffect::Resume" );
	// resume layouts
	// start with opacity
	iImpl->iOpacityLayout.Resume();
	// resume zoom and pan layout
	iImpl->iZoomAndPanLayout.Resume();
	// resume loop timer
	iImpl->iLoopTimer->Resume();
    }

// -----------------------------------------------------------------------------
// EffectInfo.
// -----------------------------------------------------------------------------
TShwEffectInfo CShwZoomAndPanEffect::EffectInfo()
	{
	return iImpl->iEffectInfo;
	}