/*

* 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:  base element Implementation

 *

*/

//  Include Files

// Class Headers

#include "mulbaseelement.h"

#include <AknUtils.h>

// Alf Headers

#include <alf/alfbatchbuffer.h>

#include <alf/alfbrusharray.h>

#include <alf/alfgradientbrush.h>

#include <alf/alfviewportlayout.h>

#include <alf/alftextvisual.h>

#include <alf/alfimagevisual.h>

#include <alf/alfutil.h>

#include <alf/alftransformation.h>

// Mul Headers

#include "mul/mulmodelutility.h"

#include "imulmodelaccessor.h"

#include <mul/imulsliderwidget.h>

#include <mul/mulevent.h>

#include "mulassert.h"

#include "mulleave.h"

#include "mullog.h" //for logs

// Local Cover Flow Headers

#include "mulcoverflowcontrol.h"

#include "mulcoverflowtemplate.h"

namespace Alf

    {

//Internal base element structure implementation

struct TMulBaseElementImpl

    {        

    UString mEmptyText;       // empty text to be displayed when number of items is 0.

	int mPadding;            //Padding between item 

  	TMulCoverFlowItem mHighlightItemStruct;

	TMulCoverFlowItem mItemStruct;

	int mVisibleCount;

    int	mScrollAnimationTime; // animation time for highlight transition set by the application.

	bool mUiOn;    // true if in UiOnMode

    bool mTextVisible;  // not suppose to be displayed in template 4

	// To keep a pointer of iconFlow layout.Not owned, created at construction. 

	// The below 4 layouts will never be null. No need to validate before using	

	CAlfFlowLayout* mIconFlowLayout; 

	CAlfLayout* mTextLayout;

    CAlfFlowLayout* mVerticalFlow;

    CAlfLayout* mSliderLayout ; // stores visual of the slider widget

    // Can be null when the template doesnt have counter.

    CAlfTextVisual* mCounterVisual ;

    CAlfTextVisual* mEmptyTextVisual;

    //Stores current slider opacity. 

    float mSliderOpacity;

    TItemScroll mScrollDir;

    float mEmptyTextOpacity;

    // whether to apply default fit mode(fitinside) or not. 

    // if false apply default fit mode , else based on the image size.

    bool mFitMode;

    // different visuals color properties

    TMulVisualColorProperty mIconBgColor;

    TMulVisualColorProperty mCounterColor;

    TMulVisualColorProperty mTextColor;

    TMulRotationProperty mRotation;

	bool mChangeSize;

	// whether user has swiped multiple times.

	TNumberofSwipes mNumSwipes;

	// total number of digits in counter visual at every highlight.

	int mNumOfDigitsInCounter;

	// marquee animation time

	int mMarqueeAnimTime;

	// Titletext extents

	TSize mTitleExt;

	// Detailtext extents

	TSize mDetailExt;

	//Dummy text visual for getting text extents

	CAlfTextVisual* mDummyVisual;

	bool mIsMirrored;

	//Constructor of the structure

	TMulBaseElementImpl()

		{

		//Intialisation

		mPadding                 = -1;   

		mNumOfDigitsInCounter    = -1;

		mVisibleCount            = 0;

		mScrollAnimationTime     = 200;

		mEmptyText 	= "";

		mCounterVisual = NULL;

		mIconFlowLayout = NULL;

		mTextLayout = NULL;

	    mVerticalFlow = NULL;

	    mSliderLayout = NULL;

	    mEmptyTextVisual = NULL;

	    mSliderOpacity = 0.0f;

	    mTextVisible   = true;

	    mScrollDir = EItemNoDirection;

	    mEmptyTextOpacity = 0.0f;

	    mFitMode = false;

	    mUiOn = false;

	    mChangeSize = false;

	    mNumSwipes = ESingleSwipe;

	    mMarqueeAnimTime = 0;

	    mDummyVisual = NULL;

	    mIsMirrored = false;

		}

	~TMulBaseElementImpl()

		{		

		}

    }; //end of the structure

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

// MulBaseElement

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

//

MulBaseElement::MulBaseElement( CAlfWidgetControl& aControl,

			                    const char* aName )

    {

    MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::MulBaseElement");

    mData.reset( new (EMM)TMulBaseElementImpl );

    //Call the base class method      

    construct( aControl,aName );

    CreateBaseLayoutStructure();

    (static_cast<MulCoverFlowControl&>(aControl)).UpdateBaseElement(this);

    if (AknLayoutUtils::LayoutMirrored())

    	{

    	mData->mIsMirrored = true;

    	}

    else

		{

		mData->mIsMirrored = false;

		}

    }

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

// ~MulBaseElement

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

//	

MulBaseElement::~MulBaseElement()

    {

    // Nothing to delete .

    }

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

// accept

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

//	

bool MulBaseElement::accept( CAlfWidgetControl& /*aControl*/,

		                     const TAlfEvent& aEvent ) const

     {

     MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::accept");

     uint eventID; 

     if(!aEvent.IsCustomEvent())

       {

       return false;

       }

    eventID = aEvent.CustomParameter();

    //Events handled by the base element

	if( eventID == ETypeHighlight 

			|| eventID == EEventWidgetInitialized 

			|| eventID == ETypePrimaryValueChange )

        {

        return true;

        }

    else

        {

        return false;	

        }

    }

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

// offerEvent

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

//	

AlfEventStatus MulBaseElement::offerEvent( CAlfWidgetControl& aControl,

			const TAlfEvent& aEvent )

    {

    MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::offerEvent");

    if ( !accept( aControl, aEvent ) )

        {

        //return false;

		return EEventNotHandled;

        }

    uint eventID = aEvent.CustomParameter();

    MulCoverFlowControl* coverflowControl = static_cast<MulCoverFlowControl*>(&control());

    if( eventID == EEventWidgetInitialized )

        {

        // some of the member variable needs to be reset

        // to support dynamic template change with model change.

        mData->mNumOfDigitsInCounter = -1;

        UpdateTextAndCounter();

        CalculatePadding();

        ArrangeItems();

		// Show empty text if coverflow is empty

	    int totalModelCount = coverflowControl->TotalModelCount();

	    IMulModelAccessor* model = coverflowControl->ModelAccessor(); 

	    if( (totalModelCount <= 0) || (model == NULL))

	        {

	        ShowEmptyText( true );

	        return EEventConsumed;

	        }

	    else

	    	{

	    	ShowEmptyText( false );

	    	} 		

 		return EEventConsumed;

        }

    else if( eventID == ETypeHighlight )

        {

        // Update the text and counter values according to the new highlight

        int newHighlight = coverflowControl->HighlightIndex(); 

        int animationTime = aEvent.CustomEventData();

        animationTime = animationTime > 0 ? animationTime : mData->mScrollAnimationTime;

        if(mData->mScrollDir != EItemNoDirection)

            {

            if(coverflowControl->IsFastScrollMode())

	            {

	            animationTime = coverflowControl->FastScrollTransitionTime();

	            SetHighlight(newHighlight,animationTime);   	

	            }

            else

	            {

	            SetHighlight(newHighlight,animationTime );   	

	            }

            }

        else

            {

            //@TODO: update all the items 

            animationTime = KZeroAnimation;

            SetHighlight(newHighlight,animationTime);    

            }

        UpdateTextAndCounter(animationTime);

		return EEventConsumed;

        }

    else if( eventID == ETypePrimaryValueChange )

    	{

 		IMulSliderModel* mulSliderModel = coverflowControl->GetSliderModel();

 		if( mulSliderModel )

	        {

	    	int primaryValue = mulSliderModel->PrimaryValue();

	  	    coverflowControl->SetHighlightIndex( primaryValue , false);

    	    }

		return EEventConsumed;

    	}

	return EEventNotHandled;    

    }

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

// setActiveStates

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

//	

void MulBaseElement::setActiveStates( unsigned int /*aStates*/ )

    {

    //No implementation required

    }

//----------------- Creating the visuals and layout structure ----------------

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

// CreateBaseLayoutStructure

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

//	

void  MulBaseElement::CreateBaseLayoutStructure()

	{

	THROW_IF_LEAVES

	( 

	 MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::CreateBaseLayoutStructure");

	 CAlfLayout* main = CAlfLayout::AddNewL(control()); 

     // set this flag, to recieve layout change events ,that are handled 

	 // by the ovverriden VisualLayoutUpdated method of the alfwidgetcontrol.

     main->SetFlags( EAlfVisualFlagLayoutUpdateNotification );

     main->SetTagL( mainlayout );

     main->SetFlag(EAlfVisualFlagAutomaticLocaleMirroringEnabled);

	 main->SetClipping(ETrue); 

    CAlfDeckLayout* deckLayout = CAlfDeckLayout::AddNewL( (CAlfControl &)control(),main);

    deckLayout->SetTagL( decklayout );

    deckLayout->SetFlag( EAlfVisualFlagManualLayout );

    CAlfGradientBrush* deckBrush = CAlfGradientBrush::NewL( control().Env() );

    // Set the brush colour

    deckBrush->SetColor( KRgbBlack );

    deckLayout->EnableBrushesL( ETrue );

    // Apply brush and set the opacity .

    deckLayout->Brushes()->AppendL( deckBrush, EAlfHasOwnership ); 

    deckLayout->SetFlag(EAlfVisualFlagAutomaticLocaleMirroringEnabled);

	deckLayout->SetClipping(ETrue);

    // Create a vertical flow layout which has two horizontal layouts 

    mData->mVerticalFlow = CAlfFlowLayout::AddNewL((CAlfControl&)control(), deckLayout );

    // Set the Layout Direction

    mData->mVerticalFlow->SetFlowDirection( CAlfFlowLayout::EFlowVertical );

    mData->mVerticalFlow->SetFlag( EAlfVisualFlagManualLayout );

    mData->mVerticalFlow->SetTagL( verticalflowlayout );

    mData->mVerticalFlow->SetFlag(EAlfVisualFlagAutomaticLocaleMirroringEnabled);

    // Create flow layout,all the item visuals are added to this layout.

    // make this layout as the child to the vertical flow layout at index 1.

    mData->mIconFlowLayout = CAlfFlowLayout::AddNewL( (CAlfControl&)control(), mData->mVerticalFlow );

    // Set the Layout Direction

    mData->mIconFlowLayout->SetFlowDirection( CAlfFlowLayout::EFlowHorizontal );

    mData->mIconFlowLayout->SetTagL( iconflowlayout );

    mData->mIconFlowLayout->SetFlag(EAlfVisualFlagAutomaticLocaleMirroringEnabled);

    // stores visuals of all the items(text visuals) 

    mData->mTextLayout = CAlfLayout::AddNewL((CAlfControl&)control(),mData->mVerticalFlow);

    mData->mTextLayout->SetTagL( textflowlayout );

    mData->mTextLayout->SetFlag(EAlfVisualFlagIgnorePointer);

    mData->mTextLayout->SetFlag( EAlfVisualFlagManualLayout );    

    mData->mTextLayout->SetFlag(EAlfVisualFlagAutomaticLocaleMirroringEnabled);

    //Add main layout to the base visual tree

    addVisualTree( main, KInitialvalueZero );

     );       

	}

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

// SetDefaultSize

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

//

void MulBaseElement::SetDefaultSize( TSize aSize )

	{

	MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::SetDefaultSize");

	CAlfLayout* main  = (CAlfLayout*)findVisual( KMainLayoutIndex );

	main->SetSize(aSize );

	CAlfDeckLayout& deckLayout = static_cast<CAlfDeckLayout&> (main->Visual(KMainLayoutIndex) );

	deckLayout.SetSize(aSize);

	CAlfVisual* backgroundVisual = deckLayout.FindTag(backgroundvisual);

    if(backgroundVisual)

		{

		backgroundVisual->SetSize(aSize);				

		}	

	if( mData->mEmptyTextVisual && mData->mEmptyTextOpacity == 1 )

		{

		mData->mEmptyTextVisual->SetSize(aSize);		

		}

	}

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

// TextAnchorLayout

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

//	        

CAlfLayout& MulBaseElement::TextLayout()

	{

	__MUL_ASSERT( mData->mTextLayout != 0,KNullPointer);

	return *mData->mTextLayout;

	}

//----------------------Empty text related visualisation---------------------

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

// SetEmptyText

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

//

void MulBaseElement::SetEmptyText( const UString& aDefaultText )

	{

	MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::SetEmptyText");

	mData->mEmptyText = aDefaultText;

	int totalModelCount = ((MulCoverFlowControl*)&control())->TotalModelCount();

	if( mData->mEmptyTextVisual )

		{

		THROW_IF_LEAVES

		 ( 

		  TBuf<KTempBufferSize> desc; 

		  MulModelUtility::ConvertUStringToTDes(mData->mEmptyText, desc);   

		  mData->mEmptyTextVisual->SetTextL(desc);

		 );

		}

    if( totalModelCount <= KInitialvalueZero )

        {

        ShowEmptyText( true );

        }

	}

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

// ShowEmptyText

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

//

void MulBaseElement::ShowEmptyText( bool aShowText  )

    {

    MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::ShowEmptyText");

     // If the application has not set any empty text , then no need to do anything 

    if( mData->mEmptyText.isEmpty() )

    	{

    	if( aShowText )

    		{

    		ShowHideVisualsForEmptyText(false);

    		HandleSizeChangeOnMain();

    		}

    	else

    		{

    		ShowHideVisualsForEmptyText(true);

    		}

    	return;

    	}

    if( aShowText )

    	{

    	if( !mData->mEmptyTextVisual )

    		{

    		CreateEmptyTextVisualisation();		

    		}

    	// This function is called twice only when an empty model is set and the app sets the empty text twice .	

    	ShowHideVisualsForEmptyText(false);	

    	if( mData->mEmptyTextOpacity == KBackGroundOpacity && mData->mEmptyTextVisual )

    		{

	    	mData->mEmptyTextVisual->SetOpacity(KHighlightOpacity);

	    	mData->mEmptyTextOpacity = KHighlightOpacity;

	    	}

    	HandleSizeChangeOnMain();

    	}

    else

    	{

    	ShowHideVisualsForEmptyText(true);

    	if( mData->mEmptyTextVisual && mData->mEmptyTextOpacity == 1 )

    		{

    		mData->mEmptyTextVisual->SetOpacity(KBackGroundOpacity);

    		mData->mEmptyTextOpacity = KBackGroundOpacity;

    		}

    	}

    }

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

// HandleSizeChangeOnMain()

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

// 

void  MulBaseElement::HandleSizeChangeOnMain()

	{

	MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::HandleSizeChangeOnMain");

	IMulModelAccessor* model = ((MulCoverFlowControl*)&control())->ModelAccessor(); 

	CAlfLayout* main  = (CAlfLayout*)findVisual( KMainLayoutIndex );

	TSize topLayoutSize = main->Size().Target().AsSize(); ;

	if( !model )

		{

		if (topLayoutSize != TSize(0,0))

			{

			SetDefaultSize(topLayoutSize);

			}

		else

			{

			SetDefaultSize( control().DisplayArea().Size() );

			}

		}

	else

	    {

	    SetDefaultSize(topLayoutSize);		

	    }

	}

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

// IsEmptyText

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

// 

bool  MulBaseElement::IsEmptyText()

	{

	return !(mData->mEmptyText.isEmpty());

	}  

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

// ShowHideVisualsForEmptyText

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

// 

void  MulBaseElement::ShowHideVisualsForEmptyText( bool aShow )

	{

	MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::ShowHideVisualsForEmptyText");

	if( !aShow )

		{

		SetTextVisualOpacity( KBackGroundOpacity );

		SetCounterTextOpacity( KBackGroundOpacity);   

		}

	else 

		{

		if(mData->mTextVisible)

			{

			SetTextVisualOpacity( KHighlightOpacity );	

			}