1 /*

     2 * Copyright (c) 2007-2008 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  base element Implementation

    15  *

    16 */

    17 

    18 //  Include Files

    19 // Class Headers

    20 #include "mulbaseelement.h"

    21 

    22 #include <AknUtils.h>

    23 // Alf Headers

    24 #include <alf/alfbatchbuffer.h>

    25 #include <alf/alfbrusharray.h>

    26 #include <alf/alfgradientbrush.h>

    27 #include <alf/alfviewportlayout.h>

    28 #include <alf/alftextvisual.h>

    29 #include <alf/alfimagevisual.h>

    30 #include <alf/alfutil.h>

    31 #include <alf/alftransformation.h>

    32 

    33 // Mul Headers

    34 #include "mul/mulmodelutility.h"

    35 #include "imulmodelaccessor.h"

    36 #include <mul/imulsliderwidget.h>

    37 #include <mul/mulevent.h>

    38 #include "mulassert.h"

    39 #include "mulleave.h"

    40 #include "mullog.h" //for logs

    41 

    42 // Local Cover Flow Headers

    43 #include "mulcoverflowcontrol.h"

    44 #include "mulcoverflowtemplate.h"

    45 

    46 namespace Alf

    47     {

    48 //Internal base element structure implementation

    49 struct TMulBaseElementImpl

    50     {        

    51     

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

    53 	

    54 	int mPadding;            //Padding between item 

    55     

    56   	TMulCoverFlowItem mHighlightItemStruct;

    57 	TMulCoverFlowItem mItemStruct;

    58 	int mVisibleCount;

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

    60 	bool mUiOn;    // true if in UiOnMode

    61     

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

    63 

    64 	

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

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

    67 	CAlfFlowLayout* mIconFlowLayout; 

    68 	CAlfLayout* mTextLayout;

    69     CAlfFlowLayout* mVerticalFlow;

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

    71     

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

    73     CAlfTextVisual* mCounterVisual ;

    74     CAlfTextVisual* mEmptyTextVisual;

    75     

    76     //Stores current slider opacity. 

    77     float mSliderOpacity;

    78     TItemScroll mScrollDir;

    79     float mEmptyTextOpacity;

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

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

    82     bool mFitMode;

    83     

    84     // different visuals color properties

    85     TMulVisualColorProperty mIconBgColor;

    86     TMulVisualColorProperty mCounterColor;

    87     TMulVisualColorProperty mTextColor;

    88     TMulRotationProperty mRotation;

    89 

    90 	bool mChangeSize;

    91 	// whether user has swiped multiple times.

    92 	TNumberofSwipes mNumSwipes;

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

    94 	int mNumOfDigitsInCounter;

    95 	// marquee animation time

    96 	int mMarqueeAnimTime;

    97 	// Titletext extents

    98 	TSize mTitleExt;

    99 	// Detailtext extents

   100 	TSize mDetailExt;

   101 	//Dummy text visual for getting text extents

   102 	CAlfTextVisual* mDummyVisual;

   103 	bool mIsMirrored;

   104 	

   105 	//Constructor of the structure

   106 	TMulBaseElementImpl()

   107 		{

   108 		//Intialisation

   109 		mPadding                 = -1;   

   110 		mNumOfDigitsInCounter    = -1;

   111 		mVisibleCount            = 0;

   112 		mScrollAnimationTime     = 200;

   113 		mEmptyText 	= "";

   114 		mCounterVisual = NULL;

   115 		mIconFlowLayout = NULL;

   116 		mTextLayout = NULL;

   117 	    mVerticalFlow = NULL;

   118 	    mSliderLayout = NULL;

   119 	    mEmptyTextVisual = NULL;

   120 	    mSliderOpacity = 0.0f;

   121 	    mTextVisible   = true;

   122 	    mScrollDir = EItemNoDirection;

   123 	    mEmptyTextOpacity = 0.0f;

   124 	    mFitMode = false;

   125 	    mUiOn = false;

   126 	    mChangeSize = false;

   127 	    mNumSwipes = ESingleSwipe;

   128 	    mMarqueeAnimTime = 0;

   129 	    mDummyVisual = NULL;

   130 	    mIsMirrored = false;

   131 		}

   132 	~TMulBaseElementImpl()

   133 		{		

   134 		}

   135     }; //end of the structure

   136 

   137 

   138 // ---------------------------------------------------------------------------

   139 // MulBaseElement

   140 // ---------------------------------------------------------------------------

   141 //

   142 MulBaseElement::MulBaseElement( CAlfWidgetControl& aControl,

   143 			                    const char* aName )

   144     {

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

   146     mData.reset( new (EMM)TMulBaseElementImpl );

   147     //Call the base class method      

   148     construct( aControl,aName );

   149     CreateBaseLayoutStructure();

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

   151     if (AknLayoutUtils::LayoutMirrored())

   152     	{

   153     	mData->mIsMirrored = true;

   154     	}

   155     else

   156 		{

   157 		mData->mIsMirrored = false;

   158 		}

   159     }

   160 

   161 // ---------------------------------------------------------------------------

   162 // ~MulBaseElement

   163 // ---------------------------------------------------------------------------

   164 //	

   165 MulBaseElement::~MulBaseElement()

   166     {

   167     // Nothing to delete .

   168     }

   169 

   170 // ---------------------------------------------------------------------------

   171 // accept

   172 // ---------------------------------------------------------------------------

   173 //	

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

   175 		                     const TAlfEvent& aEvent ) const

   176      {

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

   178      uint eventID; 

   179      if(!aEvent.IsCustomEvent())

   180        {

   181        return false;

   182        }

   183     eventID = aEvent.CustomParameter();

   184 

   185     //Events handled by the base element

   186 	if( eventID == ETypeHighlight 

   187 			|| eventID == EEventWidgetInitialized 

   188 			|| eventID == ETypePrimaryValueChange )

   189         {

   190         return true;

   191         }

   192     else

   193         {

   194         return false;	

   195         }

   196     }

   197 

   198 // ---------------------------------------------------------------------------

   199 // offerEvent

   200 // ---------------------------------------------------------------------------

   201 //	

   202 AlfEventStatus MulBaseElement::offerEvent( CAlfWidgetControl& aControl,

   203 			const TAlfEvent& aEvent )

   204     {

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

   206     if ( !accept( aControl, aEvent ) )

   207         {

   208         //return false;

   209 		return EEventNotHandled;

   210         }

   211     

   212     uint eventID = aEvent.CustomParameter();

   213     

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

   215       

   216     if( eventID == EEventWidgetInitialized )

   217         {

   218         // some of the member variable needs to be reset

   219         // to support dynamic template change with model change.

   220         mData->mNumOfDigitsInCounter = -1;

   221         

   222         UpdateTextAndCounter();

   223         CalculatePadding();

   224         ArrangeItems();

   225 		// Show empty text if coverflow is empty

   226 	    int totalModelCount = coverflowControl->TotalModelCount();

   227 	    IMulModelAccessor* model = coverflowControl->ModelAccessor(); 

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

   229 	        {

   230 	        ShowEmptyText( true );

   231 	        return EEventConsumed;

   232 	        }

   233 	    else

   234 	    	{

   235 	    	ShowEmptyText( false );

   236 	    	} 		

   237  		return EEventConsumed;

   238         }

   239         

   240     else if( eventID == ETypeHighlight )

   241         {

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

   243         int newHighlight = coverflowControl->HighlightIndex(); 

   244         int animationTime = aEvent.CustomEventData();

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

   246 

   247         if(mData->mScrollDir != EItemNoDirection)

   248             {

   249             if(coverflowControl->IsFastScrollMode())

   250 	            {

   251 	            animationTime = coverflowControl->FastScrollTransitionTime();

   252 	            SetHighlight(newHighlight,animationTime);   	

   253 	            }

   254             else

   255 	            {

   256 	            SetHighlight(newHighlight,animationTime );   	

   257 	            }

   258             }

   259         else

   260             {

   261             //@TODO: update all the items 

   262             animationTime = KZeroAnimation;

   263             SetHighlight(newHighlight,animationTime);    

   264             }

   265         

   266         UpdateTextAndCounter(animationTime);

   267             

   268 		return EEventConsumed;

   269         }

   270     else if( eventID == ETypePrimaryValueChange )

   271     	{

   272  		IMulSliderModel* mulSliderModel = coverflowControl->GetSliderModel();

   273  		if( mulSliderModel )

   274 	        {

   275 	    	int primaryValue = mulSliderModel->PrimaryValue();

   276 	  	    coverflowControl->SetHighlightIndex( primaryValue , false);

   277     	    }

   278 		return EEventConsumed;

   279     	}

   280     	 	

   281 	return EEventNotHandled;    

   282     }

   283 

   284 // ---------------------------------------------------------------------------

   285 // setActiveStates

   286 // ---------------------------------------------------------------------------

   287 //	

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

   289     {

   290     //No implementation required

   291     }

   292 

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

   294 

   295 

   296 // ---------------------------------------------------------------------------

   297 // CreateBaseLayoutStructure

   298 // ---------------------------------------------------------------------------

   299 //	

   300 void  MulBaseElement::CreateBaseLayoutStructure()

   301 	{

   302 	THROW_IF_LEAVES

   303 	( 

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

   305 	   

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

   307     

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

   309 	 // by the ovverriden VisualLayoutUpdated method of the alfwidgetcontrol.

   310      main->SetFlags( EAlfVisualFlagLayoutUpdateNotification );

   311      main->SetTagL( mainlayout );

   312      main->SetFlag(EAlfVisualFlagAutomaticLocaleMirroringEnabled);

   313 	 main->SetClipping(ETrue); 

   314      

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

   316     deckLayout->SetTagL( decklayout );

   317     deckLayout->SetFlag( EAlfVisualFlagManualLayout );

   318     

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

   320     // Set the brush colour

   321     deckBrush->SetColor( KRgbBlack );

   322     deckLayout->EnableBrushesL( ETrue );

   323     // Apply brush and set the opacity .

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

   325     deckLayout->SetFlag(EAlfVisualFlagAutomaticLocaleMirroringEnabled);

   326 	deckLayout->SetClipping(ETrue);

   327     

   328     

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

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

   331 

   332     // Set the Layout Direction

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

   334     mData->mVerticalFlow->SetFlag( EAlfVisualFlagManualLayout );

   335     mData->mVerticalFlow->SetTagL( verticalflowlayout );

   336     mData->mVerticalFlow->SetFlag(EAlfVisualFlagAutomaticLocaleMirroringEnabled);

   337 

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

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

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

   341    

   342     // Set the Layout Direction

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

   344     mData->mIconFlowLayout->SetTagL( iconflowlayout );

   345     mData->mIconFlowLayout->SetFlag(EAlfVisualFlagAutomaticLocaleMirroringEnabled);

   346     

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

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

   349     mData->mTextLayout->SetTagL( textflowlayout );

   350     mData->mTextLayout->SetFlag(EAlfVisualFlagIgnorePointer);

   351     mData->mTextLayout->SetFlag( EAlfVisualFlagManualLayout );    

   352     mData->mTextLayout->SetFlag(EAlfVisualFlagAutomaticLocaleMirroringEnabled);

   353     //Add main layout to the base visual tree

   354     addVisualTree( main, KInitialvalueZero );

   355     

   356      );       

   357 	}

   358 

   359 // ---------------------------------------------------------------------------

   360 // SetDefaultSize

   361 // ---------------------------------------------------------------------------

   362 //

   363 void MulBaseElement::SetDefaultSize( TSize aSize )

   364 	{

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

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

   367 	main->SetSize(aSize );

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

   369 	deckLayout.SetSize(aSize);

   370 	CAlfVisual* backgroundVisual = deckLayout.FindTag(backgroundvisual);

   371     if(backgroundVisual)

   372 		{

   373 		backgroundVisual->SetSize(aSize);				

   374 		}	

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

   376 		{

   377 		mData->mEmptyTextVisual->SetSize(aSize);		

   378 		}

   379 	}

   380 

   381 // ---------------------------------------------------------------------------

   382 // TextAnchorLayout

   383 // ---------------------------------------------------------------------------

   384 //	        

   385 CAlfLayout& MulBaseElement::TextLayout()

   386 	{

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

   388 	return *mData->mTextLayout;

   389 	}

   390 

   391   

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

   393 // ---------------------------------------------------------------------------

   394 // SetEmptyText

   395 // ---------------------------------------------------------------------------

   396 //

   397 void MulBaseElement::SetEmptyText( const UString& aDefaultText )

   398 	{

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

   400 

   401 	mData->mEmptyText = aDefaultText;

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

   403 

   404 	if( mData->mEmptyTextVisual )

   405 		{

   406 		THROW_IF_LEAVES

   407 		 ( 

   408 		  TBuf<KTempBufferSize> desc; 

   409 		   

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

   411 		  mData->mEmptyTextVisual->SetTextL(desc);

   412 		 );

   413 		}

   414 		

   415     if( totalModelCount <= KInitialvalueZero )

   416         {

   417         ShowEmptyText( true );

   418         }

   419 	}

   420 

   421 // ---------------------------------------------------------------------------

   422 // ShowEmptyText

   423 // ---------------------------------------------------------------------------

   424 //

   425 void MulBaseElement::ShowEmptyText( bool aShowText  )

   426     {

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

   428     	

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

   430     if( mData->mEmptyText.isEmpty() )

   431     	{

   432     	if( aShowText )

   433     		{

   434     		ShowHideVisualsForEmptyText(false);

   435     		HandleSizeChangeOnMain();

   436     		}

   437     	else

   438     		{

   439     		ShowHideVisualsForEmptyText(true);

   440     		}

   441     	return;

   442     	}

   443     	

   444     if( aShowText )

   445     	{

   446     	if( !mData->mEmptyTextVisual )

   447     		{

   448     		CreateEmptyTextVisualisation();		

   449     		}

   450     		    	

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

   452     	ShowHideVisualsForEmptyText(false);	

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

   454     		{

   455 	    	mData->mEmptyTextVisual->SetOpacity(KHighlightOpacity);

   456 	    	mData->mEmptyTextOpacity = KHighlightOpacity;

   457 	    	}

   458     	HandleSizeChangeOnMain();

   459 	    	

   460     	}

   461     else

   462     	{

   463     	ShowHideVisualsForEmptyText(true);

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

   465     		{

   466     		mData->mEmptyTextVisual->SetOpacity(KBackGroundOpacity);

   467     		mData->mEmptyTextOpacity = KBackGroundOpacity;

   468     		}

   469     	}

   470     }

   471  

   472 // ---------------------------------------------------------------------------

   473 // HandleSizeChangeOnMain()

   474 // ---------------------------------------------------------------------------

   475 // 

   476 void  MulBaseElement::HandleSizeChangeOnMain()

   477 	{

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

   479 

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

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

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

   483 	

   484 	if( !model )

   485 		{

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

   487 			{

   488 			SetDefaultSize(topLayoutSize);

   489 			}

   490 		else

   491 			{

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

   493 			}

   494 			

   495 		}

   496 	else

   497 	    {

   498 	    SetDefaultSize(topLayoutSize);		

   499 	    }

   500 	}

   501 

   502 // ---------------------------------------------------------------------------

   503 // IsEmptyText

   504 // ---------------------------------------------------------------------------

   505 // 

   506 bool  MulBaseElement::IsEmptyText()

   507 	{

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

   509 	}  

   510 // ---------------------------------------------------------------------------

   511 // ShowHideVisualsForEmptyText

   512 // ---------------------------------------------------------------------------

   513 // 

   514 void  MulBaseElement::ShowHideVisualsForEmptyText( bool aShow )

   515 	{

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

   517 

   518 	if( !aShow )

   519 		{

   520 		SetTextVisualOpacity( KBackGroundOpacity );

   521 		SetCounterTextOpacity( KBackGroundOpacity);   

   522 		}

   523 	else 

   524 		{

   525 		if(mData->mTextVisible)

   526 			{

   527 			SetTextVisualOpacity( KHighlightOpacity );	

   528 			}		

   529 		// if ui on off template is enabled then reset the counter 

   530 		// opacity depending on the current ui on/off value

   531 		if( Template2D()->IsUiOnOffFlagEnabled() )

   532 			{

   533 			ResetUiOnOff();	

   534 			}

   535 		else

   536 			{

   537 			SetCounterTextOpacity( KHighlightOpacity);   

   538 			}	

   539 		}

   540 	}

   541 	

   542 // ---------------------------------------------------------------------------

   543 // CreateEmptyTextVisualisation

   544 // ---------------------------------------------------------------------------

   545 //	

   546 void MulBaseElement::CreateEmptyTextVisualisation() 

   547 	{

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

   549  

   550 	if( !mData->mEmptyTextVisual )

   551 		{

   552 		THROW_IF_LEAVES

   553 		 ( 

   554 		 	CAlfLayout* main = static_cast<CAlfLayout*>(findVisual( KMainLayoutIndex ));

   555 		    mData->mEmptyTextVisual = CAlfTextVisual::AddNewL(control(),main);

   556 		    

   557 		    TBuf<KTempBufferSize> desc; 

   558 		   

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

   560 		    mData->mEmptyTextVisual->SetTextL(desc);

   561 		    mData->mEmptyTextVisual->SetTagL(KEmptyText);

   562 		    mData->mEmptyTextVisual->SetWrapping(CAlfTextVisual::ELineWrapBreak);

   563 		       

   564 		    TInt fontId =control().Env().TextStyleManager()

   565 				.CreatePlatformTextStyleL(EAknLogicalFontSecondaryFont,-1);	

   566 		    // check if user has set any different color for text.

   567 			if (mData->mTextColor.mIsColorSet)

   568 				{

   569 				// apply the color set by the application

   570 				mData->mEmptyTextVisual->SetColor(mData->mTextColor.mColor);

   571 				}

   572 			else

   573 				{

   574 				// apply the default color

   575 				mData->mEmptyTextVisual->SetColor(KRgbWhite);

   576 				}

   577 			

   578 			mData->mEmptyTextVisual->SetLineSpacing(KTextRowsz);

   579 			mData->mEmptyTextVisual->SetTextStyle(fontId);

   580 		    mData->mEmptyTextVisual->SetFlag(EAlfVisualFlagIgnorePointer);

   581 		 );

   582 		

   583 		}

   584     }

   585 

   586 

   587 

   588 // ---------------------------------------------------------------------------

   589 // DisplayIndicatorIcon

   590 // ---------------------------------------------------------------------------

   591 // 

   592 void MulBaseElement::DisplayIndicatorIcon(const MulVisualItem & aVisualItem, int aIndex)

   593     {

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

   595     CAlfDeckLayout& layout = static_cast<CAlfDeckLayout&>(mData->mIconFlowLayout->Visual(aIndex));

   596     CAlfImageVisual* visual =static_cast<CAlfImageVisual*>(layout.FindTag(KCoverflowIndicator));    

   597     IMulVariantType* varData = aVisualItem.Attribute(mulvisualitem::KMulIndicator2); 

   598     

   599     if(varData)

   600         {

   601         if(!visual)

   602             {

   603             visual = CreateIndicatorIconVisual(layout);   

   604             }

   605         ((MulCoverFlowControl*)&control())->DoSetImage(varData,visual);

   606         visual->ClearFlag(EAlfVisualFlagIgnorePointer);

   607         }

   608 

   609     else if(visual)

   610         {

   611         CAlfTextureManager& textureMgr = control().Env().TextureManager();

   612         TAlfImage image = TAlfImage(textureMgr.BlankTexture()); 

   613         visual->SetImage(image); 

   614         visual->SetFlag(EAlfVisualFlagIgnorePointer);

   615         }

   616 

   617     }

   618  

   619 // ---------------------------------------------------------------------------

   620 // CreateIndicatorIconVisual

   621 // ---------------------------------------------------------------------------

   622 //    

   623 CAlfImageVisual*  MulBaseElement::CreateIndicatorIconVisual(CAlfDeckLayout& aLayout) 

   624     {

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

   626     CAlfImageVisual* indicatorVisual = CAlfImageVisual::AddNewL(control(), &aLayout);

   627     indicatorVisual->SetTagL(KCoverflowIndicator); 

   628     SetIndicatorDimensions(*indicatorVisual);

   629     indicatorVisual->SetScaleMode(CAlfImageVisual::EScaleNormal);

   630     

   631     return indicatorVisual;

   632     }

   633 

   634 // ---------------------------------------------------------------------------

   635 // SetIndicatorDimensions

   636 // ---------------------------------------------------------------------------

   637 //  

   638 void  MulBaseElement::SetIndicatorDimensions(CAlfImageVisual& aIndicatorVisual)

   639     {

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

   641     TMulCoverFlowItem indicatorDimensions = Template2D()->IndicatorDimension();

   642     aIndicatorVisual.SetPos(TAlfRealPoint(indicatorDimensions.posx,indicatorDimensions.posy));

   643     aIndicatorVisual.SetSize(TAlfRealSize(indicatorDimensions.width ,indicatorDimensions.height));    

   644     }

   645     

   646 // ---------------------------------------------------------------------------

   647 // StoreVisualDimensions

   648 // ---------------------------------------------------------------------------

   649 // 

   650 void MulBaseElement::StoreVisualDimensions( TMulCoverFlowItem aHighlightItemDimensions, TMulCoverFlowItem aNonHighlightItemDimensions,int aVisibleIconCount )

   651  	{

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

   653  	mData->mHighlightItemStruct = aHighlightItemDimensions;

   654 	mData->mItemStruct = aNonHighlightItemDimensions;

   655 	mData->mVisibleCount = aVisibleIconCount;

   656 	((MulCoverFlowControl*)&control())->StoreVisibleItemCount(mData->mVisibleCount);

   657 	if (mData->mVisibleCount > 1)

   658 		{

   659 		mData->mChangeSize = true;	

   660 		}

   661 	else

   662 		{

   663 		mData->mChangeSize = false;	

   664 		}

   665  	}

   666 

   667 // ---------------------------------------------------------------------------

   668 // StoreTextVisibility

   669 // ---------------------------------------------------------------------------

   670 //	

   671 void MulBaseElement::StoreTextVisibility( bool aIsTextVisible )

   672 	{

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

   674 	mData->mTextVisible = aIsTextVisible;

   675 	}

   676 

   677 

   678 // ---------------------------------------------------------------------------

   679 // IsTextVisibile

   680 // ---------------------------------------------------------------------------

   681 //  

   682 bool MulBaseElement::IsTextVisibile( )const

   683     {

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

   685     return mData->mTextVisible ;

   686     }

   687 

   688 

   689 // ---------------------------------------------------------------------------

   690 // OrientationChange

   691 // ---------------------------------------------------------------------------

   692 //

   693 void MulBaseElement::OrientationChange()

   694 	{

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

   696 

   697 	mData->mVerticalFlow->SetOpacity(0);

   698 	if (mData->mDummyVisual)

   699 		{

   700 		// deleting since the textextents being zero.

   701 		mData->mDummyVisual->RemoveAndDestroyAllD();

   702 		mData->mDummyVisual = NULL;

   703 		}

   704 

   705 	// update the attribute of visuals

   706 	Template2D()->CreateVisualisation(((MulCoverFlowControl*)&control())->IsLandscape(),true);

   707     

   708     CalculatePadding();    

   709     CreateAndInitializeVisuals(true);

   710 	

   711 	// Redraw the visuals after orientation changes

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

   713 	if( totalModelCount == 0 )

   714 		{

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

   716 		SetDefaultSize(main->Size().ValueNow().AsSize());		

   717 		}

   718 	ArrangeItems();

   719 	SetNewCounterPosition(Template2D()->CounterDimensions(),true);

   720 	UpdateRotation();

   721 	mData->mVerticalFlow->SetOpacity(1);   

   722 	}

   723 

   724 

   725 //------------------Counter and Text related----------------------------------

   726 

   727 // ---------------------------------------------------------------------------

   728 // CreateCounterVisual

   729 // ---------------------------------------------------------------------------

   730 // 

   731 CAlfTextVisual& MulBaseElement::CounterVisual()

   732     {

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

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

   735 

   736     mData->mCounterVisual = &CreateTextVisual(KCoverflowCounter,*mData->mVerticalFlow);

   737     mData->mCounterVisual->SetAlign(EAlfAlignHCenter,EAlfAlignVCenter);

   738 	return *mData->mCounterVisual;

   739     }

   740 

   741 // ---------------------------------------------------------------------------

   742 // CreateVisual

   743 // ---------------------------------------------------------------------------

   744 // 

   745 CAlfTextVisual& MulBaseElement::CreateTextVisual(const TDesC8& aName, 

   746         CAlfLayout& aLayout) 

   747 	{

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

   749 	

   750 	CAlfTextVisual* textVisual =static_cast<CAlfTextVisual*>(aLayout.FindTag(aName));

   751 

   752 	if(textVisual == NULL)

   753 	   {

   754 	   THROW_IF_LEAVES

   755 	        (

   756 	   		textVisual = CAlfTextVisual::AddNewL( (CAlfControl &)control(),&aLayout); 

   757 	        textVisual->SetTagL(aName);

   758 	        ); 

   759 	    textVisual->SetFlag(EAlfVisualFlagIgnorePointer);

   760 	    textVisual->SetFlag(EAlfVisualFlagClipping);

   761 	   }

   762 	return *textVisual;  

   763 	}

   764     

   765     

   766 // ---------------------------------------------------------------------------

   767 // UpdateTextAndCounter

   768 // ---------------------------------------------------------------------------

   769 //	

   770 void MulBaseElement::UpdateTextAndCounter(int animationTime)

   771     {

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

   773     

   774 	UpdateTextValue(animationTime);	

   775     

   776     //After highlight is changed then the counter text should be updated

   777     SetCounterText();

   778     } 

   779     

   780 // ---------------------------------------------------------------------------

   781 // SetCounterTextOpacity

   782 // ---------------------------------------------------------------------------

   783 //  

   784 void MulBaseElement::SetCounterTextOpacity( int aOpacity)

   785     {

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

   787     if(mData->mCounterVisual)

   788         {

   789         mData->mCounterVisual->SetOpacity( aOpacity ); 		

   790         }	    

   791 	}

   792 

   793     

   794 // ---------------------------------------------------------------------------

   795 // ResetUiOnOff

   796 // ---------------------------------------------------------------------------

   797 //	

   798 void MulBaseElement::ResetUiOnOff(int aTransitionTime)

   799     {

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

   801     

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

   803     if(mData->mCounterVisual && Template2D() && Template2D()->IsUiOnOffFlagEnabled() && totalModelCount>0 )

   804         {

   805         int opacity = mData->mUiOn? KHighlightOpacity: KBackGroundOpacity;

   806         mData->mCounterVisual->SetOpacity( TAlfTimedValue(opacity,aTransitionTime)  ); 

   807         // Every time In template4 Ui on off mode toggles we should set the enable holding flag 

   808 		// to gesture helper to recieve the hold events.

   809 		((MulCoverFlowControl*)&control())->SetHoldingEnabled(); 

   810         }

   811     } 

   812     

   813 // ---------------------------------------------------------------------------

   814 // UIOnOffMode

   815 // ---------------------------------------------------------------------------

   816 //

   817 void MulBaseElement::UIOnOffMode(bool aUiOn, int aTransitionTime)

   818     {

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

   820       

   821     mData->mUiOn = aUiOn;

   822     ResetUiOnOff( aTransitionTime );

   823     }

   824     

   825 // ---------------------------------------------------------------------------

   826 // IsUiOnMode

   827 // ---------------------------------------------------------------------------

   828 //  

   829 bool MulBaseElement::IsUiOnMode()

   830 	{

   831     return mData->mUiOn;	

   832 	}

   833 

   834 

   835 // ---------------------------------------------------------------------------

   836 // SetTextVisualOpacity

   837 // ---------------------------------------------------------------------------

   838 //

   839 void MulBaseElement::SetTextVisualOpacity( int aOpacity , int aTransitionTime )

   840 	{

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

   842 	if(mData->mTextLayout)

   843 		{

   844     	mData->mTextLayout->SetOpacity(TAlfTimedValue (aOpacity,aTransitionTime));

   845     	}	

   846 	}

   847 

   848 // ---------------------------------------------------------------------------

   849 // UpdateTextValue

   850 // ---------------------------------------------------------------------------

   851 //

   852 void MulBaseElement::UpdateTextValue(int aAnimationTime)

   853 	{

   854 	MUL_LOG_ENTRY_EXIT("Mul::MulBaseElement::UpdateTextValue");

   855 	if( !mData->mTextVisible )

   856     	{

   857     	return;

   858     	}

   859     	

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

   861 	int highlightindex = static_cast<MulCoverFlowControl*>(&control())->HighlightIndex();

   862     

   863 	if(highlightindex>=0  )

   864         {

   865         //set text to title

   866         try

   867             {

   868 			const MulVisualItem& item = modelAccessor->Item(highlightindex);

   869 			IMulVariantType* varData = item.Attribute(mulvisualitem::KMulTitle);

   870             MUL_LOG_INFO("MUL::UpdateTextValue::UpdateTiltle");

   871             SetTextToVisual( mulvisualitem::KMulTitle, varData  ); 

   872             

   873             // SetVirtualSize if required.

   874             SetVirtualViewPortSize(mulvisualitem::KMulTitle);  

   875             }

   876         catch(...)

   877             {

   878             IMulVariantType* varData = NULL;

   879             SetTextToVisual( mulvisualitem::KMulTitle, varData  );

   880             }

   881          

   882          //set text to detail

   883          try

   884             {

   885 			const MulVisualItem& item = modelAccessor->Item(highlightindex);

   886 			IMulVariantType* varData = item.Attribute(mulvisualitem::KMulDetail);

   887             MUL_LOG_INFO("MUL::UpdateTextValue::UpdateDetail");

   888             SetTextToVisual( mulvisualitem::KMulDetail, varData );

   889             

   890             // SetVirtualSize if required.

   891             SetVirtualViewPortSize(mulvisualitem::KMulDetail);  

   892             }

   893         catch(...)

   894             {

   895             IMulVariantType* varData = NULL;

   896             SetTextToVisual( mulvisualitem::KMulDetail,varData );

   897             } 

   898         

   899         // Cancel if any command is in process before start marquee.

   900         CancelAllCommands();

   901         

   902         // Before orientaion change stop marquee on the text

   903         if(!((static_cast<MulCoverFlowControl&>(control())).IsFastScrollMode())) 

   904             {            

   905             control().Env().Send(

   906                 TAlfCustomEventCommand(ECustomEventMarqueeStart, 

   907                 &control()), KMarqueeTime1000 + aAnimationTime);

   908             

   909             }

   910         }

   911 	}

   912 // ---------------------------------------------------------------------------

   913 // SetTextToVisual

   914 // ---------------------------------------------------------------------------

   915 //

   916 void MulBaseElement::SetTextToVisual( mulvisualitem::TVisualAttribute aName,IMulVariantType* aText )

   917 	{

   918 	MUL_LOG_ENTRY_EXIT("Mul::MulBaseElement::SetTextToVisual");

   919 

   920 	if(mData->mTextLayout)

   921 		{

   922 		CAlfTextVisual* textVisual = 

   923 			static_cast<CAlfTextVisual*> (mData->mTextLayout->FindTag( IdToTag(aName) ));

   924 

   925 		if(textVisual)

   926 			{

   927 			if ( aText )

   928 				{  

   929 				// set text to visual

   930 				THROW_IF_LEAVES

   931 					(

   932 					MUL_LOG_INFO("MUL::SetTextToVisual::Set New Data");

   933 					textVisual->SetTextL(aText->DesC());

   934 					textVisual->SetWrapping(CAlfTextVisual::ELineWrapTruncate);

   935 					);

   936 				    // A workaround till the text visual starts giving the correct text extents value.

   937 		            if(!mData->mDummyVisual)

   938 		                {

   939 		                mData->mDummyVisual = CAlfTextVisual::AddNewL(control(), NULL);

   940 		                mData->mDummyVisual->SetWrapping(CAlfTextVisual::ELineWrapManual);

   941 		                mData->mDummyVisual->SetOpacity(0);

   942 		                mData->mDummyVisual->SetFlags(EAlfVisualFlagIgnorePointer);

   943 		                }

   944 		            

   945 		            // Setting the style same as our text visual.

   946 		            mData->mDummyVisual->SetTextStyle(textVisual->TextStyle()); 

   947 		            mData->mDummyVisual->SetTextL(aText->DesC()); // Setting the text

   948 		            	        

   949 		            if(aName == mulvisualitem::KMulDetail)

   950 		                {

   951 		                mData->mDetailExt = mData->mDummyVisual->TextExtents();

   952 		                }

   953 		            else

   954 		                {

   955 		                mData->mTitleExt = mData->mDummyVisual->TextExtents();

   956 		                }

   957 				}

   958 			else

   959 				{

   960 				// reset to null value .

   961 				THROW_IF_LEAVES

   962 					(

   963 					textVisual->SetTextL(_L(""));

   964 					);

   965 				}

   966 			}

   967 		else

   968 			{

   969 			mData->mTextLayout->SetOpacity(TAlfTimedValue(KBackGroundOpacity,0));   

   970 			}   

   971 		}

   972 	}

   973 

   974 // ---------------------------------------------------------------------------

   975 // SetVirtualViewPortSize()

   976 // ---------------------------------------------------------------------------

   977 //    

   978 void MulBaseElement::SetVirtualViewPortSize(mulvisualitem::TVisualAttribute aName)

   979     {

   980     MUL_LOG_ENTRY_EXIT("Mul::MulBaseElement::SetVirtualViewPortSize");

   981 	CAlfViewportLayout* viewportLayout = NULL ;

   982 	CAlfTextVisual* text = NULL ;

   983 	TSize textExtent ;

   984 	TSize parentSize;

   985 	if (aName == mulvisualitem::KMulDetail)

   986 	    {

   987 	    viewportLayout = static_cast<CAlfViewportLayout*>(

   988 	            mData->mTextLayout->FindTag(KDetailViewPortLayout));

   989 	    if(!viewportLayout)

   990 	        {

   991 	        return; // return if no viewport

   992 	        }

   993         textExtent = mData->mDetailExt;

   994         parentSize = Template2D()->DetailWindowSize();

   995 	          

   996 	    }

   997 	else

   998 	    {

   999 	    viewportLayout = static_cast<CAlfViewportLayout*>(

  1000 	            mData->mTextLayout->FindTag(KTitleViewPortLayout));

  1001 	    if(!viewportLayout)

  1002 	        {

  1003 	        return; // return if no viewport

  1004 	        }

  1005        textExtent = mData->mTitleExt;

  1006        parentSize = Template2D()->TitleWindowSize();

  1007 	        

  1008 	    }

  1009 	text = static_cast<CAlfTextVisual*>(

  1010 	        viewportLayout->FindTag( IdToTag(aName) ));

  1011 	if(!text)

  1012 	    {

  1013 	    return; // if text visual is not found we will not set viewportsize.

  1014 	    }

  1015 	

  1016 	viewportLayout->SetViewportPos((TAlfRealPoint(0, 0)), 0);

  1017     viewportLayout->SetVirtualSize(

  1018             (TAlfRealPoint(parentSize.iWidth, parentSize.iHeight)),0);   

  1019 	

  1020 	//Tollerance is 15 pixel, it might happen that

  1021 	// the text is big but while wrapping it not filling the whole

  1022 	// width of the layout because the remaining space is less to

  1023 	// accomodate a character.

  1024 	// As for QFN_PRIMARY the max character width is 15 pixel

  1025 	// so I am keeping tollerance as 15 

  1026 	// @TODO: Insted of hard coding to 15 pixel use max charecter 

  1027 	// width for QFN_PRIMARY.

  1028 	if ((parentSize.iWidth - textExtent.iWidth) > 15)

  1029 		{

  1030 		text->SetAlign(EAlfAlignHCenter, EAlfAlignVCenter); 	

  1031 		}

  1032 	else

  1033 		{

  1034 		text->SetAlign(EAlfAlignHLocale,EAlfAlignVCenter);

  1035 		}

  1036     }

  1037 

  1038 // ---------------------------------------------------------------------------

  1039 // StartMarquee()

  1040 // ---------------------------------------------------------------------------

  1041 //

  1042 void MulBaseElement::StartMarquee(mulvisualitem::TVisualAttribute aName)

  1043     {

  1044     MUL_LOG_ENTRY_EXIT("Mul::MulBaseElement::StartMarquee");

  1045     // start marquee.

  1046     int widthOffScreen = 0;

  1047     CAlfViewportLayout* viewportLayout = NULL ;

  1048     CAlfTextVisual* text =  NULL ;

  1049 	TSize textExtent ;

  1050 	TSize parentSize;

  1051 	int maxCharWidth ;

  1052 	if (aName == mulvisualitem::KMulDetail)

  1053         {

  1054         viewportLayout =static_cast<CAlfViewportLayout*>(

  1055                 mData->mTextLayout->FindTag(KDetailViewPortLayout));

  1056         if(!viewportLayout)

  1057             {

  1058             return;// return if no viewport

  1059             }                  

  1060        textExtent = mData->mDetailExt;

  1061        parentSize = Template2D()->DetailWindowSize();

  1062        maxCharWidth = Template2D()->DetailMaxCharWidth();         

  1063         }

  1064     else

  1065         {

  1066         viewportLayout = static_cast<CAlfViewportLayout*>(

  1067                 mData->mTextLayout->FindTag(KTitleViewPortLayout));

  1068         if(!viewportLayout)

  1069             {

  1070             return;// return if no viewport

  1071             }

  1072        textExtent = mData->mTitleExt;

  1073        parentSize = Template2D()->TitleWindowSize();

  1074        maxCharWidth = Template2D()->TitleMaxCharWidth();

  1075         }

  1076 	text = static_cast<CAlfTextVisual*>(

  1077 	        viewportLayout->FindTag( IdToTag(aName) ));

  1078 	if(!text)

  1079 	    {

  1080 	    return; // if no text.

  1081 	    }

  1082 	

  1083     text->SetWrapping(CAlfTextVisual::ELineWrapManual);

  1084    

  1085     widthOffScreen= textExtent.iWidth - parentSize.iWidth;

  1086     int nDbMaxChars = (widthOffScreen/(2*maxCharWidth)) + 1;

  1087 	          	        

  1088     // Schedule a update event, when the visual has finished marquee text scrolling.

  1089     if (aName == mulvisualitem::KMulDetail)

  1090         {

  1091         if (nDbMaxChars > 0 )

  1092             {

  1093 			viewportLayout->SetVirtualSize(

  1094 			        (TAlfRealPoint(textExtent.iWidth, parentSize.iHeight)),0);                  

  1095             // to avoid negative time value

  1096             mData->mMarqueeAnimTime = (nDbMaxChars*KMarqueeTime1000);

  1097             viewportLayout->SetViewportPos((TAlfRealPoint(widthOffScreen , 0)), 

  1098                     nDbMaxChars * KMarqueeTime1000);

  1099             // delay after completion of the marquee for titlte.

  1100             mData->mMarqueeAnimTime += KMarqueeTime1000;

  1101             control().Env().Send(

  1102                 TAlfCustomEventCommand(ECustomEventMarqueeFinished, 

  1103                 static_cast<CAlfControl*>(&(control()))), 

  1104                 mData->mMarqueeAnimTime);

  1105             }

  1106         }

  1107     else

  1108         {

  1109         // reset the marquee animation time

  1110         mData->mMarqueeAnimTime = 0;  

  1111         if(nDbMaxChars > 0)

  1112             {

  1113 			viewportLayout->SetVirtualSize(

  1114 			        (TAlfRealPoint(textExtent.iWidth, parentSize.iHeight)),0);  

  1115             

  1116             // to avoid negative time value

  1117             mData->mMarqueeAnimTime = (nDbMaxChars*KMarqueeTime1000);  

  1118             viewportLayout->SetViewportPos((TAlfRealPoint(widthOffScreen , 0)), 

  1119                     nDbMaxChars * KMarqueeTime1000);

  1120             // delay after completion of the marquee for titlte.

  1121             mData->mMarqueeAnimTime += KMarqueeTime1000;

  1122             control().Env().Send(

  1123                 TAlfCustomEventCommand(ECustomEventTitleMarqueeFinished, 

  1124                 static_cast<CAlfControl*>(&(control()))), 

  1125                 mData->mMarqueeAnimTime );

  1126             // delay before start the marquee for detail.

  1127             mData->mMarqueeAnimTime += KMarqueeTime1000;

  1128             }

  1129         control().Env().Send(

  1130             TAlfCustomEventCommand(ECustomEventDetailMarqueeStart, 

  1131             (&(control()))), mData->mMarqueeAnimTime );

  1132         }

  1133     } 	

  1134     

  1135 // ---------------------------------------------------------------------------