/*

* Copyright (c) 2002-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: 

*    Defines CSatUiView class

*

*

*/

// INCLUDE FILES

#include    <coecntrl.h> //for CCoeControl class

#include    <akntitle.h>

#include    <eikmenup.h>

#include    <barsread.h>

#include    <badesca.h> // for descriptor arrays

#include    <aknlists.h>

#include    <eiktxlbx.h>

#include	<akncontext.h>	//for Context pane

#include	<fbs.h>			//for iocn bitmap

#include    <StringLoader.h>

#include    <avkon.hrh>

#include    "satui.hrh"

#include    <SatUi.rsg>

#include    <AknIconArray.h> 

#include    <gulicon.h>

#include    <eikclbd.h>

#include    <msatuiadapter.h>

#include    <aknnotedialog.h>

#include    <aknstaticnotedialog.h>

#include    <featmgr.h> // Used for FeatureManager

#include    <activitymanager.h>

#include    "CSatUiApplication.h"

#include    "CSatUiViewAppUi.h"

#include    "CSatUiViewContainer.h"

#include    "CSatUiView.h"

#include    "tflogger.h"

// CONSTANTS

// From Ui spec 60 sec delay user response

const TInt KNoResponseFromUserDelay = 60;

_LIT( KTab, "\t" );

_LIT( KIconTab, "%d\t" );

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

// C++ default constructor can NOT contain any code, that

// might leave.

//

CSatUiView::CSatUiView( TBool aSetUpMenu, CSatUiViewAppUi* aAppUi, 

                        TBool aEmpty ):

    iSetUpMenu( aSetUpMenu ),

    iSatUiAppUi( aAppUi ),

	iModel( NULL ),

    iIconsOn( EFalse ),

    iIconStateChange( EFalse ),

    iSelfExplanatoryItems( EFalse ),

    iListBoxVisible( ETrue ),

    iEmpty( aEmpty )

    {

    }

// Symbian OS default constructor can leave.

void CSatUiView::ConstructL()

    {

	TFLOGSTRING( "CSatUiView::ConstructL() called" )

	TInt recource( R_SATUI_SELECTITEM_VIEW );

    if ( iSetUpMenu )

        {

        if ( iEmpty )

            {

            recource = R_SATUI_EMPTYMENU_VIEW;

            }

        else

            {

            recource = R_SATUI_SETUPMENU_VIEW;

            }

        }

    BaseConstructL( recource );

    iItemsIconArray = new(ELeave) CAknIconArray( 1 );

	TFLOGSTRING( "CSatUiView::ConstructL() exit" )

    }

// Two-phased constructor.

CSatUiView* CSatUiView::NewL( TBool aSetUpMenu, 

                              CSatUiViewAppUi* aAppUi, 

                              TBool aEmpty )

    {

	TFLOGSTRING( "CSatUiView::NewL called" )

    CSatUiView* self = new ( ELeave ) CSatUiView( aSetUpMenu, aAppUi, aEmpty );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

	TFLOGSTRING( "CSatUiView::NewL exit" )

    return self;

    }

// Destructor.

CSatUiView::~CSatUiView()

    {

	TFLOGSTRING( "CSatUiView::~CSatUiView() called" )

    delete iContainer;

    delete iMenuItemNextActions;

    delete iMenuItems;

    if ( iItemsIconArray )

        {

        iItemsIconArray->ResetAndDestroy();

        delete iItemsIconArray;

        iItemsIconArray = NULL;

        }

	TFLOGSTRING( "CSatUiView::~CSatUiView() exit" )

    }

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

// CSatUiView::SetTitle

// Sets the title needed for showing the view.

// (other items were commented in a header).

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

//

void CSatUiView::SetTitle( const HBufC* aTitle )

    {

    TFLOGSTRING( "CSatUiView::SetTitle called" )

    iTitle = aTitle;

    TFLOGSTRING( "CSatUiView::SetTitle exit" )

    }

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

// CSatUiView::SetIconL

// Sets the icon needed to the view.

// (other items were commented in a header).

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

//

void CSatUiView::SetIconL( const CFbsBitmap* aIconBitmap )

	{

    TFLOGSTRING( "CSatUiView::SetIconL called" )

	if ( StatusPane()->PaneCapabilities( TUid::Uid(

        EEikStatusPaneUidContext ) ).IsPresent() )

		{

		TFLOGSTRING( "CSatUiView::SetIconL pane is present" )

        CEikStatusPane* sp=iEikonEnv->AppUiFactory()->StatusPane();

        CleanupStack::PushL( sp );

		CAknContextPane* contextPane=( CAknContextPane * )sp->

            ControlL( TUid::Uid( EEikStatusPaneUidContext ) );

		CleanupStack::Pop( sp );    //sp

        if ( aIconBitmap )      //icon from SIM

            {

            TFLOGSTRING( "CSatUiView::SetIconL icon from SIM" )

            contextPane->SetPicture( aIconBitmap );

            }

        else                    //set default icon

            {

            TFLOGSTRING( "CSatUiView::SetIconL default icon" )

            contextPane->SetPictureToDefaultL();

            }

		}

	TFLOGSTRING( "CSatUiView::SetIconL exit" )

	}

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

// CSatUiView::SetItemsIconL

// Sets the items icon array.

// (other items were commented in a header).

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

//

void CSatUiView::SetItemsIconL( 

    const CAknIconArray* aItemsIconArray, 

    const TBool aSelfExplanatoryItems )

    {

    TFLOGSTRING( "CSatUiView::SetItemsIconL called" )

    iItemsIconArray->ResetAndDestroy();

    //if items icon array available

    if ( aItemsIconArray->Count() )

        {

        TFLOGSTRING( "CSatUiView::SetItemsIconL icon array available" )

        if( !iIconsOn )

            {

            //last view not with icons

            iIconStateChange = ETrue;

            }

        iItemsIconArray->InsertL( 0, &aItemsIconArray->operator[]( 0 ), 

            aItemsIconArray->Count() );

        iIconsOn = ETrue;

        iSelfExplanatoryItems = aSelfExplanatoryItems;

        }

    else

        {

        TFLOGSTRING( "CSatUiView::SetItemsIconL icon array not available" )

        if( iIconsOn )

            {

            TFLOGSTRING( "CSatUiView::SetItemsIconL iIconsOn true" )

            iIconStateChange = ETrue;

            }

        else

            {

            TFLOGSTRING( "CSatUiView::SetItemsIconL iIconsOn false" )

            iIconStateChange = EFalse;

            }

        iIconsOn = EFalse;

        iSelfExplanatoryItems = EFalse;

        }

    TFLOGSTRING( "CSatUiView::SetItemsIconL exit" )

    }

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

// CSatUiView::SetItemsL

// Sets all parameters needed for showing the view.

// (other items were commented in a header).

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

//

TSatUiResponse CSatUiView::SetItemsL(

    HBufC* aTitle,

    const MDesCArray& aMenuItems,

    const CArrayFixFlat<TSatAction>* aMenuItemNextActions,

    const TBool aHelpIsAvailable )

    {

	TFLOGSTRING( "CSatUiView::SetItemsL called" )

    iKeypadBlocked = EFalse;

    delete iMenuItemNextActions;

    iMenuItemNextActions = NULL;

    if( !iMenuItems )

		{

		iMenuItems = new ( ELeave ) CDesCArrayFlat( 1 );

		}

	// This reset is required

	iMenuItems->Reset();

    // Remove NULL characters from title

    TPtr titleptr = aTitle->Des();

    TInt nullLocation;

    while ( ( nullLocation = titleptr.Locate( NULL ) ) >= 0 )

        {

        titleptr.Delete( nullLocation, 1 );

        }

    iTitle = aTitle;

    //no memory is allocated to the array buffers here:

    iMenuItemNextActions = new ( ELeave ) CArrayFixFlat<TSatAction>( 1 );

    iNItems = aMenuItems.MdcaCount();

    TBool nextActions( EFalse );

    TFLOGSTRING2( "CSatUiView::SetItemsL, iNItems: %d", iNItems )

    if ( iNItems == ( aMenuItemNextActions->Count() ) )

        {

        nextActions = ETrue;

        }

    if (iNItems > 0)

        {

        for ( TInt i(0); i < iNItems; i++ )

            {

            TInt itemLength = aMenuItems.MdcaPoint(i).Length();

            HBufC* tmpBuf = HBufC::NewLC(

                aMenuItems.MdcaPoint(i).Length() + KTabLength );

            TPtr tmpPtr( tmpBuf->Des() );

            // Item text

            TPtrC16 text ( aMenuItems.MdcaPoint(i) );

            // Needed for NULL check

            HBufC* correctText = HBufC::NewLC( itemLength );

            TPtr ptr = correctText->Des();

            // Check item text through

            for ( TInt j(0); j < itemLength; j++)

                {

                TChar ch = text[j];

                // Remove NULL characters from item text

                if ( ch )

                    {

                    ptr.Append( ch ); 

                    }

                }

            //if view includes icons

            if( iIconsOn )

                {

                TFLOGSTRING( "CSatUiView::SetItemsL iIconsOn true" )

                //with icons

                TBuf<KTabLength> lineTab;

                lineTab.Format( KIconTab,i );

                tmpPtr.Copy( lineTab );

                }

            else

                {

                TFLOGSTRING( "CSatUiView::SetItemsL iIconsOn false" )

                //without icons

                tmpPtr.Copy( KTab );

                }

            if( !iSelfExplanatoryItems )

                {

                //icons not selfexplanatory show text

                tmpPtr.Append( ptr );

                }

            //memory is allocated here:

            TRAPD( err, iMenuItems->AppendL(tmpPtr) );

            if ( err )

                {

                iMenuItems->Reset();

                iMenuItemNextActions->Reset();

                CleanupStack::PopAndDestroy( correctText );

                CleanupStack::PopAndDestroy( tmpBuf ); //tmpBuf, correctText

                TFLOGSTRING( "CSatUiView::SetItemsL having error" )

                return ESatFailure;

                }

            TFLOGSTRING2( "CSatUiView::SetItemsL tmpPtr=%S", &tmpPtr )

            CleanupStack::PopAndDestroy( correctText );

            CleanupStack::PopAndDestroy( tmpBuf ); //tmpBuf, correctText

            //select options menu command

            if ( nextActions )

                {

                TRAP( err, iMenuItemNextActions->AppendL(

                    aMenuItemNextActions->At( i ) ) );

                if ( err )

                    {

                    iMenuItems->Reset();

                    iMenuItemNextActions->Reset();

    				TFLOGSTRING( "CSatUiView::SetItemsL return ESatFailure" )

                    return ESatFailure;

                    }

                }

            }

        }

    iHelpIsAvailable = aHelpIsAvailable;

	TFLOGSTRING( "CSatUiView::SetItemsL return ESatSuccess" )

    return ESatSuccess;

    }

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

// CSatUiView::SetUpMenuL

// Checks whether the same view should be refreshed or another

// one activated and do it.

// (other items were commented in a header).

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

//

TSatUiResponse CSatUiView::SetUpMenuL(

    HBufC* aTitle,

    const MDesCArray& aMenuItems,

    const CArrayFixFlat<TSatAction>* aMenuItemNextActions,

    const TBool aHelpIsAvailable )

    {

	TFLOGSTRING( "CSatUiView::SetUpMenuL called" )

    iDefaultItem = 0; //could be iSelection

    CSatUiView* setUpMenuView = STATIC_CAST( CSatUiView*,

        AppUi()->View( KSetUpMenuViewId ) );

    TVwsViewId setUpMenuViewId( KUidSATUI, KSetUpMenuViewId );

    TVwsViewId viewId;

    AppUi()->GetActiveViewId( viewId );

    setUpMenuView->SetItemsL( aTitle, aMenuItems, aMenuItemNextActions,

        aHelpIsAvailable );

    // Incase empty view is created before the actual SetUpMenu view

    // CBA resource has to be updated

    if ( iEmpty )

        {

        TFLOGSTRING( "CSatUiView::SetUpMenuL empty view" )

        iEmpty = EFalse;

        CEikButtonGroupContainer* cba = Cba();

        if ( cba )

            {

            TFLOGSTRING( "CSatUiView::SetUpMenuL cba" )

            cba->SetCommandSetL( R_AVKON_SOFTKEYS_OPTIONS_EXIT );

            cba->DrawDeferred();

            }

        }

    if ( viewId.iAppUid == setUpMenuViewId.iAppUid )

        {        

        TFLOGSTRING( "CSatUiView::SetUpMenuL activate SetUpMenuView" )        

        //Activate SetUpMenuView

        AppUi()->ActivateLocalViewL( KSetUpMenuViewId );

        if ( iContainer )

            {

            RefreshL();

            }

        }

	TFLOGSTRING( "CSatUiView::SetUpMenuL return ESatSuccess" )

    return ESatSuccess;

    }

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

// CSatUiView::SetAdapter

// Sets a pointer to MSatUiAdapter provided by SatCli.

// (other items were commented in a header).

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

//

void CSatUiView::SetAdapter( MSatUiAdapter* aAdapter )

    {

    TFLOGSTRING( "CSatUiView::SetAdapter called" )

    iAdapter = aAdapter;

    TFLOGSTRING( "CSatUiView::SetAdapter exit" )

    }

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

// CSatUiSelectItemView::SelectItemL

// Checks whether the same view should be refreshed or another

// one activated and do it.

// (other items were commented in a header).

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

//

TSatUiResponse CSatUiView::SelectItemL(

    HBufC* aTitle,

    const MDesCArray& aMenuItems,

    const CArrayFixFlat<TSatAction>* aMenuItemNextActions,

    const TInt aDefaultItem, TUint8& aSelection,

    const TBool aHelpIsAvailable )

    {

	TFLOGSTRING( "CSatUiView::SelectItemL called" )

    iDefaultItem = aDefaultItem;

    TFLOGSTRING2( "CSatUiView::SelectItemL in aDefaultItem = %d", aDefaultItem )

    CSatUiView* selectItemView = STATIC_CAST( CSatUiView*,

        AppUi()->View( KSelectItemViewId ) );

    TVwsViewId selectItemViewId( KUidSATUI,KSelectItemViewId );

    TVwsViewId viewId;

    AppUi()->GetActiveViewId( viewId );

    selectItemView->SetItemsL( aTitle, aMenuItems, aMenuItemNextActions,

        aHelpIsAvailable);

    if ( viewId.iAppUid == selectItemViewId.iAppUid )

        {        

        TFLOGSTRING( "CSatUiView::SelectItemL activate SelectItemview" )        

        //Activate SelectItemview

        AppUi()->ActivateLocalViewL( KSelectItemViewId );

        if ( iContainer )

            {

            RefreshL();

            }

        }

    iResponse = ESatSuccess;

    iNoResponseFromUserAfterDelay = EFalse;

    //activitymanager for wait user actions

    CUserActivityManager* activityManager = 

        CUserActivityManager::NewL( EPriorityNormal );

    CleanupStack::PushL( activityManager );

	User::ResetInactivityTime();

    activityManager->Start( TTimeIntervalSeconds( KNoResponseFromUserDelay ), 

        TCallBack( DispatchUserInactive, this ), 0 );

    if ( !iWait.IsStarted() )

        {

        TFLOGSTRING( "CSatUiView::SelectItemL start iWait" )

        iSatUiAppUi->DispatchTimer( iWait );

        iWait.Start();

        }

    CleanupStack::PopAndDestroy( activityManager ); // activityManager

    if ( iNoResponseFromUserAfterDelay )

        {

        iResponse = ESatNoResponseFromUser;

        }

    aSelection= STATIC_CAST(TUint8,iSelection);

    TFLOGSTRING2( "CSatUiView::SelectItemL out aDefaultItem = %d", aDefaultItem )

	TFLOGSTRING2( "CSatUiView::SelectItemL exit, return: %d", iResponse )

    return iResponse;

    }

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

// CSatUiView::Id

// Returns the id of the view.

// (other items were commented in a header).

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

//

TUid CSatUiView::Id() const

    {

	TFLOGSTRING( "CSatUiView::Id() called" )

    //this should be an UID.

    if ( iSetUpMenu )

        {

        TFLOGSTRING( "CSatUiView::Id() setupmenu-exit" )

        return KSetUpMenuViewId;

        }

    else

        {

        TFLOGSTRING( "CSatUiView::Id() selectitem-exit" )

        return KSelectItemViewId;

        }

    }

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

// CSatUiView::HandleCommandL

// Called by the UI framework when a command has been issued.

// A command can originate by pressing a softkey or