/*

* Copyright (c) 2006 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:  Container class for vcommand app

*

*/

// INCLUDE FILES

#include <StringLoader.h> 

#include <avkon.hrh>

#include <aknlists.h>

#include <eikclbd.h>

#include <aknkeys.h>

#include <fbs.h>

#include <eiklbd.h>

#include <eiklbx.h>

#include <eikclbd.h>

#include <eiklbi.h>

#include <aknlists.h> 

#include <aknPopup.h>

#include <akntitle.h>

#include <eikspane.h>

#include <aknlistquerydialog.h>

#include <sysutil.h>

#include <apgcli.h>

#include <featmgr.h>

#include <AknsUtils.h>

#include <s32strm.h>

#include <f32file.h>

#include <s32file.h>

#include <AknUtils.h>

#include <apgcli.h>

#include <collate.h>

#include <vcommand.rsg>

#include <vcommand.mbg>

#include "vcgenericcontainer.h"

#include "vcgenericview.h"

#include "vcommanduientry.h"

#include "uiarraysgenerator.h"

#include "vctextquerydialog.h"

#include "vcdoublelargestylelistbox.h"

#include "vcommand.hrh"

#include "vcappui.h"

#include "rubydebug.h"

// CONSTANTS

const TChar KTabulator = '\t';

const TInt KArrayGranularity( 12 );

// Show tooltip for four seconds

const TInt KPopupVisibilityTime = 4000;

_LIT( KLocReplace, "%U" );

// Bytes that should be free in the disk drive in addition to critical level 

// before voice command editing is allowed (10k)

const TInt KEditDiskUsage = 10240;

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

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

// C++ constructor

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

CVCGenericContainer::CVCGenericContainer( CEikMenuBar* aMenuBar,

                                          CVCModel& aModel,

                                          CVCGenericView& aView ):

    iMenuBar( aMenuBar ), iView( aView ), iModel( aModel )

    { 

    }

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

// CVCGenericContainer::ConstructL

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

//

void CVCGenericContainer::ConstructL( const TRect& aRect ) 

    {

    RUBY_DEBUG_BLOCKL( "CVCGenericContainer::ConstructL" );

    SetTitlePaneL( R_VC_MAIN_VIEW_TITLE );

    CreateWindowL();

    iPopupController = CAknInfoPopupNoteController::NewL();

    iPopupController->SetTimePopupInView( KPopupVisibilityTime );

    ConstructListBoxL();

    SetRect( aRect );

    SetObserver( this );

    ActivateL();

    } 

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

// CVCGenericContainer::~CVCGenericContainer

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

//

CVCGenericContainer::~CVCGenericContainer() 

    {

	delete iFolderTitles;

	iItemIsFolder.Close();

	delete iPopupController;

    if ( iListBox )

        {

        static_cast<CVCDoubleLargeStyleListBox*>( iListBox )->AddScrollBarObserver( NULL );

        }

    delete iListBox; 

    }

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

// CVCGenericContainer::SetTitlePaneL

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

//

void CVCGenericContainer::SetTitlePaneL(TInt aResourceId) const 

    {

    RUBY_DEBUG_BLOCKL( "CVCGenericContainer::SetTitlePaneL" );

    // Set up status pane

    CEikStatusPane* statusPane =

        ( static_cast<CAknAppUi*> ( iCoeEnv->AppUi() ) )->StatusPane();

    CAknTitlePane* title = 

        static_cast<CAknTitlePane*>( statusPane->ControlL( TUid::Uid( EEikStatusPaneUidTitle ) ) );

    TResourceReader rReader;

    iCoeEnv->CreateResourceReaderLC( rReader, aResourceId );

    title->SetFromResourceL( rReader );

    // Set title for folder views

    if( iView.FolderTitle() != KNullDesC() )

        {

        title->SetTextL( iView.FolderTitle() );

        }

    CleanupStack::PopAndDestroy(); // rReader

    }

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

// CVCGenericContainer::OfferKeyEventL

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

//

TKeyResponse CVCGenericContainer::OfferKeyEventL( const TKeyEvent& aKeyEvent, 

                                                  TEventCode aType ) 

    {

    RUBY_DEBUG_BLOCKL( "CVCGenericContainer::OfferKeyEventL" );

    if( iHandlingKeyPressInProgress )

        {

        return EKeyWasConsumed;

        }

    // Special case when for some reason vcommand database is empty.

    // Only exiting is allowed

    if( ListBoxCount() <= 0 && aKeyEvent.iCode != EKeyCBA2 ) 

        {

        return EKeyWasConsumed;

        }

    SetHandlingKeyPressInProgress( ETrue );

    TKeyResponse retval( EKeyWasConsumed );

    TBool isFolder = IsItemFolderL( CurrentSelection() );

    switch ( aKeyEvent.iCode ) 

        {

        case EKeyBackspace: // C - key. Deletes an application

            {

            if ( iView.MenuBar()->ItemSpecificCommandsEnabled() )

                {

                TDesC* secondRow = GetSecondRowNameLC( CurrentSelection() );

                if( !isFolder && secondRow->Length() > 0 ) 

                    {

                    SetHandlingKeyPressInProgress( EFalse );

                    iView.HandleCommandL( EVCCmdDelete );    

                    }

                else 

                    {

                    SetHandlingKeyPressInProgress( EFalse );

                    iView.HandleCommandL( EVCCmdRemove );

                    }

                CleanupStack::PopAndDestroy( secondRow );

                }

            break;  

            }

        case EKeyUpArrow: 

        case EKeyDownArrow: 

            {

            retval = iListBox->OfferKeyEventL( aKeyEvent, aType );

            TRAP_IGNORE(

                ShowTooltipL( CurrentSelection() );

                iView.SetMiddleSoftkeyLabelL( CurrentSelection() ) );

            break;

            }

        case EKeyCBA2:

            {

            if( iView.FolderTitle() == KNullDesC() ) 

                {

                iView.HandleCommandL( EAknSoftkeyExit );

                }

            }

        default: 

            {

            retval = iListBox->OfferKeyEventL( aKeyEvent, aType );

            break;

            }

        } 

    SetHandlingKeyPressInProgress( EFalse );

    return retval;

    }

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

// CVCGenericContainer::IsItemFolderL

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

//

TBool CVCGenericContainer::IsItemFolderL( TInt aListBoxIndex ) const 

    {

    RUBY_DEBUG_BLOCKL( "CVCGenericContainer::IsItemFolderL" );

    if( aListBoxIndex >= 0 && aListBoxIndex < iItemIsFolder.Count() )

        {

        return iItemIsFolder[aListBoxIndex];

        }

    else

        {

        return false;

        }

    }

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

// CVCGenericContainer::ConstructListBoxL

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

//

void CVCGenericContainer::ConstructListBoxL() 

    {

    RUBY_DEBUG_BLOCKL( "CVCGenericContainer::ConstructListBoxL" );

    CVCAppUi* appUi = static_cast<CVCAppUi*>( iEikonEnv->AppUi() );

    iListBox = CVCDoubleLargeStyleListBox::NewL();

    iListBox->SetContainerWindowL( *this ); // set's iListBox to be contained in this container

    iListBox->ConstructL( this, EAknListBoxSelectionList );

    iListBox->ItemDrawer()->FormattedCellData()->EnableMarqueeL( ETrue );

    // Ownership not transferred

    iItemArray = 

        static_cast<CDesC16ArrayFlat*>( iListBox->Model()->ItemTextArray() );

    // Folder title array    

    iFolderTitles = new (ELeave) CDesC16ArrayFlat( KArrayGranularity );

    // Populates the listbox

    PopulateListBoxL();

    CEikFormattedCellListBox* listbox = static_cast<CEikFormattedCellListBox*>( iListBox );

    // Set listbox observer

    listbox->SetListBoxObserver( this );

    static_cast<CVCDoubleLargeStyleListBox*>( iListBox )->AddScrollBarObserver( this );

    }

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

// CVCGenericContainer::PopulateListBoxL

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

//

void CVCGenericContainer::PopulateListBoxL() 

    {

    RUBY_DEBUG_BLOCKL( "CVCGenericContainer::PopulateListBoxL" );

    CAknIconArray* icons = new ( ELeave ) CAknIconArray( KArrayGranularity );

    CleanupStack::PushL( icons );

    CUiArraysGenerator* generator = CUiArraysGenerator::NewLC();

    generator->FillArraysL( iModel, iView.FolderTitle(), *icons, *iFolderTitles, 

                            iItemIsFolder, *iItemArray );

    CleanupStack::PopAndDestroy( generator );

    CEikFormattedCellListBox* listbox = static_cast<CEikFormattedCellListBox*>( iListBox );

    // Takes ownership of icons

    listbox->ItemDrawer()->ColumnData()->SetIconArray( icons );

    CleanupStack::Pop( icons );

    iListBox->CreateScrollBarFrameL( ETrue );

    iListBox->ScrollBarFrame()->SetScrollBarVisibilityL( CEikScrollBarFrame::EOff, 

                                                         CEikScrollBarFrame::EAuto );

    }

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

// CVCGenericContainer::SortItemListL

// Insertion sort implementation

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

//

void CVCGenericContainer::SortItemListL() 

    {

    RUBY_DEBUG_BLOCKL( "CVCGenericContainer::SortItemListL" );

    // Case insentitive comparing

    TCollationMethod cm = *Mem::CollationMethodByIndex( 0 ); // Default collation method

    cm.iFlags |= TCollationMethod::EFoldCase;

    TInt i( 1 );

    while( i < iItemArray->Count() )

        {

        TDesC* strToCompare = GetFirstRowNameLC( i );

        TBool isFolder = IsItemFolderL( i );

        TDesC* firstRow( NULL );

        TInt j = i - 1;

        // Previous item is greater than strToCompare or previous is not a

        // folder and current item is

        while( j >= 0 &&

               ( (firstRow = GetFirstRowNameLC( j ))->CompareC( *strToCompare, 0, &cm ) > 0 || 

               isFolder && !IsItemFolderL( j ) ) ) 

            {

            CleanupStack::PopAndDestroy( firstRow );

            // Pointers are expected to be on the cleanup stack if they are non-null

            firstRow = NULL;

            if( !isFolder && IsItemFolderL( j ) ) // folders are first on the list

                {

                break;

                }

            j--;

            }

        // Pointers popped and destroyed are nullified, so non-null pointers

        // are still on the cleanup stack

        if( firstRow )

            {

            CleanupStack::PopAndDestroy( firstRow );

            }

        j++; // the last index which satisfied the conditions

        if( j < i ) 

            {

            iItemArray->InsertL( j, iListBox->Model()->ItemText( i ) );

            iItemArray->Delete( i + 1 );

            // No need to sort iItemIsFolder. Folders are in the beginning

            // and other items are in the end. This hasn't changed.

            }

        i++;

        CleanupStack::PopAndDestroy( strToCompare );

        }

    }

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

// CVCGenericContainer::HandleListBoxEventL

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

//

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

                                               TListBoxEvent aEventType ) 

    {

    RUBY_DEBUG_BLOCKL( "CVCGenericView::HandleListBoxEventL" );

    switch ( aEventType ) 

        {

        case EEventEnterKeyPressed:

        case EEventItemSingleClicked: 

            {

            if( IsItemFolderL( CurrentSelection() ) ) 

                {

                SetHandlingKeyPressInProgress( EFalse );

                iView.HandleCommandL( EVCCmdOpen );

                }

            else

                {

                SetHandlingKeyPressInProgress( EFalse );

                iView.HandleCommandL( EVCCmdPlayback );

                ShowTooltipL( CurrentSelection() );

                }

            break;

            }

        default:

            {

            ShowTooltipL( -1 );

            }

        break;

        }

    }

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

//  CVCGenericContainer::HandleScrollEventL

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

void CVCGenericContainer::HandleScrollEventL( CEikScrollBar* /*aScrollBar*/,

                                              TEikScrollEvent /*aEventType*/ )

    {

    RUBY_DEBUG_BLOCKL( "CVCGenericView::HandleScrollEventL" );

    ShowTooltipL( -1 );

    }

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

//  CVCGenericContainer::DeleteVoiceCommandL

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

void CVCGenericContainer::DeleteVCommandL() 

    {

    RUBY_DEBUG_BLOCKL( "CVCGenericContainer::DeleteVCommandL" );

    // Get corresponding CVCommand-object

    TDesC* firstRow = GetFirstRowNameLC( CurrentSelection() );

    const CVCommandUiEntry& vcommand = iModel.GetVCommandL( *firstRow );

    CleanupStack::PopAndDestroy( firstRow );

    TDesC* secondRow = GetSecondRowNameLC( CurrentSelection() );

    // Show "cannot delete" note if the voice command is not user edited

    if ( secondRow->Length() <= 0 ||

        ( vcommand.UserText() == KNullDesC() &&

          vcommand.WrittenText() != vcommand.SpokenText() ) )

        {

        CleanupStack::PopAndDestroy( secondRow );

        return iView.DoHandleCommandL( EVCCmdRemove );    

        }

    else

        {        

        HBufC* stringholder = StringLoader::LoadL( R_QTN_VC_DELETE_COMMAND, *secondRow, iEikonEnv );

        CleanupStack::PushL( stringholder );

        CAknQueryDialog* dlg = CAknQueryDialog::NewL( CAknQueryDialog::EConfirmationTone );

        if ( dlg->ExecuteLD( R_REMOVE_APPLICATION_DIALOG, *stringholder ) ) // not cancelled: ret != 0

            {

            UpdateTextL( CurrentSelection(), KNullDesC(), *secondRow );

            }

        CleanupStack::PopAndDestroy( stringholder );

        CleanupStack::PopAndDestroy( secondRow );

        }

    }

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

//  CVCGenericContainer::ShowTooltipL

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

void CVCGenericContainer::ShowTooltipL( TInt aItemIndex ) 

    {

    RUBY_DEBUG_BLOCKL( "CVCGenericContainer::ShowTooltipL" );

    if( aItemIndex >= 0 && aItemIndex < iItemArray->Count() &&

        !IsItemFolderL( aItemIndex ) )

        {

        TDesC* firstRow = GetFirstRowNameLC( CurrentSelection() );

        const CVCommandUiEntry& vcommand = iModel.GetVCommandL( *firstRow );

        CleanupStack::PopAndDestroy( firstRow );

        TName ttText = vcommand.Tooltip();

        const TDesC& writtenText = vcommand.WrittenText();

        TDesC* spokenText = vcommand.AlternativeSpokenText().AllocLC();

        // Command is not user edited

        if( *spokenText == KNullDesC() )

            {

            CleanupStack::PopAndDestroy( spokenText );

            spokenText = vcommand.SpokenText().AllocLC();

            }

        TName ttText2;    

        if( ttText.Find( KLocReplace ) != KErrNotFound )

            {

            // Replace %U with the vc api spoken text

            StringLoader::Format( ttText2, ttText, -1, *spokenText );

            ttText.Copy( ttText2 );

            }

        else

            {

            // Replace %0U with the vc api spoken text

            StringLoader::Format( ttText2, ttText, 0, *spokenText );

            // Replace %1U with the vc api written text

            StringLoader::Format( ttText, ttText2, 1, writtenText );            

            }

        iPopupController->SetTextL( ttText );

        iPopupController->RestoreDefaultPosition();

        iPopupController->ShowInfoPopupNote();

        CleanupStack::PopAndDestroy( spokenText );

        }

    else 

        {

        iPopupController->HideInfoPopupNote();

        }

    }

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

// CVCGenericContainer::IsHandlingKeyPressInProgress

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

//                   

TBool CVCGenericContainer::IsHandlingKeyPressInProgress()

    {

    return iHandlingKeyPressInProgress;

    }

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

// CVCGenericContainer::SetHandlingKeyPressInProgress

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