/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

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

* which accompanies this distribution, and is available

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

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: 

*

*/

/*

* ============================================================================

*  Name        : radioidle.cpp

*  Part of     :

*  Description :

*  Version     :

*

* ==============================================================================

*/

// INCLUDE FILES

#include <eikenv.h>

#include <stringloader.h>

#include <alf/alfcontrolgroup.h>

#include <alf/alfenv.h>

#include <alf/alftextvisual.h>

#include <alf/alfevent.h>

#include <alf/alftransformation.h>

#include <alf/alfgradientbrush.h>

#include <alf/alfbrusharray.h>

#include <alf/alfborderbrush.h>

#include <alf/alfimagevisual.h>

#include <alf/alfimagebrush.h>

#include <alf/alftexturemanager.h>

#include <alf/alfdisplay.h>

#include <alf/alfviewportlayout.h>

#include <alf/alfdecklayout.h>

#include <alf/alfflowlayout.h>

#include <alf/alfutil.h>

#include <alf/alfTextStyle.h>

#include <aknsitemid.h>

#include <e32math.h>

#include <data_caging_path_literals.hrh>

#include "irradioidle.h"

#include "irdebug.h"

// CONSTANTS

// bitmap file for the background of the display

_LIT8( KRadioIdleAnchorTag, "radioIdleAnchor" );

_LIT8( KRadioIdleFlowLayoutTag, "radioIdleFlowLayout" );

_LIT8( KRadioIdleBackgroundTextTag, "radioIdleBackgroundText" );

_LIT8( KRadioIdleItemTag, "radioIdleItem" );

const TInt KSizeOfRadioIdleItemBigFont = 400; // background text

const TInt KSizeOfRadioIdleItemMediumFont = 60;

const TInt KSizeOfRadioIdleItemSmallFont = 30;

const TInt KRadioIdleFadeOutDurationTime = 400;

const TInt KRadioIdleFadeInDurationTime = 0; 

const TInt  KRadioIdleBackgroundTextScrollInterval = 12000;

const TReal32 KRadioIdleBackgroundTextOpacity = 0.2f;

const TInt  KRadioIdleBackgroundTextSideToSideTransitionDurationTime = 25000;

const TInt KMaxNumberOfRadioIdleItems = 5;

const TReal32 KMaxRadioIdleItemsOverlap = 0.2f;

const TInt KMaxRadioIdleItemScrollDurationTime = 35000;

const TInt KMinRadioIdleItemScrollDurationTime = 25000;

const TInt KModeChangingFactor = 3;

const TReal32 KMaxOpacity = 0.7f;

const TReal32 KMinOpacity = 0.3f;

const TInt KMaxRadioIdleItemColorDeviation = 30; // must be <= 255

const TRgb KRadioIdleItemDefaultColor(128,128,128);

const TRgb KRadioIdleItemBackgroundColor(255, 255, 255);

const TReal32 KRadioIdleItemBackgroundOpacity = 0.5f;

const TReal32 KRadioIdleBackgroundOpacity = 0.4f;

const TInt KRadioIdleItemArrayGranularity = 4;

const TInt Kone=1;

const TInt KTwoFiftyFive=255;

const TInt KZero=0;

const TInt KTen=10;

const TInt KThousand=1000;

//const TInt KThree=3

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

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

// CIRRadioIdle::NewL

// Two-phase constructor of CIRRadioIdle

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

//

CIRRadioIdle* CIRRadioIdle::NewL( CAlfEnv& aEnv, TInt aControlGroupId, CAlfLayout* aParentLayout )

	{

	CIRRadioIdle* self = new (ELeave) CIRRadioIdle();

	CleanupStack::PushL(self);

	self->ConstructL( aEnv, aControlGroupId, aParentLayout );

	CleanupStack::Pop(self);

	return self;

	}

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

// CIRRadioIdle::CIRRadioIdle

// Default constructor

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

//

CIRRadioIdle::CIRRadioIdle()

:   iOrientation ( EOrientationNone ),

	iFadeStyle( EFadeStyleNone ),

	iRadioIdleState( EStopped ),

	iRadioIdleMode( EBackgroundTextAndRadioIdleItems ),

	iRadioIdleRequestedMode( EBackgroundTextAndRadioIdleItems ),

    iRadioIdlePrimaryColor(KRadioIdleItemDefaultColor),

    iRadioIdleSecondaryColor( KRadioIdleItemDefaultColor )

	{

	}

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

// CIRRadioIdle::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CIRRadioIdle::ConstructL( CAlfEnv& aEnv, TInt aControlGroupId, CAlfLayout* aParentLayout )

	{

	CAlfControl::ConstructL( aEnv );

	iParentLayout = aParentLayout;

    // Create largest font for the background text of radio idle

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

	iRadioIdleItemBackgroundTextStyleId = manager.CreatePlatformTextStyleL();

	CAlfTextStyle* radioIdleItemStyle = manager.TextStyle( iRadioIdleItemBackgroundTextStyleId );

	radioIdleItemStyle->SetTextSizeInPixels( KSizeOfRadioIdleItemBigFont, ETrue );

	 // Create text styles for other radio idle items

    RArray<TInt> fontSizeArray;

    CleanupClosePushL( fontSizeArray );

    User::LeaveIfError( fontSizeArray.Append( KSizeOfRadioIdleItemMediumFont ) );

    User::LeaveIfError( fontSizeArray.Append( KSizeOfRadioIdleItemSmallFont ) );

    fontSizeArray.Sort();

	TInt numberOfTextStyles = fontSizeArray.Count();

	for( TInt i = 0; i < numberOfTextStyles; i++ )

		{

		TInt radioIdleItemTextStyleId = manager.CreatePlatformTextStyleL();

		radioIdleItemStyle = manager.TextStyle( radioIdleItemTextStyleId );

		radioIdleItemStyle->SetTextSizeInPixels( fontSizeArray[i], ETrue );

		iTextStyleIdArray.Append( radioIdleItemTextStyleId );

		}

	CleanupStack::PopAndDestroy( &fontSizeArray );

	aEnv.ControlGroup( aControlGroupId ).AppendL( this ); // Takes ownership.

			// No leaving code allowed after this call.

  	}

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

// ~CIRRadioIdle::~CIRRadioIdle

// Destructor

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

//

CIRRadioIdle::~CIRRadioIdle()

	{

	Env().CancelCustomCommands( this );

	if( iRadioIdleItemArray )

		{

		if( iRadioIdleItemArray->Count() > KZero )

			{

			iRadioIdleItemArray->Reset();

			}

		delete iRadioIdleItemArray;

		}

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

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

		{

		manager.DeleteTextStyle( iTextStyleIdArray[i] );

		}

	iTextStyleIdArray.Close();

	}

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

// CIRRadioIdle::AddRadioIdleL

// Creates the radio idle with passed number of radio idle items

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

//

void CIRRadioIdle::AddRadioIdleL( const TInt aNumberOfRadioIdleItems )

	{

	CAlfAnchorLayout* radioIdleAnchor = static_cast<CAlfAnchorLayout*>

								 ( FindTag( KRadioIdleAnchorTag ) );

	if ( !radioIdleAnchor )

		{

		radioIdleAnchor = CAlfAnchorLayout::AddNewL( *this, iParentLayout );

		radioIdleAnchor->SetTagL( KRadioIdleAnchorTag );

		}

	if( !iViewport )

		{

		iViewport = CAlfViewportLayout::AddNewL( *this, radioIdleAnchor );

		iViewport->SetViewportPos( TAlfRealPoint( .0f, .0f ), KZero );

		iViewport->SetViewportSize( TAlfRealSize( 1.0f, 1.0f ), KZero );

		}

	CreateBacgroundTextVisualL();

	// Create the flow layout for the other radio idle items

	CAlfFlowLayout* radioIdleFlowLayout = static_cast<CAlfFlowLayout*> 

		( iViewport->FindTag( KRadioIdleFlowLayoutTag ) );

	if( !radioIdleFlowLayout )

		{

		radioIdleFlowLayout = CAlfFlowLayout::AddNewL( *this, iViewport );

		radioIdleFlowLayout->SetTagL( KRadioIdleFlowLayoutTag );

		radioIdleFlowLayout->SetFlowDirection( CAlfFlowLayout::EFlowVertical );

		radioIdleFlowLayout->SetMode( CAlfFlowLayout::EModeCenterPerpendicular );

		}

	InitializeRadioIdleItemsL( aNumberOfRadioIdleItems );

	AnimateRadioIdleItems();

	UpdateLayout();

	RadioIdleFadeIn();

	}

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

// CRadioIdle::CreateBacgroundTextVisualL

// Creates, initializes and animates the radio idle background text visual

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

//

void CIRRadioIdle::CreateBacgroundTextVisualL()

	{

	HBufC* itemText = GetRandomRadioIdleContentL();

	CleanupStack::PushL( itemText );

    CAlfTextVisual* backgroundText = static_cast<CAlfTextVisual*> 

    	( iViewport->FindTag( KRadioIdleBackgroundTextTag ) );

	if( !backgroundText && itemText )

		{

		backgroundText = AddRadioIdleItemL(iViewport, *itemText,KRadioIdleBackgroundTextTag, EFalse,

                            KRadioIdleItemBackgroundColor,

                            KRadioIdleItemBackgroundOpacity );

		SetRadioIdleItemSettingsL( backgroundText, *itemText, iRadioIdleItemBackgroundTextStyleId );

        backgroundText->EnableBrushesL();

	    backgroundText->EnableShadow( EFalse );

	    backgroundText->SetFlag(  EAlfVisualFlagManualLayout  );

		SetScrollingToBackgroundText( backgroundText,

                           KRadioIdleBackgroundTextSideToSideTransitionDurationTime,

                           ERadioIdleBackgroundTextScrollEnd );

		backgroundText->SetOpacity( TAlfTimedValue( KRadioIdleBackgroundTextOpacity ) );

		}

	else if( itemText )

		{

		SetRadioIdleItemSettingsL( backgroundText, *itemText,

			 iRadioIdleItemBackgroundTextStyleId );

        SetScrollingToBackgroundText( backgroundText, 

        	KRadioIdleBackgroundTextSideToSideTransitionDurationTime, 

        	ERadioIdleBackgroundTextScrollEnd );

        backgroundText->SetOpacity( TAlfTimedValue( KRadioIdleBackgroundTextOpacity ) );

        }

	else

		{

		}	

	CleanupStack::PopAndDestroy( itemText );

	}

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

// CIRRadioIdle::InitializeRadioIdleItemsL

// Initializes the radio idle items

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

//

void CIRRadioIdle::InitializeRadioIdleItemsL( const TInt aNumberOfRadioIdleItems )

	{

	CAlfFlowLayout* radioIdleFlowLayout = static_cast<CAlfFlowLayout*> 

						( iViewport->FindTag( KRadioIdleFlowLayoutTag ) );

	if( radioIdleFlowLayout )

		{

		// Create the radio idle items

		for( TInt i = 0; i < aNumberOfRadioIdleItems; i++ )

			{

			HBufC* itemText = GetRandomRadioIdleContentL();

			if( itemText )

				{

				CleanupStack::PushL( itemText );

				TInt randFontStyleIx = AlfUtil::RandomInt( KZero,

				  iTextStyleIdArray.Count() - Kone );

			    CAlfTextVisual* radioIdleItem = NULL;

			    if( radioIdleFlowLayout->Count() < aNumberOfRadioIdleItems )

					{

                    radioIdleItem  = AddRadioIdleItemL( radioIdleFlowLayout,

                    	 *itemText, KRadioIdleItemTag,EFalse, 

                    	 KRadioIdleItemBackgroundColor, KRadioIdleItemBackgroundOpacity );

					}

			    else

			    	{

			    	/*lint -save -e826 (Info -- Suspicious pointer-to-pointer conversion (area too small)*/

			    	radioIdleItem = static_cast<CAlfTextVisual*> 

			    			( GetPointer( radioIdleFlowLayout->Visual( i ) ) );

			    	/*lint -restore*/

			    	radioIdleItem->SetOpacity( TAlfTimedValue( .0f ) );

					radioIdleItem->EnableTransformationL( ETrue );

					CAlfTransformation* radioIdleItemTransformation =

									 &( radioIdleItem->Transformation() );

					radioIdleItemTransformation->LoadIdentity();

			    	}

			    SetRadioIdleItemSettingsL( radioIdleItem, *itemText, 

			    		iTextStyleIdArray[ randFontStyleIx ] );

			 	CleanupStack::PopAndDestroy( itemText );

				}

			}

		}

	}

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

// CIRRadioIdle::AnimateRadioIdleItems

// Sets defined animation to the created radio idle items

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

//

void CIRRadioIdle::AnimateRadioIdleItems()

	{

	CAlfFlowLayout* radioIdleFlowLayout = static_cast<CAlfFlowLayout*> 

				( iViewport->FindTag( KRadioIdleFlowLayoutTag ) );

	if( radioIdleFlowLayout )

		{

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

			{

	    	/*lint -save -e826 (Info -- Suspicious pointer-to-pointer conversion (area too small)*/

		    CAlfTextVisual* radioIdleItem = static_cast<CAlfTextVisual*> 

		    	( GetPointer( radioIdleFlowLayout->Visual( i ) ) );

		    /*lint -restore*/

			 SetRadioIdleItemAnimation( radioIdleItem );

			}

		}

	}

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

// CIRRadioIdle::AddRadioIdleItemL

// Creates the radio idle item to the passed radio idle view port.

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

//

CAlfTextVisual* CIRRadioIdle::AddRadioIdleItemL( CAlfLayout* aRadioIdle, 

					const TDesC& aRadioIdleItemText, 

					const TDesC8& aTag, TBool aRadioIdleItemHasBackground,

					const TRgb& aBackgroundColor,

					const TReal32 aBackgroundOpacity )

	{

	CAlfTextVisual* radioIdleItem = CAlfTextVisual::AddNewL( *this, aRadioIdle );

	// Set text to transparent during initialization

	radioIdleItem->SetOpacity( TAlfTimedValue( .0f ) );

    radioIdleItem->EnableBrushesL();

    radioIdleItem->SetTextL( aRadioIdleItemText );

    radioIdleItem->SetTagL( aTag );

    radioIdleItem->EnableShadow( EFalse );

    radioIdleItem->SetAlign( EAlfAlignHCenter, EAlfAlignVCenter );

    radioIdleItem->SetSize( radioIdleItem->TextExtents() );

    if ( aRadioIdleItemHasBackground )

	    {

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

		gradientBrush->SetColor( aBackgroundColor, aBackgroundOpacity );

		radioIdleItem->Brushes()->AppendL( gradientBrush, EAlfHasOwnership );

		CleanupStack::Pop( gradientBrush );

	    }

	return radioIdleItem;

	}

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

// CIRRadioIdle::DeviateColorComponent

// Randomly modifies the value of a color component.

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

//

TInt CIRRadioIdle::DeviateColorComponent( TInt aBaseValue )

    {

    TInt deviatedValue = aBaseValue

                       + AlfUtil::RandomInt( 0, KMaxRadioIdleItemColorDeviation )

                       - AlfUtil::RandomInt( 0, KMaxRadioIdleItemColorDeviation );

    if( deviatedValue < 0)

        {

        deviatedValue = 0;

        }

    else if( deviatedValue > KTwoFiftyFive )

        {

        deviatedValue = KTwoFiftyFive;

        }

    return deviatedValue;

    }

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

// CIRRadioIdle::SetRadioIdleItemSettings

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

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

//

void CIRRadioIdle::SetRadioIdleItemSettingsL( CAlfTextVisual* aRadioIdleItem, 

											const TDesC& aRadioIdleItemText,

											  const TInt aTextStyleId )

	{

	// Set text of the radio idle item

	aRadioIdleItem->SetTextL( aRadioIdleItemText );

	// Set text to transparent during initialization

	aRadioIdleItem->SetOpacity( TAlfTimedValue( .0f ) );

	aRadioIdleItem->EnableTransformationL( ETrue );

	CAlfTransformation* radioIdleItemTransformation = &( aRadioIdleItem->Transformation() );

	radioIdleItemTransformation->LoadIdentity();

    // Select base color for text

    TRgb radioIdleItemColor( iRadioIdlePrimaryColor );

    if( AlfUtil::RandomInt(0, 1) == 0 )

        {

        radioIdleItemColor = iRadioIdleSecondaryColor;

        }

    // Modify the color

    radioIdleItemColor.SetRed( DeviateColorComponent( radioIdleItemColor.Red() ) );

    radioIdleItemColor.SetGreen( DeviateColorComponent( radioIdleItemColor.Green() ) );

    radioIdleItemColor.SetBlue( DeviateColorComponent( radioIdleItemColor.Blue() ) );

	// Set text color of the radio idle item

	aRadioIdleItem->SetColor( radioIdleItemColor );

	// Set text style of the radio idle	item

	aRadioIdleItem->SetTextStyle( aTextStyleId );

	TSize itemSize( 0, 0 );

	if ( aRadioIdleItem->TextExtents() != itemSize )

		{

		aRadioIdleItem->SetSize( aRadioIdleItem->TextExtents() );

		}

	}

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

// CIRRadioIdle::SetRadioIdleItemAnimation

// Sets translating animations to the radio idle item

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

//

void CIRRadioIdle::SetRadioIdleItemAnimation( CAlfTextVisual* aRadioIdleItem )

	{

	CAlfFlowLayout* radioIdleFlowLayout = static_cast<CAlfFlowLayout*> 

										( aRadioIdleItem->Layout() );

	TInt radioIdleItemCount = radioIdleFlowLayout->Count();

	TInt radioIdleItemIndex = radioIdleFlowLayout->FindVisual( aRadioIdleItem );

	TReal32 radioIdleItemWidth = aRadioIdleItem->DisplayRect().Width();

	TReal32 radioIdleItemHeight = aRadioIdleItem->DisplayRect().Height();

	TReal32 radioIdleWidth = radioIdleFlowLayout->Size().Target().iX;

	TInt randomTranslateDuration = AlfUtil::RandomInt( KMinRadioIdleItemScrollDurationTime,

									 KMaxRadioIdleItemScrollDurationTime );

	// Calculate y position of the radio idle item

	TReal32 randomMeanDeviationY = 0;

	if(radioIdleItemIndex != 0 && radioIdleItemIndex != radioIdleItemCount - Kone )

		{

		randomMeanDeviationY = AlfUtil::RandomReal( 0.0f,  radioIdleItemHeight * 

															KMaxRadioIdleItemsOverlap );

		TInt deviationDirection = AlfUtil::RandomInt( KZero,  Kone );

		if( deviationDirection )

		 	{

		 	randomMeanDeviationY = -randomMeanDeviationY;

		 	}

		}

	TInt scrollDirection = AlfUtil::RandomInt( KZero,  Kone );

	TAlfTimedValue targetPositionX;

	if( scrollDirection )

		{

		targetPositionX.SetValueNow( -radioIdleWidth/2 - radioIdleItemWidth/2 );

		targetPositionX.SetTarget( radioIdleWidth/2 + radioIdleItemWidth/2,

								 randomTranslateDuration );

		}

	else

		{

		targetPositionX.SetValueNow( radioIdleWidth/2 + radioIdleItemWidth/2  );

		targetPositionX.SetTarget( -radioIdleWidth/2 - radioIdleItemWidth/2,

													 randomTranslateDuration );

		}

	Translate( aRadioIdleItem, targetPositionX, TAlfTimedValue( randomMeanDeviationY ) );

	if( radioIdleItemIndex >= KZero )

		{

		Env().Send( TAlfCustomEventCommand( ERadioIdleItemTransformationEnd,

											this,

											radioIdleItemIndex ),

											randomTranslateDuration );

		}

	// Set text opacity of the radio idle item

	TReal32 randomOpacity = AlfUtil::RandomReal( KMinOpacity, KMaxOpacity );

	aRadioIdleItem->SetOpacity( TAlfTimedValue( randomOpacity ) );

	radioIdleFlowLayout->UpdateChildrenLayout( KMinRadioIdleItemScrollDurationTime );

	}

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

// CIRRadioIdle::RadioIdleFadeIn

// Fades in radio idle

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

//

void CIRRadioIdle::RadioIdleFadeIn( TBool aNow )

	{

	if ( iViewport )

		{

		if( aNow )

			{

			FadeIn( iViewport, KZero );

			}

		else

			{

			FadeIn( iViewport, KRadioIdleFadeInDurationTime );

			}

		}