diff -r 4ea6f81c838a -r 0e9bb658ef58 mulwidgets/mulcoverflowwidget/src/mulbaseelement.cpp --- /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 +// Alf Headers +#include +#include +#include +#include +#include +#include +#include +#include + +// Mul Headers +#include "mul/mulmodelutility.h" +#include "imulmodelaccessor.h" +#include +#include +#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(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(&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 (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 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(findVisual( KMainLayoutIndex )); + mData->mEmptyTextVisual = CAlfTextVisual::AddNewL(control(),main); + + TBuf 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(mData->mIconFlowLayout->Visual(aIndex)); + CAlfImageVisual* visual =static_cast(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(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(&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(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 (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( + mData->mTextLayout->FindTag(KDetailViewPortLayout)); + if(!viewportLayout) + { + return; // return if no viewport + } + textExtent = mData->mDetailExt; + parentSize = Template2D()->DetailWindowSize(); + + } + else + { + viewportLayout = static_cast( + mData->mTextLayout->FindTag(KTitleViewPortLayout)); + if(!viewportLayout) + { + return; // return if no viewport + } + textExtent = mData->mTitleExt; + parentSize = Template2D()->TitleWindowSize(); + + } + text = static_cast( + 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( + mData->mTextLayout->FindTag(KDetailViewPortLayout)); + if(!viewportLayout) + { + return;// return if no viewport + } + textExtent = mData->mDetailExt; + parentSize = Template2D()->DetailWindowSize(); + maxCharWidth = Template2D()->DetailMaxCharWidth(); + } + else + { + viewportLayout = static_cast( + mData->mTextLayout->FindTag(KTitleViewPortLayout)); + if(!viewportLayout) + { + return;// return if no viewport + } + textExtent = mData->mTitleExt; + parentSize = Template2D()->TitleWindowSize(); + maxCharWidth = Template2D()->TitleMaxCharWidth(); + } + text = static_cast( + 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(&(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(&(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(mData->mTextLayout->FindTag(KDetailViewPortLayout)); + parentSize = Template2D()->DetailWindowSize(); + } + else + { + viewPortLayout = + static_cast(mData->mTextLayout->FindTag(KTitleViewPortLayout)); + parentSize = Template2D()->TitleWindowSize(); + } + if(!viewPortLayout) + { + return; + } + text = static_cast(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 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(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(&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(&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(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(this); + } + else if(param == IAlfWidgetEventHandler::type().mImplementationId ) + { + return static_cast(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 tempItem( new (EMM) MulVisualItem()); + MulVisualItem* tempItem = const_cast (&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(control()).TotalModelCount() > 1 && mData->mSliderOpacity == KBackGroundOpacity) + { + ShowSlider(true); + } + else if((static_cast(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(&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(alfSliderWidget); + mData->mSliderLayout = const_cast(&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(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(findVisual( KMainLayoutIndex )); + CAlfDeckLayout& deckLayout = static_cast (main->Visual(KMainLayoutIndex) ); + + CAlfVisual* oldVisual = deckLayout.FindTag(backgroundvisual); + if(oldVisual) + { + CAlfImageVisual* imageVisual = static_cast(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(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(findVisual( KMainLayoutIndex )); + CAlfDeckLayout& deckLayout = static_cast (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(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 ;imIconFlowLayout->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(mData->mTextLayout->FindTag(KCoverflowTitle)); + if(titleTextVisual) + { + titleTextVisual->SetColor(aColor); + } + CAlfViewportLayout* viewPortLayout =static_cast(mData->mTextLayout->FindTag(KDetailViewPortLayout)); + if(viewPortLayout) + { + CAlfTextVisual* detailTextVisual =static_cast(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(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(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(visual.FindTag(KCoverflowIcon)); + // remove the icon brush if any. + RemoveBrushOnIcon(*imageVisual); + imageVisual->SetImage(image); + CAlfImageVisual* indicatorVisual =static_cast(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(&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 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 MulBaseElement::ReferenceMidPoints() + { + std::vector 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 MulBaseElement::FinalMidPoints(std::vector aReferenceMidPoints,int aDistance) + { + std::vector 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; imIconFlowLayout->Count(); i++) + { + CAlfVisual& visual = mData->mIconFlowLayout->Visual(i); + CAlfImageVisual* imageVisual = static_cast(visual.FindTag(KCoverflowIcon)); + // remove the icon brush if any. + RemoveBrushOnIcon(*imageVisual); + imageVisual->SetImage(image); + + CAlfImageVisual* indicatorVisual =static_cast(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(control())).GetSliderWidget(); + if(slider && slider->control()) + { + IMulSliderWidget* sliderwidget = static_cast(slider); + CAlfLayout* sliderContlyt = const_cast(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(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(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(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(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(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