/*

* 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:  Widget Control Implementation

 *

*/

//  Include Files

// Class Headers

#include "mulcoverflowcontrol.h"

#include <AknUtils.h>

// Alf Headers

#include <alf/alfenv.h>

// for dosetimage func

#include <alf/alfimageloaderutil.h>

#include <alf/alfbitmapprovider.h>

#include <alf/alfdisplay.h>

#include <alf/alfresourcepool.h> //for resource pooling

#include <alf/alfwidgetenvextension.h> //for resource pooling

#include <alf/alfutil.h>

#include <alf/alfimagevisual.h>

// Mul Headers

#include <mul/mulevent.h>

#include <mul/imulsliderwidget.h>

// Gesture Helper 

#include <gesturehelper.h>

// Local Headers

#include "mulbaseelement.h"

#include "mulcoverflowao.h"

#include "mulcoverflowtemplate.h" 

#include "mulcoverflowwidget.h"

#include "mulleave.h" //for leaving function

#include "mullog.h" //for logs

#include "mulassert.h"

#include "imulmodelaccessor.h"

//Gesture Helper

using namespace GestureHelper;

namespace Alf

	{

struct TMulCoverFlowControlImpl

	{

	TMulCoverFlowControlImpl()

		{

		mHighlightIndex = -1;

		mScreenWidth = 0;

		mScreenHeight = 0;

		mGestureSpeed  = 0;

		mCoverFlow2DTemplate = NULL;

		mIsWidgetVisible = true; //by default widget is visible .

		mBaseElement = NULL;

		mFastScroll = false;

		mNumVisibleItem = 0;

		mDefaultTextureId = -1;	

		mBounceInProgress = false;

		mDirectionChanged = false;

		mDontBounce = false;

		mNumberOfRepeatEvents = 0;

		mIsMirrored = false;

		}

    /// @bug critical:avanhata:4/7/2008 you should never cache a property that is a property of

    /// another class. The model exists to own this type of information. I gave this review comment

    /// as "critical", since it is exactly these cached member variables that will 

    /// yield most of bugs and complexity. Refactor it away.

	int mHighlightIndex;

	int mScreenWidth;

    int	mScreenHeight;

	bool mIsWidgetVisible;

	MulBaseElement* mBaseElement;	

	auto_ptr<MulCoverFlowTemplate> mCoverFlow2DTemplate;  // 2D cover flow template //owns 

	TReal32 mGestureSpeed;

	bool mFastScroll; 		// Flag to indicate wheher in fast scroll mode or not

	int mNumVisibleItem;

	int mDefaultTextureId;

	bool mBounceInProgress;

	int mReferencePoint;

	bool mDirectionChanged;

	int mCurrGestureDir; 

	bool mDontBounce;

	int mNumberOfRepeatEvents;

	bool mIsLandscape;

	bool mIsMirrored;

	};

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

// MulCoverFlowControl

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

//

MulCoverFlowControl::MulCoverFlowControl(CAlfEnv& aEnv	)

	{

	//Call the base class method

	MUL_LOG_ENTRY_EXIT("MUL:MulCoverFlowControl::MulCoverFlowControl");

	CAlfWidgetControl::construct ( aEnv);

	mData.reset( new (EMM)TMulCoverFlowControlImpl );

	mFeedback = MTouchFeedback::Instance(); 

    if (AknLayoutUtils::LayoutMirrored())

    	{

    	mData->mIsMirrored = true;

    	}

    else

		{

		mData->mIsMirrored = false;

		}

	mData->mIsLandscape = IsLandscape();

    THROW_IF_LEAVES

		(

        /// @bug critical:avanhata:30/9/2008 this is a symbian code section. don't call throwing osn code here. 

        /// Throwing within a TRAP is at best undefined

		mCoverFlowAo.reset( new(EMM) MulCoverFlowAo( *this ) );

		mHelper.reset(GestureHelper::CGestureHelper::NewL( *this ));

		mHelper->InitAlfredPointerCaptureL( aEnv, aEnv.PrimaryDisplay(), KGroupId ); 

		mHelper->SetHoldingEnabled( EFalse );

		)

	}

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

// ~MulCoverFlowControl

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

//	

MulCoverFlowControl::~MulCoverFlowControl()

	{

	MUL_LOG_ENTRY_EXIT("MUL:MulCoverFlowControl::~MulCoverFlowControl");

    if( ModelAccessor() != NULL )

        {

        ModelAccessor()->RemoveModelObserver(this);

        }

	DestroySlider();      

	}

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

// makeInterface

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

//          

IAlfInterfaceBase* MulCoverFlowControl::makeInterface( const IfId& aType )

    {

    MUL_LOG_ENTRY_EXIT("MUL:MulCoverFlowControl::makeInterface");

    UString param(aType.mImplementationId);

    return CAlfWidgetControl::makeInterface( aType );

    }

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

// ResetShowWidgetFlag

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

//  

void MulCoverFlowControl::ResetShowWidgetFlag( bool aNewResetValue )

    {

    MUL_LOG_ENTRY_EXIT("MUL:MulCoverFlowControl::ResetShowWidgetFlag");

    mData->mIsWidgetVisible = aNewResetValue;

    if( aNewResetValue)

        {

    	mHelper->AddObserver(this);

        } 

    }

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

// Template2D

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

//

MulCoverFlowTemplate*  MulCoverFlowControl::Template2D()

	{

	MUL_LOG_ENTRY_EXIT("MUL:MulCoverFlowControl::Template2D");

	return mData->mCoverFlow2DTemplate.get();

	}

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

// IsFastScrollMode

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

//	

bool MulCoverFlowControl::IsFastScrollMode()

	{

	MUL_LOG_ENTRY_EXIT("MUL:MulCoverFlowControl::IsFastScrollMode");

	return mData->mFastScroll;

	}	

//-----------------------Event Handling API's -------------------------------

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

// handleEvent

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

//	

AlfEventStatus MulCoverFlowControl::handleEvent(const TAlfEvent& aEvent)

	{

    MUL_LOG_ENTRY_EXIT("MUL:MulCoverFlowControl::handleEvent");

    if( aEvent.IsCustomEvent() )

        {

        return HandleCustomEvent( aEvent );

        } 

    else if( aEvent.IsKeyEvent() && mData->mIsWidgetVisible )

        {

        if(TotalModelCount() <= KMinNumItemForFastScroll || 

        	aEvent.KeyEvent().iRepeats == 0 )

	        {

	        return HandleKeyEvent( aEvent );	

	        }

	    else

	    	{	        

		    return HandleRepeatKeyEvent( aEvent );	

	    	}

        }      

 	else if( aEvent.IsPointerEvent() && mData->mIsWidgetVisible )

        {                 

		MUL_LOG_INFO("MUL::MulCoverFlowControl: handleEvent ::pointer event");

		//commented as gives warning in armv5 

		//THROW_IF_LEAVES

		     //(

		     TBool result = mHelper->OfferEventL(aEvent);

		     MUL_LOG_INFO1("MUL::MulCoverFlowControl: handleEvent::result %d ",result);

		     return result ? EEventConsumed :EEventNotHandled ;            

		    // )            

        }    

   	return EEventNotHandled;

    }

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

// HandleCustomEvent

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

//  

AlfEventStatus MulCoverFlowControl::HandleCustomEvent( const TAlfEvent& aEvent )

    {

    MUL_LOG_ENTRY_EXIT("MUL:MulCoverFlowControl::HandleCustomEvent");

    AlfEventStatus eventConsumed = EEventNotHandled;

    switch( aEvent.CustomParameter() )

        {

        case ECustomEventBounceBack:

            {

            MUL_LOG_INFO("MUL::MulCF:Handle custom event Compensate Bounce");

            mFeedback->InstantFeedback(ETouchFeedbackBasic); 

            mData->mBaseElement->StopDoodling(/*3*KBounceTime*/500);

            if ((TotalModelCount() > 1 && mData->mNumVisibleItem == 1) || 

            	(TotalModelCount() > 2))

	            {

	            Env().Send(TAlfCustomEventCommand(ECustomEventScroll, this),500/*3*KBounceTime*/ + 30); 	

	            }

	        else

	        	{

	        	//start marquee in case of text is visible.

	        	if(mData->mBaseElement->IsTextVisibile())

	        	    {

	        	    //start marquee after 1 sec (after doodle completed)

	        	    Env().Send(TAlfCustomEventCommand(

	        	            ECustomEventMarqueeStart, this),500/*3*KBounceTime*/ + KMarqueeTime1000);

	        	    }

	        	// if only one item is there then no need to scroll.

	        	mData->mBounceInProgress = false;	

	        	}

            eventConsumed = EEventConsumed;

            break;

            } 

        case ECustomEventScroll:

            {

            MUL_LOG_INFO("MUL::MulCF:Handle custom event Compensate Bounce");

            Env().Send(TAlfCustomEventCommand(ECustomEventBounceCompleted,this),600); 

            if (mData->mHighlightIndex == 0)

	            {

	            DoSetFocusIndex(TotalModelCount() -1,/*4*KBounceTime*/800);	

	            }

	        else

	        	{

	        	DoSetFocusIndex(0,800);	

	        	}

	        SetSliderTickPosition();

            eventConsumed = EEventConsumed;

            break;

            } 

        case ECustomEventBounceCompleted:

        	{

        	mData->mBounceInProgress = false;

			eventConsumed = EEventConsumed;

            break;        		

        	}

        case ECustomEventMarqueeStart:

        	{

        	mData->mBaseElement->StartMarquee(mulvisualitem::KMulTitle);

			eventConsumed = EEventConsumed;

			break;

        	}

        case ECustomEventTitleMarqueeFinished:

            {

            mData->mBaseElement->StopMarquee(mulvisualitem::KMulTitle);

            eventConsumed = EEventConsumed;

            break;

            }

        case ECustomEventDetailMarqueeStart:

            {

            mData->mBaseElement->StartMarquee(mulvisualitem::KMulDetail);

            eventConsumed = EEventConsumed;

            break;

            }

        case ECustomEventMarqueeFinished:

           {

           mData->mBaseElement->StopMarquee(mulvisualitem::KMulDetail);

    	   eventConsumed = EEventConsumed;

    	   break;

           }

        default: break;

        }  

    return eventConsumed;

    }

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

// HandleKeyEvent

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

//  

AlfEventStatus MulCoverFlowControl::HandleKeyEvent( const TAlfEvent& aEvent )

    {

    MUL_LOG_ENTRY_EXIT("MUL:MulCoverFlowControl::HandleKeyEvent");

    AlfEventStatus eventConsumed = EEventNotHandled;

   	if( aEvent.Code() == EEventKey)

     	{

     	switch ( aEvent.KeyEvent().iCode )

	        {

	        case EKeyEnter:

            // Event when selection key is pressed .( key event )

	        case EKeyDeviceA:

	        case EKeyDevice3: 

	            {

	            if(aEvent.KeyEvent().iRepeats == 0)

		            {

		            if(TotalModelCount() <= 0 && mData->mBaseElement->IsEmptyText() )           

			            {

			            SetSelection(mData->mHighlightIndex);

			            eventConsumed = EEventConsumed;

			            }

			        else if( TotalModelCount() > 0 )

			        	{

			        	SetSelection(mData->mHighlightIndex);

			            eventConsumed = EEventConsumed;	

			        	}

			        break;	

		            }

	            }

	        case EKeyRightArrow:

	            {

	            // Send event to inform that the Right Key is pressed

				if (mData->mIsMirrored)

					{

					HandleNavigationEvent ( EEventScrollLeft );

					}

				else

					{

					HandleNavigationEvent ( EEventScrollRight );

					}

	            eventConsumed = EEventConsumed;

	            break;

	            }

	        case EKeyLeftArrow:

	            {

	            // Send event to inform that the Left Key is pressed

				if (mData->mIsMirrored)

					{

					HandleNavigationEvent ( EEventScrollRight );

					}

				else

					{

					HandleNavigationEvent ( EEventScrollLeft );

					}

	            eventConsumed = EEventConsumed;

	            break;

	            }

	        case EKeyBackspace:

	        //case EKeyDelete:

	            {

	            CAlfWidgetControl::processEvent( TAlfEvent( ETypeRemove,mData->mHighlightIndex));

	            eventConsumed = EEventConsumed;

	            break;

	            }

	        default:

	            {

	            break;

	            }

	     	}

    	}

   else if(aEvent.Code() == EEventKeyUp) 

	   {

	   mData->mNumberOfRepeatEvents = 0;

	   switch ( aEvent.KeyEvent().iScanCode )

	        {

			case EStdKeyRightArrow:

			case EStdKeyLeftArrow:

				{

				if(mData->mFastScroll)

					{

					HandleEnhancedStop();

			   		eventConsumed = EEventConsumed;	

					}				

		   		break;

				}

			default:

				{

				break;	

				}

	        }

	   }         

    return eventConsumed;

    }

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

// HandleRepeatKeyEvent

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

//

AlfEventStatus MulCoverFlowControl::HandleRepeatKeyEvent( const TAlfEvent& aEvent )

    {

    MUL_LOG_ENTRY_EXIT("MUL:MulCoverFlowControl::HandleHoldGestureEvents");

	AlfEventStatus eventConsumed = EEventNotHandled;

   	if( aEvent.Code() == EEventKey)

     	{

     	switch ( aEvent.KeyEvent().iCode )

	        {

	        case EKeyRightArrow:

	            {

				if (mData->mIsMirrored)

					{

					HandleFastScrollWithKeyEvents(1);

					}

				else

					{

					HandleFastScrollWithKeyEvents(-1);

					}

	            eventConsumed = EEventConsumed;

	            break;

	            }

	        case EKeyLeftArrow:

	            {

				if (mData->mIsMirrored)

					{

					HandleFastScrollWithKeyEvents(-1);

					}

				else

					{

					HandleFastScrollWithKeyEvents(1);

					}

	            eventConsumed = EEventConsumed;

	            break;

	            }

	        default:

	            {

	            break;

	            }

	     	}

    	}

	return eventConsumed;

    }

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

// HandleFastScrollWithKeyEvents

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

//

void MulCoverFlowControl::HandleFastScrollWithKeyEvents(int aDirection)

    {

    MUL_LOG_ENTRY_EXIT("MUL:MulCoverFlowControl::HandleFastScrollWithKeyEvents");

    mData->mNumberOfRepeatEvents++;

    if(mData->mNumberOfRepeatEvents == 1 )

        {

        CAlfWidgetControl::processEvent( TAlfEvent( ETypeFastScroll,EScrollStart ));

		mData->mFastScroll = true;

		mCoverFlowAo->StartMoving(1, aDirection,true,200);	

        }

    else if(mData->mNumberOfRepeatEvents == KNumberOfRepeatsForMediumSpeed && mData->mFastScroll )

        {

        mCoverFlowAo->StartMoving(1, aDirection,true,150);	

        }

    else if(mData->mNumberOfRepeatEvents == KNumberOfRepeatsForFastSpeed && mData->mFastScroll )

        {

        mCoverFlowAo->StartMoving(1, aDirection,true,100);	

        }

    }      

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

// HandleNavigationEvent

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

//

void MulCoverFlowControl::HandleNavigationEvent( int aEvent )

	{

	MUL_LOG_ENTRY_EXIT("MUL:MulCoverFlowControl::HandleNavigationEvent");

	// During bounce ignore all the events

	if (mData->mBounceInProgress)

		{

		return;	

		}

	int highlightIndex = mData->mHighlightIndex;

	int totalcount = TotalModelCount();

	if(totalcount <= 0 && highlightIndex == -1 )

		{

		return;

		}

	//stop marquee if the navigation is happening.

	if(mData->mBaseElement->IsTextVisibile())

	    {

	    mData->mBaseElement->StopMarquee(mulvisualitem::KMulTitle);

	    mData->mBaseElement->StopMarquee(mulvisualitem::KMulDetail);

	    }