mulwidgets/mulcoverflowwidget/src/mulbaseelement.cpp
branchRCL_3
changeset 26 0e9bb658ef58
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mulwidgets/mulcoverflowwidget/src/mulbaseelement.cpp	Wed Sep 01 12:23:18 2010 +0100
@@ -0,0 +1,2961 @@
+/*
+* 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 );	
+			}		
+		// if ui on off template is enabled then reset the counter 
+		// opacity depending on the current ui on/off value
+		if( Template2D()->IsUiOnOffFlagEnabled() )
+			{
+			ResetUiOnOff();	
+			}
+		else
+			{
+			SetCounterTextOpacity( KHighlightOpacity);   
+			}	
+		}
+	}
+	
+// ---------------------------------------------------------------------------
+// CreateEmptyTextVisualisation
+// ---------------------------------------------------------------------------
+//	
+void MulBaseElement::CreateEmptyTextVisualisation() 
+	{
+	MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::CreateEmptyTextVisualisation");
+ 
+	if( !mData->mEmptyTextVisual )
+		{
+		THROW_IF_LEAVES
+		 ( 
+		 	CAlfLayout* main = static_cast<CAlfLayout*>(findVisual( KMainLayoutIndex ));
+		    mData->mEmptyTextVisual = CAlfTextVisual::AddNewL(control(),main);
+		    
+		    TBuf<KTempBufferSize> desc; 
+		   
+		    MulModelUtility::ConvertUStringToTDes(mData->mEmptyText, desc);   
+		    mData->mEmptyTextVisual->SetTextL(desc);
+		    mData->mEmptyTextVisual->SetTagL(KEmptyText);
+		    mData->mEmptyTextVisual->SetWrapping(CAlfTextVisual::ELineWrapBreak);
+		       
+		    TInt fontId =control().Env().TextStyleManager()
+				.CreatePlatformTextStyleL(EAknLogicalFontSecondaryFont,-1);	
+		    // check if user has set any different color for text.
+			if (mData->mTextColor.mIsColorSet)
+				{
+				// apply the color set by the application
+				mData->mEmptyTextVisual->SetColor(mData->mTextColor.mColor);
+				}
+			else
+				{
+				// apply the default color
+				mData->mEmptyTextVisual->SetColor(KRgbWhite);
+				}
+			
+			mData->mEmptyTextVisual->SetLineSpacing(KTextRowsz);
+			mData->mEmptyTextVisual->SetTextStyle(fontId);
+		    mData->mEmptyTextVisual->SetFlag(EAlfVisualFlagIgnorePointer);
+		 );
+		
+		}
+    }
+
+
+
+// ---------------------------------------------------------------------------
+// DisplayIndicatorIcon
+// ---------------------------------------------------------------------------
+// 
+void MulBaseElement::DisplayIndicatorIcon(const MulVisualItem & aVisualItem, int aIndex)
+    {
+    MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::DisplayIndicatorIcon");
+    CAlfDeckLayout& layout = static_cast<CAlfDeckLayout&>(mData->mIconFlowLayout->Visual(aIndex));
+    CAlfImageVisual* visual =static_cast<CAlfImageVisual*>(layout.FindTag(KCoverflowIndicator));    
+    IMulVariantType* varData = aVisualItem.Attribute(mulvisualitem::KMulIndicator2); 
+    
+    if(varData)
+        {
+        if(!visual)
+            {
+            visual = CreateIndicatorIconVisual(layout);   
+            }
+        ((MulCoverFlowControl*)&control())->DoSetImage(varData,visual);
+        visual->ClearFlag(EAlfVisualFlagIgnorePointer);
+        }
+
+    else if(visual)
+        {
+        CAlfTextureManager& textureMgr = control().Env().TextureManager();
+        TAlfImage image = TAlfImage(textureMgr.BlankTexture()); 
+        visual->SetImage(image); 
+        visual->SetFlag(EAlfVisualFlagIgnorePointer);
+        }
+
+    }
+ 
+// ---------------------------------------------------------------------------
+// CreateIndicatorIconVisual
+// ---------------------------------------------------------------------------
+//    
+CAlfImageVisual*  MulBaseElement::CreateIndicatorIconVisual(CAlfDeckLayout& aLayout) 
+    {
+    MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::CreateIndicatorIconVisual");
+    CAlfImageVisual* indicatorVisual = CAlfImageVisual::AddNewL(control(), &aLayout);
+    indicatorVisual->SetTagL(KCoverflowIndicator); 
+    SetIndicatorDimensions(*indicatorVisual);
+    indicatorVisual->SetScaleMode(CAlfImageVisual::EScaleNormal);
+    
+    return indicatorVisual;
+    }
+
+// ---------------------------------------------------------------------------
+// SetIndicatorDimensions
+// ---------------------------------------------------------------------------
+//  
+void  MulBaseElement::SetIndicatorDimensions(CAlfImageVisual& aIndicatorVisual)
+    {
+    MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::SetIndicatorDimensions");
+    TMulCoverFlowItem indicatorDimensions = Template2D()->IndicatorDimension();
+    aIndicatorVisual.SetPos(TAlfRealPoint(indicatorDimensions.posx,indicatorDimensions.posy));
+    aIndicatorVisual.SetSize(TAlfRealSize(indicatorDimensions.width ,indicatorDimensions.height));    
+    }
+    
+// ---------------------------------------------------------------------------
+// StoreVisualDimensions
+// ---------------------------------------------------------------------------
+// 
+void MulBaseElement::StoreVisualDimensions( TMulCoverFlowItem aHighlightItemDimensions, TMulCoverFlowItem aNonHighlightItemDimensions,int aVisibleIconCount )
+ 	{
+ 	MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::StoreVisualDimensions");
+ 	mData->mHighlightItemStruct = aHighlightItemDimensions;
+	mData->mItemStruct = aNonHighlightItemDimensions;
+	mData->mVisibleCount = aVisibleIconCount;
+	((MulCoverFlowControl*)&control())->StoreVisibleItemCount(mData->mVisibleCount);
+	if (mData->mVisibleCount > 1)
+		{
+		mData->mChangeSize = true;	
+		}
+	else
+		{
+		mData->mChangeSize = false;	
+		}
+ 	}
+
+// ---------------------------------------------------------------------------
+// StoreTextVisibility
+// ---------------------------------------------------------------------------
+//	
+void MulBaseElement::StoreTextVisibility( bool aIsTextVisible )
+	{
+	MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::StoreTextVisibility");
+	mData->mTextVisible = aIsTextVisible;
+	}
+
+
+// ---------------------------------------------------------------------------
+// IsTextVisibile
+// ---------------------------------------------------------------------------
+//  
+bool MulBaseElement::IsTextVisibile( )const
+    {
+    MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::IsTextVisible");
+    return mData->mTextVisible ;
+    }
+
+
+// ---------------------------------------------------------------------------
+// OrientationChange
+// ---------------------------------------------------------------------------
+//
+void MulBaseElement::OrientationChange()
+	{
+	MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::OrientationChange");
+
+	mData->mVerticalFlow->SetOpacity(0);
+	if (mData->mDummyVisual)
+		{
+		// deleting since the textextents being zero.
+		mData->mDummyVisual->RemoveAndDestroyAllD();
+		mData->mDummyVisual = NULL;
+		}
+
+	// update the attribute of visuals
+	Template2D()->CreateVisualisation(((MulCoverFlowControl*)&control())->IsLandscape(),true);
+    
+    CalculatePadding();    
+    CreateAndInitializeVisuals(true);
+	
+	// Redraw the visuals after orientation changes
+	int totalModelCount = ((MulCoverFlowControl*)&control())->TotalModelCount();    		
+	if( totalModelCount == 0 )
+		{
+		CAlfLayout* main  = (CAlfLayout*)findVisual( KMainLayoutIndex );
+		SetDefaultSize(main->Size().ValueNow().AsSize());		
+		}
+	ArrangeItems();
+	SetNewCounterPosition(Template2D()->CounterDimensions(),true);
+	UpdateRotation();
+	mData->mVerticalFlow->SetOpacity(1);   
+	}
+
+
+//------------------Counter and Text related----------------------------------
+
+// ---------------------------------------------------------------------------
+// CreateCounterVisual
+// ---------------------------------------------------------------------------
+// 
+CAlfTextVisual& MulBaseElement::CounterVisual()
+    {
+    MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::CounterVisual");
+   	__MUL_ASSERT( mData->mVerticalFlow != 0,KNullPointer);
+
+    mData->mCounterVisual = &CreateTextVisual(KCoverflowCounter,*mData->mVerticalFlow);
+    mData->mCounterVisual->SetAlign(EAlfAlignHCenter,EAlfAlignVCenter);
+	return *mData->mCounterVisual;
+    }
+
+// ---------------------------------------------------------------------------
+// CreateVisual
+// ---------------------------------------------------------------------------
+// 
+CAlfTextVisual& MulBaseElement::CreateTextVisual(const TDesC8& aName, 
+        CAlfLayout& aLayout) 
+	{
+	MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::CreateTextVisual");
+	
+	CAlfTextVisual* textVisual =static_cast<CAlfTextVisual*>(aLayout.FindTag(aName));
+
+	if(textVisual == NULL)
+	   {
+	   THROW_IF_LEAVES
+	        (
+	   		textVisual = CAlfTextVisual::AddNewL( (CAlfControl &)control(),&aLayout); 
+	        textVisual->SetTagL(aName);
+	        ); 
+	    textVisual->SetFlag(EAlfVisualFlagIgnorePointer);
+	    textVisual->SetFlag(EAlfVisualFlagClipping);
+	   }
+	return *textVisual;  
+	}
+    
+    
+// ---------------------------------------------------------------------------
+// UpdateTextAndCounter
+// ---------------------------------------------------------------------------
+//	
+void MulBaseElement::UpdateTextAndCounter(int animationTime)
+    {
+    MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::UpdateTextAndCounter");
+    
+	UpdateTextValue(animationTime);	
+    
+    //After highlight is changed then the counter text should be updated
+    SetCounterText();
+    } 
+    
+// ---------------------------------------------------------------------------
+// SetCounterTextOpacity
+// ---------------------------------------------------------------------------
+//  
+void MulBaseElement::SetCounterTextOpacity( int aOpacity)
+    {
+    MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::SetCounterTextOpacity");
+    if(mData->mCounterVisual)
+        {
+        mData->mCounterVisual->SetOpacity( aOpacity ); 		
+        }	    
+	}
+
+    
+// ---------------------------------------------------------------------------
+// ResetUiOnOff
+// ---------------------------------------------------------------------------
+//	
+void MulBaseElement::ResetUiOnOff(int aTransitionTime)
+    {
+    MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::ResetUiOnOff");
+    
+	int totalModelCount = ((MulCoverFlowControl*)&control())->TotalModelCount();
+    if(mData->mCounterVisual && Template2D() && Template2D()->IsUiOnOffFlagEnabled() && totalModelCount>0 )
+        {
+        int opacity = mData->mUiOn? KHighlightOpacity: KBackGroundOpacity;
+        mData->mCounterVisual->SetOpacity( TAlfTimedValue(opacity,aTransitionTime)  ); 
+        // Every time In template4 Ui on off mode toggles we should set the enable holding flag 
+		// to gesture helper to recieve the hold events.
+		((MulCoverFlowControl*)&control())->SetHoldingEnabled(); 
+        }
+    } 
+    
+// ---------------------------------------------------------------------------
+// UIOnOffMode
+// ---------------------------------------------------------------------------
+//
+void MulBaseElement::UIOnOffMode(bool aUiOn, int aTransitionTime)
+    {
+    MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::UIOnOffMode");
+      
+    mData->mUiOn = aUiOn;
+    ResetUiOnOff( aTransitionTime );
+    }
+    
+// ---------------------------------------------------------------------------
+// IsUiOnMode
+// ---------------------------------------------------------------------------
+//  
+bool MulBaseElement::IsUiOnMode()
+	{
+    return mData->mUiOn;	
+	}
+
+
+// ---------------------------------------------------------------------------
+// SetTextVisualOpacity
+// ---------------------------------------------------------------------------
+//
+void MulBaseElement::SetTextVisualOpacity( int aOpacity , int aTransitionTime )
+	{
+	MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::SetTextVisualOpacity"); 
+	if(mData->mTextLayout)
+		{
+    	mData->mTextLayout->SetOpacity(TAlfTimedValue (aOpacity,aTransitionTime));
+    	}	
+	}
+
+// ---------------------------------------------------------------------------
+// UpdateTextValue
+// ---------------------------------------------------------------------------
+//
+void MulBaseElement::UpdateTextValue(int aAnimationTime)
+	{
+	MUL_LOG_ENTRY_EXIT("Mul::MulBaseElement::UpdateTextValue");
+	if( !mData->mTextVisible )
+    	{
+    	return;
+    	}
+    	
+	IMulModelAccessor* modelAccessor = ((MulCoverFlowControl*)&control())->ModelAccessor();
+	int highlightindex = static_cast<MulCoverFlowControl*>(&control())->HighlightIndex();
+    
+	if(highlightindex>=0  )
+        {
+        //set text to title
+        try
+            {
+			const MulVisualItem& item = modelAccessor->Item(highlightindex);
+			IMulVariantType* varData = item.Attribute(mulvisualitem::KMulTitle);
+            MUL_LOG_INFO("MUL::UpdateTextValue::UpdateTiltle");
+            SetTextToVisual( mulvisualitem::KMulTitle, varData  ); 
+            
+            // SetVirtualSize if required.
+            SetVirtualViewPortSize(mulvisualitem::KMulTitle);  
+            }
+        catch(...)
+            {
+            IMulVariantType* varData = NULL;
+            SetTextToVisual( mulvisualitem::KMulTitle, varData  );
+            }
+         
+         //set text to detail
+         try
+            {
+			const MulVisualItem& item = modelAccessor->Item(highlightindex);
+			IMulVariantType* varData = item.Attribute(mulvisualitem::KMulDetail);
+            MUL_LOG_INFO("MUL::UpdateTextValue::UpdateDetail");
+            SetTextToVisual( mulvisualitem::KMulDetail, varData );
+            
+            // SetVirtualSize if required.
+            SetVirtualViewPortSize(mulvisualitem::KMulDetail);  
+            }
+        catch(...)
+            {
+            IMulVariantType* varData = NULL;
+            SetTextToVisual( mulvisualitem::KMulDetail,varData );
+            } 
+        
+        // Cancel if any command is in process before start marquee.
+        CancelAllCommands();
+        
+        // Before orientaion change stop marquee on the text
+        if(!((static_cast<MulCoverFlowControl&>(control())).IsFastScrollMode())) 
+            {            
+            control().Env().Send(
+                TAlfCustomEventCommand(ECustomEventMarqueeStart, 
+                &control()), KMarqueeTime1000 + aAnimationTime);
+            
+            }
+        }
+	}
+// ---------------------------------------------------------------------------
+// SetTextToVisual
+// ---------------------------------------------------------------------------
+//
+void MulBaseElement::SetTextToVisual( mulvisualitem::TVisualAttribute aName,IMulVariantType* aText )
+	{
+	MUL_LOG_ENTRY_EXIT("Mul::MulBaseElement::SetTextToVisual");
+
+	if(mData->mTextLayout)
+		{
+		CAlfTextVisual* textVisual = 
+			static_cast<CAlfTextVisual*> (mData->mTextLayout->FindTag( IdToTag(aName) ));
+
+		if(textVisual)
+			{
+			if ( aText )
+				{  
+				// set text to visual
+				THROW_IF_LEAVES
+					(
+					MUL_LOG_INFO("MUL::SetTextToVisual::Set New Data");
+					textVisual->SetTextL(aText->DesC());
+					textVisual->SetWrapping(CAlfTextVisual::ELineWrapTruncate);
+					);
+				    // A workaround till the text visual starts giving the correct text extents value.
+		            if(!mData->mDummyVisual)
+		                {
+		                mData->mDummyVisual = CAlfTextVisual::AddNewL(control(), NULL);
+		                mData->mDummyVisual->SetWrapping(CAlfTextVisual::ELineWrapManual);
+		                mData->mDummyVisual->SetOpacity(0);
+		                mData->mDummyVisual->SetFlags(EAlfVisualFlagIgnorePointer);
+		                }
+		            
+		            // Setting the style same as our text visual.
+		            mData->mDummyVisual->SetTextStyle(textVisual->TextStyle()); 
+		            mData->mDummyVisual->SetTextL(aText->DesC()); // Setting the text
+		            	        
+		            if(aName == mulvisualitem::KMulDetail)
+		                {
+		                mData->mDetailExt = mData->mDummyVisual->TextExtents();
+		                }
+		            else
+		                {
+		                mData->mTitleExt = mData->mDummyVisual->TextExtents();
+		                }
+				}
+			else
+				{
+				// reset to null value .
+				THROW_IF_LEAVES
+					(
+					textVisual->SetTextL(_L(""));
+					);
+				}
+			}
+		else
+			{
+			mData->mTextLayout->SetOpacity(TAlfTimedValue(KBackGroundOpacity,0));   
+			}   
+		}
+	}
+
+// ---------------------------------------------------------------------------
+// SetVirtualViewPortSize()
+// ---------------------------------------------------------------------------
+//    
+void MulBaseElement::SetVirtualViewPortSize(mulvisualitem::TVisualAttribute aName)
+    {
+    MUL_LOG_ENTRY_EXIT("Mul::MulBaseElement::SetVirtualViewPortSize");
+	CAlfViewportLayout* viewportLayout = NULL ;
+	CAlfTextVisual* text = NULL ;
+	TSize textExtent ;
+	TSize parentSize;
+	if (aName == mulvisualitem::KMulDetail)
+	    {
+	    viewportLayout = static_cast<CAlfViewportLayout*>(
+	            mData->mTextLayout->FindTag(KDetailViewPortLayout));
+	    if(!viewportLayout)
+	        {
+	        return; // return if no viewport
+	        }
+        textExtent = mData->mDetailExt;
+        parentSize = Template2D()->DetailWindowSize();
+	          
+	    }
+	else
+	    {
+	    viewportLayout = static_cast<CAlfViewportLayout*>(
+	            mData->mTextLayout->FindTag(KTitleViewPortLayout));
+	    if(!viewportLayout)
+	        {
+	        return; // return if no viewport
+	        }
+       textExtent = mData->mTitleExt;
+       parentSize = Template2D()->TitleWindowSize();
+	        
+	    }
+	text = static_cast<CAlfTextVisual*>(
+	        viewportLayout->FindTag( IdToTag(aName) ));
+	if(!text)
+	    {
+	    return; // if text visual is not found we will not set viewportsize.
+	    }
+	
+	viewportLayout->SetViewportPos((TAlfRealPoint(0, 0)), 0);
+    viewportLayout->SetVirtualSize(
+            (TAlfRealPoint(parentSize.iWidth, parentSize.iHeight)),0);   
+	
+	//Tollerance is 15 pixel, it might happen that
+	// the text is big but while wrapping it not filling the whole
+	// width of the layout because the remaining space is less to
+	// accomodate a character.
+	// As for QFN_PRIMARY the max character width is 15 pixel
+	// so I am keeping tollerance as 15 
+	// @TODO: Insted of hard coding to 15 pixel use max charecter 
+	// width for QFN_PRIMARY.
+	if ((parentSize.iWidth - textExtent.iWidth) > 15)
+		{
+		text->SetAlign(EAlfAlignHCenter, EAlfAlignVCenter); 	
+		}
+	else
+		{
+		text->SetAlign(EAlfAlignHLocale,EAlfAlignVCenter);
+		}
+    }
+
+// ---------------------------------------------------------------------------
+// StartMarquee()
+// ---------------------------------------------------------------------------
+//
+void MulBaseElement::StartMarquee(mulvisualitem::TVisualAttribute aName)
+    {
+    MUL_LOG_ENTRY_EXIT("Mul::MulBaseElement::StartMarquee");
+    // start marquee.
+    int widthOffScreen = 0;
+    CAlfViewportLayout* viewportLayout = NULL ;
+    CAlfTextVisual* text =  NULL ;
+	TSize textExtent ;
+	TSize parentSize;
+	int maxCharWidth ;
+	if (aName == mulvisualitem::KMulDetail)
+        {
+        viewportLayout =static_cast<CAlfViewportLayout*>(
+                mData->mTextLayout->FindTag(KDetailViewPortLayout));
+        if(!viewportLayout)
+            {
+            return;// return if no viewport
+            }                  
+       textExtent = mData->mDetailExt;
+       parentSize = Template2D()->DetailWindowSize();
+       maxCharWidth = Template2D()->DetailMaxCharWidth();         
+        }
+    else
+        {
+        viewportLayout = static_cast<CAlfViewportLayout*>(
+                mData->mTextLayout->FindTag(KTitleViewPortLayout));
+        if(!viewportLayout)
+            {
+            return;// return if no viewport
+            }
+       textExtent = mData->mTitleExt;
+       parentSize = Template2D()->TitleWindowSize();
+       maxCharWidth = Template2D()->TitleMaxCharWidth();
+        }
+	text = static_cast<CAlfTextVisual*>(
+	        viewportLayout->FindTag( IdToTag(aName) ));
+	if(!text)
+	    {
+	    return; // if no text.
+	    }
+	
+    text->SetWrapping(CAlfTextVisual::ELineWrapManual);
+   
+    widthOffScreen= textExtent.iWidth - parentSize.iWidth;
+    int nDbMaxChars = (widthOffScreen/(2*maxCharWidth)) + 1;
+	          	        
+    // Schedule a update event, when the visual has finished marquee text scrolling.
+    if (aName == mulvisualitem::KMulDetail)
+        {
+        if (nDbMaxChars > 0 )
+            {
+			viewportLayout->SetVirtualSize(
+			        (TAlfRealPoint(textExtent.iWidth, parentSize.iHeight)),0);                  
+            // to avoid negative time value
+            mData->mMarqueeAnimTime = (nDbMaxChars*KMarqueeTime1000);
+            viewportLayout->SetViewportPos((TAlfRealPoint(widthOffScreen , 0)), 
+                    nDbMaxChars * KMarqueeTime1000);
+            // delay after completion of the marquee for titlte.
+            mData->mMarqueeAnimTime += KMarqueeTime1000;
+            control().Env().Send(
+                TAlfCustomEventCommand(ECustomEventMarqueeFinished, 
+                static_cast<CAlfControl*>(&(control()))), 
+                mData->mMarqueeAnimTime);
+            }
+        }
+    else
+        {
+        // reset the marquee animation time
+        mData->mMarqueeAnimTime = 0;  
+        if(nDbMaxChars > 0)
+            {
+			viewportLayout->SetVirtualSize(
+			        (TAlfRealPoint(textExtent.iWidth, parentSize.iHeight)),0);  
+            
+            // to avoid negative time value
+            mData->mMarqueeAnimTime = (nDbMaxChars*KMarqueeTime1000);  
+            viewportLayout->SetViewportPos((TAlfRealPoint(widthOffScreen , 0)), 
+                    nDbMaxChars * KMarqueeTime1000);
+            // delay after completion of the marquee for titlte.
+            mData->mMarqueeAnimTime += KMarqueeTime1000;
+            control().Env().Send(
+                TAlfCustomEventCommand(ECustomEventTitleMarqueeFinished, 
+                static_cast<CAlfControl*>(&(control()))), 
+                mData->mMarqueeAnimTime );
+            // delay before start the marquee for detail.
+            mData->mMarqueeAnimTime += KMarqueeTime1000;
+            }
+        control().Env().Send(
+            TAlfCustomEventCommand(ECustomEventDetailMarqueeStart, 
+            (&(control()))), mData->mMarqueeAnimTime );
+        }
+    } 	
+    
+// ---------------------------------------------------------------------------
+// StopMarquee()
+// ---------------------------------------------------------------------------
+//
+void MulBaseElement::StopMarquee(mulvisualitem::TVisualAttribute aName)
+    {
+    MUL_LOG_ENTRY_EXIT("Mul::MulBaseElement::StopMarquee");
+    CAlfViewportLayout* viewPortLayout = NULL; 
+    CAlfTextVisual* text = NULL;
+    TSize parentSize;
+    if (aName == mulvisualitem::KMulDetail)
+        {
+        viewPortLayout =
+            static_cast<CAlfViewportLayout*>(mData->mTextLayout->FindTag(KDetailViewPortLayout));
+        parentSize = Template2D()->DetailWindowSize();
+        }
+    else
+        {
+        viewPortLayout =
+            static_cast<CAlfViewportLayout*>(mData->mTextLayout->FindTag(KTitleViewPortLayout));
+        parentSize = Template2D()->TitleWindowSize();
+        }
+   if(!viewPortLayout)
+       {
+       return;
+       }
+   text = static_cast<CAlfTextVisual*>(viewPortLayout->FindTag( IdToTag(aName) ));
+   if(!text)
+       {
+       return;
+       }
+   const TDesC textDesc = text->Text();
+   if(!textDesc.Length())
+       {
+       return;
+       }
+  
+    viewPortLayout->SetViewportPos((TAlfRealPoint(0, 0)), 0);
+    viewPortLayout->SetVirtualSize((TAlfRealPoint(parentSize.iWidth, parentSize.iHeight)),0);   
+    text->SetWrapping(CAlfTextVisual::ELineWrapTruncate);
+               
+    }
+
+// ---------------------------------------------------------------------------
+// CancelAllCommands
+// ---------------------------------------------------------------------------
+//  
+void MulBaseElement::CancelAllCommands( )
+    {
+    MUL_LOG_ENTRY_EXIT("Mul::MulBaseElement::CancelAllCommands");
+    CAlfWidgetControl * cntrl = &control();
+    control().Env().CancelCustomCommands( cntrl, ECustomEventMarqueeFinished);
+    control().Env().CancelCustomCommands( cntrl, ECustomEventMarqueeStart);
+    control().Env().CancelCustomCommands( cntrl, ECustomEventTitleMarqueeFinished);
+    control().Env().CancelCustomCommands( cntrl, ECustomEventDetailMarqueeStart); 
+    }
+
+// ---------------------------------------------------------------------------
+// SetCounterText
+// ---------------------------------------------------------------------------
+//	
+void MulBaseElement::SetCounterText( int /*aTransitionTime*/ )
+	{
+	MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::SetCounterText");
+	   
+    if( mData->mCounterVisual )
+    	{
+    	SetNewCounterPosition(Template2D()->CounterDimensions());
+    	int totalModelCount = ((MulCoverFlowControl*)&control())->TotalModelCount();
+    	int currHighlightIndex = ((MulCoverFlowControl*)&control())->HighlightIndex();
+		
+		// this code will work for model count upto 99999.
+		// done for performance improvement , no need to calculate 
+		// no of digits in highlight index and total model count.
+    	auto_ptr<HBufC> countbuffer(HBufC::NewL (12)); 
+      
+        //settin value for counter text visual
+        /// @bug critical:avanhata:7/7/2008 in arabic/hebrew the text should flow
+        /// from right to left (totalCount / highlight) => the string format needs
+        /// to come from a resource file, and use stringloader (and arabic indic number
+        /// conversion if stringloader does not do it automatically)
+        countbuffer->Des().AppendNum(currHighlightIndex+1);
+        countbuffer->Des().Append(KSlash);
+        countbuffer->Des().AppendNum(totalModelCount);
+
+        mData->mCounterVisual->SetTextL(*countbuffer);
+    	}    
+	}
+
+//--------------------------------------------------------------------------
+// SetNewCounterPosition
+//--------------------------------------------------------------------------
+//
+void MulBaseElement::SetNewCounterPosition( const TMulCoverFlowItem& aCounterLctDimension, bool aOrientationChanged)
+	{
+	MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::SetNewCounterPosition");
+	MulCoverFlowControl* coverflowControl = ((MulCoverFlowControl*)&control());
+	int totalModelCount = coverflowControl->TotalModelCount();
+	int currHighlightIndex = coverflowControl->HighlightIndex();
+	bool isLandScape = static_cast<MulCoverFlowControl&>(control()).IsLandscape();
+    
+    if( totalModelCount > 0 && currHighlightIndex >= 0 )
+    	{
+    	int numOfDigits = NumberOfDigits(totalModelCount);
+    	numOfDigits += NumberOfDigits(currHighlightIndex);
+   		
+   		if( mData->mNumOfDigitsInCounter!= numOfDigits || aOrientationChanged )
+   			{
+        	mData->mNumOfDigitsInCounter = numOfDigits;
+        	int maxCharWidth = coverflowControl->Template2D()->CounterMaxCharWidth();
+        	int numOfPixels = numOfDigits*maxCharWidth + 20; // 10 is the tolerance.
+  
+        	int rightPosx =0; 
+        	int leftPosx = 0;
+        	// if mirroring is enabled(ie for RTL Language)
+        	if (mData->mIsMirrored)
+        		{
+        			
+	        		CAlfLayout* main  = (CAlfLayout*)findVisual( KMainLayoutIndex );
+							TSize topLayoutSize = main->Size().Target().AsSize();
+							if(!isLandScape)
+        			{
+	        		rightPosx = topLayoutSize.iWidth - aCounterLctDimension.posx ;
+	        		leftPosx = rightPosx - numOfPixels;
+	        		}
+	        		else
+	        		{
+	        		leftPosx = topLayoutSize.iWidth - aCounterLctDimension.posx  ;
+	        		}
+        		}
+        	else
+        		{
+        				if(!isLandScape)
+        					{
+        					rightPosx = aCounterLctDimension.posx + aCounterLctDimension.width; 
+        					leftPosx = rightPosx - numOfPixels;
+        					}
+        				else	
+        					leftPosx = aCounterLctDimension.posx;
+        		}
+	   		mData->mCounterVisual->SetPos(TAlfRealPoint(leftPosx,aCounterLctDimension.posy));
+		    mData->mCounterVisual->SetSize(TAlfRealPoint(numOfPixels ,aCounterLctDimension.height));
+   			}
+    	}
+	}
+// ---------------------------------------------------------------------------
+// NumberOfDigits
+// ---------------------------------------------------------------------------
+//
+int MulBaseElement::NumberOfDigits(int aNumber)
+    {
+    MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::NumberOfDigits");
+    int num_digits = 0;
+    int number = aNumber;
+    do 
+    	{
+    	num_digits++;
+		number/=10;	
+    	}
+    while ( number > 0 );
+    
+    return 	num_digits;
+    }
+    	
+// ---------------------------------------------------------------------------
+// ApplyScaleMode
+// ---------------------------------------------------------------------------
+//
+void MulBaseElement::ApplyScaleMode( CAlfImageVisual& aImageVisual)
+	{
+	MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::ApplyScaleMode");
+    CAlfImageVisual::TScaleMode scaleMode; 
+
+    if (mData->mFitMode)
+	    {
+	    if(aImageVisual.Image().HasTexture())
+	        {
+	        CAlfTexture* texture = const_cast<CAlfTexture*>(&aImageVisual.Image().Texture());
+	        TInt imageWidth = texture->Size().iWidth;
+	        TInt imageHeight = texture->Size().iHeight;
+	        // when animation is not complete sizes will not be correct.
+	        // so sizes are taken from template   
+	        if(imageWidth == 0 || imageHeight == 0) 
+		        {
+		        scaleMode = CAlfImageVisual::EScaleFitInside;
+		        }
+	        else if( imageWidth <= mData->mHighlightItemStruct.width && 
+	        	imageHeight <= mData->mHighlightItemStruct.height )
+	            {
+	            scaleMode = CAlfImageVisual::EScaleNormal;
+	            }
+	        else
+	            {
+		        scaleMode = CAlfImageVisual::EScaleFitInside;
+	            }
+	        }
+	    else
+	        {
+		    scaleMode = CAlfImageVisual::EScaleFitInside;
+	        }
+	    }
+	else
+		{
+		// Apply default scale mode
+		scaleMode = CAlfImageVisual::EScaleFitInside;
+		}
+     
+	if (aImageVisual.ScaleMode() != scaleMode) 
+		{
+	    aImageVisual.SetScaleMode( scaleMode ); 	
+		}
+	 ApplyBrushOnIcon( aImageVisual );	
+    }
+    
+// ---------------------------------------------------------------------------
+// ApplyBrushOnIcon
+// ---------------------------------------------------------------------------
+//
+void MulBaseElement::ApplyBrushOnIcon( CAlfImageVisual& aImageVisual )
+    { 
+    MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::ApplyBrushOnIcon");  
+    if( mData->mIconBgColor.mIsColorSet )
+    	{
+    	aImageVisual.EnableBrushesL(ETrue); 
+    	CAlfBrushArray* brushArray = aImageVisual.Brushes();
+	    if( (brushArray->Count()==0))
+	        {
+	        CAlfGradientBrush* brush = CAlfGradientBrush::NewL(aImageVisual.Env());     
+	    	brush->SetColor( mData->mIconBgColor.mColor );         
+	    	aImageVisual.Brushes()->AppendL( brush, EAlfHasOwnership );
+	        }
+	     else
+	     	{
+	     	CAlfGradientBrush* brush = static_cast<CAlfGradientBrush*>(&brushArray->At(0));
+	     	if ( brush->Color(0) != mData->mIconBgColor.mColor )
+		     	{
+		     	brush->SetColor( mData->mIconBgColor.mColor );  	
+		     	}
+	     	}
+    	}
+    }
+    
+// ---------------------------------------------------------------------------
+// RemoveBrushOnIcon
+// ---------------------------------------------------------------------------
+//
+void MulBaseElement::RemoveBrushOnIcon( CAlfImageVisual& aImageVisual )
+    {  
+    MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::RemoveBrushOnIcon"); 
+	CAlfBrushArray* brushArray = aImageVisual.Brushes();
+    if(brushArray && (brushArray->Count()!=0))
+        {
+     	brushArray->Remove(0);
+        }
+    }    
+
+// ---------------------------------------------------------------------------
+// Template2D
+// ---------------------------------------------------------------------------
+//
+MulCoverFlowTemplate*  MulBaseElement::Template2D()
+	{
+	MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::Template2D");
+	return ((MulCoverFlowControl*)&control())->Template2D(); 
+	}
+
+// ---------------------------------------------------------------------------
+// SetScrollAnimationTime
+// ---------------------------------------------------------------------------
+//	    
+void MulBaseElement::SetScrollAnimationTime( int aScrollAnimationTime )
+    {
+    MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::SetScrollAnimationTime");
+    mData->mScrollAnimationTime = aScrollAnimationTime;    
+    }
+   
+// ---------------------------------------------------------------------------
+// ArrangeItems
+// ---------------------------------------------------------------------------
+//	    
+void MulBaseElement::ArrangeItems()
+    { 
+	MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::ArrangeItems");
+		
+	control().Env().BatchBufferHandler().SetAutoFlushMode(EAlfAutoFlushOnlyForced); 
+
+	int totalVisual = 2*mData->mVisibleCount + 1;
+	int highlightIndex = mData->mVisibleCount;
+	CAlfImageVisual* imageVisual = NULL;	
+
+
+	int posX = mData->mHighlightItemStruct.posx - mData->mVisibleCount*(mData->mItemStruct.width + mData->mPadding);
+	
+	TAlfRealPoint highlightItemSize(mData->mHighlightItemStruct.width, mData->mHighlightItemStruct.height);
+	TAlfRealPoint nonHighlightItemSize(mData->mItemStruct.width, mData->mItemStruct.height);
+
+	for (int i=0; i < totalVisual ; i++)  
+	    {
+	    CAlfVisual& deckLayout = mData->mIconFlowLayout->Visual(i);		
+		imageVisual = (CAlfImageVisual*)deckLayout.FindTag(KCoverflowIcon);
+	    
+		if (i != highlightIndex)
+			{
+			deckLayout.SetPos( TAlfRealPoint(posX,mData->mItemStruct.posy));
+		 	deckLayout.SetSize(nonHighlightItemSize);
+		   	imageVisual->SetSize(nonHighlightItemSize);
+		   	posX = posX + mData->mItemStruct.width + mData->mPadding;
+			}
+		else
+			{
+		    deckLayout.SetPos( TAlfRealPoint(mData->mHighlightItemStruct.posx,mData->mHighlightItemStruct.posy));
+		 	deckLayout.SetSize(highlightItemSize);
+		   	imageVisual->SetSize(highlightItemSize);
+		   	posX = posX + mData->mHighlightItemStruct.width + mData->mPadding;
+			}
+		if (mData->mFitMode)
+			{
+			ApplyScaleMode(*imageVisual);
+			}
+	   	CAlfImageVisual* indicatorVisual =static_cast<CAlfImageVisual*>(deckLayout.FindTag(KCoverflowIndicator));    
+        if (indicatorVisual)
+            {
+            SetIndicatorDimensions(*indicatorVisual);    
+            }
+	
+	    }
+	    
+	control().Env().BatchBufferHandler().FlushBatchBuffer();            
+	control().Env().BatchBufferHandler().SetAutoFlushMode(EAlfAutoFlushDeferred);           
+	        
+    }
+
+// ---------------------------------------------------------------------------
+// SetScrollDir
+// ---------------------------------------------------------------------------
+//    
+void MulBaseElement::SetScrollDir( TItemScroll aScrollDir )
+    {
+    MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::SetScrollDir");
+    mData->mScrollDir = aScrollDir;   
+    }
+
+// ---------------------------------------------------------------------------
+// SetScrollDir
+// ---------------------------------------------------------------------------
+//    
+TItemScroll MulBaseElement::ScrollDir()
+    {
+    MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::ScrollDir");
+    return mData->mScrollDir;   
+    }    
+
+// ---------------------------------------------------------------------------
+// CalculatePadding
+// ---------------------------------------------------------------------------
+//	
+void MulBaseElement::CalculatePadding()
+    {
+    MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::CalculatePadding");
+    
+    // The vector has already been created when the template was set. 
+     if( mData->mVisibleCount == 1)
+        {
+        if( mData->mHighlightItemStruct.posx > KInitialvalueZero )
+            {
+            mData->mPadding = mData->mHighlightItemStruct.posx;
+            }
+        else
+            {
+            // full screen template ..photos
+            // padding between the highlight and non highlight item is considered to be 2 pixel for 
+            // full screen template as only one visual is visible.
+            mData->mPadding = 2;
+            }
+        }
+   else
+        {
+        int startx = mData->mHighlightItemStruct.posx+ mData->mHighlightItemStruct.width;
+        mData->mPadding = mData->mItemStruct.posx - startx;
+        } 
+    }
+
+
+// ---------------------------------------------------------------------------
+// GetIconSize
+// ---------------------------------------------------------------------------
+//
+void MulBaseElement::GetIconSize( mulwidget::TLogicalTemplate aTemplateId, 
+		    mulvisualitem::TVisualAttribute aAttribute, int& aHeight, int& aWidth)
+	{
+	MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::GetIconSize");
+
+	bool isLandscape = ((MulCoverFlowControl*)&control())->IsLandscape();
+	switch(aTemplateId)
+		{
+		case mulwidget::KTemplate1:
+			{
+			MulCoverFlowTemplate1::GetIconSize(aAttribute,isLandscape,aHeight,aWidth);
+			}
+		break;
+		case mulwidget::KTemplate4:
+			{
+			MulCoverFlowTemplate4::GetIconSize(aAttribute,isLandscape,aHeight,aWidth);
+			}
+		break;
+		default:
+			{
+			// Invalid template id
+			// raise exception
+			__MUL_ASSERT(false,KInvalidTemplate);
+			}
+		break;
+		}
+	}
+
+
+// ---------------------------------------------------------------------------
+// ShowWidget
+// ---------------------------------------------------------------------------
+//		
+void MulBaseElement::ShowWidget( bool aShow, int aTransitionTime ) 
+	{
+	MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::ShowWidget");
+	float opacity ;
+	CAlfLayout* main = (CAlfLayout*) findVisual( KMainLayoutIndex );
+
+    if( aShow )
+		{
+		opacity =  KHighlightOpacity;
+		}
+	else
+		{
+		opacity =  KBackGroundOpacity;
+		}
+	main->SetOpacity(TAlfTimedValue(opacity,aTransitionTime));
+	}
+
+// ---------------------------------------------------------------------------
+// makeInterface
+// ---------------------------------------------------------------------------
+//	        
+IAlfInterfaceBase* MulBaseElement::makeInterface( const IfId& aType )
+    {
+    MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::makeInterface");
+    UString param(aType.mImplementationId);
+     
+    if(param == MulBaseElement::Type().mImplementationId )
+        {
+        return static_cast<IAlfElement*>(this);  
+        }    
+   else if(param == IAlfWidgetEventHandler::type().mImplementationId )
+        {
+        return static_cast<IAlfWidgetEventHandler*>(this);  
+        }
+    else 
+        {
+        return AlfElement::makeInterface(aType);    
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// setEventHandlerData
+// ---------------------------------------------------------------------------
+//
+void MulBaseElement::setEventHandlerData( const AlfWidgetEventHandlerInitData& /*aData*/ )
+	{
+	//No implementation required		
+	}
+
+// ---------------------------------------------------------------------------
+// eventHandlerData
+// ---------------------------------------------------------------------------
+//
+AlfWidgetEventHandlerInitData* MulBaseElement::eventHandlerData()
+	{
+    return NULL;		
+	}
+	
+// ----------------------------------------------------------------------------
+// eventHandlerType
+// ----------------------------------------------------------------------------
+//
+ IAlfWidgetEventHandler::AlfEventHandlerType MulBaseElement::eventHandlerType() 
+	{
+	return IAlfWidgetEventHandler::ELogicalEventHandler ;
+	}
+// ----------------------------------------------------------------------------
+// eventExecutionPhase
+// ----------------------------------------------------------------------------
+//
+
+IAlfWidgetEventHandler::AlfEventHandlerExecutionPhase MulBaseElement::eventExecutionPhase()
+	{
+	return EBubblingPhaseEventHandler;
+	}   
+	
+//------------------------Slider related Api's -------------------------	
+
+//--------------------------------------------------------------------------
+// UpdateSliderTick
+//--------------------------------------------------------------------------
+//
+void MulBaseElement::UpdateSliderTick(int aUpdateTick)
+	{
+	MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::MulBaseElement");
+	IMulSliderModel* mulSliderModel = ((MulCoverFlowControl*)&control())->GetSliderModel();
+    if( mulSliderModel && Template2D()->IsSliderVisible() )
+		{
+		 // Creating a reference Visual Item
+    	//@todo remove const from Data api in slider model
+		const MulVisualItem& item = mulSliderModel->Data();
+		//auto_ptr<MulVisualItem> tempItem( new (EMM) MulVisualItem());
+		MulVisualItem* tempItem  = const_cast<MulVisualItem*> (&item);
+		  
+		tempItem->SetAttribute( mulvisualitem::KMulMaxRange, --aUpdateTick );
+		tempItem->SetAttribute (mulvisualitem::KMulMinRange, 0);
+		tempItem->SetAttribute ( mulvisualitem::KMulTick,1);
+		
+		// Add the newly created visual item to the model
+		// Model takes the ownership of the visual item
+		mulSliderModel->SetData(*tempItem);   
+		}
+		
+	// Set the opacity to the slider widget after verifyiny all the conditions.
+	SetSliderOpacity();
+	}
+//--------------------------------------------------------------------------
+// SetSliderOpacity
+//--------------------------------------------------------------------------
+//	
+void MulBaseElement::SetSliderOpacity()
+	{
+	MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::SetSliderOpacity");
+	
+	if (mData->mSliderLayout)
+		{
+		if ( Template2D()->IsSliderVisible() )
+	    	{
+	    	if( static_cast<MulCoverFlowControl&>(control()).TotalModelCount() > 1 && mData->mSliderOpacity == KBackGroundOpacity)
+		    	{
+		     	ShowSlider(true);	    	
+		    	}
+		    else if((static_cast<MulCoverFlowControl&>(control()).TotalModelCount() <= 1) && mData->mSliderOpacity == KHighlightOpacity)
+		    	{
+		    	ShowSlider(false);	    	
+		    	}
+	    	}
+	     else if(mData->mSliderOpacity == KHighlightOpacity)
+	     	{
+	     	 ShowSlider(false);	
+	     	}
+		}
+	}
+
+//--------------------------------------------------------------------------
+//CreateSlider
+//--------------------------------------------------------------------------
+//	
+void MulBaseElement::CreateSlider()
+	{
+	MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::CreateSlider");
+	if ( Template2D()->IsSliderVisible() )
+    	{
+    	MulCoverFlowControl* coverflowControl = static_cast<MulCoverFlowControl*>(&control());
+    	IAlfWidget* sliderwidget = coverflowControl->GetSliderWidget();
+    	if(!sliderwidget)
+			{
+			ConstructSliderWidget();
+			}
+
+		const TMulCoverFlowItem sliderStruct = Template2D()->SliderDimension();
+		mData->mSliderLayout->SetPos(TAlfRealPoint(sliderStruct.posx,sliderStruct.posy));
+		mData->mSliderLayout->SetSize(TAlfRealPoint(sliderStruct.width,sliderStruct.height));
+		int totalModelCount = coverflowControl->TotalModelCount();
+		if( totalModelCount > 1 )
+			{
+			UpdateSliderTick(totalModelCount);	
+			coverflowControl->SetSliderTickPosition();
+			ShowSlider(true);
+			}
+		else
+			{
+			ShowSlider(false);
+			}
+	    mData->mSliderLayout->UpdateChildrenLayout();
+    	}
+    else
+    	{
+    	if (!mData->mSliderLayout)
+	    	{
+	    	return;	
+	    	}
+	    ShowSlider(false);
+    	}
+	}
+
+//--------------------------------------------------------------------------
+//ConstructSliderWidget
+//--------------------------------------------------------------------------	
+void MulBaseElement::ConstructSliderWidget()
+	{
+	MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::ConstructSliderWidget");
+	IAlfWidget* alfSliderWidget = ((MulCoverFlowControl*)&control())->CreateSliderWidget();
+	IMulSliderWidget* mulSliderWidget = static_cast<IMulSliderWidget*>(alfSliderWidget);
+	mData->mSliderLayout = const_cast<CAlfLayout*>(&mulSliderWidget->ContainerLayout());
+	mData->mVerticalFlow->Insert(mData->mSliderLayout, mData->mVerticalFlow->Count());
+	}
+	
+
+//--------------------------------------------------------------------------
+//ShowSlider
+//--------------------------------------------------------------------------
+void MulBaseElement::ShowSlider(bool aFlag)
+	{
+	MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::ShowSlider");
+	if(mData->mSliderLayout)
+		{
+		IAlfWidget* alfSliderWidget = ((MulCoverFlowControl*)&control())->GetSliderWidget();
+		IMulSliderWidget* mulSliderWidget = static_cast<IMulSliderWidget*>(alfSliderWidget);
+		mulSliderWidget->ShowWidget(aFlag);
+		if(aFlag)
+			{
+			mData->mSliderLayout->SetOpacity(TAlfTimedValue(KHighlightOpacity));
+			mData->mSliderOpacity = KHighlightOpacity;							
+			}
+		else
+			{
+    		mData->mSliderLayout->SetOpacity(TAlfTimedValue(KBackGroundOpacity));
+    		mData->mSliderOpacity = KBackGroundOpacity;			
+			}
+		}
+	}	
+	
+    
+//--------------------------------------------------------------------------
+// StartBounce
+//--------------------------------------------------------------------------
+void MulBaseElement::StartBounce(int aBounceDirection) 
+    {
+    int bounceDistance = (mData->mHighlightItemStruct.width/4) * aBounceDirection; 	
+    control().Env().Send(TAlfCustomEventCommand(ECustomEventBounceBack,&control()),KBounceTime); 
+ 	StartDoodling(bounceDistance,KBounceTime);
+    }
+
+
+// ---------------------------------------------------------------------------
+// CalculateDistanceChangeFactor
+// ---------------------------------------------------------------------------
+//
+int MulBaseElement::CalculateDistanceChangeFactor()
+    {
+    MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::CalculateDistanceChangeFactor");
+   
+    int firstVisualMidPoint = mData->mHighlightItemStruct.posx + (mData->mHighlightItemStruct.width/2);
+    int secVisualMidPoint =  mData->mItemStruct.posx + (mData->mItemStruct.width/2);
+   
+    return Abs(secVisualMidPoint-firstVisualMidPoint);
+    }
+
+
+// ---------------------------------------------------------------------------
+// SetBackground
+// ---------------------------------------------------------------------------
+//
+void MulBaseElement::SetBackground(const TRgb& aColor)
+	{
+	MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::SetBackground");
+	
+	CAlfLayout* main = static_cast<CAlfLayout*>(findVisual( KMainLayoutIndex ));
+	CAlfDeckLayout& deckLayout = static_cast<CAlfDeckLayout&> (main->Visual(KMainLayoutIndex) );
+	
+	CAlfVisual* oldVisual = deckLayout.FindTag(backgroundvisual);
+	if(oldVisual)
+		{
+		CAlfImageVisual* imageVisual = static_cast<CAlfImageVisual*>(oldVisual);
+		if(imageVisual->Image().HasTexture())
+			{
+			const CAlfTexture& textureToUnload = imageVisual->Image().Texture();
+			CAlfTextureManager& textureMgr = control().Env().TextureManager();    
+			textureMgr.UnloadTexture(textureToUnload.Id());		
+			}
+					
+		deckLayout.Remove( oldVisual );
+		oldVisual->RemoveAndDestroyAllD();
+		}
+		
+    deckLayout.EnableBrushesL( ETrue );
+    CAlfBrushArray* brushArray = deckLayout.Brushes();
+    if(brushArray)
+        {
+		if( brushArray->Count()!=0)
+		    {
+			CAlfGradientBrush& brush = static_cast<CAlfGradientBrush&>(brushArray->At(0));		    
+		    brush.SetColor( aColor ); 
+		    }
+		else
+			{
+			THROW_IF_LEAVES
+				(
+				CAlfGradientBrush* brush = CAlfGradientBrush::NewL( control().Env() );
+				// Set the brush colour
+				brush->SetColor( aColor );
+				// Apply brush and set the opacity .
+				deckLayout.Brushes()->AppendL( brush, EAlfHasOwnership ); 
+				); 	
+			}
+        }
+	}
+
+// ---------------------------------------------------------------------------
+// SetBackground
+// ---------------------------------------------------------------------------
+//
+void MulBaseElement::SetBackground(const TAknsItemID& aIID)
+	{
+	MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::SetBackground");
+	
+	CAlfLayout* main = static_cast<CAlfLayout*>(findVisual( KMainLayoutIndex ));
+	CAlfDeckLayout& deckLayout = static_cast<CAlfDeckLayout&> (main->Visual(KMainLayoutIndex) );
+
+	CAlfBrushArray* brushArray = deckLayout.Brushes();
+    if(brushArray)
+        {     
+		if( brushArray->Count()!=0)
+		    {
+		    brushArray->Reset();            
+		    }
+        }
+		    
+	TAlfRealSize layoutSize = deckLayout.Size().ValueNow();
+	const TAlfImage image(aIID,TSize(layoutSize),EAspectRatioPreserved,NULL,-1,-1,0.f,0.f,1.f,
+					1.f, TAlfTextureFlags(EAlfTextureFlagAutoSize | EAlfTextureFlagSkinContent),
+					KAlfAutoGeneratedTextureId,NULL);							 
+                    
+	CAlfVisual* oldVisual = deckLayout.FindTag(backgroundvisual);
+	if(oldVisual)
+		{
+		CAlfImageVisual* imageVisual = static_cast<CAlfImageVisual*>(oldVisual);
+		if(imageVisual->Image().HasTexture())
+			{
+			const CAlfTexture& textureToUnload = imageVisual->Image().Texture();
+			CAlfTextureManager& textureMgr = control().Env().TextureManager();    
+			textureMgr.UnloadTexture(textureToUnload.Id());		
+			}		
+		imageVisual->SetImage(image);	
+		}
+	else
+		{
+		THROW_IF_LEAVES
+			(
+			CAlfImageVisual* imagevisual(CAlfImageVisual::AddNewL((CAlfControl&)control(), &deckLayout));
+			deckLayout.MoveVisualToBack(*imagevisual);
+			imagevisual->SetImage(image);
+			imagevisual->SetFlag(EAlfVisualFlagIgnorePointer);
+			imagevisual->SetPos(TPoint(0,0));
+		    imagevisual->SetSize(layoutSize);
+		    imagevisual->SetOpacity( KHighlightOpacity );
+		    imagevisual->SetTagL( backgroundvisual );
+			);	
+		}	
+	}
+
+// ---------------------------------------------------------------------------
+// SetItemBrush
+// ---------------------------------------------------------------------------
+//
+void MulBaseElement::SetItemBrush(const TRgb& aColor)
+    {
+    MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::SetItemBrush");
+	mData->mIconBgColor.mIsColorSet = true;
+	mData->mIconBgColor.mColor = aColor;
+	
+	int itemCount = 2*mData->mVisibleCount + 1;
+	
+	itemCount = itemCount > mData->mIconFlowLayout->Count() ? mData->mIconFlowLayout->Count() : itemCount;
+	
+	for(int i =0 ;i<itemCount;i++)
+    	{
+    	CAlfVisual& visual = mData->mIconFlowLayout->Visual( i );
+        CAlfImageVisual* imageVisual = ( CAlfImageVisual* )visual.FindTag(KCoverflowIcon);
+        ApplyBrushOnIcon( *imageVisual);    
+    	}
+    }
+
+	
+// ---------------------------------------------------------------------------
+// SetTextColor
+// ---------------------------------------------------------------------------
+//
+void MulBaseElement::SetTextColor(TTextVisualType aVisualType, const TRgb& aColor)
+    {
+    MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::SetTextColor");
+    
+    switch(aVisualType)
+	    {
+	    case ECounterVisual:
+		    {
+		    // save the values set by the application
+		    mData->mCounterColor.mIsColorSet = true;
+		    mData->mCounterColor.mColor = aColor;
+		    
+		    // apply the property if the visuals are already created
+		    if(mData->mCounterVisual)
+			    {
+			    mData->mCounterVisual->SetColor(aColor);	
+			    }
+		    break;	
+		    }
+	    case ETilteDetailTextVisual:
+		    {
+		    // save the values set by the application
+		    mData->mTextColor.mIsColorSet = true;
+		    mData->mTextColor.mColor = aColor;
+
+		    // apply the property if the visuals are already created
+		    CAlfTextVisual* titleTextVisual =static_cast<CAlfTextVisual*>(mData->mTextLayout->FindTag(KCoverflowTitle));
+	        if(titleTextVisual)
+	            {
+	            titleTextVisual->SetColor(aColor);
+	            }
+	        CAlfViewportLayout* viewPortLayout =static_cast<CAlfViewportLayout*>(mData->mTextLayout->FindTag(KDetailViewPortLayout));
+	        if(viewPortLayout)
+	            {
+	            CAlfTextVisual* detailTextVisual =static_cast<CAlfTextVisual*>(viewPortLayout->FindTag(KCoverflowDetail));
+	            if(detailTextVisual)
+	                {
+	                detailTextVisual->SetColor(aColor);
+	                }
+	            }
+            // Apply the same color for empty text also
+            if(mData->mEmptyTextVisual)
+	            {
+	            mData->mEmptyTextVisual->SetColor(aColor);	
+	            }
+		    break;	
+		    }
+		default:
+			break;
+	    }
+    }
+
+// ---------------------------------------------------------------------------
+// TextColor
+// ---------------------------------------------------------------------------
+//
+TMulVisualColorProperty MulBaseElement::TextColor(TTextVisualType aVisualType)
+    {
+    MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::TextColor");
+    TMulVisualColorProperty colorProperty;
+    
+    switch(aVisualType)
+	    {
+	    case ECounterVisual:
+		    {
+		    colorProperty = mData->mCounterColor;
+		    break;
+		    }
+	    case ETilteDetailTextVisual:
+		    {
+		    colorProperty = mData->mTextColor;
+		    break;
+		    }
+		default:
+			break;
+	    }
+	return colorProperty;
+    }
+
+// ---------------------------------------------------------------------------
+// FlowLayout
+// ---------------------------------------------------------------------------
+//
+CAlfLayout& MulBaseElement::FlowLayout( int aLayoutIndex )
+      {
+      MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::FlowLayout");
+      
+      return static_cast<CAlfLayout&>(mData->mVerticalFlow->Visual( aLayoutIndex ));
+      }
+
+// ---------------------------------------------------------------------------
+// SetFitMode
+// ---------------------------------------------------------------------------
+//      
+void MulBaseElement::SetFitMode(bool aFlag)
+	{
+	MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::SetFitMode");
+	mData->mFitMode = aFlag;
+	}
+	
+// ----------------------------------------------------------------------------
+// CreateAndInitializeVisuals
+// ----------------------------------------------------------------------------
+//
+void MulBaseElement::CreateAndInitializeVisuals(bool aIsOrientationChange)
+	{
+	MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::CreateAndInitializeVisuals");
+	CreateVisuals();
+
+	// Specific to template 4 don't update the visuals
+	// during orientation change
+	// done for performance improvement.
+	if (!(aIsOrientationChange &&mData->mFitMode))
+		{
+		UpdateVisuals();
+		CreateSlider();
+		}
+	
+	// For template 4 set model case
+	// cancel the rotation if any.
+	if (!aIsOrientationChange && mData->mFitMode)
+		{
+		if (mData->mRotation.mIsApplied)
+			{
+			if (mData->mRotation.mIndex >= 0)
+				{
+				CancelRotation(mData->mRotation.mIndex);
+				}
+			else
+				{
+				// rotation applied on highlight index.
+				// so cancel it.
+				mData->mRotation.mIndex = 1;
+				CancelRotation(mData->mRotation.mIndex);
+				}
+			}
+		}
+	}
+	
+// ----------------------------------------------------------------------------
+// CreateVisuals
+// ----------------------------------------------------------------------------
+//
+void MulBaseElement::CreateVisuals()
+	{
+	MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::CreateVisuals");
+	int totalVisual = 2*mData->mVisibleCount + 1;
+	int visualIndex = 0;
+	
+	// if there are less visuals than required tehn create the extra visauls and
+	// set opacity 1 for already existing visuals
+	if(totalVisual > mData->mIconFlowLayout->Count())
+    	{
+    	visualIndex = mData->mIconFlowLayout->Count(); 	
+        for(; visualIndex < totalVisual;visualIndex++) 
+            {
+            CreateIconStructure(mData->mIconFlowLayout); 
+            }
+    	}
+    // if the number of visuals are more, then set opacity 0 for the extra visuals
+    else if (totalVisual < mData->mIconFlowLayout->Count())
+        {
+        IMulModelAccessor* accessor = ((MulCoverFlowControl*)&control())->ModelAccessor();
+        if(accessor)
+            {
+            if(accessor->CurrentItemCount() < totalVisual)
+	            {
+	            for(; visualIndex < totalVisual;visualIndex++) 
+	                {
+	                CAlfVisual& visual = mData->mIconFlowLayout->Visual(visualIndex);
+        			static_cast<MulCoverFlowControl&>(control()).UpdateItemAtIndex(visualIndex);	
+	                }
+	            }
+	            
+    	    CAlfTextureManager& textureMgr = control().Env().TextureManager();
+    	    TAlfImage image = TAlfImage(textureMgr.BlankTexture());
+    	    // position those visuals to some other location.
+    	    int posX = mData->mHighlightItemStruct.posx + totalVisual * mData->mHighlightItemStruct.width;
+            for(; visualIndex < mData->mIconFlowLayout->Count();visualIndex++) 
+                {
+	            CAlfVisual& visual = mData->mIconFlowLayout->Visual(visualIndex);
+	            visual.SetPos(TAlfRealPoint(posX,mData->mHighlightItemStruct.posy));
+	            CAlfImageVisual* imageVisual = static_cast<CAlfImageVisual*>(visual.FindTag(KCoverflowIcon));
+		        // remove the icon brush if any.
+		        RemoveBrushOnIcon(*imageVisual);        
+		        imageVisual->SetImage(image); 
+                CAlfImageVisual* indicatorVisual =static_cast<CAlfImageVisual*>(visual.FindTag(KCoverflowIndicator));    
+                if(indicatorVisual)
+                    {
+                    indicatorVisual->SetImage(image);   
+                    }
+	            }
+            }
+        }
+	}
+
+// ----------------------------------------------------------------------------
+// UpdateVisuals
+// ----------------------------------------------------------------------------
+//
+void MulBaseElement::UpdateVisuals()
+	{
+	MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::UpdateVisuals");
+	int totalVisual = 2*mData->mVisibleCount + 1;
+	MulCoverFlowControl* coverflowControl = static_cast<MulCoverFlowControl*>(&control());
+	IMulModelAccessor* accessor = coverflowControl->ModelAccessor();
+	if(accessor)
+    	{
+    	for(int i = 0; i < totalVisual; i++) 
+            {
+            CAlfVisual& visual = mData->mIconFlowLayout->Visual(i);
+        	coverflowControl->UpdateItemAtIndex(i);	          
+            }
+    	}
+	}
+	
+// ----------------------------------------------------------------------------
+// CreateIconStructure
+// ----------------------------------------------------------------------------
+//
+CAlfVisual* MulBaseElement::CreateIconStructure(CAlfLayout* aParentLayout)
+    { 
+    MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::CreateIconStructure");       
+    //create the deck layout.
+    CAlfDeckLayout* deck =CAlfDeckLayout::AddNewL((CAlfControl &)control(),aParentLayout);
+    CAlfImageVisual* imageVisual =CAlfImageVisual::AddNewL((CAlfControl &)control(),deck);
+    imageVisual->SetTagL(KCoverflowIcon);
+	deck->SetFlag( EAlfVisualFlagManualLayout );
+    return deck;
+    }
+	
+	
+// ----------------------------------------------------------------------------
+// SetHighlight
+// This function is used to change the highlight by 1 with animation.
+// This function also takes care whether we need to change the size or only the position.
+// it takes into consideration the current direction and the current highlight index.
+// The logic is , we are always keeping the highlight visual index fixed (its equal to
+// the no of visible item in the screen), Depending on the scroll direction we reorder
+// the last or first visual and then position all visuals keeping the highlight visual
+// in its position. Then update the last or 1st visual with appropriate data.
+// ----------------------------------------------------------------------------
+//
+void MulBaseElement::SetHighlight(int /*aHighlightIndex*/, int aAnimationTime)
+	{
+	MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::SetHighlight");
+	int totalVisual = 2*mData->mVisibleCount + 1;
+	int highlightIndex = mData->mVisibleCount;
+	CAlfVisual* deckLayout = NULL;
+	CAlfVisual* imageVisual = NULL;	
+	
+	int highlightPosX = mData->mHighlightItemStruct.posx;
+
+    if(mData->mScrollDir == EItemScrollLeft)
+    	{
+    	CancelRotation(totalVisual - 1);
+		control().Env().BatchBufferHandler().SetAutoFlushMode(EAlfAutoFlushOnlyForced);     	
+		deckLayout = (CAlfVisual*)&mData->mIconFlowLayout->Visual(totalVisual - 1);
+    	mData->mIconFlowLayout->Reorder(*deckLayout,0);
+    	
+		int posX = highlightPosX - mData->mVisibleCount*(mData->mItemStruct.width + mData->mPadding);
+		deckLayout->SetPos( TAlfRealPoint(posX,mData->mItemStruct.posy));
+		posX = posX + mData->mItemStruct.width + mData->mPadding;
+		for (int i=1; i < totalVisual ; i++)  
+		    {
+			deckLayout = (CAlfVisual*)&mData->mIconFlowLayout->Visual(i);
+			imageVisual = deckLayout->FindTag(KCoverflowIcon);
+			if (i != highlightIndex)
+				{
+				deckLayout->SetPos( TAlfTimedPoint(posX,mData->mItemStruct.posy,aAnimationTime));
+			   	posX = posX + mData->mItemStruct.width + mData->mPadding;
+			   
+			   	// Change the size if required
+				if((i == highlightIndex+1 || i == highlightIndex-1) && mData->mChangeSize)
+					{
+					deckLayout->SetSize(TAlfTimedPoint(mData->mItemStruct.width,mData->mItemStruct.height,aAnimationTime));
+					imageVisual->SetSize(TAlfTimedPoint(mData->mItemStruct.width,mData->mItemStruct.height,aAnimationTime));
+					}
+				}
+			else
+				{
+			    deckLayout->SetPos( TAlfTimedPoint(highlightPosX,mData->mHighlightItemStruct.posy,aAnimationTime));
+			   	posX = posX + mData->mHighlightItemStruct.width + mData->mPadding;
+			   	
+			   	// Change the size if required
+			   	if(mData->mChangeSize)
+				   	{
+					deckLayout->SetSize(TAlfTimedPoint(mData->mHighlightItemStruct.width,
+														mData->mHighlightItemStruct.height,
+														aAnimationTime));
+					imageVisual->SetSize(TAlfTimedPoint(mData->mHighlightItemStruct.width,
+														mData->mHighlightItemStruct.height,
+														aAnimationTime));
+				   	}
+				}
+		    }
+	    control().Env().BatchBufferHandler().FlushBatchBuffer();            
+	  	control().Env().BatchBufferHandler().SetAutoFlushMode(EAlfAutoFlushDeferred);           
+		((MulCoverFlowControl*)&control())->UpdateItemAtIndex(0, aAnimationTime);
+
+    	}
+    else if (mData->mScrollDir == EItemScrollRight)
+	    {
+	    CancelRotation(0);
+		control().Env().BatchBufferHandler().SetAutoFlushMode(EAlfAutoFlushOnlyForced); 	    
+		deckLayout = (CAlfVisual*)&mData->mIconFlowLayout->Visual(0);
+    	mData->mIconFlowLayout->Reorder(*deckLayout,totalVisual-1);
+    	
+		int posX = highlightPosX - mData->mVisibleCount*(mData->mItemStruct.width + mData->mPadding);
+
+		for (int i=0; i < totalVisual-1 ; i++)  
+		    {
+			deckLayout = (CAlfVisual*)&mData->mIconFlowLayout->Visual(i);
+			imageVisual = deckLayout->FindTag(KCoverflowIcon);
+		    
+			if (i != highlightIndex)
+				{
+				deckLayout->SetPos( TAlfTimedPoint(posX,mData->mItemStruct.posy,aAnimationTime));
+			   	posX = posX + mData->mItemStruct.width + mData->mPadding;
+			   	// Change the size if required
+				if((i == highlightIndex+1 || i == highlightIndex-1) && mData->mChangeSize)
+					{
+					deckLayout->SetSize(TAlfTimedPoint(mData->mItemStruct.width,mData->mItemStruct.height,aAnimationTime));
+					imageVisual->SetSize(TAlfTimedPoint(mData->mItemStruct.width,mData->mItemStruct.height,aAnimationTime));
+					}			   	
+				}
+			else
+				{
+			    deckLayout->SetPos( TAlfTimedPoint(highlightPosX,mData->mHighlightItemStruct.posy,aAnimationTime));
+			   	posX = posX + mData->mHighlightItemStruct.width + mData->mPadding;
+			   	// Change the size if required
+			   	if(mData->mChangeSize)
+				   	{
+					deckLayout->SetSize(TAlfTimedPoint(mData->mHighlightItemStruct.width,
+														mData->mHighlightItemStruct.height,
+														aAnimationTime));
+					imageVisual->SetSize(TAlfTimedPoint(mData->mHighlightItemStruct.width,
+														mData->mHighlightItemStruct.height,
+														aAnimationTime));
+				   	}
+				}
+		    }
+		deckLayout = (CAlfVisual*)&mData->mIconFlowLayout->Visual(totalVisual-1);
+		deckLayout->SetPos( TAlfRealPoint(posX,mData->mItemStruct.posy));
+	    control().Env().BatchBufferHandler().FlushBatchBuffer();            
+	    control().Env().BatchBufferHandler().SetAutoFlushMode(EAlfAutoFlushDeferred);           
+		((MulCoverFlowControl*)&control())->UpdateItemAtIndex(totalVisual-1, aAnimationTime);
+	    }
+	    
+	}
+	
+// ----------------------------------------------------------------------------
+// StartDoodling
+// This function is used in doodling case. it calls the appropriate function to
+// handle doodling based on whether we have to only change the position or both
+// position and size.
+// ----------------------------------------------------------------------------
+//
+void MulBaseElement::StartDoodling(int aDistance, int aAnimationTime)
+	{
+	MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::StartDoodling");
+	if (mData->mChangeSize)
+		{
+		MoveVisualsWithSizeChange(aDistance,aAnimationTime);
+		}
+	else
+		{
+		MoveVisuals(aDistance,aAnimationTime);
+		}
+	}
+	
+// ----------------------------------------------------------------------------
+// StopDoodling
+// it calls when we get a gestureunknown or to do a bounce back.
+// it basically repositions the visuals based on current highlight.
+// it simply calls a startdoodling function with 0 distance and with
+//  animation time if required.
+// ----------------------------------------------------------------------------
+//
+void MulBaseElement::StopDoodling(int aAnimationTime)
+	{
+	MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::StopDoodling");
+	StartDoodling(0,aAnimationTime);
+	}
+	
+	
+// ----------------------------------------------------------------------------
+// MoveVisuals
+// This function is used in doodling when only position needs to be change, usefull
+// in potrait where 1 visible item is in the screen. 
+// The logic is to change the position of all visuals by doodling distance.
+// ----------------------------------------------------------------------------
+//
+void MulBaseElement::MoveVisuals(int aDistance, int aAnimationTime)
+	{
+	MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::MoveVisuals");
+	CancelRotation();
+		
+	control().Env().BatchBufferHandler().SetAutoFlushMode(EAlfAutoFlushOnlyForced); 
+	int totalVisual = 2*mData->mVisibleCount + 1;
+	int highlightIndex = mData->mVisibleCount;
+	
+	int highlightPosX = mData->mHighlightItemStruct.posx;
+	
+	highlightPosX += aDistance;
+
+	int posX = highlightPosX - mData->mVisibleCount*(mData->mItemStruct.width + mData->mPadding);
+	for (int i=0; i < totalVisual ; i++)  
+	    {
+		CAlfVisual& deckLayout = mData->mIconFlowLayout->Visual(i);
+		
+		if (i != mData->mVisibleCount)
+			{
+			deckLayout.SetPos( TAlfTimedPoint(posX,mData->mItemStruct.posy,aAnimationTime));
+		   	posX = posX + mData->mItemStruct.width + mData->mPadding;
+			}
+		else
+			{
+		    deckLayout.SetPos( TAlfTimedPoint(highlightPosX,mData->mHighlightItemStruct.posy,aAnimationTime));
+		   	posX = posX + mData->mHighlightItemStruct.width + mData->mPadding;
+			}
+	    }
+  	control().Env().BatchBufferHandler().FlushBatchBuffer();            
+    control().Env().BatchBufferHandler().SetAutoFlushMode(EAlfAutoFlushDeferred);           
+	}
+
+// ----------------------------------------------------------------------------
+// NumberOfSwipe
+// ----------------------------------------------------------------------------
+//	
+TNumberofSwipes MulBaseElement::NumberOfSwipes()
+	{
+	MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::NumberOfSwipes");
+	return mData->mNumSwipes;
+	}
+	
+// ----------------------------------------------------------------------------
+// FinalSwipeDirection
+// ----------------------------------------------------------------------------
+//
+int MulBaseElement::FinalSwipeDirection(int aDistance, int aLastSwipeDirection)
+	{
+	MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::FinalSwipeDirection");
+	
+	int NewHighlightPos = NearestPoint(FinalMidPoints(ReferenceMidPoints(),aDistance),aLastSwipeDirection);
+	
+	int scrollDir = EItemNoDirection;
+	mData->mNumSwipes = ESingleSwipe;
+	
+	// now depending on the new highlight position make a decission
+	// whether to double swipe or single swipe and in which direction.
+	if(mData->mVisibleCount == 1)
+		{
+		switch(NewHighlightPos)
+			{
+			case 0:
+				{
+				scrollDir = EItemScrollLeft;	
+				}
+			break;
+			case 2:
+				{
+				scrollDir = EItemScrollRight;	
+				}
+			break;
+			case 1:
+			default:
+			break;				
+			}
+		}
+	else
+		{
+		switch(NewHighlightPos)
+			{
+			case 0:
+				{
+				mData->mNumSwipes = ETripleSwipe; // triple swipe
+				scrollDir = EItemScrollLeft;	
+				}
+			break;
+			case 1:
+				{
+				mData->mNumSwipes = EDoubleSwipe;
+				scrollDir = EItemScrollLeft;	
+				}
+			break;	
+			case 2:
+				{
+				scrollDir = EItemScrollLeft;	
+				}
+			break;					
+			case 4:
+				{
+				scrollDir = EItemScrollRight;	
+				}
+			break;
+			case 5:
+				{
+				mData->mNumSwipes = EDoubleSwipe;
+				scrollDir = EItemScrollRight;
+				}
+			break;
+			case 6:
+				{
+				mData->mNumSwipes = ETripleSwipe; // triple swipe
+				scrollDir = EItemScrollRight;
+				}
+			break;									
+			case 3:
+			default:
+			break;				
+			}
+		}
+	return scrollDir;							
+	}	
+
+// ----------------------------------------------------------------------------
+// NearestPoint
+// ----------------------------------------------------------------------------
+//
+int MulBaseElement::NearestPoint(std::vector<int> aFinalMidPoints,int aLastSwipeDirection)
+	{
+	int referencePoint = mData->mHighlightItemStruct.posx + mData->mHighlightItemStruct.width/2;
+	int i = 0;
+	while(i < aFinalMidPoints.size())
+		{
+		int temp = 	aFinalMidPoints[i];
+		if(aFinalMidPoints[i] > referencePoint)
+			{
+			break;	
+			}
+		i++;
+		}
+      
+	if(aLastSwipeDirection == EEventScrollLeft)
+		{
+		return --i;
+		}
+	return i;
+	}
+	
+// ----------------------------------------------------------------------------
+// ReferenceMidPoints
+// ----------------------------------------------------------------------------
+//
+std::vector<int> MulBaseElement::ReferenceMidPoints()
+	{
+	std::vector<int> referenceMidPoints;
+	int highlightMidPoint = mData->mHighlightItemStruct.posx + mData->mHighlightItemStruct.width/2;
+	int differnce = mData->mHighlightItemStruct.width/2
+			+ mData->mPadding + mData->mItemStruct.width/2 ;
+			
+	int doubleDiff = mData->mPadding + mData->mItemStruct.width;
+	if(mData->mVisibleCount != 1)
+		{
+		referenceMidPoints.push_back(highlightMidPoint - (differnce
+			+ 2 * doubleDiff));
+			
+		referenceMidPoints.push_back(highlightMidPoint - (differnce
+			+ doubleDiff));
+		}
+	referenceMidPoints.push_back(highlightMidPoint - differnce);
+	referenceMidPoints.push_back(highlightMidPoint);
+	referenceMidPoints.push_back(highlightMidPoint + differnce);
+
+	if(mData->mVisibleCount != 1)
+		{
+		referenceMidPoints.push_back(highlightMidPoint + (differnce
+			+ 2 * doubleDiff));	
+			
+		referenceMidPoints.push_back(highlightMidPoint + (differnce
+			+ doubleDiff));						
+		}	
+	return referenceMidPoints;
+	}
+
+// ----------------------------------------------------------------------------
+// FinalMidPoints
+// ----------------------------------------------------------------------------
+//
+std::vector<int> MulBaseElement::FinalMidPoints(std::vector<int> aReferenceMidPoints,int aDistance)
+	{
+	std::vector<int> newMidPoints;
+	for(int i = 0; i < aReferenceMidPoints.size(); i++)
+		{
+		newMidPoints.push_back(aReferenceMidPoints[i] + aDistance);
+		int temp = 	newMidPoints[i];
+		}
+	return newMidPoints;	
+	}
+
+// ----------------------------------------------------------------------------
+// MoveVisualsWithSizeChange
+// This function used when during doodling size changes also required.
+// ie in case of landscape and visible items are 3 during doodling position as well
+// as size change requird.
+// The basic logic is we are keeping a reference distance for a complete highlight 
+// change (that means the highlight becomes nonhighlight and vice versa). so at 
+// any point of time there will be only two visuals whose size needs to be change.
+// one to grow and other to shrink. so we  calculate the % of grow and shrink of
+// visual keeping the doodling distance and reference distance into consideration.
+// ----------------------------------------------------------------------------
+//
+void MulBaseElement::MoveVisualsWithSizeChange(int aDistance, int aAnimationTime)
+	{
+	MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::MoveVisualsWithSizeChange");
+	int totalVisual = 2*mData->mVisibleCount + 1;
+	int highlightIndex = mData->mVisibleCount;
+	CAlfVisual* imageVisual = NULL;	
+	int visualIndexToShrink = -1;
+	int visualIndexToGrow = -1;  
+	int updateSpecialIndex = -1;  
+	int distancefactor = CalculateDistanceChangeFactor ();
+	
+	int highlightPosX = mData->mHighlightItemStruct.posx;
+	highlightPosX += aDistance;
+	
+	
+	if (Abs(aDistance) < distancefactor)
+		{
+		// user has doodled to change the highlight by 1.Single swipe.
+		if (aDistance < 0)
+			{
+			visualIndexToGrow = highlightIndex +1;
+			}
+		else if (aDistance > 0)
+			{
+			visualIndexToGrow = highlightIndex -1;
+			}
+		else
+			{
+			// for stop doodling case
+			visualIndexToGrow = highlightIndex - 1;
+			updateSpecialIndex = highlightIndex + 1;
+			}
+		visualIndexToShrink = highlightIndex;
+		}
+	else
+		{
+		// user has doodled to change the highlight by 2. Double swipe.
+		if (aDistance < 0)
+			{
+			visualIndexToShrink = highlightIndex +1;
+			visualIndexToGrow = highlightIndex +2;
+			aDistance +=distancefactor;
+			}
+		else
+			{
+			visualIndexToShrink = highlightIndex -1;
+			visualIndexToGrow = highlightIndex -2;
+			aDistance -=distancefactor;
+			}
+		}
+	int changeInPosY = (((mData->mItemStruct.posy - mData->mHighlightItemStruct.posy)*Abs(aDistance))/distancefactor);
+	int changeInWidth = (((mData->mHighlightItemStruct.width - mData->mItemStruct.width)*Abs(aDistance))/distancefactor);
+	int changeInHeight = (((mData->mHighlightItemStruct.height - mData->mItemStruct.height)*Abs(aDistance))/distancefactor);
+
+
+	int posX = highlightPosX - mData->mVisibleCount*(mData->mItemStruct.width + mData->mPadding);
+	for (int i=0; i < totalVisual && i < mData->mIconFlowLayout->Count(); i++)  
+	    {
+		CAlfVisual& deckLayout = mData->mIconFlowLayout->Visual(i);
+		if (i == visualIndexToShrink)
+			{
+			int posY = mData->mHighlightItemStruct.posy + changeInPosY;
+			int width =mData->mHighlightItemStruct.width - changeInWidth;
+			int height =mData->mHighlightItemStruct.height - changeInHeight;
+			deckLayout.SetPos( TAlfTimedPoint(posX,posY,aAnimationTime));
+			imageVisual = deckLayout.FindTag(KCoverflowIcon);
+			deckLayout.SetSize(TAlfTimedPoint(width,height,aAnimationTime));
+			imageVisual->SetSize(TAlfTimedPoint(width,height,aAnimationTime));
+			posX = posX + width + mData->mPadding;
+			}
+		else if (i == visualIndexToGrow)
+			{
+			int posY = mData->mItemStruct.posy - changeInPosY;
+			int width = mData->mItemStruct.width + changeInWidth;
+			int height = mData->mItemStruct.height + changeInHeight;
+			deckLayout.SetPos( TAlfTimedPoint(posX,posY,aAnimationTime));
+			imageVisual = deckLayout.FindTag(KCoverflowIcon);
+			deckLayout.SetSize(TAlfTimedPoint(width,height,aAnimationTime));
+			imageVisual->SetSize(TAlfTimedPoint(width,height,aAnimationTime));
+			posX = posX + width + mData->mPadding;
+			}
+		else if (i == updateSpecialIndex)
+			{
+			deckLayout.SetPos( TAlfTimedPoint(posX,mData->mItemStruct.posy,aAnimationTime));
+			imageVisual = deckLayout.FindTag(KCoverflowIcon);
+			deckLayout.SetSize(TAlfTimedPoint(mData->mItemStruct.width,mData->mItemStruct.height,aAnimationTime));
+			imageVisual->SetSize(TAlfTimedPoint(mData->mItemStruct.width,mData->mItemStruct.height,aAnimationTime));
+		   	posX = posX + mData->mItemStruct.width + mData->mPadding;
+			}
+		else
+			{
+			deckLayout.SetPos( TAlfTimedPoint(posX,mData->mItemStruct.posy,aAnimationTime));
+		   	posX = posX + mData->mItemStruct.width + mData->mPadding;
+			}
+	    }
+	}
+
+// ----------------------------------------------------------------------------
+//RecycleIconVisuals
+// ----------------------------------------------------------------------------
+//
+void MulBaseElement::RecycleIconVisuals()
+    {
+    MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::RecycleIconVisuals");
+    CAlfTextureManager& textureMgr = control().Env().TextureManager();
+    TAlfImage image = TAlfImage(textureMgr.BlankTexture());
+    
+    for(int i=0; i<mData->mIconFlowLayout->Count(); i++)
+        {
+        CAlfVisual& visual = mData->mIconFlowLayout->Visual(i);
+        CAlfImageVisual* imageVisual = static_cast<CAlfImageVisual*>(visual.FindTag(KCoverflowIcon)); 
+        // remove the icon brush if any.
+        RemoveBrushOnIcon(*imageVisual);        
+        imageVisual->SetImage(image);
+        
+        CAlfImageVisual* indicatorVisual =static_cast<CAlfImageVisual*>(visual.FindTag(KCoverflowIndicator));    
+        if(indicatorVisual)
+            {
+            indicatorVisual->SetImage(image);   
+            }
+        }
+	// cancel the rotation if any.
+	if (mData->mRotation.mIsApplied)
+		{
+		if (mData->mRotation.mIndex >= 0)
+			{
+			CancelRotation(mData->mRotation.mIndex);
+			}
+		else
+			{
+			// rotation applied on highlight index.
+			// so cancel it.
+			mData->mRotation.mIndex = 1;
+			CancelRotation(mData->mRotation.mIndex);
+			}
+		}
+    }
+
+// ----------------------------------------------------------------------------
+//IdToTag
+// ----------------------------------------------------------------------------
+//
+const TDesC8& MulBaseElement::IdToTag( int aId )
+    {
+    MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::IdToTag");
+    switch( aId )
+        {
+        case mulvisualitem::KMulIcon1 :
+            {
+            return KCoverflowIcon;
+            }
+        case mulvisualitem::KMulTitle :
+            {
+            return KCoverflowTitle;
+            }    
+        case mulvisualitem::KMulDetail :
+            {
+            return KCoverflowDetail;
+            }  
+        case mulvisualitem::KMulIndicator2 :
+            {
+            return KCoverflowIndicator;
+            }                               
+        default:
+            {
+            return KInvalidID;
+            }
+        }
+    }
+ 
+// ---------------------------------------------------------------------------
+// RemoveSliderFromLayout
+// ---------------------------------------------------------------------------
+//
+void MulBaseElement::RemoveSliderFromLayout()
+    {
+    MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::RemoveSliderFromLayout");
+    IAlfWidget* slider = (static_cast<MulCoverFlowControl&>(control())).GetSliderWidget();
+    if(slider && slider->control())
+        {
+        IMulSliderWidget* sliderwidget = static_cast<IMulSliderWidget*>(slider);
+        CAlfLayout* sliderContlyt = const_cast<CAlfLayout*>(sliderwidget->control()->ContainerLayout(NULL));
+        mData->mVerticalFlow->Remove(sliderContlyt);
+        }
+    
+    }    
+
+// ---------------------------------------------------------------------------
+// RotateImage
+// ---------------------------------------------------------------------------
+//
+void MulBaseElement::RotateImage(IMulWidget::TMulRotation aDirection,TSize aImageSize,int aAnimationTime,bool aAdjustSize)
+	{
+    MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::RotateImage");
+	
+	__MUL_ASSERT( mData->mIconFlowLayout->Count() != 0,KNullPointer);
+		
+	if (Template2D()->IsUiOnOffFlagEnabled())
+		{
+		CAlfVisual& visual = mData->mIconFlowLayout->Visual(1);
+		CAlfImageVisual* imageVisual = static_cast<CAlfImageVisual*>(visual.FindTag(KCoverflowIcon)); 
+		
+		if (!aAdjustSize)
+			{
+			// Take care the case where rotation was
+			// applied to the previous highlight index
+			// cancel the rotation on that visual  
+			CancelRotation(mData->mRotation.mIndex);
+
+			switch(aDirection)
+				{
+				case IMulWidget::ERotateLeft:
+					{
+					mData->mRotation.mImageAngle = (mData->mRotation.mImageAngle + 90)%360;
+					imageVisual->EnableTransformationL();
+					imageVisual->Transformation().Rotate(TAlfTimedValue(90,aAnimationTime));
+					mData->mRotation.mIsApplied = true;
+					break;
+					}
+				case IMulWidget::ERotateRight:
+					{
+					mData->mRotation.mImageAngle = (mData->mRotation.mImageAngle - 90)%360;
+					imageVisual->EnableTransformationL();
+					imageVisual->Transformation().Rotate(TAlfTimedValue(-90,aAnimationTime));
+					mData->mRotation.mIsApplied = true;
+					break;
+					}
+				default:
+					break;
+				}
+			// store the actual texture size of image to be rotated.
+			mData->mRotation.mTextureSize = aImageSize;
+			}
+			
+		AdjustVisualSizeInRotation(imageVisual, aAnimationTime);
+		}
+	}
+
+// ---------------------------------------------------------------------------
+// AdjustVisualSizeInRotation
+// ---------------------------------------------------------------------------
+//
+void MulBaseElement::AdjustVisualSizeInRotation(CAlfImageVisual* aVisual,int aAnimationTime)
+	{
+    MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::AdjustVisualSizeInRotation");
+
+	bool isLandScape = static_cast<MulCoverFlowControl&>(control()).IsLandscape();
+	int shortEdge = !isLandScape ? mData->mHighlightItemStruct.width : mData->mHighlightItemStruct.height;
+		 			 			
+	if( mData->mRotation.mTextureSize.iWidth <= shortEdge && mData->mRotation.mTextureSize.iHeight <= shortEdge)
+	    {
+	    return;
+	    }
+	else
+	    {
+	    switch(Abs(mData->mRotation.mImageAngle))
+	    	{
+	    	case 90:
+	    	case 270:
+	        	{
+	        	HandleRotationOnVerticalAxis(aVisual,aAnimationTime);
+	        	}
+	    	break;
+	    	case 0:
+	    	case 180:
+	    		{
+	    		HandleRotationOnHorizontalAxis(aVisual,aAnimationTime);
+	    		}
+	        break;
+	    	default:
+	    		break;
+	    	}
+	    }
+	}
+
+// ---------------------------------------------------------------------------
+// HandleRotationOnVerticalAxis
+// ---------------------------------------------------------------------------
+//
+void MulBaseElement::HandleRotationOnVerticalAxis(CAlfImageVisual* aVisual,int aAnimationTime)
+	{
+    MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::HandleRotationOnVerticalAxis");
+
+	bool isLandScape = static_cast<MulCoverFlowControl&>(control()).IsLandscape();
+	int longEdge = isLandScape ? mData->mHighlightItemStruct.width : mData->mHighlightItemStruct.height;
+	int shortEdge = !isLandScape ? mData->mHighlightItemStruct.width : mData->mHighlightItemStruct.height;
+
+	if (isLandScape)
+		{
+		if(mData->mRotation.mTextureSize.iWidth > shortEdge) 
+			{
+			// make the visual of shortEdge size and fit the image by width.
+			aVisual->SetPos(TAlfRealPoint(longEdge/2 - shortEdge/2,0),aAnimationTime);
+			aVisual->SetSize(TAlfRealSize(shortEdge,shortEdge),aAnimationTime);
+			aVisual->SetScaleMode(CAlfImageVisual::EScaleFitWidth); 
+			}
+		else 
+			{
+			//imageHeight > shortEdge and imageWidth < shortEdge
+			if (mData->mRotation.mTextureSize.iHeight > longEdge)
+				{
+				aVisual->SetPos(TAlfRealPoint(longEdge/2 - shortEdge/2,shortEdge/2 -longEdge/2),aAnimationTime);
+				aVisual->SetSize(TAlfRealSize(shortEdge,longEdge),aAnimationTime);
+				}
+			else
+				{
+				aVisual->SetPos(TAlfRealPoint(longEdge/2 - shortEdge/2,shortEdge/2 - mData->mRotation.mTextureSize.iHeight/2),aAnimationTime);
+				aVisual->SetSize(TAlfRealSize(shortEdge,mData->mRotation.mTextureSize.iHeight),aAnimationTime);
+				}
+			aVisual->SetScaleMode(CAlfImageVisual::EScaleFitHeight);            				
+			}
+		}
+	else
+		{
+		if(mData->mRotation.mTextureSize.iHeight > shortEdge) 
+			{
+			// make the visual of shortEdge size and fit the image by height.
+			aVisual->SetPos(TAlfRealPoint(0,longEdge/2 - shortEdge/2),aAnimationTime);
+			aVisual->SetSize(TAlfRealSize(shortEdge,shortEdge),aAnimationTime);
+			aVisual->SetScaleMode(CAlfImageVisual::EScaleFitHeight);
+			}
+		else  
+			{
+			//imageWidth > shortEdge and imageHeight < shortEdge
+			if (mData->mRotation.mTextureSize.iWidth > longEdge)
+				{
+				aVisual->SetPos(TAlfRealPoint(shortEdge/2 - longEdge/2,longEdge/2 - shortEdge/2),aAnimationTime);
+				aVisual->SetSize(TAlfRealSize(longEdge,shortEdge),aAnimationTime);
+				}
+			else
+				{
+				aVisual->SetPos(TAlfRealPoint(shortEdge/2 - mData->mRotation.mTextureSize.iWidth/2,longEdge/2 - shortEdge/2),aAnimationTime);
+				aVisual->SetSize(TAlfRealSize(mData->mRotation.mTextureSize.iWidth,shortEdge),aAnimationTime);
+				}
+			// @todo check if this effective height after fit by width can ever be more than
+			// the shorter edge. If yes then this fit mode should be chnged to fit inside(check this)
+			aVisual->SetScaleMode(CAlfImageVisual::EScaleFitWidth);
+			}
+		}
+	}
+
+// ---------------------------------------------------------------------------
+// HandleRotationOnHorizontalAxis
+// ---------------------------------------------------------------------------
+//	
+void MulBaseElement::HandleRotationOnHorizontalAxis(CAlfImageVisual* aVisual,int aAnimationTime)
+	{
+    MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::HandleRotationOnHorizontalAxis");
+	
+	aVisual->SetPos(TAlfRealPoint(0,0),aAnimationTime);
+	aVisual->SetSize(TAlfRealSize(mData->mHighlightItemStruct.width,mData->mHighlightItemStruct.height),aAnimationTime);
+	ApplyScaleMode(*aVisual);
+	}
+		
+// ---------------------------------------------------------------------------
+// CancelRotation
+// ---------------------------------------------------------------------------
+//
+void MulBaseElement::CancelRotation(int aIndex)
+	{
+    MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::CancelRotation");
+	
+	if (mData->mRotation.mIsApplied)
+		{
+		if (mData->mRotation.mIndex >= 0)
+			{
+			// revert it back
+			mData->mRotation.mImageAngle = 0;
+			CAlfVisual& deckLayout = mData->mIconFlowLayout->Visual(mData->mRotation.mIndex);
+			CAlfImageVisual* imageVisual = static_cast<CAlfImageVisual*>(deckLayout.FindTag(KCoverflowIcon));
+			imageVisual->EnableTransformationL();
+			imageVisual->Transformation().LoadIdentity();
+			// reset the rotation property
+			mData->mRotation.mIsApplied = false;
+			mData->mRotation.mIndex = -1;   
+        	imageVisual->SetPos(TAlfRealPoint(0,0));
+			imageVisual->SetSize(TAlfRealSize(mData->mHighlightItemStruct.width,mData->mHighlightItemStruct.height));
+			ApplyScaleMode(*imageVisual);			
+			}
+		else
+			{
+			mData->mRotation.mIndex = aIndex;
+			}
+		}	    
+	}
+
+// ---------------------------------------------------------------------------
+// CancelRotationOnUpdate
+// ---------------------------------------------------------------------------
+//
+void MulBaseElement::CancelRotationOnUpdate(int aIndex)
+	{
+    MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::CancelRotationOnUpdate");
+	
+	if (mData->mRotation.mIsApplied)
+		{
+		if (mData->mRotation.mIndex < 0 || mData->mRotation.mIndex == aIndex)
+			{
+			// revert it back
+			mData->mRotation.mImageAngle = 0;
+			CAlfVisual& deckLayout = mData->mIconFlowLayout->Visual(aIndex);
+			CAlfImageVisual* imageVisual = static_cast<CAlfImageVisual*>(deckLayout.FindTag(KCoverflowIcon));
+			imageVisual->EnableTransformationL();
+			imageVisual->Transformation().LoadIdentity();
+			// reset the rotation property
+			mData->mRotation.mIsApplied = false;
+			mData->mRotation.mIndex = -1;   
+        	imageVisual->SetPos(TAlfRealPoint(0,0));
+			imageVisual->SetSize(TAlfRealSize(mData->mHighlightItemStruct.width,mData->mHighlightItemStruct.height));
+			ApplyScaleMode(*imageVisual);			
+			}
+		}	    
+	}
+		
+// ---------------------------------------------------------------------------
+// UpdateRotation
+// ---------------------------------------------------------------------------
+//
+void MulBaseElement::UpdateRotation()
+	{
+    MUL_LOG_ENTRY_EXIT("aakash::MulBaseElement::UpdateRotation");
+	
+	if (mData->mRotation.mIsApplied)
+		{
+		// rotation applied on the highlight item.
+		if (mData->mRotation.mIndex < 0)
+			{
+			RotateImage(IMulWidget::ERotateLeft,TSize(0,0),0,true);
+			}
+		}	    
+	}	
+
+    } //namespace Alf
+    
+//End of file