/*

* Copyright (c) 2002-2007 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 CBrowserFavouritesView.

*

*

*/

// INCLUDE FILES

#include <aknsfld.h>

#include <eikbtgpc.h>

#include <eikmenub.h>

#include <aknviewappui.h>

#include <Avkon.hrh>

#include <Uikon.hrh>

#include <eikmenup.h>

#include <AknForm.h>

#include <AknQueryDialog.h>

#include <BrowserNG.rsg>

#include <avkon.rsg>

#include <FavouritesLimits.h>

#include <FavouritesDb.h>

#include <FavouritesItem.h>

#include <FavouritesItemList.h>

#include <InternetConnectionManager.h>

#include <FeatMgr.h>

#include <centralrepository.h>

#include <nifman.h>

#include "BrowserUiPrivateCRKeys.h"

#include "BrowserUtil.h"

#include "BrowserDialogs.h"

#include "BrowserFavouritesView.h"

#include "BrowserFavouritesFolderSelector.h"

#include "BrowserFavouritesContainer.h"

#include "BrowserFavouritesListbox.h"

#include "BrowserFavouritesListboxState.h"

#include "BrowserFavouritesModel.h"

#include "Browser.hrh"

#include "BrowserAppUi.h"

#include "BrowserApplication.h"

#include "BrowserFavouritesIncrementalDelete.h"

#include "BrowserFavouritesIncrementalMove.h"

#include "BrowserUIVariant.hrh"

#include "BrowserWindowManager.h"

#include "CommandVisibility.h"

#include "CommonConstants.h"

#include "CommsModel.h"

#include "Display.h"

#include "Preferences.h"

#include "eikon.hrh"

// MACROS

/**

* Defining this macro shows "Unmark all", even if nothing is marked (except

* if there are no items at all).

*/

//#define SHOW_UNMARK_ALL_ALWAYS

/**

* Defining this macro shows "Mark all", even if all is marked (except

* if there are no items at all).

*/

//#define SHOW_MARK_ALL_ALWAYS

/// Cosmetic purpose macro (resource names are overly too long).

#define _R(str) R_BROWSER_FAVOURITES_ ## str

// CONSTANTS

/// Granularity of Uid lists used in managing multiple bookmarks.

LOCAL_C const TInt KGranularityUids = 4;

/// Estimated FFS overhead for deleting (in bytes).

LOCAL_C const TInt KEstimatedDeleteFfsOverhead = 16 * 1024;

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

/**

* Create a new empty list for Uids and push it on the cleanup stack.

* @return The constructed empty list.

*/

LOCAL_C CArrayFix<TInt>* NewUidListLC()

    {

    // Not inline - go for size, not speed.

    CArrayFixFlat<TInt>* list;

    list = new (ELeave) CArrayFixFlat<TInt> ( KGranularityUids );

    CleanupStack::PushL( list );

    return list;

    }

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

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

// CBrowserFavouritesView::~CBrowserFavouritesView

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

//

CBrowserFavouritesView::~CBrowserFavouritesView()

    {

    delete iIncrementalOp;

    delete iContainer;

    delete iModel;

    delete iSavedListboxState;

    }

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

// CBrowserFavouritesView::CommandSetResourceIdL

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

TInt CBrowserFavouritesView::CommandSetResourceIdL()

    {

    // for 5.0, BrowserBookmarksView takes over cba-assignment duties

    // this function should not be called. We now route though BrowserBookmarksView.

    return R_AVKON_SOFTKEYS_EMPTY;

    }

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

// CBrowserFavouritesView::HandleCommandL

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

//

void CBrowserFavouritesView::HandleCommandL( TInt aCommand )

    {

    switch ( aCommand )

        {

        case EWmlCmdBackFromFolder:

            {

            if ( ApiProvider().IsEmbeddedModeOn() )

                {

                AppUi()->HandleCommandL( EWmlCmdCloseBrowser );

                }

            else

                {

                CloseCurrentFolderL();

                }

            break;

            }

        case EWmlCmdOpenFolder:

            {

            OpenCurrentFolderL();

            break;

            }

        case EWmlCmdOpenMarkedFolder:

            {

            OpenMarkedFolderL();

            break;

            }

        case EWmlCmdFavourites:

            {

            ApiProvider().SetViewToBeActivatedIfNeededL( KUidBrowserBookmarksViewId );

            break;

            }

        case EWmlCmdMark:

        case EWmlCmdUnmark:

        case EWmlCmdMarkAll:

        case EWmlCmdUnmarkAll:

            {

            iContainer->Listbox()->HandleMarkableListCommandL( aCommand );

            iContainer->HandleCursorChangedL( iContainer->Listbox() );

            UpdateCbaL();

            break;

            }

        case EWmlCmdDelete:

            {

            DeleteMarkedItemsL();

            break;

            }

        case EWmlCmdNewFolder:

            {

            (void)AddNewFolderL();

            break;

            }

        case EWmlCmdMoveToFolder:

            {

            MoveMarkedItemsL();

            break;

            }

        case EWmlCmdRename:

            {

            RenameCurrentItemL();

            break;

            }

        case EWmlCmdSetPreferredBookmark:

            {

            SetPreferedCurrentItemL();

            break;

            }

        case EWmlCmdSetUnPreferredBookmark:

            {

            SetUnPreferedCurrentItemL();

            break;

            }

        case EWmlCmdPreferences:

            {

            iSaveStateOnDeactivate = ETrue;

            AppUi()->HandleCommandL( aCommand );

            break;

            }

        default :

            {

            AppUi()->HandleCommandL( aCommand );

            break;

            }

        }

    }

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

// CBrowserFavouritesView::CBrowserFavouritesView

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

//

CBrowserFavouritesView::CBrowserFavouritesView( MApiProvider& aApiProvider,

                                                TInt aInitialFolderId )

        : CBrowserViewBase( aApiProvider ),

          iPreferredHighlightUid( KFavouritesNullUid ),

          iShowOkOptions( EFalse ),

          iCurrentFolder( aInitialFolderId ),

          iIsActivated( EFalse ),

          iLastSelection( 0 ),

          iUpdatePending( EFalse ),

          iRefresh( ETrue )

    {

    }

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

// CBrowserFavouritesView::ConstructL

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

//

void CBrowserFavouritesView::ConstructL( TInt aViewResourceId )

    {

    BaseConstructL( aViewResourceId );

    iModel = CreateModelL();

    iInitialFolder = iCurrentFolder;

    // Ap model cannot be created without opening it; so that's not done here.

    // DoActivateL / DoDecativateL does that.

    }

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

// CBrowserFavouritesView::GetItemsLC

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

//

CFavouritesItemList* CBrowserFavouritesView::GetItemsLC( TInt aFolder )

    {

    CFavouritesItemList* items = new (ELeave) CFavouritesItemList();

    CleanupStack::PushL( items );

    iModel->Database().GetAll( *items, aFolder );

    iModel->SortL( *items );

    return items;

    }

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

// CBrowserFavouritesView::GetSeamlessFolderResourceID

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

//

TInt CBrowserFavouritesView::GetSeamlessFolderResourceID( TInt aContextID )

    {

    TInt resId = 0;

    switch( aContextID ) // Check if the item is a seamless link folder

        {

        case KFavouritesApplicationContextId:

               {

            resId = R_BROWSERBM_FOLDER_DOWNLOAD_APPLICATIONS;

            break;

            }

        case KFavouritesImageContextId:

        {

            resId = R_BROWSERBM_FOLDER_DOWNLOAD_IMAGES;

            break;

            }

        case KFavouritesAudioContextId:

            {

            resId = R_BROWSERBM_FOLDER_DOWNLOAD_TONES;

            break;

            }

        case KFavouritesVideoContextId:

            {

            resId = R_BROWSERBM_FOLDER_DOWNLOAD_VIDEOS;

            break;

            }

        case KFavouritesSkinContextId:

            {

            resId = R_BROWSERBM_FOLDER_DOWNLOAD_SKINS;

            break;

            }

        case KFavouritesMusicContextId:

            {

            resId = R_BROWSERBM_FOLDER_DOWNLOAD_MUSIC;

            break;

            }

        default:

            {

            break; // not a seamless link folder.

            }

        }

        return resId;

    }

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

// CBrowserFavouritesView::GetSeamlessFolderTitleResourceID

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

//

TInt CBrowserFavouritesView::GetSeamlessFolderTitleResourceID( TInt aContextID )

    {

    TInt resId = 0;

    switch( aContextID ) // Check if the item is a seamless link folder

        {

        case KFavouritesApplicationContextId:

               {

            resId = R_BROWSERBM_FOLDER_TITLE_DOWNLOAD_APPLICATIONS;

            break;

            }

        case KFavouritesImageContextId:

        {

            resId = R_BROWSERBM_FOLDER_TITLE_DOWNLOAD_IMAGES;

            break;

            }

        case KFavouritesAudioContextId:

            {

            resId = R_BROWSERBM_FOLDER_TITLE_DOWNLOAD_TONES;

            break;

            }

        case KFavouritesVideoContextId:

            {

            resId = R_BROWSERBM_FOLDER_TITLE_DOWNLOAD_VIDEOS;

            break;

            }

        case KFavouritesSkinContextId:

            {

            resId = R_BROWSERBM_FOLDER_TITLE_DOWNLOAD_SKINS;

            break;

            }

        case KFavouritesMusicContextId:

            {

            resId = R_BROWSERBM_FOLDER_TITLE_DOWNLOAD_MUSIC;

            break;

            }

        default:

            {

            break; // not a seamless link folder.

            }

        }

        return resId;

      }

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

// CBrowserFavouritesView::IsSeamlessFolder

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

//

TInt CBrowserFavouritesView::IsSeamlessFolder( TInt aContextID )

     {

     return GetSeamlessFolderResourceID( aContextID ) != 0 ? ETrue : EFalse;

     }

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

// CBrowserFavouritesView::HighlightPreferredL

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

//

void CBrowserFavouritesView::HighlightPreferredL()

    {

    if (( iContainer->Listbox()->HighlightUidNow( iPreferredHighlightUid ) ) &&

        ( iPreferredHighlightUid != KFavouritesNullUid ))

        {

        // Have a preferred uid...

        // Successfully highlighted; clear preferred now.

        iPreferredHighlightUid = KFavouritesNullUid;

        iContainer->HandleCursorChangedL( iContainer->Listbox() );

        }

    }

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

// CBrowserFavouritesView::RefreshL

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

//

void CBrowserFavouritesView::RefreshL( TBool aDbErrorNote /*=EFalse*/ )

    {

    // Do the refresh only if activated; otherwise ignore.

    // (This is a sanity-check like functionality, but is really used.

    // Bookmarks View observes changes in active and default AP-s, even if

    // not activated (and tries to refresh); but this "activated-check" is

    // made here, not in Bookmarks View, because it makes things more safe and

    // "future-proof".)

    if ( iIsActivated )

        {

        iUpdatePending = ETrue;

        if ( !iIncrementalOp )

            {

            // During an incremental operation we should never do the update

            // and refill the listbox because some of the operations holds

            // pointers to listbox items. Update is pending then.

            if ( iModel->BeginL( /*aWrite=*/EFalse, aDbErrorNote ) ==

                    KErrNone )

                {

                TInt folderExists;

                iModel->Database().FolderExists( iCurrentFolder, folderExists );

                if ( folderExists )

                    {

                    // Current folder is still OK. Refresh.

                    FillListboxL( iCurrentFolder, /*aKeepState=*/ETrue );

                    }

                else

                    {

                    // Cannot access current folder (maybe deleted).

                    // Go to root.

                    OpenFolderL( KFavouritesRootUid );

                    }

                iModel->CommitL();

                iUpdatePending = EFalse;

                }

            // iUpdatePending stays ETrue if unsuccessful.

            }

        }

    }

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

// CBrowserFavouritesView::DoActivateL

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

//

void CBrowserFavouritesView::DoActivateL(

                        const TVwsViewId& /*aPrevViewId*/,

                        TUid /*aCustomMessageId*/,

                        const TDesC8& /*aCustomMessage*/ )

    {

    iPreviousViewID = ApiProvider().LastActiveViewId( );

    ApiProvider().SetLastActiveViewId( Id() );

    ApiProvider().CommsModel().AddObserverL( *this );

    iContainer = CreateContainerL();

    iModel->AddObserverL( *this );

    AppUi()->AddToViewStackL( *this, iContainer );

    ApiProvider().StartProgressAnimationL();

    if ( iModel->BeginL( /*aWrite=*/EFalse, /*aDbErrorNote=*/ETrue )

                                                                == KErrNone )

        {

        // Disable redraw to avoid flickering.

        // (OpenFolderL and the listbox's SetStateL both

        // wants to redraw the listbox. Do it once only.)

        TBool redrawDisabled =

            iContainer->Listbox()->View()->RedrawDisabled();

        iContainer->Listbox()->View()->SetDisableRedraw( ETrue );

        // Open folder first.

        OpenFolderL( iCurrentFolder );

        iModel->CommitL();

        // Now set back redraw and draw the listbox.

        if ( (iLastSelection >=0 ))

            {

            if ( iLastSelection > iContainer->Listbox()->BottomItemIndex() )

                {

                iLastSelection = 0;

                }

            iContainer->Listbox()->SetCurrentItemIndex( iLastSelection );

            UpdateGotoPaneL();

            }

        iContainer->Listbox()->View()->SetDisableRedraw( redrawDisabled );

        iContainer->Listbox()->DrawNow();

        }

    else

        {

        // No folder is opened; update CBA and Navi Pane now.

        if ( iLastSelection >=0 )

            {

            iContainer->Listbox()->SetCurrentItemIndex( iLastSelection );

            UpdateGotoPaneL();

            }

        UpdateCbaL();

        UpdateNaviPaneL();

        }

    if (iSavedListboxState)

        {

        iContainer->Listbox()->SetStateL(*iSavedListboxState);

        }

    iIsActivated = ETrue;

    }

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

// CBrowserFavouritesView::ResetStateInDeActivation

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

//

void CBrowserFavouritesView::ResetStateInDeActivation()

    {

    //Set iLastSelection to zero if there will be a folder change

    if ( iCurrentFolder != iInitialFolder )

        {

        iLastSelection = 0;

        }

    }

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

// CBrowserFavouritesView::DoDeactivate

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

//

void CBrowserFavouritesView::DoDeactivate()

    {

    iIsActivated = EFalse;

    TRAP_IGNORE(ApiProvider().StopProgressAnimationL());

    if ( iContainer )

        {