/*

* Copyright (c) 2005 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:  Implementation of the class CFMRadioChannelListContainer

*

*/

// INCLUDE FILES

#include <e32math.h>

#include <AknsSkinInstance.h>

#include <AknsUtils.h>

#include <AknsDrawUtils.h>

#include <AknsBasicBackgroundControlContext.h>

#include <gulutil.h> 

#include <w32std.h>

#include <fmradio.rsg>

#if defined __SERIES60_HELP || defined FF_S60_HELPS_IN_USE

#include "radio.hlp.hrh"

#endif

#include <StringLoader.h>

#include <eiklabel.h>

#include <AknIconArray.h>

#include <gulicon.h>

#include <fmradiouids.h>

#include <aknconsts.h>

#include <avkon.mbg>

#include "fmradioappui.h"

#include "fmradiochannellistcontainer.h"

#include "fmradiochannellistview.h"

// CONSTANTS

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

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

// CFMRadioChannelListContainer::CFMRadioChannelListContainer

// Default constructor

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

//

CFMRadioChannelListContainer::CFMRadioChannelListContainer( 

	CRadioEngine& aRadioEngine,

	MChannelListHandler& aObserver ) :

	iRadioEngine( aRadioEngine ),

	iObserver( aObserver )

	{	

	}

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

// CFMRadioChannelListContainer::NewL

// Two-phase constructor of CFMRadioChannelListContainer

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

//

CFMRadioChannelListContainer* CFMRadioChannelListContainer::NewL( const TRect& aRect, 

		CRadioEngine& aRadioEngine, MChannelListHandler& aObserver  )

    {

    CFMRadioChannelListContainer* self = new (ELeave) CFMRadioChannelListContainer( aRadioEngine,

    		aObserver );

    CleanupStack::PushL( self );

    self->ConstructL( aRect );

    CleanupStack::Pop( self );

    return self;

    }

//

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

// CFMRadioChannelListContainer::ConstructL

// EPOC two phased constructor

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

//

void CFMRadioChannelListContainer::ConstructL( const TRect& aRect )

    {

    CreateWindowL();

    // Instantiate a listbox for the channel list

    iChannelList = new ( ELeave ) CAknDoubleNumberStyleListBox();

    iControls.Append( iChannelList );

    iChannelList->SetContainerWindowL( *this );

    iChannelList->SetListBoxObserver( this );

    iChannelList->ConstructL( this, CEikListBox::ELoopScrolling | EAknListBoxSelectionList ); // Looped list

    iChannelList->SetRect( aRect ); // Set boundaries for listbox

    // Create scrollbars

    iChannelList->CreateScrollBarFrameL( ETrue );

    iChannelList->ScrollBarFrame()->SetScrollBarVisibilityL( CEikScrollBarFrame::EOff, CEikScrollBarFrame::EAuto );

    HBufC* emptyString = NULL;

    emptyString = StringLoader::LoadLC( R_QTN_FMRADIO_LIST_NO_STATIONS, iEikonEnv );

    iChannelList->View()->SetListEmptyTextL( *emptyString );

    CleanupStack::PopAndDestroy( emptyString );

    CAknIconArray* listIconArray = new ( ELeave ) CAknIconArray( 2 );

    CleanupStack::PushL( listIconArray );

    CreateListIconsL( *listIconArray );

    iChannelList->ItemDrawer()->FormattedCellData()->SetIconArrayL( listIconArray );

    CleanupStack::Pop( listIconArray );

    // Array for channels

    iChannelItemArray = new( ELeave ) CDesCArrayFlat( KMaxNumberOfChannelListItems );

    InitializeChannelListL();

    SetRect( aRect );             // Set its rectangle

    CFMRadioAppUi* appUi = static_cast<CFMRadioAppUi*>( iCoeEnv->AppUi() );

    iChannelView = static_cast<CFMRadioChannelListView*> ( appUi->View( KFMRadioChannelListViewId ) );

    ActivateL();

    }

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

// CFMRadioChannelListContainer::~CFMRadioChannelListContainer

// Class destructor

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

//

CFMRadioChannelListContainer::~CFMRadioChannelListContainer()

    {

    iControls.ResetAndDestroy();

    iControls.Close();

    iBitMaps.ResetAndDestroy();

    iBitMaps.Close();

    delete iChannelItemArray;

    }

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

// CFMRadioChannelListContainer::CreateListIconsL

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

//

void CFMRadioChannelListContainer::CreateListIconsL( CArrayPtr<CGulIcon>& aArray )

    {

    if ( iBitMaps.Count() )

        {

        // release any previously created bitmaps

        iBitMaps.ResetAndDestroy();

        }

    TRgb defaultColor = iEikonEnv->Color( EColorControlText );

    MAknsSkinInstance* skinInstance = AknsUtils::SkinInstance();

    // speaker icon

    CFbsBitmap* playingIconBitmap = NULL;

    CFbsBitmap* playingIconBitmapMask = NULL;

    AknsUtils::CreateColorIconLC( skinInstance,

                KAknsIIDQgnIndiSpeaker,

                KAknsIIDQsnIconColors,

                EAknsCIQsnIconColorsCG13,

                playingIconBitmap,

                playingIconBitmapMask,

                KAvkonBitmapFile,

                EMbmAvkonQgn_indi_speaker,

                EMbmAvkonQgn_indi_speaker_mask,

                defaultColor

                );

    iBitMaps.AppendL( playingIconBitmap );

    iBitMaps.AppendL( playingIconBitmapMask );

    CleanupStack::Pop( 2 ); // playingIconBitmap, playingIconBitmapMask

    CGulIcon* playingIcon = CGulIcon::NewLC();

    playingIcon->SetBitmapsOwnedExternally( ETrue );

    playingIcon->SetBitmap( playingIconBitmap );

    playingIcon->SetMask( playingIconBitmap );

    aArray.AppendL( playingIcon );

    CleanupStack::Pop( playingIcon );

    // marked icon

    CFbsBitmap* markedIconBitmap = NULL;

    CFbsBitmap* markedIconBitmapMask = NULL;

    AknsUtils::CreateColorIconLC( skinInstance,

                KAknsIIDQgnIndiMarkedAdd,

                KAknsIIDQsnIconColors,

                EAknsCIQsnIconColorsCG13,

                markedIconBitmap,

                markedIconBitmapMask,

                KAvkonBitmapFile,

                EMbmAvkonQgn_indi_marked_add,

                EMbmAvkonQgn_indi_marked_add_mask,

                defaultColor

                );    

    iBitMaps.AppendL( markedIconBitmap );

    iBitMaps.AppendL( markedIconBitmapMask );

    CleanupStack::Pop( 2 ); // markedIconBitmap, markedIconBitmapMask

    CGulIcon* markedIcon = CGulIcon::NewLC();

    markedIcon->SetBitmapsOwnedExternally( ETrue );

    markedIcon->SetBitmap( markedIconBitmap );

    markedIcon->SetMask( markedIconBitmapMask );

    aArray.AppendL( markedIcon );

    CleanupStack::Pop( markedIcon );

    }

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

// CFMRadioChannelListContainer::InitializeChannelListL

// Create the channel list (initially all spots are set as empty)

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

//

void CFMRadioChannelListContainer::InitializeChannelListL()

	{

    TBuf<KLengthOfChannelItemString> textChannelItem;

    textChannelItem.SetLength( 0 );

    // Pass the array to the listbox model and set the ownership type

    iChannelList->Model()->SetItemTextArray( (MDesCArray*)iChannelItemArray );

    iChannelList->Model()->SetOwnershipType( ELbmDoesNotOwnItemArray );

    iChannelList->HandleItemAdditionL();

	DrawDeferred();

	}

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

// CFMRadioChannelListContainer::UpdateChannelListContentL

// Update the content of the channel at aIndex with the

// values specified

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

//

    TBuf<KLengthOfChannelItemString> textChannelItem;

    TBuf<KLengthOfChIndexStringChList> textChIndex;

    TBuf<KLengthOfChannelItemIconIndexString> textChIconIndex;

    textChIndex.Format( KChIndexFormatChList, aIndex+1 ); // One over index

    textChIconIndex.Format( KChIconIndexFormatChList, KNowPlayingIconIndexChList );

    textChannelItem.Append( textChIndex );

    textChannelItem.Append( KColumnListSeparator );

    textChannelItem.Append( aChannelName );

    textChannelItem.Append( KColumnListSeparator );

    if ( aChannelFrequency )

    // Set 'Now Playing' icon to the channel item

    textChannelItem.Append( KColumnListSeparator );

    if ( iRadioEngine.GetPresetIndex() == aIndex )

        textChannelItem.Append( textChIconIndex );

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

// CFMRadioChannelListContainer::RemoveChannelL

// Removes channel from container list

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

//

void CFMRadioChannelListContainer::RemoveChannelL( TInt aIndex )

	{

	if ( iChannelItemArray->Count() > 0 )

		{

		TInt presetIndex = iRadioEngine.GetPresetIndex();

		iChannelItemArray->Delete( aIndex );

		iChannelList->HandleItemRemovalL();

		iChannelList->UpdateScrollBarsL();

		iChannelList->DrawDeferred();

		if ( iChannelItemArray->Count() > 0 )

			{

			ReIndexAllL();

			if ( presetIndex > aIndex )			    

			    {

			    // update engine settings also

			    iRadioEngine.SetCurrentPresetIndex( presetIndex - 1 );

                UpdateItemIconL( presetIndex - 1, KNowPlayingIconIndexChList );

                }

			else if ( presetIndex == aIndex  )

                {

                iRadioEngine.TunePresetL( 0 );	

                UpdateItemIconL( 0, KNowPlayingIconIndexChList );

                }

			else

			    {

			    // NOP

			    }               

            iChannelList->SetCurrentItemIndex( 0 );

			}

		else

		    {

		    // The last item was deleted, tune to current frequency, out of preset mode

		    iRadioEngine.Tune( iRadioEngine.GetTunedFrequency(), CRadioEngine::ERadioTunerMode );

		    }

		}

	}

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

// CFMRadioChannelListContainer::AddChannel

// Adds channels to container list

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

//

void CFMRadioChannelListContainer::AddChannelL( 

			const TDesC& aChannelName, TInt aChannelFrequency, TBool aNowPlaying  )

	{

	TBuf<KLengthOfChannelItemString> textChannelItem;

	TBuf<KLengthOfChIndexStringChList> textChIndex;

	TBuf<KLengthOfChannelItemIconIndexString> textChIconIndex;

	textChIndex.Format( KChIndexFormatChList, iChannelItemArray->Count()+1 ); // One over index

   	if ( !AknLayoutUtils::PenEnabled() )

		{

    	textChIconIndex.Format( KChIconIndexFormatChList, KNowPlayingIconIndexChList ) ;

		}    

	//Update to display Devnagari numbers for Text Index.

	AknTextUtils::LanguageSpecificNumberConversion(textChIndex);

	//

	textChannelItem.Append( textChIndex );

	textChannelItem.Append( KColumnListSeparator );

    TReal frequency = static_cast<TReal>( aChannelFrequency / static_cast<TReal>( KHzConversionFactor ));

    // Gets locale decimal separator automatically

    TRealFormat format(KFrequencyMaxLength, iRadioEngine.DecimalCount() );

    TBuf<30> frequencyString;

    frequencyString.Num(frequency,format);	

	TBool channelHasName = EFalse;

	TInt resId = 0;

	// if name exists, place it on the first line

	if ( aChannelName.Length() > 0 )

	    {

	    textChannelItem.Append( aChannelName );

	    textChannelItem.Append( KColumnListSeparator );

	    channelHasName = ETrue;

	    resId = R_QTN_FMRADIO_DOUBLE2_FREQ;

	    }

	else // frequency goes to first line

	    {

	    resId = R_QTN_FMRADIO_DOUBLE1_FREQ;

	    }

	HBufC* stringHolder = StringLoader::LoadLC( resId, frequencyString, iEikonEnv );    

    //Update for display of Hindi Devnagari Numbers

    TPtr textItem2 = stringHolder->Des();

    AknTextUtils::LanguageSpecificNumberConversion(textItem2);

    textChannelItem.Append( textItem2 );

    CleanupStack::PopAndDestroy( stringHolder );

    if ( !channelHasName )

        {

        // add placeholder for second line

        textChannelItem.Append( KColumnListSeparator ); 

        }

	// Set 'Now Playing' icon to the channel item

    textChannelItem.Append( KColumnListSeparator );

	if( !AknLayoutUtils::PenEnabled() && aNowPlaying )

	    {	    

		textChannelItem.Append( textChIconIndex );	

	    }

	iChannelItemArray->AppendL(  textChannelItem );

	iChannelList->HandleItemAdditionL(); // Update list

	iChannelList->UpdateScrollBarsL();

	iChannelList->DrawDeferred();

	}

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

// CFMRadioChannelListContainer::UpdateItemIconL

// Adds icon to a list item

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

//

void CFMRadioChannelListContainer::UpdateItemIconL( TInt aIndex, TInt aIconIndex )

    {

    HideIconsL();

    if ( aIndex >= 0 && aIndex < iChannelItemArray->Count() ) 

        {

        TBuf<KLengthOfChannelItemIconIndexString> textChIconIndex;

        textChIconIndex.Format( KChIconIndexFormatChList, aIconIndex );

        HBufC* channelItem = HBufC::NewLC( KLengthOfChannelItemString );

        channelItem->Des().Copy( iChannelItemArray->MdcaPoint( aIndex ) );

        TPtr ptr( channelItem->Des() );

        ptr.Append( textChIconIndex ); // Add icon index

        iChannelItemArray->Delete( aIndex );

        iChannelItemArray->InsertL( aIndex, *channelItem );

        CleanupStack::PopAndDestroy( channelItem );

        }

    // use draw now so that view is up to date during fast channel switching

    iChannelList->DrawNow();

    }

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

// CFMRadioChannelListContainer::HideIconsL

// hide all icons from the list

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

//

void CFMRadioChannelListContainer::HideIconsL()

    {

    for ( TInt index = 0 ; index < iChannelItemArray->Count(); index++ ) 

        {

        HBufC* channelItem = HBufC::NewLC( KLengthOfChannelItemString );

        channelItem->Des().Copy( iChannelItemArray->MdcaPoint( index ) );

        TPtr ptr( channelItem->Des() );	

        TBuf<KLengthOfChannelItemIconIndexString> textChIconIndex;

        TPtrC iconIndexPtr( textChIconIndex );

        TInt err = TextUtils::ColumnText( iconIndexPtr, 3, &ptr );

        if ( iconIndexPtr.Length() > 0 )

            {

            ptr.Delete( ptr.Length() - iconIndexPtr.Length(), iconIndexPtr.Length() ); // Remove icon index		

            iChannelItemArray->Delete( index );

            iChannelItemArray->InsertL( index, *channelItem );

            }

        CleanupStack::PopAndDestroy( channelItem );

        }

    }

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

// CFMRadioChannelListContainer::SetFaded

// Fades the entire window and controls in the window owned

// by this container control.

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

//

void CFMRadioChannelListContainer::SetFaded( TBool aFaded )

	{

    iFadeStatus = aFaded;

    Window().SetFaded( aFaded, RWindowTreeNode::EFadeIncludeChildren );

	}

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

// CFMRadioChannelListContainer::UpdateLastListenedChannel

// Updates channel index - the highlighted channel in the list.

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

//

void CFMRadioChannelListContainer::UpdateLastListenedChannel( TInt aIndex )

	{

    iLastChIndex = aIndex;

	iChannelList->SetCurrentItemIndex( iLastChIndex );

	iChannelList->ScrollToMakeItemVisible( iLastChIndex );

	iChannelList->DrawDeferred();

	}

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

// CFMRadioChannelListContainer::CurrentlySelectedChannel

// Returns the index of the selected channel item from the

// channel list.

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

//

TInt CFMRadioChannelListContainer::CurrentlySelectedChannel() const

	{

    return iChannelList->CurrentItemIndex(); // Index of selected channel

	}

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

// CFMRadioChannelListContainer::HandleListBoxEventL

// For handling listbox-, in this case, channel list events.

// The event equals to selecting a channel item from the list.

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

//

void CFMRadioChannelListContainer::HandleListBoxEventL( CEikListBox* /*aListBox*/,

                                                      TListBoxEvent aEventType )

    {

    // Check the event generated by keypress and report the event,

    // Also check for Pen Enabled touch screen event

    switch ( aEventType )

        {

        case EEventEnterKeyPressed:

            {

            ReportEventL( MCoeControlObserver::EEventStateChanged );

            break;

            }

        case EEventItemSingleClicked:

            {

            if ( iMoveAction )

                {

                TouchMoveEventL( CurrentlySelectedChannel() ); 

                }

            else

                {

                ReportEventL( MCoeControlObserver::EEventStateChanged );

                }

            break;

            }

        default:

            {

            break;