/*

* Copyright (c) 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:  

*

*/

#include <AknUtils.h>

#include "mmdraweranimator.h"

#include "mmlistboxitemdrawer.h"

#include "mmfloatingitem.h"

#include "mmwidgetcontainer.h"

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

//

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

// 

CMmDrawerAnimator::CMmDrawerAnimator(CMmListBoxItemDrawer& aDrawer) :

    CActive( AknLayoutUtils::PenEnabled() ?

    		EPriorityRealTime : 

			EPriorityAbsoluteRealTime8 ), iDrawer(aDrawer), 

    iLastNotedHighlight( KErrNotFound ), iLastNotedTopItem( KErrNotFound ),

    iLastNotedVerticalOffset( 0 ),

    iUsualAnimationFramesCount( AknLayoutUtils::PenEnabled() ?

    		MmEffects::KUsualAnimationFramesCount : 

			MmEffects::KUsualAnimationFramesCountNonTouch )

    {

    }

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

//

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

// 

CMmDrawerAnimator* CMmDrawerAnimator::NewLC(CMmListBoxItemDrawer& aDrawer)

    {

    CMmDrawerAnimator* self = new ( ELeave ) CMmDrawerAnimator(aDrawer);

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

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

//

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

// 

CMmDrawerAnimator* CMmDrawerAnimator::NewL(CMmListBoxItemDrawer& aDrawer)

    {

    CMmDrawerAnimator* self = CMmDrawerAnimator::NewLC(aDrawer);

    CleanupStack::Pop( self );

    return self;

    }

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

//

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

// 

void CMmDrawerAnimator::ConstructL()

    {

    User::LeaveIfError( iTimer.CreateLocal() ); // Initialize timer

    CActiveScheduler::Add( this); // Add to scheduler

    iPreparedForGarbage = EFalse;

    }

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

//

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

// 

CMmDrawerAnimator::~CMmDrawerAnimator()

    {

    Cancel(); // Cancel any request, if outstanding

    iTimer.Close(); // Destroy the RTimer object

    // Delete instance variables if any

    }

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

//

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

// 

void CMmDrawerAnimator::DoCancel()

    {

    iTimer.Cancel();

    }

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

//

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

// 

TBool CMmDrawerAnimator::CancelNextRedrawL()

	{

	RunL();

    TTime currentTime;

    currentTime.HomeTime();

    return (currentTime.MicroSecondsFrom(iLastRedrawTime) 

    		<= MmEffects::KAnimationFrameDelay);

	}

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

//

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

// 

void CMmDrawerAnimator::RunL()

    {      

	if ( iPreparedForGarbage )

		{

		return;

		}

    TTime currentTime;

    currentTime.HomeTime();

   if (currentTime.MicroSecondsFrom(iLastRedrawTime) 

    		>= MmEffects::KAnimationFrameDelay && iDrawer.GetFloatingItemCount() > 0)

    	{

    	Cancel();

    	TRect refreshRect;

    	for(int i=0; i< iDrawer.GetFloatingItemCount(); i++)

			{

			TMmFloatingItem& current = iDrawer.GetFloatingItemAtIndex(i);

			TSize itemSize = iDrawer.GetItemSize(current.GetDrawnItemIndex(), EFalse);

			TRect beforeRect(current.GetItemPosition(), itemSize);

			current.MakeStep();

			TRect afterRect(current.GetItemPosition(), itemSize);

			if (current.GetFloatingItemType() == EDrag )

				{

				TInt dragTrail = iDrawer.GetFloatingItemIndex( EPostDragRefreshItem );

				if (dragTrail != KErrNotFound)

					{

					refreshRect = (refreshRect == TRect(0,0,0,0)) ? beforeRect : refreshRect;

					refreshRect.BoundingRect( afterRect );

					}

				}

			else

				{

				refreshRect = (refreshRect == TRect(0,0,0,0)) ? beforeRect : refreshRect;

				refreshRect.BoundingRect( beforeRect );

				refreshRect.BoundingRect( afterRect );

				}

			}

    	const TInt highlightedItemIndex = iDrawer.Widget()->View()->CurrentItemIndex();

    	if ( iLastNotedHighlight != highlightedItemIndex )

    	    {

            TRect highlightedItemRect(

                    iDrawer.Widget()->View()->ItemPos( highlightedItemIndex ),

                    iDrawer.Widget()->View()->ItemSize( highlightedItemIndex ) ); 

            refreshRect.BoundingRect( highlightedItemRect );

            iLastNotedHighlight = highlightedItemIndex;

    	    }

    	TInt currentVerticalOffset = static_cast<CMmWidgetContainer*>(

    	        iDrawer.Widget()->Parent() )->VerticalItemOffset();

    	if (iLastNotedTopItem != iDrawer.Widget()->TopItemIndex() ||

    	        iLastNotedVerticalOffset != currentVerticalOffset )

    		{

    		iDrawer.Widget()->DrawNow();

        	iLastNotedTopItem = iDrawer.Widget()->TopItemIndex();

        	iLastNotedVerticalOffset = currentVerticalOffset;

    		}

    	else

    		{

			if ( refreshRect != TRect(0,0,0,0))

				{

				TRect prev(iPreviousRefreshRect);

				iPreviousRefreshRect = refreshRect;

				refreshRect.BoundingRect(prev);

	            // expand rect if non-touch

	            refreshRect = TRect( AdjustRefreshRectToNonTouch( refreshRect ) );

	            // never draw on the outside of widget's view rectangle

	            refreshRect.Intersection( iDrawer.Widget()->View()->ViewRect() );

				iDrawer.Widget()->View()->Draw( &refreshRect );

				}

    		}

		iLastRedrawTime.HomeTime();

    	}

		if (iDrawer.GetFloatingItemCount() > 0)

			{

			Trigger();

			}

		else

			{

			Cancel();

#ifdef RD_UI_TRANSITION_EFFECTS_LIST

			if ( iTransTfx && iTransTfxInternal->EffectsDisabled() )

				{

				iTransTfx->EnableEffects( ETrue );

				if ( iTransTfx )

					{

					iTransTfxInternal->Remove( MAknListBoxTfxInternal::EListEverything );

					iDrawer.Widget()->DrawNow();

					iTransTfxInternal->Draw( iDrawer.Widget()->Rect() );

					}

				}

#endif

			}

    }

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

//

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

// 

TRect CMmDrawerAnimator::AdjustRefreshRectToNonTouch( const TRect& aRefreshRect )

    {

    TRect rect( aRefreshRect );

    if( !AknLayoutUtils::PenEnabled() )

        {

        TRect indicatorRect( iDrawer.GetIndicatorRect() );

        TSize itemSize( iDrawer.GetItemSize(

                iDrawer.Widget()->CurrentItemIndex(), ETrue ) );

        TInt horizontalMargin( ( indicatorRect.Width() - itemSize.iWidth ) / 2 );

        TInt verticalMargin( ( indicatorRect.Height() - itemSize.iHeight ) / 2 );

        rect.iBr.iX += horizontalMargin;

        rect.iBr.iY += verticalMargin;

        rect.iTl.iX -= horizontalMargin;

        rect.iTl.iY -= verticalMargin;

        }

    return rect;

    }

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

//

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

// 

TInt CMmDrawerAnimator::Trigger()

    {

	if ( iPreparedForGarbage )

		{

		return KErrCancel;

		}

    if (!IsActive() && iDrawer.GetFloatingItemCount() > 0 )

        {

#ifdef RD_UI_TRANSITION_EFFECTS_LIST

		iTransTfx = CAknListLoader::TfxApi( iDrawer.Gc() );

		iTransTfxInternal = CAknListLoader::TfxApiInternal( 

				iDrawer.Gc() );

		if ( iTransTfx && !iTransTfxInternal->EffectsDisabled() )

			{

			iTransTfx->EnableEffects( EFalse );

			if ( iTransTfxInternal )

				{

				iTransTfxInternal->Remove( MAknListBoxTfxInternal::EListEverything );

				iTransTfxInternal->Draw( iDrawer.Widget()->Rect() );

				}

			}

#endif

        iTimer.After(iStatus, TTimeIntervalMicroSeconds32( 

        		MmEffects::KAnimationFrameDelay ) ); 

        SetActive();

        }

    return KErrNone;

    }

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

//

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

// 

TInt CMmDrawerAnimator::RunError(TInt aError)

    {

    return aError;

    }

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

//

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

// 

void CMmDrawerAnimator::AnimateDragItemTransitionL( )

    {     

    if (KErrNotFound != iDrawer.GetFloatingItemIndex(EDrag))

        {

        TMmFloatingItem floatingItem(

                iDrawer.GetFloatingItemL(EDrag).GetDrawnItemIndex(), 

                iDrawer.GetFloatingItemL(EDrag).GetItemPosition(), 

                EDragTransition, iUsualAnimationFramesCount,

                iDrawer.Widget()->View());

        TPoint pointEnd = iDrawer.Widget()->View()->ItemPos( floatingItem.GetDrawnItemIndex() );

        floatingItem.SetPositionStep( pointEnd - floatingItem.GetItemPosition() );

        iDrawer.AddFloatingItemL( floatingItem, 0 );

        iDrawer.RemoveFloatingItem( iDrawer.GetFloatingItemIndex(EDrag) );

        }

    }

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

//

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

//

TBool CMmDrawerAnimator::IsReadyForNewAnimation()

    {

	if ( iPreparedForGarbage )

		{

		return EFalse;

		}

    for(int i=0; i< iDrawer.GetFloatingItemCount(); i++)

        {

        TMmFloatingItemType type 

			= iDrawer.GetFloatingItemAtIndex(i).GetFloatingItemType();

        if ( type != EDrag && type != EZoomTransition )

            {

            return EFalse;

            }

        }

    return ETrue;

    }

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

//

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

//

void CMmDrawerAnimator::CancelAnimationsL()

    {

    for(int i=0; i< iDrawer.GetFloatingItemCount(); i++)

        {

        TMmFloatingItem& current = iDrawer.GetFloatingItemAtIndex(i);

        if (current.GetFloatingItemType() != EDrag)

            {

            current.InvalidateFloatingItem();

            }

        }

    }

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

 //

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

 // 

void CMmDrawerAnimator::AnimateItemSwapL( TInt aItemFrom, TInt aItemTo )

    {

    TMmFloatingItem floatingItem( aItemTo, 

            iDrawer.Widget()->View()->ItemPos( aItemFrom ), 

            ESwapTransition, iUsualAnimationFramesCount,

            iDrawer.Widget()->View() );

    for(int i=0; i< iDrawer.GetFloatingItemCount(); i++)

        {

        TMmFloatingItem& current = iDrawer.GetFloatingItemAtIndex(i);

        if (current.GetFloatingItemType() == EZoomTransition 

                && current.GetDrawnItemIndex() == aItemFrom )

            {

            current.InvalidateFloatingItem();

            floatingItem.SetSizeStep( current.GetCurrentZoomRatio(), 1.0f );

            break;

            }

        }

    floatingItem.SetPositionStep( iDrawer.Widget()->View()->ItemPos(aItemTo)- 

            iDrawer.Widget()->View()->ItemPos(aItemFrom) );

    iDrawer.AddFloatingItemL(floatingItem);

    }

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

//

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

// 

void CMmDrawerAnimator::AnimateItemZoomL( TInt aItemIndex, TBool aZoomIn )

    {

    TMmFloatingItem floatingItem( aItemIndex,

            iDrawer.Widget()->View()->ItemPos( aItemIndex ),

            EZoomTransition, iUsualAnimationFramesCount,

            iDrawer.Widget()->View() );

    floatingItem.SetManualDelete( aZoomIn );

    floatingItem.SetSizeStep(

            (aZoomIn) ? KNormalStateZoomRatio : KZoomStateZoomRatio,

            (aZoomIn) ? KZoomStateZoomRatio : KNormalStateZoomRatio );

    TInt animationFound = EFalse;

    for(int i=0; i< iDrawer.GetFloatingItemCount(); i++)

        {

        TMmFloatingItem& current = iDrawer.GetFloatingItemAtIndex(i);

        if (current.GetFloatingItemType() == EZoomTransition &&

                current.GetDrawnItemIndex() == aItemIndex )

            {

            current.InvalidateFloatingItem();

            floatingItem.SetSizeStep( current.GetCurrentZoomRatio(),

                    (aZoomIn) ? KZoomStateZoomRatio : KNormalStateZoomRatio);

            animationFound = ETrue;

            break;

            }

        }

    if ( (aZoomIn != EFalse || animationFound != EFalse) )

        {

        // This covers the situation, when a zoom out animation is requested

        // whilst no zoom in occured earlier. In this case the request is 

        // neglected.

        iDrawer.AddFloatingItemL( floatingItem );

        }

    }

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

//

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

// 

void CMmDrawerAnimator::SetNextRedrawToWholeScreen()

	{

	iPreviousRefreshRect = iDrawer.Widget()->View()->ViewRect();

	}

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

//

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

// 

void CMmDrawerAnimator::PrepareForGarbage()

	{

//	Cancel any outstanding requests

	Cancel();

	iPreparedForGarbage = ETrue;

	}

//End of file