1 /*

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

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of the License "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: 

    15 *      Implementation of CBrowserFavouritesView.

    16 *

    17 *

    18 */

    19 

    20 

    21 // INCLUDE FILES

    22 #include <aknappui.h>

    23 #include <akntitle.h>

    24 #include <eikenv.h>

    25 #include <eikspane.h>

    26 

    27 #include <aknsfld.h>

    28 #include <eikbtgpc.h>

    29 #include <eikmenub.h>

    30 #include <aknviewappui.h>

    31 #include <Avkon.hrh>

    32 #include <Uikon.hrh>

    33 #include <eikmenup.h>

    34 #include <AknForm.h>

    35 #include <AknQueryDialog.h>

    36 #include <BrowserNG.rsg>

    37 #include <avkon.rsg>

    38 #include <favouriteslimits.h>

    39 #include <favouritesdb.h>

    40 #include <favouritesitem.h>

    41 #include <favouritesitemlist.h>

    42 #include <internetconnectionmanager.h>

    43 #include <FeatMgr.h>

    44 #include <centralrepository.h>

    45 #include <nifman.h>

    46 

    47 #include "BrowserUiPrivateCRKeys.h"

    48 #include "BrowserUtil.h"

    49 #include "BrowserDialogs.h"

    50 #include "BrowserFavouritesView.h"

    51 #include "BrowserFavouritesFolderSelector.h"

    52 #include "BrowserFavouritesContainer.h"

    53 #include "BrowserFavouritesListbox.h"

    54 #include "BrowserFavouritesListboxState.h"

    55 #include "BrowserFavouritesModel.h"

    56 #include "Browser.hrh"

    57 #include "BrowserAppUi.h"

    58 #include "BrowserApplication.h"

    59 #include "BrowserFavouritesIncrementalDelete.h"

    60 #include "BrowserFavouritesIncrementalMove.h"

    61 #include "BrowserUIVariant.hrh"

    62 #include "BrowserWindowManager.h"

    63 #include "CommandVisibility.h"

    64 #include "CommonConstants.h"

    65 #include "CommsModel.h"

    66 #include "Display.h"

    67 #include "Preferences.h"

    68 #include "logger.h" 

    69 

    70 #include "eikon.hrh"

    71 

    72 

    73 // MACROS

    74 

    75 /**

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

    77 * if there are no items at all).

    78 */

    79 //#define SHOW_UNMARK_ALL_ALWAYS

    80 /**

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

    82 * if there are no items at all).

    83 */

    84 //#define SHOW_MARK_ALL_ALWAYS

    85 

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

    87 #define _R(str) R_BROWSER_FAVOURITES_ ## str

    88 

    89 // CONSTANTS

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

    91 LOCAL_C const TInt KGranularityUids = 4;

    92 

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

    94 LOCAL_C const TInt KEstimatedDeleteFfsOverhead = 16 * 1024;

    95 

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

    97 

    98 /**

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

   100 * @return The constructed empty list.

   101 */

   102 LOCAL_C CArrayFix<TInt>* NewUidListLC()

   103     {

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

   105     CArrayFixFlat<TInt>* list;

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

   107     CleanupStack::PushL( list );

   108     return list;

   109     }

   110 

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

   112 

   113 // ---------------------------------------------------------

   114 // CBrowserFavouritesView::~CBrowserFavouritesView

   115 // ---------------------------------------------------------

   116 //

   117 CBrowserFavouritesView::~CBrowserFavouritesView()

   118     {

   119     delete iFavViewRefresh;

   120     delete iIncrementalOp;

   121     delete iContainer;

   122     delete iModel;

   123     delete iSavedListboxState;

   124     }

   125 

   126 // ---------------------------------------------------------------------------

   127 // CBrowserFavouritesView::CommandSetResourceIdL

   128 // ---------------------------------------------------------------------------

   129 TInt CBrowserFavouritesView::CommandSetResourceIdL()

   130     {

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

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

   133     return R_AVKON_SOFTKEYS_EMPTY;

   134     }

   135 

   136 // ---------------------------------------------------------

   137 // CBrowserFavouritesView::HandleCommandL

   138 // ---------------------------------------------------------

   139 //

   140 void CBrowserFavouritesView::HandleCommandL( TInt aCommand )

   141     {

   142     switch ( aCommand )

   143         {

   144         case EWmlCmdBackFromFolder:

   145             {

   146             if ( ApiProvider().IsEmbeddedModeOn() )

   147                 {

   148                 AppUi()->HandleCommandL( EWmlCmdCloseBrowser );

   149                 }

   150             else

   151                 {

   152                 CloseCurrentFolderL();

   153                 }

   154             break;

   155             }

   156 

   157         case EWmlCmdOpenFolder:

   158             {

   159             OpenCurrentFolderL();

   160             break;

   161             }

   162 

   163         case EWmlCmdOpenMarkedFolder:

   164             {

   165             OpenMarkedFolderL();

   166             break;

   167             }

   168 

   169         case EWmlCmdFavourites:

   170             {

   171             ApiProvider().SetViewToBeActivatedIfNeededL( KUidBrowserBookmarksViewId );

   172             break;

   173             }

   174 

   175         case EWmlCmdMark:

   176         case EWmlCmdUnmark:

   177         case EWmlCmdMarkAll:

   178         case EWmlCmdUnmarkAll:

   179             {

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

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

   182             UpdateCbaL();

   183             break;

   184             }

   185 

   186         case EWmlCmdDelete:

   187             {

   188             DeleteMarkedItemsL();

   189             break;

   190             }

   191 

   192         case EWmlCmdNewFolder:

   193             {

   194             (void)AddNewFolderL();

   195             break;

   196             }

   197 

   198         case EWmlCmdMoveToFolder:

   199             {

   200             MoveMarkedItemsL();

   201             break;

   202             }

   203 

   204 

   205         case EWmlCmdRename:

   206             {

   207             RenameCurrentItemL();

   208             break;

   209             }

   210 

   211         case EWmlCmdSetPreferredBookmark:

   212             {

   213             SetPreferedCurrentItemL();

   214             break;

   215             }

   216 

   217         case EWmlCmdSetUnPreferredBookmark:

   218             {

   219             SetUnPreferedCurrentItemL();

   220             break;

   221             }

   222 

   223         case EWmlCmdPreferences:

   224             {

   225             iSaveStateOnDeactivate = ETrue;

   226             AppUi()->HandleCommandL( aCommand );

   227             break;

   228             }

   229         default :

   230             {

   231             AppUi()->HandleCommandL( aCommand );

   232             break;

   233             }

   234         }

   235     }

   236 

   237 // ----------------------------------------------------------------------------

   238 // CBrowserFavouritesView::CBrowserFavouritesView

   239 // ----------------------------------------------------------------------------

   240 //

   241 CBrowserFavouritesView::CBrowserFavouritesView( MApiProvider& aApiProvider,

   242                                                 TInt aInitialFolderId )

   243         : CBrowserViewBase( aApiProvider ),

   244           iPreferredHighlightUid( KFavouritesNullUid ),

   245           iShowOkOptions( EFalse ),

   246           iCurrentFolder( aInitialFolderId ),

   247           iIsActivated( EFalse ),

   248           iLastSelection( 0 ),

   249           iUpdatePending( EFalse ),

   250           iFavViewRefresh(0),

   251           iRefresh( ETrue )

   252           

   253     {

   254     }

   255 

   256 // ---------------------------------------------------------

   257 // CBrowserFavouritesView::ConstructL

   258 // ---------------------------------------------------------

   259 //

   260 void CBrowserFavouritesView::ConstructL( TInt aViewResourceId )

   261     {

   262     BaseConstructL( aViewResourceId );

   263     iModel = CreateModelL();

   264     iInitialFolder = iCurrentFolder;

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

   266     // DoActivateL / DoDecativateL does that.

   267     Cba()->MakeVisible(EFalse); // avoid multiple redraws

   268     }

   269 

   270 // ---------------------------------------------------------

   271 // CBrowserFavouritesView::GetItemsLC

   272 // ---------------------------------------------------------

   273 //

   274 CFavouritesItemList* CBrowserFavouritesView::GetItemsLC( TInt aFolder )

   275     {

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

   277     CleanupStack::PushL( items );

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

   279     iModel->SortL( *items );

   280     return items;

   281     }

   282 

   283 // ---------------------------------------------------------

   284 // CBrowserFavouritesView::GetSeamlessFolderResourceID

   285 // ---------------------------------------------------------

   286 //

   287 TInt CBrowserFavouritesView::GetSeamlessFolderResourceID( TInt aContextID )

   288     {

   289     TInt resId = 0;

   290 

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

   292         {

   293         case KFavouritesApplicationContextId:

   294                {

   295             resId = R_BROWSERBM_FOLDER_DOWNLOAD_APPLICATIONS;

   296             break;

   297             }

   298         case KFavouritesImageContextId:

   299         {

   300             resId = R_BROWSERBM_FOLDER_DOWNLOAD_IMAGES;

   301             break;

   302             }

   303         case KFavouritesAudioContextId:

   304             {

   305             resId = R_BROWSERBM_FOLDER_DOWNLOAD_TONES;

   306             break;

   307             }

   308         case KFavouritesVideoContextId:

   309             {

   310             resId = R_BROWSERBM_FOLDER_DOWNLOAD_VIDEOS;

   311             break;

   312             }

   313         case KFavouritesSkinContextId:

   314             {

   315             resId = R_BROWSERBM_FOLDER_DOWNLOAD_SKINS;

   316             break;

   317             }

   318         case KFavouritesMusicContextId:

   319             {

   320             resId = R_BROWSERBM_FOLDER_DOWNLOAD_MUSIC;

   321             break;

   322             }

   323         case KFavouritesServiceContextId:

   324             {

   325             resId = R_IS_RECOMMENDATIONS;

   326             break;

   327             }

   328         default:

   329             {

   330             break; // not a seamless link folder.

   331             }

   332         }

   333 

   334         return resId;

   335     }

   336 

   337 

   338 // ---------------------------------------------------------

   339 // CBrowserFavouritesView::GetSeamlessFolderTitleResourceID

   340 // ---------------------------------------------------------

   341 //

   342 TInt CBrowserFavouritesView::GetSeamlessFolderTitleResourceID( TInt aContextID )

   343     {

   344     TInt resId = 0;

   345 

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

   347         {

   348         case KFavouritesApplicationContextId:

   349                {

   350             resId = R_BROWSERBM_FOLDER_TITLE_DOWNLOAD_APPLICATIONS;

   351             break;

   352             }

   353         case KFavouritesImageContextId:

   354         {

   355             resId = R_BROWSERBM_FOLDER_TITLE_DOWNLOAD_IMAGES;

   356             break;

   357             }

   358         case KFavouritesAudioContextId:

   359             {

   360             resId = R_BROWSERBM_FOLDER_TITLE_DOWNLOAD_TONES;

   361             break;

   362             }

   363         case KFavouritesVideoContextId:

   364             {

   365             resId = R_BROWSERBM_FOLDER_TITLE_DOWNLOAD_VIDEOS;

   366             break;

   367             }

   368         case KFavouritesSkinContextId:

   369             {

   370             resId = R_BROWSERBM_FOLDER_TITLE_DOWNLOAD_SKINS;

   371             break;

   372             }

   373         case KFavouritesMusicContextId:

   374             {

   375             resId = R_BROWSERBM_FOLDER_TITLE_DOWNLOAD_MUSIC;

   376             break;

   377             }

   378         default:

   379             {

   380             break; // not a seamless link folder.

   381             }

   382         }

   383 

   384         return resId;

   385       }

   386 

   387 

   388 // ---------------------------------------------------------

   389 // CBrowserFavouritesView::IsSeamlessFolder

   390 // ---------------------------------------------------------

   391 //

   392 TInt CBrowserFavouritesView::IsSeamlessFolder( TInt aContextID )

   393      {

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

   395      }

   396 

   397 // ---------------------------------------------------------

   398 // CBrowserFavouritesView::HighlightPreferredL

   399 // ---------------------------------------------------------

   400 //

   401 void CBrowserFavouritesView::HighlightPreferredL()

   402     {

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

   404         ( iPreferredHighlightUid != KFavouritesNullUid ))

   405         {

   406         // Have a preferred uid...

   407         // Successfully highlighted; clear preferred now.

   408         iPreferredHighlightUid = KFavouritesNullUid;

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

   410         }

   411     }

   412 

   413 // ---------------------------------------------------------

   414 // CBrowserFavouritesView::RefreshL

   415 // ---------------------------------------------------------

   416 //

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

   418     {

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

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

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

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

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

   424     // "future-proof".)

   425     if ( iIsActivated )

   426         {

   427         iUpdatePending = ETrue;

   428         if ( !iIncrementalOp )

   429             {

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

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

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

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

   434                     KErrNone )

   435                 {

   436                 TInt folderExists;

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

   438                 if ( folderExists )

   439                     {

   440                     // Current folder is still OK. Refresh.

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

   442                     }

   443                 else

   444                     {

   445                     // Cannot access current folder (maybe deleted).

   446                     // Go to root.

   447                     OpenFolderL( KFavouritesRootUid );

   448                     }

   449                 iModel->CommitL();

   450                 iUpdatePending = EFalse;

   451                 }

   452             // iUpdatePending stays ETrue if unsuccessful.

   453             }

   454         }

   455     }

   456 

   457 // ---------------------------------------------------------

   458 // CBrowserFavouritesView::DoActivateL

   459 // ---------------------------------------------------------

   460 //

   461 void CBrowserFavouritesView::DoActivateL(

   462                         const TVwsViewId& /*aPrevViewId*/,

   463                         TUid /*aCustomMessageId*/,

   464                         const TDesC8& /*aCustomMessage*/ )

   465     {

   466     iPreviousViewID = ApiProvider().LastActiveViewId( );

   467     ApiProvider().SetLastActiveViewId( Id() );

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

   469     iContainer = CreateContainerL(); // can this be created during construct ?

   470     iModel->AddObserverL( *this );

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

   472 

   473     ApiProvider().StartProgressAnimationL();

   474 

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

   476                                                                 == KErrNone )

   477         {

   478         // Disable redraw to avoid flickering.

   479         // (OpenFolderL and the listbox's SetStateL both

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

   481         TBool redrawDisabled =

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

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

   484         // Open folder first.

   485         OpenFolderL( iCurrentFolder );

   486         iModel->CommitL();

   487 

   488         // Now set back redraw and draw the listbox.

   489         if ( (iLastSelection >=0 ))

   490             {

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

   492                 {

   493                 iLastSelection = 0;

   494                 }

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

   496             }

   497 

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

   499         iContainer->Listbox()->DrawDeferred();

   500         }

   501     else

   502         {

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

   504         if ( iLastSelection >=0 )

   505             {

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

   507             UpdateGotoPaneL();

   508             }

   509         UpdateCbaL();

   510         UpdateNaviPaneL();

   511         }

   512 

   513     if (iSavedListboxState)

   514         {

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

   516         }

   517     iIsActivated = ETrue;

   518     

   519 #ifndef BRDO_PERF_IMPROVEMENTS_ENABLED_FF

   520     // TODO: Remove this crapy refresh once favicon callback interface

   521     // with engine is implemented. 

   522     if(!iFavViewRefresh)

   523          iFavViewRefresh  = CIdle::NewL( CActive::EPriorityIdle );

   524     iFavViewRefresh ->Start( TCallBack( RefeshFavoriteListBox, this ) );

   525 #endif    

   526     }

   527 

   528 

   529 TInt CBrowserFavouritesView::RefeshFavoriteListBox(TAny* aFavouritesView)

   530     {

   531    __ASSERT_DEBUG(aFavouritesView, Util::Panic( Util::EUninitializedData ));

   532    TRAP_IGNORE(

   533                 ((CBrowserFavouritesView*)aFavouritesView)->RefreshL();

   534                 );

   535     return KErrNone;

   536     }

   537 

   538 // ----------------------------------------------------------------------------

   539 // CBrowserFavouritesView::ResetStateInDeActivation

   540 // ----------------------------------------------------------------------------

   541 //

   542 void CBrowserFavouritesView::ResetStateInDeActivation()

   543     {

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

   545     if ( iCurrentFolder != iInitialFolder )

   546         {

   547         iLastSelection = 0;

   548         }

   549     }

   550 

   551 // ---------------------------------------------------------

   552 // CBrowserFavouritesView::DoDeactivate

   553 // ---------------------------------------------------------

   554 //

   555 void CBrowserFavouritesView::DoDeactivate()

   556     {

   557     iIsActivated = EFalse;

   558     TRAP_IGNORE(ApiProvider().StopProgressAnimationL());

   559     

   560     if(iFavViewRefresh)

   561         {

   562         iFavViewRefresh->Cancel();

   563         }

   564     

   565     if ( iContainer )

   566         {

   567         iLastSelection = iContainer->Listbox()->CurrentItemIndex();

   568         }

   569 

   570     if ( !iSaveStateOnDeactivate )

   571         {

   572         ResetStateInDeActivation();  // entering root directory

   573         iSaveStateOnDeactivate = EFalse;

   574         }

   575     else

   576         {

   577         CBrowserFavouritesListboxState *temp = NULL;

   578         TInt err( KErrNone );

   579         TInt tempUid( KFavouritesNullUid );

   580 

   581         temp = new CBrowserFavouritesListboxState;

   582         if ( iContainer && temp!=NULL  )

   583             {

   584             delete iSavedListboxState;

   585             iSavedListboxState = temp;

   586             // folder might be empty, no CurrentItem at all

   587             if ( iContainer->Listbox()->CurrentItem() )

   588                 {

   589                 tempUid = iContainer->Listbox()->CurrentItem()->Uid();

   590                 }

   591             iSavedListboxState->iHighlightUid = tempUid;

   592             TRAP( err, {

   593                 iSavedListboxState->iMarkUids = iContainer->Listbox()->MarkedUidsLC();

   594                 CleanupStack::Pop();    // Uid list; ownership is now in the state.

   595                 } )

   596             }

   597         if ( !err )

   598             {

   599             iSavedListboxState->iTopItemUid = tempUid;

   600             }

   601         else

   602             {

   603             delete iSavedListboxState;

   604             }

   605         }

   606 

   607     if ( !ApiProvider().ExitInProgress() )

   608         {

   609         ApiProvider().CommsModel().RemoveObserver( *this );

   610         }

   611     iModel->RemoveObserver( *this );

   612 

   613     if ( iContainer )

   614         {

   615         AppUi()->RemoveFromViewStack( *this, iContainer );

   616         delete iContainer;

   617         iContainer = NULL;

   618         }

   619     iModel->CloseDb();

   620     }

   621 

   622 // ---------------------------------------------------------

   623 // CBrowserFavouritesView::HandleClientRectChange

   624 // ---------------------------------------------------------

   625 //

   626 void CBrowserFavouritesView::HandleClientRectChange()

   627     {

   628     if ( iContainer )

   629         {

   630         iContainer->SetRect( ClientRect() );

   631         }

   632     }

   633 

   634 // ---------------------------------------------------------

   635 // CBrowserFavouritesView::DynInitMenuPaneL

   636 // ---------------------------------------------------------

   637 //

   638 void CBrowserFavouritesView::DynInitMenuPaneL

   639 ( TInt aResourceId, CEikMenuPane* aMenuPane )

   640     {

   641     if ( iContainer && iContainer->Listbox() )

   642         {

   643         TBrowserFavouritesSelectionState state =

   644             iContainer->Listbox()->SelectionStateL();

   645         TCommandVisibility::TIndex index =

   646             TCommandVisibility::Index( state, iShowOkOptions );

   647         DynInitMenuPaneL( aResourceId, aMenuPane, index, state );

   648         }

   649     }

   650 

   651 // ---------------------------------------------------------

   652 // CBrowserFavouritesView::HandleForegroundEventL

   653 // ---------------------------------------------------------

   654 //

   655 void CBrowserFavouritesView::HandleForegroundEventL( TBool aForeground )

   656     {

   657     // If another thread made changes to database, sometimes we could not

   658     // refresh when the notifcation comes in (most likely the other thread

   659     // closes the database and that performs an automatic compact(?)).

   660     // When coming foreground, check for missed updates.

   661     // Also, when coming to foreground Refresh if Skin has changed

   662     if ( aForeground && (iUpdatePending || iContainer->Listbox()->IsSkinUpdated()))

   663         {

   664         RefreshL();

   665         if (iContainer->Listbox()->IsSkinUpdated())

   666             {

   667             iContainer->Listbox()->SetSkinUpdated(EFalse);

   668             }

   669         }

   670     }

   671 

   672 // ---------------------------------------------------------

   673 // CBrowserFavouritesView::HandleListBoxEventL

   674 // ---------------------------------------------------------

   675 //

   676 void CBrowserFavouritesView::HandleListBoxEventL

   677 ( CEikListBox* aListBox, MEikListBoxObserver::TListBoxEvent aEventType )

   678     {

   679     if ( aListBox == iContainer->Listbox() )

   680         {

   681         switch ( aEventType )

   682             {

   683             case MEikListBoxObserver::EEventEnterKeyPressed:

   684             case MEikListBoxObserver::EEventItemDoubleClicked:

   685 #ifdef BRDO_SINGLE_CLICK_ENABLED_FF                

   686             case MEikListBoxObserver::EEventItemSingleClicked:    

   687 #endif                

   688                 {

   689                 if ( iContainer->Listbox()->CurrentItem() )

   690                     {

   691                     if ( iContainer->Listbox()->CurrentItem()->IsFolder() )

   692                         {

   693                         OpenCurrentFolderL();

   694                         }

   695                     }

   696                 break;

   697                 }

   698 

   699             default:

   700                 {

   701                 break;

   702                 }

   703             }

   704         }

   705     }

   706 

   707 // ---------------------------------------------------------

   708 // CBrowserFavouritesView::CloseCurrentFolderL

   709 // ---------------------------------------------------------

   710 //

   711 void CBrowserFavouritesView::CloseCurrentFolderL()

   712     {

   713     if ( iCurrentFolder != KFavouritesRootUid )

   714         {

   715         // Folders are one level deep. Closing any folder takes us to root.

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

   717                                                                 == KErrNone )

   718             {

   719             if ( iContainer && iContainer->Listbox() )

   720                 {

   721                 // After closing, the highlight should be

   722                 // on the folder just being closed.

   723                 iPreferredHighlightUid = iCurrentFolder;

   724                 OpenFolderL( KFavouritesRootUid );

   725                 }

   726             iModel->CommitL();

   727             }

   728         }

   729     }

   730 

   731 // ---------------------------------------------------------

   732 // CBrowserFavouritesView::OpenCurrentFolderL

   733 // ---------------------------------------------------------

   734 //

   735 void CBrowserFavouritesView::OpenCurrentFolderL()

   736     {

   737     if ( iContainer && iContainer->Listbox() )

   738         {

   739         const CFavouritesItem* folder =

   740             iContainer->Listbox()->CurrentItem();

   741         if ( folder && folder->IsFolder() )

   742             {

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

   744                                                                 == KErrNone )

   745                 {

   746                 OpenFolderL( folder->Uid() );

   747                 iModel->CommitL();

   748                 }

   749             }

   750         }

   751     }

   752 

   753 // ---------------------------------------------------------

   754 // CBrowserFavouritesView::OpenMarkedFolderL

   755 // ---------------------------------------------------------

   756 //

   757 void CBrowserFavouritesView::OpenMarkedFolderL()

   758     {

   759     if ( iContainer && iContainer->Listbox() )

   760         {

   761         const CFavouritesItem* folder =

   762             iContainer->Listbox()->MarkedItemL();

   763         if ( folder && folder->IsFolder() )

   764             {

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

   766                                                                 == KErrNone )

   767                 {

   768                 OpenFolderL( folder->Uid() );

   769                 iModel->CommitL();

   770                 }

   771             }

   772         }

   773     }

   774 

   775 // ---------------------------------------------------------

   776 // CBrowserFavouritesView::DeleteMarkedItemsL

   777 // ---------------------------------------------------------

   778 //

   779 void CBrowserFavouritesView::DeleteMarkedItemsL()

   780     {

   781     CArrayPtr<const CFavouritesItem>* items =

   782         iContainer->Listbox()->SelectedItemsLC();

   783     // Permormance optimization: keep a separate list for folders.

   784     // (Make the "non-empty folder" check only for folders; this speeds up

   785     // things considerably when many items are selected.)

   786     CArrayFix<TInt>* uids = NewUidListLC();

   787     CArrayFix<TInt>* folderUids = NewUidListLC();

   788     TInt i;

   789     TInt count = items->Count();

   790     const CFavouritesItem* item = NULL;

   791 

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

   793         {

   794         item = items->At( i );

   795         uids->AppendL( item->Uid() );

   796         if ( item->IsFolder() )

   797             {

   798             folderUids->AppendL( item->Uid() );

   799             }

   800         }

   801     // Cannot delete the "items" pointer list, as other objects were pushed

   802     // after it. But DO NOT USE it after this point! The call to ConfirmDeleteL

   803     // allows other active objects to run, and the listbox may be updated.

   804     // If listbox is updated, all pointers in "items" point to deleted objects.

   805 

   806     if ( ConfirmDeleteL( *uids, *folderUids ) )

   807         {

   808 

   809         if (count ==1)

   810             {

   811             CFavouritesItemList* allItems = GetItemsLC( KFavouritesRootUid );

   812             item = items->At(0);

   813             iPreferredHighlightUid = item->Uid();

   814             TInt index = allItems->UidToIndex(iPreferredHighlightUid);

   815             index++;

   816             if (allItems->IndexToUid(index) != NULL)

   817                 {

   818                 iPreferredHighlightUid = allItems->IndexToUid(index);

   819                 }

   820             else

   821                 {

   822                 iPreferredHighlightUid = allItems->IndexToUid(index-2);

   823                 }

   824             CleanupStack::PopAndDestroy(); //allItems

   825             }

   826 

   827 

   828         CArrayFix<TInt>* notDeletedUids = NewUidListLC();

   829 

   830         // OOD handling. If disk space is low, we try to get some spare.

   831 

   832         CRepository* repository = CRepository::NewL( KCRUidBrowser );

   833 

   834         TBool diskLow = Util::FFSSpaceBelowCriticalLevelL

   835                 ( /*aShowErrorNote=*/EFalse, KEstimatedDeleteFfsOverhead );

   836         if ( diskLow )

   837             {

   838             // Using disk space requests is not supported by CenRep.

   839             delete repository;

   840             }

   841 

   842         if ( !iModel->BeginL

   843                 (

   844                 /*aWrite=*/ETrue,

   845                 /*aDbErrorNote=*/ETrue,

   846                 /*aLffsCheck=*/EFalse

   847                 )

   848             )

   849             {

   850             __ASSERT_DEBUG( !iIncrementalOp, Util::Panic

   851                 ( Util::EIncrementalOperationAlreadyRunning ) );

   852             // Seems we have to give lower priority to the delete operation,

   853             // or else the wait note does not show up.

   854             iIncrementalOp = CBrowserFavouritesIncrementalDelete::NewL

   855                 (

   856                 *iModel,

   857                 *uids,

   858                 *notDeletedUids,

   859                 CActive::EPriorityStandard - 1

   860                 );

   861             iIncrementalOp->ExecuteL();

   862             delete iIncrementalOp;

   863             iIncrementalOp = NULL;

   864             iModel->CommitL();

   865 

   866             if ( diskLow )

   867                 {

   868                 // Compact database now.

   869                 iModel->Database().Compact();

   870                 // Make a manual refresh. When we get notification about the

   871                 // commit, database is most likely busy with compact, and

   872                 // the refresh is missed.

   873                 RefreshL();

   874                 }

   875 

   876             // Everything that can be deleted, is deleted by now.

   877             // Let the user know the outcome.

   878             DisplayResultOfDeleteL( *uids, *notDeletedUids );

   879             // Refresh the view only in embedded mode because in standalone mode Refresh is called by

   880             // HandleFavouritesModelChangeL causing the view to refresh twice and lose the cursor position

   881             if ( ApiProvider().IsEmbeddedModeOn() )

   882                 {

   883                 RefreshL();

   884                 }

   885             }

   886 

   887         for ( TInt ii = 0; ii< uids->Count(); ii++ )

   888             {

   889             TInt prefUid;

   890             iModel->Database().PreferredUid( iCurrentFolder, prefUid );

   891             if ( prefUid  == uids->At( ii ) )

   892                 {

   893                 iModel->Database().SetPreferredUid( iCurrentFolder,NULL );

   894                 break;

   895                 }

   896             }

   897 

   898         CleanupStack::PopAndDestroy();  // notDeletedUids

   899         }

   900     CleanupStack::PopAndDestroy( 3 );   // folderUids, uids, items

   901     }

   902 

   903 // ---------------------------------------------------------

   904 // CBrowserFavouritesView::AddNewFolderL

   905 // ---------------------------------------------------------

   906 //

   907 TInt CBrowserFavouritesView::AddNewFolderL()

   908     {

   909     TInt uid = KFavouritesNullUid;

   910     // Make an item and fill it with default values.

   911     CFavouritesItem* folder = CFavouritesItem::NewLC();

   912     folder->SetType( CFavouritesItem::EFolder );

   913     folder->SetParentFolder( KFavouritesRootUid );

   914     iModel->SetNameToDefaultL( *folder );

   915     TInt err = iModel->MakeUniqueNameL( *folder );

   916     if ( !err )

   917         {

   918         // We have the folder with a default unique name.

   919         // Let the user rename it.

   920         if ( iModel->RenameQueryL( *folder, ETrue ))

   921             {

   922             // Rename accepted.

   923             err = iModel->AddL( *folder, /*aDbErrorNote=*/ETrue,

   924                 CBrowserFavouritesModel::EAskIfRename );

   925             if ( !err )

   926                 {

   927                 // Succesfully created. Set highlight to new folder (by setting

   928                 // preferred highlight uid - we have not see the new folder

   929                 // yet, until db notification kicks in.

   930                 uid = iPreferredHighlightUid = folder->Uid();

   931                 }

   932             }

   933         }

   934     CleanupStack::PopAndDestroy();  // folder

   935     return uid;

   936     }

   937 

   938 // ---------------------------------------------------------

   939 // CBrowserFavouritesView::MoveMarkedItemsL

   940 // ---------------------------------------------------------

   941 //

   942 void CBrowserFavouritesView::MoveMarkedItemsL()

   943     {

   944     TInt targetFolder = SelectTargetFolderL( iCurrentFolder );

   945 

   946     // If we have the target folder, do the move.

   947     if ( targetFolder != KFavouritesNullUid )

   948         {

   949         CArrayFix<TInt>* uids = iContainer->Listbox()->SelectedUidsLC();

   950         CArrayFix<TInt>* unmovableUids = NewUidListLC();

   951         CArrayFix<TInt>* conflictingNameUids = NewUidListLC();

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

   953             {

   954             __ASSERT_DEBUG( !iIncrementalOp, Util::Panic

   955                 ( Util::EIncrementalOperationAlreadyRunning ) );

   956             // Seems we have to give lower priority to the move operation,

   957             // or else the wait note does not show up.

   958             iIncrementalOp = CBrowserFavouritesIncrementalMove::NewL

   959                 (

   960                 *iModel,

   961                 *uids,

   962                 *unmovableUids,

   963                 *conflictingNameUids,

   964                 targetFolder,

   965                 CActive::EPriorityStandard - 1

   966                 );

   967             iIncrementalOp->ExecuteL();

   968             delete iIncrementalOp;

   969             iIncrementalOp = NULL;

   970             iModel->CommitL();

   971             // Everything that can be moved, is moved by now.

   972             // If some items could not be moved, see why.

   973             HandleMoveResultL

   974                 ( targetFolder, *uids, *unmovableUids, *conflictingNameUids );

   975 

   976             for ( TInt ii = 0; ii< uids->Count(); ii++ )

   977                 {

   978                 TInt prefUid;

   979                 iModel->Database().PreferredUid( iCurrentFolder, prefUid );

   980                 if ( prefUid  == uids->At( ii ) )

   981                     {

   982                     iModel->Database().SetPreferredUid( iCurrentFolder,NULL );

   983                     break;

   984                     }

   985                 }

   986 

   987             CBrowserBookmarksOrder* bmOrder  = CBrowserBookmarksOrder::NewLC();

   988             CArrayFixFlat<TInt>* orderArray = new (ELeave) CArrayFixFlat<TInt>(KGranularityHigh);

   989             CleanupStack::PushL( orderArray );

   990             if ( Model().Database().GetData( CurrentFolder() ,*bmOrder ) == KErrNone)

   991                 {

   992                 if ( bmOrder->GetBookMarksOrder().Count() )

   993                     {

   994                     orderArray->AppendL( &( bmOrder->GetBookMarksOrder()[0] ), bmOrder->GetBookMarksOrder().Count());

   995                     TInt swapTo = 0;

   996                     TInt swappedItem;

   997                     for ( TInt i=0; i<orderArray->Count();i++ )

   998                         {

   999                         TInt swapFrom=0;

  1000                         while (swapFrom<uids->Count() && ( (*uids)[swapFrom] != ( *orderArray )[i]) )

  1001                             {

  1002                             swapFrom++;

  1003                             }

  1004                         if (swapFrom<uids->Count())

  1005                             {

  1006                             if ((swapFrom != swapTo) && (swapTo < uids->Count() ) )

  1007                                 {

  1008                                 swappedItem = ( *uids )[swapFrom];

  1009                                 ( *uids )[swapFrom] = ( *uids )[swapTo];

  1010                                 ( *uids )[swapTo] = swappedItem;

  1011                                 }

  1012                             swapTo++;

  1013                             }

  1014                         }

  1015                     }

  1016                 }

  1017 

  1018             orderArray->Reset();

  1019             if ( Model().Database().GetData( targetFolder ,*bmOrder ) == KErrNone)

  1020                 {

  1021                 if ( bmOrder->GetBookMarksOrder().Count() )

  1022                     {

  1023                     orderArray->AppendL( &( bmOrder->GetBookMarksOrder()[0] ), bmOrder->GetBookMarksOrder().Count());

  1024                     if ( orderArray->Count() )

  1025                         {

  1026                         for ( TInt i = 0; i < uids->Count(); i++ )

  1027                             {

  1028                             for (TInt j = 0; j < orderArray->Count(); j++ )

  1029                                 {

  1030                                 if ( orderArray->At( j ) == uids->At( i ))

  1031                                     {

  1032                                     orderArray->Delete( j );

  1033                                     }

  1034                                 }

  1035                              Model().AddUidToLastPlaceL(uids->At( i ), orderArray, bmOrder);

  1036                              }

  1037                         bmOrder->SetBookMarksOrderL( *orderArray );

  1038                         Model().Database().SetData( targetFolder , *bmOrder );

  1039                         }

  1040                     }

  1041                 }

  1042 

  1043             CleanupStack::PopAndDestroy(  ); //orderArray

  1044             CleanupStack::PopAndDestroy(  ); //bmOrder

  1045             }

  1046         CleanupStack::PopAndDestroy( 3 );   // conflictingNameUids,

  1047                                             // unmovableUids, uids

  1048         }

  1049     }

  1050 

  1051 // ---------------------------------------------------------

  1052 // CBrowserFavouritesView::RenameCurrentItemL

  1053 // ---------------------------------------------------------

  1054 //

  1055 void CBrowserFavouritesView::RenameCurrentItemL()

  1056     {

  1057     if ( iContainer && iContainer->Listbox() )

  1058         {

  1059         const CFavouritesItem* listboxItem =

  1060             iContainer->Listbox()->CurrentItem();

  1061         if ( listboxItem )

  1062             {

  1063             CFavouritesItem* item = CFavouritesItem::NewLC();

  1064             *item = *listboxItem;

  1065             if ( iModel->RenameQueryL( *item, EFalse ) )

  1066                 {

  1067                 iModel->UpdateL

  1068                     (

  1069                     *item,

  1070                     listboxItem->Uid(),

  1071                     /*aDbErrorNote=*/ETrue,

  1072                     CBrowserFavouritesModel::EAskIfRename

  1073                     );

  1074 

  1075                 iPreferredHighlightUid = item->Uid();

  1076 

  1077                 // Show infonote "Unable to rename" if read-only item

  1078                 if ( listboxItem->IsReadOnly() )

  1079                     {

  1080                     TBrowserDialogs::InfoNoteL

  1081                                                 (

  1082                                                 R_BROWSER_INFO_NOTE,

  1083                                                 _R(TEXT_PRMPT_CANT_RENAME),

  1084                                                 listboxItem->Name()

  1085                                                 );

  1086                     }

  1087                 }

  1088             CleanupStack::PopAndDestroy();  // item

  1089             }

  1090         }

  1091     }

  1092 

  1093 // ---------------------------------------------------------

  1094 // CBrowserFavouritesView::SetRootFolderForAdaptiveBookmarks

  1095 // ---------------------------------------------------------

  1096 //

  1097 void CBrowserFavouritesView::SetRootFolderForAdaptiveBookmarks()

  1098     {

  1099     iCurrentFolder = KFavouritesRootUid;

  1100     }

  1101 

  1102 // ---------------------------------------------------------

  1103 // CBrowserFavouritesView::OpenFolderL

  1104 // ---------------------------------------------------------

  1105 //

  1106 void CBrowserFavouritesView::OpenFolderL( TInt aFolder )

  1107     {

  1108 

  1109     CFavouritesItem* folder = CFavouritesItem::NewLC();

  1110     if ( iModel->Database().Get( aFolder, *folder ) == KErrNone )

  1111         {

  1112         iContainer->Listbox()->GetDefaultData().iPreferedId = NULL;

  1113         iContainer->Listbox()->GetDefaultData().iInSeamlessFolder = EFalse;

  1114         // Set title.

  1115         if ( aFolder == KFavouritesRootUid )

  1116             {

  1117             UpdateNaviPaneL(); // remove NaviPane before setting title - SetTitleL redraws

  1118             if(ApiProvider().StartedUp())

  1119                 ApiProvider().Display().SetTitleL( RootTitleResourceId() );

  1120             else

  1121                 {

  1122                 // Set title to be page title

  1123                 CEikStatusPane* sp = STATIC_CAST( CAknAppUi*, CEikonEnv::Static()->EikAppUi() )->StatusPane();

  1124                 CAknTitlePane* title = STATIC_CAST( CAknTitlePane*, sp->ControlL( TUid::Uid( EEikStatusPaneUidTitle ) ) );

  1125                 HBufC* name = CEikonEnv::Static()->AllocReadResourceLC( R_BROWSER_OPTION_BOOKMARKS );

  1126                 title->SetTextL( *name );            

  1127                 CleanupStack::PopAndDestroy();   // name

  1128                 }

  1129             }

  1130         else

  1131             {

  1132             // Next get localized title text if the folder is a seamless link folder.

  1133             TInt resId = CBrowserFavouritesView::GetSeamlessFolderTitleResourceID(

  1134                     folder->ContextId() );