1 /*

     2 * Copyright (c) 2007 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:  Implementation of the class CFMRadioAlfMediaIdle

    15 *

    16 */

    17 

    18 

    19 // INCLUDE FILES

    20 

    21 #include <aknlayoutscalable_apps.cdl.h>

    22 #include <alf/alfenv.h>

    23 #include <alf/alftextvisual.h>

    24 #include <alf/alfevent.h>

    25 #include <alf/alftransformation.h>

    26 #include <alf/alfgradientbrush.h>

    27 #include <alf/alfbrusharray.h>

    28 #include <alf/alfborderbrush.h>

    29 #include <alf/alfimagebrush.h>

    30 #include <alf/alftexturemanager.h>

    31 #include <alf/alfviewportlayout.h>

    32 #include <alf/alfdecklayout.h>

    33 #include <alf/alfflowlayout.h> 

    34 #include <alf/alfutil.h>

    35 #include <alf/alftextstyle.h>

    36 #include <AknsItemID.h>

    37 #include <data_caging_path_literals.hrh>

    38 #include <e32math.h>

    39 #include <eikenv.h>

    40 #include <StringLoader.h>

    41 

    42 #include "fmradioalfmediaidle.h"

    43 #include "fmradioappui.h"

    44 #include "debug.h"

    45 

    46 // CONSTANTS

    47 

    48 

    49 _LIT8( KMediaIdleAnchorTag, "mediaIdleAnchor" );

    50 _LIT8( KMediaIdleViewportTag, "mediaIdleViewport" );

    51 _LIT8( KMediaIdleFlowLayoutTag, "mediaIdleFlowLayout" );

    52 _LIT8( KMediaIdleBackgroundTextTag, "mediaIdleBackgroundText" );

    53 _LIT8( KMediaIdleItemTag, "mediaIdleItem" );

    54 

    55 const TInt KNumberOfTextStyles = 4;

    56 const TReal KRelativeFontSizeArray[KNumberOfTextStyles] = {0.12f, 0.17f, 0.25f, 0.33f};

    57 const TReal KRelativeSizeOfMediaIdleBackgroundFont = 0.7f;

    58 

    59 const TInt KMediaIdleFadeOutDurationTime = 500;

    60 const TInt KMediaIdleFadeInDurationTime = 500;

    61 

    62 const TInt  KMediaIdleBackgroundTextScrollInterval = 12000;

    63 const TReal KMediaIdleBackgroundTextOpacity = 0.2f;

    64 const TInt  KMediaIdleBackgroundTextSideToSideTransitionDurationTime = 25000;

    65 

    66 //const TInt KMediaIdleModeChangeInterval = 20000;

    67 

    68 const TInt KMaxNumberOfMediaIdleItems = 5;

    69 const TInt KMaxMediaIdleItemScrollDurationTime = 35000;

    70 const TInt KMinMediaIdleItemScrollDurationTime = 25000;

    71 const TInt KMinMediaIdleItemHideDurationTime = 5000;

    72 const TInt KModeChangingFactor = 3;

    73 

    74 const TReal KMaxOpacity = 0.3f;

    75 const TReal KMinOpacity = 0.1f;

    76 

    77 const TRgb KMediaIdleItemDefaultColor(0, 0, 0);  

    78 const TRgb KMediaIdleItemBackgroundColor(255, 255, 255); 

    79 const TReal KMediaIdleItemBackgroundOpacity = 0.4f;

    80 

    81 const TInt KMediaIdleItemArrayGranularity = 4;

    82 

    83 const TInt KLAFVarietyRadioIdlePortrait = 0;

    84 const TInt KLAFVarietyRadioIdleLandscape = 1;

    85 

    86 

    87 // ============================ MEMBER FUNCTIONS ===============================

    88 

    89 

    90 // ============================ LOCAL FUNCTIONS ===============================

    91 

    92 namespace LocalFunctions {

    93 

    94 // ---------------------------------------------------------------------------

    95 // fullyVerticallyVisibleRect

    96 // Check does the given rect fit vertically into a CAlfLayout area

    97 // ---------------------------------------------------------------------------

    98 //

    99 static TBool fullyVerticallyVisibleRect( const CAlfLayout& aLayout, const TAlfRealRect & aRect )

   100 	{	

   101 	TBool ret = ETrue;

   102 	TInt layoutHeight = aLayout.Size().IntTarget().iY;

   103 	TInt bottomY = aRect.BottomLeft().iY;

   104 	TInt topY = aRect.TopRight().iY;

   105 	

   106 	if ( bottomY >= layoutHeight || topY < 0 ) ret = EFalse;

   107 	

   108 	return ret;

   109 	}

   110 // ---------------------------------------------------------------------------

   111 // updateItemVisibility

   112 // Hide (or unhide) an visual depending is it going to be not fully visible or not

   113 // ---------------------------------------------------------------------------

   114 //

   115 static void updateItemVisibility( const CAlfLayout& aLayout, TInt index )

   116 	{

   117 	CAlfVisual& visual = aLayout.Visual( index );

   118 	if ( !LocalFunctions::fullyVerticallyVisibleRect( aLayout, visual.DisplayRectTarget() ) )

   119 		{

   120 		visual.SetOpacity( TAlfTimedValue( 0.0f, KMinMediaIdleItemHideDurationTime ) );

   121 		}

   122 	}

   123 }

   124 

   125 // ============================ MEMBER FUNCTIONS ===============================

   126 

   127 // ---------------------------------------------------------------------------

   128 // CFMRadioAlfMediaIdle::NewL

   129 // Two-phase constructor of CFMRadioAlfMediaIdle

   130 // ---------------------------------------------------------------------------

   131 //

   132 CFMRadioAlfMediaIdle* CFMRadioAlfMediaIdle::NewL( CAlfEnv& aEnv )

   133 	{

   134 	CFMRadioAlfMediaIdle* self = new (ELeave) CFMRadioAlfMediaIdle( );

   135 	CleanupStack::PushL(self);

   136 	self->ConstructL( aEnv );

   137 	CleanupStack::Pop(self);

   138 	return self;

   139 	}

   140 

   141 // ----------------------------------------------------------------------------

   142 // CFMRadioAlfMediaIdle::CFMRadioAlfMediaIdle

   143 // Default constructor

   144 // ----------------------------------------------------------------------------

   145 //

   146 CFMRadioAlfMediaIdle::CFMRadioAlfMediaIdle() 

   147 :   iFontsOrientation( EOrientationNone ),

   148     iOrientation( EOrientationNone ),

   149 	iMediaIdleItemBackgroundTextStyleId( KErrNotFound ), 

   150 	iMediaIdleState( EStopped ),

   151 	iMediaIdleMode( EBackgroundTextAndMediaIdleItems ),

   152 	iMediaIdleRequestedMode( EBackgroundTextAndMediaIdleItems ),	

   153 	iMediaIdlePrimaryColor( KRgbBlue ),

   154 	iMediaIdleSecondaryColor( KRgbBlue ),

   155 	iPsName( NULL )

   156 	{

   157 	}

   158 

   159 // ----------------------------------------------------------------------------

   160 // CFMRadioAlfMediaIdle::ConstructL

   161 // Symbian 2nd phase constructor can leave.

   162 // ----------------------------------------------------------------------------

   163 //

   164 void CFMRadioAlfMediaIdle::ConstructL( CAlfEnv& aEnv )

   165     {

   166     CAlfControl::ConstructL( aEnv );

   167     UpdateLayout();

   168     iIsConstructed = ETrue;

   169     }

   170 

   171 // ----------------------------------------------------------------------------

   172 // CFMRadioAlfMediaIdle::CreateFontsL

   173 // Create fonts that are based on a list of relative sizes

   174 // ----------------------------------------------------------------------------

   175 //

   176 void CFMRadioAlfMediaIdle::CreateFontsL()

   177 	{

   178 	TInt layoutHeight = 20;

   179 	

   180 	if ( iMediaIdleLayout.Rect().Height() != 0 )

   181 		{

   182 		layoutHeight = iMediaIdleLayout.Rect().Height();

   183 		}

   184 	

   185 	if( iFontsOrientation != iOrientation ||  

   186 		iFontReferenceHeight != layoutHeight )

   187 		{

   188 		CAlfTextStyleManager& manager = Env().TextStyleManager();

   189 		for( TInt i=0; i < iTextStyleIdArray.Count(); i++ )

   190 			{

   191 			manager.DeleteTextStyle( iTextStyleIdArray[i] );

   192 			iTextStyleIdArray.Reset();

   193 			}

   194 		if( iMediaIdleItemBackgroundTextStyleId != KErrNotFound )

   195 			{

   196 			manager.DeleteTextStyle( iMediaIdleItemBackgroundTextStyleId );

   197 			iMediaIdleItemBackgroundTextStyleId = KErrNotFound;

   198 			}

   199 

   200 		// Create largest font for the background text of media idle

   201 		iMediaIdleItemBackgroundTextStyleId = manager.CreatePlatformTextStyleL();	

   202 		CAlfTextStyle* mediaIdleItemStyle = manager.TextStyle( iMediaIdleItemBackgroundTextStyleId );					

   203 		mediaIdleItemStyle->SetTextSizeInPixels( KRelativeSizeOfMediaIdleBackgroundFont * layoutHeight, ETrue );

   204 		// Create text styles for other media idle items

   205 		for( TInt i = 0; i < KNumberOfTextStyles; i++ )

   206 			{		

   207 			TInt mediaIdleItemTextStyleId = manager.CreatePlatformTextStyleL();	

   208 			CAlfTextStyle* mediaIdleItemStyle = manager.TextStyle( mediaIdleItemTextStyleId );					

   209 			mediaIdleItemStyle->SetTextSizeInPixels( KRelativeFontSizeArray[i] * layoutHeight, ETrue ); 

   210 			iTextStyleIdArray.Append( mediaIdleItemTextStyleId );

   211 			}

   212 		iFontsOrientation = iOrientation;

   213 		iFontReferenceHeight = layoutHeight;

   214 		}

   215 	}

   216 

   217 // ---------------------------------------------------------------------------

   218 // ~CFMRadioAlfMediaIdle::~CFMRadioAlfMediaIdle

   219 // Destructor

   220 // ---------------------------------------------------------------------------

   221 //

   222 CFMRadioAlfMediaIdle::~CFMRadioAlfMediaIdle()

   223 	{

   224 	Env().CancelCustomCommands( this );

   225 	if( iMediaIdleItemArray )

   226 		{

   227 		if( iMediaIdleItemArray->Count() > 0 )

   228 			{

   229 			iMediaIdleItemArray->Reset();	

   230 			}

   231 		delete iMediaIdleItemArray;

   232 		}

   233 	CAlfTextStyleManager& manager = Env().TextStyleManager();

   234 	for( TInt i=0; i < iTextStyleIdArray.Count(); i++ )

   235 		{

   236 		manager.DeleteTextStyle( iTextStyleIdArray[i] );

   237 		}

   238 	iTextStyleIdArray.Close();

   239     if ( iMediaIdleItemBackgroundTextStyleId != KErrNotFound )

   240         {

   241         manager.DeleteTextStyle( iMediaIdleItemBackgroundTextStyleId );

   242         }

   243     delete iPsName;

   244     }

   245  

   246 // ----------------------------------------------------------------------------

   247 // CFMRadioAlfMediaIdle::AddMediaIdleL

   248 // Creates the media idle with passed number of media idle items

   249 // ----------------------------------------------------------------------------

   250 //

   251 void CFMRadioAlfMediaIdle::AddMediaIdleL( const TInt aNumberOfMediaIdleItems ) 

   252 	{	

   253 	FTRACE( FPrint( _L("CFMRadioAlfMediaIdle::AddMediaIdleL(%d)"), aNumberOfMediaIdleItems ) );

   254 	

   255 	CAlfAnchorLayout* mediaIdleAnchor = static_cast<CAlfAnchorLayout*> ( FindTag( KMediaIdleAnchorTag ) );

   256 	if ( !mediaIdleAnchor )

   257 		{

   258 		mediaIdleAnchor = CAlfAnchorLayout::AddNewL( *this );	

   259 		}

   260 	mediaIdleAnchor->SetTagL( KMediaIdleAnchorTag );

   261 	

   262 	CAlfViewportLayout* mediaIdleViewport = static_cast<CAlfViewportLayout*> ( FindTag( KMediaIdleViewportTag ) );

   263 	if( !mediaIdleViewport )

   264 		{

   265 		mediaIdleViewport = CAlfViewportLayout::AddNewL( *this, mediaIdleAnchor );

   266 		mediaIdleViewport->SetTagL( KMediaIdleViewportTag );

   267 		mediaIdleViewport->SetViewportPos( TAlfRealPoint( .0f, .0f ), 0 );

   268 		mediaIdleViewport->SetViewportSize( TAlfRealSize( 1.0f, 1.0f ), 0 );

   269 		}

   270 	MediaIdleFadeOut( ETrue ); 

   271 

   272 	// Create the flow layout for the other media idle items

   273 	CAlfFlowLayout* mediaIdleFlowLayout = static_cast<CAlfFlowLayout*> ( FindTag( KMediaIdleFlowLayoutTag ) );

   274 	if( !mediaIdleFlowLayout )

   275 		{

   276 		mediaIdleFlowLayout = CAlfFlowLayout::AddNewL( *this, mediaIdleViewport );

   277 		mediaIdleFlowLayout->SetTagL( KMediaIdleFlowLayoutTag );

   278 		mediaIdleFlowLayout->SetFlowDirection( CAlfFlowLayout::EFlowVertical );

   279 		mediaIdleFlowLayout->SetMode( CAlfFlowLayout::EModeCenterPerpendicular );

   280 		}

   281 	

   282 	InitializeMediaIdleItemsL( aNumberOfMediaIdleItems );

   283 	UpdateLayout();	

   284 	AnimateMediaIdleItems();

   285 	MediaIdleFadeIn();

   286 	}

   287 	

   288 // ----------------------------------------------------------------------------

   289 // CFMRadioAlfMediaIdle::CreateBackgroundTextL

   290 // Creates backgrounf text for media idle content

   291 // ----------------------------------------------------------------------------

   292 //

   293 void CFMRadioAlfMediaIdle::CreateBackgroundTextL()

   294 	{

   295 	FTRACE( FPrint( _L("CFMRadioAlfMediaIdle::CreateBackgroundTextL()") ) );

   296 

   297 	CAlfViewportLayout* mediaIdleViewport = static_cast<CAlfViewportLayout*> ( FindTag( KMediaIdleViewportTag ) );

   298 	// Create and animate the background text of the media idle

   299 	HBufC* itemText = GetRandomMediaIdleContentL();

   300 	CleanupStack::PushL( itemText ); 

   301 	CAlfTextVisual* backgroundText = static_cast<CAlfTextVisual*> ( mediaIdleViewport->FindTag( KMediaIdleBackgroundTextTag ) );

   302 	if( !backgroundText && itemText )

   303 		{	

   304 		backgroundText = AddMediaIdleItemL( mediaIdleViewport, *itemText, EFalse, KMediaIdleItemBackgroundColor, KMediaIdleItemBackgroundOpacity );			

   305 		backgroundText->SetTagL( KMediaIdleBackgroundTextTag );

   306 		SetMediaIdleItemSettingsL( backgroundText, *itemText, iMediaIdleItemBackgroundTextStyleId );

   307 		backgroundText->SetOpacity( TAlfTimedValue( KMediaIdleBackgroundTextOpacity ) ); 

   308 		backgroundText->EnableBrushesL();

   309 		backgroundText->EnableShadow( EFalse );

   310 		SetScrollingToBackgroundText( backgroundText,

   311 						   KMediaIdleBackgroundTextSideToSideTransitionDurationTime,

   312 						   EMediaIdleBackgroundTextScrollEnd );	

   313 		}

   314 	else if( itemText )

   315 		{

   316 		SetMediaIdleItemSettingsL( backgroundText, *itemText, iMediaIdleItemBackgroundTextStyleId );

   317 		backgroundText->SetOpacity( TAlfTimedValue( KMediaIdleBackgroundTextOpacity ) ); 

   318 		SetScrollingToBackgroundText( backgroundText, KMediaIdleBackgroundTextSideToSideTransitionDurationTime, EMediaIdleBackgroundTextScrollEnd );

   319 		}

   320 	CleanupStack::PopAndDestroy( itemText ); 

   321 	}

   322 

   323 // ----------------------------------------------------------------------------

   324 // CFMRadioAlfMediaIdle::InitializeMediaIdleItemsL

   325 // Initializes the media idle items

   326 // ----------------------------------------------------------------------------

   327 //	

   328 void CFMRadioAlfMediaIdle::InitializeMediaIdleItemsL( const TInt aNumberOfMediaIdleItems )

   329 	{

   330 	FTRACE( FPrint( _L("CFMRadioAlfMediaIdle::InitializeMediaIdleItemsL(%d)"), aNumberOfMediaIdleItems ) );

   331 

   332 	CAlfFlowLayout* mediaIdleFlowLayout = static_cast<CAlfFlowLayout*> ( FindTag( KMediaIdleFlowLayoutTag ) );

   333 	if( mediaIdleFlowLayout )

   334 		{

   335 		CreateFontsL();

   336 		CreateBackgroundTextL();

   337 		// Create the media idle items 	  	

   338 		for( TInt i = 0, fontStyleIdIx = 0; i < aNumberOfMediaIdleItems; i++, fontStyleIdIx++ )

   339 			{

   340 			HBufC* itemText = GetRandomMediaIdleContentL();

   341 			const TPtrC& text = itemText ? itemText->Des() : KNullDesC();

   342 

   343 			CleanupStack::PushL( itemText ); 

   344             TInt randFontStyleIx = AlfUtil::RandomInt( 0,  iTextStyleIdArray.Count() - 1 );

   345             CAlfTextVisual* mediaIdleItem = NULL;

   346             if( mediaIdleFlowLayout->Count() < aNumberOfMediaIdleItems )	

   347                 {

   348                 mediaIdleItem  = AddMediaIdleItemL( mediaIdleFlowLayout, text, EFalse, KMediaIdleItemBackgroundColor, KMediaIdleItemBackgroundOpacity );					

   349                 }

   350             else

   351                 {

   352                 mediaIdleItem = static_cast<CAlfTextVisual*> ( &mediaIdleFlowLayout->Visual( i ) );

   353                 mediaIdleItem->SetOpacity( TAlfTimedValue( .0f ) );

   354                 mediaIdleItem->EnableTransformationL( ETrue );

   355                 mediaIdleItem->Transformation().LoadIdentity();

   356                 }	

   357             SetMediaIdleItemSettingsL( mediaIdleItem, text, iTextStyleIdArray[ randFontStyleIx ] );		

   358             CleanupStack::PopAndDestroy( itemText );

   359 			} 

   360 		}

   361 	}

   362 

   363 // ----------------------------------------------------------------------------

   364 // CFMRadioAlfMediaIdle::AnimateMediaIdleItems

   365 // Sets defined animation to the created media idle items

   366 // ----------------------------------------------------------------------------

   367 //	

   368 void CFMRadioAlfMediaIdle::AnimateMediaIdleItems()

   369 	{

   370 	FTRACE( FPrint( _L("CFMRadioAlfMediaIdle::AnimateMediaIdleItems()") ) );

   371 

   372 	CAlfFlowLayout* mediaIdleFlowLayout = static_cast<CAlfFlowLayout*> ( FindTag( KMediaIdleFlowLayoutTag ) );

   373 	if( mediaIdleFlowLayout )

   374 		{		  	

   375 		for( TInt i = 0; i < mediaIdleFlowLayout->Count(); i++ )

   376 			{	

   377 		    CAlfTextVisual* mediaIdleItem = static_cast<CAlfTextVisual*> ( &mediaIdleFlowLayout->Visual( i ) );

   378 		    if( mediaIdleItem )	

   379 				{

   380 			 	SetMediaIdleItemAnimation( mediaIdleItem );	

   381 				}	

   382 			} 

   383 		}

   384 	}

   385 

   386 // ----------------------------------------------------------------------------

   387 // CFMRadioAlfMediaIdle::AddMediaIdleItemL

   388 // Creates the media idle item to the passed media idle view port.

   389 // ----------------------------------------------------------------------------

   390 //	

   391 CAlfTextVisual* CFMRadioAlfMediaIdle::AddMediaIdleItemL( CAlfLayout* aMediaIdle, 

   392                                                          const TDesC& aMediaIdleItemText, 

   393                                                          TBool aMediaIdleItemHasBackground, 

   394                                                          const TRgb& aBackgroundColor, 

   395                                                          const TReal aBackgroundOpacity )

   396 	{

   397 	FTRACE( FPrint( _L("CFMRadioAlfMediaIdle::AddMediaIdleItemL('%S')"), &aMediaIdleItemText ) );

   398 	

   399 	CAlfTextVisual* mediaIdleItem = CAlfTextVisual::AddNewL( *this, aMediaIdle );

   400     mediaIdleItem->EnableBrushesL();

   401     mediaIdleItem->SetTextL( aMediaIdleItemText );	

   402     mediaIdleItem->SetTagL( KMediaIdleItemTag );

   403     mediaIdleItem->EnableShadow( EFalse );

   404     mediaIdleItem->SetAlign( EAlfAlignHCenter, EAlfAlignVCenter );

   405    	// mediaIdleItem->SetFlag( EAlfVisualFlagManualLayout );

   406     mediaIdleItem->SetSize( mediaIdleItem->TextExtents() );

   407         

   408     if ( aMediaIdleItemHasBackground )

   409 	    {

   410 		CAlfGradientBrush* gradientBrush = CAlfGradientBrush::NewLC( Env() );

   411 		gradientBrush->SetColor( aBackgroundColor, aBackgroundOpacity );

   412 		mediaIdleItem->Brushes()->AppendL( gradientBrush, EAlfHasOwnership );

   413 		CleanupStack::Pop( gradientBrush );		

   414 	    }

   415 	return mediaIdleItem;

   416 	}

   417 	

   418 // ----------------------------------------------------------------------------

   419 // CFMRadioAlfMediaIdle::SetMediaIdleItemSettings

   420 // Sets color, opacity and scaling settings to the media idle item

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

   422 //	

   423 void CFMRadioAlfMediaIdle::SetMediaIdleItemSettingsL( CAlfTextVisual* aMediaIdleItem, const TDesC& aMediaIdleItemText, const TInt aTextStyleId )

   424 	{

   425 	// Set text of the media idle item

   426 	aMediaIdleItem->SetTextL( aMediaIdleItemText );	

   427 	aMediaIdleItem->SetOpacity( TAlfTimedValue( .0f ) );

   428 	aMediaIdleItem->EnableTransformationL( ETrue );

   429 	CAlfTransformation* mediaIdleItemTransformation = &( aMediaIdleItem->Transformation() );

   430 	mediaIdleItemTransformation->LoadIdentity();	

   431 	

   432 	// Select text color of the media idle item	

   433 	TInt randomColorSelector = AlfUtil::RandomInt( 0, 1 );

   434 	if ( randomColorSelector )

   435 		{

   436 		// Set text color of the media idle item 	

   437 		aMediaIdleItem->SetColor( iMediaIdlePrimaryColor );	

   438 		}

   439 	else

   440 		{

   441 		// Set text color of the media idle item 	

   442 		aMediaIdleItem->SetColor( iMediaIdleSecondaryColor );

   443 		}

   444 				    	

   445 	// Set text style of the media idle	item   

   446 	aMediaIdleItem->SetTextStyle( aTextStyleId );

   447 		

   448 	TSize itemSize( 0, 0 );

   449 	if ( aMediaIdleItem->TextExtents() != itemSize )

   450 		{

   451 		aMediaIdleItem->SetSize( aMediaIdleItem->TextExtents() );	

   452 		}		

   453 	}

   454 

   455 // ----------------------------------------------------------------------------

   456 // CFMRadioAlfMediaIdle::SetMediaIdleItemAnimation

   457 // Sets translating animations to the media idle item

   458 // ----------------------------------------------------------------------------

   459 //

   460 void CFMRadioAlfMediaIdle::SetMediaIdleItemAnimation( CAlfTextVisual* aMediaIdleItem )

   461 	{	

   462 	FTRACE( FPrint( _L("CFMRadioAlfMediaIdle::SetMediaIdleItemAnimation()") ) );

   463 

   464 	CAlfFlowLayout* mediaIdleFlowLayout = static_cast<CAlfFlowLayout*> ( aMediaIdleItem->Layout() );

   465 	TInt mediaIdleItemCount = mediaIdleFlowLayout->Count();

   466 	TInt mediaIdleItemIndex = mediaIdleFlowLayout->FindVisual( aMediaIdleItem );

   467 	

   468 	TInt mediaIdleItemWidth = aMediaIdleItem->DisplayRect().Width();

   469 	TInt mediaIdleWidth = mediaIdleFlowLayout->Size().IntTarget().iX;

   470 	

   471 	TInt randomTranslateDuration = AlfUtil::RandomInt( KMinMediaIdleItemScrollDurationTime, KMaxMediaIdleItemScrollDurationTime );

   472 	TInt scrollDirection = AlfUtil::RandomInt( 0,  1 );

   473 	TAlfTimedValue targetPositionX;

   474 	if( scrollDirection )

   475 		{

   476 		targetPositionX.SetValueNow( -mediaIdleWidth/2 - mediaIdleItemWidth/2 ); 

   477 		targetPositionX.SetTarget( mediaIdleWidth/2 + mediaIdleItemWidth/2, randomTranslateDuration ); 

   478 		}

   479 	else

   480 		{

   481 		targetPositionX.SetValueNow( mediaIdleWidth/2 + mediaIdleItemWidth/2  );

   482 		targetPositionX.SetTarget( -mediaIdleWidth/2 - mediaIdleItemWidth/2, randomTranslateDuration ); 

   483 		}

   484 

   485 	Translate( aMediaIdleItem, targetPositionX, TAlfTimedValue(0)); // targetPositionY );

   486 

   487 	if( mediaIdleItemIndex >= 0 )

   488 		{

   489 		Env().Send( TAlfCustomEventCommand( EMediaIdleItemTransformationEnd,

   490 											this,

   491 											mediaIdleItemIndex ),

   492 											randomTranslateDuration );

   493 		}

   494 	// Set text opacity of the media idle item

   495 	if( !LocalFunctions::fullyVerticallyVisibleRect( *mediaIdleFlowLayout, aMediaIdleItem->DisplayRect() ) )

   496 		{

   497 		aMediaIdleItem->SetOpacity( TAlfTimedValue( 0.0f ) );

   498 		}

   499 	else

   500 		{

   501 		TReal randomOpacity = AlfUtil::RandomReal( KMinOpacity, KMaxOpacity );

   502 		aMediaIdleItem->SetOpacity( TAlfTimedValue( randomOpacity ) );

   503 		}

   504 	

   505 	mediaIdleFlowLayout->UpdateChildrenLayout( KMinMediaIdleItemScrollDurationTime );

   506 	

   507 	// Checking all items, should they fade or not; must be done after UpdateChildrenLayout

   508 	for (TInt i=0; i<mediaIdleItemCount; i++ ) 

   509 		{

   510 		LocalFunctions::updateItemVisibility( *mediaIdleFlowLayout, i );

   511 		}

   512 	}

   513 

   514 // ---------------------------------------------------------------------------

   515 // CFMRadioAlfMediaIdle::MediaIdleFadeIn

   516 // Fades in media idle

   517 // ---------------------------------------------------------------------------

   518 //		

   519 void CFMRadioAlfMediaIdle::MediaIdleFadeIn( TBool aNow )

   520 	{

   521 	FTRACE( FPrint( _L("CFMRadioAlfMediaIdle::MediaIdleFadeIn(%d)"), aNow ) );

   522 

   523 	CAlfViewportLayout* mediaIdle = static_cast<CAlfViewportLayout*> ( FindTag( KMediaIdleViewportTag ) );

   524 	if ( mediaIdle )

   525 		{	

   526 		if( aNow )

   527 			{

   528 			FadeIn( mediaIdle, 0 );

   529 			}

   530 		else

   531 			{

   532 			FadeIn( mediaIdle, KMediaIdleFadeInDurationTime );	

   533 			}

   534 		}

   535 	}

   536 

   537 // ---------------------------------------------------------------------------

   538 // CFMRadioAlfMediaIdle::MediaIdleFadeOut

   539 // Fades out media idle

   540 // ---------------------------------------------------------------------------

   541 //	

   542 void CFMRadioAlfMediaIdle::MediaIdleFadeOut( TBool aNow )

   543 	{

   544 	FTRACE( FPrint( _L("CFMRadioAlfMediaIdle::MediaIdleFadeOut(%d)"), aNow ) );

   545 

   546 	CAlfViewportLayout* mediaIdle = static_cast<CAlfViewportLayout*> ( FindTag( KMediaIdleViewportTag ) );

   547 	if ( mediaIdle )

   548 		{		

   549 		if( aNow )

   550 			{

   551 			FadeOut( mediaIdle, 0 );

   552 			}

   553 		else

   554 			{

   555 			FadeOut( mediaIdle, KMediaIdleFadeOutDurationTime );	

   556 			}

   557 		}

   558 	}

   559 

   560 // ---------------------------------------------------------------------------

   561 // CFMRadioAlfMediaIdle::StartMediaIdleL

   562 // Launches media idle.

   563 // ---------------------------------------------------------------------------

   564 //

   565 void CFMRadioAlfMediaIdle::StartMediaIdleL() 

   566     {

   567     FTRACE( FPrint( _L("CFMRadioAlfMediaIdle::StartMediaIdleL()") ) );

   568 

   569     if ( iMediaIdleState == EStopped )

   570         {

   571         Env().CancelCustomCommands( this );

   572         iMediaIdleState = ERunning;

   573         AddMediaIdleL( KMaxNumberOfMediaIdleItems );

   574         }

   575     }

   576 

   577 // ----------------------------------------------------------------------------

   578 // CFMRadioAlfMediaIdle::AddMediaIdleContentL

   579 // Adds media idle item text to be used in the media idle

   580 // ----------------------------------------------------------------------------

   581 //		

   582 void CFMRadioAlfMediaIdle::AddMediaIdleContentL( const TDesC& aMediaIdleItemText )

   583 	{

   584 	FTRACE( FPrint( _L("CFMRadioAlfMediaIdle::AddMediaIdleContentL('%S')"), &aMediaIdleItemText ) );

   585 

   586 	if( !iMediaIdleItemArray )

   587 		{

   588 		// Array for media idle items

   589     	iMediaIdleItemArray = new( ELeave ) CDesCArrayFlat( KMediaIdleItemArrayGranularity );

   590     	iMediaIdleItemArray->AppendL( aMediaIdleItemText );

   591 		}

   592 	else

   593 	    {

   594 	    TInt searchResultIndex = 0;

   595 	    if ( iMediaIdleItemArray->Find( aMediaIdleItemText, searchResultIndex ) )

   596 	        {

   597 	        // text wasn't added earlier

   598 	        iMediaIdleItemArray->AppendL( aMediaIdleItemText );

   599 	        }

   600 	    }

   601 	}

   602 

   603 // ----------------------------------------------------------------------------

   604 // CFMRadioAlfMediaIdle::GetRandomMediaIdleContentL

   605 // Retrieves text from randomly chousen media idle item

   606 // ----------------------------------------------------------------------------

   607 //	

   608 HBufC* CFMRadioAlfMediaIdle::GetRandomMediaIdleContentL()	

   609 	{

   610 	if( !iMediaIdleItemArray )

   611 		{	

   612 		return NULL;		

   613 		}

   614 	TInt count = iMediaIdleItemArray->MdcaCount();

   615 	if( count > 0 )

   616     	{  

   617     	TInt mediaIdleItemIndex;

   618     	mediaIdleItemIndex = AlfUtil::RandomInt( 0, count - 1 );

   619     	TPtrC itemContent( iMediaIdleItemArray->MdcaPoint( mediaIdleItemIndex ) );

   620     	return itemContent.AllocL();

   621     	}

   622     else

   623     	{

   624     	return NULL;	

   625     	}

   626 	}

   627 

   628 // ----------------------------------------------------------------------------

   629 // CFMRadioAlfMediaIdle::ResetMediaIdleContent

   630 // Removes all media idle item texts

   631 // ----------------------------------------------------------------------------

   632 //

   633 void  CFMRadioAlfMediaIdle::ResetMediaIdleContent()

   634 	{

   635 	FTRACE( FPrint( _L("CFMRadioAlfMediaIdle::ResetMediaIdleContent()") ) );

   636 

   637 	delete iPsName;

   638 	iPsName = NULL;

   639 	if( iMediaIdleItemArray )

   640 		{

   641 		if( iMediaIdleItemArray->Count() > 0 )

   642 			{

   643 			iMediaIdleItemArray->Reset();	

   644 			iMediaIdleItemArray->Compress();

   645 			}	

   646 		}	

   647 	}

   648 

   649 // ----------------------------------------------------------------------------

   650 // CFMRadioAlfMediaIdle::MediaIdleContentCount

   651 // Returns number of media idle content items  

   652 // ----------------------------------------------------------------------------

   653 //

   654 TInt CFMRadioAlfMediaIdle::MediaIdleContentCount() const

   655 	{

   656 	if( iMediaIdleItemArray )

   657 		{

   658 		return iMediaIdleItemArray->Count();

   659 		}

   660 	else

   661 		{

   662 		return 0;

   663 		}

   664 	}

   665 

   666 // ----------------------------------------------------------------------------

   667 // CFMRadioAlfMediaIdle::SetPrimaryColor

   668 // Sets primary color for the media idle

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

   670 //

   671 void CFMRadioAlfMediaIdle::SetPrimaryColor( const TRgb& aColor )		

   672 	{

   673 	iMediaIdlePrimaryColor = aColor;	

   674 	}

   675 

   676 // ----------------------------------------------------------------------------

   677 // CFMRadioAlfMediaIdle::SetSecondaryColor

   678 // Sets secondary color for the media idle

   679 // ----------------------------------------------------------------------------

   680 //

   681 void CFMRadioAlfMediaIdle::SetSecondaryColor( const TRgb& aColor )		

   682 	{

   683 	iMediaIdleSecondaryColor = aColor;	

   684 	}

   685 

   686 // ----------------------------------------------------------------------------

   687 // CFMRadioAlfMediaIdle::Translate

   688 // Translates the visual object with passed arguments

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

   690 //	

   691 void CFMRadioAlfMediaIdle::Translate( CAlfTextVisual* aTextVisual, const TAlfTimedValue& aX, const TAlfTimedValue& aY )

   692 	{

   693 	if( aTextVisual )

   694 		{

   695 		TRAPD( err, aTextVisual->EnableTransformationL( ETrue ) );

   696 		if( err == KErrNone )

   697 			{

   698 			CAlfTransformation* visualTransformation = &( aTextVisual->Transformation() );

   699 			TAlfTimedValue x(aX);

   700 			x.SetStyle( EAlfTimedValueStyleLinear );

   701 			

   702 			TAlfTimedValue y(aY);

   703 			y.SetStyle( EAlfTimedValueStyleLinear );

   704 			

   705 			visualTransformation->Translate( x, y );

   706 			}			

   707 		}

   708 	}

   709 

   710 // ----------------------------------------------------------------------------

   711 // CFMRadioAlfMediaIdle::LoadTextVisualIdentity

   712 // Removes all transformations of the visual object such as the scaling and translating.

   713 // ----------------------------------------------------------------------------

   714 //

   715 void CFMRadioAlfMediaIdle::LoadTextVisualIdentity( CAlfTextVisual* aTextVisual )

   716 	{

   717 	if( aTextVisual )

   718 		{

   719 		TRAPD( err, aTextVisual->EnableTransformationL( ETrue ) );

   720 		if( err == KErrNone )

   721 			{

   722 			CAlfTransformation* visualTransformation = &( aTextVisual->Transformation() );

   723 			visualTransformation->LoadIdentity();		

   724 			}

   725 		}

   726 	}

   727 	

   728 // ----------------------------------------------------------------------------

   729 // CFMRadioAlfMediaIdle::UpdateLayout

   730 // Calculates display layout

   731 // ----------------------------------------------------------------------------

   732 //

   733 void CFMRadioAlfMediaIdle::UpdateLayout()

   734 	{

   735 	FTRACE( FPrint( _L("CFMRadioAlfMediaIdle::UpdateLayout()") ) );

   736 	

   737     TRect mainPaneRect;

   738     AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EMainPane, mainPaneRect );   

   739     TRect displayRect( mainPaneRect.Size() );   	

   740 

   741     TInt lafVarietyMediaIdle = 0;

   742 

   743     // Adjust positions of the visual elements 

   744     if ( iOrientation == EPortrait || iOrientation == EOrientationNone )

   745         {

   746         lafVarietyMediaIdle = KLAFVarietyRadioIdlePortrait;		

   747         }

   748     else if ( iOrientation == ELandscape )

   749         {

   750         lafVarietyMediaIdle = KLAFVarietyRadioIdleLandscape;

   751         }

   752 

   753     iMediaIdleLayout.LayoutRect( displayRect,

   754             AknLayoutScalable_Apps::area_fmrd2_visual_pane( lafVarietyMediaIdle ).LayoutLine() );

   755 

   756 	if ( iIsConstructed )

   757 		{

   758 		CAlfVisual* thirdVisual = FindTag( KMediaIdleAnchorTag );

   759 		if ( thirdVisual )

   760 			{

   761 			CAlfAnchorLayout* mediaIdleAnchor = static_cast<CAlfAnchorLayout*>( thirdVisual );

   762 			SetAbsoluteCornerAnchors( mediaIdleAnchor, 0, iMediaIdleLayout.Rect().iTl, iMediaIdleLayout.Rect().iBr  );

   763 			mediaIdleAnchor->UpdateChildrenLayout();

   764 			}

   765 		}

   766 	}

   767 

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

   769 // CFMRadioAlfMediaIdle::SetModeChangeRequest

   770 // Sets request for mode change

   771 // ----------------------------------------------------------------------------

   772 //

   773 void CFMRadioAlfMediaIdle::SetModeChangeRequestL( TMediaIdleMode aRequestedMode )

   774 	{

   775 	FTRACE( FPrint( _L("CFMRadioAlfMediaIdle::SetModeChangeRequestL(%d)"), aRequestedMode ) );

   776 

   777 	iMediaIdleRequestedMode = aRequestedMode;

   778 	if( iMediaIdleRequestedMode == EBackgroundTextAndMediaIdleItems && 

   779 		Mode() == EOnlyBackgroundText )

   780 		{

   781 		InitializeMediaIdleItemsL( KMaxNumberOfMediaIdleItems );

   782 		AnimateMediaIdleItems();

   783 		SetMode( EBackgroundTextAndMediaIdleItems );

   784 		}

   785 	}

   786 

   787 // ----------------------------------------------------------------------------

   788 // CFMRadioAlfMediaIdle::SetMode

   789 // Sets the media idle mode

   790 // ----------------------------------------------------------------------------

   791 //

   792 void CFMRadioAlfMediaIdle::SetMode( TMediaIdleMode aMode )

   793 	{

   794 	FTRACE( FPrint( _L("CFMRadioAlfMediaIdle::SetMode(%d)"), aMode ) );

   795 

   796 	iMediaIdleMode = aMode;

   797 	}

   798 	

   799 // ----------------------------------------------------------------------------

   800 // CFMRadioAlfMediaIdle::Mode

   801 // Retrieves the media idle mode

   802 // ----------------------------------------------------------------------------

   803 //

   804 CFMRadioAlfMediaIdle::TMediaIdleMode CFMRadioAlfMediaIdle::Mode()

   805 	{

   806 	return iMediaIdleMode;

   807 	}

   808 

   809 // ----------------------------------------------------------------------------

   810 // CFMRadioAlfMediaIdle::Orientation

   811 // Return orientation of the display

   812 // ----------------------------------------------------------------------------

   813 //

   814 CFMRadioAlfMediaIdle::TOrientation CFMRadioAlfMediaIdle::Orientation()

   815 	{

   816 	return iOrientation;

   817 	}

   818 

   819 // ----------------------------------------------------------------------------

   820 // CFMRadioAlfMediaIdle::Orientation

   821 // Set orientation of the display

   822 // ----------------------------------------------------------------------------

   823 //		

   824 void CFMRadioAlfMediaIdle::SetOrientation( TOrientation aOrientation )

   825 	{

   826 	iOrientation = aOrientation;

   827 	}

   828 

   829 // ----------------------------------------------------------------------------

   830 // CFMRadioAlfMediaIdle::OfferEventL

   831 // From CAlfControl, takes care of alfred event handling.

   832 // ----------------------------------------------------------------------------

   833 //

   834 TBool CFMRadioAlfMediaIdle::OfferEventL( const TAlfEvent& aEvent )

   835 	{

   836 	TBool isHandled = EFalse;

   837 	if( aEvent.IsCustomEvent() )

   838 		{

   839 		FTRACE( FPrint( _L("CFMRadioAlfMediaIdle::OfferEventL(aEvent.CustomParameter()=%d)"), aEvent.CustomParameter() ) );

   840 

   841 		switch( aEvent.CustomParameter() )

   842 			{

   843 			case EMediaIdleItemTransformationEnd:

   844 				{

   845 				HandleMediaIdleItemTransformationEndEventL( aEvent );	

   846 				isHandled = ETrue;

   847 				}

   848 				break;

   849 			case EMediaIdleBackgroundTextScrollEnd:

   850 				{	

   851 				HandleBackgroundTextScrollEndEventL( aEvent );		

   852 				isHandled = ETrue;

   853 				}

   854 				break;

   855 			case EMediaIdleChangeMode:

   856 				{	

   857 				if( Mode() == EBackgroundTextAndMediaIdleItems )

   858 					{

   859 					SetModeChangeRequestL( EOnlyBackgroundText );

   860 					}

   861 				else

   862 					{

   863 					SetModeChangeRequestL( EBackgroundTextAndMediaIdleItems );

   864 					}

   865 				isHandled = ETrue;

   866 				}

   867 				break;

   868 			default:

   869 			break;

   870 			}

   871 		}

   872 	return isHandled;

   873 	}

   874 

   875 // ----------------------------------------------------------------------------

   876 // CFMRadioAlfMediaIdle::HandleMediaIdleItemTransformationEndEventL

   877 // ----------------------------------------------------------------------------

   878 //

   879 void CFMRadioAlfMediaIdle::HandleMediaIdleItemTransformationEndEventL( const TAlfEvent& aEvent )

   880 	{

   881 	FTRACE( FPrint( _L("CFMRadioAlfMediaIdle::HandleMediaIdleItemTransformationEndEventL()") ) );

   882 	

   883 	iItemsTransformationEndEventCounter++;

   884 	if ( iMediaIdleRequestedMode == EOnlyBackgroundText || Mode() == EOnlyBackgroundText )

   885 		{			

   886 		CAlfFlowLayout* mediaIdleFlowLayout = static_cast<CAlfFlowLayout*> ( FindTag( KMediaIdleFlowLayoutTag ) );			

   887 		if ( mediaIdleFlowLayout )

   888 			{					

   889 			TInt mediaIdleItemIndex = aEvent.CustomEventData(); 

   890 			CAlfTextVisual* mediaIdleItem = static_cast<CAlfTextVisual*> ( &mediaIdleFlowLayout->Visual( mediaIdleItemIndex ) );

   891 			if ( mediaIdleItem )

   892 				{

   893 				mediaIdleItem->SetOpacity( TAlfTimedValue( .0f ) ); 

   894 				}

   895 			

   896 			if( iItemsTransformationEndEventCounter == mediaIdleFlowLayout->Count() )

   897 				{

   898 				SetMode( EOnlyBackgroundText ); 

   899 				iItemsTransformationEndEventCounter = 0;

   900 				Env().Send( TAlfCustomEventCommand( EMediaIdleBackgroundTextScrollEnd, this ), 0 );

   901 				}

   902 			}

   903 		}

   904 	else 

   905 		{ 

   906 		CAlfFlowLayout* mediaIdleFlowLayout = static_cast<CAlfFlowLayout*> ( FindTag( KMediaIdleFlowLayoutTag ) );			

   907 		if ( mediaIdleFlowLayout )

   908 			{

   909 			HBufC* itemText = GetRandomMediaIdleContentL();

   910 			if( itemText )

   911 				{

   912 				CleanupStack::PushL( itemText ); 

   913 				TInt mediaIdleItemIndex = aEvent.CustomEventData(); 

   914 				CAlfTextVisual* mediaIdleItem = static_cast<CAlfTextVisual*> ( &mediaIdleFlowLayout->Visual( mediaIdleItemIndex ) );

   915 				if ( mediaIdleItem && iTextStyleIdArray.Count() > 0 )

   916 					{

   917 			    	// First hide the media idle item	

   918 					mediaIdleItem->SetOpacity( TAlfTimedValue( .0f ) );

   919 					mediaIdleItem->EnableTransformationL( ETrue );

   920 					mediaIdleItem->Transformation().LoadIdentity();	

   921 										

   922 					TInt randFontStyleIx = AlfUtil::RandomInt( 0,  iTextStyleIdArray.Count() - 1 );

   923 					SetMediaIdleItemSettingsL( mediaIdleItem, *itemText,  iTextStyleIdArray[ randFontStyleIx ] );				

   924 					SetMediaIdleItemAnimation( mediaIdleItem );	

   925 					

   926 					if ( iMediaIdleRequestedMode != EOnlyBackgroundText )

   927 						{

   928 						if( iItemsTransformationEndEventCounter == mediaIdleFlowLayout->Count() )

   929 							{

   930 							Env().Send( TAlfCustomEventCommand( EMediaIdleChangeMode, this ),

   931 									KMaxMediaIdleItemScrollDurationTime * KModeChangingFactor );

   932 							iItemsTransformationEndEventCounter = 0;

   933 							}

   934 						}

   935 					}

   936 				CleanupStack::PopAndDestroy( itemText ); 

   937 				}

   938 			}

   939 		}

   940 	}

   941 

   942 // ----------------------------------------------------------------------------

   943 // CFMRadioAlfMediaIdle::HandleBackgroundTextScrollEndEventL

   944 // ----------------------------------------------------------------------------

   945 //

   946 void CFMRadioAlfMediaIdle::HandleBackgroundTextScrollEndEventL( const TAlfEvent& /*aEvent*/ )

   947 	{

   948     FTRACE( FPrint( _L("CFMRadioAlfMediaIdle::HandleBackgroundTextScrollEndEventL()") ) );

   949 	   

   950 	CAlfViewportLayout* mediaIdleViewport = static_cast<CAlfViewportLayout*> ( FindTag( KMediaIdleViewportTag ) );

   951 	if( mediaIdleViewport )

   952 		{

   953 		CAlfTextVisual* backgroundText = static_cast<CAlfTextVisual*> ( mediaIdleViewport->FindTag( KMediaIdleBackgroundTextTag ) );

   954 		if( backgroundText )

   955 			{				

   956 			backgroundText->SetOpacity( TAlfTimedValue( .0f ) );

   957 

   958 			if ( iMediaIdleRequestedMode == EOnlyBackgroundText && Mode() ==  EBackgroundTextAndMediaIdleItems )

   959 				{

   960 				}

   961 			else

   962 				{

   963 				if( iMediaIdleRequestedMode == EOnlyBackgroundText && 

   964 						Mode() == EOnlyBackgroundText )

   965 					{

   966 					Env().CancelCustomCommands( this );

   967 					Env().Send( TAlfCustomEventCommand( EMediaIdleChangeMode, this ),

   968 							KMediaIdleBackgroundTextSideToSideTransitionDurationTime );

   969 					}

   970 				backgroundText->EnableTransformationL( ETrue );

   971 				backgroundText->Transformation().LoadIdentity();

   972 				HBufC* itemText = GetRandomMediaIdleContentL();

   973 				if( itemText )

   974 					{

   975 					CleanupStack::PushL( itemText ); 

   976 					SetMediaIdleItemSettingsL( backgroundText, *itemText, iMediaIdleItemBackgroundTextStyleId );

   977 					CleanupStack::PopAndDestroy( itemText );

   978 					}

   979 				backgroundText->SetOpacity( TAlfTimedValue( KMediaIdleBackgroundTextOpacity ) );

   980 				SetScrollingToBackgroundText( backgroundText,

   981 								   KMediaIdleBackgroundTextSideToSideTransitionDurationTime,

   982 								   EMediaIdleBackgroundTextScrollEnd );		

   983 				}	

   984 			}

   985 		}

   986 	}

   987 

   988 // ---------------------------------------------------------------------------

   989 // CFMRadioAlfMediaIdle::SetAbsoluteCornerAnchors

   990 // Sets absolute rect of the anchor by top left and bottom right points.

   991 // ---------------------------------------------------------------------------

   992 //

   993 void CFMRadioAlfMediaIdle::SetAbsoluteCornerAnchors( CAlfAnchorLayout* aAnchor,

   994 													 TInt aOrdinal,

   995 													 const TPoint& aTopLeftPosition,													 

   996 													 const TPoint& aBottomRightPosition )

   997 	{

   998 	if ( aAnchor )

   999 		{					

  1000 		// Set top/left anchor.

  1001 	    aAnchor->Attach( aOrdinal, 

  1002 			             EAlfAnchorTypeTopLeft,

  1003 			             TAlfXYMetric( TAlfMetric( aTopLeftPosition.iX ), TAlfMetric( aTopLeftPosition.iY ) ),

  1004 			             EAlfAnchorAttachmentOriginTopLeft );

  1005 		

  1006 		

  1007 		// Set bottom/right anchor.

  1008 		aAnchor->Attach( aOrdinal, 

  1009 		                 EAlfAnchorTypeBottomRight, 

  1010 		                 TAlfXYMetric( TAlfMetric( aBottomRightPosition.iX ), TAlfMetric( aBottomRightPosition.iY ) ),

  1011 		                 EAlfAnchorAttachmentOriginTopLeft );

  1012 		}

  1013 	}

  1014 

  1015 // ---------------------------------------------------------------------------

  1016 // CFMRadioAlfMediaIdle::SetAbsoluteCornerAnchors

  1017 // Sets absolute rect of the anchor by top left point and size of the rect

  1018 // ---------------------------------------------------------------------------

  1019 //	

  1020 void CFMRadioAlfMediaIdle::SetAbsoluteCornerAnchors( CAlfAnchorLayout* aAnchor, TInt aOrdinal, const TPoint& aTopLeftPosition, const TSize& aSize )

  1021 	{

  1022 	if( aAnchor )

  1023 		{

  1024 		// set top left corner position

  1025 		aAnchor->SetAnchor( EAlfAnchorTopLeft, aOrdinal,

  1026 		EAlfAnchorOriginLeft, 

  1027 		EAlfAnchorOriginTop,

  1028 		EAlfAnchorMetricAbsolute, 

  1029 		EAlfAnchorMetricAbsolute, 

  1030 		TAlfTimedPoint( aTopLeftPosition.iX, aTopLeftPosition.iY ) );

  1031 		// .. and set the bottom right corner also to fix the size

  1032 		aAnchor->SetAnchor( EAlfAnchorBottomRight, aOrdinal,

  1033 		EAlfAnchorOriginLeft, 

  1034 		EAlfAnchorOriginTop,

  1035 		EAlfAnchorMetricAbsolute, 

  1036 		EAlfAnchorMetricAbsolute,

  1037 		TAlfTimedPoint( aTopLeftPosition.iX + aSize.iWidth, aTopLeftPosition.iY + aSize.iHeight ) );			

  1038 		}

  1039 	}

  1040 	

  1041 // ---------------------------------------------------------------------------

  1042 // CFMRadioAlfMediaIdle::SetRelativeCornerAnchors

  1043 // Sets relative rect of the anchor by top left and bottom right points.

  1044 // ---------------------------------------------------------------------------

  1045 //

  1046 void CFMRadioAlfMediaIdle::SetRelativeCornerAnchors( CAlfAnchorLayout* aAnchor, TInt aOrdinal, const TAlfRealPoint& aTopLeftPosition, const TAlfRealPoint& aBottomRightPosition )

  1047 	{

  1048 	if( aAnchor )

  1049 		{

  1050 		aAnchor->SetRelativeAnchorRect( aOrdinal,

  1051     	EAlfAnchorOriginLeft, EAlfAnchorOriginTop, aTopLeftPosition,

  1052         EAlfAnchorOriginLeft, EAlfAnchorOriginTop, aBottomRightPosition );		

  1053 		}

  1054 	}

  1055 	

  1056 // ---------------------------------------------------------------------------

  1057 // CFMRadioAlfMediaIdle::SetRelativeCornerAnchors

  1058 // Sets relative rect of the anchor by top left point and size of the rect

  1059 // ---------------------------------------------------------------------------

  1060 //	

  1061 void CFMRadioAlfMediaIdle::SetRelativeCornerAnchors( CAlfAnchorLayout* aAnchor, TInt aOrdinal, const TAlfRealPoint& aTopLeftPosition, const TAlfRealSize& aSize )

  1062 	{

  1063 	if( aAnchor )

  1064 		{

  1065 		aAnchor->SetRelativeAnchorRect( aOrdinal,

  1066     	EAlfAnchorOriginLeft, EAlfAnchorOriginTop, aTopLeftPosition,

  1067         EAlfAnchorOriginLeft, EAlfAnchorOriginTop, aTopLeftPosition + TAlfRealPoint( aSize.iWidth, aSize.iHeight ) );		

  1068 		}

  1069 	}

  1070 

  1071 // ----------------------------------------------------------------------------

  1072 // CFMRadioAlfMediaIdle::SetScrollingToBackgroundText

  1073 // ----------------------------------------------------------------------------

  1074 //

  1075 void CFMRadioAlfMediaIdle::SetScrollingToBackgroundText( CAlfTextVisual* aVisual, TInt aTransitionTime, TMediaIdleCustomEvent aEventAfterScrollingEnd )

  1076 	{

  1077 	FTRACE( FPrint( _L("CFMRadioAlfMediaIdle::SetScrollingToBackgroundText(aTransitionTime=%d)"), aTransitionTime ) );

  1078 	

  1079 	CAlfViewportLayout* mediaIdle = static_cast<CAlfViewportLayout*> ( aVisual->Layout() );

  1080 	TInt mediaIdleItemWidth = aVisual->DisplayRect().Width();

  1081 	TInt mediaIdleItemHeight = aVisual->DisplayRect().Height();

  1082 	TInt mediaIdleWidth = mediaIdle->Size().IntTarget().iX;

  1083 	

  1084 	TAlfTimedValue targetPositionX;

  1085 	if( iBackgroundTextScrollDirection == EScrollRightToLeft  )

  1086 	 	{

  1087 		targetPositionX.SetValueNow(  -mediaIdleItemWidth ); 

  1088 		targetPositionX.SetTarget( mediaIdleWidth, aTransitionTime ); 		

  1089 	 	iBackgroundTextScrollDirection = EScrollLeftToRight;

  1090 	 	}

  1091 	else

  1092 	 	{ 	

  1093 		targetPositionX.SetValueNow( mediaIdleWidth );

  1094 		targetPositionX.SetTarget( -mediaIdleItemWidth, aTransitionTime ); 

  1095 		iBackgroundTextScrollDirection = EScrollRightToLeft;

  1096 	 	}

  1097 	Translate( aVisual, targetPositionX, TAlfTimedValue( -30 ) );

  1098 	Env().Send( TAlfCustomEventCommand( aEventAfterScrollingEnd, this ), 

  1099 			    aTransitionTime + KMediaIdleBackgroundTextScrollInterval );

  1100 	}

  1101 

  1102 // ----------------------------------------------------------------------------

  1103 // CFMRadioAlfMediaIdle::ScrollToLeft

  1104 // Sets and starts scrolling animation to CAlfTextVisual.

  1105 // The visual object is scrolled from current position to 

  1106 // left side of the display

  1107 // ----------------------------------------------------------------------------

  1108 //	

  1109 void CFMRadioAlfMediaIdle::ScrollToLeft( CAlfTextVisual* aVisual ) const

  1110 	{

  1111 	FTRACE( FPrint( _L("CFMRadioAlfMediaIdle::ScrollToLeft(0x%x)"), aVisual ) );

  1112 	

  1113 	if( aVisual )

  1114 		{

  1115 		TInt visualWidth = aVisual->DisplayRect().Width();

  1116 		TInt textWidth = aVisual->TextExtents().iWidth;

  1117 		TInt scrollValue = visualWidth;

  1118 		if( textWidth > visualWidth )

  1119 			{

  1120 			scrollValue += textWidth - visualWidth; 

  1121 			}

  1122 		TAlfTimedPoint timedPosition = aVisual->Pos();

  1123 		TAlfRealPoint positionZero( 0, timedPosition.iY.ValueNow() );

  1124 		TAlfRealPoint positionLeft( - ( scrollValue ), timedPosition.iY.ValueNow() );

  1125 		aVisual->SetPos( positionZero );

  1126 		aVisual->SetPos( positionLeft, 1000 );

  1127 		}

  1128 	}

  1129 

  1130 // ----------------------------------------------------------------------------

  1131 // CFMRadioAlfMediaIdle::ScrollToRight

  1132 // Sets and starts scrolling animation to CAlfTextVisual.

  1133 // The visual object is scrolled from current position to 

  1134 // right side of the display