/*

* Copyright (c) 2006-2007 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:  Base class for all file manager containers

*

*/

// INCLUDE FILES

#include <aknlists.h>

#include <eikclbd.h>

#include <StringLoader.h>

#include <FileManagerUID.h>

#include "CFileManagerContainerBase.h"

#include "FileManager.hrh"

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

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

// CFileManagerContainerBase::CFileManagerContainerBase

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

// might leave.

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

//

CFileManagerContainerBase::CFileManagerContainerBase()

    {

    }

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

// CFileManagerContainerBase::ConstructL

// 

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

//

void CFileManagerContainerBase::ConstructL(

        const TRect& aRect,

        const TInt aFocusedIndex )

    {

    CreateWindowL();

    iListBox = CreateListBoxL();

    if ( !iListBox )

        {

        User::Leave( KErrGeneral );

        }

    SetListEmptyL();

    iListBox->CreateScrollBarFrameL( ETrue );

    iListBox->ScrollBarFrame()->SetScrollBarVisibilityL(

        CEikScrollBarFrame::EOff, CEikScrollBarFrame::EAuto );

    iListBox->SetObserver( this );

    iListBox->SetListBoxObserver( this );

    SetIndex( aFocusedIndex );

    iListBox->SetFocus( ETrue );

    iListBox->AddSelectionObserverL( this );

    SetRect( aRect );

    ActivateL();

    }

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

// CFileManagerContainerBase::~CFileManagerContainerBase

//

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

//

CFileManagerContainerBase::~CFileManagerContainerBase()

    {

    delete iListBox;

    delete iEmptyText;

    }

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

// CFileManagerContainerBase::SizeChanged

// 

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

//

void CFileManagerContainerBase::SizeChanged()

    {

    if ( iListBox )

        {

        iListBox->SetRect( Rect() );

        }

    }

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

// CFileManagerContainerBase::CountComponentControls

// 

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

//

TInt CFileManagerContainerBase::CountComponentControls() const

    {

    return iListBox ? 1 : 0;

    }

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

// CFileManagerContainerBase::ComponentControl

// 

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

//

CCoeControl* CFileManagerContainerBase::ComponentControl(

        TInt /* aIndex */ ) const

    {

    return iListBox;

    }

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

// CFileManagerContainerBase::OfferKeyEventL

// 

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

//

TKeyResponse CFileManagerContainerBase::OfferKeyEventL(

        const TKeyEvent& aKeyEvent, TEventCode aType )

    {

    return iListBox->OfferKeyEventL( aKeyEvent, aType );

    }

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

// CFileManagerContainerBase::ListBox

// 

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

//

CEikListBox& CFileManagerContainerBase::ListBox()

    {

    return *iListBox;

    }

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

// CFileManagerContainerBase::RefreshListL

// 

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

//

void CFileManagerContainerBase::RefreshListL( TInt aFocusedIndex )

    {

    if ( !iListBox )

        {

        return;

        }

    TBool isEmpty( ETrue );

    if ( iArray )

        {

        if ( iArray->MdcaCount() )

            {

            isEmpty = EFalse;

            iListBox->Model()->SetItemTextArray( iArray );

            // Remove ownership from listbox.

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

            }

        }

    if ( isEmpty )

        {

        SetEmptyArrayL();

        }

    iListBox->Reset();

    SetIndex( aFocusedIndex );

    iListBox->UpdateScrollBarsL();

    iListBox->SetFocus( ETrue );

    if ( iEmptyText )

        {

        iListBox->View()->SetListEmptyTextL( *iEmptyText );

        }

    else

        {

        iListBox->View()->SetListEmptyTextL( KNullDesC );

        }

    iListBox->DrawDeferred();

    }

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

// CFileManagerContainerBase::SetListEmptyL

// 

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

//

void CFileManagerContainerBase::SetListEmptyL()

    {

    if ( !iListBox )

        {

        return;

        }

    SetEmptyArrayL();

    iListBox->View()->SetListEmptyTextL( KNullDesC );

    }

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

// CFileManagerContainerBase::SetIndex

// 

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

//

void CFileManagerContainerBase::SetIndex( TInt aFocusedIndex )

    {

    if ( !iListBox )

        {

        return;

        }

    // Check that given index is valid

    if ( aFocusedIndex >= 0 && 

         aFocusedIndex < iListBox->Model()->NumberOfItems() )

        {

        iListBox->SetCurrentItemIndex( aFocusedIndex );

        }

    else

        {

        // if list is empty or value is negative then set focus to 0

        if ( !iListBox->Model()->NumberOfItems() || aFocusedIndex < 0 )

            {

            iListBox->SetCurrentItemIndex( 0 );

            }

        else 

            {

            // Something has been deleted in the end of the list

            // set focus to last one so the focus doesn't jump around

            iListBox->SetCurrentItemIndex(

                iListBox->Model()->NumberOfItems() - 1 );

            }

        }

    }

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

// CFileManagerContainerBase::SetTextArray

// 

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

//

void CFileManagerContainerBase::SetTextArray( MDesCArray* aArray )

    {

    iArray = aArray;

    }

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

// CFileManagerContainerBase::SetEmptyTextL

// 

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

//

void CFileManagerContainerBase::SetEmptyTextL( TInt aTextId )

    {

    delete iEmptyText;

    iEmptyText = NULL;

    if ( aTextId )

        {

        iEmptyText = StringLoader::LoadL( aTextId );

        }

    }

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

// CFileManagerContainerBase::SetHelpContext

// 

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

//

void CFileManagerContainerBase::SetHelpContext(

        const TDesC& aHelpContext )

    {

    iHelpContext = aHelpContext;

    }

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

// CFileManagerContainerBase::HandleListBoxEventL

//

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

//

void CFileManagerContainerBase::HandleListBoxEventL(

        CEikListBox* /*aListBox*/, TListBoxEvent aEventType )

    {

    switch ( aEventType )

        {

        case EEventItemSingleClicked: // FALLTHROUGH

        case EEventEnterKeyPressed:

            {

            static_cast< CAknAppUi* >( ControlEnv()->AppUi() )->

                ProcessCommandL( EFileManagerSelectionKey );

            break;

            }

        default:

            {

            break;

            }

        }

    }

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

// CFileManagerContainerBase::HandleControlEventL

//

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

//

void CFileManagerContainerBase::HandleControlEventL(

        CCoeControl* /* aControl*/, TCoeEvent /*aEventType*/ )

    {

    }

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

// CFileManagerContainerBase::FocusChanged

// 

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

//

void CFileManagerContainerBase::FocusChanged( TDrawNow aDrawNow )

    {

    CCoeControl::FocusChanged( aDrawNow );

    if ( iListBox )

        {

        iListBox->SetFocus( IsFocused(), aDrawNow );

        }

    }

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

// CFileManagerContainerBase::GetHelpContext

// 

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

// 

void CFileManagerContainerBase::GetHelpContext(

        TCoeHelpContext& aContext ) const

	{

    if ( iHelpContext.Length() )

        {

        aContext.iMajor = TUid::Uid( KFileManagerUID3 );

	    aContext.iContext = iHelpContext;

	    }

    else

        {

        CCoeControl::GetHelpContext( aContext );

        }

	}

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

// CFileManagerContainerBase::ListBoxExists

// 

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

// 

TBool CFileManagerContainerBase::ListBoxExists() const

    {

    return iListBox ? ETrue : EFalse;

    }

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

// CFileManagerContainerBase::SetEmptyArrayL

// 

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

// 

void CFileManagerContainerBase::SetEmptyArrayL()

    {

    CDesCArray* empty = new( ELeave ) CDesCArrayFlat( 1 );

    iListBox->Model()->SetItemTextArray( empty );

    // Transfer ownership to listbox.

    iListBox->Model()->SetOwnershipType( ELbmOwnsItemArray );

    }

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

// CFileManagerContainerBase::ProcessCommandL

// 

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

// 

void CFileManagerContainerBase::ProcessCommandL( TInt aCommandId )

    {

    switch ( aCommandId )

        {

        case EAknSoftkeyShiftMSK:

            {

            static_cast< CAknAppUi* >( ControlEnv()->AppUi() )->

                ProcessCommandL( EFileManagerToggleMark );

            break;

            }

        default:

            {

            break;

            }

        }

    }

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

// CFileManagerContainerBase::SelectionModeChanged

// 

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

// 

void CFileManagerContainerBase::SelectionModeChanged(

        CEikListBox* aListBox, TBool aSelectionModeEnabled )

    {

    if ( iListBox == aListBox &&

        iSelectionModeEnabled != aSelectionModeEnabled )

        {

        iSelectionModeEnabled = aSelectionModeEnabled;

        if ( !iSelectionModeEnabled )

            {

            // Update cba after selection mode gets done

            UpdateCba();

            }

        }

    }

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

// CFileManagerContainerBase::SelectionModeEnabled

// 

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

// 

TBool CFileManagerContainerBase::SelectionModeEnabled() const

    {

    return iSelectionModeEnabled;

    }

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

// CFileManagerContainerBase::UpdateCba

// 

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

// 

void CFileManagerContainerBase::UpdateCba()

    {

    }

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

// CFileManagerContainerBase::ListBoxCurrentItemIndex

// 

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

// 

TInt CFileManagerContainerBase::ListBoxCurrentItemIndex()

    {

    return iListBox->CurrentItemIndex();

    }

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

// CFileManagerContainerBase::ListBoxNumberOfItems

// 

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

//

TInt CFileManagerContainerBase::ListBoxNumberOfItems()

    {

    return iListBox->Model()->NumberOfItems();

    }

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

// CFileManagerContainerBase::ListBoxSelectionIndexes

// 

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

//

const CArrayFix< TInt >* CFileManagerContainerBase::ListBoxSelectionIndexes()

    {

    return iListBox->SelectionIndexes();

    }

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

// CFileManagerContainerBase::ListBoxSelectionIndexesCount

// 

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

//

TInt CFileManagerContainerBase::ListBoxSelectionIndexesCount()

    {

    return iListBox->SelectionIndexes()->Count();

    }

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

// CFileManagerContainerBase::ListBoxToggleItemL

// 

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

//

void CFileManagerContainerBase::ListBoxToggleItemL( TInt aIndex )

    {

    iListBox->View()->ToggleItemL( aIndex );

    }

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

// CFileManagerContainerBase::ListBoxIsItemSelected

// 

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

//

TBool CFileManagerContainerBase::ListBoxIsItemSelected( TInt aIndex )

    {

    return iListBox->View()->ItemIsSelected( aIndex );

    }

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

// CFileManagerContainerBase::ListBoxSelectAllL

// 

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

//

void CFileManagerContainerBase::ListBoxSelectAllL()

    {

    TInt count( ListBoxNumberOfItems() );

    if ( count > 0 )

        {

        CArrayFixFlat<TInt>* array =

            new( ELeave ) CArrayFixFlat< TInt >( count );

        CleanupStack::PushL( array );

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

            {

            array->AppendL( i );

            }

        iListBox->View()->SetSelectionIndexesL( array );

        CleanupStack::PopAndDestroy( array );

        }

    }

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

// CFileManagerContainerBase::ListBoxClearSelection

// 

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

//

void CFileManagerContainerBase::ListBoxClearSelection()

    {

    iListBox->View()->ClearSelection();

    }

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

// CFileManagerContainerBase::ListBoxSetTextL

// 

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

//

void CFileManagerContainerBase::ListBoxSetTextL( const TDesC& aText )

    {

    iListBox->View()->SetListEmptyTextL( aText );

    iListBox->DrawDeferred();

    }

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

// CFileManagerContainerBase::IsSearchFieldVisible

// 

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

//

TBool CFileManagerContainerBase::IsSearchFieldVisible() const

    {

    return EFalse;