/*

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

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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 CBrowserFavouritesListbox.

*

*

*/

// INCLUDE FILES

#include <aknkeys.h>

#include <EIKCLBD.H>

#include <gulicon.h>

#include <AknIconArray.h>

#include <FavouritesDb.h>

#include <BrowserNG.rsg>

#include <ApListItemList.h>

#include <FavouritesItem.h>

#include <FavouritesItemList.h>

#include <AknsConstants.h>

#include "BrowserFavouritesListbox.h"

#include "BrowserFavouritesListboxState.h"

#include "BrowserFavouritesListboxModel.h"

#include "BrowserFavouritesListboxView.h"

#include "BrowserFavouritesModel.h"

#include "CommsModel.h"

#include "BrowserFavouritesListboxIconHandler.h"

#include "BrowserFavouritesIconIndexArray.h"

#include "BrowserUtil.h"

#include "BrowserFavouritesListboxCursorObserver.h"

#include "BrowserFavouritesListboxState.h"

#include "BrowserFavouritesListboxItemDrawer.h"

#include "ApiProvider.h"

#include "BrowserAppUi.h"

#include "BrowserFaviconHandler.h"

#include <AknLayout2ScalableDef.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include "eikon.hrh"

// CONSTANTS

/// Granularity of the icon index array.

LOCAL_C const TInt KGranularity = 4;

// ================= LOCAL FUNCTIONS =======================

/**

* Append elements from aSource to the end of aTarget.

* @param aTarget Array which receives copied elements from aSource.

* @param aSource Elements from this will be appended to aTarget.

*/

LOCAL_D void AppendArrayL

( CArrayFix<TInt>& aTarget, const CArrayFix<TInt>& aSource )

    {

    TInt i;

    TInt count = aSource.Count();

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

        {

        aTarget.AppendL( aSource.At( i ) );

        }

    }

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

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

// CBrowserFavouritesListbox::NewL

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

//

CBrowserFavouritesListbox* CBrowserFavouritesListbox::NewL

        (

        MApiProvider& aApiProvider,

        const CCoeControl* aParent,

        const MBrowserFavouritesListboxIconHandler& aIconHandler

        )

    {

    CBrowserFavouritesListbox* listbox =

        new (ELeave) CBrowserFavouritesListbox( aApiProvider );

    CleanupStack::PushL( listbox );

    listbox->ConstructL( aParent, aIconHandler );

    CleanupStack::Pop();    // listbox

    return listbox;

    }

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

// CBrowserFavouritesListbox::~CBrowserFavouritesListbox

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

//

CBrowserFavouritesListbox::~CBrowserFavouritesListbox()

    {

    delete iFaviconHandler;

    delete iIconIndexes;

    delete iItems;

    delete iNewState;

    }

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

// CBrowserFavouritesListbox::SetListboxCursorObserver

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

//

void CBrowserFavouritesListbox::SetListboxCursorObserver

(MBrowserFavouritesListboxCursorObserver* aObserver)

    {

    iCursorObserver = aObserver;

    if ( View() )

        {

        STATIC_CAST( CBrowserFavouritesListboxView*, View() )->

            SetCursorObserver( aObserver );

        }

    }

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

// CBrowserFavouritesListbox::SetDataL

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

//

void CBrowserFavouritesListbox::SetDataL

( CFavouritesItemList* aItems, /*MCommsModel& aCommsModel,*/ TBool aKeepState )

    {

    __ASSERT_DEBUG( aItems, Util::Panic( Util::EUnExpected ) );

    // Ownership of aItems is taken, and will become a member (but not yet

    // that) - push until then.

    CleanupStack::PushL( aItems );

    // Get all favicons asynchronously by iteration on icon array

    iFaviconHandler->StartGetFaviconsL( aItems );

    // Get icon indexes into new list. Replace the existing

    // data only if successfully gotten. This ensures that they don't go out

    // of sync (there cannot be different number of items in the two list).

    CBrowserFavouritesIconIndexArray* newIconIndexes =

        GetIconIndexesLC( /*aCommsModel,*/ *aItems );

    if ( aKeepState )

        {

        // Calculate new state now, while we still have old items.

        CalcNewStateL( *aItems );

        }

    // Got new data. Empty existing data, but keep the empty lists.

    ClearSelection();

    iItems->ResetAndDestroy();

    iIconIndexes->Reset();

    SetTopItemIndex(0);

    UpdateFilterL();

    HandleItemRemovalL();

    // Replace data with new.

    delete iIconIndexes;                            // Not NULL-ed, because...

    delete iItems;                                  // Not NULL-ed, because...

    iItems = aItems;                                // ... this cannot leave

    iIconIndexes = newIconIndexes;                  // ... this cannot leave

    // Let the model know the change.

    TheModel()->SetData( *iItems, *iIconIndexes );  // ... this cannot leave

    CleanupStack::Pop( 2 ); // newIconIndexes, aItems: now members.

    HandleItemAdditionL();

    UpdateFilterL();

    if ( aKeepState )

        {

        // Now set the new state into listbox, then discard it.

        __ASSERT_DEBUG( iNewState, Util::Panic( Util::EUnExpected ) );

        SetStateL( *iNewState );

        delete iNewState;

        iNewState = NULL;

        }

    }

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

// CBrowserFavouritesListbox::DrawFavicons

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

//

TInt CBrowserFavouritesListbox::DrawFavicons()

    {

    // We have some favicons to draw

    TInt err = KErrNone;

    //Update the icon indices

    TRAP(   err,

            CBrowserFavouritesIconIndexArray* newIconIndexes =

                GetIconIndexesLC( /*aCommsModel,*/ *iItems );

            iIconIndexes->Reset();

            delete iIconIndexes;

            iIconIndexes = newIconIndexes;

            CleanupStack::Pop( newIconIndexes );

        );

    // Don't draw the favicons if there is a leave

    if ( !err )

        {

        // Let the model know the change and update the lisbox.

        TheModel()->SetData( *iItems, *iIconIndexes );

        DrawNow();

        }

    return err;

    }

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

// CBrowserFavouritesListbox::SelectionStateL

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

//

TBrowserFavouritesSelectionState

CBrowserFavouritesListbox::SelectionStateL() const

    {

    TBrowserFavouritesSelectionState state;

    // Check marking first.

    const CArrayFix<TInt>* selection = MarkedRealIndexesLC();

    TInt i;

    TInt count = selection->Count();

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

        {

        state.iMarkFlags |=

            SelectionFlags( *(iItems->At( selection->At( i ) )) );

        if ( iItems->At( selection->At( i ) )->IsItem() )

            {

            state.iMarkedItemCount++;

            }

        else

            {

            state.iMarkedFolderCount++;

            }

        }

    if ( count == iItems->Count() )

        {

        state.iMarkFlags |= TBrowserFavouritesSelectionState::EAll;

        }

    TInt visibleCount;

    CAknListBoxFilterItems* filter = TheModel()->Filter();

    visibleCount = filter ? filter->FilteredNumberOfItems() : iItems->Count();

    for ( i = 0; i < visibleCount; i++ )

        {

        if ( iItems->At( RealIndex( i ) )->IsItem() )

            {

            state.iVisibleItemCount++;

            }

        }

    TKeyArrayFix key( 0, ECmpTInt32 );

    TInt dummy;

    if ( !selection->Find( CurrentItemRealIndex(), key, dummy ) )

        {

        state.iMarkFlags |=

            TBrowserFavouritesSelectionState::ECurrent;

        }

    CleanupStack::PopAndDestroy();  // selection

    // Then comes the current.

    const CFavouritesItem* current = CurrentItem();

    if ( current )

        {

        state.iCurrentFlags |= SelectionFlags( *current );

        }

    return state;

    }

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

// CBrowserFavouritesListbox::CurrentItem

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

//

const CFavouritesItem* CBrowserFavouritesListbox::CurrentItem() const

    {

    TInt index = CurrentItemRealIndex();

    if ( index >= 0 )

        {

        return iItems->At( index );

        }

    return NULL;

    }

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

// CBrowserFavouritesListbox::MarkedItemL

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

//

const CFavouritesItem* CBrowserFavouritesListbox::MarkedItemL() const

    {

    CFavouritesItem* item = NULL;

    CArrayFix<TInt>* marked = MarkedRealIndexesLC();

    if ( marked->Count() == 1 )

        {

        item = iItems->At( marked->At( 0 ) );

        }

    CleanupStack::PopAndDestroy();

    return item;

    }

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

// CBrowserFavouritesListbox::HighlightUidNow

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

//

TBool CBrowserFavouritesListbox::HighlightUidNow( TInt aUid )

    {

    TInt index = 0;

    if (aUid != 0)

        {

        index = UidToViewIndex( aUid );

        }

    if ( index >= 0 )

        {

        SetCurrentItemIndexAndDraw( index );

        return ETrue;

        }

    return EFalse;

    }

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

// CBrowserFavouritesListbox::HandleMarkableListCommandL

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

//

void CBrowserFavouritesListbox::HandleMarkableListCommandL( TInt aCommand )

    {

    if ( ListboxFlags() & EAknListBoxMarkableList )

        {

        TInt index;

        switch ( aCommand )

            {

            case EWmlCmdMark:

                {

                index = CurrentItemIndex();

                if ( index >= 0 )

                    {

                    View()->SelectItemL( index );

                    }

                break;

                }

            case EWmlCmdUnmark:

                {

                index = CurrentItemIndex();

                if ( index >= 0 )

                    {

                    View()->DeselectItem( index );

                    }

                break;

                }

            case EWmlCmdMarkAll:

                {

                ClearSelection();

                TInt count = Model()->NumberOfItems();

                if ( count )

                    {

                    TInt i = 0;

                    CArrayFixFlat<TInt>* selection =

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

                    CleanupStack::PushL( selection );

                    selection->SetReserveL( count );

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

                        {

                        selection->AppendL( i );

                        }

                    SetSelectionIndexesL( selection );

                    CleanupStack::PopAndDestroy();  // selection

                    }

                break;

                }

            case EWmlCmdUnmarkAll:

                {

                ClearSelection();

                break;

                }

            default:

                {

                Util::Panic( Util::EUnExpected );

                }

            }

        }

    }

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

// CBrowserFavouritesListbox::MarkedUidsLC

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

//

CArrayFix<TInt>* CBrowserFavouritesListbox::MarkedUidsLC() const

    {

    CArrayFix<TInt>* array = MarkedRealIndexesLC();

    RealIndexesToUids( *array );

    return array;

    }

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

// CBrowserFavouritesListbox::SelectedUidsLC

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

//

CArrayFix<TInt>* CBrowserFavouritesListbox::SelectedUidsLC() const

    {

    CArrayFix<TInt>* array = SelectedRealIndexesLC();

    RealIndexesToUids( *array );

    return array;

    }

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

// CBrowserFavouritesListbox::SelectedItemsLC

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

//

CArrayPtr<const CFavouritesItem>*

CBrowserFavouritesListbox::SelectedItemsLC(TBool aIncludeSpecialItems) const

    {

    CArrayPtrFlat<const CFavouritesItem>* itemPtrs =

        new (ELeave) CArrayPtrFlat<const CFavouritesItem>( KGranularity );

    CleanupStack::PushL( itemPtrs );

    CArrayFix<TInt>* indexes = SelectedRealIndexesLC();

    TInt i;

    TInt count = indexes->Count();

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

        {

        CFavouritesItem* item = iItems->At( indexes->At( i ) );

        if ( !aIncludeSpecialItems )

            {

            // Skip special items:

            // folders, homepage, last visited & start page URLs.

            // Need a workaround for the start page since CFavouritesItem

            // does not provide IsStartPage() or something similar.

            if ( (item->Uid() == KFavouritesHomepageUid ) ||

                (item->Uid() == KFavouritesLastVisitedUid ) ||

                item->IsFolder() ||

                item->Uid() == KFavouritesStartPageUid )

                    continue;

            }

        itemPtrs->AppendL( item );

        }

    CleanupStack::PopAndDestroy();  // indexes

    return itemPtrs;

    }

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

// CBrowserFavouritesListbox::ItemByUid

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

//

const CFavouritesItem* CBrowserFavouritesListbox::ItemByUid

( TInt aUid ) const

    {

    return iItems->ItemByUid( aUid );

    }

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

// CBrowserFavouritesListbox::UnfilteredNumberOfItems

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

//

TInt CBrowserFavouritesListbox::UnfilteredNumberOfItems()

    {

    return iItems->Count();

    }

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

// CBrowserFavouritesListbox::FilteredNumberOfItems

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

//

TInt CBrowserFavouritesListbox::FilteredNumberOfItems()

    {

    CAknListBoxFilterItems* filter = TheModel()->Filter();

    return filter->FilteredNumberOfItems();

    }

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

// CBrowserFavouritesListbox::UpdateFilterL

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

//

void CBrowserFavouritesListbox::UpdateFilterL()

    {

    CAknListBoxFilterItems* filter = TheModel()->Filter();

    if ( filter )

        {

        filter->HandleItemArrayChangeL();

        }

    }

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

// CBrowserFavouritesListbox::AnyFoldersL

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

//

TBool CBrowserFavouritesListbox::AnyFoldersL()

    {

    TInt i;

    TInt count = iItems->Count();

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

        {

        if ( iItems->At( i )->IsFolder() )

            {

            if (iItems->At( i )->Uid()!=KFavouritesAdaptiveItemsFolderUid) return ETrue; //exclude Adaptive Bookmarks Folder

            }

        }

    return EFalse;

    }

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

// CBrowserFavouritesListbox::OfferKeyEventL

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

//

TKeyResponse CBrowserFavouritesListbox::OfferKeyEventL

( const TKeyEvent& aKeyEvent, TEventCode aType )

    {

    TKeyResponse result = EKeyWasNotConsumed;

    switch ( aKeyEvent.iCode )

        {

        case EKeyLeftUpArrow:     // Northwest

        case EStdKeyDevice10:     //   : Extra KeyEvent supports diagonal event simulator wedge

        case EKeyLeftArrow:       // West

        case EKeyLeftDownArrow:   // Southwest

        case EStdKeyDevice13:     //   : Extra KeyEvent supports diagonal event simulator wedge